/* automatically generated by rust-bindgen 0.58.1 */

extern "C" {
    pub fn syz_getVersion(
        major: *mut ::std::os::raw::c_uint,
        minor: *mut ::std::os::raw::c_uint,
        patch: *mut ::std::os::raw::c_uint,
    );
}
pub type syz_Handle = ::std::os::raw::c_ulonglong;
pub type syz_ErrorCode = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_UserAutomationEvent {
    pub param: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_syz_UserAutomationEvent() {
    assert_eq!(
        ::std::mem::size_of::<syz_UserAutomationEvent>(),
        8usize,
        concat!("Size of: ", stringify!(syz_UserAutomationEvent))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_UserAutomationEvent>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_UserAutomationEvent))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_UserAutomationEvent>())).param as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_UserAutomationEvent),
            "::",
            stringify!(param)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct syz_Event {
    pub type_: ::std::os::raw::c_int,
    pub source: syz_Handle,
    pub context: syz_Handle,
    pub payload: syz_Event__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union syz_Event__bindgen_ty_1 {
    pub user_automation: syz_UserAutomationEvent,
}
#[test]
fn bindgen_test_layout_syz_Event__bindgen_ty_1() {
    assert_eq!(
        ::std::mem::size_of::<syz_Event__bindgen_ty_1>(),
        8usize,
        concat!("Size of: ", stringify!(syz_Event__bindgen_ty_1))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_Event__bindgen_ty_1>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_Event__bindgen_ty_1))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_Event__bindgen_ty_1>())).user_automation as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_Event__bindgen_ty_1),
            "::",
            stringify!(user_automation)
        )
    );
}
impl Default for syz_Event__bindgen_ty_1 {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
#[test]
fn bindgen_test_layout_syz_Event() {
    assert_eq!(
        ::std::mem::size_of::<syz_Event>(),
        32usize,
        concat!("Size of: ", stringify!(syz_Event))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_Event>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_Event))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_Event>())).type_ as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_Event),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_Event>())).source as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_Event),
            "::",
            stringify!(source)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_Event>())).context as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_Event),
            "::",
            stringify!(context)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_Event>())).payload as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_Event),
            "::",
            stringify!(payload)
        )
    );
}
impl Default for syz_Event {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
extern "C" {
    pub fn syz_eventDeinit(event: *mut syz_Event);
}
pub const SYZ_LOGGING_BACKEND_NONE: SYZ_LOGGING_BACKEND = 0;
pub const SYZ_LOGGING_BACKEND_STDERR: SYZ_LOGGING_BACKEND = 1;
pub type SYZ_LOGGING_BACKEND = ::std::os::raw::c_uint;
pub const SYZ_LOG_LEVEL_ERROR: SYZ_LOG_LEVEL = 0;
pub const SYZ_LOG_LEVEL_WARN: SYZ_LOG_LEVEL = 10;
pub const SYZ_LOG_LEVEL_INFO: SYZ_LOG_LEVEL = 20;
pub const SYZ_LOG_LEVEL_DEBUG: SYZ_LOG_LEVEL = 30;
pub type SYZ_LOG_LEVEL = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct syz_LibraryConfig {
    pub log_level: ::std::os::raw::c_uint,
    pub logging_backend: ::std::os::raw::c_uint,
    pub libsndfile_path: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_syz_LibraryConfig() {
    assert_eq!(
        ::std::mem::size_of::<syz_LibraryConfig>(),
        16usize,
        concat!("Size of: ", stringify!(syz_LibraryConfig))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_LibraryConfig>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_LibraryConfig))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_LibraryConfig>())).log_level as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_LibraryConfig),
            "::",
            stringify!(log_level)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_LibraryConfig>())).logging_backend as *const _ as usize
        },
        4usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_LibraryConfig),
            "::",
            stringify!(logging_backend)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_LibraryConfig>())).libsndfile_path as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_LibraryConfig),
            "::",
            stringify!(libsndfile_path)
        )
    );
}
impl Default for syz_LibraryConfig {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
extern "C" {
    pub fn syz_libraryConfigSetDefaults(config: *mut syz_LibraryConfig);
}
extern "C" {
    pub fn syz_initialize() -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_initializeWithConfig(config: *const syz_LibraryConfig) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_shutdown() -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getLastErrorCode() -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getLastErrorMessage() -> *const ::std::os::raw::c_char;
}
extern "C" {
    pub fn syz_handleIncRef(handle: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_handleDecRef(handle: syz_Handle) -> syz_ErrorCode;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_DeleteBehaviorConfig {
    pub linger: ::std::os::raw::c_int,
    pub linger_timeout: f64,
}
#[test]
fn bindgen_test_layout_syz_DeleteBehaviorConfig() {
    assert_eq!(
        ::std::mem::size_of::<syz_DeleteBehaviorConfig>(),
        16usize,
        concat!("Size of: ", stringify!(syz_DeleteBehaviorConfig))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_DeleteBehaviorConfig>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_DeleteBehaviorConfig))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_DeleteBehaviorConfig>())).linger as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_DeleteBehaviorConfig),
            "::",
            stringify!(linger)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_DeleteBehaviorConfig>())).linger_timeout as *const _ as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_DeleteBehaviorConfig),
            "::",
            stringify!(linger_timeout)
        )
    );
}
extern "C" {
    pub fn syz_initDeleteBehaviorConfig(cfg: *mut syz_DeleteBehaviorConfig);
}
extern "C" {
    pub fn syz_configDeleteBehavior(
        object: syz_Handle,
        cfg: *const syz_DeleteBehaviorConfig,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_handleGetObjectType(
        out: *mut ::std::os::raw::c_int,
        handle: syz_Handle,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_handleGetUserdata(
        out: *mut *mut ::std::os::raw::c_void,
        handle: syz_Handle,
    ) -> syz_ErrorCode;
}
pub type syz_UserdataFreeCallback =
    ::std::option::Option<unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void)>;
extern "C" {
    pub fn syz_handleSetUserdata(
        handle: syz_Handle,
        userdata: *mut ::std::os::raw::c_void,
        free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_pause(object: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_play(object: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getI(
        out: *mut ::std::os::raw::c_int,
        target: syz_Handle,
        property: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setI(
        target: syz_Handle,
        property: ::std::os::raw::c_int,
        value: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getD(
        out: *mut f64,
        target: syz_Handle,
        property: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setD(
        target: syz_Handle,
        property: ::std::os::raw::c_int,
        value: f64,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setO(
        target: syz_Handle,
        property: ::std::os::raw::c_int,
        value: syz_Handle,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getD3(
        x: *mut f64,
        y: *mut f64,
        z: *mut f64,
        target: syz_Handle,
        property: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setD3(
        target: syz_Handle,
        property: ::std::os::raw::c_int,
        x: f64,
        y: f64,
        z: f64,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_getD6(
        x1: *mut f64,
        y1: *mut f64,
        z1: *mut f64,
        x2: *mut f64,
        y2: *mut f64,
        z2: *mut f64,
        target: syz_Handle,
        property: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setD6(
        handle: syz_Handle,
        property: ::std::os::raw::c_int,
        x1: f64,
        y1: f64,
        z1: f64,
        x2: f64,
        y2: f64,
        z2: f64,
    ) -> syz_ErrorCode;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_BiquadConfig {
    pub _b0: f64,
    pub _b1: f64,
    pub _b2: f64,
    pub _a1: f64,
    pub _a2: f64,
    pub _gain: f64,
    pub _is_wire: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_syz_BiquadConfig() {
    assert_eq!(
        ::std::mem::size_of::<syz_BiquadConfig>(),
        56usize,
        concat!("Size of: ", stringify!(syz_BiquadConfig))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_BiquadConfig>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_BiquadConfig))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._b0 as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_b0)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._b1 as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_b1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._b2 as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_b2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._a1 as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_a1)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._a2 as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_a2)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._gain as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_gain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_BiquadConfig>()))._is_wire as *const _ as usize },
        48usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_BiquadConfig),
            "::",
            stringify!(_is_wire)
        )
    );
}
extern "C" {
    pub fn syz_getBiquad(
        filter: *mut syz_BiquadConfig,
        target: syz_Handle,
        property: ::std::os::raw::c_int,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_setBiquad(
        target: syz_Handle,
        property: ::std::os::raw::c_int,
        filter: *const syz_BiquadConfig,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_biquadDesignIdentity(filter: *mut syz_BiquadConfig) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_biquadDesignLowpass(
        filter: *mut syz_BiquadConfig,
        frequency: f64,
        q: f64,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_biquadDesignHighpass(
        filter: *mut syz_BiquadConfig,
        frequency: f64,
        q: f64,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_biquadDesignBandpass(
        filter: *mut syz_BiquadConfig,
        frequency: f64,
        bw: f64,
    ) -> syz_ErrorCode;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_AutomationPoint {
    pub interpolation_type: ::std::os::raw::c_int,
    pub values: [f64; 6usize],
    pub flags: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_syz_AutomationPoint() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationPoint>(),
        64usize,
        concat!("Size of: ", stringify!(syz_AutomationPoint))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationPoint>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_AutomationPoint))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationPoint>())).interpolation_type as *const _ as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationPoint),
            "::",
            stringify!(interpolation_type)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationPoint>())).values as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationPoint),
            "::",
            stringify!(values)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationPoint>())).flags as *const _ as usize },
        56usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationPoint),
            "::",
            stringify!(flags)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_AutomationAppendPropertyCommand {
    pub property: ::std::os::raw::c_int,
    pub point: syz_AutomationPoint,
}
#[test]
fn bindgen_test_layout_syz_AutomationAppendPropertyCommand() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationAppendPropertyCommand>(),
        72usize,
        concat!("Size of: ", stringify!(syz_AutomationAppendPropertyCommand))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationAppendPropertyCommand>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(syz_AutomationAppendPropertyCommand)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationAppendPropertyCommand>())).property as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationAppendPropertyCommand),
            "::",
            stringify!(property)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationAppendPropertyCommand>())).point as *const _
                as usize
        },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationAppendPropertyCommand),
            "::",
            stringify!(point)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_AutomationClearPropertyCommand {
    pub property: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_syz_AutomationClearPropertyCommand() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationClearPropertyCommand>(),
        4usize,
        concat!("Size of: ", stringify!(syz_AutomationClearPropertyCommand))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationClearPropertyCommand>(),
        4usize,
        concat!(
            "Alignment of ",
            stringify!(syz_AutomationClearPropertyCommand)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationClearPropertyCommand>())).property as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationClearPropertyCommand),
            "::",
            stringify!(property)
        )
    );
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_AutomationSendUserEventCommand {
    pub param: ::std::os::raw::c_ulonglong,
}
#[test]
fn bindgen_test_layout_syz_AutomationSendUserEventCommand() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationSendUserEventCommand>(),
        8usize,
        concat!("Size of: ", stringify!(syz_AutomationSendUserEventCommand))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationSendUserEventCommand>(),
        8usize,
        concat!(
            "Alignment of ",
            stringify!(syz_AutomationSendUserEventCommand)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationSendUserEventCommand>())).param as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationSendUserEventCommand),
            "::",
            stringify!(param)
        )
    );
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union syz_AutomationCommandParams {
    pub append_to_property: syz_AutomationAppendPropertyCommand,
    pub clear_property: syz_AutomationClearPropertyCommand,
    pub send_user_event: syz_AutomationSendUserEventCommand,
}
#[test]
fn bindgen_test_layout_syz_AutomationCommandParams() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationCommandParams>(),
        72usize,
        concat!("Size of: ", stringify!(syz_AutomationCommandParams))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationCommandParams>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_AutomationCommandParams))
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationCommandParams>())).append_to_property as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommandParams),
            "::",
            stringify!(append_to_property)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationCommandParams>())).clear_property as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommandParams),
            "::",
            stringify!(clear_property)
        )
    );
    assert_eq!(
        unsafe {
            &(*(::std::ptr::null::<syz_AutomationCommandParams>())).send_user_event as *const _
                as usize
        },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommandParams),
            "::",
            stringify!(send_user_event)
        )
    );
}
impl Default for syz_AutomationCommandParams {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct syz_AutomationCommand {
    pub target: syz_Handle,
    pub time: f64,
    pub type_: ::std::os::raw::c_int,
    pub flags: ::std::os::raw::c_uint,
    pub params: syz_AutomationCommandParams,
}
#[test]
fn bindgen_test_layout_syz_AutomationCommand() {
    assert_eq!(
        ::std::mem::size_of::<syz_AutomationCommand>(),
        96usize,
        concat!("Size of: ", stringify!(syz_AutomationCommand))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_AutomationCommand>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_AutomationCommand))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationCommand>())).target as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommand),
            "::",
            stringify!(target)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationCommand>())).time as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommand),
            "::",
            stringify!(time)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationCommand>())).type_ as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommand),
            "::",
            stringify!(type_)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationCommand>())).flags as *const _ as usize },
        20usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommand),
            "::",
            stringify!(flags)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_AutomationCommand>())).params as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_AutomationCommand),
            "::",
            stringify!(params)
        )
    );
}
impl Default for syz_AutomationCommand {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
extern "C" {
    pub fn syz_createAutomationBatch(
        out: *mut syz_Handle,
        context: syz_Handle,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_automationBatchAddCommands(
        batch: syz_Handle,
        commands_len: ::std::os::raw::c_ulonglong,
        commands: *const syz_AutomationCommand,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_automationBatchExecute(batch: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createContext(
        out: *mut syz_Handle,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createContextHeadless(
        out: *mut syz_Handle,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_contextGetBlock(context: syz_Handle, block: *mut f32) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_contextEnableEvents(context: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_contextGetNextEvent(
        out: *mut syz_Event,
        context: syz_Handle,
        flags: ::std::os::raw::c_ulonglong,
    ) -> syz_ErrorCode;
}
pub type syz_StreamReadCallback = ::std::option::Option<
    unsafe extern "C" fn(
        read: *mut ::std::os::raw::c_ulonglong,
        requested: ::std::os::raw::c_ulonglong,
        destination: *mut ::std::os::raw::c_char,
        userdata: *mut ::std::os::raw::c_void,
        err_msg: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
>;
pub type syz_StreamSeekCallback = ::std::option::Option<
    unsafe extern "C" fn(
        pos: ::std::os::raw::c_ulonglong,
        userdata: *mut ::std::os::raw::c_void,
        err_msg: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
>;
pub type syz_StreamCloseCallback = ::std::option::Option<
    unsafe extern "C" fn(
        userdata: *mut ::std::os::raw::c_void,
        err_msg: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
>;
pub type syz_StreamDestroyCallback =
    ::std::option::Option<unsafe extern "C" fn(userdata: *mut ::std::os::raw::c_void)>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct syz_CustomStreamDef {
    pub read_cb: syz_StreamReadCallback,
    pub seek_cb: syz_StreamSeekCallback,
    pub close_cb: syz_StreamCloseCallback,
    pub destroy_cb: syz_StreamDestroyCallback,
    pub length: ::std::os::raw::c_longlong,
    pub userdata: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout_syz_CustomStreamDef() {
    assert_eq!(
        ::std::mem::size_of::<syz_CustomStreamDef>(),
        48usize,
        concat!("Size of: ", stringify!(syz_CustomStreamDef))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_CustomStreamDef>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_CustomStreamDef))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).read_cb as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(read_cb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).seek_cb as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(seek_cb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).close_cb as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(close_cb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).destroy_cb as *const _ as usize },
        24usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(destroy_cb)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).length as *const _ as usize },
        32usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(length)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_CustomStreamDef>())).userdata as *const _ as usize },
        40usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_CustomStreamDef),
            "::",
            stringify!(userdata)
        )
    );
}
impl Default for syz_CustomStreamDef {
    fn default() -> Self {
        unsafe { ::std::mem::zeroed() }
    }
}
pub type syz_StreamOpenCallback = ::std::option::Option<
    unsafe extern "C" fn(
        callbacks: *mut syz_CustomStreamDef,
        protocol: *const ::std::os::raw::c_char,
        path: *const ::std::os::raw::c_char,
        param: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        err_msg: *mut *const ::std::os::raw::c_char,
    ) -> ::std::os::raw::c_int,
