zac/libburn-sys
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
libburn-sys/src/lib.rs

4997 lines
231 KiB
Rust
Raw Blame History

/* automatically generated by rust-bindgen 0.72.1 */
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
fn extract_bit(byte: u8, index: usize) -> bool {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
Self::extract_bit(byte, index)
}
#[inline]
pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
*(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
};
Self::extract_bit(byte, index)
}
#[inline]
fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
let bit_index = if cfg!(target_endian = "big") {
7 - (index % 8)
} else {
index % 8
};
let mask = 1 << bit_index;
if val { byte | mask } else { byte & !mask }
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
*byte = Self::change_bit(*byte, index, val);
}
#[inline]
pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
debug_assert!(index / 8 < core::mem::size_of::<Storage>());
let byte_index = index / 8;
let byte = unsafe {
(core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
};
unsafe { *byte = Self::change_bit(*byte, index, val) };
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
let mut val = 0;
for i in 0..(bit_width as usize) {
if unsafe { Self::raw_get_bit(this, i + bit_offset) } {
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
#[inline]
pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < core::mem::size_of::<Storage>());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= core::mem::size_of::<Storage>());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") {
bit_width as usize - 1 - i
} else {
i
};
unsafe { Self::raw_set_bit(this, index + bit_offset, val_bit_is_set) };
}
}
}
pub const BURN_CDROM: u32 = 0;
pub const BURN_CDI: u32 = 16;
pub const BURN_CDXA: u32 = 32;
pub const BURN_POS_END: u32 = 100;
pub const BURN_MODE_BITS: u32 = 127;
pub const BURN_MODE0: u32 = 1;
pub const BURN_MODE_RAW: u32 = 2;
pub const BURN_MODE1: u32 = 4;
pub const BURN_MODE2: u32 = 8;
pub const BURN_FORM1: u32 = 16;
pub const BURN_FORM2: u32 = 32;
pub const BURN_AUDIO: u32 = 64;
pub const BURN_4CH: u32 = 128;
pub const BURN_COPY: u32 = 256;
pub const BURN_PREEMPHASIS: u32 = 512;
pub const BURN_SUBCODE_P16: u32 = 1024;
pub const BURN_SUBCODE_P96: u32 = 2048;
pub const BURN_SUBCODE_R96: u32 = 4096;
pub const BURN_SCMS: u32 = 8192;
pub const BURN_DRIVE_WHITELIST_LEN: u32 = 255;
pub const BURN_DRIVE_ADR_LEN: u32 = 1024;
pub const BURN_FORMAT_IS_UNFORMATTED: u32 = 1;
pub const BURN_FORMAT_IS_FORMATTED: u32 = 2;
pub const BURN_FORMAT_IS_UNKNOWN: u32 = 3;
pub const BURN_REASONS_LEN: u32 = 4096;
pub const BURN_CDTEXT_NUM_GENRES: u32 = 28;
pub const BURN_HEADER_VERSION_MAJOR: u32 = 1;
pub const BURN_HEADER_VERSION_MINOR: u32 = 5;
pub const BURN_HEADER_VERSION_MICRO: u32 = 6;
pub const BURN_MSGS_MESSAGE_LEN: u32 = 4096;
pub const LIBDAX_AUDIOXTR_STRLEN: u32 = 4096;
pub type __off_t = ::std::os::raw::c_long;
pub type __time_t = ::std::os::raw::c_long;
pub type __suseconds_t = ::std::os::raw::c_long;
pub type off_t = __off_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct timeval {
pub tv_sec: __time_t,
pub tv_usec: __suseconds_t,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of timeval"][::std::mem::size_of::<timeval>() - 16usize];
["Alignment of timeval"][::std::mem::align_of::<timeval>() - 8usize];
["Offset of field: timeval::tv_sec"][::std::mem::offset_of!(timeval, tv_sec) - 0usize];
["Offset of field: timeval::tv_usec"][::std::mem::offset_of!(timeval, tv_usec) - 8usize];
};
/// References a physical drive in the system
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_drive {
_unused: [u8; 0],
}
/// References a whole disc
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_disc {
_unused: [u8; 0],
}
/// References a single session on a disc
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_session {
_unused: [u8; 0],
}
/// References a single track on a disc
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_track {
_unused: [u8; 0],
}
/// References a set of write parameters
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_write_opts {
_unused: [u8; 0],
}
/// Packet writing.
/// currently unsupported, (for DVD Incremental Streaming use TAO)
pub const burn_write_types_BURN_WRITE_PACKET: burn_write_types = 0;
/// With CD: Track At Once recording
/// 2s gaps between tracks, no fonky lead-ins
///
/// With sequential DVD-R[W]: Incremental Streaming
/// With DVD+R and BD-R: Track of open size
/// With DVD-RAM, DVD+RW, BD-RE: Random Writeable (used sequentially)
/// With overwritable DVD-RW: Rigid Restricted Overwrite
pub const burn_write_types_BURN_WRITE_TAO: burn_write_types = 1;
/// With CD: Session At Once
/// Block type MUST be BURN_BLOCK_SAO
/// ts A70122: Currently not capable of mixing data and audio tracks.
///
/// With sequential DVD-R[W]: Disc-at-once, DAO
/// Single session, single track, fixed size mandatory, (-dvd-compat)
/// With other DVD or BD media: same as BURN_WRITE_TAO but may demand
/// that track size is known in advance.
pub const burn_write_types_BURN_WRITE_SAO: burn_write_types = 2;
/// With CD: Raw disc at once recording.
/// all subcodes must be provided by lib or user
/// only raw block types are supported
/// With DVD and BD media: not supported.
///
/// ts A90901: This had been disabled because its implementation
/// relied on code from cdrdao which is not understood
/// currently.
/// A burn run will abort with \"FATAL\" error message
/// if this mode is attempted.
/// @since 0.7.2
/// ts A91016: Re-implemented according to ECMA-130 Annex A and B.
/// Now understood, explained and not stemming from cdrdao.
/// @since 0.7.4
pub const burn_write_types_BURN_WRITE_RAW: burn_write_types = 3;
/// In replies this indicates that not any writing will work.
/// As parameter for inquiries it indicates that no particular write
/// mode shall is specified.
/// Do not use for setting a write mode for burning. It will not work.
pub const burn_write_types_BURN_WRITE_NONE: burn_write_types = 4;
/// Possible disc writing style/modes
pub type burn_write_types = ::std::os::raw::c_uint;
/// sync, headers, edc/ecc provided by lib/user
pub const burn_block_types_BURN_BLOCK_RAW0: burn_block_types = 1;
/// sync, headers, edc/ecc and p/q subs provided by lib/user
pub const burn_block_types_BURN_BLOCK_RAW16: burn_block_types = 2;
/// sync, headers, edc/ecc and packed p-w subs provided by lib/user
pub const burn_block_types_BURN_BLOCK_RAW96P: burn_block_types = 4;
/// sync, headers, edc/ecc and raw p-w subs provided by lib/user
pub const burn_block_types_BURN_BLOCK_RAW96R: burn_block_types = 8;
/// only 2048 bytes of user data provided by lib/user
pub const burn_block_types_BURN_BLOCK_MODE1: burn_block_types = 256;
/// 2336 bytes of user data provided by lib/user
pub const burn_block_types_BURN_BLOCK_MODE2R: burn_block_types = 512;
/// 2048 bytes of user data provided by lib/user
/// subheader provided in write parameters
/// are we ever going to support this shit? I vote no.
/// (supposed to be supported on all drives...)
pub const burn_block_types_BURN_BLOCK_MODE2_PATHETIC: burn_block_types = 1024;
/// 2048 bytes of data + 8 byte subheader provided by lib/user
/// hey, this is also dumb
pub const burn_block_types_BURN_BLOCK_MODE2_LAME: burn_block_types = 2048;
/// 2324 bytes of data provided by lib/user
/// subheader provided in write parameters
/// no sir, I don't like it.
pub const burn_block_types_BURN_BLOCK_MODE2_OBSCURE: burn_block_types = 4096;
/// 2332 bytes of data supplied by lib/user
/// 8 bytes sub header provided in write parameters
/// this is the second least suck mode2, and is mandatory for
/// all drives to support.
pub const burn_block_types_BURN_BLOCK_MODE2_OK: burn_block_types = 8192;
/// SAO block sizes are based on cue sheet, so use this.
pub const burn_block_types_BURN_BLOCK_SAO: burn_block_types = 16384;
/// Data format to send to the drive
pub type burn_block_types = ::std::os::raw::c_uint;
/// The current status is not yet known
pub const burn_disc_status_BURN_DISC_UNREADY: burn_disc_status = 0;
/// The drive holds a blank disc. It is ready for writing from scratch.
/// Unused multi-session media:
/// CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, BD-R
/// Blanked multi-session media (i.e. treated by burn_disc_erase())
/// CD-RW, DVD-RW
/// Overwritable media with or without valid data
/// DVD-RAM, DVD+RW, formatted DVD-RW, BD-RE
pub const burn_disc_status_BURN_DISC_BLANK: burn_disc_status = 1;
/// There is no disc at all in the drive
pub const burn_disc_status_BURN_DISC_EMPTY: burn_disc_status = 2;
/// There is an incomplete disc in the drive. It is ready for appending
/// another session.
/// Written but not yet closed multi-session media
/// CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, BD-R
pub const burn_disc_status_BURN_DISC_APPENDABLE: burn_disc_status = 3;
/// There is a disc with data on it in the drive. It is usable only for
/// reading.
/// Written and closed multi-session media
/// CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, BD-R
/// Read-Only media
/// CD-ROM, DVD-ROM, BD-ROM
/// Note that many DVD-ROM drives report any written media
/// as Read-Only media and not by their real media types.
pub const burn_disc_status_BURN_DISC_FULL: burn_disc_status = 4;
/// The drive was not grabbed when the status was inquired
pub const burn_disc_status_BURN_DISC_UNGRABBED: burn_disc_status = 5;
/// The media seems to be unsuitable for reading and for writing
pub const burn_disc_status_BURN_DISC_UNSUITABLE: burn_disc_status = 6;
/// Possible status of the drive in regard to the disc in it.
pub type burn_disc_status = ::std::os::raw::c_uint;
/// The source is ok
pub const burn_source_status_BURN_SOURCE_OK: burn_source_status = 0;
/// The source is at end of file
pub const burn_source_status_BURN_SOURCE_EOF: burn_source_status = 1;
/// The source is unusable
pub const burn_source_status_BURN_SOURCE_FAILED: burn_source_status = 2;
/// Possible data source return values
pub type burn_source_status = ::std::os::raw::c_uint;
/// The drive is not in an operation
pub const burn_drive_status_BURN_DRIVE_IDLE: burn_drive_status = 0;
/// The library is spawning the processes to handle a pending
/// operation (A read/write/etc is about to start but hasn't quite
/// yet)
pub const burn_drive_status_BURN_DRIVE_SPAWNING: burn_drive_status = 1;
/// The drive is reading data from a disc
pub const burn_drive_status_BURN_DRIVE_READING: burn_drive_status = 2;
/// The drive is writing data to a disc
pub const burn_drive_status_BURN_DRIVE_WRITING: burn_drive_status = 3;
/// The drive is writing Lead-In
pub const burn_drive_status_BURN_DRIVE_WRITING_LEADIN: burn_drive_status = 4;
/// The drive is writing Lead-Out
pub const burn_drive_status_BURN_DRIVE_WRITING_LEADOUT: burn_drive_status = 5;
/// The drive is erasing a disc
pub const burn_drive_status_BURN_DRIVE_ERASING: burn_drive_status = 6;
/// The drive is being grabbed
pub const burn_drive_status_BURN_DRIVE_GRABBING: burn_drive_status = 7;
/// The drive gets written zeroes before the track payload data
pub const burn_drive_status_BURN_DRIVE_WRITING_PREGAP: burn_drive_status = 8;
/// The drive is told to close a track (TAO only)
pub const burn_drive_status_BURN_DRIVE_CLOSING_TRACK: burn_drive_status = 9;
/// The drive is told to close a session (TAO only)
pub const burn_drive_status_BURN_DRIVE_CLOSING_SESSION: burn_drive_status = 10;
/// The drive is formatting media
pub const burn_drive_status_BURN_DRIVE_FORMATTING: burn_drive_status = 11;
/// The drive is busy in synchronous read (if you see this then it
/// has been interrupted)
pub const burn_drive_status_BURN_DRIVE_READING_SYNC: burn_drive_status = 12;
/// The drive is busy in synchronous write (if you see this then it
/// has been interrupted)
pub const burn_drive_status_BURN_DRIVE_WRITING_SYNC: burn_drive_status = 13;
/// Possible busy states for a drive
pub type burn_drive_status = ::std::os::raw::c_uint;
/// Information about a track on a disc - this is from the q sub channel of the
/// lead-in area of a disc. The documentation here is very terse.
/// See a document such as mmc3 for proper information.
///
/// CAUTION : This structure is prone to future extension !
///
/// Do not restrict your application to unsigned char with any counter like
/// \"session\", \"point\", \"pmin\", ...
/// Do not rely on the current size of a burn_toc_entry.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_toc_entry {
/// Session the track is in
pub session: ::std::os::raw::c_uchar,
/// Type of data. for this struct to be valid, it must be 1
pub adr: ::std::os::raw::c_uchar,
/// Type of data in the track
pub control: ::std::os::raw::c_uchar,
/// Zero. Always. Really.
pub tno: ::std::os::raw::c_uchar,
/// Track number or special information
pub point: ::std::os::raw::c_uchar,
pub min: ::std::os::raw::c_uchar,
pub sec: ::std::os::raw::c_uchar,
pub frame: ::std::os::raw::c_uchar,
pub zero: ::std::os::raw::c_uchar,
/// Track start time minutes for normal tracks
pub pmin: ::std::os::raw::c_uchar,
/// Track start time seconds for normal tracks
pub psec: ::std::os::raw::c_uchar,
/// Track start time frames for normal tracks
pub pframe: ::std::os::raw::c_uchar,
pub extensions_valid: ::std::os::raw::c_uchar,
pub session_msb: ::std::os::raw::c_uchar,
pub point_msb: ::std::os::raw::c_uchar,
pub start_lba: ::std::os::raw::c_int,
pub track_blocks: ::std::os::raw::c_int,
pub last_recorded_address: ::std::os::raw::c_int,
pub track_status_bits: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_toc_entry"][::std::mem::size_of::<burn_toc_entry>() - 32usize];
["Alignment of burn_toc_entry"][::std::mem::align_of::<burn_toc_entry>() - 4usize];
["Offset of field: burn_toc_entry::session"]
[::std::mem::offset_of!(burn_toc_entry, session) - 0usize];
["Offset of field: burn_toc_entry::adr"][::std::mem::offset_of!(burn_toc_entry, adr) - 1usize];
["Offset of field: burn_toc_entry::control"]
[::std::mem::offset_of!(burn_toc_entry, control) - 2usize];
["Offset of field: burn_toc_entry::tno"][::std::mem::offset_of!(burn_toc_entry, tno) - 3usize];
["Offset of field: burn_toc_entry::point"]
[::std::mem::offset_of!(burn_toc_entry, point) - 4usize];
["Offset of field: burn_toc_entry::min"][::std::mem::offset_of!(burn_toc_entry, min) - 5usize];
["Offset of field: burn_toc_entry::sec"][::std::mem::offset_of!(burn_toc_entry, sec) - 6usize];
["Offset of field: burn_toc_entry::frame"]
[::std::mem::offset_of!(burn_toc_entry, frame) - 7usize];
["Offset of field: burn_toc_entry::zero"]
[::std::mem::offset_of!(burn_toc_entry, zero) - 8usize];
["Offset of field: burn_toc_entry::pmin"]
[::std::mem::offset_of!(burn_toc_entry, pmin) - 9usize];
["Offset of field: burn_toc_entry::psec"]
[::std::mem::offset_of!(burn_toc_entry, psec) - 10usize];
["Offset of field: burn_toc_entry::pframe"]
[::std::mem::offset_of!(burn_toc_entry, pframe) - 11usize];
["Offset of field: burn_toc_entry::extensions_valid"]
[::std::mem::offset_of!(burn_toc_entry, extensions_valid) - 12usize];
["Offset of field: burn_toc_entry::session_msb"]
[::std::mem::offset_of!(burn_toc_entry, session_msb) - 13usize];
["Offset of field: burn_toc_entry::point_msb"]
[::std::mem::offset_of!(burn_toc_entry, point_msb) - 14usize];
["Offset of field: burn_toc_entry::start_lba"]
[::std::mem::offset_of!(burn_toc_entry, start_lba) - 16usize];
["Offset of field: burn_toc_entry::track_blocks"]
[::std::mem::offset_of!(burn_toc_entry, track_blocks) - 20usize];
["Offset of field: burn_toc_entry::last_recorded_address"]
[::std::mem::offset_of!(burn_toc_entry, last_recorded_address) - 24usize];
["Offset of field: burn_toc_entry::track_status_bits"]
[::std::mem::offset_of!(burn_toc_entry, track_status_bits) - 28usize];
};
/// Data source interface for tracks.
/// This allows you to use arbitrary program code as provider of track input
/// data.
///
/// Objects compliant to this interface are either provided by the application
/// or by API calls of libburn: burn_fd_source_new() , burn_file_source_new(),
/// and burn_fifo_source_new().
///
/// The API calls may use any file object as data source. Consider to feed
/// an eventual custom data stream asynchronously into a pipe(2) and to let
/// libburn handle the rest.
/// In this case the following rule applies:
/// Call burn_source_free() exactly once for every source obtained from
/// libburn API. You MUST NOT otherwise use or manipulate its components.
///
/// In general, burn_source objects can be freed as soon as they are attached
/// to track objects. The track objects will keep them alive and dispose them
/// when they are no longer needed. With a fifo burn_source it makes sense to
/// keep the own reference for inquiring its state while burning is in
/// progress.
///
/// ---
///
/// The following description of burn_source applies only to application
/// implemented burn_source objects. You need not to know it for API provided
/// ones.
///
/// If you really implement an own passive data producer by this interface,
/// then beware: it can do anything and it can spoil everything.
///
/// In this case the functions (*read), (*get_size), (*set_size), (*free_data)
/// MUST be implemented by the application and attached to the object at
/// creation time.
/// Function (*read_sub) is allowed to be NULL or it MUST be implemented and
/// attached.
///
/// burn_source.refcount MUST be handled properly: If not exactly as many
/// references are freed as have been obtained, then either memory leaks or
/// corrupted memory are the consequence.
/// All objects which are referred to by *data must be kept existent until
/// (*free_data) is called via burn_source_free() by the last referer.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_source {
/// Reference count for the data source. MUST be 1 when a new source
/// is created and thus the first reference is handed out. Increment
/// it to take more references for yourself. Use burn_source_free()
/// to destroy your references to it.
pub refcount: ::std::os::raw::c_int,
/// Read data from the source. Semantics like with read(2), but MUST
/// either deliver the full buffer as defined by size or MUST deliver
/// EOF (return 0) or failure (return -1) at this call or at the
/// next following call. I.e. the only incomplete buffer may be the
/// last one from that source.
/// libburn will read a single sector by each call to (*read).
/// The size of a sector depends on BURN_MODE_*. The known range is
/// 2048 to 2352.
///
/// If this call is reading from a pipe then it will learn
/// about the end of data only when that pipe gets closed on the
/// feeder side. So if the track size is not fixed or if the pipe
/// delivers less than the predicted amount or if the size is not
/// block aligned, then burning will halt until the input process
/// closes the pipe.
///
/// IMPORTANT:
/// If this function pointer is NULL, then the struct burn_source is of
/// version >= 1 and the job of .(*read)() is done by .(*read_xt)().
/// See below, member .version.
pub read: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut burn_source,
buffer: *mut ::std::os::raw::c_uchar,
size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
/// Read subchannel data from the source (NULL if lib generated)
/// WARNING: This is an obscure feature with CD raw write modes.
/// Unless you checked the libburn code for correctness in that aspect
/// you should not rely on raw writing with own subchannels.
/// ADVICE: Set this pointer to NULL.
pub read_sub: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut burn_source,
buffer: *mut ::std::os::raw::c_uchar,
size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
/// Get the size of the source's data. Return 0 means unpredictable
/// size. If application provided (*get_size) might return 0, then
/// the application MUST provide a fully functional (*set_size).
pub get_size: ::std::option::Option<unsafe extern "C" fn(arg1: *mut burn_source) -> off_t>,
/// Program the reply of (*get_size) to a fixed value. It is advised
/// to implement this by a attribute off_t fixed_size; in *data .
/// The read() function does not have to take into respect this fake
/// setting. It is rather a note of libburn to itself. Eventually
/// necessary truncation or padding is done in libburn. Truncation
/// is usually considered a misburn. Padding is considered ok.
///
/// libburn is supposed to work even if (*get_size) ignores the
/// setting by (*set_size). But your application will not be able to
/// enforce fixed track sizes by burn_track_set_size() and possibly
/// even padding might be left out.
pub set_size: ::std::option::Option<
unsafe extern "C" fn(source: *mut burn_source, size: off_t) -> ::std::os::raw::c_int,
>,
/// Clean up the source specific data. This function will be called
/// once by burn_source_free() when the last referer disposes the
/// source.
pub free_data: ::std::option::Option<unsafe extern "C" fn(arg1: *mut burn_source)>,
/// Next source, for when a source runs dry and padding is disabled
/// WARNING: This is an obscure feature. Set to NULL at creation and
/// from then on leave untouched and uninterpreted.
pub next: *mut burn_source,
/// Source specific data. Here the various source classes express their
/// specific properties and the instance objects store their individual
/// management data.
/// E.g. data could point to a struct like this:
/// struct app_burn_source
/// {
/// struct my_app *app_handle;
/// ... other individual source parameters ...
/// off_t fixed_size;
/// };
///
/// Function (*free_data) has to be prepared to clean up and free
/// the struct.
pub data: *mut ::std::os::raw::c_void,
/// Valid only if above member .(*read)() is NULL. This indicates a
/// version of struct burn_source younger than 0.
/// From then on, member .version tells which further members exist
/// in the memory layout of struct burn_source. libburn will only touch
/// those announced extensions.
///
/// Versions:
/// 0 has .(*read)() != NULL, not even .version is present.
/// 1 has .version, .(*read_xt)(), .(*cancel)()
pub version: ::std::os::raw::c_int,
/// This substitutes for (*read)() in versions above 0.
pub read_xt: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut burn_source,
buffer: *mut ::std::os::raw::c_uchar,
size: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
/// Informs the burn_source that the consumer of data prematurely
/// ended reading. This call may or may not be issued by libburn
/// before (*free_data)() is called.
pub cancel: ::std::option::Option<
unsafe extern "C" fn(source: *mut burn_source) -> ::std::os::raw::c_int,
>,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_source"][::std::mem::size_of::<burn_source>() - 88usize];
["Alignment of burn_source"][::std::mem::align_of::<burn_source>() - 8usize];
["Offset of field: burn_source::refcount"]
[::std::mem::offset_of!(burn_source, refcount) - 0usize];
["Offset of field: burn_source::read"][::std::mem::offset_of!(burn_source, read) - 8usize];
["Offset of field: burn_source::read_sub"]
[::std::mem::offset_of!(burn_source, read_sub) - 16usize];
["Offset of field: burn_source::get_size"]
[::std::mem::offset_of!(burn_source, get_size) - 24usize];
["Offset of field: burn_source::set_size"]
[::std::mem::offset_of!(burn_source, set_size) - 32usize];
["Offset of field: burn_source::free_data"]
[::std::mem::offset_of!(burn_source, free_data) - 40usize];
["Offset of field: burn_source::next"][::std::mem::offset_of!(burn_source, next) - 48usize];
["Offset of field: burn_source::data"][::std::mem::offset_of!(burn_source, data) - 56usize];
["Offset of field: burn_source::version"]
[::std::mem::offset_of!(burn_source, version) - 64usize];
["Offset of field: burn_source::read_xt"]
[::std::mem::offset_of!(burn_source, read_xt) - 72usize];
["Offset of field: burn_source::cancel"][::std::mem::offset_of!(burn_source, cancel) - 80usize];
};
/// Information on a drive in the system
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_drive_info {
/// Name of the vendor of the drive
pub vendor: [::std::os::raw::c_char; 9usize],
/// Name of the drive
pub product: [::std::os::raw::c_char; 17usize],
/// Revision of the drive
pub revision: [::std::os::raw::c_char; 5usize],
/// Invalid: Was: \"Location of the drive in the filesystem.\" */
/// /** This string has no meaning any more. Once it stored the drive
/// device file address. Now always use function burn_drive_d_get_adr()
/// to inquire a device file address. ^^^^^ ALWAYS ^^^^^^^
pub location: [::std::os::raw::c_char; 17usize],
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
/// DEPRECATED: The size of the drive's buffer (in kilobytes)
pub buffer_size: ::std::os::raw::c_int,
/// The supported block types in tao mode.
/// They should be tested with the desired block type.
/// See also burn_block_types.
pub tao_block_types: ::std::os::raw::c_int,
/// The supported block types in sao mode.
/// They should be tested with the desired block type.
/// See also burn_block_types.
pub sao_block_types: ::std::os::raw::c_int,
/// The supported block types in raw mode.
/// They should be tested with the desired block type.
/// See also burn_block_types.
pub raw_block_types: ::std::os::raw::c_int,
/// The supported block types in packet mode.
/// They should be tested with the desired block type.
/// See also burn_block_types.
pub packet_block_types: ::std::os::raw::c_int,
/// The value by which this drive can be indexed when using functions
/// in the library. This is the value to pass to all libbburn functions
/// that operate on a drive.
pub drive: *mut burn_drive,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_drive_info"][::std::mem::size_of::<burn_drive_info>() - 80usize];
["Alignment of burn_drive_info"][::std::mem::align_of::<burn_drive_info>() - 8usize];
["Offset of field: burn_drive_info::vendor"]
[::std::mem::offset_of!(burn_drive_info, vendor) - 0usize];
["Offset of field: burn_drive_info::product"]
[::std::mem::offset_of!(burn_drive_info, product) - 9usize];
["Offset of field: burn_drive_info::revision"]
[::std::mem::offset_of!(burn_drive_info, revision) - 26usize];
["Offset of field: burn_drive_info::location"]
[::std::mem::offset_of!(burn_drive_info, location) - 31usize];
["Offset of field: burn_drive_info::buffer_size"]
[::std::mem::offset_of!(burn_drive_info, buffer_size) - 52usize];
["Offset of field: burn_drive_info::tao_block_types"]
[::std::mem::offset_of!(burn_drive_info, tao_block_types) - 56usize];
["Offset of field: burn_drive_info::sao_block_types"]
[::std::mem::offset_of!(burn_drive_info, sao_block_types) - 60usize];
["Offset of field: burn_drive_info::raw_block_types"]
[::std::mem::offset_of!(burn_drive_info, raw_block_types) - 64usize];
["Offset of field: burn_drive_info::packet_block_types"]
[::std::mem::offset_of!(burn_drive_info, packet_block_types) - 68usize];
["Offset of field: burn_drive_info::drive"]
[::std::mem::offset_of!(burn_drive_info, drive) - 72usize];
};
impl burn_drive_info {
#[inline]
pub fn read_dvdram(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
}
#[inline]
pub fn set_read_dvdram(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn read_dvdram_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
0usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_read_dvdram_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
0usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn read_dvdr(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u32) }
}
#[inline]
pub fn set_read_dvdr(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn read_dvdr_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
1usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_read_dvdr_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
1usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn read_dvdrom(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u32) }
}
#[inline]
pub fn set_read_dvdrom(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn read_dvdrom_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
2usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_read_dvdrom_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
2usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn read_cdr(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u32) }
}
#[inline]
pub fn set_read_cdr(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn read_cdr_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
3usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_read_cdr_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
3usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn read_cdrw(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
}
#[inline]
pub fn set_read_cdrw(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn read_cdrw_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
4usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_read_cdrw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
4usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn write_dvdram(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
}
#[inline]
pub fn set_write_dvdram(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn write_dvdram_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
5usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_write_dvdram_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
5usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn write_dvdr(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u32) }
}
#[inline]
pub fn set_write_dvdr(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn write_dvdr_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
6usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_write_dvdr_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
6usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn write_cdr(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u32) }
}
#[inline]
pub fn set_write_cdr(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn write_cdr_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
7usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_write_cdr_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
7usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn write_cdrw(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u32) }
}
#[inline]
pub fn set_write_cdrw(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn write_cdrw_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
8usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_write_cdrw_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
8usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn write_simulate(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u32) }
}
#[inline]
pub fn set_write_simulate(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn write_simulate_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
9usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_write_simulate_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
9usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn c2_errors(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u32) }
}
#[inline]
pub fn set_c2_errors(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub unsafe fn c2_errors_raw(this: *const Self) -> ::std::os::raw::c_uint {
unsafe {
::std::mem::transmute(<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_get(
::std::ptr::addr_of!((*this)._bitfield_1),
10usize,
1u8,
) as u32)
}
}
#[inline]
pub unsafe fn set_c2_errors_raw(this: *mut Self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
<__BindgenBitfieldUnit<[u8; 2usize]>>::raw_set(
::std::ptr::addr_of_mut!((*this)._bitfield_1),
10usize,
1u8,
val as u64,
)
}
}
#[inline]
pub fn new_bitfield_1(
read_dvdram: ::std::os::raw::c_uint,
read_dvdr: ::std::os::raw::c_uint,
read_dvdrom: ::std::os::raw::c_uint,
read_cdr: ::std::os::raw::c_uint,
read_cdrw: ::std::os::raw::c_uint,
write_dvdram: ::std::os::raw::c_uint,
write_dvdr: ::std::os::raw::c_uint,
write_cdr: ::std::os::raw::c_uint,
write_cdrw: ::std::os::raw::c_uint,
write_simulate: ::std::os::raw::c_uint,
c2_errors: ::std::os::raw::c_uint,
) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let read_dvdram: u32 = unsafe { ::std::mem::transmute(read_dvdram) };
read_dvdram as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let read_dvdr: u32 = unsafe { ::std::mem::transmute(read_dvdr) };
read_dvdr as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let read_dvdrom: u32 = unsafe { ::std::mem::transmute(read_dvdrom) };
read_dvdrom as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let read_cdr: u32 = unsafe { ::std::mem::transmute(read_cdr) };
read_cdr as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let read_cdrw: u32 = unsafe { ::std::mem::transmute(read_cdrw) };
read_cdrw as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let write_dvdram: u32 = unsafe { ::std::mem::transmute(write_dvdram) };
write_dvdram as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let write_dvdr: u32 = unsafe { ::std::mem::transmute(write_dvdr) };
write_dvdr as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let write_cdr: u32 = unsafe { ::std::mem::transmute(write_cdr) };
write_cdr as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let write_cdrw: u32 = unsafe { ::std::mem::transmute(write_cdrw) };
write_cdrw as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let write_simulate: u32 = unsafe { ::std::mem::transmute(write_simulate) };
write_simulate as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let c2_errors: u32 = unsafe { ::std::mem::transmute(c2_errors) };
c2_errors as u64
});
__bindgen_bitfield_unit
}
}
/// Operation progress report. All values are 0 based indices.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_progress {
/// The total number of sessions
pub sessions: ::std::os::raw::c_int,
/// Current session.
pub session: ::std::os::raw::c_int,
/// The total number of tracks
pub tracks: ::std::os::raw::c_int,
/// Current track.
pub track: ::std::os::raw::c_int,
/// The total number of indices
pub indices: ::std::os::raw::c_int,
/// Current index.
pub index: ::std::os::raw::c_int,
/// The starting logical block address
pub start_sector: ::std::os::raw::c_int,
/// On write: The number of sectors.
/// On blank: 0x10000 as upper limit for relative progress steps
pub sectors: ::std::os::raw::c_int,
/// On write: The current sector being processed.
/// On blank: Relative progress steps 0 to 0x10000
pub sector: ::std::os::raw::c_int,
/// The capacity of the drive buffer
pub buffer_capacity: ::std::os::raw::c_uint,
/// The free space in the drive buffer (might be slightly outdated)
pub buffer_available: ::std::os::raw::c_uint,
/// The number of bytes sent to the drive buffer
pub buffered_bytes: off_t,
/// The minimum number of bytes stored in buffer during write.
/// (Caution: Before surely one buffer size of bytes was processed,
/// this value is 0xffffffff.)
pub buffer_min_fill: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_progress"][::std::mem::size_of::<burn_progress>() - 64usize];
["Alignment of burn_progress"][::std::mem::align_of::<burn_progress>() - 8usize];
["Offset of field: burn_progress::sessions"]
[::std::mem::offset_of!(burn_progress, sessions) - 0usize];
["Offset of field: burn_progress::session"]
[::std::mem::offset_of!(burn_progress, session) - 4usize];
["Offset of field: burn_progress::tracks"]
[::std::mem::offset_of!(burn_progress, tracks) - 8usize];
["Offset of field: burn_progress::track"]
[::std::mem::offset_of!(burn_progress, track) - 12usize];
["Offset of field: burn_progress::indices"]
[::std::mem::offset_of!(burn_progress, indices) - 16usize];
["Offset of field: burn_progress::index"]
[::std::mem::offset_of!(burn_progress, index) - 20usize];
["Offset of field: burn_progress::start_sector"]
[::std::mem::offset_of!(burn_progress, start_sector) - 24usize];
["Offset of field: burn_progress::sectors"]
[::std::mem::offset_of!(burn_progress, sectors) - 28usize];
["Offset of field: burn_progress::sector"]
[::std::mem::offset_of!(burn_progress, sector) - 32usize];
["Offset of field: burn_progress::buffer_capacity"]
[::std::mem::offset_of!(burn_progress, buffer_capacity) - 36usize];
["Offset of field: burn_progress::buffer_available"]
[::std::mem::offset_of!(burn_progress, buffer_available) - 40usize];
["Offset of field: burn_progress::buffered_bytes"]
[::std::mem::offset_of!(burn_progress, buffered_bytes) - 48usize];
["Offset of field: burn_progress::buffer_min_fill"]
[::std::mem::offset_of!(burn_progress, buffer_min_fill) - 56usize];
};
/// Description of a speed capability as reported by the drive in conjunction
/// with eventually loaded media. There can be more than one such object per
/// drive. So they are chained via .next and .prev , where NULL marks the end
/// of the chain. This list is set up by burn_drive_scan() and gets updated
/// by burn_drive_grab().
/// A copy may be obtained by burn_drive_get_speedlist() and disposed by
/// burn_drive_free_speedlist().
/// For technical background info see SCSI specs MMC and SPC:
/// mode page 2Ah (from SPC 5Ah MODE SENSE) , mmc3r10g.pdf , 6.3.11 Table 364
/// ACh GET PERFORMANCE, Type 03h , mmc5r03c.pdf , 6.8.5.3 Table 312
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_speed_descriptor {
/// Where this info comes from :
/// 0 = misc
/// 1 = mode page 2Ah
/// 2 = ACh GET PERFORMANCE Type 03h
/// 3 = ACh GET PERFORMANCE Type 00h Data Type 10h (read speed)
pub source: ::std::os::raw::c_int,
/// The media type that was current at the time of report
/// -2 = state unknown, -1 = no media was loaded , else see
/// burn_disc_get_profile()
pub profile_loaded: ::std::os::raw::c_int,
pub profile_name: [::std::os::raw::c_char; 80usize],
/// The attributed capacity of appropriate media in logical block units
/// i.e. 2352 raw bytes or 2048 data bytes. -1 = capacity unknown.
pub end_lba: ::std::os::raw::c_int,
/// Speed is given in 1000 bytes/s , 0 = invalid. The numbers
/// are supposed to be usable with burn_drive_set_speed()
pub write_speed: ::std::os::raw::c_int,
pub read_speed: ::std::os::raw::c_int,
/// Expert info from ACh GET PERFORMANCE and/or mode page 2Ah.
/// Expect values other than 0 or 1 to get a meaning in future.
pub wrc: ::std::os::raw::c_int,
pub exact: ::std::os::raw::c_int,
pub mrw: ::std::os::raw::c_int,
/// List chaining. Use .next until NULL to iterate over the list
pub prev: *mut burn_speed_descriptor,
pub next: *mut burn_speed_descriptor,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_speed_descriptor"][::std::mem::size_of::<burn_speed_descriptor>() - 128usize];
["Alignment of burn_speed_descriptor"]
[::std::mem::align_of::<burn_speed_descriptor>() - 8usize];
["Offset of field: burn_speed_descriptor::source"]
[::std::mem::offset_of!(burn_speed_descriptor, source) - 0usize];
["Offset of field: burn_speed_descriptor::profile_loaded"]
[::std::mem::offset_of!(burn_speed_descriptor, profile_loaded) - 4usize];
["Offset of field: burn_speed_descriptor::profile_name"]
[::std::mem::offset_of!(burn_speed_descriptor, profile_name) - 8usize];
["Offset of field: burn_speed_descriptor::end_lba"]
[::std::mem::offset_of!(burn_speed_descriptor, end_lba) - 88usize];
["Offset of field: burn_speed_descriptor::write_speed"]
[::std::mem::offset_of!(burn_speed_descriptor, write_speed) - 92usize];
["Offset of field: burn_speed_descriptor::read_speed"]
[::std::mem::offset_of!(burn_speed_descriptor, read_speed) - 96usize];
["Offset of field: burn_speed_descriptor::wrc"]
[::std::mem::offset_of!(burn_speed_descriptor, wrc) - 100usize];
["Offset of field: burn_speed_descriptor::exact"]
[::std::mem::offset_of!(burn_speed_descriptor, exact) - 104usize];
["Offset of field: burn_speed_descriptor::mrw"]
[::std::mem::offset_of!(burn_speed_descriptor, mrw) - 108usize];
["Offset of field: burn_speed_descriptor::prev"]
[::std::mem::offset_of!(burn_speed_descriptor, prev) - 112usize];
["Offset of field: burn_speed_descriptor::next"]
[::std::mem::offset_of!(burn_speed_descriptor, next) - 120usize];
};
unsafe extern "C" {
/// Initialize the library.
/// This must be called before using any other functions in the library. It
/// may be called more than once with no effect.
/// It is possible to 'restart' the library by shutting it down and
/// re-initializing it. Once this was necessary if you follow the older and
/// more general way of accessing a drive via burn_drive_scan() and
/// burn_drive_grab(). See burn_drive_scan_and_grab() with its strong
/// urges and its explanations.
/// @return Nonzero if the library was able to initialize; zero if
/// initialization failed.
pub fn burn_initialize() -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Shutdown the library.
/// This should be called before exiting your application. Make sure that all
/// drives you have grabbed are released <i>before</i> calling this.
pub fn burn_finish();
}
unsafe extern "C" {
/// Abort any running drive operation and eventually call burn_finish().
///
/// You MUST shut down the busy drives if an aborting event occurs during a
/// burn run. For that you may call this function either from your own signal
/// handling code or indirectly by activating the built-in signal handling:
/// burn_set_signal_handling(\"my_app_name : \", NULL, 0);
/// Else you may eventually call burn_drive_cancel() on the active drives and
/// wait for them to assume state BURN_DRIVE_IDLE.
/// @param patience Maximum number of seconds to wait for drives to
/// finish.
/// @since 0.7.8 :
/// If this is -1, then only the cancel operations will
/// be performed and no burn_finish() will happen.
/// @param pacifier_func If not NULL: a function to produce appeasing messages.
/// See burn_abort_pacifier() for an example.
/// @param handle Opaque handle to be used with pacifier_func
/// @return 1 ok, all went well
/// 0 had to leave a drive in unclean state
/// <0 severe error, do no use libburn again
/// @since 0.2.6
pub fn burn_abort(
patience: ::std::os::raw::c_int,
pacifier_func: ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
patience: ::std::os::raw::c_int,
elapsed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>,
handle: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// A pacifier function suitable for burn_abort.
/// @param handle If not NULL, a pointer to a text suitable for printf(\"%s\")
/// @param patience Maximum number of seconds to wait
/// @param elapsed Elapsed number of seconds
pub fn burn_abort_pacifier(
handle: *mut ::std::os::raw::c_void,
patience: ::std::os::raw::c_int,
elapsed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// ts A61006 : This is for development only. Not suitable for applications.
/// Set the verbosity level of the library. The default value is 0, which means
/// that nothing is output on stderr. The more you increase this, the more
/// debug output should be displayed on stderr for you.
/// @param level The verbosity level desired. 0 for nothing, higher positive
/// values for more information output.
pub fn burn_set_verbosity(level: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Enable or disable logging of SCSI commands.
/// This call can be made at any time - even before burn_initialize().
/// It is in effect for all active drives and currently not very thread
/// safe for multiple drives.
/// @param flag Bitfield for control purposes. The default is 0.
/// bit0= log to file /tmp/libburn_sg_command_log
/// bit1= log to stderr
/// bit2= flush output after each line
/// @since 0.7.4
pub fn burn_set_scsi_logging(flag: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Set parameters for behavior on opening device files. To be called early
/// after burn_initialize() and before any bus scan. But not mandatory at all.
/// Parameter value 1 enables a feature, 0 disables.
/// Default is (1,0,0). Have a good reason before you change it.
/// @param exclusive
/// 0 = no attempt to make drive access exclusive.
/// 1 = Try to open only devices which are not marked as busy
/// and try to mark them busy if opened successfully. (O_EXCL
/// on GNU/Linux , flock(LOCK_EX) on FreeBSD.)
/// 2 = in case of a SCSI device, also try to open exclusively
/// the matching /dev/sr, /dev/scd and /dev/st .
/// One may select a device SCSI file family by adding
/// 0 = default family
/// 4 = /dev/sr%d
/// 8 = /dev/scd%d
/// 16 = /dev/sg%d
/// Do not use other values !
/// Add 32 to demand on GNU/Linux an exclusive lock by
/// fcntl(,F_SETLK,) after open() has succeeded.
/// @param blocking Try to wait for drives which do not open immediately but
/// also do not return an error as well. (O_NONBLOCK)
/// This might stall indefinitely with /dev/hdX hard disks.
/// @param abort_on_busy Unconditionally abort process when a non blocking
/// exclusive opening attempt indicates a busy drive.
/// Use this only after thorough tests with your app.
/// @since 0.2.2
pub fn burn_preset_device_open(
exclusive: ::std::os::raw::c_int,
blocking: ::std::os::raw::c_int,
abort_on_busy: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Allows the use of media types which are implemented in libburn but not yet
/// tested. The list of those untested profiles is subject to change.
/// - Currently no media types are under test reservation -
/// If you really test such media, then please report the outcome on
/// libburn-hackers@pykix.org
/// If ever then this call should be done soon after burn_initialize() before
/// any drive scanning.
/// @param yes 1=allow all implemented profiles, 0=only tested media (default)
/// @since 0.3.4
pub fn burn_allow_untested_profiles(yes: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Acquire a drive with known device file address.
///
/// This is the sysadmin friendly way to open one drive and to leave all
/// others untouched. It bundles the following API calls to form a
/// non-obtrusive way to use libburn:
/// burn_drive_add_whitelist() , burn_drive_scan() , burn_drive_grab()
/// You are *strongly urged* to use this call whenever you know the drive
/// address in advance.
///
/// If not, then you have to use directly above calls. In that case, you are
/// strongly urged* to drop any unintended drive which will be exclusively
/// occupied and not closed by burn_drive_scan().
/// This can be done by shutting down the library including a call to
/// burn_finish(). You may later start a new libburn session and should then
/// use the function described here with an address obtained after
/// burn_drive_scan() via burn_drive_d_get_adr(drive_infos[driveno].drive,adr).
/// Another way is to drop the unwanted drives by burn_drive_info_forget().
///
/// Operating on multiple drives:
///
/// Different than with burn_drive_scan() it is allowed to call
/// burn_drive_scan_and_grab() without giving up any other scanned drives. So
/// this call can be used to get a collection of more than one acquired drives.
/// The attempt to acquire the same drive twice will fail, though.
///
/// Pseudo-drives:
///
/// burn_drive_scan_and_grab() is able to acquire virtual drives which will
/// accept options much like a MMC burner drive. Many of those options will not
/// cause any effect, though. The address of a pseudo-drive begins with
/// prefix \"stdio:\" followed by a path.
/// Examples: \"stdio:/tmp/pseudo_drive\" , \"stdio:/dev/null\" , \"stdio:-\"
///
/// If the path is empty, the result is a null-drive = drive role 0.
/// It pretends to have loaded no media and supports no reading or writing.
///
/// If the path leads to an existing regular file, or to a not yet existing
/// file, or to an existing block device, then the result is a random access
/// stdio-drive capable of reading and writing = drive role 2.
///
/// If the path leads to an existing file of any type other than directory,
/// then the result is a sequential write-only stdio-drive = drive role 3.
///
/// The special address form \"stdio:/dev/fd/{number}\" is interpreted literally
/// as reference to open file descriptor {number}. This address form coincides
/// with real files on some systems, but it is in fact hardcoded in libburn.
/// Special address \"stdio:-\" means stdout = \"stdio:/dev/fd/1\".
/// The role of such a drive is determined by the file type obtained via
/// fstat({number}).
///
/// Roles 2 and 3 perform all their eventual data transfer activities on a file
/// via standard i/o functions open(2), lseek(2), read(2), write(2), close(2).
/// The media profile is reported as 0xffff. Write space information from those
/// media is not necessarily realistic.
///
/// The capabilities of role 2 resemble DVD-RAM but it can simulate writing.
/// If the path does not exist in the filesystem yet, it is attempted to create
/// it as a regular file as soon as write operations are started.
///
/// The capabilities of role 3 resemble a blank DVD-R. Nevertheless each
/// burn_disc_write() run may only write a single track.
///
/// One may distinguish pseudo-drives from MMC drives by call
/// burn_drive_get_drive_role().
///
/// @param drive_infos On success returns a one element array with the drive
/// (cdrom/burner). Thus use with driveno 0 only. On failure
/// the array has no valid elements at all.
/// The returned array should be freed via burn_drive_info_free()
/// when it is no longer needed.
/// This is a result from call burn_drive_scan(). See there.
/// Use with driveno 0 only.
/// @param adr The device file address of the desired drive. Either once
/// obtained by burn_drive_d_get_adr() or composed skillfully by
/// application or its user. E.g. \"/dev/sr0\".
/// Consider to preprocess it by burn_drive_convert_fs_adr().
/// @param load Nonzero to make the drive attempt to load a disc (close its
/// tray door, etc).
/// @return 1 = success , 0 = drive not found , -1 = other error
/// @since 0.2.2
pub fn burn_drive_scan_and_grab(
drive_infos: *mut *mut burn_drive_info,
adr: *mut ::std::os::raw::c_char,
load: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Add a device to the list of permissible drives. As soon as some entry is in
/// the whitelist all non-listed drives are banned from scanning.
/// @return 1 success, <=0 failure
/// @since 0.2.2
pub fn burn_drive_add_whitelist(
device_address: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove all drives from whitelist. This enables all possible drives.
pub fn burn_drive_clear_whitelist();
}
unsafe extern "C" {
/// Scan for drives. This function MUST be called until it returns nonzero.
/// In case of re-scanning:
/// All pointers to struct burn_drive and all struct burn_drive_info arrays
/// are invalidated by using this function. Do NOT store drive pointers across
/// calls to this function !
/// To avoid invalid pointers one MUST free all burn_drive_info arrays
/// by burn_drive_info_free() before calling burn_drive_scan() a second time.
/// If there are drives left, then burn_drive_scan() will refuse to work.
///
/// After this call all drives depicted by the returned array are subject
/// to eventual (O_EXCL) locking. See burn_preset_device_open(). This state
/// ends either with burn_drive_info_forget() or with burn_drive_release().
/// It is unfriendly to other processes on the system to hold drives locked
/// which one does not definitely plan to use soon.
/// @param drive_infos Returns an array of drive info items (cdroms/burners).
/// The returned array must be freed by burn_drive_info_free()
/// before burn_finish(), and also before calling this function
/// burn_drive_scan() again.
/// @param n_drives Returns the number of drive items in drive_infos.
/// @return 0 while scanning is not complete
/// >0 when it is finished successfully,
/// <0 when finished but failed.
pub fn burn_drive_scan(
drive_infos: *mut *mut burn_drive_info,
n_drives: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Release memory about a single drive and any exclusive lock on it.
/// Become unable to inquire or grab it. Expect FATAL consequences if you try.
/// @param drive_info pointer to a single element out of the array
/// obtained from burn_drive_scan() : &(drive_infos[driveno])
/// @param force controls degree of permissible drive usage at the moment this
/// function is called, and the amount of automatically provided
/// drive shutdown :
/// 0= drive must be ungrabbed and BURN_DRIVE_IDLE
/// 1= try to release drive even if in state BURN_DRIVE_GRABBING
/// Use these two only. Further values are to be defined.
/// @return 1 on success, 2 if drive was already forgotten,
/// 0 if not permissible, <0 on other failures,
/// @since 0.2.2
pub fn burn_drive_info_forget(
drive_info: *mut burn_drive_info,
force: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// When no longer needed, free a whole burn_drive_info array which was
/// returned by burn_drive_scan().
/// For freeing single drive array elements use burn_drive_info_forget().
pub fn burn_drive_info_free(drive_infos: *mut burn_drive_info);
}
unsafe extern "C" {
/// Inquire the device file address of the given drive.
/// @param drive The drive to inquire.
/// @param adr An application provided array of at least BURN_DRIVE_ADR_LEN
/// characters size. The device file address gets copied to it.
/// @return >0 success , <=0 error (due to libburn internal problem)
/// @since 0.4.0
pub fn burn_drive_d_get_adr(
drive: *mut burn_drive,
adr: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire the device file address of a drive via a given drive_info object.
/// (Note: This is a legacy call.)
/// @param drive_info The drive to inquire.Usually some &(drive_infos[driveno])
/// @param adr An application provided array of at least BURN_DRIVE_ADR_LEN
/// characters size. The device file address gets copied to it.
/// @return >0 success , <=0 error (due to libburn internal problem)
/// @since 0.2.6
pub fn burn_drive_get_adr(
drive_info: *mut burn_drive_info,
adr: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Evaluate whether the given address would be a drive device file address
/// which could be listed by a run of burn_drive_scan(). No check is made
/// whether a device file with this address exists or whether it leads
/// to a usable MMC drive.
/// @return 1 means yes, 0 means no
/// @since 0.2.6
pub fn burn_drive_is_enumerable_adr(adr: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to convert a given existing filesystem address into a drive device file
/// address. This succeeds with symbolic links or if a hint about the drive's
/// system address can be read from the filesystem object and a matching drive
/// is found.
/// @param path The address of an existing file system object
/// @param adr An application provided array of at least BURN_DRIVE_ADR_LEN
/// characters size. The device file address gets copied to it.
/// @return 1 = success , 0 = failure , -1 = severe error
/// @since 0.2.6
pub fn burn_drive_convert_fs_adr(
path: *mut ::std::os::raw::c_char,
adr: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to convert a given SCSI address of bus,host,channel,target,lun into
/// a drive device file address. If a SCSI address component parameter is < 0
/// then it is not decisive and the first enumerated address which matches
/// the >= 0 parameters is taken as result.
/// Note: bus and (host,channel) are supposed to be redundant.
/// @param bus_no \"Bus Number\" (something like a virtual controller)
/// @param host_no \"Host Number\" (something like half a virtual controller)
/// @param channel_no \"Channel Number\" (other half of \"Host Number\")
/// @param target_no \"Target Number\" or \"SCSI Id\" (a device)
/// @param lun_no \"Logical Unit Number\" (a sub device)
/// @param adr An application provided array of at least BURN_DRIVE_ADR_LEN
/// characters size. The device file address gets copied to it.
/// @return 1 = success , 0 = failure , -1 = severe error
/// @since 0.2.6
pub fn burn_drive_convert_scsi_adr(
bus_no: ::std::os::raw::c_int,
host_no: ::std::os::raw::c_int,
channel_no: ::std::os::raw::c_int,
target_no: ::std::os::raw::c_int,
lun_no: ::std::os::raw::c_int,
adr: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to convert a given drive device file address into the address of a
/// symbolic link that points to this drive address.
/// Modern GNU/Linux systems may shuffle drive addresses from boot to boot.
/// The udev daemon is supposed to create links which always point to the
/// same drive, regardless of its system address.
/// This call tries to find such links.
/// @param dev_adr Should contain a drive address as returned by
/// burn_drive_scan().
/// @param link_adr An application provided array of at least
/// BURN_DRIVE_ADR_LEN characters size. The found link
/// address gets copied to it.
/// @param dir_adr The address of the directory where to look for links.
/// Normally: \"/dev\"
/// @param templ An array of pointers to name templates, which
/// links have to match. A symbolic link in dir_adr matches
/// a name template if it begins by that text. E.g.
/// link address \"/dev/dvdrw1\" matches template \"dvdrw\".
/// If templ is NULL, then the default array gets used:
/// {\"dvdrw\", \"cdrw\", \"dvd\", \"cdrom\", \"cd\"}
/// If several links would match, then a link will win,
/// which matches the template with the lowest array index.
/// Among these candidates, the one with the lowest strcmp()
/// rank will be chosen as link_adr.
/// @param num_templ Number of array elements in templ.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return <0 severe error, 0 failed to search, 2 nothing found
/// 1 success, link_adr is valid
/// @since 1.1.4
pub fn burn_lookup_device_link(
dev_adr: *mut ::std::os::raw::c_char,
link_adr: *mut ::std::os::raw::c_char,
dir_adr: *mut ::std::os::raw::c_char,
templ: *mut *mut ::std::os::raw::c_char,
num_templ: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to obtain bus,host,channel,target,lun from path. If there is an SCSI
/// address at all, then this call should succeed with a drive device file
/// address obtained via burn_drive_d_get_adr(). It is also supposed to
/// succeed with any device file of a (possibly emulated) SCSI device.
/// @return 1 = success , 0 = failure , -1 = severe error
/// @since 0.2.6
pub fn burn_drive_obtain_scsi_adr(
path: *mut ::std::os::raw::c_char,
bus_no: *mut ::std::os::raw::c_int,
host_no: *mut ::std::os::raw::c_int,
channel_no: *mut ::std::os::raw::c_int,
target_no: *mut ::std::os::raw::c_int,
lun_no: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Grab a drive. This must be done before the drive can be used (for reading,
/// writing, etc).
/// @param drive The drive to grab. This is found in a returned
/// burn_drive_info struct.
/// @param load Nonzero to make the drive attempt to load a disc (close its
/// tray door, etc).
/// @return 1 if it was possible to grab the drive, else 0
pub fn burn_drive_grab(
drive: *mut burn_drive,
load: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
pub fn burn_drive_probe_cd_write_modes(
drive_info: *mut burn_drive_info,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Calm down or alert a drive. Some drives stay alert after reading for
/// quite some time. This saves time with the startup for the next read
/// operation but also causes noise and consumes extra energy. It makes
/// sense to calm down the drive if no read operation is expected for the
/// next few seconds. The drive will get alert automatically if operations
/// are required.
/// @param d The drive to influence.
/// @param flag Bitfield for control purposes
/// bit0= become alert (else start snoozing)
/// This is not mandatory for further drive operations
/// @return 1= success , 0= drive role not suitable for calming
/// @since 0.7.0
pub fn burn_drive_snooze(
d: *mut burn_drive,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Re-assess drive and media status. This should be done after a drive
/// underwent a status change and shall be further used without intermediate
/// burn_drive_release(), burn_drive_grab(). E.g. after blanking or burning.
/// @param d The already grabbed drive to re-assess.
/// @param flag Unused yet. Submit 0.
/// @return 1 success , <= 0 could not determine drive and media state
/// @since 1.1.8
pub fn burn_drive_re_assess(
d: *mut burn_drive,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Release a drive. This should not be done until the drive is no longer
/// busy (see burn_drive_get_status).
/// @param drive The drive to release.
/// @param eject Nonzero to make the drive eject the disc in it.
pub fn burn_drive_release(drive: *mut burn_drive, eject: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Like burn_drive_release() but keeping the drive tray closed and its
/// eject button disabled. This physically locked drive state will last until
/// the drive is grabbed again and released via burn_drive_release().
/// Programs like eject, cdrecord, growisofs will break that ban too.
/// @param d The drive to release and leave locked.
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 means success, <=0 means failure
/// @since 0.4.0
pub fn burn_drive_leave_locked(
d: *mut burn_drive,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns what kind of disc a drive is holding. This function may need to be
/// called more than once to get a proper status from it. See burn_disc_status
/// for details.
/// @param drive The drive to query for a disc.
/// @return The status of the drive, or what kind of disc is in it.
/// Note: BURN_DISC_UNGRABBED indicates wrong API usage
pub fn burn_disc_get_status(drive: *mut burn_drive) -> burn_disc_status;
}
unsafe extern "C" {
/// WARNING: This revives an old bug-like behavior that might be dangerous.
/// Sets the drive status to BURN_DISC_BLANK if it is BURN_DISC_UNREADY
/// or BURN_DISC_UNSUITABLE. Thus marking media as writable which actually
/// failed to declare themselves either blank or (partially) filled.
/// @return 1 drive status has been set , 0 = unsuitable drive status
/// @since 0.2.6
pub fn burn_disc_pretend_blank(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// WARNING: This overrides the safety measures against unsuitable media.
/// Sets the drive status to BURN_DISC_FULL if it is BURN_DISC_UNREADY
/// or BURN_DISC_UNSUITABLE. Thus marking media as blankable which actually
/// failed to declare themselves either blank or (partially) filled.
/// @since 0.2.6
pub fn burn_disc_pretend_full(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// WARNING: This overrides the safety measures against unsuitable media.
/// Sets the drive status to BURN_DISC_FULL unconditionally.
/// @since 1.3.4
pub fn burn_disc_pretend_full_uncond(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns the Drive Serial Number as of MMC feature 108h.
/// @param d The drive to inquire.
/// @param sno Returns the bytes of the serial number. A trailing 0-byte
/// is appended for convenience. MMC specifies ASCII 0x20 to
/// 0x7h as possible byte values. But given drive firmware
/// habits there is no warranty that *sno contains no other
/// byte values.
/// Submit *sno as NULL or pointing to free()-able memory.
/// Apply free() to *sno when no longer needed.
/// @param sno_len Returns the number of valid bytes in returned *sno,
/// not counting the appended trailing 0.
/// @return 1= success (but maybe *sno_len is 0), <= 0 severe failure
/// @since 1.4.2
pub fn burn_drive_get_serial_no(
d: *mut burn_drive,
sno: *mut *mut ::std::os::raw::c_char,
sno_len: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns the Media Serial Number as of MMC feature 109h and command ABh
/// READ MEDIA SERIAL NUMBER.
///
/// Note: This call will return an empty result unless the macro
/// Libburn_enable_scsi_cmd_ABh
/// is defined at compile time.
/// This is because the command READ MEDIA SERIAL NUMBER demands
/// superuser authority on Linux, because no medium with serial number
/// could be tested yet, and because this command made one of the test
/// drives unusable until power cycle when it was executed despite
/// feature 109h was not announced as \"current\".
///
/// @param d The drive to inquire.
/// @param sno Returns the bytes of the serial number. A trailing 0-byte
/// is appended for convenience. There is no warranty that
/// sno contains only non-zero printable bytes.
/// Submit *sno as NULL or pointing to free()-able memory.
/// Apply free() to *sno when no longer needed.
/// @param sno_len Returns the number of valid bytes in returned *sno,
/// not counting the appended trailing 0.
/// @return 1= success (but maybe *sno_len is 0), <= 0 severe failure
/// @since 1.4.2
pub fn burn_drive_get_media_sno(
d: *mut burn_drive,
sno: *mut *mut ::std::os::raw::c_char,
sno_len: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Reads ATIP information from inserted media. To be obtained via
/// burn_drive_get_write_speed(), burn_drive_get_min_write_speed(),
/// burn_drive_get_start_end_lba(). The drive must be grabbed for this call.
/// @param drive The drive to query.
/// @return 1=success, 0=no valid ATIP info read, -1 severe error
/// @since 0.2.6
pub fn burn_disc_read_atip(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Tells whether a BD-R medium with Pseudo Overwrite (POW) formatting is in
/// the drive. Such a formatting may have been applied by dvd+rw-tools. It
/// prevents sequential multi-session.
/// libburn will refuse to write to such a medium.
/// @param drive The drive to query.
/// @return 1 if BD-R Pseudo Overwrite , 0 if not BD-R or not POW
/// @since 1.4.8
pub fn burn_drive_get_bd_r_pow(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns start and end lba of the media which is currently inserted
/// in the given drive. The drive has to be grabbed to have hope for reply.
/// Shortcoming (not a feature): unless burn_disc_read_atip() was called
/// only blank media will return valid info.
/// @param drive The drive to query.
/// @param start_lba Returns the start lba value
/// @param end_lba Returns the end lba value
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 if lba values are valid , 0 if invalid
/// @since 0.2.6
pub fn burn_drive_get_start_end_lba(
drive: *mut burn_drive,
start_lba: *mut ::std::os::raw::c_int,
end_lba: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Guess the manufacturer name of CD media from the ATIP addresses of lead-in
/// and lead-out. (Currently only lead-in is interpreted. Lead-out may in
/// future be used to identify the media type in more detail.)
/// The parameters of this call should be obtained by burn_disc_read_atip(d),
/// burn_drive_get_start_end_lba(d, &start_lba, &end_lba, 0),
/// burn_lba_to_msf(start_lba, &m_li, &s_li, &f_li) and
/// burn_lba_to_msf(end_lba, &m_lo, &s_lo, &f_lo).
/// @param m_li \"minute\" part of ATIP lead-in or start_lba
/// @param s_li \"second\" of lead-in or start_lba
/// @param f_li \"frame\" of lead-in
/// @param m_lo \"minute\" part of ATIP lead-out
/// @param s_lo \"second\" of lead-out
/// @param f_lo \"frame\" of lead-out
/// @param flag Bitfield for control purposes,
/// bit0= append a text \"(aka ...)\" to reply if other brands or
/// vendor names are known.
/// @return Printable text or NULL on memory shortage.
/// Dispose by free() when no longer needed.
/// @since 0.7.2
pub fn burn_guess_cd_manufacturer(
m_li: ::std::os::raw::c_int,
s_li: ::std::os::raw::c_int,
f_li: ::std::os::raw::c_int,
m_lo: ::std::os::raw::c_int,
s_lo: ::std::os::raw::c_int,
f_lo: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
/// Retrieve some media information which is mainly specific to CD. For other
/// media only the bits in reply parameter valid are supposed to be meaningful.
/// @param d The drive to query.
/// @param disc_type A string saying either \"CD-DA or CD-ROM\", or \"CD-I\",
/// or \"\"CD-ROM XA\", or \"undefined\".
/// @param disc_id A 32 bit number read from the media. (Meaning unclear yet)
/// @param bar_code 8 hex digits from a barcode on media read by the drive
/// (if the drive has a bar code reader built in).
/// @param app_code The Host Application Code which must be set in the Write
/// Parameters Page if the media is not unrestricted (URU==0).
/// @param valid Replies bits which indicate the validity of other reply
/// parameters or the state of certain CD info bits:
/// bit0= disc_type is valid
/// bit1= disc_id is valid
/// bit2= bar_code is valid
/// bit3= disc_app_code is valid
/// bit4= Disc is unrestricted (URU bit, 51h READ DISC INFO)
/// This seems to be broken with my drives. The bit is
/// 0 and the validity bit for disc_app_code is 0 too.
/// bit5= Disc is nominally erasable (Erasable bit)
/// This will be set with overwritable media which
/// libburn normally considers to be unerasable blank.
/// @return 1 success, <= 0 an error occurred
/// @since 0.7.2
pub fn burn_disc_get_cd_info(
d: *mut burn_drive,
disc_type: *mut ::std::os::raw::c_char,
disc_id: *mut ::std::os::raw::c_uint,
bar_code: *mut ::std::os::raw::c_char,
app_code: *mut ::std::os::raw::c_int,
valid: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read the array of CD-TEXT packs from the Lead-in of an audio CD.
/// Each pack consists of 18 bytes, of which 4 are header. 12 bytes are pieces
/// of 0-terminated texts or binary data. 2 bytes hold a CRC.
/// For a description of the format of the array, see file doc/cdtext.txt.
/// @param d The drive to query.
/// @param text_packs Will point to an allocated memory buffer with CD-TEXT.
/// It will only contain text packs, and not be prepended
/// by the TOC header of four bytes, which gets stored with
/// file cdtext.dat by cdrecord -vv -toc. (The first two of
/// these bytes are supposed to hold the number of CD-TEXT
/// bytes + 2. The other two bytes are supposed to be 0.)
/// Dispose this buffer by free(), when no longer needed.
/// @param num_packs Will tell the number of text packs, i.e. the number of
/// bytes in text_packs divided by 18.
/// @param flag Bitfield for control purposes,
/// Unused yet. Submit 0.
/// @return 1 success, 0= no CD-TEXT found, < 0 an error occurred
/// @since 1.2.0
pub fn burn_disc_get_leadin_text(
d: *mut burn_drive,
text_packs: *mut *mut ::std::os::raw::c_uchar,
num_packs: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read the current usage of the eventual BD Spare Area. This area gets
/// reserved on BD media during formatting. During writing it is used to
/// host replacements of blocks which failed the checkread immediately after
/// writing.
/// This call applies only to recordable BD media. I.e. profiles 0x41 to 0x43.
/// @param d The drive to query.
/// @param alloc_blocks Returns the number of blocks reserved as Spare Area
/// @param free_blocks Returns the number of yet unused blocks in that area
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 = reply prarameters are valid,
/// <=0 = reply is invalid (e.g. because no BD profile)
/// @since 0.8.8
pub fn burn_disc_get_bd_spare_info(
d: *mut burn_drive,
alloc_blocks: *mut ::std::os::raw::c_int,
free_blocks: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Retrieve some media information which is mainly specific to media of
/// the DVD-R family: DVD-R , DVD-RW , DVD-R DL , HD DVD-R
/// Currently the information cannot be retrieved from other media types.
/// @param d The drive to query.
/// @param disk_category returns DVD Book to which the media complies
/// @param book_name returns a pointer to the book name of disk_category.
/// This memory is static. Do not alter or free it !
/// @param part_version returns the Media Version in the DVD Book
/// @param num_layers returns the number of media layers
/// @param num_blocks returns the number of blocks between pysical start
/// and physical end of the media
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 = reply prarameters are valid,
/// <=0 = reply is invalid (e.g. because no DVD-R)
/// @since 1.1.4
pub fn burn_disc_get_phys_format_info(
d: *mut burn_drive,
disk_category: *mut ::std::os::raw::c_int,
book_name: *mut *mut ::std::os::raw::c_char,
part_version: *mut ::std::os::raw::c_int,
num_layers: *mut ::std::os::raw::c_int,
num_blocks: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read start lba and Next Writeable Address of a track from media.
/// Usually a track lba is obtained from the result of burn_track_get_entry().
/// This call retrieves an updated lba, eventual nwa, and can address the
/// invisible track to come.
/// The drive must be grabbed for this call. One may not issue this call
/// during ongoing burn_disc_write() or burn_disc_erase().
/// @param d The drive to query.
/// @param o If not NULL: write parameters to be set on drive before query
/// @param trackno 0=next track to come, >0 number of existing track
/// The first existing track on a CD may have a number higher
/// than 1. Use burn_session_get_start_tno() to inquire this
/// start number.
/// @param lba return value: start lba
/// @param nwa return value: Next Writeable Address
/// @return 1=nwa is valid , 0=nwa is not valid , -1=error
/// @since 0.2.6
pub fn burn_disc_track_lba_nwa(
d: *mut burn_drive,
o: *mut burn_write_opts,
trackno: ::std::os::raw::c_int,
lba: *mut ::std::os::raw::c_int,
nwa: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Tells whether a previous attempt to determine the Next Writeable Address
/// of the upcoming track reveiled that the READ TRACK INFORMATION Damage Bit
/// is set for this track and that no valid writable address is available.
/// See MMC-5 6.27.3.7 Damage Bit, 6.27.3.11 NWA_V (NWA valid)
/// @param d The drive to query.
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 0= Looks ok: Damage Bit is not set, NWA_V is set
/// 1= Damaged and theoretically writable (NWA_V is set)
/// 2= Not writable: NWA_V is not set
/// 3= Damaged and not writable (NWA_V is not set),
/// @since 1.1.0
pub fn burn_disc_next_track_is_damaged(
d: *mut burn_drive,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to close the last track and session of media which have bit0 set in
/// the return value of call burn_disc_next_track_is_damaged().
/// Whether it helps depends much on the reason why the media is reported
/// as damaged by the drive.
/// This call works only for profiles 0x09 CD-R, 0x0a CD-RW, 0x11 DVD-R,
/// 0x14 DVD-RW sequential, 0x1b DVD+R, 0x2b DVD+R DL, 0x41 BD-R sequential.
/// Note: After writing it is advised to give up the drive and to grab it again
/// in order to learn about its view on the new media state.
/// @param o Write options created by burn_write_opts_new() and
/// manipulated by burn_write_opts_set_multi().
/// burn_write_opts_set_write_type() should be set to
/// BURN_WRITE_TAO, burn_write_opts_set_simulate() should be
/// set to 0.
/// @param flag Bitfield for control purposes
/// bit0= force close, even if no damage was seen
/// @return <=0 media not marked as damaged, or media type not suitable,
/// or closing attempted but failed
/// 1= attempt finished without error indication
/// @since 1.1.0
pub fn burn_disc_close_damaged(
o: *mut burn_write_opts,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read start lba of the first track in the last complete session.
/// This is the first parameter of mkisofs option -C. The second parameter
/// is nwa as obtained by burn_disc_track_lba_nwa() with trackno 0.
/// @param d The drive to query.
/// @param start_lba returns the start address of that track
/// @return <= 0 : failure, 1 = ok
/// @since 0.3.2
pub fn burn_disc_get_msc1(
d: *mut burn_drive,
start_lba: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Return the best possible estimation of the currently available capacity of
/// the media. This might depend on particular write option settings. For
/// inquiring the space with such a set of options, the drive has to be
/// grabbed and BURN_DRIVE_IDLE. If not, then one will only get a canned value
/// from the most recent automatic inquiry (e.g. during last drive grabbing).
/// An eventual start address from burn_write_opts_set_start_byte() will be
/// taken into respect with the capacity estimation. Negative results get
/// defaulted to 0.
/// If the drive is actually a file in a large filesystem or a large block
/// device, then the capacity is curbed to a maximum of 0x7ffffff0 blocks
/// = 4 TB - 32 KB.
/// @param d The drive to query.
/// @param o If not NULL: write parameters to be set on drive before query
/// @return number of most probably available free bytes
/// @since 0.3.4
pub fn burn_disc_available_space(d: *mut burn_drive, o: *mut burn_write_opts) -> off_t;
}
unsafe extern "C" {
/// Tells the MMC Profile identifier of the loaded media. The drive must be
/// grabbed in order to get a non-zero result.
/// libburn currently writes only to profiles
/// 0x09 \"CD-R\"
/// 0x0a \"CD-RW\"
/// 0x11 \"DVD-R sequential recording\"
/// 0x12 \"DVD-RAM\"
/// 0x13 \"DVD-RW restricted overwrite\"
/// 0x14 \"DVD-RW sequential recording\",
/// 0x15 \"DVD-R/DL sequential recording\",
/// 0x1a \"DVD+RW\"
/// 0x1b \"DVD+R\",
/// 0x2b \"DVD+R/DL\",
/// 0x41 \"BD-R sequential recording\",
/// 0x43 \"BD-RE\",
/// 0xffff \"stdio file\"
/// Note: 0xffff is not a MMC profile but a libburn invention.
/// Read-only are the profiles
/// 0x08 \"CD-ROM\",
/// 0x10 \"DVD-ROM\",
/// 0x40 \"BD-ROM\",
/// Read-only for now is this BD-R profile (testers wanted)
/// 0x42 \"BD-R random recording\"
/// Empty drives are supposed to report
/// 0x00 \"\"
/// @param d The drive where the media is inserted.
/// @param pno Profile Number. See also mmc5r03c.pdf, table 89
/// @param name Profile Name (see above list, unknown profiles have empty name)
/// @return 1 profile is valid, 0 no profile info available
/// @since 0.3.0
pub fn burn_disc_get_profile(
d: *mut burn_drive,
pno: *mut ::std::os::raw::c_int,
name: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain product id and standards defined media codes.
/// The product id is a printable string which is supposed to be the same
/// for identical media but should vary with non-identical media. Some media
/// cannot provide such an id at all.
/// The pair (profile_number, product_id) should be the best id to identify
/// media with identical product specifications.
/// The reply parameters media_code1 and media_code2 can be used with
/// burn_guess_manufacturer()
/// The reply parameters have to be disposed by free() when no longer needed.
/// @param d The drive where the media is inserted.
/// @param product_id Reply: Printable text depicting manufacturer and
/// eventually media id.
/// @param media_code1 Reply: The eventual manufacturer identification as read
/// from DVD/BD media or a text \"XXmYYsZZf\" from CD media
/// ATIP lead-in.
/// @param media_code2 The eventual media id as read from DVD+/BD media or a
/// text \"XXmYYsZZf\" from CD ATIP lead-out.
/// @param book_type Book type text for DVD and BD.
/// Caution: is NULL with CD, even if return value says ok.
/// @param flag Bitfield for control purposes
/// bit0= do not escape \" _/\" (not suitable for
/// burn_guess_manufacturer())
/// @return 1= ok, product_id and media codes are valid,
/// 0= no product id_available, reply parameters are NULL
/// <0= error
/// @since 0.7.2
pub fn burn_disc_get_media_id(
d: *mut burn_drive,
product_id: *mut *mut ::std::os::raw::c_char,
media_code1: *mut *mut ::std::os::raw::c_char,
media_code2: *mut *mut ::std::os::raw::c_char,
book_type: *mut *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Guess the name of a manufacturer by profile number, manufacturer code
/// and media code. The profile number can be obtained by
/// burn_disc_get_profile(), the other two parameters can be obtained as
/// media_code1 and media_code2 by burn_disc_get_media_id().
/// @param profile_no Profile number (submit -1 if not known)
/// @param manuf_code Manufacturer code from media (e.g. \"RICOHJPN\")
/// @param media_code Media ID code from media (e.g. \"W11\")
/// @param flag Bitfield for control purposes, submit 0
/// @return Printable text or NULL on memory shortage.
/// If the text begins with \"Unknown \" then no item of the
/// manufacturer list matched the codes.
/// Dispose by free() when no longer needed.
/// @since 0.7.2
pub fn burn_guess_manufacturer(
profile_no: ::std::os::raw::c_int,
manuf_code: *mut ::std::os::raw::c_char,
media_code: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
/// Tells whether a disc can be erased or not
/// @param d The drive to inquire.
/// @return Non-zero means erasable
pub fn burn_disc_erasable(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns the progress and status of a drive.
/// @param drive The drive to query busy state for.
/// @param p Returns the progress of the operation, NULL if you don't care
/// @return the current status of the drive. See also burn_drive_status.
pub fn burn_drive_get_status(
drive: *mut burn_drive,
p: *mut burn_progress,
) -> burn_drive_status;
}
unsafe extern "C" {
/// Creates a write_opts struct for burning to the specified drive.
/// The returned object must later be freed with burn_write_opts_free().
/// @param drive The drive to write with
/// @return The write_opts, NULL on error
pub fn burn_write_opts_new(drive: *mut burn_drive) -> *mut burn_write_opts;
}
unsafe extern "C" {
/// Inquires the drive associated with a burn_write_opts object.
/// @param opts object to inquire
/// @return pointer to drive
/// @since 0.4.0
pub fn burn_write_opts_get_drive(opts: *mut burn_write_opts) -> *mut burn_drive;
}
unsafe extern "C" {
/// Frees a write_opts struct created with burn_write_opts_new
/// @param opts write_opts to free
pub fn burn_write_opts_free(opts: *mut burn_write_opts);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_read_opts {
_unused: [u8; 0],
}
unsafe extern "C" {
/// Creates a read_opts struct for reading from the specified drive
/// must be freed with burn_read_opts_free
/// @param drive The drive to read from
/// @return The read_opts
pub fn burn_read_opts_new(drive: *mut burn_drive) -> *mut burn_read_opts;
}
unsafe extern "C" {
/// Frees a read_opts struct created with burn_read_opts_new
/// @param opts write_opts to free
pub fn burn_read_opts_free(opts: *mut burn_read_opts);
}
unsafe extern "C" {
/// Erase a disc in the drive. The drive must be grabbed successfully BEFORE
/// calling this functions. Always ensure that the drive reports a status of
/// BURN_DISC_FULL before calling this function. An erase operation is not
/// cancellable, as control of the operation is passed wholly to the drive and
/// there is no way to interrupt it safely.
/// @param drive The drive with which to erase a disc.
/// Only drive roles 1 (MMC) and 5 (stdio random write-only)
/// support erasing.
/// @param fast Nonzero to do a fast erase, where only the disc's headers are
/// erased; zero to erase the entire disc.
/// With DVD-RW, fast blanking yields media capable only of DAO.
pub fn burn_disc_erase(drive: *mut burn_drive, fast: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Format media for use with libburn. This currently applies to DVD-RW
/// in state \"Sequential Recording\" (profile 0014h) which get formatted to
/// state \"Restricted Overwrite\" (profile 0013h). DVD+RW can be \"de-iced\"
/// by setting bit4 of flag. DVD-RAM and BD-RE may get formatted initially
/// or re-formatted to adjust their Defect Management.
/// This function usually returns while the drive is still in the process
/// of formatting. The formatting is done, when burn_drive_get_status()
/// returns BURN_DRIVE_IDLE. This may be immediately after return or may
/// need several thousand seconds to occur.
/// @param drive The drive with the disc to format.
/// @param size The size in bytes to be used with the format command. It should
/// be divisible by 32*1024. The effect of this parameter may
/// depend on the media profile and on parameter flag.
/// @param flag Bitfield for control purposes:
/// bit0= after formatting, write the given number of zero-bytes
/// to the media and eventually perform preliminary closing.
/// bit1+2: size mode
/// 0 = use parameter size as far as it makes sense
/// 1 = insist in size 0 even if there is a better default known
/// (on DVD-RAM or BD-R identical to size mode 0,
/// i.e. they never get formatted with payload size 0)
/// 2 = without bit7: format to maximum available size
/// with bit7 : take size from indexed format descriptor
/// 3 = without bit7: format to default size
/// with bit7 : take size from indexed format descriptor
/// bit3= -reserved-
/// bit4= enforce re-format of (partly) formatted media
/// bit5= try to disable eventual defect management
/// bit6= try to avoid lengthy media certification
/// bit7, bit8 to bit15 =
/// bit7 enables MMC expert application mode (else libburn
/// tries to choose a suitable format type):
/// If it is set then bit8 to bit15 contain the index of
/// the format to use. See burn_disc_get_formats(),
/// burn_disc_get_format_descr().
/// Acceptable types are: 0x00, 0x01, 0x10, 0x11, 0x13,
/// 0x15, 0x26, 0x30, 0x31, 0x32.
/// If bit7 is set, then bit4 is set automatically.
/// bit16= enable POW on blank BD-R
/// @since 0.3.0
pub fn burn_disc_format(drive: *mut burn_drive, size: off_t, flag: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Inquire the formatting status, the associated sizes and the number of
/// available formats. The info is media specific and stems from MMC command
/// 23h READ FORMAT CAPACITY. See mmc5r03c.pdf 6.24 for background details.
/// Media type can be determined via burn_disc_get_profile().
/// @param drive The drive with the disc to format.
/// @param status The current formatting status of the inserted media.
/// See BURN_FORMAT_IS_* macros. Note: \"unknown\" is the
/// legal status for quick formatted, yet unwritten DVD-RW.
/// @param size The size in bytes associated with status.
/// unformatted: the maximum achievable size of the media
/// formatted: the currently formatted capacity
/// unknown: maximum capacity of drive or of media
/// @param bl_sas Additional info \"Block Length/Spare Area Size\".
/// Expected to be constantly 2048 for non-BD media.
/// @param num_formats The number of available formats. To be used with
/// burn_disc_get_format_descr() to obtain such a format
/// and eventually with burn_disc_format() to select one.
/// @return 1 reply is valid , <=0 failure
/// @since 0.3.0
pub fn burn_disc_get_formats(
drive: *mut burn_drive,
status: *mut ::std::os::raw::c_int,
size: *mut off_t,
bl_sas: *mut ::std::os::raw::c_uint,
num_formats: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire parameters of an available media format.
/// @param drive The drive with the disc to format.
/// @param index The index of the format item. Beginning with 0 up to reply
/// parameter from burn_disc_get_formats() : num_formats - 1
/// @param type The format type. See mmc5r03c.pdf, 6.5, 04h FORMAT UNIT.
/// 0x00=full, 0x10=CD-RW/DVD-RW full, 0x11=CD-RW/DVD-RW grow,
/// 0x15=DVD-RW quick, 0x13=DVD-RW quick grow,
/// 0x26=DVD+RW background, 0x30=BD-RE with spare areas,
/// 0x31=BD-RE without spare areas
/// @param size The maximum size in bytes achievable with this format.
/// @param tdp Type Dependent Parameter. See mmc5r03c.pdf.
/// @return 1 reply is valid , <=0 failure
/// @since 0.3.0
pub fn burn_disc_get_format_descr(
drive: *mut burn_drive,
index: ::std::os::raw::c_int,
type_: *mut ::std::os::raw::c_int,
size: *mut off_t,
tdp: *mut ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read a disc from the drive and write it to an fd pair. The drive must be
/// grabbed successfully BEFORE calling this function. Always ensure that the
/// drive reports a status of BURN_DISC_FULL before calling this function.
/// @param drive The drive from which to read a disc.
/// @param o The options for the read operation.
pub fn burn_disc_read(drive: *mut burn_drive, o: *const burn_read_opts);
}
unsafe extern "C" {
/// Examines a completed setup for burn_disc_write() whether it is permissible
/// with drive and media. This function is called by burn_disc_write() but
/// an application might be interested in this check in advance.
/// @param o The options for the writing operation.
/// @param disc The description of the disc to be created
/// @param reasons Eventually returns a list of rejection reason statements
/// @param silent 1= do not issue error messages , 0= report problems
/// @return 1 ok, -1= no recordable media detected, 0= other failure
/// @since 0.3.4
pub fn burn_precheck_write(
o: *mut burn_write_opts,
disc: *mut burn_disc,
reasons: *mut ::std::os::raw::c_char,
silent: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Write a disc in the drive. The drive must be grabbed successfully before
/// calling this function. Always ensure that the drive reports a status of
/// BURN_DISC_BLANK ot BURN_DISC_APPENDABLE before calling this function.
/// Note: write_type BURN_WRITE_SAO is currently not capable of writing a mix
/// of data and audio tracks. You must use BURN_WRITE_TAO for such sessions.
/// To be set by burn_write_opts_set_write_type().
/// Note: This function is not suitable for overwriting data in the middle of
/// a valid data area because it is allowed to append trailing data.
/// For exact random access overwriting use burn_random_access_write().
/// Note: After writing it is advised to give up the drive and to grab it again
/// in order to learn about its view on the new media state.
/// Note: Before mounting the written media it might be necessary to eject
/// and reload in order to allow the operating system to notice the new
/// media state.
/// @param o The options for the writing operation.
/// @param disc The struct burn_disc * that described the disc to be created
pub fn burn_disc_write(o: *mut burn_write_opts, disc: *mut burn_disc);
}
unsafe extern "C" {
/// Control stream recording during the write run and eventually set the start
/// LBA for stream recording.
/// Stream recording is set from struct burn_write_opts when the write run
/// gets started. See burn_write_opts_set_stream_recording().
/// The call described here can be used later to override this setting and
/// to program automatic switching at a given LBA. It also affects subsequent
/// calls to burn_random_access_write().
/// @param drive The drive which performs the write operation.
/// @param recmode -1= disable stream recording
/// 0= leave setting as is
/// 1= enable stream recording
/// @param start The LBA where actual stream recording shall start.
/// (0 means unconditional stream recording)
/// @param flag Bitfield for control purposes (unused yet, submit 0).
/// @return 1=success , <=0 failure
/// @since 0.6.4
pub fn burn_drive_set_stream_recording(
drive: *mut burn_drive,
recmode: ::std::os::raw::c_int,
start: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Enable or disable use of the Immed bit with long running SCSI commands.
/// If the Immed bit is used, then those SCSI commands end early and leave
/// the drive in not-ready state. libburn then tries periodically whether
/// the drive became ready again. Only then it assumes the command to be
/// completely done.
/// The default setting may depend on the operating system on which libburn
/// was compiled.
/// @param drive The drive which will be affected.
/// @param enable 1= use Immed bit.
/// 0= use no Immed bit. Affected commands can last very long.
/// @return 1=success , <=0 failure
/// @since 1.4.6
pub fn burn_drive_set_immed(
drive: *mut burn_drive,
enable: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire the current setting of usage of the Immed bit. Either the still set
/// system dependent default or the value set by call burn_drive_set_immed().
/// @return The current value.
/// @since 1.4.6
pub fn burn_drive_get_immed(drive: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Cancel an operation on a drive.
/// This will only work when the drive's busy state is BURN_DRIVE_READING or
/// BURN_DRIVE_WRITING.
/// @param drive The drive on which to cancel the current operation.
pub fn burn_drive_cancel(drive: *mut burn_drive);
}
unsafe extern "C" {
/// Inquire whether the most recent asynchronous media job was successful.
/// This applies to burn_disc_erase(), burn_disc_format(), burn_disc_write().
/// Reasons for non-success may be: rejection of burn parameters, abort due to
/// fatal errors during write, blank or format, a call to burn_drive_cancel()
/// by the application thread.
/// @param d The drive to inquire.
/// @return 1=burn seems to have went well, 0=burn failed
/// @since 0.2.6
pub fn burn_drive_wrote_well(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire whether a write error occurred which is suspected to have happened
/// due to a false report about DVD-RW capability to be written in write type
/// BURN_WRITE_TAO.
/// @param d The drive to inquire.
/// @return 1= it seems that BURN_WRITE_TAO on DVD-RW caused error,
/// 0= it does not seem so
/// @since 1.3.4
pub fn burn_drive_was_feat21_failure(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert a minute-second-frame (MSF) value to sector count
/// @param m Minute component
/// @param s Second component
/// @param f Frame component
/// @return The sector count
pub fn burn_msf_to_sectors(
m: ::std::os::raw::c_int,
s: ::std::os::raw::c_int,
f: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert a sector count to minute-second-frame (MSF)
/// @param sectors The sector count
/// @param m Returns the minute component
/// @param s Returns the second component
/// @param f Returns the frame component
pub fn burn_sectors_to_msf(
sectors: ::std::os::raw::c_int,
m: *mut ::std::os::raw::c_int,
s: *mut ::std::os::raw::c_int,
f: *mut ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Convert a minute-second-frame (MSF) value to an lba
/// @param m Minute component
/// @param s Second component
/// @param f Frame component
/// @return The lba
pub fn burn_msf_to_lba(
m: ::std::os::raw::c_int,
s: ::std::os::raw::c_int,
f: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert an lba to minute-second-frame (MSF)
/// @param lba The lba
/// @param m Returns the minute component
/// @param s Returns the second component
/// @param f Returns the frame component
pub fn burn_lba_to_msf(
lba: ::std::os::raw::c_int,
m: *mut ::std::os::raw::c_int,
s: *mut ::std::os::raw::c_int,
f: *mut ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Create a new disc
/// @return Pointer to a burn_disc object or NULL on failure.
pub fn burn_disc_create() -> *mut burn_disc;
}
unsafe extern "C" {
/// Delete disc and decrease the reference count on all its sessions
/// @param d The disc to be freed
pub fn burn_disc_free(d: *mut burn_disc);
}
unsafe extern "C" {
/// Create a new session
/// @return Pointer to a burn_session object or NULL on failure.
pub fn burn_session_create() -> *mut burn_session;
}
unsafe extern "C" {
/// Free a session (and decrease reference count on all tracks inside)
/// @param s Session to be freed
pub fn burn_session_free(s: *mut burn_session);
}
unsafe extern "C" {
/// Add a session to a disc at a specific position, increasing the
/// sessions's reference count.
/// @param d Disc to add the session to
/// @param s Session to add to the disc
/// @param pos position to add at (BURN_POS_END is \"at the end\")
/// @return 0 for failure, 1 for success
pub fn burn_disc_add_session(
d: *mut burn_disc,
s: *mut burn_session,
pos: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove a session from a disc
/// @param d Disc to remove session from
/// @param s Session pointer to find and remove
pub fn burn_disc_remove_session(
d: *mut burn_disc,
s: *mut burn_session,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read a CDRWIN cue sheet file and equip the session object by tracks and
/// CD-TEXT according to the content of the file.
/// For a description of CDRWIN file format see
/// http://digitalx.org/cue-sheet/syntax/
/// Fully supported commands are:
/// CATALOG , CDTEXTFILE , FLAGS , INDEX , ISRC , PERFORMER ,
/// POSTGAP , PREGAP , REM , SONGWRITER , TITLE
/// Further supported commands introduced by cdrecord (usage like PERFORMER):
/// ARRANGER , COMPOSER , MESSAGE
/// Partly supported commands are:
/// FILE which supports only types BINARY , MOTOROLA , WAVE
/// TRACK which supports only datatypes AUDIO , MODE1/2048
/// Unsupported types of FILE or TRACK lead to failure of the call.
/// libburn does not yet support mixing of AUDIO and MODE1/2048. So this call
/// will fail if such a mix is found.
/// CD-TEXT information is allowed only if all tracks are of datatype AUDIO.
/// Empty lines and lines which start by '#' are ignored.
/// @param session Session where to attach tracks. It must not yet have
/// tracks or else this call will fail.
/// @param path Filesystem address of the CDRWIN cue sheet file.
/// Normally with suffix .cue
/// @param fifo_size Number of bytes in fifo. This will be rounded up by
/// the block size of the track mode. <= 0 means no fifo.
/// @param fifo Returns a reference to the burn_source object that
/// was installed as fifo between FILE and the track
/// burn sources. One may use this to inquire the fifo
/// state. Dispose it by burn_source_free() when no longer
/// needed. It is permissible to pass this parameter to
/// libburn as NULL, in order to immediately drop ownership
/// on the fifo.
/// @param text_packs Returns pre-formatted CD-TEXT packs resulting from
/// cue sheet command CDTEXTFILE. To be used with call
/// burn_write_opts_set_leadin_text().
/// It is permissible to pass this parameter to libburn
/// as NULL, in order to disable CDTEXTFILE.
/// @param num_packs Returns the number of 18 byte records in text_packs.
/// @param flag Bitfield for control purposes.
/// bit0= Do not attach CD-TEXT information to session and
/// tracks. Do not load text_packs.
/// bit1= Do not use media catalog string of session or ISRC
/// strings of tracks for writing to Q sub-channel.
/// @return > 0 indicates success, <= 0 indicates failure
/// @since 1.2.0
pub fn burn_session_by_cue_file(
session: *mut burn_session,
path: *mut ::std::os::raw::c_char,
fifo_size: ::std::os::raw::c_int,
fifo: *mut *mut burn_source,
text_packs: *mut *mut ::std::os::raw::c_uchar,
num_packs: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Create a track
pub fn burn_track_create() -> *mut burn_track;
}
unsafe extern "C" {
/// Free a track
/// @param t Track to free
pub fn burn_track_free(t: *mut burn_track);
}
unsafe extern "C" {
/// Add a track to a session at specified position
/// @param s Session to add to
/// @param t Track to insert in session
/// @param pos position to add at (BURN_POS_END is \"at the end\")
/// @return 0 for failure, 1 for success
pub fn burn_session_add_track(
s: *mut burn_session,
t: *mut burn_track,
pos: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove a track from a session
/// @param s Session to remove track from
/// @param t Track pointer to find and remove
/// @return 0 for failure, 1 for success
pub fn burn_session_remove_track(
s: *mut burn_session,
t: *mut burn_track,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Set the number which shall be written as CD track number with the first
/// track of the session. The following tracks will then get written with
/// consecutive CD track numbers. The resulting number of the last track
/// must not exceed 99. The lowest possible start number is 1, which is also
/// the default. This setting applies only to CD SAO writing.
/// @param session The session to be manipulated
/// @param tno A number between 1 and 99
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 indicates failure
/// @since 1.2.0
pub fn burn_session_set_start_tno(
session: *mut burn_session,
tno: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire the CD track start number, as set by default or by
/// burn_session_set_start_tno().
/// @param session The session to be inquired
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 is the currently set CD track start number
/// <= 0 indicates failure
/// @since 1.2.0
pub fn burn_session_get_start_tno(
session: *mut burn_session,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Set the Character Codes, the Copyright bytes, and the Language Codes
/// for CD-TEXT blocks 0 to 7. They will be used in the block summaries
/// of text packs which get generated from text or binary data submitted
/// by burn_session_set_cdtext() and burn_track_set_cdtext().
/// Character Code value can be
/// 0x00 = ISO-8859-1
/// 0x01 = 7 bit ASCII
/// 0x80 = MS-JIS (japanesei Kanji, double byte characters)
/// Copyright byte value can be
/// 0x00 = not copyrighted
/// 0x03 = copyrighted
/// Language Code value will typically be 0x09 = English or 0x69 = Japanese.
/// See below macros BURN_CDTEXT_LANGUAGES_0X00 and BURN_CDTEXT_LANGUAGES_0X45,
/// but be aware that many of these codes have never been seen on CD, and that
/// many of them do not have a character representation among the above
/// Character Codes.
/// Default is 0x09 = English for block 0 and 0x00 = Unknown for block 1 to 7.
/// Copyright and Character Code are 0x00 for all blocks by default.
/// See also file doc/cdtext.txt, \"Format of a CD-TEXT packs array\",
/// \"Pack type 0x8f\".
///
/// Parameter value -1 leaves the current setting of the session parameter
/// unchanged.
/// @param s Session where to change settings
/// @param char_codes Character Codes for block 0 to 7
/// @param copyrights Copyright bytes for block 0 to 7
/// @param languages Language Codes for block 0 to 7
/// @param flag Bitfiled for control purposes. Unused yet. Submit 0.
/// @return <=0 failure, > 0 success
/// @since 1.2.0
pub fn burn_session_set_cdtext_par(
s: *mut burn_session,
char_codes: *mut ::std::os::raw::c_int,
copyrights: *mut ::std::os::raw::c_int,
languages: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain the current settings as of burn_session_set_cdtext_par()
/// @param s Session which to inquire
/// @param char_codes Will return Character Codes for block 0 to 7
/// @param copyrights Will return Copyright bytes for block 0 to 7
/// @param block_languages Will return Language Codes for block 0 to 7
/// @param flag Bitfiled for control purposes. Unused yet. Submit 0.
/// @return <=0 failure, reply invalid, > 0 success, reply valid
/// @since 1.2.0
pub fn burn_session_get_cdtext_par(
s: *mut burn_session,
char_codes: *mut ::std::os::raw::c_int,
copyrights: *mut ::std::os::raw::c_int,
block_languages: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Attach text or binary data as CD-TEXT attributes to a session.
/// They can be used to generate CD-TEXT packs by burn_cdtext_from_session()
/// or to write CD-TEXT packs into the lead-in of a CD SAO session.
/// The latter happens only if no array of CD-TEXT packs is attached to
/// the write options by burn_write_opts_set_leadin_text().
/// For details of the CD-TEXT format and of the payload content, see file
/// doc/cdtext.txt .
/// @param s Session where to attach CD-TEXT attribute
/// @param block Number of the language block in which the attribute
/// shall appear. Possible values: 0 to 7.
/// @param pack_type Pack type number. 0x80 to 0x8e. Used if pack_type_name
/// is NULL or empty text. Else submit 0 and a name.
/// Pack type 0x8f is generated automatically and may not
/// be set by applications.
/// @param pack_type_name The pack type by name. Defined names are:
/// 0x80 = \"TITLE\" 0x81 = \"PERFORMER\"
/// 0x82 = \"SONGWRITER\" 0x83 = \"COMPOSER\"
/// 0x84 = \"ARRANGER\" 0x85 = \"MESSAGE\"
/// 0x86 = \"DISCID\" 0x87 = \"GENRE\"
/// 0x88 = \"TOC\" 0x89 = \"TOC2\"
/// 0x8d = \"CLOSED\" 0x8e = \"UPC_ISRC\"
/// Names are recognized uppercase and lowercase.
/// @param payload Text or binary bytes. The data will be copied to
/// session-internal memory.
/// Pack types 0x80 to 0x85 contain 0-terminated cleartext
/// encoded according to the block's Character Code.
/// If double byte characters are used, then two 0-bytes
/// terminate the cleartext.
/// Pack type 0x86 is 0-terminated ASCII cleartext.
/// Pack type 0x87 consists of two byte big-endian
/// Genre code (see below BURN_CDTEXT_GENRE_LIST), and
/// 0-terminated ASCII cleartext of genre description.
/// Pack type 0x88 mirrors the session table-of-content.
/// Pack type 0x89 is not understood yet.
/// Pack types 0x8a to 0x8c are reserved.
/// Pack type 0x8d contains ISO-8859-1 cleartext which is
/// not to be shown by commercial audio CD players.
/// Pack type 0x8e is ASCII cleartext with UPC/EAN code.
/// @param length Number of bytes in payload. Including terminating
/// 0-bytes.
/// @param flag Bitfield for control purposes.
/// bit0= payload contains double byte characters
/// (with character code 0x80 MS-JIS japanese Kanji)
/// @return > 0 indicates success , <= 0 is failure
/// @since 1.2.0
pub fn burn_session_set_cdtext(
s: *mut burn_session,
block: ::std::os::raw::c_int,
pack_type: ::std::os::raw::c_int,
pack_type_name: *mut ::std::os::raw::c_char,
payload: *mut ::std::os::raw::c_uchar,
length: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain a CD-TEXT attribute that was set by burn_session_set_cdtext()
/// @param s Session to inquire
/// @param block Number of the language block to inquire.
/// @param pack_type Pack type number to inquire. Used if pack_type_name
/// is NULL or empty text. Else submit 0 and a name.
/// Pack type 0x8f is generated automatically and may not
/// be inquire in advance. Use burn_cdtext_from_session()
/// to generate all packs including type 0x8f packs.
/// @param pack_type_name The pack type by name.
/// See above burn_session_set_cdtext().
/// @param payload Will return a pointer to text or binary bytes.
/// Not a copy of data. Do not free() this address.
/// If no text attribute is attached for pack type and
/// block, then payload is returned as NULL. The return
/// value will not indicate error in this case.
/// @param length Will return the number of bytes pointed to by payload.
/// Including terminating 0-bytes.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return 1 single byte char, 2 double byte char, <=0 error
/// @since 1.2.0
pub fn burn_session_get_cdtext(
s: *mut burn_session,
block: ::std::os::raw::c_int,
pack_type: ::std::os::raw::c_int,
pack_type_name: *mut ::std::os::raw::c_char,
payload: *mut *mut ::std::os::raw::c_uchar,
length: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read a Sony CD-TEXT Input Sheet Version 0.7T file and attach its text
/// attributes to the given session and its tracks for the given CD-TEXT
/// block number. This overrides previous settings made by
/// burn_session_set_cdtext(), burn_track_set_cdtext(), burn_track_set_isrc(),
/// burn_session_set_start_tno(). It can later be overridden by said function
/// calls.
/// The media catalog number from purpose specifier \"UPC / EAN\" gets into
/// effect only if burn_write_opts_set_has_mediacatalog() is set to 0.
/// The format of a v07t sheet file is documented in doc/cdtext.txt.
/// @param session Session where to attach CD-TEXT attributes
/// @param path Local filesystem address of the sheet file which
/// shall be read and interpreted.
/// @param block Number of the language block in which the attributes
/// shall appear. Possible values: 0 to 7.
/// @param flag Bitfield for control purposes.
/// bit0= Permission to read multiple blocks from the
/// given sheet file. Each block is supposed to begin
/// by a line \"Input Sheet Version = 0.7T\". Therefore
/// this permission is only valid if the input file
/// begins by such a line.
/// @since 1.3.2
/// bit1= Do not use media catalog string of session or ISRC
/// strings of tracks for writing to Q sub-channel.
/// @since 1.2.0
/// @return > 0 indicates success and the number of interpreted
/// blocks (1 if not flag bit0 is set).
/// <= 0 indicates failure
/// @since 1.2.0
pub fn burn_session_input_sheet_v07t(
session: *mut burn_session,
path: *mut ::std::os::raw::c_char,
block: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Produce an array of CD-TEXT packs that could be submitted to
/// burn_write_opts_set_leadin_text(), or stored as *.cdt file,
/// or submitted to burn_make_input_sheet_v07t().
/// For a description of the format of the array, see file doc/cdtext.txt.
/// The input data stem from burn_session_set_cdtext_par(),
/// burn_session_set_cdtext(), and burn_track_set_cdtext().
/// @param s Session from which to produce CD-TEXT packs.
/// @param text_packs Will return the buffer with the CD-TEXT packs.
/// Dispose by free() when no longer needed.
/// @param num_packs Will return the number of 18 byte text packs.
/// @param flag Bitfield for control purposes.
/// bit0= do not return generated CD-TEXT packs,
/// but check whether production would work and
/// indicate the number of packs by the call return
/// value. This happens also if
/// (text_packs == NULL || num_packs == NULL).
/// @return Without flag bit0: > 0 is success, <= 0 failure
/// With flag bit0: > 0 is number of packs,
/// 0 means no packs will be generated,
/// < 0 means failure
/// @since 1.2.0
pub fn burn_cdtext_from_session(
s: *mut burn_session,
text_packs: *mut *mut ::std::os::raw::c_uchar,
num_packs: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert an array of CD-TEXT packs into the text format of
/// Sony CD-TEXT Input Sheet Version 0.7T .
///
/// @param text_packs Array of bytes which form CD-TEXT packs of 18 bytes
/// each. For a description of the format of the array,
/// see file doc/cdtext.txt.
/// No header of 4 bytes must be prepended which would
/// tell the number of pack bytes + 2.
/// This parameter may be NULL if the currently attached
/// array of packs shall be removed.
/// @param num_packs The number of 18 byte packs in text_packs.
/// @param start_tno The start number of track counting, if known from
/// CD table-of-content or other sources.
/// Submit 0 to enable the attempt to read it and the
/// track_count from pack type 0x8f.
/// @param track_count The number of tracks, if known from CD table-of-content
/// or orther sources.
/// @param result Will return the buffer with Sheet text.
/// Dispose by free() when no longer needed.
/// It will be filled by the text for the v07t sheet file
/// plus a trailing 0-byte. (Be aware that double-byte
/// characters might contain 0-bytes, too.)
/// Each CD-TEXT language block starts by the line
/// \"Input Sheet Version = 0.7T\"
/// and a \"Remarks\" line that tells the block number.
/// @param char_code Returns the character code of the pack array:
/// 0x00 = ISO-8859-1
/// 0x01 = 7 bit ASCII
/// 0x80 = MS-JIS (japanese Kanji, double byte characters)
/// The presence of a code value that is not in this list
/// will cause this function to fail.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 tells the number of valid text bytes in result.
/// This does not include the trailing 0-byte.
/// <= 0 indicates failure.
/// @since 1.3.2
pub fn burn_make_input_sheet_v07t(
text_packs: *mut ::std::os::raw::c_uchar,
num_packs: ::std::os::raw::c_int,
start_tno: ::std::os::raw::c_int,
track_count: ::std::os::raw::c_int,
result: *mut *mut ::std::os::raw::c_char,
char_code: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove all CD-TEXT attributes of the given block from the session.
/// They were attached by burn_session_set_cdtext().
/// @param s Session where to remove the CD-TEXT attribute
/// @param block Number of the language block in which the attribute
/// shall appear. Possible values: 0 to 7.
/// -1 causes text packs of all blocks to be removed.
/// @return > 0 is success, <= 0 failure
/// @since 1.2.0
pub fn burn_session_dispose_cdtext(
s: *mut burn_session,
block: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read an array of CD-TEXT packs from a file. This array should be suitable
/// for burn_write_opts_set_leadin_text().
/// The function tolerates and removes 4-byte headers as produced by
/// cdrecord -vv -toc, if this header tells the correct number of bytes which
/// matches the file size. If no 4-byte header is present, then the function
/// tolerates and removes a trailing 0-byte as of Sony specs.
/// @param path Filesystem address of the CD-TEXT pack file.
/// Normally with suffix .cdt or .dat
/// @param text_packs Will return the buffer with the CD-TEXT packs.
/// Dispose by free() when no longer needed.
/// @param num_packs Will return the number of 18 byte text packs.
/// @param flag Bitfield for control purposes. Unused yet.Submit 0.
/// @return 0 is success, <= 0 failure
/// @since 1.2.0
pub fn burn_cdtext_from_packfile(
path: *mut ::std::os::raw::c_char,
text_packs: *mut *mut ::std::os::raw::c_uchar,
num_packs: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Define the data in a track
/// @param t the track to define
/// @param offset The lib will write this many 0s before start of data
/// @param tail The number of extra 0s to write after data
/// @param pad 1 means the lib should pad the last sector with 0s if the
/// track isn't exactly sector sized. (otherwise the lib will
/// begin reading from the next track)
/// @param mode data format (bitfield)
pub fn burn_track_define_data(
t: *mut burn_track,
offset: ::std::os::raw::c_int,
tail: ::std::os::raw::c_int,
pad: ::std::os::raw::c_int,
mode: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Attach text or binary data as CD-TEXT attributes to a track.
/// The payload will be used to generate CD-TEXT packs by
/// burn_cdtext_from_session() or to write CD-TEXT packs into the lead-in
/// of a CD SAO session. This happens if the CD-TEXT attribute of the session
/// gets generated, which has the same block number and pack type. In this
/// case, each track should have such a CD-TEXT attribute, too.
/// See burn_session_set_cdtext().
/// Be cautious not to exceed the maximum number of 253 payload packs per
/// language block. Use burn_cdtext_from_session() to learn whether a valid
/// array of CD-TEXT packs can be generated from your attributes.
/// @param t Track where to attach CD-TEXT attribute.
/// @param block Number of the language block in which the attribute
/// shall appear. Possible values: 0 to 7.
/// @param pack_type Pack type number. 0x80 to 0x85 or 0x8e. Used if
/// pack_type_name is NULL or empty text. Else submit 0
/// and a name.
/// @param pack_type_name The pack type by name. Applicable names are:
/// 0x80 = \"TITLE\" 0x81 = \"PERFORMER\"
/// 0x82 = \"SONGWRITER\" 0x83 = \"COMPOSER\"
/// 0x84 = \"ARRANGER\" 0x85 = \"MESSAGE\"
/// 0x8e = \"UPC_ISRC\"
/// @param payload 0-terminated cleartext. If double byte characters
/// are used, then two 0-bytes terminate the cleartext.
/// @param length Number of bytes in payload. Including terminating
/// 0-bytes.
/// @param flag Bitfield for control purposes.
/// bit0= payload contains double byte characters
/// (with character code 0x80 MS-JIS japanese Kanji)
/// @return > 0 indicates success , <= 0 is failure
/// @since 1.2.0
pub fn burn_track_set_cdtext(
t: *mut burn_track,
block: ::std::os::raw::c_int,
pack_type: ::std::os::raw::c_int,
pack_type_name: *mut ::std::os::raw::c_char,
payload: *mut ::std::os::raw::c_uchar,
length: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain a CD-TEXT attribute that was set by burn_track_set_cdtext().
/// @param t Track to inquire
/// @param block Number of the language block to inquire.
/// @param pack_type Pack type number to inquire. Used if pack_type_name
/// is NULL or empty text. Else submit 0 and a name.
/// @param pack_type_name The pack type by name.
/// See above burn_track_set_cdtext().
/// @param payload Will return a pointer to text bytes.
/// Not a copy of data. Do not free() this address.
/// If no text attribute is attached for pack type and
/// block, then payload is returned as NULL. The return
/// value will not indicate error in this case.
/// @param length Will return the number of bytes pointed to by payload.
/// Including terminating 0-bytes.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return 1=single byte char , 2= double byte char , <=0 error
/// @since 1.2.0
pub fn burn_track_get_cdtext(
t: *mut burn_track,
block: ::std::os::raw::c_int,
pack_type: ::std::os::raw::c_int,
pack_type_name: *mut ::std::os::raw::c_char,
payload: *mut *mut ::std::os::raw::c_uchar,
length: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove all CD-TEXT attributes of the given block from the track.
/// They were attached by burn_track_set_cdtext().
/// @param t Track where to remove the CD-TEXT attribute.
/// @param block Number of the language block in which the attribute
/// shall appear. Possible values: 0 to 7.
/// -1 causes text packs of all blocks to be removed.
/// @return > 0 is success, <= 0 failure
/// @since 1.2.0
pub fn burn_track_dispose_cdtext(
t: *mut burn_track,
block: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Activates CD XA compatibility modes.
/// libburn currently writes data only in CD mode 1. Some programs insist in
/// sending data with additional management bytes. These bytes have to be
/// stripped in order to make the input suitable for BURN_MODE1.
/// @param t The track to manipulate
/// @param value 0= no conversion
/// 1= strip 8 byte sector headers of CD-ROM XA mode 2 form 1
/// see MMC-5 4.2.3.8.5.3 Block Format for Mode 2 form 1 Data
/// all other values are reserved
/// @return 1=success , 0=unacceptable value
/// @since 0.7.2
pub fn burn_track_set_cdxa_conv(
t: *mut burn_track,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Set the ISRC details for a track. When writing to CD media, ISRC will get
/// written into the Q sub-channel.
/// @param t The track to change
/// @param country the 2 char country code. Each character must be
/// only numbers or letters.
/// @param owner 3 char owner code. Each character must be only numbers
/// or letters.
/// @param year 2 digit year. A number in 0-99 (Yep, not Y2K friendly).
/// @param serial 5 digit serial number. A number in 0-99999.
pub fn burn_track_set_isrc(
t: *mut burn_track,
country: *mut ::std::os::raw::c_char,
owner: *mut ::std::os::raw::c_char,
year: ::std::os::raw::c_uchar,
serial: ::std::os::raw::c_uint,
);
}
unsafe extern "C" {
/// Set the composed ISRC string for a track. This is an alternative to
/// burn_track_set_isrc().
/// @param t The track to be manipulated
/// @param isrc 12 characters which are composed from ISRC details.
/// Format is CCOOOYYSSSSS, terminated by a 0-byte:
/// Country, Owner, Year(decimal digits), Serial(decimal digits).
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 means failure
/// @since 1.2.0
pub fn burn_track_set_isrc_string(
t: *mut burn_track,
isrc: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Disable ISRC parameters for a track
/// @param t The track to change
pub fn burn_track_clear_isrc(t: *mut burn_track);
}
unsafe extern "C" {
/// Define an index start address within a track. The index numbers inside a
/// track have to form sequence starting at 0 or 1 with no gaps up to the
/// highest number used. They affect only writing of CD SAO sessions.
/// The first index start address of a track must be 0.
/// Blocks between index 0 and index 1 are considered to be located before the
/// track start as of the table-of-content.
/// @param t The track to be manipulated
/// @param index_number A number between 0 and 99
/// @param relative_lba The start address relative to the start of the
/// burn_source of the track. It will get mapped to the
/// appropriate absolute block address.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 means failure
/// @since 1.2.0
pub fn burn_track_set_index(
t: *mut burn_track,
index_number: ::std::os::raw::c_int,
relative_lba: ::std::os::raw::c_uint,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Remove all index start addresses and reset to the default indexing of
/// CD SAO sessions. This means index 0 of track 1 reaches from LBA -150
/// to LBA -1. Index 1 of track 1 reaches from LBA 0 to track end. Index 1
/// of track 2 follows immediately. The same happens for all further tracks
/// after the end of their predecessor.
/// @param t The track to be manipulated
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 means failure
/// @since 1.2.0
pub fn burn_track_clear_indice(
t: *mut burn_track,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Define whether a pre-gap shall be written before the track and how many
/// sectors this pre-gap shall have. A pre-gap is written in the range of track
/// index 0 and contains zeros (audio silence). No bytes from the track source
/// will be read for writing the pre-gap.
/// This setting affects only CD SAO write runs.
/// The first track automatically gets a pre-gap of at least 150 sectors. Its
/// size may be enlarged by this call. Further pre-gaps are demanded by MMC
/// for tracks which follow tracks of a different mode. (But Mode mixing in
/// CD SAO sessions is currently not supported by libburn.)
/// @param t The track to change
/// @param size Number of sectors in the pre-gap.
/// -1 disables pre-gap, except for the first track.
/// libburn allows 0, but MMC does not propose this.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 means failure
/// @since 1.2.0
pub fn burn_track_set_pregap_size(
t: *mut burn_track,
size: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Define whether a post-gap shall be written at the end of the track and
/// how many sectors this gap shall have. A post-gap occupies the range of
/// an additional index of the track. It contains zeros. No bytes from the
/// track source will be read for writing the post-gap.
/// This setting affects only CD SAO write runs.
/// MMC prescribes to add a post-gap to a data track which is followed by
/// a non-data track. (But libburn does not yet support mixed mode CD SAO
/// sessions.)
/// @param t The track to change
/// @param size Number of sectors in the post-gap.
/// -1 disables post-gap.
/// libburn allows 0, but MMC does not propose this.
/// @param flag Bitfield for control purposes. Unused yet. Submit 0.
/// @return > 0 indicates success, <= 0 means failure
/// @since 1.2.0
pub fn burn_track_set_postgap_size(
t: *mut burn_track,
size: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Define whether a track shall swap bytes of its input stream.
/// @param t The track to change
/// @param swap_source_bytes 0=do not swap, 1=swap byte pairs
/// @return 1=success , 0=unacceptable value
/// @since 0.2.6
pub fn burn_track_set_byte_swap(
t: *mut burn_track,
swap_source_bytes: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Hide the first track in the \"pre gap\" of the disc
/// @param s session to change
/// @param onoff 1 to enable hiding, 0 to disable
pub fn burn_session_hide_first_track(s: *mut burn_session, onoff: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Get the drive's disc struct - free when done
/// @param d drive to query
/// @return the disc struct or NULL on failure
pub fn burn_drive_get_disc(d: *mut burn_drive) -> *mut burn_disc;
}
unsafe extern "C" {
/// Set the track's data source
/// @param t The track to set the data source for
/// @param s The data source to use for the contents of the track
/// @return An error code stating if the source is ready for use for
/// writing the track, or if an error occurred
pub fn burn_track_set_source(t: *mut burn_track, s: *mut burn_source) -> burn_source_status;
}
unsafe extern "C" {
/// Set a default track size to be used only if the track turns out to be of
/// unpredictable length and if the effective write type demands a fixed size.
/// This can be useful to enable write types CD SAO or DVD DAO together with
/// a track source like stdin. If the track source delivers fewer bytes than
/// announced then the track will be padded up with zeros.
/// @param t The track to change
/// @param size The size to set
/// @return 0=failure 1=success
/// @since 0.3.4
pub fn burn_track_set_default_size(t: *mut burn_track, size: off_t) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Free a burn_source (decrease its refcount and maybe free it)
/// @param s Source to free
pub fn burn_source_free(s: *mut burn_source);
}
unsafe extern "C" {
/// Creates a data source for an image file (and maybe subcode file)
/// @param path The file address for the main channel payload.
/// @param subpath Eventual address for subchannel data. Only used in exotic
/// raw write modes. Submit NULL for normal tasks.
/// @return Pointer to a burn_source object, NULL indicates failure
pub fn burn_file_source_new(
path: *const ::std::os::raw::c_char,
subpath: *const ::std::os::raw::c_char,
) -> *mut burn_source;
}
unsafe extern "C" {
/// Opens a file with eventual acceleration preparations which may depend
/// on the operating system and on compile time options of libburn.
/// You may use this call instead of open(2) for opening file descriptors
/// which shall be handed to burn_fd_source_new().
/// This should only be done for tracks with BURN_BLOCK_MODE1 (2048 bytes
/// per block).
///
/// If you use this call then you MUST allocate the buffers which you use
/// with read(2) by call burn_os_alloc_buffer(). Read sizes MUST be a multiple
/// of a safe buffer amount. Else you risk that track data get altered during
/// transmission.
/// burn_disk_write() will allocate a suitable read/write buffer for its own
/// operations. A fifo created by burn_fifo_source_new() will allocate
/// suitable memory for its buffer if called with flag bit0 and a multiple
/// of a safe buffer amount.
/// @param path The file address to open
/// @param open_flags The flags as of man 2 open. Normally just O_RDONLY.
/// @param flag Bitfield for control purposes (unused yet, submit 0).
/// @return A file descriptor as of open(2). Finally to be disposed
/// by close(2).
/// -1 indicates failure.
/// @since 0.7.4
pub fn burn_os_open_track_src(
path: *mut ::std::os::raw::c_char,
open_flags: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Allocate a memory area that is suitable for reading with a file descriptor
/// opened by burn_os_open_track_src().
/// @param amount Number of bytes to allocate. This should be a multiple
/// of the operating system's i/o block size. 32 KB is
/// guaranteed by libburn to be safe.
/// @param flag Bitfield for control purposes (unused yet, submit 0).
/// @return The address of the allocated memory, or NULL on failure.
/// A non-NULL return value has finally to be disposed via
/// burn_os_free_buffer().
/// @since 0.7.4
pub fn burn_os_alloc_buffer(
amount: usize,
flag: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
/// Dispose a memory area which was obtained by burn_os_alloc_buffer(),
/// @param buffer Memory address to be freed.
/// @param amount The number of bytes which was allocated at that
/// address.
/// @param flag Bitfield for control purposes (unused yet, submit 0).
/// @return 1 success , <=0 failure
/// @since 0.7.4
pub fn burn_os_free_buffer(
buffer: *mut ::std::os::raw::c_void,
amount: usize,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Creates a data source for an image file (a track) from an open
/// readable filedescriptor, an eventually open readable subcodes file
/// descriptor and eventually a fixed size in bytes.
/// @param datafd The source of data.
/// @param subfd The eventual source of subchannel data. Only used in exotic
/// raw write modes. Submit -1 for normal tasks.
/// @param size The eventual fixed size of eventually both fds.
/// If this value is 0, the size will be determined from datafd.
/// @return Pointer to a burn_source object, NULL indicates failure
pub fn burn_fd_source_new(
datafd: ::std::os::raw::c_int,
subfd: ::std::os::raw::c_int,
size: off_t,
) -> *mut burn_source;
}
unsafe extern "C" {
/// Creates an offset source which shall provide a byte interval of a stream
/// to its consumer. It is supposed to be chain-linked with other offset
/// sources which serve neighboring consumers. The chronological sequence
/// of consumers and the sequence of offset sources must match. The intervals
/// of the sources must not overlap.
///
/// A chain of these burn_source objects may be used to feed multiple tracks
/// from one single stream of input bytes.
/// Each of the offset sources will skip the bytes up to its start address and
/// provide the prescribed number of bytes to the track. Skipping takes into
/// respect the bytes which have been processed by eventual predecessors in the
/// chain.
/// Important: It is not allowed to free an offset source before its successor
/// has ended its work. Best is to keep them all until all tracks
/// are done.
///
/// @param inp The burn_source object from which to read stream data.
/// E.g. created by burn_file_source_new().
/// @param prev The eventual offset source object which shall read data from
/// inp before the new offset source will begin its own work.
/// This must either be a result of burn_offst_source_new() or
/// it must be NULL.
/// @param start The byte address where to start reading bytes for the
/// consumer. inp bytes may get skipped to reach this address.
/// @param size The number of bytes to be delivered to the consumer.
/// If size is <= 0 then it may be set later by a call of method
/// set_size(). If it is >= 0, then it can only be changed if
/// flag bit0 was set with burn_offst_source_new().
/// @param flag Bitfield for control purposes
/// bit0 = Prevent set_size() from overriding interval sizes > 0.
/// If such a size is already set, then the new one will
/// only affect the reply of get_size().
/// See also above struct burn_source.
/// @since 1.2.0
/// @return Pointer to a burn_source object, later to be freed by
/// burn_source_free(). NULL indicates failure.
/// @since 0.8.8
pub fn burn_offst_source_new(
inp: *mut burn_source,
prev: *mut burn_source,
start: off_t,
size: off_t,
flag: ::std::os::raw::c_int,
) -> *mut burn_source;
}
unsafe extern "C" {
/// Creates a fifo which acts as proxy for an already existing data source.
/// The fifo provides a ring buffer which shall smoothen the data stream
/// between burn_source and writer thread. Each fifo serves only for one
/// data source. It may be attached to one track as its only data source
/// by burn_track_set_source(), or it may be used as input for other burn
/// sources.
/// A fifo starts its life in \"standby\" mode with no buffer space allocated.
/// As soon as its consumer requires bytes, the fifo establishes a worker
/// thread and allocates its buffer. After input has ended and all buffer
/// content is consumed, the buffer space gets freed and the worker thread
/// ends. This happens asynchronously. So expect two buffers and worker threads
/// to exist for a short time between tracks. Be modest in your size demands if
/// multiple tracks are to be expected.
/// @param inp The burn_source for which the fifo shall act as proxy.
/// It can be disposed by burn_source_free() immediately
/// after this call.
/// @param chunksize The size in bytes of a chunk.
/// Use 2048 for sources suitable for BURN_BLOCK_MODE1,
/// 2352 for sources which deliver for BURN_BLOCK_AUDIO,
/// 2056 for sources which shall get treated by
/// burn_track_set_cdxa_conv(track, 1).
/// Some variations of burn_source might work only with
/// a particular chunksize. E.g. libisofs demands 2048.
/// @param chunks The number of chunks to be allocated in ring buffer.
/// This value must be >= 2.
/// @param flag Bitfield for control purposes:
/// bit0= The read method of inp is capable of delivering
/// arbitrary amounts of data per call. Not only one
/// sector.
/// Suitable for inp from burn_file_source_new()
/// and burn_fd_source_new() if not the fd has
/// exotic limitations on read size.
/// You MUST use this on inp which uses an fd opened
/// with burn_os_open_track_src().
/// Better do not use with other inp types.
/// @since 0.7.4
/// @return A pointer to the newly created burn_source.
/// Later both burn_sources, inp and the returned fifo, have
/// to be disposed by calling burn_source_free() for each.
/// inp can be freed immediately, the returned fifo may be
/// kept as handle for burn_fifo_inquire_status().
/// @since 0.4.0
pub fn burn_fifo_source_new(
inp: *mut burn_source,
chunksize: ::std::os::raw::c_int,
chunks: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> *mut burn_source;
}
unsafe extern "C" {
/// Inquires state and fill parameters of a fifo burn_source which was created
/// by burn_fifo_source_new() . Do not use with other burn_source variants.
/// @param fifo The fifo object to inquire
/// @param size The total size of the fifo
/// @param free_bytes The current free capacity of the fifo
/// @param status_text Returns a pointer to a constant text, see below
/// @return <0 reply invalid, >=0 fifo status code:
/// bit0+1=input status, bit2=consumption status, i.e:
/// 0=\"standby\" : data processing not started yet
/// 1=\"active\" : input and consumption are active
/// 2=\"ending\" : input has ended without error
/// 3=\"failing\" : input had error and ended,
/// 4=\"unused\" : ( consumption has ended before processing start )
/// 5=\"abandoned\" : consumption has ended prematurely
/// 6=\"ended\" : consumption has ended without input error
/// 7=\"aborted\" : consumption has ended after input error
/// @since 0.4.0
pub fn burn_fifo_inquire_status(
fifo: *mut burn_source,
size: *mut ::std::os::raw::c_int,
free_bytes: *mut ::std::os::raw::c_int,
status_text: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire various counters which reflect the fifo operation.
/// @param fifo The fifo object to inquire
/// @param total_min_fill The minimum number of bytes in the fifo. Beginning
/// from the moment when fifo consumption is enabled.
/// @param interval_min_fill The minimum byte number beginning from the moment
/// when fifo consumption is enabled or from the
/// most recent moment when burn_fifo_next_interval()
/// was called.
/// @param put_counter The number of data transactions into the fifo.
/// @param get_counter The number of data transactions out of the fifo.
/// @param empty_counter The number of times the fifo was empty.
/// @param full_counter The number of times the fifo was full.
/// @since 0.7.4
pub fn burn_fifo_get_statistics(
fifo: *mut burn_source,
total_min_fill: *mut ::std::os::raw::c_int,
interval_min_fill: *mut ::std::os::raw::c_int,
put_counter: *mut ::std::os::raw::c_int,
get_counter: *mut ::std::os::raw::c_int,
empty_counter: *mut ::std::os::raw::c_int,
full_counter: *mut ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Inquire the fifo minimum fill counter for intervals and reset that counter.
/// @param fifo The fifo object to inquire
/// @param interval_min_fill The minimum number of bytes in the fifo. Beginning
/// from the moment when fifo consumption is enabled
/// or from the most recent moment when
/// burn_fifo_next_interval() was called.
/// @since 0.7.4
pub fn burn_fifo_next_interval(
fifo: *mut burn_source,
interval_min_fill: *mut ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Obtain a preview of the first input data of a fifo which was created
/// by burn_fifo_source_new(). The data will later be delivered normally to
/// the consumer track of the fifo.
/// bufsize may not be larger than the fifo size (chunk_size * chunks) - 32k.
/// This call will succeed only if data consumption by the track has not
/// started yet, i.e. best before the call to burn_disc_write().
/// It will start the worker thread of the fifo with the expectable side
/// effects on the external data source. Then it waits either until enough
/// data have arrived or until it becomes clear that this will not happen.
/// The call may be repeated with increased bufsize. It will always yield
/// the bytes beginning from the first one in the fifo.
/// @param fifo The fifo object to start and to inquire
/// @param buf Pointer to memory of at least bufsize bytes where to
/// deliver the peeked data.
/// @param bufsize Number of bytes to peek from the start of the fifo data
/// @param flag Bitfield for control purposes (unused yet, submit 0).
/// @return <0 on severe error, 0 if not enough data, 1 if bufsize bytes read
/// @since 0.5.0
pub fn burn_fifo_peek_data(
fifo: *mut burn_source,
buf: *mut ::std::os::raw::c_char,
bufsize: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Start the fifo worker thread and wait either until the requested number
/// of bytes have arrived or until it becomes clear that this will not happen.
/// Filling will go on asynchronously after burn_fifo_fill() returned.
/// This call and burn_fifo_peek_data() do not disturb each other.
/// @param fifo The fifo object to start
/// @param fill Number of bytes desired. Expect to get return 1 if
/// at least fifo size - 32k were read.
/// @param flag Bitfield for control purposes.
/// bit0= fill fifo to maximum size
/// @return <0 on severe error, 0 if not enough data,
/// 1 if desired amount or fifo full
/// @since 0.7.4
pub fn burn_fifo_fill(
fifo: *mut burn_source,
fill: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Sets a fixed track size after the data source object has already been
/// created.
/// @param t The track to operate on
/// @param size the number of bytes to use as track size
/// @return <=0 indicates failure , >0 success
/// @since 0.3.6
pub fn burn_track_set_size(t: *mut burn_track, size: off_t) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Tells how many sectors a track will have on disc, or already has on
/// disc. This includes offset, payload, tail, and post-gap, but not pre-gap.
/// The result is NOT RELIABLE with tracks of undefined length
pub fn burn_track_get_sectors(arg1: *mut burn_track) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Tells how many source bytes have been read and how many data bytes have
/// been written by the track during burn.
/// @param t The track to inquire
/// @param read_bytes Number of bytes read from the track source
/// @param written_bytes Number of bytes written to track
/// @since 0.2.6
pub fn burn_track_get_counters(
t: *mut burn_track,
read_bytes: *mut off_t,
written_bytes: *mut off_t,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Sets drive read and write speed.
/// Note: \"k\" is 1000, not 1024.
/// 1xCD = 176.4 k/s, 1xDVD = 1385 k/s, 1xBD = 4496 k/s.
/// Fractional speeds should be rounded up. Like 4xCD = 706.
/// @param d The drive to set speed for
/// @param read Read speed in k/s (0 is max, -1 is min).
/// @param write Write speed in k/s (0 is max, -1 is min).
pub fn burn_drive_set_speed(
d: *mut burn_drive,
read: ::std::os::raw::c_int,
write: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets drive read and write speed using the \"Exact\" bit of SCSI command
/// SET STREAMING. This command will be used even if a CD medium is present.
/// MMC specifies that with the Exact bit the desired speed settings shall
/// either be obeyed by the drive exactly, or that the drive shall indicate
/// failure and not accept the settings.
/// But many drives reply no error and nevertheless adjust their read speed
/// only coarsly or ignore the setting after a few MB of fast read attempts.
///
/// The call parameters have the same meaning as with burn_drive_set_speed().
/// @param d The drive to set speed for. It must be a role 1 drive.
/// @param read Read speed in k/s (0 is max, -1 is min).
/// @param write Write speed in k/s (0 is max, -1 is min).
/// @return 1=success , 0=failure
/// @since 1.5.4
pub fn burn_drive_set_speed_exact(
d: *mut burn_drive,
read: ::std::os::raw::c_int,
write: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Waits until the time has elapsed since the given previous time to transmit
/// the given byte count with the given speed in KB/second (KB = 1000 bytes).
/// This call may be used between random access read operations like
/// burn_read_data() in order to force a slower speed than the drive is
/// willing to use if it gets read requests as fast as it delivers data.
///
/// The parameter us_corr carries microseconds of time deviations from one
/// call to the next one. Such deviations may happen because of small
/// inexactnesses of the sleeper function and because of temporary delays
/// in the data supply so that sleeping for a negative time span would have
/// been necessary. The next call will reduce or enlarge its own sleeping
/// period by this value.
///
/// @param kb_per_second the desired speed in 1000 bytes per second.
/// Supplied by the caller.
/// @max_corr the maximum backlog in microseconds which shall
/// be compensated by the next call. Supplied by the
/// caller. Not more than 1 billion = 1000 seconds.
/// @param prev_time time keeper updated by burn_nominal_slowdown().
/// The caller provides the memory and elsewise should
/// carry it unchanged from call to call.
/// @param us_corr updated by burn_nominal_slowdown(). See above.
/// The caller provides the memory and elsewise should
/// carry it unchanged from call to call.
/// @param b_since_prev byte count since the previous call. This number
/// has to be counted and supplied by the caller.
/// @param flag Bitfield for control purposes:
/// bit0= initialize *prev_time and *us_corr,
/// ignore other parameters, do not wait
/// @return 2=no wait because no usable kb_per_second , 1=success , 0=failure
/// @since 1.5.4
pub fn burn_nominal_slowdown(
kb_per_second: ::std::os::raw::c_int,
max_corr: ::std::os::raw::c_int,
prev_time: *mut timeval,
us_corr: *mut ::std::os::raw::c_int,
b_since_prev: off_t,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Controls the behavior with writing when the drive buffer is suspected to
/// be full. To check and wait for enough free buffer space before writing
/// will move the task of waiting from the operating system's device driver
/// to libburn. While writing is going on and waiting is enabled, any write
/// operation will be checked whether it will fill the drive buffer up to
/// more than max_percent. If so, then waiting will happen until the buffer
/// fill is predicted with at most min_percent.
/// Thus: if min_percent < max_percent then transfer rate will oscillate.
/// This may allow the driver to operate on other devices, e.g. a disk from
/// which to read the input for writing. On the other hand, this checking might
/// reduce maximum throughput to the drive or even get misled by faulty buffer
/// fill replies from the drive.
/// If a setting parameter is < 0, then this setting will stay unchanged
/// by the call.
/// Known burner or media specific pitfalls:
/// To have max_percent larger than the burner's best reported buffer fill has
/// the same effect as min_percent==max_percent. Some burners do not report
/// their full buffer with all media types. Some are not suitable because
/// they report their buffer fill with delay. Some do not go to full speed
/// unless their buffer is full.
///
/// @param d The drive to control
/// @param enable 0= disable , 1= enable waiting , (-1 = do not change setting)
/// @param min_usec Shortest possible sleeping period (given in micro seconds)
/// @param max_usec Longest possible sleeping period (given in micro seconds)
/// @param timeout_sec If a single write has to wait longer than this number
/// of seconds, then waiting gets disabled and mindless
/// writing starts. A value of 0 disables this timeout.
/// @param min_percent Minimum of desired buffer oscillation: 25 to 100
/// @param max_percent Maximum of desired buffer oscillation: 25 to 100
/// @return 1=success , 0=failure
/// @since 0.3.8
pub fn burn_drive_set_buffer_waiting(
d: *mut burn_drive,
enable: ::std::os::raw::c_int,
min_usec: ::std::os::raw::c_int,
max_usec: ::std::os::raw::c_int,
timeout_sec: ::std::os::raw::c_int,
min_percent: ::std::os::raw::c_int,
max_percent: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Control the write simulation mode before or after burn_write_opts get
/// into effect.
/// Beginning with version 1.4.8 a burn run by burn_disc_write() brings the
/// burn_drive object in the simulation state as set to the burn_write_opts
/// by burn_write_opts_set_simulate(). This state is respected by call
/// burn_random_access_write() until a new call of burn_disc_write() happens
/// or until burn_drive_reset_simulate() is called.
/// This call may only be made when burn_drive_get_status() returns
/// BURN_DRIVE_IDLE.
///
/// @param d The drive to control
/// @param simulate 1 enables simulation, 0 enables real writing
/// @return 1=success , 0=failure
/// @since 1.4.8
pub fn burn_drive_reset_simulate(
d: *mut burn_drive,
simulate: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
pub fn burn_structure_print_disc(d: *mut burn_disc);
}
unsafe extern "C" {
pub fn burn_structure_print_session(s: *mut burn_session);
}
unsafe extern "C" {
pub fn burn_structure_print_track(t: *mut burn_track);
}
unsafe extern "C" {
/// Sets the write type for the write_opts struct.
/// Note: write_type BURN_WRITE_SAO is currently not capable of writing a mix
/// of data and audio tracks. You must use BURN_WRITE_TAO for such sessions.
/// @param opts The write opts to change
/// @param write_type The write type to use
/// @param block_type The block type to use
/// @return Returns 1 on success and 0 on failure.
pub fn burn_write_opts_set_write_type(
opts: *mut burn_write_opts,
write_type: burn_write_types,
block_type: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// As an alternative to burn_write_opts_set_write_type() this function tries
/// to find a suitable write type and block type for a given write job
/// described by opts and disc. To be used after all other setups have been
/// made, i.e. immediately before burn_disc_write().
/// @param opts The nearly complete write opts to change
/// @param disc The already composed session and track model
/// @param reasons This text string collects reasons for decision or failure
/// @param flag Bitfield for control purposes:
/// bit0= do not choose type but check the one that is already set
/// bit1= do not issue error messages via burn_msgs queue
/// (is automatically set with bit0)
/// @return Chosen write type. BURN_WRITE_NONE on failure.
/// @since 0.3.2
pub fn burn_write_opts_auto_write_type(
opts: *mut burn_write_opts,
disc: *mut burn_disc,
reasons: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> burn_write_types;
}
unsafe extern "C" {
/// Supplies toc entries for writing - not normally required for cd mastering
/// @param opts The write opts to change
/// @param count The number of entries
/// @param toc_entries
pub fn burn_write_opts_set_toc_entries(
opts: *mut burn_write_opts,
count: ::std::os::raw::c_int,
toc_entries: *mut burn_toc_entry,
);
}
unsafe extern "C" {
/// Sets the session format for a disc
/// @param opts The write opts to change
/// @param format The session format to set
pub fn burn_write_opts_set_format(opts: *mut burn_write_opts, format: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Sets the simulate value for the write_opts struct .
/// This corresponds to the Test Write bit in MMC mode page 05h. Several media
/// types do not support this. See struct burn_multi_caps.might_simulate for
/// actual availability of this feature.
/// If the media is suitable, the drive will perform burn_disc_write() as a
/// simulation instead of effective write operations. This means that the
/// media content and burn_disc_get_status() stay unchanged.
/// Note: With stdio-drives, the target file gets eventually created, opened,
/// lseeked, and closed, but not written. So there are effects on it.
/// Note: Up to version 1.4.6 the call burn_random_access_write() after
/// burn_disc_write() did not simulate because it does not get any
/// burn_write_opts and the drive did not memorize the simulation state.
/// This has changed now. burn_random_access_write() will not write after
/// a simulated burn run.
/// Use burn_drive_reset_simulate(drive, 0) if you really want to end
/// simulation before you call burn_disc_write() with new write options.
/// @param opts The write opts to change
/// @param sim Non-zero enables simulation, 0 enables real writing
/// @return Returns 1 on success and 0 on failure.
pub fn burn_write_opts_set_simulate(
opts: *mut burn_write_opts,
sim: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Controls buffer underrun prevention. This is only needed with CD media
/// and possibly with old DVD-R drives. All other media types are not
/// vulnerable to burn failure due to buffer underrun.
/// @param opts The write opts to change
/// @param underrun_proof if non-zero, buffer underrun protection is enabled
/// @return Returns 1 if the drive announces to be capable of underrun
/// prevention,
/// Returns 0 if not.
pub fn burn_write_opts_set_underrun_proof(
opts: *mut burn_write_opts,
underrun_proof: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Sets whether to use opc or not with the write_opts struct
/// @param opts The write opts to change
/// @param opc If non-zero, optical power calibration will be performed at
/// start of burn
pub fn burn_write_opts_set_perform_opc(opts: *mut burn_write_opts, opc: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// The Q sub-channel of a CD may contain a Media Catalog Number of 13 decimal
/// digits. This call sets the string of digits, but does not yet activate it
/// for writing.
/// @param opts The write opts to change
/// @param mediacatalog The 13 decimal digits as ASCII bytes. I.e. '0' = 0x30.
pub fn burn_write_opts_set_mediacatalog(
opts: *mut burn_write_opts,
mediacatalog: *mut ::std::os::raw::c_uchar,
);
}
unsafe extern "C" {
/// This call activates the Media Catalog Number for writing. The digits of
/// that number have to be set by call burn_write_opts_set_mediacatalog().
/// @param opts The write opts to change
/// @param has_mediacatalog 1= activate writing of catalog to Q sub-channel
/// 0= deactivate it
pub fn burn_write_opts_set_has_mediacatalog(
opts: *mut burn_write_opts,
has_mediacatalog: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets the multi flag which eventually marks the emerging session as not
/// being the last one and thus creating a BURN_DISC_APPENDABLE media.
/// Note: DVD-R[W] in write mode BURN_WRITE_SAO are not capable of this.
/// DVD-R DL are not capable of this at all.
/// libburn will refuse to write if burn_write_opts_set_multi() is
/// enabled under such conditions.
/// @param opts The option object to be manipulated
/// @param multi 1=media will be appendable, 0=media will be closed (default)
/// @since 0.2.6
pub fn burn_write_opts_set_multi(opts: *mut burn_write_opts, multi: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Set the severity to be used with write error messages which are potentially
/// caused by not using write type BURN_WRITE_SAO on fast blanked DVD-RW.
///
/// Normally the call burn_write_opts_auto_write_type() can prevent such
/// errors by looking for MMC feature 21h \"Incremental Streaming Writable\"
/// which anounnces the capability for BURN_WRITE_TAO and multi session.
/// Regrettable many drives announce feature 21h even if they only can do
/// BURN_WRITE_SAO. This mistake becomes obvious by an early write error.
///
/// If you plan to call burn_drive_was_feat21_failure() and to repeat the
/// burn attempt with BURN_WRITE_SAO, then set the severity of the error
/// message low enough, so that the application does not see reason to abort.
///
/// @param opts The option object to be manipulated
/// @param severity Severity as with burn_msgs_set_severities().
/// \"ALL\" or empty text means the default severity that
/// is attributed to other kinds of write errors.
pub fn burn_write_opts_set_fail21h_sev(
opts: *mut burn_write_opts,
severity: *mut ::std::os::raw::c_char,
);
}
unsafe extern "C" {
/// Submit an array of CD-TEXT packs which shall be written to the Lead-in
/// of a SAO write run on CD.
/// @param opts The option object to be manipulated
/// @param text_packs Array of bytes which form CD-TEXT packs of 18 bytes
/// each. For a description of the format of the array,
/// see file doc/cdtext.txt.
/// No header of 4 bytes must be prepended which would
/// tell the number of pack bytes + 2.
/// This parameter may be NULL if the currently attached
/// array of packs shall be removed.
/// @param num_packs The number of 18 byte packs in text_packs.
/// This parameter may be 0 if the currently attached
/// array of packs shall be removed.
/// @param flag Bitfield for control purposes.
/// bit0= do not verify checksums
/// bit1= repair mismatching checksums
/// bit2= repair checksums if they are 00 00 with each pack
/// @return 1 on success, <= 0 on failure
/// @since 1.2.0
pub fn burn_write_opts_set_leadin_text(
opts: *mut burn_write_opts,
text_packs: *mut ::std::os::raw::c_uchar,
num_packs: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Sets a start address for writing to media and write modes which are able
/// to choose this address at all (for now: DVD+RW, DVD-RAM, formatted DVD-RW).
/// now). The address is given in bytes. If it is not -1 then a write run
/// will fail if choice of start address is not supported or if the block
/// alignment of the address is not suitable for media and write mode.
/// Alignment to 32 kB blocks is supposed to be safe with DVD media.
/// Call burn_disc_get_multi_caps() can obtain the necessary media info. See
/// resulting struct burn_multi_caps elements .start_adr , .start_alignment ,
/// .start_range_low , .start_range_high .
/// @param opts The write opts to change
/// @param value The address in bytes (-1 = start at default address)
/// @since 0.3.0
pub fn burn_write_opts_set_start_byte(opts: *mut burn_write_opts, value: off_t);
}
unsafe extern "C" {
/// Caution: still immature and likely to change. Problems arose with
/// sequential DVD-RW on one drive.
///
/// Controls whether the whole available space of the media shall be filled up
/// by the last track of the last session.
/// @param opts The write opts to change
/// @param fill_up_media If 1 : fill up by last track, if 0 = do not fill up
/// @since 0.3.4
pub fn burn_write_opts_set_fillup(
opts: *mut burn_write_opts,
fill_up_media: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Lets libburn ignore the failure of some conformance checks:
/// - the check whether CD write+block type is supported by the drive
/// - the check whether the media profile supports simulated burning
/// - @since 1.5.6
/// The check whether a write operation exceeds the size of the medium
/// as announced by the drive. This is known as \"overburn\" and may work
/// for a few thousand additional blocks on CD media with write type SAO.
/// @param opts The write opts to change
/// @param use_force 1=ignore above checks, 0=refuse work on failed check
/// @since 0.3.4
pub fn burn_write_opts_set_force(opts: *mut burn_write_opts, use_force: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Eventually makes use of the more modern write command AAh WRITE12 and
/// sets the Streaming bit. With DVD-RAM and BD this can override the
/// traditional slowdown to half nominal speed. But if it speeds up writing
/// then it also disables error management and correction. Weigh your
/// priorities. This affects the write operations of burn_disc_write()
/// and subsequent calls of burn_random_access_write().
/// @param opts The write opts to change
/// @param value 0=use 2Ah WRITE10, 1=use AAh WRITE12 with Streaming bit
/// @since 0.6.4:
/// >=16 use WRITE12 but not before the LBA given by value
/// @since 0.4.6
pub fn burn_write_opts_set_stream_recording(
opts: *mut burn_write_opts,
value: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Overrides the write chunk size for DVD and BD media which is normally
/// determined according to media type and setting of stream recording.
/// A chunk size of 64 KB may improve throughput with bus systems which show
/// latency problems.
/// @param opts The write opts to change
/// @param obs Number of bytes which shall be sent by a single write command.
/// 0 means automatic size, 32768 and 65336 are the only other
/// accepted sizes for now.
/// @since 0.7.4
pub fn burn_write_opts_set_dvd_obs(opts: *mut burn_write_opts, obs: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Overrides the automatic decision whether to pad up the last write chunk to
/// its full size. This applies to DVD, BD and stdio: pseudo-drives.
/// Note: This override may get enabled fixely already at compile time by
/// defining macro Libburn_dvd_always_obs_paD .
/// @param opts The write opts to change
/// @param pad 1 means to pad up in any case, 0 means automatic decision.
/// @since 1.2.4
pub fn burn_write_opts_set_obs_pad(opts: *mut burn_write_opts, pad: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Exempts BD-R media from the elsewise unavoidable automatic padding of the
/// last write chunk to its full size.
/// Even if this exempt is granted it gets into effect only if stream recording
/// is disabled and burn_write_opts_set_obs_pad() is set to 0.
/// @param opts The write opts to change
/// @param value 1= possibly exempt BD-R from end chunk padding.
/// 0= always act on BD-R as if
/// burn_write_opts_set_obs_pad(opts, 1) is in effect.
/// @since 1.5.6
pub fn burn_write_opts_set_bdr_obs_exempt(
opts: *mut burn_write_opts,
value: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets the rhythm by which stdio pseudo drives force their output data to
/// be consumed by the receiving storage device. This forcing keeps the memory
/// from being clogged with lots of pending data for slow devices.
/// @param opts The write opts to change
/// @param rhythm Number of 2KB output blocks after which fsync(2) is
/// performed.
/// -1 means no fsync()
/// 0 means default
/// 1 means fsync() only at end, @since 1.3.8 (noop before 1.3.8)
/// elsewise the value must be >= 32.
/// Default is currently 8192 = 16 MB.
/// @since 0.7.4
pub fn burn_write_opts_set_stdio_fsync(
opts: *mut burn_write_opts,
rhythm: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets whether to read in raw mode or not
/// @param opts The read opts to change
/// @param raw_mode If non-zero, reading will be done in raw mode, so that everything in the data tracks on the
/// disc is read, including headers.
pub fn burn_read_opts_set_raw(opts: *mut burn_read_opts, raw_mode: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Sets whether to report c2 errors or not
/// @param opts The read opts to change
/// @param c2errors If non-zero, report c2 errors.
pub fn burn_read_opts_set_c2errors(opts: *mut burn_read_opts, c2errors: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Sets whether to read subcodes from audio tracks or not
/// @param opts The read opts to change
/// @param subcodes_audio If non-zero, read subcodes from audio tracks on the disc.
pub fn burn_read_opts_read_subcodes_audio(
opts: *mut burn_read_opts,
subcodes_audio: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets whether to read subcodes from data tracks or not
/// @param opts The read opts to change
/// @param subcodes_data If non-zero, read subcodes from data tracks on the disc.
pub fn burn_read_opts_read_subcodes_data(
opts: *mut burn_read_opts,
subcodes_data: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets whether to recover errors if possible
/// @param opts The read opts to change
/// @param hardware_error_recovery If non-zero, attempt to recover errors if possible.
pub fn burn_read_opts_set_hardware_error_recovery(
opts: *mut burn_read_opts,
hardware_error_recovery: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets whether to report recovered errors or not
/// @param opts The read opts to change
/// @param report_recovered_errors If non-zero, recovered errors will be reported.
pub fn burn_read_opts_report_recovered_errors(
opts: *mut burn_read_opts,
report_recovered_errors: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets whether blocks with unrecoverable errors should be read or not
/// @param opts The read opts to change
/// @param transfer_damaged_blocks If non-zero, blocks with unrecoverable errors will still be read.
pub fn burn_read_opts_transfer_damaged_blocks(
opts: *mut burn_read_opts,
transfer_damaged_blocks: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Sets the number of retries to attempt when trying to correct an error
/// @param opts The read opts to change
/// @param hardware_error_retries The number of retries to attempt when correcting an error.
pub fn burn_read_opts_set_hardware_error_retries(
opts: *mut burn_read_opts,
hardware_error_retries: ::std::os::raw::c_uchar,
);
}
unsafe extern "C" {
/// Gets the list of profile codes supported by the drive.
/// Profiles depict the feature sets which constitute media types. For
/// known profile codes and names see burn_disc_get_profile().
/// @param d is the drive to query
/// @param num_profiles returns the number of supported profiles
/// @param profiles returns the profile codes
/// @param is_current returns the status of the corresponding profile code:
/// 1= current, i.e. the matching media is loaded
/// 0= not current, i.e. the matching media is not loaded
/// @return always 1 for now
/// @since 0.7.0
pub fn burn_drive_get_all_profiles(
d: *mut burn_drive,
num_profiles: *mut ::std::os::raw::c_int,
profiles: *mut ::std::os::raw::c_int,
is_current: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtains the profile name associated with a profile code.
/// @param profile_code the profile code to be translated
/// @param name returns the profile name (e.g. \"DVD+RW\")
/// @return 1= known profile code , 0= unknown profile code
/// @since 0.7.0
pub fn burn_obtain_profile_name(
profile_code: ::std::os::raw::c_int,
name: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtains the list of SCSI Feature Codes from feature descriptors which
/// were obtained from the drive when it was most recently acquired or
/// re-assessed.
/// @param d Drive to query
/// @param count Returns the number of allocated elements in feature_codes
/// @param feature_codes Returns the allocated array of feature codes.
/// If returned *feature_codes is not NULL, dispose it
/// by free() when it is no longer needed.
/// @since 1.5.2
pub fn burn_drive_get_feature_codes(
d: *mut burn_drive,
count: *mut ::std::os::raw::c_int,
feature_codes: *mut *mut ::std::os::raw::c_uint,
);
}
unsafe extern "C" {
/// Obtains the fields and data of a particular feature which were obtained
/// from the drive when it was last acquired or re-assessed. See MMC specs
/// for full detail.
/// @param d Drive to query
/// @param feature_code A number as learned by burn_drive_get_feature_codes()
/// @param flags Returns byte 2 of the feature descriptor:
/// bit0= Current
/// bit1= Persistent
/// bit2-5= Version
/// @param additional_length Returns byte 3 of descriptor.
/// This is the size of feature_data.
/// @param feature_data Returns further bytes of descriptor.
/// If returned *feature_data is not NULL, dispose it
/// by free() when it is no longer needed.
/// @param feature_text Returns text representation of the feature descriptor:
/// Code +/- : Name : Version,P/N : Hex bytes : Parsed info
/// Current features are marked by \"+\", others by \"-\".
/// Persistent features are marked by \"P\", others by \"N\".
/// feature_text may be submitted as NULL. In this case
/// no text is generated and returned.
/// If returned *feature_text is not NULL, dispose it
/// by free() when it is no longer needed.
/// @return 0 feature descriptor is not present
/// -1 out of memory
/// >0 success
/// @since 1.5.2
pub fn burn_drive_get_feature(
d: *mut burn_drive,
feature_code: ::std::os::raw::c_uint,
flags: *mut ::std::os::raw::c_uchar,
additional_length: *mut ::std::os::raw::c_uchar,
feature_data: *mut *mut ::std::os::raw::c_uchar,
feature_text: *mut *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets the maximum write speed for a drive and eventually loaded media.
/// The return value might change by the media type of already loaded media,
/// again by call burn_drive_grab() and again by call burn_disc_read_atip().
/// @param d Drive to query
/// @return Maximum write speed in K/s
pub fn burn_drive_get_write_speed(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets the minimum write speed for a drive and eventually loaded media.
/// The return value might change by the media type of already loaded media,
/// again by call burn_drive_grab() and again by call burn_disc_read_atip().
/// @param d Drive to query
/// @return Minimum write speed in K/s
/// @since 0.2.6
pub fn burn_drive_get_min_write_speed(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets the maximum read speed for a drive
/// @param d Drive to query
/// @return Maximum read speed in K/s
pub fn burn_drive_get_read_speed(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain a copy of the current speed descriptor list. The drive's list gets
/// updated on various occasions such as burn_drive_grab() but the copy
/// obtained here stays untouched. It has to be disposed via
/// burn_drive_free_speedlist() when it is not longer needed. Speeds
/// may appear several times in the list. The list content depends much on
/// drive and media type. It seems that .source == 1 applies mostly to CD media
/// whereas .source == 2 applies to any media.
/// @param d Drive to query
/// @param speed_list The copy. If empty, *speed_list gets returned as NULL.
/// @return 1=success , 0=list empty , <0 severe error
/// @since 0.3.0
pub fn burn_drive_get_speedlist(
d: *mut burn_drive,
speed_list: *mut *mut burn_speed_descriptor,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Look up the fastest speed descriptor which is not faster than the given
/// speed_goal. If it is 0, then the fastest one is chosen among the
/// descriptors with the highest end_lba. If it is -1 then the slowest speed
/// descriptor is chosen regardless of end_lba. Parameter flag decides whether
/// the speed goal means write speed or read speed.
/// @param d Drive to query
/// @param speed_goal Upper limit for speed,
/// 0=search for maximum speed , -1 search for minimum speed
/// @param best_descr Result of the search, NULL if no match
/// @param flag Bitfield for control purposes
/// bit0= look for best read speed rather than write speed
/// bit1= look for any source type (else look for source==2 first
/// and for any other source type only with CD media)
/// @return >0 indicates a valid best_descr, 0 = no valid best_descr
/// @since 0.3.8
pub fn burn_drive_get_best_speed(
d: *mut burn_drive,
speed_goal: ::std::os::raw::c_int,
best_descr: *mut *mut burn_speed_descriptor,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Dispose a speed descriptor list copy which was obtained by
/// burn_drive_get_speedlist().
/// @param speed_list The list copy. *speed_list gets set to NULL.
/// @return 1=list disposed , 0= *speedlist was already NULL
/// @since 0.3.0
pub fn burn_drive_free_speedlist(
speed_list: *mut *mut burn_speed_descriptor,
) -> ::std::os::raw::c_int;
}
/// The reply structure for burn_disc_get_multi_caps()
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct burn_multi_caps {
pub multi_session: ::std::os::raw::c_int,
pub multi_track: ::std::os::raw::c_int,
pub start_adr: ::std::os::raw::c_int,
/// The alignment for start addresses.
/// ( start_address % start_alignment ) must be 0.
pub start_alignment: off_t,
/// The lowest permissible start address.
pub start_range_low: off_t,
/// The highest addressable start address.
pub start_range_high: off_t,
/// Potential availability of write modes
/// 4= needs no size prediction, not to be chosen automatically
/// 3= needs size prediction, not to be chosen automatically
/// 2= available, no size prediction necessary
/// 1= available, needs exact size prediction
/// 0= not available
/// With CD media (profiles 0x09 and 0x0a) check also the elements
/// _block_types of the according write mode.
pub might_do_tao: ::std::os::raw::c_int,
pub might_do_sao: ::std::os::raw::c_int,
pub might_do_raw: ::std::os::raw::c_int,
/// Generally advised write mode.
/// Not necessarily the one chosen by burn_write_opts_auto_write_type()
/// because the burn_disc structure might impose particular demands.
pub advised_write_mode: burn_write_types,
/// Write mode as given by parameter wt of burn_disc_get_multi_caps().
pub selected_write_mode: burn_write_types,
/// Profile number which was current when the reply was generated
pub current_profile: ::std::os::raw::c_int,
/// Whether the current profile indicates CD media. 1=yes, 0=no
pub current_is_cd_profile: ::std::os::raw::c_int,
/// Whether the current profile is able to perform simulated write
pub might_simulate: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
["Size of burn_multi_caps"][::std::mem::size_of::<burn_multi_caps>() - 72usize];
["Alignment of burn_multi_caps"][::std::mem::align_of::<burn_multi_caps>() - 8usize];
["Offset of field: burn_multi_caps::multi_session"]
[::std::mem::offset_of!(burn_multi_caps, multi_session) - 0usize];
["Offset of field: burn_multi_caps::multi_track"]
[::std::mem::offset_of!(burn_multi_caps, multi_track) - 4usize];
["Offset of field: burn_multi_caps::start_adr"]
[::std::mem::offset_of!(burn_multi_caps, start_adr) - 8usize];
["Offset of field: burn_multi_caps::start_alignment"]
[::std::mem::offset_of!(burn_multi_caps, start_alignment) - 16usize];
["Offset of field: burn_multi_caps::start_range_low"]
[::std::mem::offset_of!(burn_multi_caps, start_range_low) - 24usize];
["Offset of field: burn_multi_caps::start_range_high"]
[::std::mem::offset_of!(burn_multi_caps, start_range_high) - 32usize];
["Offset of field: burn_multi_caps::might_do_tao"]
[::std::mem::offset_of!(burn_multi_caps, might_do_tao) - 40usize];
["Offset of field: burn_multi_caps::might_do_sao"]
[::std::mem::offset_of!(burn_multi_caps, might_do_sao) - 44usize];
["Offset of field: burn_multi_caps::might_do_raw"]
[::std::mem::offset_of!(burn_multi_caps, might_do_raw) - 48usize];
["Offset of field: burn_multi_caps::advised_write_mode"]
[::std::mem::offset_of!(burn_multi_caps, advised_write_mode) - 52usize];
["Offset of field: burn_multi_caps::selected_write_mode"]
[::std::mem::offset_of!(burn_multi_caps, selected_write_mode) - 56usize];
["Offset of field: burn_multi_caps::current_profile"]
[::std::mem::offset_of!(burn_multi_caps, current_profile) - 60usize];
["Offset of field: burn_multi_caps::current_is_cd_profile"]
[::std::mem::offset_of!(burn_multi_caps, current_is_cd_profile) - 64usize];
["Offset of field: burn_multi_caps::might_simulate"]
[::std::mem::offset_of!(burn_multi_caps, might_simulate) - 68usize];
};
unsafe extern "C" {
/// Allocates a struct burn_multi_caps (see above) and fills it with values
/// which are appropriate for the drive and the loaded media. The drive
/// must be grabbed for this call. The returned structure has to be disposed
/// via burn_disc_free_multi_caps() when no longer needed.
/// @param d The drive to inquire
/// @param wt With BURN_WRITE_NONE the best capabilities of all write modes
/// get returned. If set to a write mode like BURN_WRITE_SAO the
/// capabilities with that particular mode are returned and the
/// return value is 0 if the desired mode is not possible.
/// @param caps returns the info structure
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return < 0 : error , 0 : writing seems impossible , 1 : writing possible
/// @since 0.3.2
pub fn burn_disc_get_multi_caps(
d: *mut burn_drive,
wt: burn_write_types,
caps: *mut *mut burn_multi_caps,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Removes from memory a multi session info structure which was returned by
/// burn_disc_get_multi_caps(). The pointer *caps gets set to NULL.
/// @param caps the info structure to dispose (note: pointer to pointer)
/// @return 0 : *caps was already NULL, 1 : memory object was disposed
/// @since 0.3.2
pub fn burn_disc_free_multi_caps(caps: *mut *mut burn_multi_caps) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets a copy of the toc_entry structure associated with a track
/// @param t Track to get the entry from
/// @param entry Struct for the library to fill out
pub fn burn_track_get_entry(t: *mut burn_track, entry: *mut burn_toc_entry);
}
unsafe extern "C" {
/// Gets a copy of the toc_entry structure associated with a session's lead out
/// @param s Session to get the entry from
/// @param entry Struct for the library to fill out
pub fn burn_session_get_leadout_entry(s: *mut burn_session, entry: *mut burn_toc_entry);
}
unsafe extern "C" {
/// Gets an array of all complete sessions for the disc
/// THIS IS NO LONGER VALID AFTER YOU ADD OR REMOVE A SESSION
/// The result array contains *num + burn_disc_get_incomplete_sessions()
/// elements. All above *num are incomplete sessions.
/// Typically there is at most one incomplete session with one empty track.
/// DVD+R and BD-R seem support more than one track with even readable data.
/// @param d Disc to get session array for
/// @param num Returns the number of sessions in the array
/// @return array of sessions
pub fn burn_disc_get_sessions(
d: *mut burn_disc,
num: *mut ::std::os::raw::c_int,
) -> *mut *mut burn_session;
}
unsafe extern "C" {
/// Obtains the number of incomplete sessions which are recorded in the
/// result array of burn_disc_get_sessions() after the complete sessions.
/// See above.
/// @param d Disc object to inquire
/// @return Number of incomplete sessions
pub fn burn_disc_get_incomplete_sessions(d: *mut burn_disc) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
pub fn burn_disc_get_sectors(d: *mut burn_disc) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets an array of all the tracks for a session
/// THIS IS NO LONGER VALID AFTER YOU ADD OR REMOVE A TRACK
/// @param s session to get track array for
/// @param num Returns the number of tracks in the array
/// @return array of tracks
pub fn burn_session_get_tracks(
s: *mut burn_session,
num: *mut ::std::os::raw::c_int,
) -> *mut *mut burn_track;
}
unsafe extern "C" {
pub fn burn_session_get_sectors(s: *mut burn_session) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Gets the mode of a track
/// @param track the track to query
/// @return the track's mode
pub fn burn_track_get_mode(track: *mut burn_track) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns whether the first track of a session is hidden in the pregap
/// @param session the session to query
/// @return non-zero means the first track is hidden
pub fn burn_session_get_hidefirst(session: *mut burn_session) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Returns the library's version in its parts.
/// This is the runtime counterpart of the three build time macros
/// burn_header_version_* below.
/// @param major The major version number
/// @param minor The minor version number
/// @param micro The micro version number
pub fn burn_version(
major: *mut ::std::os::raw::c_int,
minor: *mut ::std::os::raw::c_int,
micro: *mut ::std::os::raw::c_int,
);
}
unsafe extern "C" {
/// Obtain the id string of the SCSI transport interface.
/// This interface may be a system specific adapter module of libburn or
/// an adapter to a supporting library like libcdio.
/// @param flag Bitfield for control puposes, submit 0 for now
/// @return A pointer to the id string. Do not alter the string content.
/// @since 0.7.6
pub fn burn_scsi_transport_id(flag: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
/// Control queueing and stderr printing of messages from libburn.
/// Severity may be one of \"NEVER\", \"ABORT\", \"FATAL\", \"FAILURE\", \"SORRY\",
/// \"WARNING\", \"HINT\", \"NOTE\", \"UPDATE\", \"DEBUG\", \"ALL\".
/// @param queue_severity Gives the minimum limit for messages to be queued.
/// Default: \"NEVER\". If you queue messages then you
/// must consume them by burn_msgs_obtain().
/// @param print_severity Does the same for messages to be printed directly
/// to stderr. Default: \"FATAL\".
/// @param print_id A text prefix to be printed before the message.
/// @return >0 for success, <=0 for error
/// @since 0.2.6
pub fn burn_msgs_set_severities(
queue_severity: *mut ::std::os::raw::c_char,
print_severity: *mut ::std::os::raw::c_char,
print_id: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain the oldest pending libburn message from the queue which has at
/// least the given minimum_severity. This message and any older message of
/// lower severity will get discarded from the queue and is then lost forever.
/// @param minimum_severity may be one of \"NEVER\", \"ABORT\", \"FATAL\",
/// \"FAILURE\", \"SORRY\", \"WARNING\", \"HINT\", \"NOTE\", \"UPDATE\",
/// \"DEBUG\", \"ALL\".
/// To call with minimum_severity \"NEVER\" will discard the
/// whole queue.
/// @param error_code Will become a unique error code as listed in
/// libburn/libdax_msgs.h
/// @param msg_text Must provide at least BURN_MSGS_MESSAGE_LEN bytes.
/// @param os_errno Will become the eventual errno related to the message
/// @param severity Will become the severity related to the message and
/// should provide at least 80 bytes.
/// @return 1 if a matching item was found, 0 if not, <0 for severe errors
/// @since 0.2.6
pub fn burn_msgs_obtain(
minimum_severity: *mut ::std::os::raw::c_char,
error_code: *mut ::std::os::raw::c_int,
msg_text: *mut ::std::os::raw::c_char,
os_errno: *mut ::std::os::raw::c_int,
severity: *mut ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Submit a message to the libburn queueing system. It will be queued or
/// printed as if it was generated by libburn itself.
/// @param error_code The unique error code of your message.
/// Submit 0 if you do not have reserved error codes within
/// the libburnia project.
/// @param msg_text Not more than BURN_MSGS_MESSAGE_LEN characters of
/// message text.
/// @param os_errno Eventual errno related to the message. Submit 0 if
/// the message is not related to a operating system error.
/// @param severity One of \"ABORT\", \"FATAL\", \"FAILURE\", \"SORRY\", \"WARNING\",
/// \"HINT\", \"NOTE\", \"UPDATE\", \"DEBUG\". Defaults to \"FATAL\".
/// @param d An eventual drive to which the message shall be related.
/// Submit NULL if the message is not specific to a
/// particular drive object.
/// @return 1 if message was delivered, <=0 if failure
/// @since 0.4.0
pub fn burn_msgs_submit(
error_code: ::std::os::raw::c_int,
msg_text: *mut ::std::os::raw::c_char,
os_errno: ::std::os::raw::c_int,
severity: *mut ::std::os::raw::c_char,
d: *mut burn_drive,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert a severity name into a severity number, which gives the severity
/// rank of the name.
/// @param severity_name A name as with burn_msgs_submit(), e.g. \"SORRY\".
/// @param severity_number The rank number: the higher, the more severe.
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return >0 success, <=0 failure
/// @since 0.4.0
pub fn burn_text_to_sev(
severity_name: *mut ::std::os::raw::c_char,
severity_number: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Convert a severity number into a severity name
/// @param severity_number The rank number: the higher, the more severe.
/// @param severity_name A name as with burn_msgs_submit(), e.g. \"SORRY\".
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return >0 success, <=0 failure
/// @since 0.4.4
pub fn burn_sev_to_text(
severity_number: ::std::os::raw::c_int,
severity_name: *mut *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Return a blank separated list of severity names. Sorted from low
/// to high severity.
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return A constant string with the severity names
/// @since 1.2.6
pub fn burn_list_sev_texts(flag: ::std::os::raw::c_int) -> *mut ::std::os::raw::c_char;
}
unsafe extern "C" {
/// Replace the messenger object handle of libburn by a compatible handle
/// obtained from a related library.
/// See also: libisofs, API function iso_get_messenger().
/// @param messenger The foreign but compatible message handle.
/// @return 1 : success, <=0 : failure
/// @since 0.4.0
pub fn burn_set_messenger(messenger: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
/// The prototype of a handler function suitable for burn_set_signal_handling()
/// Such a function has to return -2 if it does not want the process to
/// exit with value 1.
pub type burn_abort_handler_t = ::std::option::Option<
unsafe extern "C" fn(
handle: *mut ::std::os::raw::c_void,
signum: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int,
>;
unsafe extern "C" {
/// Control built-in signal handling. Either by setting an own handler or
/// by activating the built-in signal handler.
///
/// A function parameter handle of NULL activates the built-in abort handler.
/// Depending on mode it may cancel all drive operations, wait for all drives
/// to become idle, exit(1). It may also prepare function
/// burn_drive_get_status() for waiting and performing exit(1).
/// Parameter handle may be NULL or a text that shall be used as prefix for
/// pacifier messages of burn_abort_pacifier(). Other than with an application
/// provided handler, the prefix char array does not have to be kept existing
/// until the eventual signal event.
/// Before version 0.7.8 only action 0 was available. I.e. the built-in handler
/// waited for the drives to become idle and then performed exit(1) directly.
/// But during burn_disc_write() onto real CD or DVD, FreeBSD 8.0 pauses the
/// other threads until the signal handler returns.
/// The new actions try to avoid this deadlock. It is advised to use action 3
/// at least during burn_disc_write(), burn_disc_erase(), burn_disc_format():
/// burn_set_signal_handling(text, NULL, 0x30);
/// and to call burn_is_aborting(0) when the drive is BURN_DRIVE_IDLE.
/// If burn_is_aborting(0) returns 1, then call burn_abort() and exit(1).
///
/// @param handle Opaque handle eventually pointing to an application
/// provided memory object
/// @param handler A function to be called on signals, if the handling bits
/// in parameter mode are set 0.
/// It will get parameter handle as argument. flag will be 0.
/// It should finally call burn_abort(). See there.
/// If the handler function returns 2 or -2, then the wrapping
/// signal handler of libburn will return and let the program
/// continue its operations. Any other return value causes
/// exit(1).
/// @param mode : bit0 - bit3: Handling of received signals:
/// 0 Install libburn wrapping signal handler, which will call
/// handler(handle, signum, 0) on nearly all signals
/// 1 Enable system default reaction on all signals
/// 2 Try to ignore nearly all signals
/// 10 like mode 2 but handle SIGABRT like with mode 0
/// bit4 - bit7: With handler == NULL :
/// Action of built-in handler. \"control thread\" is the one
/// which called burn_set_signal_handling().
/// All actions activate receive mode 2 to ignore further
/// signals.
/// 0 Same as 1 (for pre-0.7.8 backward compatibility)
/// @since 0.7.8
/// 1 Catch the control thread in abort handler, call
/// burn_abort() with a patience value > 0 and
/// finally exit(1). Does not always work with FreeBSD.
/// 2 Call burn_abort() with patience -1 and return from
/// handler. When the control thread calls
/// burn_drive_get_status(), then call burn_abort()
/// with patience 1 instead, and finally exit(1).
/// Does not always work with FreeBSD.
/// 3 Call burn_abort() with patience -1, return from handler.
/// It is duty of the application to detect a pending abort
/// condition by calling burn_is_aborting() and to wait for
/// all drives to become idle. E.g. by calling burn_abort()
/// with patience >0.
/// 4 Like 3, but without calling burn_abort() with -1. Only
/// the indicator of burn_is_aborting() gets set.
/// bit8: @since 1.3.2
/// try to ignore SIGPIPE (regardless of bit0 - bit3)
///
/// @since 0.2.6
pub fn burn_set_signal_handling(
handle: *mut ::std::os::raw::c_void,
handler: burn_abort_handler_t,
mode: ::std::os::raw::c_int,
);
}
unsafe extern "C" {
pub fn burn_is_aborting(flag: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Write data in random access mode.
/// The drive must be grabbed successfully before calling this function which
/// circumvents usual libburn session processing and rather writes data without
/// preparations or finalizing. This will work only with overwritable media
/// which are also suitable for burn_write_opts_set_start_byte(). The same
/// address alignment restrictions as with this function apply. I.e. for DVD
/// it is best to align to 32 KiB blocks (= 16 LBA units). The amount of data
/// to be written is subject to the same media dependent alignment rules.
/// Again, 32 KiB is most safe.
/// Call burn_disc_get_multi_caps() can obtain the necessary media info. See
/// resulting struct burn_multi_caps elements .start_adr , .start_alignment ,
/// .start_range_low , .start_range_high .
/// Other than burn_disc_write() this is a synchronous call which returns
/// only after the write transaction has ended (successfully or not). So it is
/// wise not to transfer giant amounts of data in a single call.
/// Important: Data have to fit into the already formatted area of the media.
///
/// If the burn_drive object is in simulation mode, then no actual write
/// operation or synchronization of the drive buffer will happen.
/// See burn_drive_reset_simulate().
///
/// @param d The drive to which to write
/// @param byte_address The start address of the write in byte
/// (1 LBA unit = 2048 bytes) (do respect media alignment)
/// @param data The bytes to be written
/// @param data_count The number of those bytes (do respect media alignment)
/// data_count == 0 is permitted (e.g. to flush the
/// drive buffer without further data transfer).
/// @param flag Bitfield for control purposes:
/// bit0 = flush the drive buffer after eventual writing
/// @return 1=successful , <=0 : number of transferred bytes * -1
/// @since 0.4.0
pub fn burn_random_access_write(
d: *mut burn_drive,
byte_address: off_t,
data: *mut ::std::os::raw::c_char,
data_count: off_t,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire the maximum amount of readable data.
/// On DVD and BD it is supposed that all LBAs in the range from 0 to
/// capacity - 1 can be read via burn_read_data() although some of them may
/// never have been recorded. With multi-session CD there have to be
/// expected unreadable TAO Run-out blocks.
/// If tracks are recognizable then it is better to only read LBAs which
/// are part of some track and on CD to be cautious about the last two blocks
/// of each track which might be TAO Run-out blocks.
/// If the drive is actually a large file or block device, then the capacity
/// is curbed to a maximum of 0x7ffffff0 blocks = 4 TB - 32 KB.
/// @param d The drive from which to read
/// @param capacity Will return the result if valid
/// @param flag Bitfield for control purposes: Unused yet, submit 0.
/// @return 1=successful , <=0 an error occurred
/// @since 0.6.0
pub fn burn_get_read_capacity(
d: *mut burn_drive,
capacity: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read data in random access mode.
/// The drive must be grabbed successfully before calling this function.
/// With all currently supported drives and media the byte_address has to
/// be aligned to 2048 bytes. Only data tracks with 2048 bytes per sector
/// can be read this way. I.e. not CD-audio, not CD-video-stream ...
/// This is a synchronous call which returns only after the full read job
/// has ended (successfully or not). So it is wise not to read giant amounts
/// of data in a single call.
/// @param d The drive from which to read
/// @param byte_address The start address of the read in byte (aligned to 2048)
/// @param data A memory buffer capable of taking data_size bytes
/// @param data_size The amount of data to be read. This does not have to
/// be aligned to any block size.
/// @param data_count The amount of data actually read (interesting on error)
/// The counted bytes are supposed to be valid.
/// @param flag Bitfield for control purposes:
/// bit0= - reserved -
/// bit1= do not submit error message if read error
/// bit2= on error do not try to read a second time
/// with single block steps.
/// @since 0.5.2
/// bit3= return -2 on permission denied error rather than
/// issuing a warning message.
/// @since 1.0.6
/// bit4= return -3 on SCSI error
/// 5 64 00 ILLEGAL MODE FOR THIS TRACK
/// and prevent this error from being reported as
/// event message. Do not retry reading in this case.
/// (Useful to try the last two blocks of a CD
/// track which might be non-data because of TAO.)
/// @since 1.2.6
/// bit5= issue messages with severity DEBUG if they would
/// be suppressed by bit1.
/// @since 1.4.0
/// @return 1=successful , <=0 an error occurred
/// with bit3: -2= permission denied error
/// @since 0.4.0
pub fn burn_read_data(
d: *mut burn_drive,
byte_address: off_t,
data: *mut ::std::os::raw::c_char,
data_size: off_t,
data_count: *mut off_t,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Read CD audio sectors in random access mode.
/// The drive must be grabbed successfully before calling this function.
/// Only CD audio tracks with 2352 bytes per sector can be read this way.
/// I.e. not data tracks, not CD-video-stream, ...
///
/// Note that audio data do not have exact block addressing. If you read a
/// sequence of successive blocks then you will get a seamless stream
/// of data. But the actual start and end position of this audio stream
/// will differ by a few dozens of milliseconds, depending on individual
/// CD and individual drive.
/// Expect leading and trailing zeros, as well as slight truncation.
///
/// @param d The drive from which to read.
/// It must be a real MMC drive (i.e. not a stdio file)
/// and it must have a CD loaded (i.e. not DVD or BD).
/// @param sector_no The sector number (Logical Block Address)
/// It may be slightly below 0, depending on drive and
/// medium. -150 is a lower limit.
/// @param data A memory buffer capable of taking data_size bytes
/// @param data_size The amount of data to be read. This must be aligned
/// to full multiples of 2352.
/// @param data_count The amount of data actually read (interesting on error)
/// @param flag Bitfield for control purposes:
/// bit0= - reserved -
/// bit1= do not submit error message if read error
/// bit2= on error do not try to read a second time
/// with single block steps.
/// bit3= Enable DAP : \"flaw obscuring mechanisms like
/// audio data mute and interpolate\"
/// bit4= return -3 on SCSI error
/// 5 64 00 ILLEGAL MODE FOR THIS TRACK
/// and prevent this error from being reported as
/// event message. Do not retry reading in this case.
/// (Useful to try the last two blocks of a CD
/// track which might be non-audio because of TAO.)
/// bit5= issue messages with severity DEBUG if they would
/// be suppressed by bit1.
/// @since 1.4.0
/// @return 1=successful , <=0 an error occurred
/// with bit3: -2= permission denied error
/// @since 1.2.6
pub fn burn_read_audio(
d: *mut burn_drive,
sector_no: ::std::os::raw::c_int,
data: *mut ::std::os::raw::c_char,
data_size: off_t,
data_count: *mut off_t,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Extract an interval of audio sectors from CD and store it as a WAVE
/// audio file on hard disk.
///
/// @param drive The drive from which to read.
/// @param start_sector The logical block address of the first audio sector
/// which shall be read.
/// @param sector_count The number of audio sectors to be read.
/// Each sector consists of 2352 bytes.
/// @param target_path The address of the file where to store the extracted
/// audio data. Will be opened O_WRONLY | O_CREAT.
/// The file name should have suffix \".wav\".
/// @param flag Bitfield for control purposes:
/// bit0= Report about progress by UPDATE messages
/// bit3= Enable DAP : \"flaw obscuring mechanisms like
/// audio data mute and interpolate\"
/// @since 1.3.2
pub fn burn_drive_extract_audio(
drive: *mut burn_drive,
start_sector: ::std::os::raw::c_int,
sector_count: ::std::os::raw::c_int,
target_path: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Extract all audio sectors of a track from CD and store them as a WAVE
/// audio file on hard disk.
///
/// @param drive The drive from which to read.
/// @param track The track which shall be extracted.
/// @param target_path The address of the file where to store the extracted
/// audio data. Will be opened O_WRONLY | O_CREAT.
/// The file name should have suffix \".wav\".
/// @param flag Bitfield for control purposes:
/// bit0= Report about progress by UPDATE messages
/// bit3= Enable DAP : \"flaw obscuring mechanisms like
/// audio data mute and interpolate\"
/// @since 1.3.2
pub fn burn_drive_extract_audio_track(
drive: *mut burn_drive,
track: *mut burn_track,
target_path: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Inquire whether the drive object is a real MMC drive or a pseudo-drive
/// created by a stdio: address.
/// @param d The drive to inquire
/// @return 0= null-drive
/// 1= real MMC drive
/// 2= stdio-drive, random access, read-write
/// 3= stdio-drive, sequential, write-only
/// 4= stdio-drive, random access, read-only
/// (only if enabled by burn_allow_drive_role_4())
/// 5= stdio-drive, random access, write-only
/// (only if enabled by burn_allow_drive_role_4())
/// @since 0.4.0
pub fn burn_drive_get_drive_role(d: *mut burn_drive) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Allow drive role 4 \"random access read-only\"
/// and drive role 5 \"random access write-only\".
/// By default a random access file assumes drive role 2 \"read-write\"
/// regardless whether it is actually readable or writeable.
/// If enabled, random-access file objects which recognizably permit no
/// writing will be classified as role 4 and those which permit no reading
/// will get role 5.
/// Candidates are drive addresses of the form stdio:/dev/fd/# , where # is
/// the integer number of an open file descriptor. If this descriptor was
/// opened read-only or write-only, then it gets role 4 or role 5,
/// respectively.
/// Other paths may get tested by an attempt to open them for read-write
/// (role 2) or read-only (role 4) or write-only (role 5). See bit1.
/// @param allowed Bitfield for control purposes:
/// bit0= Enable roles 4 and 5 for drives which get
/// acquired after this call
/// bit1= with bit0:
/// Test whether the file can be opened for
/// read-write, read-only, or write-only.
/// Classify as roles 2, 4, 5.
/// bit2= with bit0 and bit1:
/// Classify files which cannot be opened at all
/// as role 0 : useless dummy.
/// Else classify as role 2.
/// bit3= Classify non-empty role 5 drives as
/// BURN_DISC_APPENDABLE with Next Writeable Address
/// after the end of the file. It is nevertheless
/// possible to change this address by call
/// burn_write_opts_set_start_byte().
/// @since 1.0.6
pub fn burn_allow_drive_role_4(allowed: ::std::os::raw::c_int);
}
unsafe extern "C" {
/// Find out whether a given address string would lead to the given drive
/// object. This should be done in advance for track source addresses
/// with parameter drive_role set to 2.
/// Although a real MMC drive should hardly exist as two drive objects at
/// the same time, this can easily happen with stdio-drives. So if more than
/// one drive is used by the application, then this gesture is advised:
/// burn_drive_d_get_adr(d2, adr2);
/// if (burn_drive_equals_adr(d1, adr2, burn_drive_get_drive_role(d2)))
/// ... Both drive objects point to the same storage facility ...
///
/// @param d1 Existing drive object
/// @param adr2 Address string to be tested. Prefix \"stdio:\" overrides
/// parameter drive_role2 by either 0 or 2 as appropriate.
/// The string must be shorter than BURN_DRIVE_ADR_LEN.
/// @param drive_role2 Role as burn_drive_get_drive_role() would attribute
/// to adr2 if it was a drive. Use value 2 for checking track
/// sources or pseudo-drive addresses without \"stdio:\".
/// Use 1 for checking drive addresses including those with
/// prefix \"stdio:\".
/// @return 1= adr2 leads to d1 , 0= adr2 seems not to lead to d1,
/// -1 = adr2 is bad
/// @since 0.4.0
pub fn burn_drive_equals_adr(
d1: *mut burn_drive,
adr2: *mut ::std::os::raw::c_char,
drive_role2: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
/// Extractor object encapsulating intermediate states of extraction.
/// The clients of libdax_audioxtr shall only allocate pointers to this
/// struct and get a storage object via libdax_audioxtr_new().
/// Appropriate initial value for the pointer is NULL.
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct libdax_audioxtr {
_unused: [u8; 0],
}
unsafe extern "C" {
/// Open an audio file, check whether suitable, create extractor object.
/// @param xtr Opaque handle to extractor. Gets attached extractor object.
/// @param path Address of the audio file to extract. \"-\" is stdin (but might
/// be not suitable for all futurely supported formats).
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return >0 success
/// 0 unsuitable format
/// -1 severe error
/// -2 path not found
/// @since 0.2.4
pub fn libdax_audioxtr_new(
xtr: *mut *mut libdax_audioxtr,
path: *mut ::std::os::raw::c_char,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain identification parameters of opened audio source.
/// @param xtr Opaque handle to extractor
/// @param fmt Gets pointed to the audio file format id text: \".wav\" , \".au\"
/// @param fmt_info Gets pointed to a format info text telling parameters
/// @param num_channels e.g. 1=mono, 2=stereo, etc
/// @param sample_rate e.g. 11025, 44100
/// @param bits_per_sample e.g. 8= 8 bits per sample, 16= 16 bits ...
/// @param msb_first Byte order of samples: 0= Intel = Little Endian
/// 1= Motorola = Big Endian
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return >0 success, <=0 failure
/// @since 0.2.4
pub fn libdax_audioxtr_get_id(
xtr: *mut libdax_audioxtr,
fmt: *mut *mut ::std::os::raw::c_char,
fmt_info: *mut *mut ::std::os::raw::c_char,
num_channels: *mut ::std::os::raw::c_int,
sample_rate: *mut ::std::os::raw::c_int,
bits_per_sample: *mut ::std::os::raw::c_int,
msb_first: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain a prediction about the extracted size based on internal information
/// of the formatted file.
/// @param o Opaque handle to extractor
/// @param size Gets filled with the predicted size
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 prediction was possible , 0 no prediction could be made
/// @since 0.2.4
pub fn libdax_audioxtr_get_size(
o: *mut libdax_audioxtr,
size: *mut off_t,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Obtain next buffer full of extracted data in desired format (only raw audio
/// for now).
/// @param xtr Opaque handle to extractor
/// @param buffer Gets filled with extracted data
/// @param buffer_size Maximum number of bytes to be filled into buffer
/// @param flag Bitfield for control purposes
/// bit0= do not stop at predicted end of data
/// @return >0 number of valid buffer bytes,
/// 0 End of file
/// -1 operating system reports error
/// -2 usage error by application
/// @since 0.2.4
pub fn libdax_audioxtr_read(
xtr: *mut libdax_audioxtr,
buffer: *mut ::std::os::raw::c_char,
buffer_size: ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Try to obtain a file descriptor which will deliver extracted data
/// to normal calls of read(2). This may fail because the format is
/// unsuitable for that, but WAVE (.wav) is ok. If this call succeeds the xtr
/// object will have forgotten its file descriptor and libdax_audioxtr_read()
/// will return a usage error. One may use *fd after libdax_audioxtr_destroy()
/// and will have to close it via close(2) when done with it.
/// @param o Opaque handle to extractor
/// @param fd Returns the file descriptor number
/// @param flag Bitfield for control purposes
/// bit0= do not dup(2) and close(2) but hand out original fd
/// @return 1 success, 0 cannot hand out fd , -1 severe error
/// @since 0.2.4
pub fn libdax_audioxtr_detach_fd(
o: *mut libdax_audioxtr,
fd: *mut ::std::os::raw::c_int,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
unsafe extern "C" {
/// Clean up after extraction and destroy extractor object.
/// @param xtr Opaque handle to extractor, *xtr is allowed to be NULL,
/// xtr is set to NULL by this function
/// @param flag Bitfield for control purposes (unused yet, submit 0)
/// @return 1 = destroyed object, 0 = was already destroyed
/// @since 0.2.4
pub fn libdax_audioxtr_destroy(
xtr: *mut *mut libdax_audioxtr,
flag: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
Reference in a new issue View git blame Copy permalink