libburn_sys/

lib.rs

//! Low-level Rust bindings for libburn.
//!
//! You can find out more about the libburnia project, of which libburn is a part, by visiting
//! <https://dev.lovelyhq.com/libburnia/web/wiki>
//!
//! This version of libburn-sys is based on libburn 1.5.6
//!
//! ## Requirements
//!
//! Currently, libburn-sys does not support statically linking libburn into your application, and may never do.
//! Instead, **you must have libburn 1.5.6 or greater installed** on your system so libburn-sys can dynamically
//! link to it.
//!
//! Bindings for libburn are pregenerated for libburn-sys, so you shouldn't need bindgen's dependencies
//! installed to start using libburn-sys.

#![allow(non_camel_case_types)]
#![allow(clippy::useless_transmute)]

/* 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).add(byte_index)
        };
        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).add(byte_index)
        };
        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;

/// 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) -> libc::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: libc::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,
            )
        }
    }
    #[expect(clippy::too_many_arguments)]
    #[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: libc::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) -> libc::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: libc::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 libc::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 libc::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: libc::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: libc::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: libc::off_t,
        size: libc::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: libc::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 libc::off_t,
        written_bytes: *mut libc::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 libc::timeval,
        us_corr: *mut ::std::os::raw::c_int,
        b_since_prev: libc::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: libc::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: libc::off_t,
    /// The lowest permissible start address.
    pub start_range_low: libc::off_t,
    /// The highest addressable start address.
    pub start_range_high: libc::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: libc::off_t,
        data: *mut ::std::os::raw::c_char,
        data_count: libc::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: libc::off_t,
        data: *mut ::std::os::raw::c_char,
        data_size: libc::off_t,
        data_count: *mut libc::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: libc::off_t,
        data_count: *mut libc::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 libc::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;
}