Quelle  generated.rs   Sprache: unbekannt

/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage, Align> {
    storage: Storage,
    align: [Align; 0],
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
    #[inline]
    pub const fn new(storage: Storage) -> Self {
        Self { storage, align: [] }
    }
}
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
where
    Storage: AsRef<[u8]> + AsMut<[u8]>,
{
    #[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];
        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 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];
        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 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 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);
        }
    }
}
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub const fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub fn as_ptr(&self) -> *const T {
        self as *const _ as *const T
    }
    #[inline]
    pub fn as_mut_ptr(&mut self) -> *mut T {
        self as *mut _ as *mut T
    }
    #[inline]
    pub unsafe fn as_slice(&self, len: usize) -> &[T] {
        ::std::slice::from_raw_parts(self.as_ptr(), len)
    }
    #[inline]
    pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
        ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
    }
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        fmt.write_str("__IncompleteArrayField")
    }
}
extern "C" {
    #[doc = "  \\defgroup Global Global defines and functions"]
    #[doc = "  Global defines and functions."]
    #[doc = "  \\par"]
    #[doc = "  The ALSA library implementation uses these macros and functions."]
    #[doc = "  Most applications probably do not need them."]
    #[doc = "  \\{"]
    pub fn snd_asoundlib_version() -> *const ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct snd_dlsym_link {
    pub next: *mut snd_dlsym_link,
    pub dlsym_name: *const ::std::os::raw::c_char,
    pub dlsym_ptr: *const ::std::os::raw::c_void,
}
extern "C" {
    pub fn snd_dlpath(
        path: *mut ::std::os::raw::c_char,
        path_len: usize,
        name: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_dlopen(
        file: *const ::std::os::raw::c_char,
        mode: ::std::os::raw::c_int,
        errbuf: *mut ::std::os::raw::c_char,
        errbuflen: usize,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn snd_dlsym(
        handle: *mut ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
        version: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void;
}
extern "C" {
    pub fn snd_dlclose(handle: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_async_handler {
    _unused: [u8; 0],
}
#[doc = " \\brief Internal structure for an async notification client handler."]
#[doc = ""]
#[doc = " The ALSA library uses a pointer to this structure as a handle to an async"]
#[doc = " notification object. Applications don't access its contents directly."]
pub type snd_async_handler_t = _snd_async_handler;
#[doc = " \\brief Async notification callback."]
#[doc = ""]
#[doc = " See the #snd_async_add_handler function for details."]
pub type snd_async_callback_t =
    ::std::option::Option<unsafe extern "C" fn(handler: *mut snd_async_handler_t)>;
extern "C" {
    pub fn snd_async_add_handler(
        handler: *mut *mut snd_async_handler_t,
        fd: ::std::os::raw::c_int,
        callback: snd_async_callback_t,
        private_data: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_del_handler(handler: *mut snd_async_handler_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_handler_get_fd(handler: *mut snd_async_handler_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_handler_get_signo(handler: *mut snd_async_handler_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_handler_get_callback_private(
        handler: *mut snd_async_handler_t,
    ) -> *mut ::std::os::raw::c_void;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct snd_shm_area {
    _unused: [u8; 0],
}
extern "C" {
    pub fn snd_shm_area_create(
        shmid: ::std::os::raw::c_int,
        ptr: *mut ::std::os::raw::c_void,
    ) -> *mut snd_shm_area;
}
extern "C" {
    pub fn snd_shm_area_share(area: *mut snd_shm_area) -> *mut snd_shm_area;
}
extern "C" {
    pub fn snd_shm_area_destroy(area: *mut snd_shm_area) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_user_file(
        file: *const ::std::os::raw::c_char,
        result: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
#[doc = " Timestamp"]
pub type snd_timestamp_t = timeval;
#[doc = " Hi-res timestamp"]
pub type snd_htimestamp_t = timespec;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_input {
    _unused: [u8; 0],
}
#[doc = " \\brief Internal structure for an input object."]
#[doc = ""]
#[doc = " The ALSA library uses a pointer to this structure as a handle to an"]
#[doc = " input object. Applications don't access its contents directly."]
pub type snd_input_t = _snd_input;
#[doc = " Input from a stdio stream."]
pub const SND_INPUT_STDIO: _snd_input_type = 0;
#[doc = " Input from a memory buffer."]
pub const SND_INPUT_BUFFER: _snd_input_type = 1;
#[doc = " Input type."]
pub type _snd_input_type = u32;
#[doc = " Input type."]
pub use self::_snd_input_type as snd_input_type_t;
extern "C" {
    pub fn snd_input_stdio_open(
        inputp: *mut *mut snd_input_t,
        file: *const ::std::os::raw::c_char,
        mode: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_stdio_attach(
        inputp: *mut *mut snd_input_t,
        fp: *mut FILE,
        _close: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_buffer_open(
        inputp: *mut *mut snd_input_t,
        buffer: *const ::std::os::raw::c_char,
        size: isize,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_close(input: *mut snd_input_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_scanf(
        input: *mut snd_input_t,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_gets(
        input: *mut snd_input_t,
        str: *mut ::std::os::raw::c_char,
        size: usize,
    ) -> *mut ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_input_getc(input: *mut snd_input_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_input_ungetc(
        input: *mut snd_input_t,
        c: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_output {
    _unused: [u8; 0],
}
#[doc = " \\brief Internal structure for an output object."]
#[doc = ""]
#[doc = " The ALSA library uses a pointer to this structure as a handle to an"]
#[doc = " output object. Applications don't access its contents directly."]
pub type snd_output_t = _snd_output;
#[doc = " Output to a stdio stream."]
pub const SND_OUTPUT_STDIO: _snd_output_type = 0;
#[doc = " Output to a memory buffer."]
pub const SND_OUTPUT_BUFFER: _snd_output_type = 1;
#[doc = " Output type."]
pub type _snd_output_type = u32;
#[doc = " Output type."]
pub use self::_snd_output_type as snd_output_type_t;
extern "C" {
    pub fn snd_output_stdio_open(
        outputp: *mut *mut snd_output_t,
        file: *const ::std::os::raw::c_char,
        mode: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_stdio_attach(
        outputp: *mut *mut snd_output_t,
        fp: *mut FILE,
        _close: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_buffer_open(outputp: *mut *mut snd_output_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_buffer_string(
        output: *mut snd_output_t,
        buf: *mut *mut ::std::os::raw::c_char,
    ) -> usize;
}
extern "C" {
    pub fn snd_output_close(output: *mut snd_output_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_printf(
        output: *mut snd_output_t,
        format: *const ::std::os::raw::c_char,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_vprintf(
        output: *mut snd_output_t,
        format: *const ::std::os::raw::c_char,
        args: *mut __va_list_tag,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_puts(
        output: *mut snd_output_t,
        str: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_putc(
        output: *mut snd_output_t,
        c: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_output_flush(output: *mut snd_output_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_strerror(errnum: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
#[doc = " \\brief Error handler callback."]
#[doc = " \\param file Source file name."]
#[doc = " \\param line Line number."]
#[doc = " \\param function Function name."]
#[doc = " \\param err Value of \\c errno, or 0 if not relevant."]
#[doc = " \\param fmt \\c printf(3) format."]
#[doc = " \\param ... \\c printf(3) arguments."]
#[doc = ""]
#[doc = " A function of this type is called by the ALSA library when an error occurs."]
#[doc = " This function usually shows the message on the screen, and/or logs it."]
pub type snd_lib_error_handler_t = ::std::option::Option<
    unsafe extern "C" fn(
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        function: *const ::std::os::raw::c_char,
        err: ::std::os::raw::c_int,
        fmt: *const ::std::os::raw::c_char,
        ...
    ),
>;
extern "C" {
    pub fn snd_lib_error_set_handler(handler: snd_lib_error_handler_t) -> ::std::os::raw::c_int;
}
#[doc = " Local error handler function type"]
pub type snd_local_error_handler_t = ::std::option::Option<
    unsafe extern "C" fn(
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        func: *const ::std::os::raw::c_char,
        err: ::std::os::raw::c_int,
        fmt: *const ::std::os::raw::c_char,
        arg: *mut __va_list_tag,
    ),
>;
extern "C" {
    pub fn snd_lib_error_set_local(func: snd_local_error_handler_t) -> snd_local_error_handler_t;
}
#[doc = " Integer number."]
pub const SND_CONFIG_TYPE_INTEGER: _snd_config_type = 0;
#[doc = " 64-bit integer number."]
pub const SND_CONFIG_TYPE_INTEGER64: _snd_config_type = 1;
#[doc = " Real number."]
pub const SND_CONFIG_TYPE_REAL: _snd_config_type = 2;
#[doc = " Character string."]
pub const SND_CONFIG_TYPE_STRING: _snd_config_type = 3;
#[doc = " Pointer (runtime only, cannot be saved)."]
pub const SND_CONFIG_TYPE_POINTER: _snd_config_type = 4;
#[doc = " Compound node."]
pub const SND_CONFIG_TYPE_COMPOUND: _snd_config_type = 1024;
#[doc = " \\brief Configuration node type."]
pub type _snd_config_type = u32;
#[doc = " \\brief Configuration node type."]
pub use self::_snd_config_type as snd_config_type_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_config {
    _unused: [u8; 0],
}
#[doc = " \\brief Internal structure for a configuration node object."]
#[doc = ""]
#[doc = " The ALSA library uses a pointer to this structure as a handle to a"]
#[doc = " configuration node. Applications don't access its contents directly."]
pub type snd_config_t = _snd_config;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_config_iterator {
    _unused: [u8; 0],
}
#[doc = " \\brief Type for a configuration compound iterator."]
#[doc = ""]
#[doc = " The ALSA library uses this pointer type as a handle to a configuration"]
#[doc = " compound iterator. Applications don't directly access the contents of"]
#[doc = " the structure pointed to by this type."]
pub type snd_config_iterator_t = *mut _snd_config_iterator;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_config_update {
    _unused: [u8; 0],
}
#[doc = " \\brief Internal structure for a configuration private update object."]
#[doc = ""]
#[doc = " The ALSA library uses this structure to save private update information."]
pub type snd_config_update_t = _snd_config_update;
extern "C" {
    pub fn snd_config_topdir() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_config_top(config: *mut *mut snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_load(
        config: *mut snd_config_t,
        in_: *mut snd_input_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_load_override(
        config: *mut snd_config_t,
        in_: *mut snd_input_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_save(
        config: *mut snd_config_t,
        out: *mut snd_output_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_update() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_update_r(
        top: *mut *mut snd_config_t,
        update: *mut *mut snd_config_update_t,
        path: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_update_free(update: *mut snd_config_update_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_update_free_global() -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_update_ref(top: *mut *mut snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_ref(top: *mut snd_config_t);
}
extern "C" {
    pub fn snd_config_unref(top: *mut snd_config_t);
}
extern "C" {
    pub fn snd_config_search(
        config: *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        result: *mut *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_searchv(
        config: *mut snd_config_t,
        result: *mut *mut snd_config_t,
        ...
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_search_definition(
        config: *mut snd_config_t,
        base: *const ::std::os::raw::c_char,
        key: *const ::std::os::raw::c_char,
        result: *mut *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_expand(
        config: *mut snd_config_t,
        root: *mut snd_config_t,
        args: *const ::std::os::raw::c_char,
        private_data: *mut snd_config_t,
        result: *mut *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_evaluate(
        config: *mut snd_config_t,
        root: *mut snd_config_t,
        private_data: *mut snd_config_t,
        result: *mut *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_add(
        config: *mut snd_config_t,
        child: *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_add_before(
        before: *mut snd_config_t,
        child: *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_add_after(
        after: *mut snd_config_t,
        child: *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_remove(config: *mut snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_delete(config: *mut snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_delete_compound_members(config: *const snd_config_t)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_copy(
        dst: *mut *mut snd_config_t,
        src: *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        type_: snd_config_type_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_integer(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_integer64(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_real(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_string(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_pointer(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_make_compound(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        join: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_integer(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        value: ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_integer64(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        value: ::std::os::raw::c_longlong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_real(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        value: f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_string(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        ascii: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_safe_string(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        ascii: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_imake_pointer(
        config: *mut *mut snd_config_t,
        key: *const ::std::os::raw::c_char,
        ptr: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_type(config: *const snd_config_t) -> snd_config_type_t;
}
extern "C" {
    pub fn snd_config_is_array(config: *const snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_id(
        config: *mut snd_config_t,
        id: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_integer(
        config: *mut snd_config_t,
        value: ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_integer64(
        config: *mut snd_config_t,
        value: ::std::os::raw::c_longlong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_real(config: *mut snd_config_t, value: f64) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_string(
        config: *mut snd_config_t,
        value: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_ascii(
        config: *mut snd_config_t,
        ascii: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_set_pointer(
        config: *mut snd_config_t,
        ptr: *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_id(
        config: *const snd_config_t,
        value: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_integer(
        config: *const snd_config_t,
        value: *mut ::std::os::raw::c_long,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_integer64(
        config: *const snd_config_t,
        value: *mut ::std::os::raw::c_longlong,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_real(
        config: *const snd_config_t,
        value: *mut f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_ireal(
        config: *const snd_config_t,
        value: *mut f64,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_string(
        config: *const snd_config_t,
        value: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_ascii(
        config: *const snd_config_t,
        value: *mut *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_pointer(
        config: *const snd_config_t,
        value: *mut *const ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_test_id(
        config: *const snd_config_t,
        id: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_iterator_first(node: *const snd_config_t) -> snd_config_iterator_t;
}
extern "C" {
    pub fn snd_config_iterator_next(iterator: snd_config_iterator_t) -> snd_config_iterator_t;
}
extern "C" {
    pub fn snd_config_iterator_end(node: *const snd_config_t) -> snd_config_iterator_t;
}
extern "C" {
    pub fn snd_config_iterator_entry(iterator: snd_config_iterator_t) -> *mut snd_config_t;
}
extern "C" {
    pub fn snd_config_get_bool_ascii(ascii: *const ::std::os::raw::c_char)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_bool(conf: *const snd_config_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_ctl_iface_ascii(
        ascii: *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_config_get_ctl_iface(conf: *const snd_config_t) -> ::std::os::raw::c_int;
}
#[doc = " Device-name list element"]
pub type snd_devname_t = snd_devname;
#[doc = " Device-name list element (definition)"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct snd_devname {
    #[doc = "< Device name string"]
    pub name: *mut ::std::os::raw::c_char,
    #[doc = "< Comments"]
    pub comment: *mut ::std::os::raw::c_char,
    #[doc = "< Next pointer"]
    pub next: *mut snd_devname_t,
}
extern "C" {
    pub fn snd_names_list(
        iface: *const ::std::os::raw::c_char,
        list: *mut *mut snd_devname_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_names_list_free(list: *mut snd_devname_t);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_info {
    _unused: [u8; 0],
}
#[doc = " PCM generic info container"]
pub type snd_pcm_info_t = _snd_pcm_info;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_hw_params {
    _unused: [u8; 0],
}
#[doc = " PCM hardware configuration space container"]
#[doc = ""]
#[doc = "  snd_pcm_hw_params_t is an opaque structure which contains a set of possible"]
#[doc = "  PCM hardware configurations. For example, a given instance might include a"]
#[doc = "  range of buffer sizes, a range of period sizes, and a set of several sample"]
#[doc = "  formats. Some subset of all possible combinations these sets may be valid,"]
#[doc = "  but not necessarily any combination will be valid."]
#[doc = ""]
#[doc = "  When a parameter is set or restricted using a snd_pcm_hw_params_set*"]
#[doc = "  function, all of the other ranges will be updated to exclude as many"]
#[doc = "  impossible configurations as possible. Attempting to set a parameter"]
#[doc = "  outside of its acceptable range will result in the function failing"]
#[doc = "  and an error code being returned."]
pub type snd_pcm_hw_params_t = _snd_pcm_hw_params;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_sw_params {
    _unused: [u8; 0],
}
#[doc = " PCM software configuration container"]
pub type snd_pcm_sw_params_t = _snd_pcm_sw_params;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_status {
    _unused: [u8; 0],
}
#[doc = " PCM status container"]
pub type snd_pcm_status_t = _snd_pcm_status;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_access_mask {
    _unused: [u8; 0],
}
#[doc = " PCM access types mask"]
pub type snd_pcm_access_mask_t = _snd_pcm_access_mask;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_format_mask {
    _unused: [u8; 0],
}
#[doc = " PCM formats mask"]
pub type snd_pcm_format_mask_t = _snd_pcm_format_mask;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_subformat_mask {
    _unused: [u8; 0],
}
#[doc = " PCM subformats mask"]
pub type snd_pcm_subformat_mask_t = _snd_pcm_subformat_mask;
#[doc = " standard device"]
pub const SND_PCM_CLASS_GENERIC: _snd_pcm_class = 0;
#[doc = " multichannel device"]
pub const SND_PCM_CLASS_MULTI: _snd_pcm_class = 1;
#[doc = " software modem device"]
pub const SND_PCM_CLASS_MODEM: _snd_pcm_class = 2;
#[doc = " digitizer device"]
pub const SND_PCM_CLASS_DIGITIZER: _snd_pcm_class = 3;
#[doc = " digitizer device"]
pub const SND_PCM_CLASS_LAST: _snd_pcm_class = 3;
#[doc = " PCM class"]
pub type _snd_pcm_class = u32;
#[doc = " PCM class"]
pub use self::_snd_pcm_class as snd_pcm_class_t;
#[doc = " subdevices are mixed together"]
pub const SND_PCM_SUBCLASS_GENERIC_MIX: _snd_pcm_subclass = 0;
#[doc = " multichannel subdevices are mixed together"]
pub const SND_PCM_SUBCLASS_MULTI_MIX: _snd_pcm_subclass = 1;
#[doc = " multichannel subdevices are mixed together"]
pub const SND_PCM_SUBCLASS_LAST: _snd_pcm_subclass = 1;
#[doc = " PCM subclass"]
pub type _snd_pcm_subclass = u32;
#[doc = " PCM subclass"]
pub use self::_snd_pcm_subclass as snd_pcm_subclass_t;
#[doc = " Playback stream"]
pub const SND_PCM_STREAM_PLAYBACK: _snd_pcm_stream = 0;
#[doc = " Capture stream"]
pub const SND_PCM_STREAM_CAPTURE: _snd_pcm_stream = 1;
#[doc = " Capture stream"]
pub const SND_PCM_STREAM_LAST: _snd_pcm_stream = 1;
#[doc = " PCM stream (direction)"]
pub type _snd_pcm_stream = u32;
#[doc = " PCM stream (direction)"]
pub use self::_snd_pcm_stream as snd_pcm_stream_t;
#[doc = " mmap access with simple interleaved channels"]
pub const SND_PCM_ACCESS_MMAP_INTERLEAVED: _snd_pcm_access = 0;
#[doc = " mmap access with simple non interleaved channels"]
pub const SND_PCM_ACCESS_MMAP_NONINTERLEAVED: _snd_pcm_access = 1;
#[doc = " mmap access with complex placement"]
pub const SND_PCM_ACCESS_MMAP_COMPLEX: _snd_pcm_access = 2;
#[doc = " snd_pcm_readi/snd_pcm_writei access"]
pub const SND_PCM_ACCESS_RW_INTERLEAVED: _snd_pcm_access = 3;
#[doc = " snd_pcm_readn/snd_pcm_writen access"]
pub const SND_PCM_ACCESS_RW_NONINTERLEAVED: _snd_pcm_access = 4;
#[doc = " snd_pcm_readn/snd_pcm_writen access"]
pub const SND_PCM_ACCESS_LAST: _snd_pcm_access = 4;
#[doc = " PCM access type"]
pub type _snd_pcm_access = u32;
#[doc = " PCM access type"]
pub use self::_snd_pcm_access as snd_pcm_access_t;
#[doc = " Unknown"]
pub const SND_PCM_FORMAT_UNKNOWN: _snd_pcm_format = -1;
#[doc = " Signed 8 bit"]
pub const SND_PCM_FORMAT_S8: _snd_pcm_format = 0;
#[doc = " Unsigned 8 bit"]
pub const SND_PCM_FORMAT_U8: _snd_pcm_format = 1;
#[doc = " Signed 16 bit Little Endian"]
pub const SND_PCM_FORMAT_S16_LE: _snd_pcm_format = 2;
#[doc = " Signed 16 bit Big Endian"]
pub const SND_PCM_FORMAT_S16_BE: _snd_pcm_format = 3;
#[doc = " Unsigned 16 bit Little Endian"]
pub const SND_PCM_FORMAT_U16_LE: _snd_pcm_format = 4;
#[doc = " Unsigned 16 bit Big Endian"]
pub const SND_PCM_FORMAT_U16_BE: _snd_pcm_format = 5;
#[doc = " Signed 24 bit Little Endian using low three bytes in 32-bit word"]
pub const SND_PCM_FORMAT_S24_LE: _snd_pcm_format = 6;
#[doc = " Signed 24 bit Big Endian using low three bytes in 32-bit word"]
pub const SND_PCM_FORMAT_S24_BE: _snd_pcm_format = 7;
#[doc = " Unsigned 24 bit Little Endian using low three bytes in 32-bit word"]
pub const SND_PCM_FORMAT_U24_LE: _snd_pcm_format = 8;
#[doc = " Unsigned 24 bit Big Endian using low three bytes in 32-bit word"]
pub const SND_PCM_FORMAT_U24_BE: _snd_pcm_format = 9;
#[doc = " Signed 32 bit Little Endian"]
pub const SND_PCM_FORMAT_S32_LE: _snd_pcm_format = 10;
#[doc = " Signed 32 bit Big Endian"]
pub const SND_PCM_FORMAT_S32_BE: _snd_pcm_format = 11;
#[doc = " Unsigned 32 bit Little Endian"]
pub const SND_PCM_FORMAT_U32_LE: _snd_pcm_format = 12;
#[doc = " Unsigned 32 bit Big Endian"]
pub const SND_PCM_FORMAT_U32_BE: _snd_pcm_format = 13;
#[doc = " Float 32 bit Little Endian, Range -1.0 to 1.0"]
pub const SND_PCM_FORMAT_FLOAT_LE: _snd_pcm_format = 14;
#[doc = " Float 32 bit Big Endian, Range -1.0 to 1.0"]
pub const SND_PCM_FORMAT_FLOAT_BE: _snd_pcm_format = 15;
#[doc = " Float 64 bit Little Endian, Range -1.0 to 1.0"]
pub const SND_PCM_FORMAT_FLOAT64_LE: _snd_pcm_format = 16;
#[doc = " Float 64 bit Big Endian, Range -1.0 to 1.0"]
pub const SND_PCM_FORMAT_FLOAT64_BE: _snd_pcm_format = 17;
#[doc = " IEC-958 Little Endian"]
pub const SND_PCM_FORMAT_IEC958_SUBFRAME_LE: _snd_pcm_format = 18;
#[doc = " IEC-958 Big Endian"]
pub const SND_PCM_FORMAT_IEC958_SUBFRAME_BE: _snd_pcm_format = 19;
#[doc = " Mu-Law"]
pub const SND_PCM_FORMAT_MU_LAW: _snd_pcm_format = 20;
#[doc = " A-Law"]
pub const SND_PCM_FORMAT_A_LAW: _snd_pcm_format = 21;
#[doc = " Ima-ADPCM"]
pub const SND_PCM_FORMAT_IMA_ADPCM: _snd_pcm_format = 22;
#[doc = " MPEG"]
pub const SND_PCM_FORMAT_MPEG: _snd_pcm_format = 23;
#[doc = " GSM"]
pub const SND_PCM_FORMAT_GSM: _snd_pcm_format = 24;
#[doc = " Signed 20bit Little Endian in 4bytes format, LSB justified"]
pub const SND_PCM_FORMAT_S20_LE: _snd_pcm_format = 25;
#[doc = " Signed 20bit Big Endian in 4bytes format, LSB justified"]
pub const SND_PCM_FORMAT_S20_BE: _snd_pcm_format = 26;
#[doc = " Unsigned 20bit Little Endian in 4bytes format, LSB justified"]
pub const SND_PCM_FORMAT_U20_LE: _snd_pcm_format = 27;
#[doc = " Unsigned 20bit Big Endian in 4bytes format, LSB justified"]
pub const SND_PCM_FORMAT_U20_BE: _snd_pcm_format = 28;
#[doc = " Special"]
pub const SND_PCM_FORMAT_SPECIAL: _snd_pcm_format = 31;
#[doc = " Signed 24bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S24_3LE: _snd_pcm_format = 32;
#[doc = " Signed 24bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S24_3BE: _snd_pcm_format = 33;
#[doc = " Unsigned 24bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U24_3LE: _snd_pcm_format = 34;
#[doc = " Unsigned 24bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U24_3BE: _snd_pcm_format = 35;
#[doc = " Signed 20bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S20_3LE: _snd_pcm_format = 36;
#[doc = " Signed 20bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S20_3BE: _snd_pcm_format = 37;
#[doc = " Unsigned 20bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U20_3LE: _snd_pcm_format = 38;
#[doc = " Unsigned 20bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U20_3BE: _snd_pcm_format = 39;
#[doc = " Signed 18bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S18_3LE: _snd_pcm_format = 40;
#[doc = " Signed 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_S18_3BE: _snd_pcm_format = 41;
#[doc = " Unsigned 18bit Little Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U18_3LE: _snd_pcm_format = 42;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_U18_3BE: _snd_pcm_format = 43;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_G723_24: _snd_pcm_format = 44;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_G723_24_1B: _snd_pcm_format = 45;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_G723_40: _snd_pcm_format = 46;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_G723_40_1B: _snd_pcm_format = 47;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_DSD_U8: _snd_pcm_format = 48;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_DSD_U16_LE: _snd_pcm_format = 49;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_DSD_U32_LE: _snd_pcm_format = 50;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_DSD_U16_BE: _snd_pcm_format = 51;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_DSD_U32_BE: _snd_pcm_format = 52;
#[doc = " Unsigned 18bit Big Endian in 3bytes format"]
pub const SND_PCM_FORMAT_LAST: _snd_pcm_format = 52;
#[doc = " Signed 16 bit CPU endian"]
pub const SND_PCM_FORMAT_S16: _snd_pcm_format = 2;
#[doc = " Unsigned 16 bit CPU endian"]
pub const SND_PCM_FORMAT_U16: _snd_pcm_format = 4;
#[doc = " Signed 24 bit CPU endian"]
pub const SND_PCM_FORMAT_S24: _snd_pcm_format = 6;
#[doc = " Unsigned 24 bit CPU endian"]
pub const SND_PCM_FORMAT_U24: _snd_pcm_format = 8;
#[doc = " Signed 32 bit CPU endian"]
pub const SND_PCM_FORMAT_S32: _snd_pcm_format = 10;
#[doc = " Unsigned 32 bit CPU endian"]
pub const SND_PCM_FORMAT_U32: _snd_pcm_format = 12;
#[doc = " Float 32 bit CPU endian"]
pub const SND_PCM_FORMAT_FLOAT: _snd_pcm_format = 14;
#[doc = " Float 64 bit CPU endian"]
pub const SND_PCM_FORMAT_FLOAT64: _snd_pcm_format = 16;
#[doc = " IEC-958 CPU Endian"]
pub const SND_PCM_FORMAT_IEC958_SUBFRAME: _snd_pcm_format = 18;
#[doc = " Signed 20bit in 4bytes format, LSB justified, CPU Endian"]
pub const SND_PCM_FORMAT_S20: _snd_pcm_format = 25;
#[doc = " Unsigned 20bit in 4bytes format, LSB justified, CPU Endian"]
pub const SND_PCM_FORMAT_U20: _snd_pcm_format = 27;
#[doc = " PCM sample format"]
pub type _snd_pcm_format = i32;
#[doc = " PCM sample format"]
pub use self::_snd_pcm_format as snd_pcm_format_t;
#[doc = " Standard"]
pub const SND_PCM_SUBFORMAT_STD: _snd_pcm_subformat = 0;
#[doc = " Standard"]
pub const SND_PCM_SUBFORMAT_LAST: _snd_pcm_subformat = 0;
#[doc = " PCM sample subformat"]
pub type _snd_pcm_subformat = u32;
#[doc = " PCM sample subformat"]
pub use self::_snd_pcm_subformat as snd_pcm_subformat_t;
#[doc = " Open"]
pub const SND_PCM_STATE_OPEN: _snd_pcm_state = 0;
#[doc = " Setup installed"]
pub const SND_PCM_STATE_SETUP: _snd_pcm_state = 1;
#[doc = " Ready to start"]
pub const SND_PCM_STATE_PREPARED: _snd_pcm_state = 2;
#[doc = " Running"]
pub const SND_PCM_STATE_RUNNING: _snd_pcm_state = 3;
#[doc = " Stopped: underrun (playback) or overrun (capture) detected"]
pub const SND_PCM_STATE_XRUN: _snd_pcm_state = 4;
#[doc = " Draining: running (playback) or stopped (capture)"]
pub const SND_PCM_STATE_DRAINING: _snd_pcm_state = 5;
#[doc = " Paused"]
pub const SND_PCM_STATE_PAUSED: _snd_pcm_state = 6;
#[doc = " Hardware is suspended"]
pub const SND_PCM_STATE_SUSPENDED: _snd_pcm_state = 7;
#[doc = " Hardware is disconnected"]
pub const SND_PCM_STATE_DISCONNECTED: _snd_pcm_state = 8;
#[doc = " Hardware is disconnected"]
pub const SND_PCM_STATE_LAST: _snd_pcm_state = 8;
#[doc = " Private - used internally in the library - do not use"]
pub const SND_PCM_STATE_PRIVATE1: _snd_pcm_state = 1024;
#[doc = " PCM state"]
pub type _snd_pcm_state = u32;
#[doc = " PCM state"]
pub use self::_snd_pcm_state as snd_pcm_state_t;
#[doc = " Automatic start on data read/write"]
pub const SND_PCM_START_DATA: _snd_pcm_start = 0;
#[doc = " Explicit start"]
pub const SND_PCM_START_EXPLICIT: _snd_pcm_start = 1;
#[doc = " Explicit start"]
pub const SND_PCM_START_LAST: _snd_pcm_start = 1;
#[doc = " PCM start mode"]
pub type _snd_pcm_start = u32;
#[doc = " PCM start mode"]
pub use self::_snd_pcm_start as snd_pcm_start_t;
#[doc = " Xrun detection disabled"]
pub const SND_PCM_XRUN_NONE: _snd_pcm_xrun = 0;
#[doc = " Stop on xrun detection"]
pub const SND_PCM_XRUN_STOP: _snd_pcm_xrun = 1;
#[doc = " Stop on xrun detection"]
pub const SND_PCM_XRUN_LAST: _snd_pcm_xrun = 1;
#[doc = " PCM xrun mode"]
pub type _snd_pcm_xrun = u32;
#[doc = " PCM xrun mode"]
pub use self::_snd_pcm_xrun as snd_pcm_xrun_t;
#[doc = " No timestamp"]
pub const SND_PCM_TSTAMP_NONE: _snd_pcm_tstamp = 0;
#[doc = " Update timestamp at every hardware position update"]
pub const SND_PCM_TSTAMP_ENABLE: _snd_pcm_tstamp = 1;
#[doc = " Equivalent with #SND_PCM_TSTAMP_ENABLE,"]
#[doc = " just for compatibility with older versions"]
pub const SND_PCM_TSTAMP_MMAP: _snd_pcm_tstamp = 1;
#[doc = " Equivalent with #SND_PCM_TSTAMP_ENABLE,"]
#[doc = " just for compatibility with older versions"]
pub const SND_PCM_TSTAMP_LAST: _snd_pcm_tstamp = 1;
#[doc = " PCM timestamp mode"]
pub type _snd_pcm_tstamp = u32;
#[doc = " PCM timestamp mode"]
pub use self::_snd_pcm_tstamp as snd_pcm_tstamp_t;
#[doc = "< gettimeofday equivalent"]
pub const SND_PCM_TSTAMP_TYPE_GETTIMEOFDAY: _snd_pcm_tstamp_type = 0;
#[doc = "< posix_clock_monotonic equivalent"]
pub const SND_PCM_TSTAMP_TYPE_MONOTONIC: _snd_pcm_tstamp_type = 1;
#[doc = "< monotonic_raw (no NTP)"]
pub const SND_PCM_TSTAMP_TYPE_MONOTONIC_RAW: _snd_pcm_tstamp_type = 2;
pub const SND_PCM_TSTAMP_TYPE_LAST: _snd_pcm_tstamp_type = 2;
pub type _snd_pcm_tstamp_type = u32;
pub use self::_snd_pcm_tstamp_type as snd_pcm_tstamp_type_t;
#[doc = " first definition for backwards compatibility only,"]
#[doc = " maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_COMPAT: _snd_pcm_audio_tstamp_type = 0;
#[doc = "< DMA time, reported as per hw_ptr"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_DEFAULT: _snd_pcm_audio_tstamp_type = 1;
#[doc = "< link time reported by sample or wallclock counter, reset on startup"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_LINK: _snd_pcm_audio_tstamp_type = 2;
#[doc = "< link time reported by sample or wallclock counter, not reset on startup"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE: _snd_pcm_audio_tstamp_type = 3;
#[doc = "< link time estimated indirectly"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED: _snd_pcm_audio_tstamp_type = 4;
#[doc = "< link time synchronized with system time"]
pub const SND_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED: _snd_pcm_audio_tstamp_type = 5;
pub const SND_PCM_AUDIO_TSTAMP_TYPE_LAST: _snd_pcm_audio_tstamp_type = 5;
pub type _snd_pcm_audio_tstamp_type = u32;
pub use self::_snd_pcm_audio_tstamp_type as snd_pcm_audio_tstamp_type_t;
#[repr(C)]
#[repr(align(4))]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_audio_tstamp_config {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub __bindgen_padding_0: [u8; 3usize],
}
impl _snd_pcm_audio_tstamp_config {
    #[inline]
    pub fn type_requested(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_type_requested(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub fn report_delay(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_report_delay(&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 fn new_bitfield_1(
        type_requested: ::std::os::raw::c_uint,
        report_delay: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 4u8, {
            let type_requested: u32 = unsafe { ::std::mem::transmute(type_requested) };
            type_requested as u64
        });
        __bindgen_bitfield_unit.set(4usize, 1u8, {
            let report_delay: u32 = unsafe { ::std::mem::transmute(report_delay) };
            report_delay as u64
        });
        __bindgen_bitfield_unit
    }
}
pub type snd_pcm_audio_tstamp_config_t = _snd_pcm_audio_tstamp_config;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_audio_tstamp_report {
    pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize], u8>,
    pub accuracy: ::std::os::raw::c_uint,
}
impl _snd_pcm_audio_tstamp_report {
    #[inline]
    pub fn valid(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_valid(&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 fn actual_type(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 4u8) as u32) }
    }
    #[inline]
    pub fn set_actual_type(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(1usize, 4u8, val as u64)
        }
    }
    #[inline]
    pub fn accuracy_report(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_accuracy_report(&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 fn new_bitfield_1(
        valid: ::std::os::raw::c_uint,
        actual_type: ::std::os::raw::c_uint,
        accuracy_report: ::std::os::raw::c_uint,
    ) -> __BindgenBitfieldUnit<[u8; 1usize], u8> {
        let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize], u8> =
            Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let valid: u32 = unsafe { ::std::mem::transmute(valid) };
            valid as u64
        });
        __bindgen_bitfield_unit.set(1usize, 4u8, {
            let actual_type: u32 = unsafe { ::std::mem::transmute(actual_type) };
            actual_type as u64
        });
        __bindgen_bitfield_unit.set(5usize, 1u8, {
            let accuracy_report: u32 = unsafe { ::std::mem::transmute(accuracy_report) };
            accuracy_report as u64
        });
        __bindgen_bitfield_unit
    }
}
pub type snd_pcm_audio_tstamp_report_t = _snd_pcm_audio_tstamp_report;
#[doc = " Unsigned frames quantity"]
pub type snd_pcm_uframes_t = ::std::os::raw::c_ulong;
#[doc = " Signed frames quantity"]
pub type snd_pcm_sframes_t = ::std::os::raw::c_long;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm {
    _unused: [u8; 0],
}
#[doc = " PCM handle"]
pub type snd_pcm_t = _snd_pcm;
#[doc = " Kernel level PCM"]
pub const SND_PCM_TYPE_HW: _snd_pcm_type = 0;
#[doc = " Hooked PCM"]
pub const SND_PCM_TYPE_HOOKS: _snd_pcm_type = 1;
#[doc = " One or more linked PCM with exclusive access to selected"]
#[doc = "channels"]
pub const SND_PCM_TYPE_MULTI: _snd_pcm_type = 2;
#[doc = " File writing plugin"]
pub const SND_PCM_TYPE_FILE: _snd_pcm_type = 3;
#[doc = " Null endpoint PCM"]
pub const SND_PCM_TYPE_NULL: _snd_pcm_type = 4;
#[doc = " Shared memory client PCM"]
pub const SND_PCM_TYPE_SHM: _snd_pcm_type = 5;
#[doc = " INET client PCM (not yet implemented)"]
pub const SND_PCM_TYPE_INET: _snd_pcm_type = 6;
#[doc = " Copying plugin"]
pub const SND_PCM_TYPE_COPY: _snd_pcm_type = 7;
#[doc = " Linear format conversion PCM"]
pub const SND_PCM_TYPE_LINEAR: _snd_pcm_type = 8;
#[doc = " A-Law format conversion PCM"]
pub const SND_PCM_TYPE_ALAW: _snd_pcm_type = 9;
#[doc = " Mu-Law format conversion PCM"]
pub const SND_PCM_TYPE_MULAW: _snd_pcm_type = 10;
#[doc = " IMA-ADPCM format conversion PCM"]
pub const SND_PCM_TYPE_ADPCM: _snd_pcm_type = 11;
#[doc = " Rate conversion PCM"]
pub const SND_PCM_TYPE_RATE: _snd_pcm_type = 12;
#[doc = " Attenuated static route PCM"]
pub const SND_PCM_TYPE_ROUTE: _snd_pcm_type = 13;
#[doc = " Format adjusted PCM"]
pub const SND_PCM_TYPE_PLUG: _snd_pcm_type = 14;
#[doc = " Sharing PCM"]
pub const SND_PCM_TYPE_SHARE: _snd_pcm_type = 15;
#[doc = " Meter plugin"]
pub const SND_PCM_TYPE_METER: _snd_pcm_type = 16;
#[doc = " Mixing PCM"]
pub const SND_PCM_TYPE_MIX: _snd_pcm_type = 17;
#[doc = " Attenuated dynamic route PCM (not yet implemented)"]
pub const SND_PCM_TYPE_DROUTE: _snd_pcm_type = 18;
#[doc = " Loopback server plugin (not yet implemented)"]
pub const SND_PCM_TYPE_LBSERVER: _snd_pcm_type = 19;
#[doc = " Linear Integer <-> Linear Float format conversion PCM"]
pub const SND_PCM_TYPE_LINEAR_FLOAT: _snd_pcm_type = 20;
#[doc = " LADSPA integration plugin"]
pub const SND_PCM_TYPE_LADSPA: _snd_pcm_type = 21;
#[doc = " Direct Mixing plugin"]
pub const SND_PCM_TYPE_DMIX: _snd_pcm_type = 22;
#[doc = " Jack Audio Connection Kit plugin"]
pub const SND_PCM_TYPE_JACK: _snd_pcm_type = 23;
#[doc = " Direct Snooping plugin"]
pub const SND_PCM_TYPE_DSNOOP: _snd_pcm_type = 24;
#[doc = " Direct Sharing plugin"]
pub const SND_PCM_TYPE_DSHARE: _snd_pcm_type = 25;
#[doc = " IEC958 subframe plugin"]
pub const SND_PCM_TYPE_IEC958: _snd_pcm_type = 26;
#[doc = " Soft volume plugin"]
pub const SND_PCM_TYPE_SOFTVOL: _snd_pcm_type = 27;
#[doc = " External I/O plugin"]
pub const SND_PCM_TYPE_IOPLUG: _snd_pcm_type = 28;
#[doc = " External filter plugin"]
pub const SND_PCM_TYPE_EXTPLUG: _snd_pcm_type = 29;
#[doc = " Mmap-emulation plugin"]
pub const SND_PCM_TYPE_MMAP_EMUL: _snd_pcm_type = 30;
#[doc = " Mmap-emulation plugin"]
pub const SND_PCM_TYPE_LAST: _snd_pcm_type = 30;
#[doc = " PCM type"]
pub type _snd_pcm_type = u32;
#[doc = " PCM type"]
pub use self::_snd_pcm_type as snd_pcm_type_t;
#[doc = " PCM area specification"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_channel_area {
    #[doc = " base address of channel samples"]
    pub addr: *mut ::std::os::raw::c_void,
    #[doc = " offset to first sample in bits"]
    pub first: ::std::os::raw::c_uint,
    #[doc = " samples distance in bits"]
    pub step: ::std::os::raw::c_uint,
}
#[doc = " PCM area specification"]
pub type snd_pcm_channel_area_t = _snd_pcm_channel_area;
#[doc = " PCM synchronization ID"]
#[repr(C)]
#[derive(Copy, Clone)]
pub union _snd_pcm_sync_id {
    #[doc = " 8-bit ID"]
    pub id: [::std::os::raw::c_uchar; 16usize],
    #[doc = " 16-bit ID"]
    pub id16: [::std::os::raw::c_ushort; 8usize],
    #[doc = " 32-bit ID"]
    pub id32: [::std::os::raw::c_uint; 4usize],
    _bindgen_union_align: [u32; 4usize],
}
#[doc = " PCM synchronization ID"]
pub type snd_pcm_sync_id_t = _snd_pcm_sync_id;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _snd_pcm_scope {
    _unused: [u8; 0],
}
#[doc = " #SND_PCM_TYPE_METER scope handle"]
pub type snd_pcm_scope_t = _snd_pcm_scope;
extern "C" {
    pub fn snd_pcm_open(
        pcm: *mut *mut snd_pcm_t,
        name: *const ::std::os::raw::c_char,
        stream: snd_pcm_stream_t,
        mode: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_open_lconf(
        pcm: *mut *mut snd_pcm_t,
        name: *const ::std::os::raw::c_char,
        stream: snd_pcm_stream_t,
        mode: ::std::os::raw::c_int,
        lconf: *mut snd_config_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_open_fallback(
        pcm: *mut *mut snd_pcm_t,
        root: *mut snd_config_t,
        name: *const ::std::os::raw::c_char,
        orig_name: *const ::std::os::raw::c_char,
        stream: snd_pcm_stream_t,
        mode: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_close(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_name(pcm: *mut snd_pcm_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_type(pcm: *mut snd_pcm_t) -> snd_pcm_type_t;
}
extern "C" {
    pub fn snd_pcm_stream(pcm: *mut snd_pcm_t) -> snd_pcm_stream_t;
}
extern "C" {
    pub fn snd_pcm_poll_descriptors_count(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_poll_descriptors(
        pcm: *mut snd_pcm_t,
        pfds: *mut pollfd,
        space: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_poll_descriptors_revents(
        pcm: *mut snd_pcm_t,
        pfds: *mut pollfd,
        nfds: ::std::os::raw::c_uint,
        revents: *mut ::std::os::raw::c_ushort,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_nonblock(
        pcm: *mut snd_pcm_t,
        nonblock: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_add_pcm_handler(
        handler: *mut *mut snd_async_handler_t,
        pcm: *mut snd_pcm_t,
        callback: snd_async_callback_t,
        private_data: *mut ::std::os::raw::c_void,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_async_handler_get_pcm(handler: *mut snd_async_handler_t) -> *mut snd_pcm_t;
}
extern "C" {
    pub fn snd_pcm_info(pcm: *mut snd_pcm_t, info: *mut snd_pcm_info_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_current(
        pcm: *mut snd_pcm_t,
        params: *mut snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params(
        pcm: *mut snd_pcm_t,
        params: *mut snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_free(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_sw_params_current(
        pcm: *mut snd_pcm_t,
        params: *mut snd_pcm_sw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_sw_params(
        pcm: *mut snd_pcm_t,
        params: *mut snd_pcm_sw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_prepare(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_reset(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_status(
        pcm: *mut snd_pcm_t,
        status: *mut snd_pcm_status_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_start(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_drop(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_drain(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_pause(
        pcm: *mut snd_pcm_t,
        enable: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_state(pcm: *mut snd_pcm_t) -> snd_pcm_state_t;
}
extern "C" {
    pub fn snd_pcm_hwsync(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_delay(
        pcm: *mut snd_pcm_t,
        delayp: *mut snd_pcm_sframes_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_resume(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_htimestamp(
        pcm: *mut snd_pcm_t,
        avail: *mut snd_pcm_uframes_t,
        tstamp: *mut snd_htimestamp_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_avail(pcm: *mut snd_pcm_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_avail_update(pcm: *mut snd_pcm_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_avail_delay(
        pcm: *mut snd_pcm_t,
        availp: *mut snd_pcm_sframes_t,
        delayp: *mut snd_pcm_sframes_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_rewindable(pcm: *mut snd_pcm_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_rewind(pcm: *mut snd_pcm_t, frames: snd_pcm_uframes_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_forwardable(pcm: *mut snd_pcm_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_forward(pcm: *mut snd_pcm_t, frames: snd_pcm_uframes_t) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_writei(
        pcm: *mut snd_pcm_t,
        buffer: *const ::std::os::raw::c_void,
        size: snd_pcm_uframes_t,
    ) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_readi(
        pcm: *mut snd_pcm_t,
        buffer: *mut ::std::os::raw::c_void,
        size: snd_pcm_uframes_t,
    ) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_writen(
        pcm: *mut snd_pcm_t,
        bufs: *mut *mut ::std::os::raw::c_void,
        size: snd_pcm_uframes_t,
    ) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_readn(
        pcm: *mut snd_pcm_t,
        bufs: *mut *mut ::std::os::raw::c_void,
        size: snd_pcm_uframes_t,
    ) -> snd_pcm_sframes_t;
}
extern "C" {
    pub fn snd_pcm_wait(
        pcm: *mut snd_pcm_t,
        timeout: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_link(pcm1: *mut snd_pcm_t, pcm2: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_unlink(pcm: *mut snd_pcm_t) -> ::std::os::raw::c_int;
}
#[doc = "< unspecified channel position"]
pub const SND_CHMAP_TYPE_NONE: snd_pcm_chmap_type = 0;
#[doc = "< fixed channel position"]
pub const SND_CHMAP_TYPE_FIXED: snd_pcm_chmap_type = 1;
#[doc = "< freely swappable channel position"]
pub const SND_CHMAP_TYPE_VAR: snd_pcm_chmap_type = 2;
#[doc = "< pair-wise swappable channel position"]
pub const SND_CHMAP_TYPE_PAIRED: snd_pcm_chmap_type = 3;
#[doc = "< last entry"]
pub const SND_CHMAP_TYPE_LAST: snd_pcm_chmap_type = 3;
#[doc = " channel map list type"]
pub type snd_pcm_chmap_type = u32;
#[doc = "< unspecified"]
pub const SND_CHMAP_UNKNOWN: snd_pcm_chmap_position = 0;
#[doc = "< N/A, silent"]
pub const SND_CHMAP_NA: snd_pcm_chmap_position = 1;
#[doc = "< mono stream"]
pub const SND_CHMAP_MONO: snd_pcm_chmap_position = 2;
#[doc = "< front left"]
pub const SND_CHMAP_FL: snd_pcm_chmap_position = 3;
#[doc = "< front right"]
pub const SND_CHMAP_FR: snd_pcm_chmap_position = 4;
#[doc = "< rear left"]
pub const SND_CHMAP_RL: snd_pcm_chmap_position = 5;
#[doc = "< rear right"]
pub const SND_CHMAP_RR: snd_pcm_chmap_position = 6;
#[doc = "< front center"]
pub const SND_CHMAP_FC: snd_pcm_chmap_position = 7;
#[doc = "< LFE"]
pub const SND_CHMAP_LFE: snd_pcm_chmap_position = 8;
#[doc = "< side left"]
pub const SND_CHMAP_SL: snd_pcm_chmap_position = 9;
#[doc = "< side right"]
pub const SND_CHMAP_SR: snd_pcm_chmap_position = 10;
#[doc = "< rear center"]
pub const SND_CHMAP_RC: snd_pcm_chmap_position = 11;
#[doc = "< front left center"]
pub const SND_CHMAP_FLC: snd_pcm_chmap_position = 12;
#[doc = "< front right center"]
pub const SND_CHMAP_FRC: snd_pcm_chmap_position = 13;
#[doc = "< rear left center"]
pub const SND_CHMAP_RLC: snd_pcm_chmap_position = 14;
#[doc = "< rear right center"]
pub const SND_CHMAP_RRC: snd_pcm_chmap_position = 15;
#[doc = "< front left wide"]
pub const SND_CHMAP_FLW: snd_pcm_chmap_position = 16;
#[doc = "< front right wide"]
pub const SND_CHMAP_FRW: snd_pcm_chmap_position = 17;
#[doc = "< front left high"]
pub const SND_CHMAP_FLH: snd_pcm_chmap_position = 18;
#[doc = "< front center high"]
pub const SND_CHMAP_FCH: snd_pcm_chmap_position = 19;
#[doc = "< front right high"]
pub const SND_CHMAP_FRH: snd_pcm_chmap_position = 20;
#[doc = "< top center"]
pub const SND_CHMAP_TC: snd_pcm_chmap_position = 21;
#[doc = "< top front left"]
pub const SND_CHMAP_TFL: snd_pcm_chmap_position = 22;
#[doc = "< top front right"]
pub const SND_CHMAP_TFR: snd_pcm_chmap_position = 23;
#[doc = "< top front center"]
pub const SND_CHMAP_TFC: snd_pcm_chmap_position = 24;
#[doc = "< top rear left"]
pub const SND_CHMAP_TRL: snd_pcm_chmap_position = 25;
#[doc = "< top rear right"]
pub const SND_CHMAP_TRR: snd_pcm_chmap_position = 26;
#[doc = "< top rear center"]
pub const SND_CHMAP_TRC: snd_pcm_chmap_position = 27;
#[doc = "< top front left center"]
pub const SND_CHMAP_TFLC: snd_pcm_chmap_position = 28;
#[doc = "< top front right center"]
pub const SND_CHMAP_TFRC: snd_pcm_chmap_position = 29;
#[doc = "< top side left"]
pub const SND_CHMAP_TSL: snd_pcm_chmap_position = 30;
#[doc = "< top side right"]
pub const SND_CHMAP_TSR: snd_pcm_chmap_position = 31;
#[doc = "< left LFE"]
pub const SND_CHMAP_LLFE: snd_pcm_chmap_position = 32;
#[doc = "< right LFE"]
pub const SND_CHMAP_RLFE: snd_pcm_chmap_position = 33;
#[doc = "< bottom center"]
pub const SND_CHMAP_BC: snd_pcm_chmap_position = 34;
#[doc = "< bottom left center"]
pub const SND_CHMAP_BLC: snd_pcm_chmap_position = 35;
#[doc = "< bottom right center"]
pub const SND_CHMAP_BRC: snd_pcm_chmap_position = 36;
pub const SND_CHMAP_LAST: snd_pcm_chmap_position = 36;
#[doc = " channel positions"]
pub type snd_pcm_chmap_position = u32;
#[doc = " the channel map header"]
#[repr(C)]
#[derive(Debug)]
pub struct snd_pcm_chmap {
    #[doc = "< number of channels"]
    pub channels: ::std::os::raw::c_uint,
    #[doc = "< channel position array"]
    pub pos: __IncompleteArrayField<::std::os::raw::c_uint>,
}
#[doc = " the channel map header"]
pub type snd_pcm_chmap_t = snd_pcm_chmap;
#[doc = " the header of array items returned from snd_pcm_query_chmaps()"]
#[repr(C)]
#[derive(Debug)]
pub struct snd_pcm_chmap_query {
    #[doc = "< channel map type"]
    pub type_: snd_pcm_chmap_type,
    #[doc = "< available channel map"]
    pub map: snd_pcm_chmap_t,
}
#[doc = " the header of array items returned from snd_pcm_query_chmaps()"]
pub type snd_pcm_chmap_query_t = snd_pcm_chmap_query;
extern "C" {
    pub fn snd_pcm_query_chmaps(pcm: *mut snd_pcm_t) -> *mut *mut snd_pcm_chmap_query_t;
}
extern "C" {
    pub fn snd_pcm_query_chmaps_from_hw(
        card: ::std::os::raw::c_int,
        dev: ::std::os::raw::c_int,
        subdev: ::std::os::raw::c_int,
        stream: snd_pcm_stream_t,
    ) -> *mut *mut snd_pcm_chmap_query_t;
}
extern "C" {
    pub fn snd_pcm_free_chmaps(maps: *mut *mut snd_pcm_chmap_query_t);
}
extern "C" {
    pub fn snd_pcm_get_chmap(pcm: *mut snd_pcm_t) -> *mut snd_pcm_chmap_t;
}
extern "C" {
    pub fn snd_pcm_set_chmap(
        pcm: *mut snd_pcm_t,
        map: *const snd_pcm_chmap_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_chmap_type_name(val: snd_pcm_chmap_type) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_chmap_name(val: snd_pcm_chmap_position) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_chmap_long_name(val: snd_pcm_chmap_position) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_chmap_print(
        map: *const snd_pcm_chmap_t,
        maxlen: usize,
        buf: *mut ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_chmap_from_string(str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn snd_pcm_chmap_parse_string(str: *const ::std::os::raw::c_char) -> *mut snd_pcm_chmap_t;
}
extern "C" {
    pub fn snd_pcm_recover(
        pcm: *mut snd_pcm_t,
        err: ::std::os::raw::c_int,
        silent: ::std::os::raw::c_int,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_set_params(
        pcm: *mut snd_pcm_t,
        format: snd_pcm_format_t,
        access: snd_pcm_access_t,
        channels: ::std::os::raw::c_uint,
        rate: ::std::os::raw::c_uint,
        soft_resample: ::std::os::raw::c_int,
        latency: ::std::os::raw::c_uint,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_get_params(
        pcm: *mut snd_pcm_t,
        buffer_size: *mut snd_pcm_uframes_t,
        period_size: *mut snd_pcm_uframes_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    #[doc = " \\defgroup PCM_Info Stream Information"]
    #[doc = " \\ingroup PCM"]
    #[doc = " See the \\ref pcm page for more details."]
    #[doc = " \\{"]
    pub fn snd_pcm_info_sizeof() -> usize;
}
extern "C" {
    pub fn snd_pcm_info_malloc(ptr: *mut *mut snd_pcm_info_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_info_free(obj: *mut snd_pcm_info_t);
}
extern "C" {
    pub fn snd_pcm_info_copy(dst: *mut snd_pcm_info_t, src: *const snd_pcm_info_t);
}
extern "C" {
    pub fn snd_pcm_info_get_device(obj: *const snd_pcm_info_t) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn snd_pcm_info_get_subdevice(obj: *const snd_pcm_info_t) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn snd_pcm_info_get_stream(obj: *const snd_pcm_info_t) -> snd_pcm_stream_t;
}
extern "C" {
    pub fn snd_pcm_info_get_card(obj: *const snd_pcm_info_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_info_get_id(obj: *const snd_pcm_info_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_info_get_name(obj: *const snd_pcm_info_t) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_info_get_subdevice_name(
        obj: *const snd_pcm_info_t,
    ) -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn snd_pcm_info_get_class(obj: *const snd_pcm_info_t) -> snd_pcm_class_t;
}
extern "C" {
    pub fn snd_pcm_info_get_subclass(obj: *const snd_pcm_info_t) -> snd_pcm_subclass_t;
}
extern "C" {
    pub fn snd_pcm_info_get_subdevices_count(obj: *const snd_pcm_info_t) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn snd_pcm_info_get_subdevices_avail(obj: *const snd_pcm_info_t) -> ::std::os::raw::c_uint;
}
extern "C" {
    pub fn snd_pcm_info_get_sync(obj: *const snd_pcm_info_t) -> snd_pcm_sync_id_t;
}
extern "C" {
    pub fn snd_pcm_info_set_device(obj: *mut snd_pcm_info_t, val: ::std::os::raw::c_uint);
}
extern "C" {
    pub fn snd_pcm_info_set_subdevice(obj: *mut snd_pcm_info_t, val: ::std::os::raw::c_uint);
}
extern "C" {
    pub fn snd_pcm_info_set_stream(obj: *mut snd_pcm_info_t, val: snd_pcm_stream_t);
}
extern "C" {
    #[doc = " \\defgroup PCM_HW_Params Hardware Parameters"]
    #[doc = " \\ingroup PCM"]
    #[doc = " See the \\ref pcm page for more details."]
    #[doc = " \\{"]
    pub fn snd_pcm_hw_params_any(
        pcm: *mut snd_pcm_t,
        params: *mut snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_mmap_sample_resolution(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_double(params: *const snd_pcm_hw_params_t)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_batch(params: *const snd_pcm_hw_params_t) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_block_transfer(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_monotonic(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_overrange(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_pause(params: *const snd_pcm_hw_params_t)
        -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_resume(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_half_duplex(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_is_joint_duplex(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_sync_start(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_can_disable_period_wakeup(
        params: *const snd_pcm_hw_params_t,
    ) -> ::std::os::raw::c_int;
}
extern "C" {
    pub fn snd_pcm_hw_params_supports_audio_wallclock_ts(
--> --------------------

--> maximum size reached

--> --------------------