>;
extern "C" {
    pub fn syz_registerStreamProtocol(
        protocol: *const ::std::os::raw::c_char,
        callback: syz_StreamOpenCallback,
        userdata: *mut ::std::os::raw::c_void,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamHandleFromStreamParams(
        out: *mut syz_Handle,
        protocol: *const ::std::os::raw::c_char,
        path: *const ::std::os::raw::c_char,
        param: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamHandleFromMemory(
        out: *mut syz_Handle,
        data_len: ::std::os::raw::c_ulonglong,
        data: *const ::std::os::raw::c_char,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamHandleFromFile(
        out: *mut syz_Handle,
        path: *const ::std::os::raw::c_char,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamHandleFromCustomStream(
        out: *mut syz_Handle,
        callbacks: *mut syz_CustomStreamDef,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamingGeneratorFromStreamParams(
        out: *mut syz_Handle,
        context: syz_Handle,
        protocol: *const ::std::os::raw::c_char,
        path: *const ::std::os::raw::c_char,
        param: *mut ::std::os::raw::c_void,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamingGeneratorFromFile(
        out: *mut syz_Handle,
        context: syz_Handle,
        path: *const ::std::os::raw::c_char,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createStreamingGeneratorFromStreamHandle(
        out: *mut syz_Handle,
        context: syz_Handle,
        stream: syz_Handle,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferFromStreamParams(
        out: *mut syz_Handle,
        protocol: *const ::std::os::raw::c_char,
        path: *const ::std::os::raw::c_char,
        param: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferFromEncodedData(
        out: *mut syz_Handle,
        data_len: ::std::os::raw::c_ulonglong,
        data: *const ::std::os::raw::c_char,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferFromFloatArray(
        out: *mut syz_Handle,
        sr: ::std::os::raw::c_uint,
        channels: ::std::os::raw::c_uint,
        frames: ::std::os::raw::c_ulonglong,
        data: *const f32,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferFromFile(
        out: *mut syz_Handle,
        path: *const ::std::os::raw::c_char,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferFromStreamHandle(
        out: *mut syz_Handle,
        stream: syz_Handle,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_bufferGetChannels(
        out: *mut ::std::os::raw::c_uint,
        buffer: syz_Handle,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_bufferGetLengthInSamples(
        out: *mut ::std::os::raw::c_uint,
        buffer: syz_Handle,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_bufferGetLengthInSeconds(out: *mut f64, buffer: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_bufferGetSizeInBytes(
        size: *mut ::std::os::raw::c_ulonglong,
        buffer: syz_Handle,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createBufferGenerator(
        out: *mut syz_Handle,
        context: syz_Handle,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_sourceAddGenerator(source: syz_Handle, generator: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_sourceRemoveGenerator(source: syz_Handle, generator: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createDirectSource(
        out: *mut syz_Handle,
        context: syz_Handle,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createAngularPannedSource(
        out: *mut syz_Handle,
        context: syz_Handle,
        panner_strategy: ::std::os::raw::c_int,
        azimuth: f64,
        elevation: f64,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createScalarPannedSource(
        out: *mut syz_Handle,
        context: syz_Handle,
        panner_strategy: ::std::os::raw::c_int,
        panning_scalar: f64,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createSource3D(
        out: *mut syz_Handle,
        context: syz_Handle,
        panner_strategy: ::std::os::raw::c_int,
        x: f64,
        y: f64,
        z: f64,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createNoiseGenerator(
        out: *mut syz_Handle,
        context: syz_Handle,
        channels: ::std::os::raw::c_uint,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_RouteConfig {
    pub gain: f64,
    pub fade_time: f64,
    pub filter: syz_BiquadConfig,
}
#[test]
fn bindgen_test_layout_syz_RouteConfig() {
    assert_eq!(
        ::std::mem::size_of::<syz_RouteConfig>(),
        72usize,
        concat!("Size of: ", stringify!(syz_RouteConfig))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_RouteConfig>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_RouteConfig))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_RouteConfig>())).gain as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_RouteConfig),
            "::",
            stringify!(gain)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_RouteConfig>())).fade_time as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_RouteConfig),
            "::",
            stringify!(fade_time)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_RouteConfig>())).filter as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_RouteConfig),
            "::",
            stringify!(filter)
        )
    );
}
extern "C" {
    pub fn syz_initRouteConfig(cfg: *mut syz_RouteConfig) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_routingConfigRoute(
        context: syz_Handle,
        output: syz_Handle,
        input: syz_Handle,
        config: *const syz_RouteConfig,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_routingRemoveRoute(
        context: syz_Handle,
        output: syz_Handle,
        input: syz_Handle,
        fade_out: f64,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_effectReset(effect: syz_Handle) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createGlobalEcho(
        out: *mut syz_Handle,
        context: syz_Handle,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct syz_EchoTapConfig {
    pub delay: f64,
    pub gain_l: f64,
    pub gain_r: f64,
}
#[test]
fn bindgen_test_layout_syz_EchoTapConfig() {
    assert_eq!(
        ::std::mem::size_of::<syz_EchoTapConfig>(),
        24usize,
        concat!("Size of: ", stringify!(syz_EchoTapConfig))
    );
    assert_eq!(
        ::std::mem::align_of::<syz_EchoTapConfig>(),
        8usize,
        concat!("Alignment of ", stringify!(syz_EchoTapConfig))
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_EchoTapConfig>())).delay as *const _ as usize },
        0usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_EchoTapConfig),
            "::",
            stringify!(delay)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_EchoTapConfig>())).gain_l as *const _ as usize },
        8usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_EchoTapConfig),
            "::",
            stringify!(gain_l)
        )
    );
    assert_eq!(
        unsafe { &(*(::std::ptr::null::<syz_EchoTapConfig>())).gain_r as *const _ as usize },
        16usize,
        concat!(
            "Offset of field: ",
            stringify!(syz_EchoTapConfig),
            "::",
            stringify!(gain_r)
        )
    );
}
extern "C" {
    pub fn syz_globalEchoSetTaps(
        handle: syz_Handle,
        n_taps: ::std::os::raw::c_uint,
        taps: *const syz_EchoTapConfig,
    ) -> syz_ErrorCode;
}
extern "C" {
    pub fn syz_createGlobalFdnReverb(
        out: *mut syz_Handle,
        context: syz_Handle,
        config: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
        userdata_free_callback: syz_UserdataFreeCallback,
    ) -> syz_ErrorCode;
}