fmod-audio-sys 0.1.3

/* automatically generated by rust-bindgen 0.71.1 */

pub const FMOD_VERSION: u32 = 131847;
pub const FMOD_BUILDNUMBER: u32 = 150747;
pub const FMOD_DEBUG_LEVEL_NONE: u32 = 0;
pub const FMOD_DEBUG_LEVEL_ERROR: u32 = 1;
pub const FMOD_DEBUG_LEVEL_WARNING: u32 = 2;
pub const FMOD_DEBUG_LEVEL_LOG: u32 = 4;
pub const FMOD_DEBUG_TYPE_MEMORY: u32 = 256;
pub const FMOD_DEBUG_TYPE_FILE: u32 = 512;
pub const FMOD_DEBUG_TYPE_CODEC: u32 = 1024;
pub const FMOD_DEBUG_TYPE_TRACE: u32 = 2048;
pub const FMOD_DEBUG_DISPLAY_TIMESTAMPS: u32 = 65536;
pub const FMOD_DEBUG_DISPLAY_LINENUMBERS: u32 = 131072;
pub const FMOD_DEBUG_DISPLAY_THREAD: u32 = 262144;
pub const FMOD_MEMORY_NORMAL: u32 = 0;
pub const FMOD_MEMORY_STREAM_FILE: u32 = 1;
pub const FMOD_MEMORY_STREAM_DECODE: u32 = 2;
pub const FMOD_MEMORY_SAMPLEDATA: u32 = 4;
pub const FMOD_MEMORY_DSP_BUFFER: u32 = 8;
pub const FMOD_MEMORY_PLUGIN: u32 = 16;
pub const FMOD_MEMORY_PERSISTENT: u32 = 2097152;
pub const FMOD_MEMORY_ALL: u32 = 4294967295;
pub const FMOD_INIT_NORMAL: u32 = 0;
pub const FMOD_INIT_STREAM_FROM_UPDATE: u32 = 1;
pub const FMOD_INIT_MIX_FROM_UPDATE: u32 = 2;
pub const FMOD_INIT_3D_RIGHTHANDED: u32 = 4;
pub const FMOD_INIT_CLIP_OUTPUT: u32 = 8;
pub const FMOD_INIT_CHANNEL_LOWPASS: u32 = 256;
pub const FMOD_INIT_CHANNEL_DISTANCEFILTER: u32 = 512;
pub const FMOD_INIT_PROFILE_ENABLE: u32 = 65536;
pub const FMOD_INIT_VOL0_BECOMES_VIRTUAL: u32 = 131072;
pub const FMOD_INIT_GEOMETRY_USECLOSEST: u32 = 262144;
pub const FMOD_INIT_PREFER_DOLBY_DOWNMIX: u32 = 524288;
pub const FMOD_INIT_THREAD_UNSAFE: u32 = 1048576;
pub const FMOD_INIT_PROFILE_METER_ALL: u32 = 2097152;
pub const FMOD_INIT_MEMORY_TRACKING: u32 = 4194304;
pub const FMOD_DRIVER_STATE_CONNECTED: u32 = 1;
pub const FMOD_DRIVER_STATE_DEFAULT: u32 = 2;
pub const FMOD_TIMEUNIT_MS: u32 = 1;
pub const FMOD_TIMEUNIT_PCM: u32 = 2;
pub const FMOD_TIMEUNIT_PCMBYTES: u32 = 4;
pub const FMOD_TIMEUNIT_RAWBYTES: u32 = 8;
pub const FMOD_TIMEUNIT_PCMFRACTION: u32 = 16;
pub const FMOD_TIMEUNIT_MODORDER: u32 = 256;
pub const FMOD_TIMEUNIT_MODROW: u32 = 512;
pub const FMOD_TIMEUNIT_MODPATTERN: u32 = 1024;
pub const FMOD_SYSTEM_CALLBACK_DEVICELISTCHANGED: u32 = 1;
pub const FMOD_SYSTEM_CALLBACK_DEVICELOST: u32 = 2;
pub const FMOD_SYSTEM_CALLBACK_MEMORYALLOCATIONFAILED: u32 = 4;
pub const FMOD_SYSTEM_CALLBACK_THREADCREATED: u32 = 8;
pub const FMOD_SYSTEM_CALLBACK_BADDSPCONNECTION: u32 = 16;
pub const FMOD_SYSTEM_CALLBACK_PREMIX: u32 = 32;
pub const FMOD_SYSTEM_CALLBACK_POSTMIX: u32 = 64;
pub const FMOD_SYSTEM_CALLBACK_ERROR: u32 = 128;
pub const FMOD_SYSTEM_CALLBACK_THREADDESTROYED: u32 = 256;
pub const FMOD_SYSTEM_CALLBACK_PREUPDATE: u32 = 512;
pub const FMOD_SYSTEM_CALLBACK_POSTUPDATE: u32 = 1024;
pub const FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED: u32 = 2048;
pub const FMOD_SYSTEM_CALLBACK_BUFFEREDNOMIX: u32 = 4096;
pub const FMOD_SYSTEM_CALLBACK_DEVICEREINITIALIZE: u32 = 8192;
pub const FMOD_SYSTEM_CALLBACK_OUTPUTUNDERRUN: u32 = 16384;
pub const FMOD_SYSTEM_CALLBACK_RECORDPOSITIONCHANGED: u32 = 32768;
pub const FMOD_SYSTEM_CALLBACK_ALL: u32 = 4294967295;
pub const FMOD_DEFAULT: u32 = 0;
pub const FMOD_LOOP_OFF: u32 = 1;
pub const FMOD_LOOP_NORMAL: u32 = 2;
pub const FMOD_LOOP_BIDI: u32 = 4;
pub const FMOD_2D: u32 = 8;
pub const FMOD_3D: u32 = 16;
pub const FMOD_CREATESTREAM: u32 = 128;
pub const FMOD_CREATESAMPLE: u32 = 256;
pub const FMOD_CREATECOMPRESSEDSAMPLE: u32 = 512;
pub const FMOD_OPENUSER: u32 = 1024;
pub const FMOD_OPENMEMORY: u32 = 2048;
pub const FMOD_OPENMEMORY_POINT: u32 = 268435456;
pub const FMOD_OPENRAW: u32 = 4096;
pub const FMOD_OPENONLY: u32 = 8192;
pub const FMOD_ACCURATETIME: u32 = 16384;
pub const FMOD_MPEGSEARCH: u32 = 32768;
pub const FMOD_NONBLOCKING: u32 = 65536;
pub const FMOD_UNIQUE: u32 = 131072;
pub const FMOD_3D_HEADRELATIVE: u32 = 262144;
pub const FMOD_3D_WORLDRELATIVE: u32 = 524288;
pub const FMOD_3D_INVERSEROLLOFF: u32 = 1048576;
pub const FMOD_3D_LINEARROLLOFF: u32 = 2097152;
pub const FMOD_3D_LINEARSQUAREROLLOFF: u32 = 4194304;
pub const FMOD_3D_INVERSETAPEREDROLLOFF: u32 = 8388608;
pub const FMOD_3D_CUSTOMROLLOFF: u32 = 67108864;
pub const FMOD_3D_IGNOREGEOMETRY: u32 = 1073741824;
pub const FMOD_IGNORETAGS: u32 = 33554432;
pub const FMOD_LOWMEM: u32 = 134217728;
pub const FMOD_VIRTUAL_PLAYFROMSTART: u32 = 2147483648;
pub const FMOD_CHANNELMASK_FRONT_LEFT: u32 = 1;
pub const FMOD_CHANNELMASK_FRONT_RIGHT: u32 = 2;
pub const FMOD_CHANNELMASK_FRONT_CENTER: u32 = 4;
pub const FMOD_CHANNELMASK_LOW_FREQUENCY: u32 = 8;
pub const FMOD_CHANNELMASK_SURROUND_LEFT: u32 = 16;
pub const FMOD_CHANNELMASK_SURROUND_RIGHT: u32 = 32;
pub const FMOD_CHANNELMASK_BACK_LEFT: u32 = 64;
pub const FMOD_CHANNELMASK_BACK_RIGHT: u32 = 128;
pub const FMOD_CHANNELMASK_BACK_CENTER: u32 = 256;
pub const FMOD_CHANNELMASK_MONO: u32 = 1;
pub const FMOD_CHANNELMASK_STEREO: u32 = 3;
pub const FMOD_CHANNELMASK_LRC: u32 = 7;
pub const FMOD_CHANNELMASK_QUAD: u32 = 51;
pub const FMOD_CHANNELMASK_SURROUND: u32 = 55;
pub const FMOD_CHANNELMASK_5POINT1: u32 = 63;
pub const FMOD_CHANNELMASK_5POINT1_REARS: u32 = 207;
pub const FMOD_CHANNELMASK_7POINT0: u32 = 247;
pub const FMOD_CHANNELMASK_7POINT1: u32 = 255;
pub const FMOD_PORT_INDEX_NONE: i32 = -1;
pub const FMOD_THREAD_PRIORITY_PLATFORM_MIN: i32 = -32768;
pub const FMOD_THREAD_PRIORITY_PLATFORM_MAX: u32 = 32768;
pub const FMOD_THREAD_PRIORITY_DEFAULT: i32 = -32769;
pub const FMOD_THREAD_PRIORITY_LOW: i32 = -32770;
pub const FMOD_THREAD_PRIORITY_MEDIUM: i32 = -32771;
pub const FMOD_THREAD_PRIORITY_HIGH: i32 = -32772;
pub const FMOD_THREAD_PRIORITY_VERY_HIGH: i32 = -32773;
pub const FMOD_THREAD_PRIORITY_EXTREME: i32 = -32774;
pub const FMOD_THREAD_PRIORITY_CRITICAL: i32 = -32775;
pub const FMOD_THREAD_PRIORITY_MIXER: i32 = -32774;
pub const FMOD_THREAD_PRIORITY_FEEDER: i32 = -32775;
pub const FMOD_THREAD_PRIORITY_STREAM: i32 = -32773;
pub const FMOD_THREAD_PRIORITY_FILE: i32 = -32772;
pub const FMOD_THREAD_PRIORITY_NONBLOCKING: i32 = -32772;
pub const FMOD_THREAD_PRIORITY_RECORD: i32 = -32772;
pub const FMOD_THREAD_PRIORITY_GEOMETRY: i32 = -32770;
pub const FMOD_THREAD_PRIORITY_PROFILER: i32 = -32771;
pub const FMOD_THREAD_PRIORITY_STUDIO_UPDATE: i32 = -32771;
pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_BANK: i32 = -32771;
pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_SAMPLE: i32 = -32771;
pub const FMOD_THREAD_PRIORITY_CONVOLUTION1: i32 = -32773;
pub const FMOD_THREAD_PRIORITY_CONVOLUTION2: i32 = -32773;
pub const FMOD_THREAD_STACK_SIZE_DEFAULT: u32 = 0;
pub const FMOD_THREAD_STACK_SIZE_MIXER: u32 = 81920;
pub const FMOD_THREAD_STACK_SIZE_FEEDER: u32 = 16384;
pub const FMOD_THREAD_STACK_SIZE_STREAM: u32 = 98304;
pub const FMOD_THREAD_STACK_SIZE_FILE: u32 = 65536;
pub const FMOD_THREAD_STACK_SIZE_NONBLOCKING: u32 = 114688;
pub const FMOD_THREAD_STACK_SIZE_RECORD: u32 = 16384;
pub const FMOD_THREAD_STACK_SIZE_GEOMETRY: u32 = 49152;
pub const FMOD_THREAD_STACK_SIZE_PROFILER: u32 = 131072;
pub const FMOD_THREAD_STACK_SIZE_STUDIO_UPDATE: u32 = 98304;
pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_BANK: u32 = 98304;
pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_SAMPLE: u32 = 98304;
pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION1: u32 = 16384;
pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION2: u32 = 16384;
pub const FMOD_THREAD_AFFINITY_GROUP_DEFAULT: u64 = 4611686018427387904;
pub const FMOD_THREAD_AFFINITY_GROUP_A: u64 = 4611686018427387905;
pub const FMOD_THREAD_AFFINITY_GROUP_B: u64 = 4611686018427387906;
pub const FMOD_THREAD_AFFINITY_GROUP_C: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_MIXER: u64 = 4611686018427387905;
pub const FMOD_THREAD_AFFINITY_FEEDER: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_STREAM: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_FILE: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_NONBLOCKING: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_RECORD: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_GEOMETRY: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_PROFILER: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_STUDIO_UPDATE: u64 = 4611686018427387906;
pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_BANK: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_SAMPLE: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_CONVOLUTION1: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_CONVOLUTION2: u64 = 4611686018427387907;
pub const FMOD_THREAD_AFFINITY_CORE_ALL: u32 = 0;
pub const FMOD_THREAD_AFFINITY_CORE_0: u32 = 1;
pub const FMOD_THREAD_AFFINITY_CORE_1: u32 = 2;
pub const FMOD_THREAD_AFFINITY_CORE_2: u32 = 4;
pub const FMOD_THREAD_AFFINITY_CORE_3: u32 = 8;
pub const FMOD_THREAD_AFFINITY_CORE_4: u32 = 16;
pub const FMOD_THREAD_AFFINITY_CORE_5: u32 = 32;
pub const FMOD_THREAD_AFFINITY_CORE_6: u32 = 64;
pub const FMOD_THREAD_AFFINITY_CORE_7: u32 = 128;
pub const FMOD_THREAD_AFFINITY_CORE_8: u32 = 256;
pub const FMOD_THREAD_AFFINITY_CORE_9: u32 = 512;
pub const FMOD_THREAD_AFFINITY_CORE_10: u32 = 1024;
pub const FMOD_THREAD_AFFINITY_CORE_11: u32 = 2048;
pub const FMOD_THREAD_AFFINITY_CORE_12: u32 = 4096;
pub const FMOD_THREAD_AFFINITY_CORE_13: u32 = 8192;
pub const FMOD_THREAD_AFFINITY_CORE_14: u32 = 16384;
pub const FMOD_THREAD_AFFINITY_CORE_15: u32 = 32768;
pub const FMOD_MAX_CHANNEL_WIDTH: u32 = 32;
pub const FMOD_MAX_SYSTEMS: u32 = 8;
pub const FMOD_MAX_LISTENERS: u32 = 8;
pub const FMOD_REVERB_MAXINSTANCES: u32 = 4;
pub const FMOD_CODEC_PLUGIN_VERSION: u32 = 1;
pub const FMOD_CODEC_SEEK_METHOD_SET: u32 = 0;
pub const FMOD_CODEC_SEEK_METHOD_CURRENT: u32 = 1;
pub const FMOD_CODEC_SEEK_METHOD_END: u32 = 2;
pub const FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES: u32 = 66;
pub const FMOD_PLUGIN_SDK_VERSION: u32 = 110;
pub const FMOD_DSP_GETPARAM_VALUESTR_LENGTH: u32 = 32;
pub const FMOD_OUTPUT_PLUGIN_VERSION: u32 = 5;
pub const FMOD_OUTPUT_METHOD_MIX_DIRECT: u32 = 0;
pub const FMOD_OUTPUT_METHOD_MIX_BUFFERED: u32 = 1;
pub const __bool_true_false_are_defined: u32 = 1;
pub const true_: u32 = 1;
pub const false_: u32 = 0;
pub const FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT: u32 = 32;
pub const FMOD_STUDIO_INIT_NORMAL: u32 = 0;
pub const FMOD_STUDIO_INIT_LIVEUPDATE: u32 = 1;
pub const FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS: u32 = 2;
pub const FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE: u32 = 4;
pub const FMOD_STUDIO_INIT_DEFERRED_CALLBACKS: u32 = 8;
pub const FMOD_STUDIO_INIT_LOAD_FROM_UPDATE: u32 = 16;
pub const FMOD_STUDIO_INIT_MEMORY_TRACKING: u32 = 32;
pub const FMOD_STUDIO_PARAMETER_READONLY: u32 = 1;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC: u32 = 2;
pub const FMOD_STUDIO_PARAMETER_GLOBAL: u32 = 4;
pub const FMOD_STUDIO_PARAMETER_DISCRETE: u32 = 8;
pub const FMOD_STUDIO_PARAMETER_LABELED: u32 = 16;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE: u32 = 1;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE: u32 = 2;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD: u32 = 4;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED: u32 = 8;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED: u32 = 16;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_ALL: u32 = 4294967295;
pub const FMOD_STUDIO_EVENT_CALLBACK_CREATED: u32 = 1;
pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROYED: u32 = 2;
pub const FMOD_STUDIO_EVENT_CALLBACK_STARTING: u32 = 4;
pub const FMOD_STUDIO_EVENT_CALLBACK_STARTED: u32 = 8;
pub const FMOD_STUDIO_EVENT_CALLBACK_RESTARTED: u32 = 16;
pub const FMOD_STUDIO_EVENT_CALLBACK_STOPPED: u32 = 32;
pub const FMOD_STUDIO_EVENT_CALLBACK_START_FAILED: u32 = 64;
pub const FMOD_STUDIO_EVENT_CALLBACK_CREATE_PROGRAMMER_SOUND: u32 = 128;
pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROY_PROGRAMMER_SOUND: u32 = 256;
pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_CREATED: u32 = 512;
pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_DESTROYED: u32 = 1024;
pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_MARKER: u32 = 2048;
pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_BEAT: u32 = 4096;
pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_PLAYED: u32 = 8192;
pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_STOPPED: u32 = 16384;
pub const FMOD_STUDIO_EVENT_CALLBACK_REAL_TO_VIRTUAL: u32 = 32768;
pub const FMOD_STUDIO_EVENT_CALLBACK_VIRTUAL_TO_REAL: u32 = 65536;
pub const FMOD_STUDIO_EVENT_CALLBACK_START_EVENT_COMMAND: u32 = 131072;
pub const FMOD_STUDIO_EVENT_CALLBACK_NESTED_TIMELINE_BEAT: u32 = 262144;
pub const FMOD_STUDIO_EVENT_CALLBACK_ALL: u32 = 4294967295;
pub const FMOD_STUDIO_LOAD_BANK_NORMAL: u32 = 0;
pub const FMOD_STUDIO_LOAD_BANK_NONBLOCKING: u32 = 1;
pub const FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES: u32 = 2;
pub const FMOD_STUDIO_LOAD_BANK_UNENCRYPTED: u32 = 4;
pub const FMOD_STUDIO_COMMANDCAPTURE_NORMAL: u32 = 0;
pub const FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH: u32 = 1;
pub const FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE: u32 = 2;
pub const FMOD_STUDIO_COMMANDREPLAY_NORMAL: u32 = 0;
pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP: u32 = 1;
pub const FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD: u32 = 2;
pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD: u32 = 4;
#[repr(transparent)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_BOOL(pub ::std::os::raw::c_int);
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_SYSTEM {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_SOUND {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CHANNELCONTROL {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CHANNEL {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CHANNELGROUP {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_SOUNDGROUP {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_REVERB3D {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSPCONNECTION {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_POLYGON {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_GEOMETRY {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_SYNCPOINT {
    _unused: [u8; 0],
}
pub type FMOD_DEBUG_FLAGS = ::std::os::raw::c_uint;
pub type FMOD_MEMORY_TYPE = ::std::os::raw::c_uint;
pub type FMOD_INITFLAGS = ::std::os::raw::c_uint;
pub type FMOD_DRIVER_STATE = ::std::os::raw::c_uint;
pub type FMOD_TIMEUNIT = ::std::os::raw::c_uint;
pub type FMOD_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
pub type FMOD_MODE = ::std::os::raw::c_uint;
pub type FMOD_CHANNELMASK = ::std::os::raw::c_uint;
pub type FMOD_PORT_INDEX = ::std::os::raw::c_ulonglong;
pub type FMOD_THREAD_PRIORITY = ::std::os::raw::c_int;
pub type FMOD_THREAD_STACK_SIZE = ::std::os::raw::c_uint;
pub type FMOD_THREAD_AFFINITY = ::std::os::raw::c_longlong;
pub const FMOD_THREAD_TYPE_MIXER: FMOD_THREAD_TYPE = 0;
pub const FMOD_THREAD_TYPE_FEEDER: FMOD_THREAD_TYPE = 1;
pub const FMOD_THREAD_TYPE_STREAM: FMOD_THREAD_TYPE = 2;
pub const FMOD_THREAD_TYPE_FILE: FMOD_THREAD_TYPE = 3;
pub const FMOD_THREAD_TYPE_NONBLOCKING: FMOD_THREAD_TYPE = 4;
pub const FMOD_THREAD_TYPE_RECORD: FMOD_THREAD_TYPE = 5;
pub const FMOD_THREAD_TYPE_GEOMETRY: FMOD_THREAD_TYPE = 6;
pub const FMOD_THREAD_TYPE_PROFILER: FMOD_THREAD_TYPE = 7;
pub const FMOD_THREAD_TYPE_STUDIO_UPDATE: FMOD_THREAD_TYPE = 8;
pub const FMOD_THREAD_TYPE_STUDIO_LOAD_BANK: FMOD_THREAD_TYPE = 9;
pub const FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE: FMOD_THREAD_TYPE = 10;
pub const FMOD_THREAD_TYPE_CONVOLUTION1: FMOD_THREAD_TYPE = 11;
pub const FMOD_THREAD_TYPE_CONVOLUTION2: FMOD_THREAD_TYPE = 12;
pub const FMOD_THREAD_TYPE_MAX: FMOD_THREAD_TYPE = 13;
pub const FMOD_THREAD_TYPE_FORCEINT: FMOD_THREAD_TYPE = 65536;
pub type FMOD_THREAD_TYPE = ::std::os::raw::c_uint;
impl FMOD_RESULT {
    pub const FMOD_OK: FMOD_RESULT = FMOD_RESULT(0);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_BADCOMMAND: FMOD_RESULT = FMOD_RESULT(1);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_CHANNEL_ALLOC: FMOD_RESULT = FMOD_RESULT(2);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_CHANNEL_STOLEN: FMOD_RESULT = FMOD_RESULT(3);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DMA: FMOD_RESULT = FMOD_RESULT(4);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_CONNECTION: FMOD_RESULT = FMOD_RESULT(5);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_DONTPROCESS: FMOD_RESULT = FMOD_RESULT(6);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_FORMAT: FMOD_RESULT = FMOD_RESULT(7);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_INUSE: FMOD_RESULT = FMOD_RESULT(8);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_NOTFOUND: FMOD_RESULT = FMOD_RESULT(9);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_RESERVED: FMOD_RESULT = FMOD_RESULT(10);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_SILENCE: FMOD_RESULT = FMOD_RESULT(11);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_DSP_TYPE: FMOD_RESULT = FMOD_RESULT(12);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_BAD: FMOD_RESULT = FMOD_RESULT(13);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_COULDNOTSEEK: FMOD_RESULT = FMOD_RESULT(14);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_DISKEJECTED: FMOD_RESULT = FMOD_RESULT(15);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_EOF: FMOD_RESULT = FMOD_RESULT(16);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_ENDOFDATA: FMOD_RESULT = FMOD_RESULT(17);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FILE_NOTFOUND: FMOD_RESULT = FMOD_RESULT(18);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_FORMAT: FMOD_RESULT = FMOD_RESULT(19);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HEADER_MISMATCH: FMOD_RESULT = FMOD_RESULT(20);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HTTP: FMOD_RESULT = FMOD_RESULT(21);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HTTP_ACCESS: FMOD_RESULT = FMOD_RESULT(22);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HTTP_PROXY_AUTH: FMOD_RESULT = FMOD_RESULT(23);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HTTP_SERVER_ERROR: FMOD_RESULT = FMOD_RESULT(24);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_HTTP_TIMEOUT: FMOD_RESULT = FMOD_RESULT(25);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INITIALIZATION: FMOD_RESULT = FMOD_RESULT(26);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INITIALIZED: FMOD_RESULT = FMOD_RESULT(27);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INTERNAL: FMOD_RESULT = FMOD_RESULT(28);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_FLOAT: FMOD_RESULT = FMOD_RESULT(29);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_HANDLE: FMOD_RESULT = FMOD_RESULT(30);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_PARAM: FMOD_RESULT = FMOD_RESULT(31);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_POSITION: FMOD_RESULT = FMOD_RESULT(32);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_SPEAKER: FMOD_RESULT = FMOD_RESULT(33);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_SYNCPOINT: FMOD_RESULT = FMOD_RESULT(34);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_THREAD: FMOD_RESULT = FMOD_RESULT(35);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_VECTOR: FMOD_RESULT = FMOD_RESULT(36);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_MAXAUDIBLE: FMOD_RESULT = FMOD_RESULT(37);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_MEMORY: FMOD_RESULT = FMOD_RESULT(38);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_MEMORY_CANTPOINT: FMOD_RESULT = FMOD_RESULT(39);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NEEDS3D: FMOD_RESULT = FMOD_RESULT(40);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NEEDSHARDWARE: FMOD_RESULT = FMOD_RESULT(41);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NET_CONNECT: FMOD_RESULT = FMOD_RESULT(42);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NET_SOCKET_ERROR: FMOD_RESULT = FMOD_RESULT(43);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NET_URL: FMOD_RESULT = FMOD_RESULT(44);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NET_WOULD_BLOCK: FMOD_RESULT = FMOD_RESULT(45);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NOTREADY: FMOD_RESULT = FMOD_RESULT(46);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_ALLOCATED: FMOD_RESULT = FMOD_RESULT(47);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_CREATEBUFFER: FMOD_RESULT = FMOD_RESULT(48);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_DRIVERCALL: FMOD_RESULT = FMOD_RESULT(49);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_FORMAT: FMOD_RESULT = FMOD_RESULT(50);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_INIT: FMOD_RESULT = FMOD_RESULT(51);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_OUTPUT_NODRIVERS: FMOD_RESULT = FMOD_RESULT(52);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_PLUGIN: FMOD_RESULT = FMOD_RESULT(53);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_PLUGIN_MISSING: FMOD_RESULT = FMOD_RESULT(54);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_PLUGIN_RESOURCE: FMOD_RESULT = FMOD_RESULT(55);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_PLUGIN_VERSION: FMOD_RESULT = FMOD_RESULT(56);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_RECORD: FMOD_RESULT = FMOD_RESULT(57);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_REVERB_CHANNELGROUP: FMOD_RESULT = FMOD_RESULT(58);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_REVERB_INSTANCE: FMOD_RESULT = FMOD_RESULT(59);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_SUBSOUNDS: FMOD_RESULT = FMOD_RESULT(60);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_SUBSOUND_ALLOCATED: FMOD_RESULT = FMOD_RESULT(61);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_SUBSOUND_CANTMOVE: FMOD_RESULT = FMOD_RESULT(62);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_TAGNOTFOUND: FMOD_RESULT = FMOD_RESULT(63);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_TOOMANYCHANNELS: FMOD_RESULT = FMOD_RESULT(64);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_TRUNCATED: FMOD_RESULT = FMOD_RESULT(65);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_UNIMPLEMENTED: FMOD_RESULT = FMOD_RESULT(66);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(67);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_UNSUPPORTED: FMOD_RESULT = FMOD_RESULT(68);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_VERSION: FMOD_RESULT = FMOD_RESULT(69);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_EVENT_ALREADY_LOADED: FMOD_RESULT = FMOD_RESULT(70);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_EVENT_LIVEUPDATE_BUSY: FMOD_RESULT = FMOD_RESULT(71);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH: FMOD_RESULT = FMOD_RESULT(72);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT: FMOD_RESULT = FMOD_RESULT(73);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_EVENT_NOTFOUND: FMOD_RESULT = FMOD_RESULT(74);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_STUDIO_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(75);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_STUDIO_NOT_LOADED: FMOD_RESULT = FMOD_RESULT(76);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_INVALID_STRING: FMOD_RESULT = FMOD_RESULT(77);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_ALREADY_LOCKED: FMOD_RESULT = FMOD_RESULT(78);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_NOT_LOCKED: FMOD_RESULT = FMOD_RESULT(79);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_RECORD_DISCONNECTED: FMOD_RESULT = FMOD_RESULT(80);
}
impl FMOD_RESULT {
    pub const FMOD_ERR_TOOMANYSAMPLES: FMOD_RESULT = FMOD_RESULT(81);
}
impl FMOD_RESULT {
    pub const FMOD_RESULT_FORCEINT: FMOD_RESULT = FMOD_RESULT(65536);
}
#[repr(transparent)]
#[must_use]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_RESULT(pub ::std::os::raw::c_uint);
pub const FMOD_CHANNELCONTROL_CHANNEL: FMOD_CHANNELCONTROL_TYPE = 0;
pub const FMOD_CHANNELCONTROL_CHANNELGROUP: FMOD_CHANNELCONTROL_TYPE = 1;
pub const FMOD_CHANNELCONTROL_MAX: FMOD_CHANNELCONTROL_TYPE = 2;
pub const FMOD_CHANNELCONTROL_FORCEINT: FMOD_CHANNELCONTROL_TYPE = 65536;
pub type FMOD_CHANNELCONTROL_TYPE = ::std::os::raw::c_uint;
pub const FMOD_OUTPUTTYPE_AUTODETECT: FMOD_OUTPUTTYPE = 0;
pub const FMOD_OUTPUTTYPE_UNKNOWN: FMOD_OUTPUTTYPE = 1;
pub const FMOD_OUTPUTTYPE_NOSOUND: FMOD_OUTPUTTYPE = 2;
pub const FMOD_OUTPUTTYPE_WAVWRITER: FMOD_OUTPUTTYPE = 3;
pub const FMOD_OUTPUTTYPE_NOSOUND_NRT: FMOD_OUTPUTTYPE = 4;
pub const FMOD_OUTPUTTYPE_WAVWRITER_NRT: FMOD_OUTPUTTYPE = 5;
pub const FMOD_OUTPUTTYPE_WASAPI: FMOD_OUTPUTTYPE = 6;
pub const FMOD_OUTPUTTYPE_ASIO: FMOD_OUTPUTTYPE = 7;
pub const FMOD_OUTPUTTYPE_PULSEAUDIO: FMOD_OUTPUTTYPE = 8;
pub const FMOD_OUTPUTTYPE_ALSA: FMOD_OUTPUTTYPE = 9;
pub const FMOD_OUTPUTTYPE_COREAUDIO: FMOD_OUTPUTTYPE = 10;
pub const FMOD_OUTPUTTYPE_AUDIOTRACK: FMOD_OUTPUTTYPE = 11;
pub const FMOD_OUTPUTTYPE_OPENSL: FMOD_OUTPUTTYPE = 12;
pub const FMOD_OUTPUTTYPE_AUDIOOUT: FMOD_OUTPUTTYPE = 13;
pub const FMOD_OUTPUTTYPE_AUDIO3D: FMOD_OUTPUTTYPE = 14;
pub const FMOD_OUTPUTTYPE_WEBAUDIO: FMOD_OUTPUTTYPE = 15;
pub const FMOD_OUTPUTTYPE_NNAUDIO: FMOD_OUTPUTTYPE = 16;
pub const FMOD_OUTPUTTYPE_WINSONIC: FMOD_OUTPUTTYPE = 17;
pub const FMOD_OUTPUTTYPE_AAUDIO: FMOD_OUTPUTTYPE = 18;
pub const FMOD_OUTPUTTYPE_AUDIOWORKLET: FMOD_OUTPUTTYPE = 19;
pub const FMOD_OUTPUTTYPE_PHASE: FMOD_OUTPUTTYPE = 20;
pub const FMOD_OUTPUTTYPE_OHAUDIO: FMOD_OUTPUTTYPE = 21;
pub const FMOD_OUTPUTTYPE_MAX: FMOD_OUTPUTTYPE = 22;
pub const FMOD_OUTPUTTYPE_FORCEINT: FMOD_OUTPUTTYPE = 65536;
pub type FMOD_OUTPUTTYPE = ::std::os::raw::c_uint;
pub const FMOD_DEBUG_MODE_TTY: FMOD_DEBUG_MODE = 0;
pub const FMOD_DEBUG_MODE_FILE: FMOD_DEBUG_MODE = 1;
pub const FMOD_DEBUG_MODE_CALLBACK: FMOD_DEBUG_MODE = 2;
pub const FMOD_DEBUG_MODE_FORCEINT: FMOD_DEBUG_MODE = 65536;
pub type FMOD_DEBUG_MODE = ::std::os::raw::c_uint;
pub const FMOD_SPEAKERMODE_DEFAULT: FMOD_SPEAKERMODE = 0;
pub const FMOD_SPEAKERMODE_RAW: FMOD_SPEAKERMODE = 1;
pub const FMOD_SPEAKERMODE_MONO: FMOD_SPEAKERMODE = 2;
pub const FMOD_SPEAKERMODE_STEREO: FMOD_SPEAKERMODE = 3;
pub const FMOD_SPEAKERMODE_QUAD: FMOD_SPEAKERMODE = 4;
pub const FMOD_SPEAKERMODE_SURROUND: FMOD_SPEAKERMODE = 5;
pub const FMOD_SPEAKERMODE_5POINT1: FMOD_SPEAKERMODE = 6;
pub const FMOD_SPEAKERMODE_7POINT1: FMOD_SPEAKERMODE = 7;
pub const FMOD_SPEAKERMODE_7POINT1POINT4: FMOD_SPEAKERMODE = 8;
pub const FMOD_SPEAKERMODE_MAX: FMOD_SPEAKERMODE = 9;
pub const FMOD_SPEAKERMODE_FORCEINT: FMOD_SPEAKERMODE = 65536;
pub type FMOD_SPEAKERMODE = ::std::os::raw::c_uint;
pub const FMOD_SPEAKER_NONE: FMOD_SPEAKER = -1;
pub const FMOD_SPEAKER_FRONT_LEFT: FMOD_SPEAKER = 0;
pub const FMOD_SPEAKER_FRONT_RIGHT: FMOD_SPEAKER = 1;
pub const FMOD_SPEAKER_FRONT_CENTER: FMOD_SPEAKER = 2;
pub const FMOD_SPEAKER_LOW_FREQUENCY: FMOD_SPEAKER = 3;
pub const FMOD_SPEAKER_SURROUND_LEFT: FMOD_SPEAKER = 4;
pub const FMOD_SPEAKER_SURROUND_RIGHT: FMOD_SPEAKER = 5;
pub const FMOD_SPEAKER_BACK_LEFT: FMOD_SPEAKER = 6;
pub const FMOD_SPEAKER_BACK_RIGHT: FMOD_SPEAKER = 7;
pub const FMOD_SPEAKER_TOP_FRONT_LEFT: FMOD_SPEAKER = 8;
pub const FMOD_SPEAKER_TOP_FRONT_RIGHT: FMOD_SPEAKER = 9;
pub const FMOD_SPEAKER_TOP_BACK_LEFT: FMOD_SPEAKER = 10;
pub const FMOD_SPEAKER_TOP_BACK_RIGHT: FMOD_SPEAKER = 11;
pub const FMOD_SPEAKER_MAX: FMOD_SPEAKER = 12;
pub const FMOD_SPEAKER_FORCEINT: FMOD_SPEAKER = 65536;
pub type FMOD_SPEAKER = ::std::os::raw::c_int;
pub const FMOD_CHANNELORDER_DEFAULT: FMOD_CHANNELORDER = 0;
pub const FMOD_CHANNELORDER_WAVEFORMAT: FMOD_CHANNELORDER = 1;
pub const FMOD_CHANNELORDER_PROTOOLS: FMOD_CHANNELORDER = 2;
pub const FMOD_CHANNELORDER_ALLMONO: FMOD_CHANNELORDER = 3;
pub const FMOD_CHANNELORDER_ALLSTEREO: FMOD_CHANNELORDER = 4;
pub const FMOD_CHANNELORDER_ALSA: FMOD_CHANNELORDER = 5;
pub const FMOD_CHANNELORDER_MAX: FMOD_CHANNELORDER = 6;
pub const FMOD_CHANNELORDER_FORCEINT: FMOD_CHANNELORDER = 65536;
pub type FMOD_CHANNELORDER = ::std::os::raw::c_uint;
pub const FMOD_PLUGINTYPE_OUTPUT: FMOD_PLUGINTYPE = 0;
pub const FMOD_PLUGINTYPE_CODEC: FMOD_PLUGINTYPE = 1;
pub const FMOD_PLUGINTYPE_DSP: FMOD_PLUGINTYPE = 2;
pub const FMOD_PLUGINTYPE_MAX: FMOD_PLUGINTYPE = 3;
pub const FMOD_PLUGINTYPE_FORCEINT: FMOD_PLUGINTYPE = 65536;
pub type FMOD_PLUGINTYPE = ::std::os::raw::c_uint;
pub const FMOD_SOUND_TYPE_UNKNOWN: FMOD_SOUND_TYPE = 0;
pub const FMOD_SOUND_TYPE_AIFF: FMOD_SOUND_TYPE = 1;
pub const FMOD_SOUND_TYPE_ASF: FMOD_SOUND_TYPE = 2;
pub const FMOD_SOUND_TYPE_DLS: FMOD_SOUND_TYPE = 3;
pub const FMOD_SOUND_TYPE_FLAC: FMOD_SOUND_TYPE = 4;
pub const FMOD_SOUND_TYPE_FSB: FMOD_SOUND_TYPE = 5;
pub const FMOD_SOUND_TYPE_IT: FMOD_SOUND_TYPE = 6;
pub const FMOD_SOUND_TYPE_MIDI: FMOD_SOUND_TYPE = 7;
pub const FMOD_SOUND_TYPE_MOD: FMOD_SOUND_TYPE = 8;
pub const FMOD_SOUND_TYPE_MPEG: FMOD_SOUND_TYPE = 9;
pub const FMOD_SOUND_TYPE_OGGVORBIS: FMOD_SOUND_TYPE = 10;
pub const FMOD_SOUND_TYPE_PLAYLIST: FMOD_SOUND_TYPE = 11;
pub const FMOD_SOUND_TYPE_RAW: FMOD_SOUND_TYPE = 12;
pub const FMOD_SOUND_TYPE_S3M: FMOD_SOUND_TYPE = 13;
pub const FMOD_SOUND_TYPE_USER: FMOD_SOUND_TYPE = 14;
pub const FMOD_SOUND_TYPE_WAV: FMOD_SOUND_TYPE = 15;
pub const FMOD_SOUND_TYPE_XM: FMOD_SOUND_TYPE = 16;
pub const FMOD_SOUND_TYPE_XMA: FMOD_SOUND_TYPE = 17;
pub const FMOD_SOUND_TYPE_AUDIOQUEUE: FMOD_SOUND_TYPE = 18;
pub const FMOD_SOUND_TYPE_AT9: FMOD_SOUND_TYPE = 19;
pub const FMOD_SOUND_TYPE_VORBIS: FMOD_SOUND_TYPE = 20;
pub const FMOD_SOUND_TYPE_MEDIA_FOUNDATION: FMOD_SOUND_TYPE = 21;
pub const FMOD_SOUND_TYPE_MEDIACODEC: FMOD_SOUND_TYPE = 22;
pub const FMOD_SOUND_TYPE_FADPCM: FMOD_SOUND_TYPE = 23;
pub const FMOD_SOUND_TYPE_OPUS: FMOD_SOUND_TYPE = 24;
pub const FMOD_SOUND_TYPE_MAX: FMOD_SOUND_TYPE = 25;
pub const FMOD_SOUND_TYPE_FORCEINT: FMOD_SOUND_TYPE = 65536;
pub type FMOD_SOUND_TYPE = ::std::os::raw::c_uint;
pub const FMOD_SOUND_FORMAT_NONE: FMOD_SOUND_FORMAT = 0;
pub const FMOD_SOUND_FORMAT_PCM8: FMOD_SOUND_FORMAT = 1;
pub const FMOD_SOUND_FORMAT_PCM16: FMOD_SOUND_FORMAT = 2;
pub const FMOD_SOUND_FORMAT_PCM24: FMOD_SOUND_FORMAT = 3;
pub const FMOD_SOUND_FORMAT_PCM32: FMOD_SOUND_FORMAT = 4;
pub const FMOD_SOUND_FORMAT_PCMFLOAT: FMOD_SOUND_FORMAT = 5;
pub const FMOD_SOUND_FORMAT_BITSTREAM: FMOD_SOUND_FORMAT = 6;
pub const FMOD_SOUND_FORMAT_MAX: FMOD_SOUND_FORMAT = 7;
pub const FMOD_SOUND_FORMAT_FORCEINT: FMOD_SOUND_FORMAT = 65536;
pub type FMOD_SOUND_FORMAT = ::std::os::raw::c_uint;
pub const FMOD_OPENSTATE_READY: FMOD_OPENSTATE = 0;
pub const FMOD_OPENSTATE_LOADING: FMOD_OPENSTATE = 1;
pub const FMOD_OPENSTATE_ERROR: FMOD_OPENSTATE = 2;
pub const FMOD_OPENSTATE_CONNECTING: FMOD_OPENSTATE = 3;
pub const FMOD_OPENSTATE_BUFFERING: FMOD_OPENSTATE = 4;
pub const FMOD_OPENSTATE_SEEKING: FMOD_OPENSTATE = 5;
pub const FMOD_OPENSTATE_PLAYING: FMOD_OPENSTATE = 6;
pub const FMOD_OPENSTATE_SETPOSITION: FMOD_OPENSTATE = 7;
pub const FMOD_OPENSTATE_MAX: FMOD_OPENSTATE = 8;
pub const FMOD_OPENSTATE_FORCEINT: FMOD_OPENSTATE = 65536;
pub type FMOD_OPENSTATE = ::std::os::raw::c_uint;
pub const FMOD_SOUNDGROUP_BEHAVIOR_FAIL: FMOD_SOUNDGROUP_BEHAVIOR = 0;
pub const FMOD_SOUNDGROUP_BEHAVIOR_MUTE: FMOD_SOUNDGROUP_BEHAVIOR = 1;
pub const FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST: FMOD_SOUNDGROUP_BEHAVIOR = 2;
pub const FMOD_SOUNDGROUP_BEHAVIOR_MAX: FMOD_SOUNDGROUP_BEHAVIOR = 3;
pub const FMOD_SOUNDGROUP_BEHAVIOR_FORCEINT: FMOD_SOUNDGROUP_BEHAVIOR = 65536;
pub type FMOD_SOUNDGROUP_BEHAVIOR = ::std::os::raw::c_uint;
pub const FMOD_CHANNELCONTROL_CALLBACK_END: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 0;
pub const FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 1;
pub const FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 2;
pub const FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 3;
pub const FMOD_CHANNELCONTROL_CALLBACK_MAX: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 4;
pub const FMOD_CHANNELCONTROL_CALLBACK_FORCEINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 65536;
pub type FMOD_CHANNELCONTROL_CALLBACK_TYPE = ::std::os::raw::c_uint;
pub const FMOD_CHANNELCONTROL_DSP_HEAD: FMOD_CHANNELCONTROL_DSP_INDEX = -1;
pub const FMOD_CHANNELCONTROL_DSP_FADER: FMOD_CHANNELCONTROL_DSP_INDEX = -2;
pub const FMOD_CHANNELCONTROL_DSP_TAIL: FMOD_CHANNELCONTROL_DSP_INDEX = -3;
pub const FMOD_CHANNELCONTROL_DSP_FORCEINT: FMOD_CHANNELCONTROL_DSP_INDEX = 65536;
pub type FMOD_CHANNELCONTROL_DSP_INDEX = ::std::os::raw::c_int;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_NONE: FMOD_ERRORCALLBACK_INSTANCETYPE = 0;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 1;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL: FMOD_ERRORCALLBACK_INSTANCETYPE = 2;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 3;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL: FMOD_ERRORCALLBACK_INSTANCETYPE = 4;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND: FMOD_ERRORCALLBACK_INSTANCETYPE = 5;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 6;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSP: FMOD_ERRORCALLBACK_INSTANCETYPE = 7;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION: FMOD_ERRORCALLBACK_INSTANCETYPE = 8;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY: FMOD_ERRORCALLBACK_INSTANCETYPE = 9;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D: FMOD_ERRORCALLBACK_INSTANCETYPE = 10;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 11;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION: FMOD_ERRORCALLBACK_INSTANCETYPE =
    12;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE: FMOD_ERRORCALLBACK_INSTANCETYPE =
    13;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE:
    FMOD_ERRORCALLBACK_INSTANCETYPE = 14;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS: FMOD_ERRORCALLBACK_INSTANCETYPE = 15;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA: FMOD_ERRORCALLBACK_INSTANCETYPE = 16;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK: FMOD_ERRORCALLBACK_INSTANCETYPE = 17;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY: FMOD_ERRORCALLBACK_INSTANCETYPE =
    18;
pub const FMOD_ERRORCALLBACK_INSTANCETYPE_FORCEINT: FMOD_ERRORCALLBACK_INSTANCETYPE = 65536;
pub type FMOD_ERRORCALLBACK_INSTANCETYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_RESAMPLER_DEFAULT: FMOD_DSP_RESAMPLER = 0;
pub const FMOD_DSP_RESAMPLER_NOINTERP: FMOD_DSP_RESAMPLER = 1;
pub const FMOD_DSP_RESAMPLER_LINEAR: FMOD_DSP_RESAMPLER = 2;
pub const FMOD_DSP_RESAMPLER_CUBIC: FMOD_DSP_RESAMPLER = 3;
pub const FMOD_DSP_RESAMPLER_SPLINE: FMOD_DSP_RESAMPLER = 4;
pub const FMOD_DSP_RESAMPLER_MAX: FMOD_DSP_RESAMPLER = 5;
pub const FMOD_DSP_RESAMPLER_FORCEINT: FMOD_DSP_RESAMPLER = 65536;
pub type FMOD_DSP_RESAMPLER = ::std::os::raw::c_uint;
pub const FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE: FMOD_DSP_CALLBACK_TYPE = 0;
pub const FMOD_DSP_CALLBACK_MAX: FMOD_DSP_CALLBACK_TYPE = 1;
pub const FMOD_DSP_CALLBACK_FORCEINT: FMOD_DSP_CALLBACK_TYPE = 65536;
pub type FMOD_DSP_CALLBACK_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSPCONNECTION_TYPE_STANDARD: FMOD_DSPCONNECTION_TYPE = 0;
pub const FMOD_DSPCONNECTION_TYPE_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 1;
pub const FMOD_DSPCONNECTION_TYPE_SEND: FMOD_DSPCONNECTION_TYPE = 2;
pub const FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 3;
pub const FMOD_DSPCONNECTION_TYPE_MAX: FMOD_DSPCONNECTION_TYPE = 4;
pub const FMOD_DSPCONNECTION_TYPE_FORCEINT: FMOD_DSPCONNECTION_TYPE = 65536;
pub type FMOD_DSPCONNECTION_TYPE = ::std::os::raw::c_uint;
pub const FMOD_TAGTYPE_UNKNOWN: FMOD_TAGTYPE = 0;
pub const FMOD_TAGTYPE_ID3V1: FMOD_TAGTYPE = 1;
pub const FMOD_TAGTYPE_ID3V2: FMOD_TAGTYPE = 2;
pub const FMOD_TAGTYPE_VORBISCOMMENT: FMOD_TAGTYPE = 3;
pub const FMOD_TAGTYPE_SHOUTCAST: FMOD_TAGTYPE = 4;
pub const FMOD_TAGTYPE_ICECAST: FMOD_TAGTYPE = 5;
pub const FMOD_TAGTYPE_ASF: FMOD_TAGTYPE = 6;
pub const FMOD_TAGTYPE_MIDI: FMOD_TAGTYPE = 7;
pub const FMOD_TAGTYPE_PLAYLIST: FMOD_TAGTYPE = 8;
pub const FMOD_TAGTYPE_FMOD: FMOD_TAGTYPE = 9;
pub const FMOD_TAGTYPE_USER: FMOD_TAGTYPE = 10;
pub const FMOD_TAGTYPE_MAX: FMOD_TAGTYPE = 11;
pub const FMOD_TAGTYPE_FORCEINT: FMOD_TAGTYPE = 65536;
pub type FMOD_TAGTYPE = ::std::os::raw::c_uint;
pub const FMOD_TAGDATATYPE_BINARY: FMOD_TAGDATATYPE = 0;
pub const FMOD_TAGDATATYPE_INT: FMOD_TAGDATATYPE = 1;
pub const FMOD_TAGDATATYPE_FLOAT: FMOD_TAGDATATYPE = 2;
pub const FMOD_TAGDATATYPE_STRING: FMOD_TAGDATATYPE = 3;
pub const FMOD_TAGDATATYPE_STRING_UTF16: FMOD_TAGDATATYPE = 4;
pub const FMOD_TAGDATATYPE_STRING_UTF16BE: FMOD_TAGDATATYPE = 5;
pub const FMOD_TAGDATATYPE_STRING_UTF8: FMOD_TAGDATATYPE = 6;
pub const FMOD_TAGDATATYPE_MAX: FMOD_TAGDATATYPE = 7;
pub const FMOD_TAGDATATYPE_FORCEINT: FMOD_TAGDATATYPE = 65536;
pub type FMOD_TAGDATATYPE = ::std::os::raw::c_uint;
pub const FMOD_PORT_TYPE_MUSIC: FMOD_PORT_TYPE = 0;
pub const FMOD_PORT_TYPE_COPYRIGHT_MUSIC: FMOD_PORT_TYPE = 1;
pub const FMOD_PORT_TYPE_VOICE: FMOD_PORT_TYPE = 2;
pub const FMOD_PORT_TYPE_CONTROLLER: FMOD_PORT_TYPE = 3;
pub const FMOD_PORT_TYPE_PERSONAL: FMOD_PORT_TYPE = 4;
pub const FMOD_PORT_TYPE_VIBRATION: FMOD_PORT_TYPE = 5;
pub const FMOD_PORT_TYPE_AUX: FMOD_PORT_TYPE = 6;
pub const FMOD_PORT_TYPE_PASSTHROUGH: FMOD_PORT_TYPE = 7;
pub const FMOD_PORT_TYPE_VR_VIBRATION: FMOD_PORT_TYPE = 8;
pub const FMOD_PORT_TYPE_MAX: FMOD_PORT_TYPE = 9;
pub const FMOD_PORT_TYPE_FORCEINT: FMOD_PORT_TYPE = 65536;
pub type FMOD_PORT_TYPE = ::std::os::raw::c_uint;
pub type FMOD_DEBUG_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        flags: FMOD_DEBUG_FLAGS,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        func: *const ::std::os::raw::c_char,
        message: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_SYSTEM_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_SYSTEM_CALLBACK_TYPE,
        commanddata1: *mut ::std::os::raw::c_void,
        commanddata2: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CHANNELCONTROL_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        controltype: FMOD_CHANNELCONTROL_TYPE,
        callbacktype: FMOD_CHANNELCONTROL_CALLBACK_TYPE,
        commanddata1: *mut ::std::os::raw::c_void,
        commanddata2: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp: *mut FMOD_DSP,
        type_: FMOD_DSP_CALLBACK_TYPE,
        data: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_SOUND_NONBLOCK_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(sound: *mut FMOD_SOUND, result: FMOD_RESULT) -> FMOD_RESULT,
>;
pub type FMOD_SOUND_PCMREAD_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        sound: *mut FMOD_SOUND,
        data: *mut ::std::os::raw::c_void,
        datalen: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_SOUND_PCMSETPOS_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        sound: *mut FMOD_SOUND,
        subsound: ::std::os::raw::c_int,
        position: ::std::os::raw::c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_OPEN_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        name: *const ::std::os::raw::c_char,
        filesize: *mut ::std::os::raw::c_uint,
        handle: *mut *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_CLOSE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        handle: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_READ_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        handle: *mut ::std::os::raw::c_void,
        buffer: *mut ::std::os::raw::c_void,
        sizebytes: ::std::os::raw::c_uint,
        bytesread: *mut ::std::os::raw::c_uint,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_SEEK_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        handle: *mut ::std::os::raw::c_void,
        pos: ::std::os::raw::c_uint,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCREAD_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        info: *mut FMOD_ASYNCREADINFO,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCCANCEL_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        info: *mut FMOD_ASYNCREADINFO,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCDONE_FUNC =
    ::std::option::Option<unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, result: FMOD_RESULT)>;
pub type FMOD_MEMORY_ALLOC_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        size: ::std::os::raw::c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_MEMORY_REALLOC_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_MEMORY_FREE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ),
>;
pub type FMOD_3D_ROLLOFF_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(channelcontrol: *mut FMOD_CHANNELCONTROL, distance: f32) -> f32,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_ASYNCREADINFO {
    pub handle: *mut ::std::os::raw::c_void,
    pub offset: ::std::os::raw::c_uint,
    pub sizebytes: ::std::os::raw::c_uint,
    pub priority: ::std::os::raw::c_int,
    pub userdata: *mut ::std::os::raw::c_void,
    pub buffer: *mut ::std::os::raw::c_void,
    pub bytesread: ::std::os::raw::c_uint,
    pub done: FMOD_FILE_ASYNCDONE_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_ASYNCREADINFO"][::std::mem::size_of::<FMOD_ASYNCREADINFO>() - 56usize];
    ["Alignment of FMOD_ASYNCREADINFO"][::std::mem::align_of::<FMOD_ASYNCREADINFO>() - 8usize];
    ["Offset of field: FMOD_ASYNCREADINFO::handle"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, handle) - 0usize];
    ["Offset of field: FMOD_ASYNCREADINFO::offset"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, offset) - 8usize];
    ["Offset of field: FMOD_ASYNCREADINFO::sizebytes"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, sizebytes) - 12usize];
    ["Offset of field: FMOD_ASYNCREADINFO::priority"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, priority) - 16usize];
    ["Offset of field: FMOD_ASYNCREADINFO::userdata"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, userdata) - 24usize];
    ["Offset of field: FMOD_ASYNCREADINFO::buffer"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, buffer) - 32usize];
    ["Offset of field: FMOD_ASYNCREADINFO::bytesread"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, bytesread) - 40usize];
    ["Offset of field: FMOD_ASYNCREADINFO::done"]
        [::std::mem::offset_of!(FMOD_ASYNCREADINFO, done) - 48usize];
};
impl Default for FMOD_ASYNCREADINFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_VECTOR {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_VECTOR"][::std::mem::size_of::<FMOD_VECTOR>() - 12usize];
    ["Alignment of FMOD_VECTOR"][::std::mem::align_of::<FMOD_VECTOR>() - 4usize];
    ["Offset of field: FMOD_VECTOR::x"][::std::mem::offset_of!(FMOD_VECTOR, x) - 0usize];
    ["Offset of field: FMOD_VECTOR::y"][::std::mem::offset_of!(FMOD_VECTOR, y) - 4usize];
    ["Offset of field: FMOD_VECTOR::z"][::std::mem::offset_of!(FMOD_VECTOR, z) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_3D_ATTRIBUTES {
    pub position: FMOD_VECTOR,
    pub velocity: FMOD_VECTOR,
    pub forward: FMOD_VECTOR,
    pub up: FMOD_VECTOR,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_3D_ATTRIBUTES"][::std::mem::size_of::<FMOD_3D_ATTRIBUTES>() - 48usize];
    ["Alignment of FMOD_3D_ATTRIBUTES"][::std::mem::align_of::<FMOD_3D_ATTRIBUTES>() - 4usize];
    ["Offset of field: FMOD_3D_ATTRIBUTES::position"]
        [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, position) - 0usize];
    ["Offset of field: FMOD_3D_ATTRIBUTES::velocity"]
        [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, velocity) - 12usize];
    ["Offset of field: FMOD_3D_ATTRIBUTES::forward"]
        [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, forward) - 24usize];
    ["Offset of field: FMOD_3D_ATTRIBUTES::up"]
        [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, up) - 36usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_GUID {
    pub Data1: ::std::os::raw::c_uint,
    pub Data2: ::std::os::raw::c_ushort,
    pub Data3: ::std::os::raw::c_ushort,
    pub Data4: [::std::os::raw::c_uchar; 8usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_GUID"][::std::mem::size_of::<FMOD_GUID>() - 16usize];
    ["Alignment of FMOD_GUID"][::std::mem::align_of::<FMOD_GUID>() - 4usize];
    ["Offset of field: FMOD_GUID::Data1"][::std::mem::offset_of!(FMOD_GUID, Data1) - 0usize];
    ["Offset of field: FMOD_GUID::Data2"][::std::mem::offset_of!(FMOD_GUID, Data2) - 4usize];
    ["Offset of field: FMOD_GUID::Data3"][::std::mem::offset_of!(FMOD_GUID, Data3) - 6usize];
    ["Offset of field: FMOD_GUID::Data4"][::std::mem::offset_of!(FMOD_GUID, Data4) - 8usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_PLUGINLIST {
    pub type_: FMOD_PLUGINTYPE,
    pub description: *mut ::std::os::raw::c_void,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_PLUGINLIST"][::std::mem::size_of::<FMOD_PLUGINLIST>() - 16usize];
    ["Alignment of FMOD_PLUGINLIST"][::std::mem::align_of::<FMOD_PLUGINLIST>() - 8usize];
    ["Offset of field: FMOD_PLUGINLIST::type_"]
        [::std::mem::offset_of!(FMOD_PLUGINLIST, type_) - 0usize];
    ["Offset of field: FMOD_PLUGINLIST::description"]
        [::std::mem::offset_of!(FMOD_PLUGINLIST, description) - 8usize];
};
impl Default for FMOD_PLUGINLIST {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_ADVANCEDSETTINGS {
    pub cbSize: ::std::os::raw::c_int,
    pub maxMPEGCodecs: ::std::os::raw::c_int,
    pub maxADPCMCodecs: ::std::os::raw::c_int,
    pub maxXMACodecs: ::std::os::raw::c_int,
    pub maxVorbisCodecs: ::std::os::raw::c_int,
    pub maxAT9Codecs: ::std::os::raw::c_int,
    pub maxFADPCMCodecs: ::std::os::raw::c_int,
    pub maxOpusCodecs: ::std::os::raw::c_int,
    pub ASIONumChannels: ::std::os::raw::c_int,
    pub ASIOChannelList: *mut *mut ::std::os::raw::c_char,
    pub ASIOSpeakerList: *mut FMOD_SPEAKER,
    pub vol0virtualvol: f32,
    pub defaultDecodeBufferSize: ::std::os::raw::c_uint,
    pub profilePort: ::std::os::raw::c_ushort,
    pub geometryMaxFadeTime: ::std::os::raw::c_uint,
    pub distanceFilterCenterFreq: f32,
    pub reverb3Dinstance: ::std::os::raw::c_int,
    pub DSPBufferPoolSize: ::std::os::raw::c_int,
    pub resamplerMethod: FMOD_DSP_RESAMPLER,
    pub randomSeed: ::std::os::raw::c_uint,
    pub maxConvolutionThreads: ::std::os::raw::c_int,
    pub maxSpatialObjects: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_ADVANCEDSETTINGS"][::std::mem::size_of::<FMOD_ADVANCEDSETTINGS>() - 104usize];
    ["Alignment of FMOD_ADVANCEDSETTINGS"]
        [::std::mem::align_of::<FMOD_ADVANCEDSETTINGS>() - 8usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::cbSize"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, cbSize) - 0usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxMPEGCodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxMPEGCodecs) - 4usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxADPCMCodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxADPCMCodecs) - 8usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxXMACodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxXMACodecs) - 12usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxVorbisCodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxVorbisCodecs) - 16usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxAT9Codecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxAT9Codecs) - 20usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxFADPCMCodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxFADPCMCodecs) - 24usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxOpusCodecs"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxOpusCodecs) - 28usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIONumChannels"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIONumChannels) - 32usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIOChannelList"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIOChannelList) - 40usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIOSpeakerList"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIOSpeakerList) - 48usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::vol0virtualvol"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, vol0virtualvol) - 56usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::defaultDecodeBufferSize"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, defaultDecodeBufferSize) - 60usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::profilePort"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, profilePort) - 64usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::geometryMaxFadeTime"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, geometryMaxFadeTime) - 68usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::distanceFilterCenterFreq"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, distanceFilterCenterFreq) - 72usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::reverb3Dinstance"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, reverb3Dinstance) - 76usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::DSPBufferPoolSize"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, DSPBufferPoolSize) - 80usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::resamplerMethod"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, resamplerMethod) - 84usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::randomSeed"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, randomSeed) - 88usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxConvolutionThreads"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxConvolutionThreads) - 92usize];
    ["Offset of field: FMOD_ADVANCEDSETTINGS::maxSpatialObjects"]
        [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxSpatialObjects) - 96usize];
};
impl Default for FMOD_ADVANCEDSETTINGS {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_TAG {
    pub type_: FMOD_TAGTYPE,
    pub datatype: FMOD_TAGDATATYPE,
    pub name: *mut ::std::os::raw::c_char,
    pub data: *mut ::std::os::raw::c_void,
    pub datalen: ::std::os::raw::c_uint,
    pub updated: FMOD_BOOL,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_TAG"][::std::mem::size_of::<FMOD_TAG>() - 32usize];
    ["Alignment of FMOD_TAG"][::std::mem::align_of::<FMOD_TAG>() - 8usize];
    ["Offset of field: FMOD_TAG::type_"][::std::mem::offset_of!(FMOD_TAG, type_) - 0usize];
    ["Offset of field: FMOD_TAG::datatype"][::std::mem::offset_of!(FMOD_TAG, datatype) - 4usize];
    ["Offset of field: FMOD_TAG::name"][::std::mem::offset_of!(FMOD_TAG, name) - 8usize];
    ["Offset of field: FMOD_TAG::data"][::std::mem::offset_of!(FMOD_TAG, data) - 16usize];
    ["Offset of field: FMOD_TAG::datalen"][::std::mem::offset_of!(FMOD_TAG, datalen) - 24usize];
    ["Offset of field: FMOD_TAG::updated"][::std::mem::offset_of!(FMOD_TAG, updated) - 28usize];
};
impl Default for FMOD_TAG {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_CREATESOUNDEXINFO {
    pub cbsize: ::std::os::raw::c_int,
    pub length: ::std::os::raw::c_uint,
    pub fileoffset: ::std::os::raw::c_uint,
    pub numchannels: ::std::os::raw::c_int,
    pub defaultfrequency: ::std::os::raw::c_int,
    pub format: FMOD_SOUND_FORMAT,
    pub decodebuffersize: ::std::os::raw::c_uint,
    pub initialsubsound: ::std::os::raw::c_int,
    pub numsubsounds: ::std::os::raw::c_int,
    pub inclusionlist: *mut ::std::os::raw::c_int,
    pub inclusionlistnum: ::std::os::raw::c_int,
    pub pcmreadcallback: FMOD_SOUND_PCMREAD_CALLBACK,
    pub pcmsetposcallback: FMOD_SOUND_PCMSETPOS_CALLBACK,
    pub nonblockcallback: FMOD_SOUND_NONBLOCK_CALLBACK,
    pub dlsname: *const ::std::os::raw::c_char,
    pub encryptionkey: *const ::std::os::raw::c_char,
    pub maxpolyphony: ::std::os::raw::c_int,
    pub userdata: *mut ::std::os::raw::c_void,
    pub suggestedsoundtype: FMOD_SOUND_TYPE,
    pub fileuseropen: FMOD_FILE_OPEN_CALLBACK,
    pub fileuserclose: FMOD_FILE_CLOSE_CALLBACK,
    pub fileuserread: FMOD_FILE_READ_CALLBACK,
    pub fileuserseek: FMOD_FILE_SEEK_CALLBACK,
    pub fileuserasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
    pub fileuserasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
    pub fileuserdata: *mut ::std::os::raw::c_void,
    pub filebuffersize: ::std::os::raw::c_int,
    pub channelorder: FMOD_CHANNELORDER,
    pub initialsoundgroup: *mut FMOD_SOUNDGROUP,
    pub initialseekposition: ::std::os::raw::c_uint,
    pub initialseekpostype: FMOD_TIMEUNIT,
    pub ignoresetfilesystem: ::std::os::raw::c_int,
    pub audioqueuepolicy: ::std::os::raw::c_uint,
    pub minmidigranularity: ::std::os::raw::c_uint,
    pub nonblockthreadid: ::std::os::raw::c_int,
    pub fsbguid: *mut FMOD_GUID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CREATESOUNDEXINFO"][::std::mem::size_of::<FMOD_CREATESOUNDEXINFO>() - 224usize];
    ["Alignment of FMOD_CREATESOUNDEXINFO"]
        [::std::mem::align_of::<FMOD_CREATESOUNDEXINFO>() - 8usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::cbsize"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, cbsize) - 0usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::length"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, length) - 4usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileoffset"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileoffset) - 8usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::numchannels"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, numchannels) - 12usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::defaultfrequency"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, defaultfrequency) - 16usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::format"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, format) - 20usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::decodebuffersize"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, decodebuffersize) - 24usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::initialsubsound"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialsubsound) - 28usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::numsubsounds"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, numsubsounds) - 32usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::inclusionlist"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, inclusionlist) - 40usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::inclusionlistnum"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, inclusionlistnum) - 48usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::pcmreadcallback"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, pcmreadcallback) - 56usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::pcmsetposcallback"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, pcmsetposcallback) - 64usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::nonblockcallback"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, nonblockcallback) - 72usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::dlsname"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, dlsname) - 80usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::encryptionkey"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, encryptionkey) - 88usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::maxpolyphony"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, maxpolyphony) - 96usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::userdata"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, userdata) - 104usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::suggestedsoundtype"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, suggestedsoundtype) - 112usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuseropen"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuseropen) - 120usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserclose"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserclose) - 128usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserread"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserread) - 136usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserseek"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserseek) - 144usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserasyncread"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserasyncread) - 152usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserasynccancel"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserasynccancel) - 160usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserdata"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserdata) - 168usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::filebuffersize"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, filebuffersize) - 176usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::channelorder"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, channelorder) - 180usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::initialsoundgroup"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialsoundgroup) - 184usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::initialseekposition"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialseekposition) - 192usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::initialseekpostype"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialseekpostype) - 196usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::ignoresetfilesystem"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, ignoresetfilesystem) - 200usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::audioqueuepolicy"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, audioqueuepolicy) - 204usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::minmidigranularity"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, minmidigranularity) - 208usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::nonblockthreadid"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, nonblockthreadid) - 212usize];
    ["Offset of field: FMOD_CREATESOUNDEXINFO::fsbguid"]
        [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fsbguid) - 216usize];
};
impl Default for FMOD_CREATESOUNDEXINFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_REVERB_PROPERTIES {
    pub DecayTime: f32,
    pub EarlyDelay: f32,
    pub LateDelay: f32,
    pub HFReference: f32,
    pub HFDecayRatio: f32,
    pub Diffusion: f32,
    pub Density: f32,
    pub LowShelfFrequency: f32,
    pub LowShelfGain: f32,
    pub HighCut: f32,
    pub EarlyLateMix: f32,
    pub WetLevel: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_REVERB_PROPERTIES"][::std::mem::size_of::<FMOD_REVERB_PROPERTIES>() - 48usize];
    ["Alignment of FMOD_REVERB_PROPERTIES"]
        [::std::mem::align_of::<FMOD_REVERB_PROPERTIES>() - 4usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::DecayTime"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, DecayTime) - 0usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::EarlyDelay"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, EarlyDelay) - 4usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::LateDelay"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LateDelay) - 8usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::HFReference"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HFReference) - 12usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::HFDecayRatio"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HFDecayRatio) - 16usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::Diffusion"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, Diffusion) - 20usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::Density"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, Density) - 24usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::LowShelfFrequency"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LowShelfFrequency) - 28usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::LowShelfGain"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LowShelfGain) - 32usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::HighCut"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HighCut) - 36usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::EarlyLateMix"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, EarlyLateMix) - 40usize];
    ["Offset of field: FMOD_REVERB_PROPERTIES::WetLevel"]
        [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, WetLevel) - 44usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_ERRORCALLBACK_INFO {
    pub result: FMOD_RESULT,
    pub instancetype: FMOD_ERRORCALLBACK_INSTANCETYPE,
    pub instance: *mut ::std::os::raw::c_void,
    pub functionname: *const ::std::os::raw::c_char,
    pub functionparams: *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_ERRORCALLBACK_INFO"][::std::mem::size_of::<FMOD_ERRORCALLBACK_INFO>() - 32usize];
    ["Alignment of FMOD_ERRORCALLBACK_INFO"]
        [::std::mem::align_of::<FMOD_ERRORCALLBACK_INFO>() - 8usize];
    ["Offset of field: FMOD_ERRORCALLBACK_INFO::result"]
        [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, result) - 0usize];
    ["Offset of field: FMOD_ERRORCALLBACK_INFO::instancetype"]
        [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, instancetype) - 4usize];
    ["Offset of field: FMOD_ERRORCALLBACK_INFO::instance"]
        [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, instance) - 8usize];
    ["Offset of field: FMOD_ERRORCALLBACK_INFO::functionname"]
        [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, functionname) - 16usize];
    ["Offset of field: FMOD_ERRORCALLBACK_INFO::functionparams"]
        [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, functionparams) - 24usize];
};
impl Default for FMOD_ERRORCALLBACK_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_CPU_USAGE {
    pub dsp: f32,
    pub stream: f32,
    pub geometry: f32,
    pub update: f32,
    pub convolution1: f32,
    pub convolution2: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CPU_USAGE"][::std::mem::size_of::<FMOD_CPU_USAGE>() - 24usize];
    ["Alignment of FMOD_CPU_USAGE"][::std::mem::align_of::<FMOD_CPU_USAGE>() - 4usize];
    ["Offset of field: FMOD_CPU_USAGE::dsp"][::std::mem::offset_of!(FMOD_CPU_USAGE, dsp) - 0usize];
    ["Offset of field: FMOD_CPU_USAGE::stream"]
        [::std::mem::offset_of!(FMOD_CPU_USAGE, stream) - 4usize];
    ["Offset of field: FMOD_CPU_USAGE::geometry"]
        [::std::mem::offset_of!(FMOD_CPU_USAGE, geometry) - 8usize];
    ["Offset of field: FMOD_CPU_USAGE::update"]
        [::std::mem::offset_of!(FMOD_CPU_USAGE, update) - 12usize];
    ["Offset of field: FMOD_CPU_USAGE::convolution1"]
        [::std::mem::offset_of!(FMOD_CPU_USAGE, convolution1) - 16usize];
    ["Offset of field: FMOD_CPU_USAGE::convolution2"]
        [::std::mem::offset_of!(FMOD_CPU_USAGE, convolution2) - 20usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_DATA_PARAMETER_INFO {
    pub data: *mut ::std::os::raw::c_void,
    pub length: ::std::os::raw::c_uint,
    pub index: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_DATA_PARAMETER_INFO"]
        [::std::mem::size_of::<FMOD_DSP_DATA_PARAMETER_INFO>() - 16usize];
    ["Alignment of FMOD_DSP_DATA_PARAMETER_INFO"]
        [::std::mem::align_of::<FMOD_DSP_DATA_PARAMETER_INFO>() - 8usize];
    ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::data"]
        [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, data) - 0usize];
    ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::length"]
        [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, length) - 8usize];
    ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::index"]
        [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, index) - 12usize];
};
impl Default for FMOD_DSP_DATA_PARAMETER_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub type FMOD_CODEC_SEEK_METHOD = ::std::os::raw::c_int;
pub type FMOD_CODEC_OPEN_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        usermode: FMOD_MODE,
        userexinfo: *mut FMOD_CREATESOUNDEXINFO,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_CLOSE_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE) -> FMOD_RESULT>;
pub type FMOD_CODEC_READ_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        buffer: *mut ::std::os::raw::c_void,
        samples_in: ::std::os::raw::c_uint,
        samples_out: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETLENGTH_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        length: *mut ::std::os::raw::c_uint,
        lengthtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_SETPOSITION_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        subsound: ::std::os::raw::c_int,
        position: ::std::os::raw::c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETPOSITION_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        position: *mut ::std::os::raw::c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_SOUNDCREATE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        subsound: ::std::os::raw::c_int,
        sound: *mut FMOD_SOUND,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETWAVEFORMAT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        index: ::std::os::raw::c_int,
        waveformat: *mut FMOD_CODEC_WAVEFORMAT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_METADATA_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        tagtype: FMOD_TAGTYPE,
        name: *mut ::std::os::raw::c_char,
        data: *mut ::std::os::raw::c_void,
        datalen: ::std::os::raw::c_uint,
        datatype: FMOD_TAGDATATYPE,
        unique: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_ALLOC_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        size: ::std::os::raw::c_uint,
        align: ::std::os::raw::c_uint,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_CODEC_FREE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
    ),
>;
pub type FMOD_CODEC_LOG_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        function: *const ::std::os::raw::c_char,
        string: *const ::std::os::raw::c_char,
        ...
    ),
>;
pub type FMOD_CODEC_FILE_READ_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        buffer: *mut ::std::os::raw::c_void,
        sizebytes: ::std::os::raw::c_uint,
        bytesread: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_SEEK_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        pos: ::std::os::raw::c_uint,
        method: FMOD_CODEC_SEEK_METHOD,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_TELL_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        pos: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_SIZE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        size: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_CODEC_DESCRIPTION {
    pub apiversion: ::std::os::raw::c_uint,
    pub name: *const ::std::os::raw::c_char,
    pub version: ::std::os::raw::c_uint,
    pub defaultasstream: ::std::os::raw::c_int,
    pub timeunits: FMOD_TIMEUNIT,
    pub open: FMOD_CODEC_OPEN_CALLBACK,
    pub close: FMOD_CODEC_CLOSE_CALLBACK,
    pub read: FMOD_CODEC_READ_CALLBACK,
    pub getlength: FMOD_CODEC_GETLENGTH_CALLBACK,
    pub setposition: FMOD_CODEC_SETPOSITION_CALLBACK,
    pub getposition: FMOD_CODEC_GETPOSITION_CALLBACK,
    pub soundcreate: FMOD_CODEC_SOUNDCREATE_CALLBACK,
    pub getwaveformat: FMOD_CODEC_GETWAVEFORMAT_CALLBACK,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CODEC_DESCRIPTION"][::std::mem::size_of::<FMOD_CODEC_DESCRIPTION>() - 96usize];
    ["Alignment of FMOD_CODEC_DESCRIPTION"]
        [::std::mem::align_of::<FMOD_CODEC_DESCRIPTION>() - 8usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::apiversion"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, apiversion) - 0usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::name"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, name) - 8usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::version"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, version) - 16usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::defaultasstream"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, defaultasstream) - 20usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::timeunits"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, timeunits) - 24usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::open"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, open) - 32usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::close"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, close) - 40usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::read"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, read) - 48usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::getlength"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getlength) - 56usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::setposition"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, setposition) - 64usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::getposition"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getposition) - 72usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::soundcreate"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, soundcreate) - 80usize];
    ["Offset of field: FMOD_CODEC_DESCRIPTION::getwaveformat"]
        [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getwaveformat) - 88usize];
};
impl Default for FMOD_CODEC_DESCRIPTION {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_CODEC_WAVEFORMAT {
    pub name: *const ::std::os::raw::c_char,
    pub format: FMOD_SOUND_FORMAT,
    pub channels: ::std::os::raw::c_int,
    pub frequency: ::std::os::raw::c_int,
    pub lengthbytes: ::std::os::raw::c_uint,
    pub lengthpcm: ::std::os::raw::c_uint,
    pub pcmblocksize: ::std::os::raw::c_uint,
    pub loopstart: ::std::os::raw::c_int,
    pub loopend: ::std::os::raw::c_int,
    pub mode: FMOD_MODE,
    pub channelmask: FMOD_CHANNELMASK,
    pub channelorder: FMOD_CHANNELORDER,
    pub peakvolume: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CODEC_WAVEFORMAT"][::std::mem::size_of::<FMOD_CODEC_WAVEFORMAT>() - 56usize];
    ["Alignment of FMOD_CODEC_WAVEFORMAT"]
        [::std::mem::align_of::<FMOD_CODEC_WAVEFORMAT>() - 8usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::name"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, name) - 0usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::format"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, format) - 8usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::channels"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channels) - 12usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::frequency"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, frequency) - 16usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::lengthbytes"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, lengthbytes) - 20usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::lengthpcm"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, lengthpcm) - 24usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::pcmblocksize"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, pcmblocksize) - 28usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::loopstart"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, loopstart) - 32usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::loopend"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, loopend) - 36usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::mode"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, mode) - 40usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::channelmask"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channelmask) - 44usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::channelorder"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channelorder) - 48usize];
    ["Offset of field: FMOD_CODEC_WAVEFORMAT::peakvolume"]
        [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, peakvolume) - 52usize];
};
impl Default for FMOD_CODEC_WAVEFORMAT {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_CODEC_STATE_FUNCTIONS {
    pub metadata: FMOD_CODEC_METADATA_FUNC,
    pub alloc: FMOD_CODEC_ALLOC_FUNC,
    pub free: FMOD_CODEC_FREE_FUNC,
    pub log: FMOD_CODEC_LOG_FUNC,
    pub read: FMOD_CODEC_FILE_READ_FUNC,
    pub seek: FMOD_CODEC_FILE_SEEK_FUNC,
    pub tell: FMOD_CODEC_FILE_TELL_FUNC,
    pub size: FMOD_CODEC_FILE_SIZE_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CODEC_STATE_FUNCTIONS"]
        [::std::mem::size_of::<FMOD_CODEC_STATE_FUNCTIONS>() - 64usize];
    ["Alignment of FMOD_CODEC_STATE_FUNCTIONS"]
        [::std::mem::align_of::<FMOD_CODEC_STATE_FUNCTIONS>() - 8usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::metadata"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, metadata) - 0usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::alloc"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, alloc) - 8usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::free"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, free) - 16usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::log"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, log) - 24usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::read"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, read) - 32usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::seek"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, seek) - 40usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::tell"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, tell) - 48usize];
    ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::size"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, size) - 56usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_CODEC_STATE {
    pub plugindata: *mut ::std::os::raw::c_void,
    pub waveformat: *mut FMOD_CODEC_WAVEFORMAT,
    pub functions: *mut FMOD_CODEC_STATE_FUNCTIONS,
    pub numsubsounds: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_CODEC_STATE"][::std::mem::size_of::<FMOD_CODEC_STATE>() - 32usize];
    ["Alignment of FMOD_CODEC_STATE"][::std::mem::align_of::<FMOD_CODEC_STATE>() - 8usize];
    ["Offset of field: FMOD_CODEC_STATE::plugindata"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE, plugindata) - 0usize];
    ["Offset of field: FMOD_CODEC_STATE::waveformat"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE, waveformat) - 8usize];
    ["Offset of field: FMOD_CODEC_STATE::functions"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE, functions) - 16usize];
    ["Offset of field: FMOD_CODEC_STATE::numsubsounds"]
        [::std::mem::offset_of!(FMOD_CODEC_STATE, numsubsounds) - 24usize];
};
impl Default for FMOD_CODEC_STATE {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
pub const FMOD_DSP_TYPE_UNKNOWN: FMOD_DSP_TYPE = 0;
pub const FMOD_DSP_TYPE_MIXER: FMOD_DSP_TYPE = 1;
pub const FMOD_DSP_TYPE_OSCILLATOR: FMOD_DSP_TYPE = 2;
pub const FMOD_DSP_TYPE_LOWPASS: FMOD_DSP_TYPE = 3;
pub const FMOD_DSP_TYPE_ITLOWPASS: FMOD_DSP_TYPE = 4;
pub const FMOD_DSP_TYPE_HIGHPASS: FMOD_DSP_TYPE = 5;
pub const FMOD_DSP_TYPE_ECHO: FMOD_DSP_TYPE = 6;
pub const FMOD_DSP_TYPE_FADER: FMOD_DSP_TYPE = 7;
pub const FMOD_DSP_TYPE_FLANGE: FMOD_DSP_TYPE = 8;
pub const FMOD_DSP_TYPE_DISTORTION: FMOD_DSP_TYPE = 9;
pub const FMOD_DSP_TYPE_NORMALIZE: FMOD_DSP_TYPE = 10;
pub const FMOD_DSP_TYPE_LIMITER: FMOD_DSP_TYPE = 11;
pub const FMOD_DSP_TYPE_PARAMEQ: FMOD_DSP_TYPE = 12;
pub const FMOD_DSP_TYPE_PITCHSHIFT: FMOD_DSP_TYPE = 13;
pub const FMOD_DSP_TYPE_CHORUS: FMOD_DSP_TYPE = 14;
pub const FMOD_DSP_TYPE_ITECHO: FMOD_DSP_TYPE = 15;
pub const FMOD_DSP_TYPE_COMPRESSOR: FMOD_DSP_TYPE = 16;
pub const FMOD_DSP_TYPE_SFXREVERB: FMOD_DSP_TYPE = 17;
pub const FMOD_DSP_TYPE_LOWPASS_SIMPLE: FMOD_DSP_TYPE = 18;
pub const FMOD_DSP_TYPE_DELAY: FMOD_DSP_TYPE = 19;
pub const FMOD_DSP_TYPE_TREMOLO: FMOD_DSP_TYPE = 20;
pub const FMOD_DSP_TYPE_SEND: FMOD_DSP_TYPE = 21;
pub const FMOD_DSP_TYPE_RETURN: FMOD_DSP_TYPE = 22;
pub const FMOD_DSP_TYPE_HIGHPASS_SIMPLE: FMOD_DSP_TYPE = 23;
pub const FMOD_DSP_TYPE_PAN: FMOD_DSP_TYPE = 24;
pub const FMOD_DSP_TYPE_THREE_EQ: FMOD_DSP_TYPE = 25;
pub const FMOD_DSP_TYPE_FFT: FMOD_DSP_TYPE = 26;
pub const FMOD_DSP_TYPE_LOUDNESS_METER: FMOD_DSP_TYPE = 27;
pub const FMOD_DSP_TYPE_CONVOLUTIONREVERB: FMOD_DSP_TYPE = 28;
pub const FMOD_DSP_TYPE_CHANNELMIX: FMOD_DSP_TYPE = 29;
pub const FMOD_DSP_TYPE_TRANSCEIVER: FMOD_DSP_TYPE = 30;
pub const FMOD_DSP_TYPE_OBJECTPAN: FMOD_DSP_TYPE = 31;
pub const FMOD_DSP_TYPE_MULTIBAND_EQ: FMOD_DSP_TYPE = 32;
pub const FMOD_DSP_TYPE_MULTIBAND_DYNAMICS: FMOD_DSP_TYPE = 33;
pub const FMOD_DSP_TYPE_MAX: FMOD_DSP_TYPE = 34;
pub const FMOD_DSP_TYPE_FORCEINT: FMOD_DSP_TYPE = 65536;
pub type FMOD_DSP_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_OSCILLATOR_TYPE: FMOD_DSP_OSCILLATOR = 0;
pub const FMOD_DSP_OSCILLATOR_RATE: FMOD_DSP_OSCILLATOR = 1;
pub type FMOD_DSP_OSCILLATOR = ::std::os::raw::c_uint;
pub const FMOD_DSP_LOWPASS_CUTOFF: FMOD_DSP_LOWPASS = 0;
pub const FMOD_DSP_LOWPASS_RESONANCE: FMOD_DSP_LOWPASS = 1;
pub type FMOD_DSP_LOWPASS = ::std::os::raw::c_uint;
pub const FMOD_DSP_ITLOWPASS_CUTOFF: FMOD_DSP_ITLOWPASS = 0;
pub const FMOD_DSP_ITLOWPASS_RESONANCE: FMOD_DSP_ITLOWPASS = 1;
pub type FMOD_DSP_ITLOWPASS = ::std::os::raw::c_uint;
pub const FMOD_DSP_HIGHPASS_CUTOFF: FMOD_DSP_HIGHPASS = 0;
pub const FMOD_DSP_HIGHPASS_RESONANCE: FMOD_DSP_HIGHPASS = 1;
pub type FMOD_DSP_HIGHPASS = ::std::os::raw::c_uint;
pub const FMOD_DSP_ECHO_DELAY: FMOD_DSP_ECHO = 0;
pub const FMOD_DSP_ECHO_FEEDBACK: FMOD_DSP_ECHO = 1;
pub const FMOD_DSP_ECHO_DRYLEVEL: FMOD_DSP_ECHO = 2;
pub const FMOD_DSP_ECHO_WETLEVEL: FMOD_DSP_ECHO = 3;
pub const FMOD_DSP_ECHO_DELAYCHANGEMODE: FMOD_DSP_ECHO = 4;
pub type FMOD_DSP_ECHO = ::std::os::raw::c_uint;
pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_FADE: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 0;
pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_LERP: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 1;
pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_NONE: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 2;
pub type FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_FADER_GAIN: FMOD_DSP_FADER = 0;
pub const FMOD_DSP_FADER_OVERALL_GAIN: FMOD_DSP_FADER = 1;
pub type FMOD_DSP_FADER = ::std::os::raw::c_uint;
pub const FMOD_DSP_FLANGE_MIX: FMOD_DSP_FLANGE = 0;
pub const FMOD_DSP_FLANGE_DEPTH: FMOD_DSP_FLANGE = 1;
pub const FMOD_DSP_FLANGE_RATE: FMOD_DSP_FLANGE = 2;
pub type FMOD_DSP_FLANGE = ::std::os::raw::c_uint;
pub const FMOD_DSP_DISTORTION_LEVEL: FMOD_DSP_DISTORTION = 0;
pub type FMOD_DSP_DISTORTION = ::std::os::raw::c_uint;
pub const FMOD_DSP_NORMALIZE_FADETIME: FMOD_DSP_NORMALIZE = 0;
pub const FMOD_DSP_NORMALIZE_THRESHOLD: FMOD_DSP_NORMALIZE = 1;
pub const FMOD_DSP_NORMALIZE_MAXAMP: FMOD_DSP_NORMALIZE = 2;
pub type FMOD_DSP_NORMALIZE = ::std::os::raw::c_uint;
pub const FMOD_DSP_LIMITER_RELEASETIME: FMOD_DSP_LIMITER = 0;
pub const FMOD_DSP_LIMITER_CEILING: FMOD_DSP_LIMITER = 1;
pub const FMOD_DSP_LIMITER_MAXIMIZERGAIN: FMOD_DSP_LIMITER = 2;
pub const FMOD_DSP_LIMITER_MODE: FMOD_DSP_LIMITER = 3;
pub type FMOD_DSP_LIMITER = ::std::os::raw::c_uint;
pub const FMOD_DSP_PARAMEQ_CENTER: FMOD_DSP_PARAMEQ = 0;
pub const FMOD_DSP_PARAMEQ_BANDWIDTH: FMOD_DSP_PARAMEQ = 1;
pub const FMOD_DSP_PARAMEQ_GAIN: FMOD_DSP_PARAMEQ = 2;
pub type FMOD_DSP_PARAMEQ = ::std::os::raw::c_uint;
pub const FMOD_DSP_MULTIBAND_EQ_A_FILTER: FMOD_DSP_MULTIBAND_EQ = 0;
pub const FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 1;
pub const FMOD_DSP_MULTIBAND_EQ_A_Q: FMOD_DSP_MULTIBAND_EQ = 2;
pub const FMOD_DSP_MULTIBAND_EQ_A_GAIN: FMOD_DSP_MULTIBAND_EQ = 3;
pub const FMOD_DSP_MULTIBAND_EQ_B_FILTER: FMOD_DSP_MULTIBAND_EQ = 4;
pub const FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 5;
pub const FMOD_DSP_MULTIBAND_EQ_B_Q: FMOD_DSP_MULTIBAND_EQ = 6;
pub const FMOD_DSP_MULTIBAND_EQ_B_GAIN: FMOD_DSP_MULTIBAND_EQ = 7;
pub const FMOD_DSP_MULTIBAND_EQ_C_FILTER: FMOD_DSP_MULTIBAND_EQ = 8;
pub const FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 9;
pub const FMOD_DSP_MULTIBAND_EQ_C_Q: FMOD_DSP_MULTIBAND_EQ = 10;
pub const FMOD_DSP_MULTIBAND_EQ_C_GAIN: FMOD_DSP_MULTIBAND_EQ = 11;
pub const FMOD_DSP_MULTIBAND_EQ_D_FILTER: FMOD_DSP_MULTIBAND_EQ = 12;
pub const FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 13;
pub const FMOD_DSP_MULTIBAND_EQ_D_Q: FMOD_DSP_MULTIBAND_EQ = 14;
pub const FMOD_DSP_MULTIBAND_EQ_D_GAIN: FMOD_DSP_MULTIBAND_EQ = 15;
pub const FMOD_DSP_MULTIBAND_EQ_E_FILTER: FMOD_DSP_MULTIBAND_EQ = 16;
pub const FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 17;
pub const FMOD_DSP_MULTIBAND_EQ_E_Q: FMOD_DSP_MULTIBAND_EQ = 18;
pub const FMOD_DSP_MULTIBAND_EQ_E_GAIN: FMOD_DSP_MULTIBAND_EQ = 19;
pub type FMOD_DSP_MULTIBAND_EQ = ::std::os::raw::c_uint;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 0;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 1;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 2;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 3;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 4;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 5;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 6;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 7;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 8;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 9;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 10;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 11;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 12;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_6DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 13;
pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_6DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 14;
pub type FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_LOWER_FREQUENCY: FMOD_DSP_MULTIBAND_DYNAMICS = 0;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_UPPER_FREQUENCY: FMOD_DSP_MULTIBAND_DYNAMICS = 1;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_LINKED: FMOD_DSP_MULTIBAND_DYNAMICS = 2;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_USE_SIDECHAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 3;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 4;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 5;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 6;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 7;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 8;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 9;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 10;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 11;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 12;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 13;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 14;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 15;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 16;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 17;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 18;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 19;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 20;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 21;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 22;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 23;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 24;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 25;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 26;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 27;
pub type FMOD_DSP_MULTIBAND_DYNAMICS = ::std::os::raw::c_uint;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_DISABLED: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 0;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_COMPRESS_UP: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 1;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_COMPRESS_DOWN: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 2;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_EXPAND_UP: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 3;
pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_EXPAND_DOWN: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 4;
pub type FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PITCHSHIFT_PITCH: FMOD_DSP_PITCHSHIFT = 0;
pub const FMOD_DSP_PITCHSHIFT_FFTSIZE: FMOD_DSP_PITCHSHIFT = 1;
pub const FMOD_DSP_PITCHSHIFT_OVERLAP: FMOD_DSP_PITCHSHIFT = 2;
pub const FMOD_DSP_PITCHSHIFT_MAXCHANNELS: FMOD_DSP_PITCHSHIFT = 3;
pub type FMOD_DSP_PITCHSHIFT = ::std::os::raw::c_uint;
pub const FMOD_DSP_CHORUS_MIX: FMOD_DSP_CHORUS = 0;
pub const FMOD_DSP_CHORUS_RATE: FMOD_DSP_CHORUS = 1;
pub const FMOD_DSP_CHORUS_DEPTH: FMOD_DSP_CHORUS = 2;
pub type FMOD_DSP_CHORUS = ::std::os::raw::c_uint;
pub const FMOD_DSP_ITECHO_WETDRYMIX: FMOD_DSP_ITECHO = 0;
pub const FMOD_DSP_ITECHO_FEEDBACK: FMOD_DSP_ITECHO = 1;
pub const FMOD_DSP_ITECHO_LEFTDELAY: FMOD_DSP_ITECHO = 2;
pub const FMOD_DSP_ITECHO_RIGHTDELAY: FMOD_DSP_ITECHO = 3;
pub const FMOD_DSP_ITECHO_PANDELAY: FMOD_DSP_ITECHO = 4;
pub type FMOD_DSP_ITECHO = ::std::os::raw::c_uint;
pub const FMOD_DSP_COMPRESSOR_THRESHOLD: FMOD_DSP_COMPRESSOR = 0;
pub const FMOD_DSP_COMPRESSOR_RATIO: FMOD_DSP_COMPRESSOR = 1;
pub const FMOD_DSP_COMPRESSOR_ATTACK: FMOD_DSP_COMPRESSOR = 2;
pub const FMOD_DSP_COMPRESSOR_RELEASE: FMOD_DSP_COMPRESSOR = 3;
pub const FMOD_DSP_COMPRESSOR_GAINMAKEUP: FMOD_DSP_COMPRESSOR = 4;
pub const FMOD_DSP_COMPRESSOR_USESIDECHAIN: FMOD_DSP_COMPRESSOR = 5;
pub const FMOD_DSP_COMPRESSOR_LINKED: FMOD_DSP_COMPRESSOR = 6;
pub type FMOD_DSP_COMPRESSOR = ::std::os::raw::c_uint;
pub const FMOD_DSP_SFXREVERB_DECAYTIME: FMOD_DSP_SFXREVERB = 0;
pub const FMOD_DSP_SFXREVERB_EARLYDELAY: FMOD_DSP_SFXREVERB = 1;
pub const FMOD_DSP_SFXREVERB_LATEDELAY: FMOD_DSP_SFXREVERB = 2;
pub const FMOD_DSP_SFXREVERB_HFREFERENCE: FMOD_DSP_SFXREVERB = 3;
pub const FMOD_DSP_SFXREVERB_HFDECAYRATIO: FMOD_DSP_SFXREVERB = 4;
pub const FMOD_DSP_SFXREVERB_DIFFUSION: FMOD_DSP_SFXREVERB = 5;
pub const FMOD_DSP_SFXREVERB_DENSITY: FMOD_DSP_SFXREVERB = 6;
pub const FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY: FMOD_DSP_SFXREVERB = 7;
pub const FMOD_DSP_SFXREVERB_LOWSHELFGAIN: FMOD_DSP_SFXREVERB = 8;
pub const FMOD_DSP_SFXREVERB_HIGHCUT: FMOD_DSP_SFXREVERB = 9;
pub const FMOD_DSP_SFXREVERB_EARLYLATEMIX: FMOD_DSP_SFXREVERB = 10;
pub const FMOD_DSP_SFXREVERB_WETLEVEL: FMOD_DSP_SFXREVERB = 11;
pub const FMOD_DSP_SFXREVERB_DRYLEVEL: FMOD_DSP_SFXREVERB = 12;
pub type FMOD_DSP_SFXREVERB = ::std::os::raw::c_uint;
pub const FMOD_DSP_LOWPASS_SIMPLE_CUTOFF: FMOD_DSP_LOWPASS_SIMPLE = 0;
pub type FMOD_DSP_LOWPASS_SIMPLE = ::std::os::raw::c_uint;
pub const FMOD_DSP_DELAY_CH0: FMOD_DSP_DELAY = 0;
pub const FMOD_DSP_DELAY_CH1: FMOD_DSP_DELAY = 1;
pub const FMOD_DSP_DELAY_CH2: FMOD_DSP_DELAY = 2;
pub const FMOD_DSP_DELAY_CH3: FMOD_DSP_DELAY = 3;
pub const FMOD_DSP_DELAY_CH4: FMOD_DSP_DELAY = 4;
pub const FMOD_DSP_DELAY_CH5: FMOD_DSP_DELAY = 5;
pub const FMOD_DSP_DELAY_CH6: FMOD_DSP_DELAY = 6;
pub const FMOD_DSP_DELAY_CH7: FMOD_DSP_DELAY = 7;
pub const FMOD_DSP_DELAY_CH8: FMOD_DSP_DELAY = 8;
pub const FMOD_DSP_DELAY_CH9: FMOD_DSP_DELAY = 9;
pub const FMOD_DSP_DELAY_CH10: FMOD_DSP_DELAY = 10;
pub const FMOD_DSP_DELAY_CH11: FMOD_DSP_DELAY = 11;
pub const FMOD_DSP_DELAY_CH12: FMOD_DSP_DELAY = 12;
pub const FMOD_DSP_DELAY_CH13: FMOD_DSP_DELAY = 13;
pub const FMOD_DSP_DELAY_CH14: FMOD_DSP_DELAY = 14;
pub const FMOD_DSP_DELAY_CH15: FMOD_DSP_DELAY = 15;
pub const FMOD_DSP_DELAY_MAXDELAY: FMOD_DSP_DELAY = 16;
pub type FMOD_DSP_DELAY = ::std::os::raw::c_uint;
pub const FMOD_DSP_TREMOLO_FREQUENCY: FMOD_DSP_TREMOLO = 0;
pub const FMOD_DSP_TREMOLO_DEPTH: FMOD_DSP_TREMOLO = 1;
pub const FMOD_DSP_TREMOLO_SHAPE: FMOD_DSP_TREMOLO = 2;
pub const FMOD_DSP_TREMOLO_SKEW: FMOD_DSP_TREMOLO = 3;
pub const FMOD_DSP_TREMOLO_DUTY: FMOD_DSP_TREMOLO = 4;
pub const FMOD_DSP_TREMOLO_SQUARE: FMOD_DSP_TREMOLO = 5;
pub const FMOD_DSP_TREMOLO_PHASE: FMOD_DSP_TREMOLO = 6;
pub const FMOD_DSP_TREMOLO_SPREAD: FMOD_DSP_TREMOLO = 7;
pub type FMOD_DSP_TREMOLO = ::std::os::raw::c_uint;
pub const FMOD_DSP_SEND_RETURNID: FMOD_DSP_SEND = 0;
pub const FMOD_DSP_SEND_LEVEL: FMOD_DSP_SEND = 1;
pub type FMOD_DSP_SEND = ::std::os::raw::c_uint;
pub const FMOD_DSP_RETURN_ID: FMOD_DSP_RETURN = 0;
pub const FMOD_DSP_RETURN_INPUT_SPEAKER_MODE: FMOD_DSP_RETURN = 1;
pub type FMOD_DSP_RETURN = ::std::os::raw::c_uint;
pub const FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF: FMOD_DSP_HIGHPASS_SIMPLE = 0;
pub type FMOD_DSP_HIGHPASS_SIMPLE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 0;
pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 1;
pub type FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_MODE_MONO: FMOD_DSP_PAN_MODE_TYPE = 0;
pub const FMOD_DSP_PAN_MODE_STEREO: FMOD_DSP_PAN_MODE_TYPE = 1;
pub const FMOD_DSP_PAN_MODE_SURROUND: FMOD_DSP_PAN_MODE_TYPE = 2;
pub type FMOD_DSP_PAN_MODE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 0;
pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEAR: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 1;
pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSE: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 2;
pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 3;
pub const FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 4;
pub type FMOD_DSP_PAN_3D_ROLLOFF_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 0;
pub const FMOD_DSP_PAN_3D_EXTENT_MODE_USER: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 1;
pub const FMOD_DSP_PAN_3D_EXTENT_MODE_OFF: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 2;
pub type FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_MODE: FMOD_DSP_PAN = 0;
pub const FMOD_DSP_PAN_2D_STEREO_POSITION: FMOD_DSP_PAN = 1;
pub const FMOD_DSP_PAN_2D_DIRECTION: FMOD_DSP_PAN = 2;
pub const FMOD_DSP_PAN_2D_EXTENT: FMOD_DSP_PAN = 3;
pub const FMOD_DSP_PAN_2D_ROTATION: FMOD_DSP_PAN = 4;
pub const FMOD_DSP_PAN_2D_LFE_LEVEL: FMOD_DSP_PAN = 5;
pub const FMOD_DSP_PAN_2D_STEREO_MODE: FMOD_DSP_PAN = 6;
pub const FMOD_DSP_PAN_2D_STEREO_SEPARATION: FMOD_DSP_PAN = 7;
pub const FMOD_DSP_PAN_2D_STEREO_AXIS: FMOD_DSP_PAN = 8;
pub const FMOD_DSP_PAN_ENABLED_SPEAKERS: FMOD_DSP_PAN = 9;
pub const FMOD_DSP_PAN_3D_POSITION: FMOD_DSP_PAN = 10;
pub const FMOD_DSP_PAN_3D_ROLLOFF: FMOD_DSP_PAN = 11;
pub const FMOD_DSP_PAN_3D_MIN_DISTANCE: FMOD_DSP_PAN = 12;
pub const FMOD_DSP_PAN_3D_MAX_DISTANCE: FMOD_DSP_PAN = 13;
pub const FMOD_DSP_PAN_3D_EXTENT_MODE: FMOD_DSP_PAN = 14;
pub const FMOD_DSP_PAN_3D_SOUND_SIZE: FMOD_DSP_PAN = 15;
pub const FMOD_DSP_PAN_3D_MIN_EXTENT: FMOD_DSP_PAN = 16;
pub const FMOD_DSP_PAN_3D_PAN_BLEND: FMOD_DSP_PAN = 17;
pub const FMOD_DSP_PAN_LFE_UPMIX_ENABLED: FMOD_DSP_PAN = 18;
pub const FMOD_DSP_PAN_OVERALL_GAIN: FMOD_DSP_PAN = 19;
pub const FMOD_DSP_PAN_SURROUND_SPEAKER_MODE: FMOD_DSP_PAN = 20;
pub const FMOD_DSP_PAN_2D_HEIGHT_BLEND: FMOD_DSP_PAN = 21;
pub const FMOD_DSP_PAN_ATTENUATION_RANGE: FMOD_DSP_PAN = 22;
pub const FMOD_DSP_PAN_OVERRIDE_RANGE: FMOD_DSP_PAN = 23;
pub type FMOD_DSP_PAN = ::std::os::raw::c_uint;
pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 0;
pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 1;
pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 2;
pub type FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_THREE_EQ_LOWGAIN: FMOD_DSP_THREE_EQ = 0;
pub const FMOD_DSP_THREE_EQ_MIDGAIN: FMOD_DSP_THREE_EQ = 1;
pub const FMOD_DSP_THREE_EQ_HIGHGAIN: FMOD_DSP_THREE_EQ = 2;
pub const FMOD_DSP_THREE_EQ_LOWCROSSOVER: FMOD_DSP_THREE_EQ = 3;
pub const FMOD_DSP_THREE_EQ_HIGHCROSSOVER: FMOD_DSP_THREE_EQ = 4;
pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE: FMOD_DSP_THREE_EQ = 5;
pub type FMOD_DSP_THREE_EQ = ::std::os::raw::c_uint;
pub const FMOD_DSP_FFT_WINDOW_RECT: FMOD_DSP_FFT_WINDOW_TYPE = 0;
pub const FMOD_DSP_FFT_WINDOW_TRIANGLE: FMOD_DSP_FFT_WINDOW_TYPE = 1;
pub const FMOD_DSP_FFT_WINDOW_HAMMING: FMOD_DSP_FFT_WINDOW_TYPE = 2;
pub const FMOD_DSP_FFT_WINDOW_HANNING: FMOD_DSP_FFT_WINDOW_TYPE = 3;
pub const FMOD_DSP_FFT_WINDOW_BLACKMAN: FMOD_DSP_FFT_WINDOW_TYPE = 4;
pub const FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS: FMOD_DSP_FFT_WINDOW_TYPE = 5;
pub type FMOD_DSP_FFT_WINDOW_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_FFT_DOWNMIX_NONE: FMOD_DSP_FFT_DOWNMIX_TYPE = 0;
pub const FMOD_DSP_FFT_DOWNMIX_MONO: FMOD_DSP_FFT_DOWNMIX_TYPE = 1;
pub type FMOD_DSP_FFT_DOWNMIX_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_FFT_WINDOWSIZE: FMOD_DSP_FFT = 0;
pub const FMOD_DSP_FFT_WINDOW: FMOD_DSP_FFT = 1;
pub const FMOD_DSP_FFT_BAND_START_FREQ: FMOD_DSP_FFT = 2;
pub const FMOD_DSP_FFT_BAND_STOP_FREQ: FMOD_DSP_FFT = 3;
pub const FMOD_DSP_FFT_SPECTRUMDATA: FMOD_DSP_FFT = 4;
pub const FMOD_DSP_FFT_RMS: FMOD_DSP_FFT = 5;
pub const FMOD_DSP_FFT_SPECTRAL_CENTROID: FMOD_DSP_FFT = 6;
pub const FMOD_DSP_FFT_IMMEDIATE_MODE: FMOD_DSP_FFT = 7;
pub const FMOD_DSP_FFT_DOWNMIX: FMOD_DSP_FFT = 8;
pub const FMOD_DSP_FFT_CHANNEL: FMOD_DSP_FFT = 9;
pub type FMOD_DSP_FFT = ::std::os::raw::c_uint;
pub const FMOD_DSP_LOUDNESS_METER_STATE: FMOD_DSP_LOUDNESS_METER = 0;
pub const FMOD_DSP_LOUDNESS_METER_WEIGHTING: FMOD_DSP_LOUDNESS_METER = 1;
pub const FMOD_DSP_LOUDNESS_METER_INFO: FMOD_DSP_LOUDNESS_METER = 2;
pub type FMOD_DSP_LOUDNESS_METER = ::std::os::raw::c_uint;
pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -3;
pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -2;
pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -1;
pub const FMOD_DSP_LOUDNESS_METER_STATE_PAUSED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 0;
pub const FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 1;
pub type FMOD_DSP_LOUDNESS_METER_STATE_TYPE = ::std::os::raw::c_int;
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
    pub momentaryloudness: f32,
    pub shorttermloudness: f32,
    pub integratedloudness: f32,
    pub loudness10thpercentile: f32,
    pub loudness95thpercentile: f32,
    pub loudnesshistogram: [f32; 66usize],
    pub maxtruepeak: f32,
    pub maxmomentaryloudness: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_LOUDNESS_METER_INFO_TYPE"]
        [::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>() - 292usize];
    ["Alignment of FMOD_DSP_LOUDNESS_METER_INFO_TYPE"]
        [::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>() - 4usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::momentaryloudness"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, momentaryloudness) - 0usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::shorttermloudness"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, shorttermloudness) - 4usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::integratedloudness"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, integratedloudness) - 8usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudness10thpercentile"][::std::mem::offset_of!(
        FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
        loudness10thpercentile
    ) - 12usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudness95thpercentile"][::std::mem::offset_of!(
        FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
        loudness95thpercentile
    ) - 16usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudnesshistogram"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, loudnesshistogram) - 20usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::maxtruepeak"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, maxtruepeak) - 284usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::maxmomentaryloudness"][::std::mem::offset_of!(
        FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
        maxmomentaryloudness
    ) - 288usize];
};
impl Default for FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
    pub channelweight: [f32; 32usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE"]
        [::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>() - 128usize];
    ["Alignment of FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE"]
        [::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>() - 4usize];
    ["Offset of field: FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE::channelweight"]
        [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE, channelweight) - 0usize];
};
pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR: FMOD_DSP_CONVOLUTION_REVERB = 0;
pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET: FMOD_DSP_CONVOLUTION_REVERB = 1;
pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY: FMOD_DSP_CONVOLUTION_REVERB = 2;
pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED: FMOD_DSP_CONVOLUTION_REVERB = 3;
pub type FMOD_DSP_CONVOLUTION_REVERB = ::std::os::raw::c_uint;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT: FMOD_DSP_CHANNELMIX_OUTPUT = 0;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO: FMOD_DSP_CHANNELMIX_OUTPUT = 1;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO: FMOD_DSP_CHANNELMIX_OUTPUT = 2;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD: FMOD_DSP_CHANNELMIX_OUTPUT = 3;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 4;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 5;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE: FMOD_DSP_CHANNELMIX_OUTPUT = 6;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4: FMOD_DSP_CHANNELMIX_OUTPUT = 7;
pub type FMOD_DSP_CHANNELMIX_OUTPUT = ::std::os::raw::c_uint;
pub const FMOD_DSP_CHANNELMIX_OUTPUTGROUPING: FMOD_DSP_CHANNELMIX = 0;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH0: FMOD_DSP_CHANNELMIX = 1;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH1: FMOD_DSP_CHANNELMIX = 2;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH2: FMOD_DSP_CHANNELMIX = 3;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH3: FMOD_DSP_CHANNELMIX = 4;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH4: FMOD_DSP_CHANNELMIX = 5;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH5: FMOD_DSP_CHANNELMIX = 6;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH6: FMOD_DSP_CHANNELMIX = 7;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH7: FMOD_DSP_CHANNELMIX = 8;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH8: FMOD_DSP_CHANNELMIX = 9;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH9: FMOD_DSP_CHANNELMIX = 10;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH10: FMOD_DSP_CHANNELMIX = 11;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH11: FMOD_DSP_CHANNELMIX = 12;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH12: FMOD_DSP_CHANNELMIX = 13;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH13: FMOD_DSP_CHANNELMIX = 14;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH14: FMOD_DSP_CHANNELMIX = 15;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH15: FMOD_DSP_CHANNELMIX = 16;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH16: FMOD_DSP_CHANNELMIX = 17;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH17: FMOD_DSP_CHANNELMIX = 18;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH18: FMOD_DSP_CHANNELMIX = 19;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH19: FMOD_DSP_CHANNELMIX = 20;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH20: FMOD_DSP_CHANNELMIX = 21;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH21: FMOD_DSP_CHANNELMIX = 22;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH22: FMOD_DSP_CHANNELMIX = 23;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH23: FMOD_DSP_CHANNELMIX = 24;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH24: FMOD_DSP_CHANNELMIX = 25;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH25: FMOD_DSP_CHANNELMIX = 26;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH26: FMOD_DSP_CHANNELMIX = 27;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH27: FMOD_DSP_CHANNELMIX = 28;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH28: FMOD_DSP_CHANNELMIX = 29;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH29: FMOD_DSP_CHANNELMIX = 30;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH30: FMOD_DSP_CHANNELMIX = 31;
pub const FMOD_DSP_CHANNELMIX_GAIN_CH31: FMOD_DSP_CHANNELMIX = 32;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH0: FMOD_DSP_CHANNELMIX = 33;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH1: FMOD_DSP_CHANNELMIX = 34;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH2: FMOD_DSP_CHANNELMIX = 35;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH3: FMOD_DSP_CHANNELMIX = 36;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH4: FMOD_DSP_CHANNELMIX = 37;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH5: FMOD_DSP_CHANNELMIX = 38;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH6: FMOD_DSP_CHANNELMIX = 39;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH7: FMOD_DSP_CHANNELMIX = 40;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH8: FMOD_DSP_CHANNELMIX = 41;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH9: FMOD_DSP_CHANNELMIX = 42;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH10: FMOD_DSP_CHANNELMIX = 43;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH11: FMOD_DSP_CHANNELMIX = 44;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH12: FMOD_DSP_CHANNELMIX = 45;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH13: FMOD_DSP_CHANNELMIX = 46;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH14: FMOD_DSP_CHANNELMIX = 47;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH15: FMOD_DSP_CHANNELMIX = 48;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH16: FMOD_DSP_CHANNELMIX = 49;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH17: FMOD_DSP_CHANNELMIX = 50;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH18: FMOD_DSP_CHANNELMIX = 51;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH19: FMOD_DSP_CHANNELMIX = 52;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH20: FMOD_DSP_CHANNELMIX = 53;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH21: FMOD_DSP_CHANNELMIX = 54;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH22: FMOD_DSP_CHANNELMIX = 55;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH23: FMOD_DSP_CHANNELMIX = 56;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH24: FMOD_DSP_CHANNELMIX = 57;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH25: FMOD_DSP_CHANNELMIX = 58;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH26: FMOD_DSP_CHANNELMIX = 59;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH27: FMOD_DSP_CHANNELMIX = 60;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH28: FMOD_DSP_CHANNELMIX = 61;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH29: FMOD_DSP_CHANNELMIX = 62;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH30: FMOD_DSP_CHANNELMIX = 63;
pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH31: FMOD_DSP_CHANNELMIX = 64;
pub type FMOD_DSP_CHANNELMIX = ::std::os::raw::c_uint;
pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = -1;
pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 0;
pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 1;
pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 2;
pub type FMOD_DSP_TRANSCEIVER_SPEAKERMODE = ::std::os::raw::c_int;
pub const FMOD_DSP_TRANSCEIVER_TRANSMIT: FMOD_DSP_TRANSCEIVER = 0;
pub const FMOD_DSP_TRANSCEIVER_GAIN: FMOD_DSP_TRANSCEIVER = 1;
pub const FMOD_DSP_TRANSCEIVER_CHANNEL: FMOD_DSP_TRANSCEIVER = 2;
pub const FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE: FMOD_DSP_TRANSCEIVER = 3;
pub type FMOD_DSP_TRANSCEIVER = ::std::os::raw::c_uint;
pub const FMOD_DSP_OBJECTPAN_3D_POSITION: FMOD_DSP_OBJECTPAN = 0;
pub const FMOD_DSP_OBJECTPAN_3D_ROLLOFF: FMOD_DSP_OBJECTPAN = 1;
pub const FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE: FMOD_DSP_OBJECTPAN = 2;
pub const FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE: FMOD_DSP_OBJECTPAN = 3;
pub const FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE: FMOD_DSP_OBJECTPAN = 4;
pub const FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE: FMOD_DSP_OBJECTPAN = 5;
pub const FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT: FMOD_DSP_OBJECTPAN = 6;
pub const FMOD_DSP_OBJECTPAN_OVERALL_GAIN: FMOD_DSP_OBJECTPAN = 7;
pub const FMOD_DSP_OBJECTPAN_OUTPUTGAIN: FMOD_DSP_OBJECTPAN = 8;
pub const FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE: FMOD_DSP_OBJECTPAN = 9;
pub const FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE: FMOD_DSP_OBJECTPAN = 10;
pub type FMOD_DSP_OBJECTPAN = ::std::os::raw::c_uint;
pub const FMOD_DSP_PROCESS_PERFORM: FMOD_DSP_PROCESS_OPERATION = 0;
pub const FMOD_DSP_PROCESS_QUERY: FMOD_DSP_PROCESS_OPERATION = 1;
pub type FMOD_DSP_PROCESS_OPERATION = ::std::os::raw::c_uint;
pub const FMOD_DSP_PAN_SURROUND_DEFAULT: FMOD_DSP_PAN_SURROUND_FLAGS = 0;
pub const FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED: FMOD_DSP_PAN_SURROUND_FLAGS = 1;
pub const FMOD_DSP_PAN_SURROUND_FLAGS_FORCEINT: FMOD_DSP_PAN_SURROUND_FLAGS = 65536;
pub type FMOD_DSP_PAN_SURROUND_FLAGS = ::std::os::raw::c_uint;
pub const FMOD_DSP_PARAMETER_TYPE_FLOAT: FMOD_DSP_PARAMETER_TYPE = 0;
pub const FMOD_DSP_PARAMETER_TYPE_INT: FMOD_DSP_PARAMETER_TYPE = 1;
pub const FMOD_DSP_PARAMETER_TYPE_BOOL: FMOD_DSP_PARAMETER_TYPE = 2;
pub const FMOD_DSP_PARAMETER_TYPE_DATA: FMOD_DSP_PARAMETER_TYPE = 3;
pub const FMOD_DSP_PARAMETER_TYPE_MAX: FMOD_DSP_PARAMETER_TYPE = 4;
pub const FMOD_DSP_PARAMETER_TYPE_FORCEINT: FMOD_DSP_PARAMETER_TYPE = 65536;
pub type FMOD_DSP_PARAMETER_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 0;
pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 1;
pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR:
    FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 2;
pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_FORCEINT: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE =
    65536;
pub type FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = ::std::os::raw::c_uint;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_USER: FMOD_DSP_PARAMETER_DATA_TYPE = 0;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -1;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES: FMOD_DSP_PARAMETER_DATA_TYPE = -2;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -3;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_FFT: FMOD_DSP_PARAMETER_DATA_TYPE = -4;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI: FMOD_DSP_PARAMETER_DATA_TYPE = -5;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE: FMOD_DSP_PARAMETER_DATA_TYPE = -6;
pub const FMOD_DSP_PARAMETER_DATA_TYPE_DYNAMIC_RESPONSE: FMOD_DSP_PARAMETER_DATA_TYPE = -7;
pub type FMOD_DSP_PARAMETER_DATA_TYPE = ::std::os::raw::c_int;
pub type FMOD_DSP_CREATE_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_RELEASE_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_RESET_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_READ_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        inbuffer: *mut f32,
        outbuffer: *mut f32,
        length: ::std::os::raw::c_uint,
        inchannels: ::std::os::raw::c_int,
        outchannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PROCESS_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        length: ::std::os::raw::c_uint,
        inbufferarray: *const FMOD_DSP_BUFFER_ARRAY,
        outbufferarray: *mut FMOD_DSP_BUFFER_ARRAY,
        inputsidle: FMOD_BOOL,
        op: FMOD_DSP_PROCESS_OPERATION,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPOSITION_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        pos: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SHOULDIPROCESS_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        inputsidle: FMOD_BOOL,
        length: ::std::os::raw::c_uint,
        inmask: FMOD_CHANNELMASK,
        inchannels: ::std::os::raw::c_int,
        speakermode: FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_FLOAT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: f32,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_INT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_BOOL_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: FMOD_BOOL,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_DATA_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        data: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_FLOAT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: *mut f32,
        valuestr: *mut ::std::os::raw::c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_INT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: *mut ::std::os::raw::c_int,
        valuestr: *mut ::std::os::raw::c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_BOOL_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        value: *mut FMOD_BOOL,
        valuestr: *mut ::std::os::raw::c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_DATA_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: ::std::os::raw::c_int,
        data: *mut *mut ::std::os::raw::c_void,
        length: *mut ::std::os::raw::c_uint,
        valuestr: *mut ::std::os::raw::c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SYSTEM_REGISTER_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK =
    ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_SYSTEM_MIX_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        stage: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_ALLOC_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        size: ::std::os::raw::c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_DSP_REALLOC_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        size: ::std::os::raw::c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_DSP_FREE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const ::std::os::raw::c_char,
    ),
>;
pub type FMOD_DSP_LOG_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        function: *const ::std::os::raw::c_char,
        str_: *const ::std::os::raw::c_char,
        ...
    ),
>;
pub type FMOD_DSP_GETSAMPLERATE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        rate: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETBLOCKSIZE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        blocksize: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETSPEAKERMODE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        speakermode_mixer: *mut FMOD_SPEAKERMODE,
        speakermode_output: *mut FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETCLOCK_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        clock: *mut ::std::os::raw::c_ulonglong,
        offset: *mut ::std::os::raw::c_uint,
        length: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETLISTENERATTRIBUTES_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        numlisteners: *mut ::std::os::raw::c_int,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETUSERDATA_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_DFT_FFTREAL_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        size: ::std::os::raw::c_int,
        signal: *const f32,
        dft: *mut FMOD_COMPLEX,
        window: *const f32,
        signalhop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_DFT_IFFTREAL_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        size: ::std::os::raw::c_int,
        dft: *const FMOD_COMPLEX,
        signal: *mut f32,
        window: *const f32,
        signalhop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMMONOMATRIX_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        lowFrequencyGain: f32,
        overallGain: f32,
        matrix: *mut f32,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        pan: f32,
        lowFrequencyGain: f32,
        overallGain: f32,
        matrixHop: ::std::os::raw::c_int,
        matrix: *mut f32,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: f32,
        extent: f32,
        rotation: f32,
        lowFrequencyGain: f32,
        overallGain: f32,
        matrixHop: ::std::os::raw::c_int,
        matrix: *mut f32,
        flags: FMOD_DSP_PAN_SURROUND_FLAGS,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: f32,
        extent: f32,
        lowFrequencyGain: f32,
        overallGain: f32,
        matrixHop: ::std::os::raw::c_int,
        matrix: *mut f32,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: f32,
        extent: f32,
        rotation: f32,
        lowFrequencyGain: f32,
        overallGain: f32,
        matrixHop: ::std::os::raw::c_int,
        matrix: *mut f32,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        rolloff: FMOD_DSP_PAN_3D_ROLLOFF_TYPE,
        distance: f32,
        mindistance: f32,
        maxdistance: f32,
        gain: *mut f32,
    ) -> FMOD_RESULT,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_BUFFER_ARRAY {
    pub numbuffers: ::std::os::raw::c_int,
    pub buffernumchannels: *mut ::std::os::raw::c_int,
    pub bufferchannelmask: *mut FMOD_CHANNELMASK,
    pub buffers: *mut *mut f32,
    pub speakermode: FMOD_SPEAKERMODE,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_BUFFER_ARRAY"][::std::mem::size_of::<FMOD_DSP_BUFFER_ARRAY>() - 40usize];
    ["Alignment of FMOD_DSP_BUFFER_ARRAY"]
        [::std::mem::align_of::<FMOD_DSP_BUFFER_ARRAY>() - 8usize];
    ["Offset of field: FMOD_DSP_BUFFER_ARRAY::numbuffers"]
        [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, numbuffers) - 0usize];
    ["Offset of field: FMOD_DSP_BUFFER_ARRAY::buffernumchannels"]
        [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, buffernumchannels) - 8usize];
    ["Offset of field: FMOD_DSP_BUFFER_ARRAY::bufferchannelmask"]
        [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, bufferchannelmask) - 16usize];
    ["Offset of field: FMOD_DSP_BUFFER_ARRAY::buffers"]
        [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, buffers) - 24usize];
    ["Offset of field: FMOD_DSP_BUFFER_ARRAY::speakermode"]
        [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, speakermode) - 32usize];
};
impl Default for FMOD_DSP_BUFFER_ARRAY {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_COMPLEX {
    pub real: f32,
    pub imag: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_COMPLEX"][::std::mem::size_of::<FMOD_COMPLEX>() - 8usize];
    ["Alignment of FMOD_COMPLEX"][::std::mem::align_of::<FMOD_COMPLEX>() - 4usize];
    ["Offset of field: FMOD_COMPLEX::real"][::std::mem::offset_of!(FMOD_COMPLEX, real) - 0usize];
    ["Offset of field: FMOD_COMPLEX::imag"][::std::mem::offset_of!(FMOD_COMPLEX, imag) - 4usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
    pub numpoints: ::std::os::raw::c_int,
    pub pointparamvalues: *mut f32,
    pub pointpositions: *mut f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>() - 24usize];
    ["Alignment of FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::numpoints"][::std::mem::offset_of!(
        FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
        numpoints
    ) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::pointparamvalues"][::std::mem::offset_of!(
        FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
        pointparamvalues
    )
        - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::pointpositions"][::std::mem::offset_of!(
        FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
        pointpositions
    )
        - 16usize];
};
impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING {
    pub type_: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE,
    pub piecewiselinearmapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_FLOAT_MAPPING"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>() - 32usize];
    ["Alignment of FMOD_DSP_PARAMETER_FLOAT_MAPPING"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING::type_"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FLOAT_MAPPING, type_) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING::piecewiselinearmapping"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FLOAT_MAPPING, piecewiselinearmapping) - 8usize];
};
impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_DESC_FLOAT {
    pub min: f32,
    pub max: f32,
    pub defaultval: f32,
    pub mapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC_FLOAT"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>() - 48usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC_FLOAT"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::min"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, min) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::max"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, max) - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::defaultval"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, defaultval) - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::mapping"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, mapping) - 16usize];
};
impl Default for FMOD_DSP_PARAMETER_DESC_FLOAT {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_DESC_INT {
    pub min: ::std::os::raw::c_int,
    pub max: ::std::os::raw::c_int,
    pub defaultval: ::std::os::raw::c_int,
    pub goestoinf: FMOD_BOOL,
    pub valuenames: *const *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC_INT"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_INT>() - 24usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC_INT"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_INT>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::min"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, min) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::max"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, max) - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::defaultval"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, defaultval) - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::goestoinf"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, goestoinf) - 12usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::valuenames"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, valuenames) - 16usize];
};
impl Default for FMOD_DSP_PARAMETER_DESC_INT {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_DESC_BOOL {
    pub defaultval: FMOD_BOOL,
    pub valuenames: *const *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC_BOOL"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_BOOL>() - 16usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC_BOOL"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_BOOL>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_BOOL::defaultval"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_BOOL, defaultval) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_BOOL::valuenames"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_BOOL, valuenames) - 8usize];
};
impl Default for FMOD_DSP_PARAMETER_DESC_BOOL {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_DESC_DATA {
    pub datatype: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC_DATA"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_DATA>() - 4usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC_DATA"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_DATA>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC_DATA::datatype"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_DATA, datatype) - 0usize];
};
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC {
    pub type_: FMOD_DSP_PARAMETER_TYPE,
    pub name: [::std::os::raw::c_char; 16usize],
    pub label: [::std::os::raw::c_char; 16usize],
    pub description: *const ::std::os::raw::c_char,
    pub __bindgen_anon_1: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
    pub floatdesc: FMOD_DSP_PARAMETER_DESC_FLOAT,
    pub intdesc: FMOD_DSP_PARAMETER_DESC_INT,
    pub booldesc: FMOD_DSP_PARAMETER_DESC_BOOL,
    pub datadesc: FMOD_DSP_PARAMETER_DESC_DATA,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC__bindgen_ty_1"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>() - 48usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC__bindgen_ty_1"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::floatdesc"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, floatdesc) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::intdesc"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, intdesc) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::booldesc"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, booldesc) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::datadesc"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, datadesc) - 0usize];
};
impl Default for FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DESC"][::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC>() - 96usize];
    ["Alignment of FMOD_DSP_PARAMETER_DESC"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC::type_"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, type_) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC::name"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, name) - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC::label"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, label) - 20usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DESC::description"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, description) - 40usize];
};
impl Default for FMOD_DSP_PARAMETER_DESC {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_OVERALLGAIN {
    pub linear_gain: f32,
    pub linear_gain_additive: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_OVERALLGAIN"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>() - 8usize];
    ["Alignment of FMOD_DSP_PARAMETER_OVERALLGAIN"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_OVERALLGAIN::linear_gain"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_OVERALLGAIN, linear_gain) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_OVERALLGAIN::linear_gain_additive"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_OVERALLGAIN, linear_gain_additive) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES {
    pub relative: FMOD_3D_ATTRIBUTES,
    pub absolute: FMOD_3D_ATTRIBUTES,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_3DATTRIBUTES"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>() - 96usize];
    ["Alignment of FMOD_DSP_PARAMETER_3DATTRIBUTES"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES::relative"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES, relative) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES::absolute"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES, absolute) - 48usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
    pub numlisteners: ::std::os::raw::c_int,
    pub relative: [FMOD_3D_ATTRIBUTES; 8usize],
    pub weight: [f32; 8usize],
    pub absolute: FMOD_3D_ATTRIBUTES,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>() - 468usize];
    ["Alignment of FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::numlisteners"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, numlisteners) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::relative"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, relative) - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::weight"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, weight) - 388usize];
    ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::absolute"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, absolute) - 420usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
    pub min: f32,
    pub max: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_ATTENUATION_RANGE"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>() - 8usize];
    ["Alignment of FMOD_DSP_PARAMETER_ATTENUATION_RANGE"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_ATTENUATION_RANGE::min"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE, min) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_ATTENUATION_RANGE::max"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE, max) - 4usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_SIDECHAIN {
    pub sidechainenable: FMOD_BOOL,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_SIDECHAIN"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_SIDECHAIN>() - 4usize];
    ["Alignment of FMOD_DSP_PARAMETER_SIDECHAIN"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_SIDECHAIN>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_SIDECHAIN::sidechainenable"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_SIDECHAIN, sidechainenable) - 0usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_PARAMETER_FFT {
    pub length: ::std::os::raw::c_int,
    pub numchannels: ::std::os::raw::c_int,
    pub spectrum: [*mut f32; 32usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_FFT"][::std::mem::size_of::<FMOD_DSP_PARAMETER_FFT>() - 264usize];
    ["Alignment of FMOD_DSP_PARAMETER_FFT"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_FFT>() - 8usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FFT::length"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, length) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FFT::numchannels"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, numchannels) - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_FFT::spectrum"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, spectrum) - 8usize];
};
impl Default for FMOD_DSP_PARAMETER_FFT {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE {
    pub numchannels: ::std::os::raw::c_int,
    pub rms: [f32; 32usize],
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE"]
        [::std::mem::size_of::<FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE>() - 132usize];
    ["Alignment of FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE"]
        [::std::mem::align_of::<FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE>() - 4usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE::numchannels"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE, numchannels) - 0usize];
    ["Offset of field: FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE::rms"]
        [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE, rms) - 4usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_DESCRIPTION {
    pub pluginsdkversion: ::std::os::raw::c_uint,
    pub name: [::std::os::raw::c_char; 32usize],
    pub version: ::std::os::raw::c_uint,
    pub numinputbuffers: ::std::os::raw::c_int,
    pub numoutputbuffers: ::std::os::raw::c_int,
    pub create: FMOD_DSP_CREATE_CALLBACK,
    pub release: FMOD_DSP_RELEASE_CALLBACK,
    pub reset: FMOD_DSP_RESET_CALLBACK,
    pub read: FMOD_DSP_READ_CALLBACK,
    pub process: FMOD_DSP_PROCESS_CALLBACK,
    pub setposition: FMOD_DSP_SETPOSITION_CALLBACK,
    pub numparameters: ::std::os::raw::c_int,
    pub paramdesc: *mut *mut FMOD_DSP_PARAMETER_DESC,
    pub setparameterfloat: FMOD_DSP_SETPARAM_FLOAT_CALLBACK,
    pub setparameterint: FMOD_DSP_SETPARAM_INT_CALLBACK,
    pub setparameterbool: FMOD_DSP_SETPARAM_BOOL_CALLBACK,
    pub setparameterdata: FMOD_DSP_SETPARAM_DATA_CALLBACK,
    pub getparameterfloat: FMOD_DSP_GETPARAM_FLOAT_CALLBACK,
    pub getparameterint: FMOD_DSP_GETPARAM_INT_CALLBACK,
    pub getparameterbool: FMOD_DSP_GETPARAM_BOOL_CALLBACK,
    pub getparameterdata: FMOD_DSP_GETPARAM_DATA_CALLBACK,
    pub shouldiprocess: FMOD_DSP_SHOULDIPROCESS_CALLBACK,
    pub userdata: *mut ::std::os::raw::c_void,
    pub sys_register: FMOD_DSP_SYSTEM_REGISTER_CALLBACK,
    pub sys_deregister: FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK,
    pub sys_mix: FMOD_DSP_SYSTEM_MIX_CALLBACK,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_DESCRIPTION"][::std::mem::size_of::<FMOD_DSP_DESCRIPTION>() - 216usize];
    ["Alignment of FMOD_DSP_DESCRIPTION"][::std::mem::align_of::<FMOD_DSP_DESCRIPTION>() - 8usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::pluginsdkversion"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, pluginsdkversion) - 0usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::name"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, name) - 4usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::version"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, version) - 36usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::numinputbuffers"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numinputbuffers) - 40usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::numoutputbuffers"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numoutputbuffers) - 44usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::create"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, create) - 48usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::release"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, release) - 56usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::reset"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, reset) - 64usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::read"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, read) - 72usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::process"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, process) - 80usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::setposition"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setposition) - 88usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::numparameters"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numparameters) - 96usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::paramdesc"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, paramdesc) - 104usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterfloat"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterfloat) - 112usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterint"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterint) - 120usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterbool"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterbool) - 128usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterdata"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterdata) - 136usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterfloat"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterfloat) - 144usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterint"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterint) - 152usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterbool"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterbool) - 160usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterdata"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterdata) - 168usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::shouldiprocess"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, shouldiprocess) - 176usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::userdata"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, userdata) - 184usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::sys_register"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_register) - 192usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::sys_deregister"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_deregister) - 200usize];
    ["Offset of field: FMOD_DSP_DESCRIPTION::sys_mix"]
        [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_mix) - 208usize];
};
impl Default for FMOD_DSP_DESCRIPTION {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_STATE_DFT_FUNCTIONS {
    pub fftreal: FMOD_DSP_DFT_FFTREAL_FUNC,
    pub inversefftreal: FMOD_DSP_DFT_IFFTREAL_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_STATE_DFT_FUNCTIONS"]
        [::std::mem::size_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>() - 16usize];
    ["Alignment of FMOD_DSP_STATE_DFT_FUNCTIONS"]
        [::std::mem::align_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>() - 8usize];
    ["Offset of field: FMOD_DSP_STATE_DFT_FUNCTIONS::fftreal"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_DFT_FUNCTIONS, fftreal) - 0usize];
    ["Offset of field: FMOD_DSP_STATE_DFT_FUNCTIONS::inversefftreal"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_DFT_FUNCTIONS, inversefftreal) - 8usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_STATE_PAN_FUNCTIONS {
    pub summonomatrix: FMOD_DSP_PAN_SUMMONOMATRIX_FUNC,
    pub sumstereomatrix: FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC,
    pub sumsurroundmatrix: FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC,
    pub summonotosurroundmatrix: FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC,
    pub sumstereotosurroundmatrix: FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC,
    pub getrolloffgain: FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_STATE_PAN_FUNCTIONS"]
        [::std::mem::size_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>() - 48usize];
    ["Alignment of FMOD_DSP_STATE_PAN_FUNCTIONS"]
        [::std::mem::align_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>() - 8usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::summonomatrix"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, summonomatrix) - 0usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumstereomatrix"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumstereomatrix) - 8usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumsurroundmatrix"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumsurroundmatrix) - 16usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::summonotosurroundmatrix"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, summonotosurroundmatrix) - 24usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumstereotosurroundmatrix"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumstereotosurroundmatrix) - 32usize];
    ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::getrolloffgain"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, getrolloffgain) - 40usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_STATE_FUNCTIONS {
    pub alloc: FMOD_DSP_ALLOC_FUNC,
    pub realloc: FMOD_DSP_REALLOC_FUNC,
    pub free: FMOD_DSP_FREE_FUNC,
    pub getsamplerate: FMOD_DSP_GETSAMPLERATE_FUNC,
    pub getblocksize: FMOD_DSP_GETBLOCKSIZE_FUNC,
    pub dft: *mut FMOD_DSP_STATE_DFT_FUNCTIONS,
    pub pan: *mut FMOD_DSP_STATE_PAN_FUNCTIONS,
    pub getspeakermode: FMOD_DSP_GETSPEAKERMODE_FUNC,
    pub getclock: FMOD_DSP_GETCLOCK_FUNC,
    pub getlistenerattributes: FMOD_DSP_GETLISTENERATTRIBUTES_FUNC,
    pub log: FMOD_DSP_LOG_FUNC,
    pub getuserdata: FMOD_DSP_GETUSERDATA_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_STATE_FUNCTIONS"]
        [::std::mem::size_of::<FMOD_DSP_STATE_FUNCTIONS>() - 96usize];
    ["Alignment of FMOD_DSP_STATE_FUNCTIONS"]
        [::std::mem::align_of::<FMOD_DSP_STATE_FUNCTIONS>() - 8usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::alloc"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, alloc) - 0usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::realloc"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, realloc) - 8usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::free"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, free) - 16usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getsamplerate"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getsamplerate) - 24usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getblocksize"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getblocksize) - 32usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::dft"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, dft) - 40usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::pan"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, pan) - 48usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getspeakermode"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getspeakermode) - 56usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getclock"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getclock) - 64usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getlistenerattributes"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getlistenerattributes) - 72usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::log"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, log) - 80usize];
    ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getuserdata"]
        [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getuserdata) - 88usize];
};
impl Default for FMOD_DSP_STATE_FUNCTIONS {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_DSP_STATE {
    pub instance: *mut ::std::os::raw::c_void,
    pub plugindata: *mut ::std::os::raw::c_void,
    pub channelmask: FMOD_CHANNELMASK,
    pub source_speakermode: FMOD_SPEAKERMODE,
    pub sidechaindata: *mut f32,
    pub sidechainchannels: ::std::os::raw::c_int,
    pub functions: *mut FMOD_DSP_STATE_FUNCTIONS,
    pub systemobject: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_STATE"][::std::mem::size_of::<FMOD_DSP_STATE>() - 56usize];
    ["Alignment of FMOD_DSP_STATE"][::std::mem::align_of::<FMOD_DSP_STATE>() - 8usize];
    ["Offset of field: FMOD_DSP_STATE::instance"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, instance) - 0usize];
    ["Offset of field: FMOD_DSP_STATE::plugindata"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, plugindata) - 8usize];
    ["Offset of field: FMOD_DSP_STATE::channelmask"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, channelmask) - 16usize];
    ["Offset of field: FMOD_DSP_STATE::source_speakermode"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, source_speakermode) - 20usize];
    ["Offset of field: FMOD_DSP_STATE::sidechaindata"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, sidechaindata) - 24usize];
    ["Offset of field: FMOD_DSP_STATE::sidechainchannels"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, sidechainchannels) - 32usize];
    ["Offset of field: FMOD_DSP_STATE::functions"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, functions) - 40usize];
    ["Offset of field: FMOD_DSP_STATE::systemobject"]
        [::std::mem::offset_of!(FMOD_DSP_STATE, systemobject) - 48usize];
};
impl Default for FMOD_DSP_STATE {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_DSP_METERING_INFO {
    pub numsamples: ::std::os::raw::c_int,
    pub peaklevel: [f32; 32usize],
    pub rmslevel: [f32; 32usize],
    pub numchannels: ::std::os::raw::c_short,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_DSP_METERING_INFO"][::std::mem::size_of::<FMOD_DSP_METERING_INFO>() - 264usize];
    ["Alignment of FMOD_DSP_METERING_INFO"]
        [::std::mem::align_of::<FMOD_DSP_METERING_INFO>() - 4usize];
    ["Offset of field: FMOD_DSP_METERING_INFO::numsamples"]
        [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, numsamples) - 0usize];
    ["Offset of field: FMOD_DSP_METERING_INFO::peaklevel"]
        [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, peaklevel) - 4usize];
    ["Offset of field: FMOD_DSP_METERING_INFO::rmslevel"]
        [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, rmslevel) - 132usize];
    ["Offset of field: FMOD_DSP_METERING_INFO::numchannels"]
        [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, numchannels) - 260usize];
};
pub type FMOD_OUTPUT_METHOD = ::std::os::raw::c_uint;
pub type FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        numdrivers: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_GETDRIVERINFO_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        id: ::std::os::raw::c_int,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut ::std::os::raw::c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_INIT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        selecteddriver: ::std::os::raw::c_int,
        flags: FMOD_INITFLAGS,
        outputrate: *mut ::std::os::raw::c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut ::std::os::raw::c_int,
        outputformat: *mut FMOD_SOUND_FORMAT,
        dspbufferlength: ::std::os::raw::c_int,
        dspnumbuffers: *mut ::std::os::raw::c_int,
        dspnumadditionalbuffers: *mut ::std::os::raw::c_int,
        extradriverdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_START_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_STOP_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_CLOSE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_UPDATE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_GETHANDLE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        handle: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_MIXER_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        maxhardwareobjects: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DFREE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut ::std::os::raw::c_void,
        info: *const FMOD_OUTPUT_OBJECT3DINFO,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OPENPORT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        portType: FMOD_PORT_TYPE,
        portIndex: FMOD_PORT_INDEX,
        portId: *mut ::std::os::raw::c_int,
        portRate: *mut ::std::os::raw::c_int,
        portChannels: *mut ::std::os::raw::c_int,
        portFormat: *mut FMOD_SOUND_FORMAT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_CLOSEPORT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        portId: ::std::os::raw::c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_READFROMMIXER_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        buffer: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_COPYPORT_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        portId: ::std::os::raw::c_int,
        buffer: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_REQUESTRESET_FUNC = ::std::option::Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_ALLOC_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        size: ::std::os::raw::c_uint,
        align: ::std::os::raw::c_uint,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
    ) -> *mut ::std::os::raw::c_void,
>;
pub type FMOD_OUTPUT_FREE_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        ptr: *mut ::std::os::raw::c_void,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
    ),
>;
pub type FMOD_OUTPUT_LOG_FUNC = ::std::option::Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const ::std::os::raw::c_char,
        line: ::std::os::raw::c_int,
        function: *const ::std::os::raw::c_char,
        string: *const ::std::os::raw::c_char,
        ...
    ),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_OUTPUT_DESCRIPTION {
    pub apiversion: ::std::os::raw::c_uint,
    pub name: *const ::std::os::raw::c_char,
    pub version: ::std::os::raw::c_uint,
    pub method: FMOD_OUTPUT_METHOD,
    pub getnumdrivers: FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK,
    pub getdriverinfo: FMOD_OUTPUT_GETDRIVERINFO_CALLBACK,
    pub init: FMOD_OUTPUT_INIT_CALLBACK,
    pub start: FMOD_OUTPUT_START_CALLBACK,
    pub stop: FMOD_OUTPUT_STOP_CALLBACK,
    pub close: FMOD_OUTPUT_CLOSE_CALLBACK,
    pub update: FMOD_OUTPUT_UPDATE_CALLBACK,
    pub gethandle: FMOD_OUTPUT_GETHANDLE_CALLBACK,
    pub mixer: FMOD_OUTPUT_MIXER_CALLBACK,
    pub object3dgetinfo: FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK,
    pub object3dalloc: FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK,
    pub object3dfree: FMOD_OUTPUT_OBJECT3DFREE_CALLBACK,
    pub object3dupdate: FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK,
    pub openport: FMOD_OUTPUT_OPENPORT_CALLBACK,
    pub closeport: FMOD_OUTPUT_CLOSEPORT_CALLBACK,
    pub devicelistchanged: FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_OUTPUT_DESCRIPTION"]
        [::std::mem::size_of::<FMOD_OUTPUT_DESCRIPTION>() - 152usize];
    ["Alignment of FMOD_OUTPUT_DESCRIPTION"]
        [::std::mem::align_of::<FMOD_OUTPUT_DESCRIPTION>() - 8usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::apiversion"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, apiversion) - 0usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::name"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, name) - 8usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::version"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, version) - 16usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::method"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, method) - 20usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::getnumdrivers"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, getnumdrivers) - 24usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::getdriverinfo"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, getdriverinfo) - 32usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::init"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, init) - 40usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::start"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, start) - 48usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::stop"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, stop) - 56usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::close"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, close) - 64usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::update"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, update) - 72usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::gethandle"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, gethandle) - 80usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::mixer"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, mixer) - 88usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dgetinfo"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dgetinfo) - 96usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dalloc"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dalloc) - 104usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dfree"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dfree) - 112usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dupdate"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dupdate) - 120usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::openport"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, openport) - 128usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::closeport"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, closeport) - 136usize];
    ["Offset of field: FMOD_OUTPUT_DESCRIPTION::devicelistchanged"]
        [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, devicelistchanged) - 144usize];
};
impl Default for FMOD_OUTPUT_DESCRIPTION {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_OUTPUT_STATE {
    pub plugindata: *mut ::std::os::raw::c_void,
    pub readfrommixer: FMOD_OUTPUT_READFROMMIXER_FUNC,
    pub alloc: FMOD_OUTPUT_ALLOC_FUNC,
    pub free: FMOD_OUTPUT_FREE_FUNC,
    pub log: FMOD_OUTPUT_LOG_FUNC,
    pub copyport: FMOD_OUTPUT_COPYPORT_FUNC,
    pub requestreset: FMOD_OUTPUT_REQUESTRESET_FUNC,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_OUTPUT_STATE"][::std::mem::size_of::<FMOD_OUTPUT_STATE>() - 56usize];
    ["Alignment of FMOD_OUTPUT_STATE"][::std::mem::align_of::<FMOD_OUTPUT_STATE>() - 8usize];
    ["Offset of field: FMOD_OUTPUT_STATE::plugindata"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, plugindata) - 0usize];
    ["Offset of field: FMOD_OUTPUT_STATE::readfrommixer"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, readfrommixer) - 8usize];
    ["Offset of field: FMOD_OUTPUT_STATE::alloc"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, alloc) - 16usize];
    ["Offset of field: FMOD_OUTPUT_STATE::free"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, free) - 24usize];
    ["Offset of field: FMOD_OUTPUT_STATE::log"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, log) - 32usize];
    ["Offset of field: FMOD_OUTPUT_STATE::copyport"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, copyport) - 40usize];
    ["Offset of field: FMOD_OUTPUT_STATE::requestreset"]
        [::std::mem::offset_of!(FMOD_OUTPUT_STATE, requestreset) - 48usize];
};
impl Default for FMOD_OUTPUT_STATE {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_OUTPUT_OBJECT3DINFO {
    pub buffer: *mut f32,
    pub bufferlength: ::std::os::raw::c_uint,
    pub position: FMOD_VECTOR,
    pub gain: f32,
    pub spread: f32,
    pub priority: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_OUTPUT_OBJECT3DINFO"]
        [::std::mem::size_of::<FMOD_OUTPUT_OBJECT3DINFO>() - 40usize];
    ["Alignment of FMOD_OUTPUT_OBJECT3DINFO"]
        [::std::mem::align_of::<FMOD_OUTPUT_OBJECT3DINFO>() - 8usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::buffer"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, buffer) - 0usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::bufferlength"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, bufferlength) - 8usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::position"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, position) - 12usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::gain"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, gain) - 24usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::spread"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, spread) - 28usize];
    ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::priority"]
        [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, priority) - 32usize];
};
impl Default for FMOD_OUTPUT_OBJECT3DINFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Memory_Initialize(
        poolmem: *mut ::std::os::raw::c_void,
        poollen: ::std::os::raw::c_int,
        useralloc: FMOD_MEMORY_ALLOC_CALLBACK,
        userrealloc: FMOD_MEMORY_REALLOC_CALLBACK,
        userfree: FMOD_MEMORY_FREE_CALLBACK,
        memtypeflags: FMOD_MEMORY_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Memory_GetStats(
        currentalloced: *mut ::std::os::raw::c_int,
        maxalloced: *mut ::std::os::raw::c_int,
        blocking: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Debug_Initialize(
        flags: FMOD_DEBUG_FLAGS,
        mode: FMOD_DEBUG_MODE,
        callback: FMOD_DEBUG_CALLBACK,
        filename: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_File_SetDiskBusy(busy: ::std::os::raw::c_int) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_File_GetDiskBusy(busy: *mut ::std::os::raw::c_int) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Thread_SetAttributes(
        type_: FMOD_THREAD_TYPE,
        affinity: FMOD_THREAD_AFFINITY,
        priority: FMOD_THREAD_PRIORITY,
        stacksize: FMOD_THREAD_STACK_SIZE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Create(
        system: *mut *mut FMOD_SYSTEM,
        headerversion: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Release(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetOutput(system: *mut FMOD_SYSTEM, output: FMOD_OUTPUTTYPE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetOutput(
        system: *mut FMOD_SYSTEM,
        output: *mut FMOD_OUTPUTTYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNumDrivers(
        system: *mut FMOD_SYSTEM,
        numdrivers: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDriverInfo(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut ::std::os::raw::c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetDriver(
        system: *mut FMOD_SYSTEM,
        driver: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDriver(
        system: *mut FMOD_SYSTEM,
        driver: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetSoftwareChannels(
        system: *mut FMOD_SYSTEM,
        numsoftwarechannels: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetSoftwareChannels(
        system: *mut FMOD_SYSTEM,
        numsoftwarechannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetSoftwareFormat(
        system: *mut FMOD_SYSTEM,
        samplerate: ::std::os::raw::c_int,
        speakermode: FMOD_SPEAKERMODE,
        numrawspeakers: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetSoftwareFormat(
        system: *mut FMOD_SYSTEM,
        samplerate: *mut ::std::os::raw::c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        numrawspeakers: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetDSPBufferSize(
        system: *mut FMOD_SYSTEM,
        bufferlength: ::std::os::raw::c_uint,
        numbuffers: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDSPBufferSize(
        system: *mut FMOD_SYSTEM,
        bufferlength: *mut ::std::os::raw::c_uint,
        numbuffers: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetFileSystem(
        system: *mut FMOD_SYSTEM,
        useropen: FMOD_FILE_OPEN_CALLBACK,
        userclose: FMOD_FILE_CLOSE_CALLBACK,
        userread: FMOD_FILE_READ_CALLBACK,
        userseek: FMOD_FILE_SEEK_CALLBACK,
        userasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
        userasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
        blockalign: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_AttachFileSystem(
        system: *mut FMOD_SYSTEM,
        useropen: FMOD_FILE_OPEN_CALLBACK,
        userclose: FMOD_FILE_CLOSE_CALLBACK,
        userread: FMOD_FILE_READ_CALLBACK,
        userseek: FMOD_FILE_SEEK_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetAdvancedSettings(
        system: *mut FMOD_SYSTEM,
        settings: *mut FMOD_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetAdvancedSettings(
        system: *mut FMOD_SYSTEM,
        settings: *mut FMOD_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetCallback(
        system: *mut FMOD_SYSTEM,
        callback: FMOD_SYSTEM_CALLBACK,
        callbackmask: FMOD_SYSTEM_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetPluginPath(
        system: *mut FMOD_SYSTEM,
        path: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_LoadPlugin(
        system: *mut FMOD_SYSTEM,
        filename: *const ::std::os::raw::c_char,
        handle: *mut ::std::os::raw::c_uint,
        priority: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_UnloadPlugin(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNumNestedPlugins(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNestedPlugin(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
        index: ::std::os::raw::c_int,
        nestedhandle: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNumPlugins(
        system: *mut FMOD_SYSTEM,
        plugintype: FMOD_PLUGINTYPE,
        numplugins: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetPluginHandle(
        system: *mut FMOD_SYSTEM,
        plugintype: FMOD_PLUGINTYPE,
        index: ::std::os::raw::c_int,
        handle: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetPluginInfo(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
        plugintype: *mut FMOD_PLUGINTYPE,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
        version: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetOutputByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetOutputByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateDSPByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDSPInfoByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: ::std::os::raw::c_uint,
        description: *mut *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_RegisterCodec(
        system: *mut FMOD_SYSTEM,
        description: *mut FMOD_CODEC_DESCRIPTION,
        handle: *mut ::std::os::raw::c_uint,
        priority: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_RegisterDSP(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
        handle: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_RegisterOutput(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_OUTPUT_DESCRIPTION,
        handle: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Init(
        system: *mut FMOD_SYSTEM,
        maxchannels: ::std::os::raw::c_int,
        flags: FMOD_INITFLAGS,
        extradriverdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Close(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Update(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetSpeakerPosition(
        system: *mut FMOD_SYSTEM,
        speaker: FMOD_SPEAKER,
        x: f32,
        y: f32,
        active: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetSpeakerPosition(
        system: *mut FMOD_SYSTEM,
        speaker: FMOD_SPEAKER,
        x: *mut f32,
        y: *mut f32,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetStreamBufferSize(
        system: *mut FMOD_SYSTEM,
        filebuffersize: ::std::os::raw::c_uint,
        filebuffersizetype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetStreamBufferSize(
        system: *mut FMOD_SYSTEM,
        filebuffersize: *mut ::std::os::raw::c_uint,
        filebuffersizetype: *mut FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Set3DSettings(
        system: *mut FMOD_SYSTEM,
        dopplerscale: f32,
        distancefactor: f32,
        rolloffscale: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Get3DSettings(
        system: *mut FMOD_SYSTEM,
        dopplerscale: *mut f32,
        distancefactor: *mut f32,
        rolloffscale: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Set3DNumListeners(
        system: *mut FMOD_SYSTEM,
        numlisteners: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Get3DNumListeners(
        system: *mut FMOD_SYSTEM,
        numlisteners: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Set3DListenerAttributes(
        system: *mut FMOD_SYSTEM,
        listener: ::std::os::raw::c_int,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
        forward: *const FMOD_VECTOR,
        up: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Get3DListenerAttributes(
        system: *mut FMOD_SYSTEM,
        listener: ::std::os::raw::c_int,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
        forward: *mut FMOD_VECTOR,
        up: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_Set3DRolloffCallback(
        system: *mut FMOD_SYSTEM,
        callback: FMOD_3D_ROLLOFF_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_MixerSuspend(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_MixerResume(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDefaultMixMatrix(
        system: *mut FMOD_SYSTEM,
        sourcespeakermode: FMOD_SPEAKERMODE,
        targetspeakermode: FMOD_SPEAKERMODE,
        matrix: *mut f32,
        matrixhop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetSpeakerModeChannels(
        system: *mut FMOD_SYSTEM,
        mode: FMOD_SPEAKERMODE,
        channels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetVersion(
        system: *mut FMOD_SYSTEM,
        version: *mut ::std::os::raw::c_uint,
        buildnumber: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetOutputHandle(
        system: *mut FMOD_SYSTEM,
        handle: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetChannelsPlaying(
        system: *mut FMOD_SYSTEM,
        channels: *mut ::std::os::raw::c_int,
        realchannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetCPUUsage(
        system: *mut FMOD_SYSTEM,
        usage: *mut FMOD_CPU_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetFileUsage(
        system: *mut FMOD_SYSTEM,
        sampleBytesRead: *mut ::std::os::raw::c_longlong,
        streamBytesRead: *mut ::std::os::raw::c_longlong,
        otherBytesRead: *mut ::std::os::raw::c_longlong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateSound(
        system: *mut FMOD_SYSTEM,
        name_or_data: *const ::std::os::raw::c_char,
        mode: FMOD_MODE,
        exinfo: *mut FMOD_CREATESOUNDEXINFO,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateStream(
        system: *mut FMOD_SYSTEM,
        name_or_data: *const ::std::os::raw::c_char,
        mode: FMOD_MODE,
        exinfo: *mut FMOD_CREATESOUNDEXINFO,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateDSP(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateDSPByType(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_DSP_TYPE,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateChannelGroup(
        system: *mut FMOD_SYSTEM,
        name: *const ::std::os::raw::c_char,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateSoundGroup(
        system: *mut FMOD_SYSTEM,
        name: *const ::std::os::raw::c_char,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateReverb3D(
        system: *mut FMOD_SYSTEM,
        reverb: *mut *mut FMOD_REVERB3D,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_PlaySound(
        system: *mut FMOD_SYSTEM,
        sound: *mut FMOD_SOUND,
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: FMOD_BOOL,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_PlayDSP(
        system: *mut FMOD_SYSTEM,
        dsp: *mut FMOD_DSP,
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: FMOD_BOOL,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetChannel(
        system: *mut FMOD_SYSTEM,
        channelid: ::std::os::raw::c_int,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetDSPInfoByType(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_DSP_TYPE,
        description: *mut *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetMasterChannelGroup(
        system: *mut FMOD_SYSTEM,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetMasterSoundGroup(
        system: *mut FMOD_SYSTEM,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_AttachChannelGroupToPort(
        system: *mut FMOD_SYSTEM,
        portType: FMOD_PORT_TYPE,
        portIndex: FMOD_PORT_INDEX,
        channelgroup: *mut FMOD_CHANNELGROUP,
        passThru: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_DetachChannelGroupFromPort(
        system: *mut FMOD_SYSTEM,
        channelgroup: *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetReverbProperties(
        system: *mut FMOD_SYSTEM,
        instance: ::std::os::raw::c_int,
        prop: *const FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetReverbProperties(
        system: *mut FMOD_SYSTEM,
        instance: ::std::os::raw::c_int,
        prop: *mut FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_LockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_UnlockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetRecordNumDrivers(
        system: *mut FMOD_SYSTEM,
        numdrivers: *mut ::std::os::raw::c_int,
        numconnected: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetRecordDriverInfo(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut ::std::os::raw::c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut ::std::os::raw::c_int,
        state: *mut FMOD_DRIVER_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetRecordPosition(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
        position: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_RecordStart(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
        sound: *mut FMOD_SOUND,
        loop_: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_RecordStop(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_IsRecording(
        system: *mut FMOD_SYSTEM,
        id: ::std::os::raw::c_int,
        recording: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_CreateGeometry(
        system: *mut FMOD_SYSTEM,
        maxpolygons: ::std::os::raw::c_int,
        maxvertices: ::std::os::raw::c_int,
        geometry: *mut *mut FMOD_GEOMETRY,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetGeometrySettings(
        system: *mut FMOD_SYSTEM,
        maxworldsize: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetGeometrySettings(
        system: *mut FMOD_SYSTEM,
        maxworldsize: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_LoadGeometry(
        system: *mut FMOD_SYSTEM,
        data: *const ::std::os::raw::c_void,
        datasize: ::std::os::raw::c_int,
        geometry: *mut *mut FMOD_GEOMETRY,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetGeometryOcclusion(
        system: *mut FMOD_SYSTEM,
        listener: *const FMOD_VECTOR,
        source: *const FMOD_VECTOR,
        direct: *mut f32,
        reverb: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetNetworkProxy(
        system: *mut FMOD_SYSTEM,
        proxy: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNetworkProxy(
        system: *mut FMOD_SYSTEM,
        proxy: *mut ::std::os::raw::c_char,
        proxylen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetNetworkTimeout(
        system: *mut FMOD_SYSTEM,
        timeout: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetNetworkTimeout(
        system: *mut FMOD_SYSTEM,
        timeout: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_SetUserData(
        system: *mut FMOD_SYSTEM,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_System_GetUserData(
        system: *mut FMOD_SYSTEM,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Release(sound: *mut FMOD_SOUND) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSystemObject(
        sound: *mut FMOD_SOUND,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Lock(
        sound: *mut FMOD_SOUND,
        offset: ::std::os::raw::c_uint,
        length: ::std::os::raw::c_uint,
        ptr1: *mut *mut ::std::os::raw::c_void,
        ptr2: *mut *mut ::std::os::raw::c_void,
        len1: *mut ::std::os::raw::c_uint,
        len2: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Unlock(
        sound: *mut FMOD_SOUND,
        ptr1: *mut ::std::os::raw::c_void,
        ptr2: *mut ::std::os::raw::c_void,
        len1: ::std::os::raw::c_uint,
        len2: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetDefaults(
        sound: *mut FMOD_SOUND,
        frequency: f32,
        priority: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetDefaults(
        sound: *mut FMOD_SOUND,
        frequency: *mut f32,
        priority: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Set3DMinMaxDistance(
        sound: *mut FMOD_SOUND,
        min: f32,
        max: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Get3DMinMaxDistance(
        sound: *mut FMOD_SOUND,
        min: *mut f32,
        max: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Set3DConeSettings(
        sound: *mut FMOD_SOUND,
        insideconeangle: f32,
        outsideconeangle: f32,
        outsidevolume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Get3DConeSettings(
        sound: *mut FMOD_SOUND,
        insideconeangle: *mut f32,
        outsideconeangle: *mut f32,
        outsidevolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Set3DCustomRolloff(
        sound: *mut FMOD_SOUND,
        points: *mut FMOD_VECTOR,
        numpoints: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_Get3DCustomRolloff(
        sound: *mut FMOD_SOUND,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSubSound(
        sound: *mut FMOD_SOUND,
        index: ::std::os::raw::c_int,
        subsound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSubSoundParent(
        sound: *mut FMOD_SOUND,
        parentsound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetName(
        sound: *mut FMOD_SOUND,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetLength(
        sound: *mut FMOD_SOUND,
        length: *mut ::std::os::raw::c_uint,
        lengthtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetFormat(
        sound: *mut FMOD_SOUND,
        type_: *mut FMOD_SOUND_TYPE,
        format: *mut FMOD_SOUND_FORMAT,
        channels: *mut ::std::os::raw::c_int,
        bits: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetNumSubSounds(
        sound: *mut FMOD_SOUND,
        numsubsounds: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetNumTags(
        sound: *mut FMOD_SOUND,
        numtags: *mut ::std::os::raw::c_int,
        numtagsupdated: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetTag(
        sound: *mut FMOD_SOUND,
        name: *const ::std::os::raw::c_char,
        index: ::std::os::raw::c_int,
        tag: *mut FMOD_TAG,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetOpenState(
        sound: *mut FMOD_SOUND,
        openstate: *mut FMOD_OPENSTATE,
        percentbuffered: *mut ::std::os::raw::c_uint,
        starving: *mut FMOD_BOOL,
        diskbusy: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_ReadData(
        sound: *mut FMOD_SOUND,
        buffer: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_uint,
        read: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SeekData(sound: *mut FMOD_SOUND, pcm: ::std::os::raw::c_uint) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetSoundGroup(
        sound: *mut FMOD_SOUND,
        soundgroup: *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSoundGroup(
        sound: *mut FMOD_SOUND,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetNumSyncPoints(
        sound: *mut FMOD_SOUND,
        numsyncpoints: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSyncPoint(
        sound: *mut FMOD_SOUND,
        index: ::std::os::raw::c_int,
        point: *mut *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetSyncPointInfo(
        sound: *mut FMOD_SOUND,
        point: *mut FMOD_SYNCPOINT,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
        offset: *mut ::std::os::raw::c_uint,
        offsettype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_AddSyncPoint(
        sound: *mut FMOD_SOUND,
        offset: ::std::os::raw::c_uint,
        offsettype: FMOD_TIMEUNIT,
        name: *const ::std::os::raw::c_char,
        point: *mut *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_DeleteSyncPoint(
        sound: *mut FMOD_SOUND,
        point: *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetMode(sound: *mut FMOD_SOUND, mode: FMOD_MODE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetMode(sound: *mut FMOD_SOUND, mode: *mut FMOD_MODE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetLoopCount(
        sound: *mut FMOD_SOUND,
        loopcount: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetLoopCount(
        sound: *mut FMOD_SOUND,
        loopcount: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetLoopPoints(
        sound: *mut FMOD_SOUND,
        loopstart: ::std::os::raw::c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: ::std::os::raw::c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetLoopPoints(
        sound: *mut FMOD_SOUND,
        loopstart: *mut ::std::os::raw::c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: *mut ::std::os::raw::c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetMusicNumChannels(
        sound: *mut FMOD_SOUND,
        numchannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetMusicChannelVolume(
        sound: *mut FMOD_SOUND,
        channel: ::std::os::raw::c_int,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetMusicChannelVolume(
        sound: *mut FMOD_SOUND,
        channel: ::std::os::raw::c_int,
        volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetMusicSpeed(sound: *mut FMOD_SOUND, speed: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetMusicSpeed(sound: *mut FMOD_SOUND, speed: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_SetUserData(
        sound: *mut FMOD_SOUND,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Sound_GetUserData(
        sound: *mut FMOD_SOUND,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetSystemObject(
        channel: *mut FMOD_CHANNEL,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Stop(channel: *mut FMOD_CHANNEL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetPaused(channel: *mut FMOD_CHANNEL, paused: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetPaused(
        channel: *mut FMOD_CHANNEL,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetVolume(channel: *mut FMOD_CHANNEL, volume: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetVolume(channel: *mut FMOD_CHANNEL, volume: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetVolumeRamp(channel: *mut FMOD_CHANNEL, ramp: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetVolumeRamp(
        channel: *mut FMOD_CHANNEL,
        ramp: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetAudibility(
        channel: *mut FMOD_CHANNEL,
        audibility: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetPitch(channel: *mut FMOD_CHANNEL, pitch: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetPitch(channel: *mut FMOD_CHANNEL, pitch: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetMute(channel: *mut FMOD_CHANNEL, mute: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetMute(channel: *mut FMOD_CHANNEL, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetReverbProperties(
        channel: *mut FMOD_CHANNEL,
        instance: ::std::os::raw::c_int,
        wet: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetReverbProperties(
        channel: *mut FMOD_CHANNEL,
        instance: ::std::os::raw::c_int,
        wet: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetLowPassGain(channel: *mut FMOD_CHANNEL, gain: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetLowPassGain(channel: *mut FMOD_CHANNEL, gain: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetMode(channel: *mut FMOD_CHANNEL, mode: FMOD_MODE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetMode(channel: *mut FMOD_CHANNEL, mode: *mut FMOD_MODE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetCallback(
        channel: *mut FMOD_CHANNEL,
        callback: FMOD_CHANNELCONTROL_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_IsPlaying(
        channel: *mut FMOD_CHANNEL,
        isplaying: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetPan(channel: *mut FMOD_CHANNEL, pan: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetMixLevelsOutput(
        channel: *mut FMOD_CHANNEL,
        frontleft: f32,
        frontright: f32,
        center: f32,
        lfe: f32,
        surroundleft: f32,
        surroundright: f32,
        backleft: f32,
        backright: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetMixLevelsInput(
        channel: *mut FMOD_CHANNEL,
        levels: *mut f32,
        numlevels: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetMixMatrix(
        channel: *mut FMOD_CHANNEL,
        matrix: *mut f32,
        outchannels: ::std::os::raw::c_int,
        inchannels: ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetMixMatrix(
        channel: *mut FMOD_CHANNEL,
        matrix: *mut f32,
        outchannels: *mut ::std::os::raw::c_int,
        inchannels: *mut ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetDSPClock(
        channel: *mut FMOD_CHANNEL,
        dspclock: *mut ::std::os::raw::c_ulonglong,
        parentclock: *mut ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetDelay(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
        stopchannels: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetDelay(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: *mut ::std::os::raw::c_ulonglong,
        dspclock_end: *mut ::std::os::raw::c_ulonglong,
        stopchannels: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_AddFadePoint(
        channel: *mut FMOD_CHANNEL,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetFadePointRamp(
        channel: *mut FMOD_CHANNEL,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_RemoveFadePoints(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetFadePoints(
        channel: *mut FMOD_CHANNEL,
        numpoints: *mut ::std::os::raw::c_uint,
        point_dspclock: *mut ::std::os::raw::c_ulonglong,
        point_volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetDSP(
        channel: *mut FMOD_CHANNEL,
        index: ::std::os::raw::c_int,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_AddDSP(
        channel: *mut FMOD_CHANNEL,
        index: ::std::os::raw::c_int,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_RemoveDSP(channel: *mut FMOD_CHANNEL, dsp: *mut FMOD_DSP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetNumDSPs(
        channel: *mut FMOD_CHANNEL,
        numdsps: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetDSPIndex(
        channel: *mut FMOD_CHANNEL,
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetDSPIndex(
        channel: *mut FMOD_CHANNEL,
        dsp: *mut FMOD_DSP,
        index: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DAttributes(
        channel: *mut FMOD_CHANNEL,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DAttributes(
        channel: *mut FMOD_CHANNEL,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DMinMaxDistance(
        channel: *mut FMOD_CHANNEL,
        mindistance: f32,
        maxdistance: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DMinMaxDistance(
        channel: *mut FMOD_CHANNEL,
        mindistance: *mut f32,
        maxdistance: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DConeSettings(
        channel: *mut FMOD_CHANNEL,
        insideconeangle: f32,
        outsideconeangle: f32,
        outsidevolume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DConeSettings(
        channel: *mut FMOD_CHANNEL,
        insideconeangle: *mut f32,
        outsideconeangle: *mut f32,
        outsidevolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DConeOrientation(
        channel: *mut FMOD_CHANNEL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DConeOrientation(
        channel: *mut FMOD_CHANNEL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DCustomRolloff(
        channel: *mut FMOD_CHANNEL,
        points: *mut FMOD_VECTOR,
        numpoints: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DCustomRolloff(
        channel: *mut FMOD_CHANNEL,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DOcclusion(
        channel: *mut FMOD_CHANNEL,
        directocclusion: f32,
        reverbocclusion: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DOcclusion(
        channel: *mut FMOD_CHANNEL,
        directocclusion: *mut f32,
        reverbocclusion: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DSpread(channel: *mut FMOD_CHANNEL, angle: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DSpread(channel: *mut FMOD_CHANNEL, angle: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DLevel(channel: *mut FMOD_CHANNEL, level: *mut f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DDopplerLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DDopplerLevel(
        channel: *mut FMOD_CHANNEL,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Set3DDistanceFilter(
        channel: *mut FMOD_CHANNEL,
        custom: FMOD_BOOL,
        customLevel: f32,
        centerFreq: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_Get3DDistanceFilter(
        channel: *mut FMOD_CHANNEL,
        custom: *mut FMOD_BOOL,
        customLevel: *mut f32,
        centerFreq: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetUserData(
        channel: *mut FMOD_CHANNEL,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetUserData(
        channel: *mut FMOD_CHANNEL,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetFrequency(channel: *mut FMOD_CHANNEL, frequency: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetFrequency(
        channel: *mut FMOD_CHANNEL,
        frequency: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetPriority(
        channel: *mut FMOD_CHANNEL,
        priority: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetPriority(
        channel: *mut FMOD_CHANNEL,
        priority: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetPosition(
        channel: *mut FMOD_CHANNEL,
        position: ::std::os::raw::c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetPosition(
        channel: *mut FMOD_CHANNEL,
        position: *mut ::std::os::raw::c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetChannelGroup(
        channel: *mut FMOD_CHANNEL,
        channelgroup: *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetChannelGroup(
        channel: *mut FMOD_CHANNEL,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetLoopCount(
        channel: *mut FMOD_CHANNEL,
        loopcount: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetLoopCount(
        channel: *mut FMOD_CHANNEL,
        loopcount: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_SetLoopPoints(
        channel: *mut FMOD_CHANNEL,
        loopstart: ::std::os::raw::c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: ::std::os::raw::c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetLoopPoints(
        channel: *mut FMOD_CHANNEL,
        loopstart: *mut ::std::os::raw::c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: *mut ::std::os::raw::c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_IsVirtual(
        channel: *mut FMOD_CHANNEL,
        isvirtual: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetCurrentSound(
        channel: *mut FMOD_CHANNEL,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Channel_GetIndex(
        channel: *mut FMOD_CHANNEL,
        index: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetSystemObject(
        channelgroup: *mut FMOD_CHANNELGROUP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Stop(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetPaused(
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetPaused(
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetVolume(
        channelgroup: *mut FMOD_CHANNELGROUP,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetVolume(
        channelgroup: *mut FMOD_CHANNELGROUP,
        volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetVolumeRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        ramp: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetVolumeRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        ramp: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetAudibility(
        channelgroup: *mut FMOD_CHANNELGROUP,
        audibility: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetPitch(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pitch: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetPitch(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pitch: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetMute(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mute: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetMute(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mute: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetReverbProperties(
        channelgroup: *mut FMOD_CHANNELGROUP,
        instance: ::std::os::raw::c_int,
        wet: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetReverbProperties(
        channelgroup: *mut FMOD_CHANNELGROUP,
        instance: ::std::os::raw::c_int,
        wet: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetLowPassGain(
        channelgroup: *mut FMOD_CHANNELGROUP,
        gain: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetLowPassGain(
        channelgroup: *mut FMOD_CHANNELGROUP,
        gain: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetMode(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mode: FMOD_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetMode(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mode: *mut FMOD_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetCallback(
        channelgroup: *mut FMOD_CHANNELGROUP,
        callback: FMOD_CHANNELCONTROL_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_IsPlaying(
        channelgroup: *mut FMOD_CHANNELGROUP,
        isplaying: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetPan(channelgroup: *mut FMOD_CHANNELGROUP, pan: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetMixLevelsOutput(
        channelgroup: *mut FMOD_CHANNELGROUP,
        frontleft: f32,
        frontright: f32,
        center: f32,
        lfe: f32,
        surroundleft: f32,
        surroundright: f32,
        backleft: f32,
        backright: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetMixLevelsInput(
        channelgroup: *mut FMOD_CHANNELGROUP,
        levels: *mut f32,
        numlevels: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetMixMatrix(
        channelgroup: *mut FMOD_CHANNELGROUP,
        matrix: *mut f32,
        outchannels: ::std::os::raw::c_int,
        inchannels: ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetMixMatrix(
        channelgroup: *mut FMOD_CHANNELGROUP,
        matrix: *mut f32,
        outchannels: *mut ::std::os::raw::c_int,
        inchannels: *mut ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetDSPClock(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: *mut ::std::os::raw::c_ulonglong,
        parentclock: *mut ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetDelay(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
        stopchannels: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetDelay(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: *mut ::std::os::raw::c_ulonglong,
        dspclock_end: *mut ::std::os::raw::c_ulonglong,
        stopchannels: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_AddFadePoint(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetFadePointRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_RemoveFadePoints(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetFadePoints(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numpoints: *mut ::std::os::raw::c_uint,
        point_dspclock: *mut ::std::os::raw::c_ulonglong,
        point_volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: ::std::os::raw::c_int,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_AddDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: ::std::os::raw::c_int,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_RemoveDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetNumDSPs(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numdsps: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetDSPIndex(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetDSPIndex(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
        index: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DAttributes(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DAttributes(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DMinMaxDistance(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mindistance: f32,
        maxdistance: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DMinMaxDistance(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mindistance: *mut f32,
        maxdistance: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DConeSettings(
        channelgroup: *mut FMOD_CHANNELGROUP,
        insideconeangle: f32,
        outsideconeangle: f32,
        outsidevolume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DConeSettings(
        channelgroup: *mut FMOD_CHANNELGROUP,
        insideconeangle: *mut f32,
        outsideconeangle: *mut f32,
        outsidevolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DConeOrientation(
        channelgroup: *mut FMOD_CHANNELGROUP,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DConeOrientation(
        channelgroup: *mut FMOD_CHANNELGROUP,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DCustomRolloff(
        channelgroup: *mut FMOD_CHANNELGROUP,
        points: *mut FMOD_VECTOR,
        numpoints: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DCustomRolloff(
        channelgroup: *mut FMOD_CHANNELGROUP,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DOcclusion(
        channelgroup: *mut FMOD_CHANNELGROUP,
        directocclusion: f32,
        reverbocclusion: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DOcclusion(
        channelgroup: *mut FMOD_CHANNELGROUP,
        directocclusion: *mut f32,
        reverbocclusion: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DSpread(
        channelgroup: *mut FMOD_CHANNELGROUP,
        angle: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DSpread(
        channelgroup: *mut FMOD_CHANNELGROUP,
        angle: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DDopplerLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DDopplerLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Set3DDistanceFilter(
        channelgroup: *mut FMOD_CHANNELGROUP,
        custom: FMOD_BOOL,
        customLevel: f32,
        centerFreq: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Get3DDistanceFilter(
        channelgroup: *mut FMOD_CHANNELGROUP,
        custom: *mut FMOD_BOOL,
        customLevel: *mut f32,
        centerFreq: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_SetUserData(
        channelgroup: *mut FMOD_CHANNELGROUP,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetUserData(
        channelgroup: *mut FMOD_CHANNELGROUP,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_Release(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_AddGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        group: *mut FMOD_CHANNELGROUP,
        propagatedspclock: FMOD_BOOL,
        connection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetNumGroups(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numgroups: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: ::std::os::raw::c_int,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetParentGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetName(
        channelgroup: *mut FMOD_CHANNELGROUP,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetNumChannels(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numchannels: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelGroup_GetChannel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: ::std::os::raw::c_int,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_Release(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetSystemObject(
        soundgroup: *mut FMOD_SOUNDGROUP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_SetMaxAudible(
        soundgroup: *mut FMOD_SOUNDGROUP,
        maxaudible: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetMaxAudible(
        soundgroup: *mut FMOD_SOUNDGROUP,
        maxaudible: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_SetMaxAudibleBehavior(
        soundgroup: *mut FMOD_SOUNDGROUP,
        behavior: FMOD_SOUNDGROUP_BEHAVIOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetMaxAudibleBehavior(
        soundgroup: *mut FMOD_SOUNDGROUP,
        behavior: *mut FMOD_SOUNDGROUP_BEHAVIOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_SetMuteFadeSpeed(
        soundgroup: *mut FMOD_SOUNDGROUP,
        speed: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetMuteFadeSpeed(
        soundgroup: *mut FMOD_SOUNDGROUP,
        speed: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_SetVolume(soundgroup: *mut FMOD_SOUNDGROUP, volume: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetVolume(
        soundgroup: *mut FMOD_SOUNDGROUP,
        volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_Stop(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetName(
        soundgroup: *mut FMOD_SOUNDGROUP,
        name: *mut ::std::os::raw::c_char,
        namelen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetNumSounds(
        soundgroup: *mut FMOD_SOUNDGROUP,
        numsounds: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetSound(
        soundgroup: *mut FMOD_SOUNDGROUP,
        index: ::std::os::raw::c_int,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetNumPlaying(
        soundgroup: *mut FMOD_SOUNDGROUP,
        numplaying: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_SetUserData(
        soundgroup: *mut FMOD_SOUNDGROUP,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_SoundGroup_GetUserData(
        soundgroup: *mut FMOD_SOUNDGROUP,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_Release(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetSystemObject(
        dsp: *mut FMOD_DSP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_AddInput(
        dsp: *mut FMOD_DSP,
        input: *mut FMOD_DSP,
        connection: *mut *mut FMOD_DSPCONNECTION,
        type_: FMOD_DSPCONNECTION_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_DisconnectFrom(
        dsp: *mut FMOD_DSP,
        target: *mut FMOD_DSP,
        connection: *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_DisconnectAll(
        dsp: *mut FMOD_DSP,
        inputs: FMOD_BOOL,
        outputs: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetNumInputs(
        dsp: *mut FMOD_DSP,
        numinputs: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetNumOutputs(
        dsp: *mut FMOD_DSP,
        numoutputs: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetInput(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        input: *mut *mut FMOD_DSP,
        inputconnection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetOutput(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        output: *mut *mut FMOD_DSP,
        outputconnection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetActive(dsp: *mut FMOD_DSP, active: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetActive(dsp: *mut FMOD_DSP, active: *mut FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetBypass(dsp: *mut FMOD_DSP, bypass: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetBypass(dsp: *mut FMOD_DSP, bypass: *mut FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetWetDryMix(
        dsp: *mut FMOD_DSP,
        prewet: f32,
        postwet: f32,
        dry: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetWetDryMix(
        dsp: *mut FMOD_DSP,
        prewet: *mut f32,
        postwet: *mut f32,
        dry: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetChannelFormat(
        dsp: *mut FMOD_DSP,
        channelmask: FMOD_CHANNELMASK,
        numchannels: ::std::os::raw::c_int,
        source_speakermode: FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetChannelFormat(
        dsp: *mut FMOD_DSP,
        channelmask: *mut FMOD_CHANNELMASK,
        numchannels: *mut ::std::os::raw::c_int,
        source_speakermode: *mut FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetOutputChannelFormat(
        dsp: *mut FMOD_DSP,
        inmask: FMOD_CHANNELMASK,
        inchannels: ::std::os::raw::c_int,
        inspeakermode: FMOD_SPEAKERMODE,
        outmask: *mut FMOD_CHANNELMASK,
        outchannels: *mut ::std::os::raw::c_int,
        outspeakermode: *mut FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_Reset(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetCallback(dsp: *mut FMOD_DSP, callback: FMOD_DSP_CALLBACK) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetParameterFloat(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetParameterInt(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetParameterBool(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetParameterData(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        data: *mut ::std::os::raw::c_void,
        length: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetParameterFloat(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: *mut f32,
        valuestr: *mut ::std::os::raw::c_char,
        valuestrlen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetParameterInt(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: *mut ::std::os::raw::c_int,
        valuestr: *mut ::std::os::raw::c_char,
        valuestrlen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetParameterBool(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        value: *mut FMOD_BOOL,
        valuestr: *mut ::std::os::raw::c_char,
        valuestrlen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetParameterData(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        data: *mut *mut ::std::os::raw::c_void,
        length: *mut ::std::os::raw::c_uint,
        valuestr: *mut ::std::os::raw::c_char,
        valuestrlen: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetNumParameters(
        dsp: *mut FMOD_DSP,
        numparams: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetParameterInfo(
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
        desc: *mut *mut FMOD_DSP_PARAMETER_DESC,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetDataParameterIndex(
        dsp: *mut FMOD_DSP,
        datatype: ::std::os::raw::c_int,
        index: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_ShowConfigDialog(
        dsp: *mut FMOD_DSP,
        hwnd: *mut ::std::os::raw::c_void,
        show: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetInfo(
        dsp: *mut FMOD_DSP,
        name: *mut ::std::os::raw::c_char,
        version: *mut ::std::os::raw::c_uint,
        channels: *mut ::std::os::raw::c_int,
        configwidth: *mut ::std::os::raw::c_int,
        configheight: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetType(dsp: *mut FMOD_DSP, type_: *mut FMOD_DSP_TYPE) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetIdle(dsp: *mut FMOD_DSP, idle: *mut FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetUserData(
        dsp: *mut FMOD_DSP,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetUserData(
        dsp: *mut FMOD_DSP,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_SetMeteringEnabled(
        dsp: *mut FMOD_DSP,
        inputEnabled: FMOD_BOOL,
        outputEnabled: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetMeteringEnabled(
        dsp: *mut FMOD_DSP,
        inputEnabled: *mut FMOD_BOOL,
        outputEnabled: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetMeteringInfo(
        dsp: *mut FMOD_DSP,
        inputInfo: *mut FMOD_DSP_METERING_INFO,
        outputInfo: *mut FMOD_DSP_METERING_INFO,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSP_GetCPUUsage(
        dsp: *mut FMOD_DSP,
        exclusive: *mut ::std::os::raw::c_uint,
        inclusive: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetInput(
        dspconnection: *mut FMOD_DSPCONNECTION,
        input: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetOutput(
        dspconnection: *mut FMOD_DSPCONNECTION,
        output: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_SetMix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetMix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_SetMixMatrix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        matrix: *mut f32,
        outchannels: ::std::os::raw::c_int,
        inchannels: ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetMixMatrix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        matrix: *mut f32,
        outchannels: *mut ::std::os::raw::c_int,
        inchannels: *mut ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetType(
        dspconnection: *mut FMOD_DSPCONNECTION,
        type_: *mut FMOD_DSPCONNECTION_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_SetUserData(
        dspconnection: *mut FMOD_DSPCONNECTION,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_DSPConnection_GetUserData(
        dspconnection: *mut FMOD_DSPCONNECTION,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_Release(geometry: *mut FMOD_GEOMETRY) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_AddPolygon(
        geometry: *mut FMOD_GEOMETRY,
        directocclusion: f32,
        reverbocclusion: f32,
        doublesided: FMOD_BOOL,
        numvertices: ::std::os::raw::c_int,
        vertices: *const FMOD_VECTOR,
        polygonindex: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetNumPolygons(
        geometry: *mut FMOD_GEOMETRY,
        numpolygons: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetMaxPolygons(
        geometry: *mut FMOD_GEOMETRY,
        maxpolygons: *mut ::std::os::raw::c_int,
        maxvertices: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetPolygonNumVertices(
        geometry: *mut FMOD_GEOMETRY,
        index: ::std::os::raw::c_int,
        numvertices: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetPolygonVertex(
        geometry: *mut FMOD_GEOMETRY,
        index: ::std::os::raw::c_int,
        vertexindex: ::std::os::raw::c_int,
        vertex: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetPolygonVertex(
        geometry: *mut FMOD_GEOMETRY,
        index: ::std::os::raw::c_int,
        vertexindex: ::std::os::raw::c_int,
        vertex: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetPolygonAttributes(
        geometry: *mut FMOD_GEOMETRY,
        index: ::std::os::raw::c_int,
        directocclusion: f32,
        reverbocclusion: f32,
        doublesided: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetPolygonAttributes(
        geometry: *mut FMOD_GEOMETRY,
        index: ::std::os::raw::c_int,
        directocclusion: *mut f32,
        reverbocclusion: *mut f32,
        doublesided: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetActive(geometry: *mut FMOD_GEOMETRY, active: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetActive(
        geometry: *mut FMOD_GEOMETRY,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetRotation(
        geometry: *mut FMOD_GEOMETRY,
        forward: *const FMOD_VECTOR,
        up: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetRotation(
        geometry: *mut FMOD_GEOMETRY,
        forward: *mut FMOD_VECTOR,
        up: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetPosition(
        geometry: *mut FMOD_GEOMETRY,
        position: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetPosition(
        geometry: *mut FMOD_GEOMETRY,
        position: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetScale(
        geometry: *mut FMOD_GEOMETRY,
        scale: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetScale(
        geometry: *mut FMOD_GEOMETRY,
        scale: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_Save(
        geometry: *mut FMOD_GEOMETRY,
        data: *mut ::std::os::raw::c_void,
        datasize: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_SetUserData(
        geometry: *mut FMOD_GEOMETRY,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Geometry_GetUserData(
        geometry: *mut FMOD_GEOMETRY,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_Release(reverb3d: *mut FMOD_REVERB3D) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_Set3DAttributes(
        reverb3d: *mut FMOD_REVERB3D,
        position: *const FMOD_VECTOR,
        mindistance: f32,
        maxdistance: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_Get3DAttributes(
        reverb3d: *mut FMOD_REVERB3D,
        position: *mut FMOD_VECTOR,
        mindistance: *mut f32,
        maxdistance: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_SetProperties(
        reverb3d: *mut FMOD_REVERB3D,
        properties: *const FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_GetProperties(
        reverb3d: *mut FMOD_REVERB3D,
        properties: *mut FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_SetActive(reverb3d: *mut FMOD_REVERB3D, active: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_GetActive(
        reverb3d: *mut FMOD_REVERB3D,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_SetUserData(
        reverb3d: *mut FMOD_REVERB3D,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Reverb3D_GetUserData(
        reverb3d: *mut FMOD_REVERB3D,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Channel_CastToControl(channel: *mut FMOD_CHANNEL) -> *mut FMOD_CHANNELCONTROL;
}
unsafe extern "C" {
    pub fn FMOD_ChannelGroup_CastToControl(
        group: *mut FMOD_CHANNELGROUP,
    ) -> *mut FMOD_CHANNELCONTROL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetSystemObject(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Stop(channelcontrol: *mut FMOD_CHANNELCONTROL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetPaused(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        paused: bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetPaused(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        paused: *mut bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetVolume(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetVolume(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetVolumeRamp(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        ramp: bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetVolumeRamp(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        ramp: *mut bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetAudibility(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        audibility: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetPitch(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        pitch: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetPitch(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        pitch: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetMute(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mute: bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetMute(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mute: *mut bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetReverbProperties(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        instance: ::std::os::raw::c_int,
        wet: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetReverbProperties(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        instance: ::std::os::raw::c_int,
        wet: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetLowPassGain(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        gain: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetLowPassGain(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        gain: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetMode(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mode: FMOD_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetMode(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mode: *mut FMOD_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetCallback(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        callback: FMOD_CHANNELCONTROL_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_IsPlaying(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        isplaying: *mut bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetPan(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        pan: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetMixLevelsOutput(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        frontleft: f32,
        frontright: f32,
        center: f32,
        lfe: f32,
        surroundleft: f32,
        surroundright: f32,
        backleft: f32,
        backright: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetMixLevelsInput(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        levels: *mut f32,
        numlevels: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetMixMatrix(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        matrix: *mut f32,
        outchannels: ::std::os::raw::c_int,
        inchannels: ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetMixMatrix(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        matrix: *mut f32,
        outchannels: *mut ::std::os::raw::c_int,
        inchannels: *mut ::std::os::raw::c_int,
        inchannel_hop: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetDSPClock(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock: *mut ::std::os::raw::c_ulonglong,
        parentclock: *mut ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetDelay(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
        stopchannels: bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetDelay(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock_start: *mut ::std::os::raw::c_ulonglong,
        dspclock_end: *mut ::std::os::raw::c_ulonglong,
        stopchannels: *mut bool,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_AddFadePoint(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetFadePointRamp(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock: ::std::os::raw::c_ulonglong,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_RemoveFadePoints(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dspclock_start: ::std::os::raw::c_ulonglong,
        dspclock_end: ::std::os::raw::c_ulonglong,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetFadePoints(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        numpoints: *mut ::std::os::raw::c_uint,
        point_dspclock: *mut ::std::os::raw::c_ulonglong,
        point_volume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetDSP(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        index: ::std::os::raw::c_int,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_AddDSP(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        index: ::std::os::raw::c_int,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_RemoveDSP(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetNumDSPs(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        numdsps: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetDSPIndex(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dsp: *mut FMOD_DSP,
        index: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetDSPIndex(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        dsp: *mut FMOD_DSP,
        index: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DAttributes(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DAttributes(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DMinMaxDistance(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mindistance: f32,
        maxdistance: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DMinMaxDistance(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        mindistance: *mut f32,
        maxdistance: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DConeSettings(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        insideconeangle: f32,
        outsideconeangle: f32,
        outsidevolume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DConeSettings(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        insideconeangle: *mut f32,
        outsideconeangle: *mut f32,
        outsidevolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DConeOrientation(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DConeOrientation(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DCustomRolloff(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        points: *mut FMOD_VECTOR,
        numpoints: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DCustomRolloff(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DOcclusion(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        directocclusion: f32,
        reverbocclusion: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DOcclusion(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        directocclusion: *mut f32,
        reverbocclusion: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DSpread(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        angle: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DSpread(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        angle: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DLevel(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        level: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DLevel(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DDopplerLevel(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        level: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DDopplerLevel(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Set3DDistanceFilter(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        custom: bool,
        customLevel: f32,
        centerFreq: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_Get3DDistanceFilter(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        custom: *mut bool,
        customLevel: *mut f32,
        centerFreq: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_SetUserData(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_ChannelControl_GetUserData(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_SYSTEM {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_EVENTDESCRIPTION {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_EVENTINSTANCE {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_BUS {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_VCA {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_BANK {
    _unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_COMMANDREPLAY {
    _unused: [u8; 0],
}
pub type FMOD_STUDIO_INITFLAGS = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_PARAMETER_FLAGS = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_EVENT_CALLBACK_TYPE = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_LOAD_BANK_FLAGS = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_COMMANDCAPTURE_FLAGS = ::std::os::raw::c_uint;
pub type FMOD_STUDIO_COMMANDREPLAY_FLAGS = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_LOADING_STATE_UNLOADING: FMOD_STUDIO_LOADING_STATE = 0;
pub const FMOD_STUDIO_LOADING_STATE_UNLOADED: FMOD_STUDIO_LOADING_STATE = 1;
pub const FMOD_STUDIO_LOADING_STATE_LOADING: FMOD_STUDIO_LOADING_STATE = 2;
pub const FMOD_STUDIO_LOADING_STATE_LOADED: FMOD_STUDIO_LOADING_STATE = 3;
pub const FMOD_STUDIO_LOADING_STATE_ERROR: FMOD_STUDIO_LOADING_STATE = 4;
pub const FMOD_STUDIO_LOADING_STATE_FORCEINT: FMOD_STUDIO_LOADING_STATE = 65536;
pub type FMOD_STUDIO_LOADING_STATE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_LOAD_MEMORY: FMOD_STUDIO_LOAD_MEMORY_MODE = 0;
pub const FMOD_STUDIO_LOAD_MEMORY_POINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 1;
pub const FMOD_STUDIO_LOAD_MEMORY_FORCEINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 65536;
pub type FMOD_STUDIO_LOAD_MEMORY_MODE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_PARAMETER_GAME_CONTROLLED: FMOD_STUDIO_PARAMETER_TYPE = 0;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE: FMOD_STUDIO_PARAMETER_TYPE = 1;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_CONE_ANGLE: FMOD_STUDIO_PARAMETER_TYPE = 2;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 3;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DIRECTION: FMOD_STUDIO_PARAMETER_TYPE = 4;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_ELEVATION: FMOD_STUDIO_PARAMETER_TYPE = 5;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_LISTENER_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 6;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED: FMOD_STUDIO_PARAMETER_TYPE = 7;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED_ABSOLUTE: FMOD_STUDIO_PARAMETER_TYPE = 8;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE_NORMALIZED: FMOD_STUDIO_PARAMETER_TYPE = 9;
pub const FMOD_STUDIO_PARAMETER_MAX: FMOD_STUDIO_PARAMETER_TYPE = 10;
pub const FMOD_STUDIO_PARAMETER_FORCEINT: FMOD_STUDIO_PARAMETER_TYPE = 65536;
pub type FMOD_STUDIO_PARAMETER_TYPE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_USER_PROPERTY_TYPE_INTEGER: FMOD_STUDIO_USER_PROPERTY_TYPE = 0;
pub const FMOD_STUDIO_USER_PROPERTY_TYPE_BOOLEAN: FMOD_STUDIO_USER_PROPERTY_TYPE = 1;
pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FLOAT: FMOD_STUDIO_USER_PROPERTY_TYPE = 2;
pub const FMOD_STUDIO_USER_PROPERTY_TYPE_STRING: FMOD_STUDIO_USER_PROPERTY_TYPE = 3;
pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FORCEINT: FMOD_STUDIO_USER_PROPERTY_TYPE = 65536;
pub type FMOD_STUDIO_USER_PROPERTY_TYPE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_EVENT_PROPERTY_CHANNELPRIORITY: FMOD_STUDIO_EVENT_PROPERTY = 0;
pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_DELAY: FMOD_STUDIO_EVENT_PROPERTY = 1;
pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_LOOKAHEAD: FMOD_STUDIO_EVENT_PROPERTY = 2;
pub const FMOD_STUDIO_EVENT_PROPERTY_MINIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 3;
pub const FMOD_STUDIO_EVENT_PROPERTY_MAXIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 4;
pub const FMOD_STUDIO_EVENT_PROPERTY_COOLDOWN: FMOD_STUDIO_EVENT_PROPERTY = 5;
pub const FMOD_STUDIO_EVENT_PROPERTY_MAX: FMOD_STUDIO_EVENT_PROPERTY = 6;
pub const FMOD_STUDIO_EVENT_PROPERTY_FORCEINT: FMOD_STUDIO_EVENT_PROPERTY = 65536;
pub type FMOD_STUDIO_EVENT_PROPERTY = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_PLAYBACK_PLAYING: FMOD_STUDIO_PLAYBACK_STATE = 0;
pub const FMOD_STUDIO_PLAYBACK_SUSTAINING: FMOD_STUDIO_PLAYBACK_STATE = 1;
pub const FMOD_STUDIO_PLAYBACK_STOPPED: FMOD_STUDIO_PLAYBACK_STATE = 2;
pub const FMOD_STUDIO_PLAYBACK_STARTING: FMOD_STUDIO_PLAYBACK_STATE = 3;
pub const FMOD_STUDIO_PLAYBACK_STOPPING: FMOD_STUDIO_PLAYBACK_STATE = 4;
pub const FMOD_STUDIO_PLAYBACK_FORCEINT: FMOD_STUDIO_PLAYBACK_STATE = 65536;
pub type FMOD_STUDIO_PLAYBACK_STATE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_STOP_ALLOWFADEOUT: FMOD_STUDIO_STOP_MODE = 0;
pub const FMOD_STUDIO_STOP_IMMEDIATE: FMOD_STUDIO_STOP_MODE = 1;
pub const FMOD_STUDIO_STOP_FORCEINT: FMOD_STUDIO_STOP_MODE = 65536;
pub type FMOD_STUDIO_STOP_MODE = ::std::os::raw::c_uint;
pub const FMOD_STUDIO_INSTANCETYPE_NONE: FMOD_STUDIO_INSTANCETYPE = 0;
pub const FMOD_STUDIO_INSTANCETYPE_SYSTEM: FMOD_STUDIO_INSTANCETYPE = 1;
pub const FMOD_STUDIO_INSTANCETYPE_EVENTDESCRIPTION: FMOD_STUDIO_INSTANCETYPE = 2;
pub const FMOD_STUDIO_INSTANCETYPE_EVENTINSTANCE: FMOD_STUDIO_INSTANCETYPE = 3;
pub const FMOD_STUDIO_INSTANCETYPE_PARAMETERINSTANCE: FMOD_STUDIO_INSTANCETYPE = 4;
pub const FMOD_STUDIO_INSTANCETYPE_BUS: FMOD_STUDIO_INSTANCETYPE = 5;
pub const FMOD_STUDIO_INSTANCETYPE_VCA: FMOD_STUDIO_INSTANCETYPE = 6;
pub const FMOD_STUDIO_INSTANCETYPE_BANK: FMOD_STUDIO_INSTANCETYPE = 7;
pub const FMOD_STUDIO_INSTANCETYPE_COMMANDREPLAY: FMOD_STUDIO_INSTANCETYPE = 8;
pub const FMOD_STUDIO_INSTANCETYPE_FORCEINT: FMOD_STUDIO_INSTANCETYPE = 65536;
pub type FMOD_STUDIO_INSTANCETYPE = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_BANK_INFO {
    pub size: ::std::os::raw::c_int,
    pub userdata: *mut ::std::os::raw::c_void,
    pub userdatalength: ::std::os::raw::c_int,
    pub opencallback: FMOD_FILE_OPEN_CALLBACK,
    pub closecallback: FMOD_FILE_CLOSE_CALLBACK,
    pub readcallback: FMOD_FILE_READ_CALLBACK,
    pub seekcallback: FMOD_FILE_SEEK_CALLBACK,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_BANK_INFO"][::std::mem::size_of::<FMOD_STUDIO_BANK_INFO>() - 56usize];
    ["Alignment of FMOD_STUDIO_BANK_INFO"]
        [::std::mem::align_of::<FMOD_STUDIO_BANK_INFO>() - 8usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::size"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, size) - 0usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::userdata"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, userdata) - 8usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::userdatalength"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, userdatalength) - 16usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::opencallback"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, opencallback) - 24usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::closecallback"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, closecallback) - 32usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::readcallback"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, readcallback) - 40usize];
    ["Offset of field: FMOD_STUDIO_BANK_INFO::seekcallback"]
        [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, seekcallback) - 48usize];
};
impl Default for FMOD_STUDIO_BANK_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_PARAMETER_ID {
    pub data1: ::std::os::raw::c_uint,
    pub data2: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_PARAMETER_ID"]
        [::std::mem::size_of::<FMOD_STUDIO_PARAMETER_ID>() - 8usize];
    ["Alignment of FMOD_STUDIO_PARAMETER_ID"]
        [::std::mem::align_of::<FMOD_STUDIO_PARAMETER_ID>() - 4usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_ID::data1"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_ID, data1) - 0usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_ID::data2"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_ID, data2) - 4usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_PARAMETER_DESCRIPTION {
    pub name: *const ::std::os::raw::c_char,
    pub id: FMOD_STUDIO_PARAMETER_ID,
    pub minimum: f32,
    pub maximum: f32,
    pub defaultvalue: f32,
    pub type_: FMOD_STUDIO_PARAMETER_TYPE,
    pub flags: FMOD_STUDIO_PARAMETER_FLAGS,
    pub guid: FMOD_GUID,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_PARAMETER_DESCRIPTION"]
        [::std::mem::size_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>() - 56usize];
    ["Alignment of FMOD_STUDIO_PARAMETER_DESCRIPTION"]
        [::std::mem::align_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>() - 8usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::name"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, name) - 0usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::id"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, id) - 8usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::minimum"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, minimum) - 16usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::maximum"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, maximum) - 20usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::defaultvalue"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, defaultvalue) - 24usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::type_"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, type_) - 28usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::flags"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, flags) - 32usize];
    ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::guid"]
        [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, guid) - 36usize];
};
impl Default for FMOD_STUDIO_PARAMETER_DESCRIPTION {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FMOD_STUDIO_USER_PROPERTY {
    pub name: *const ::std::os::raw::c_char,
    pub type_: FMOD_STUDIO_USER_PROPERTY_TYPE,
    pub __bindgen_anon_1: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
    pub intvalue: ::std::os::raw::c_int,
    pub boolvalue: FMOD_BOOL,
    pub floatvalue: f32,
    pub stringvalue: *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1"]
        [::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>() - 8usize];
    ["Alignment of FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1"]
        [::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>() - 8usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::intvalue"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, intvalue) - 0usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::boolvalue"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, boolvalue) - 0usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::floatvalue"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, floatvalue) - 0usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::stringvalue"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, stringvalue) - 0usize];
};
impl Default for FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_USER_PROPERTY"]
        [::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY>() - 24usize];
    ["Alignment of FMOD_STUDIO_USER_PROPERTY"]
        [::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY>() - 8usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY::name"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY, name) - 0usize];
    ["Offset of field: FMOD_STUDIO_USER_PROPERTY::type_"]
        [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY, type_) - 8usize];
};
impl Default for FMOD_STUDIO_USER_PROPERTY {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
    pub name: *const ::std::os::raw::c_char,
    pub sound: *mut FMOD_SOUND,
    pub subsoundIndex: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES"]
        [::std::mem::size_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>() - 24usize];
    ["Alignment of FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES"]
        [::std::mem::align_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>() - 8usize];
    ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::name"]
        [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, name) - 0usize];
    ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::sound"]
        [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, sound) - 8usize];
    ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::subsoundIndex"]
        [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, subsoundIndex) - 16usize];
};
impl Default for FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
    pub name: *const ::std::os::raw::c_char,
    pub dsp: *mut FMOD_DSP,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES"]
        [::std::mem::size_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>() - 16usize];
    ["Alignment of FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES"]
        [::std::mem::align_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>() - 8usize];
    ["Offset of field: FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES::name"]
        [::std::mem::offset_of!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES, name) - 0usize];
    ["Offset of field: FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES::dsp"]
        [::std::mem::offset_of!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES, dsp) - 8usize];
};
impl Default for FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
    pub name: *const ::std::os::raw::c_char,
    pub position: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES"]
        [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>() - 16usize];
    ["Alignment of FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES"]
        [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>() - 8usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES::name"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES, name) - 0usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES::position"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES, position) - 8usize];
};
impl Default for FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
    pub bar: ::std::os::raw::c_int,
    pub beat: ::std::os::raw::c_int,
    pub position: ::std::os::raw::c_int,
    pub tempo: f32,
    pub timesignatureupper: ::std::os::raw::c_int,
    pub timesignaturelower: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES"]
        [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>() - 24usize];
    ["Alignment of FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES"]
        [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>() - 4usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::bar"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, bar) - 0usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::beat"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, beat) - 4usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::position"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, position) - 8usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::tempo"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, tempo) - 12usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::timesignatureupper"][::std::mem::offset_of!(
        FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
        timesignatureupper
    ) - 16usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::timesignaturelower"][::std::mem::offset_of!(
        FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
        timesignaturelower
    ) - 20usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
    pub eventid: FMOD_GUID,
    pub properties: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES"]
        [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>() - 40usize];
    ["Alignment of FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES"]
        [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>() - 4usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES::eventid"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES, eventid) - 0usize];
    ["Offset of field: FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES::properties"]
        [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES, properties) - 16usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_ADVANCEDSETTINGS {
    pub cbsize: ::std::os::raw::c_int,
    pub commandqueuesize: ::std::os::raw::c_uint,
    pub handleinitialsize: ::std::os::raw::c_uint,
    pub studioupdateperiod: ::std::os::raw::c_int,
    pub idlesampledatapoolsize: ::std::os::raw::c_int,
    pub streamingscheduledelay: ::std::os::raw::c_uint,
    pub encryptionkey: *const ::std::os::raw::c_char,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_ADVANCEDSETTINGS"]
        [::std::mem::size_of::<FMOD_STUDIO_ADVANCEDSETTINGS>() - 32usize];
    ["Alignment of FMOD_STUDIO_ADVANCEDSETTINGS"]
        [::std::mem::align_of::<FMOD_STUDIO_ADVANCEDSETTINGS>() - 8usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::cbsize"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, cbsize) - 0usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::commandqueuesize"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, commandqueuesize) - 4usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::handleinitialsize"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, handleinitialsize) - 8usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::studioupdateperiod"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, studioupdateperiod) - 12usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::idlesampledatapoolsize"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, idlesampledatapoolsize) - 16usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::streamingscheduledelay"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, streamingscheduledelay) - 20usize];
    ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::encryptionkey"]
        [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, encryptionkey) - 24usize];
};
impl Default for FMOD_STUDIO_ADVANCEDSETTINGS {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_CPU_USAGE {
    pub update: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_CPU_USAGE"][::std::mem::size_of::<FMOD_STUDIO_CPU_USAGE>() - 4usize];
    ["Alignment of FMOD_STUDIO_CPU_USAGE"]
        [::std::mem::align_of::<FMOD_STUDIO_CPU_USAGE>() - 4usize];
    ["Offset of field: FMOD_STUDIO_CPU_USAGE::update"]
        [::std::mem::offset_of!(FMOD_STUDIO_CPU_USAGE, update) - 0usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_BUFFER_INFO {
    pub currentusage: ::std::os::raw::c_int,
    pub peakusage: ::std::os::raw::c_int,
    pub capacity: ::std::os::raw::c_int,
    pub stallcount: ::std::os::raw::c_int,
    pub stalltime: f32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_BUFFER_INFO"][::std::mem::size_of::<FMOD_STUDIO_BUFFER_INFO>() - 20usize];
    ["Alignment of FMOD_STUDIO_BUFFER_INFO"]
        [::std::mem::align_of::<FMOD_STUDIO_BUFFER_INFO>() - 4usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_INFO::currentusage"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, currentusage) - 0usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_INFO::peakusage"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, peakusage) - 4usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_INFO::capacity"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, capacity) - 8usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_INFO::stallcount"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, stallcount) - 12usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_INFO::stalltime"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, stalltime) - 16usize];
};
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_BUFFER_USAGE {
    pub studiocommandqueue: FMOD_STUDIO_BUFFER_INFO,
    pub studiohandle: FMOD_STUDIO_BUFFER_INFO,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_BUFFER_USAGE"]
        [::std::mem::size_of::<FMOD_STUDIO_BUFFER_USAGE>() - 40usize];
    ["Alignment of FMOD_STUDIO_BUFFER_USAGE"]
        [::std::mem::align_of::<FMOD_STUDIO_BUFFER_USAGE>() - 4usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_USAGE::studiocommandqueue"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_USAGE, studiocommandqueue) - 0usize];
    ["Offset of field: FMOD_STUDIO_BUFFER_USAGE::studiohandle"]
        [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_USAGE, studiohandle) - 20usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_SOUND_INFO {
    pub name_or_data: *const ::std::os::raw::c_char,
    pub mode: FMOD_MODE,
    pub exinfo: FMOD_CREATESOUNDEXINFO,
    pub subsoundindex: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_SOUND_INFO"][::std::mem::size_of::<FMOD_STUDIO_SOUND_INFO>() - 248usize];
    ["Alignment of FMOD_STUDIO_SOUND_INFO"]
        [::std::mem::align_of::<FMOD_STUDIO_SOUND_INFO>() - 8usize];
    ["Offset of field: FMOD_STUDIO_SOUND_INFO::name_or_data"]
        [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, name_or_data) - 0usize];
    ["Offset of field: FMOD_STUDIO_SOUND_INFO::mode"]
        [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, mode) - 8usize];
    ["Offset of field: FMOD_STUDIO_SOUND_INFO::exinfo"]
        [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, exinfo) - 16usize];
    ["Offset of field: FMOD_STUDIO_SOUND_INFO::subsoundindex"]
        [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, subsoundindex) - 240usize];
};
impl Default for FMOD_STUDIO_SOUND_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct FMOD_STUDIO_COMMAND_INFO {
    pub commandname: *const ::std::os::raw::c_char,
    pub parentcommandindex: ::std::os::raw::c_int,
    pub framenumber: ::std::os::raw::c_int,
    pub frametime: f32,
    pub instancetype: FMOD_STUDIO_INSTANCETYPE,
    pub outputtype: FMOD_STUDIO_INSTANCETYPE,
    pub instancehandle: ::std::os::raw::c_uint,
    pub outputhandle: ::std::os::raw::c_uint,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_COMMAND_INFO"]
        [::std::mem::size_of::<FMOD_STUDIO_COMMAND_INFO>() - 40usize];
    ["Alignment of FMOD_STUDIO_COMMAND_INFO"]
        [::std::mem::align_of::<FMOD_STUDIO_COMMAND_INFO>() - 8usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::commandname"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, commandname) - 0usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::parentcommandindex"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, parentcommandindex) - 8usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::framenumber"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, framenumber) - 12usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::frametime"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, frametime) - 16usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::instancetype"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, instancetype) - 20usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::outputtype"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, outputtype) - 24usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::instancehandle"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, instancehandle) - 28usize];
    ["Offset of field: FMOD_STUDIO_COMMAND_INFO::outputhandle"]
        [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, outputhandle) - 32usize];
};
impl Default for FMOD_STUDIO_COMMAND_INFO {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct FMOD_STUDIO_MEMORY_USAGE {
    pub exclusive: ::std::os::raw::c_int,
    pub inclusive: ::std::os::raw::c_int,
    pub sampledata: ::std::os::raw::c_int,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of FMOD_STUDIO_MEMORY_USAGE"]
        [::std::mem::size_of::<FMOD_STUDIO_MEMORY_USAGE>() - 12usize];
    ["Alignment of FMOD_STUDIO_MEMORY_USAGE"]
        [::std::mem::align_of::<FMOD_STUDIO_MEMORY_USAGE>() - 4usize];
    ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::exclusive"]
        [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, exclusive) - 0usize];
    ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::inclusive"]
        [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, inclusive) - 4usize];
    ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::sampledata"]
        [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, sampledata) - 8usize];
};
pub type FMOD_STUDIO_SYSTEM_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        system: *mut FMOD_STUDIO_SYSTEM,
        type_: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
        commanddata: *mut ::std::os::raw::c_void,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_EVENT_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        type_: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
        event: *mut FMOD_STUDIO_EVENTINSTANCE,
        parameters: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
        currenttime: f32,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
        bankguid: *const FMOD_GUID,
        bankfilename: *const ::std::os::raw::c_char,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK = ::std::option::Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT,
>;
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_ParseID(
        idstring: *const ::std::os::raw::c_char,
        id: *mut FMOD_GUID,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_Create(
        system: *mut *mut FMOD_STUDIO_SYSTEM,
        headerversion: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_System_IsValid(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetAdvancedSettings(
        system: *mut FMOD_STUDIO_SYSTEM,
        settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetAdvancedSettings(
        system: *mut FMOD_STUDIO_SYSTEM,
        settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_Initialize(
        system: *mut FMOD_STUDIO_SYSTEM,
        maxchannels: ::std::os::raw::c_int,
        studioflags: FMOD_STUDIO_INITFLAGS,
        flags: FMOD_INITFLAGS,
        extradriverdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_Release(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_Update(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetCoreSystem(
        system: *mut FMOD_STUDIO_SYSTEM,
        coresystem: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetEvent(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const ::std::os::raw::c_char,
        event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBus(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const ::std::os::raw::c_char,
        bus: *mut *mut FMOD_STUDIO_BUS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetVCA(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const ::std::os::raw::c_char,
        vca: *mut *mut FMOD_STUDIO_VCA,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBank(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const ::std::os::raw::c_char,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetEventByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBusByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        bus: *mut *mut FMOD_STUDIO_BUS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetVCAByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        vca: *mut *mut FMOD_STUDIO_VCA,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBankByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetSoundInfo(
        system: *mut FMOD_STUDIO_SYSTEM,
        key: *const ::std::os::raw::c_char,
        info: *mut FMOD_STUDIO_SOUND_INFO,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterDescriptionByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterDescriptionByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterLabelByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
        labelindex: ::std::os::raw::c_int,
        label: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterLabelByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        labelindex: ::std::os::raw::c_int,
        label: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: *mut f32,
        finalvalue: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetParameterByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: f32,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetParameterByIDWithLabel(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        label: *const ::std::os::raw::c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetParametersByIDs(
        system: *mut FMOD_STUDIO_SYSTEM,
        ids: *const FMOD_STUDIO_PARAMETER_ID,
        values: *mut f32,
        count: ::std::os::raw::c_int,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
        value: *mut f32,
        finalvalue: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetParameterByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
        value: f32,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetParameterByNameWithLabel(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
        label: *const ::std::os::raw::c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LookupID(
        system: *mut FMOD_STUDIO_SYSTEM,
        path: *const ::std::os::raw::c_char,
        id: *mut FMOD_GUID,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LookupPath(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetNumListeners(
        system: *mut FMOD_STUDIO_SYSTEM,
        numlisteners: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetNumListeners(
        system: *mut FMOD_STUDIO_SYSTEM,
        numlisteners: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetListenerAttributes(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: ::std::os::raw::c_int,
        attributes: *mut FMOD_3D_ATTRIBUTES,
        attenuationposition: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetListenerAttributes(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: ::std::os::raw::c_int,
        attributes: *const FMOD_3D_ATTRIBUTES,
        attenuationposition: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetListenerWeight(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: ::std::os::raw::c_int,
        weight: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetListenerWeight(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: ::std::os::raw::c_int,
        weight: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LoadBankFile(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const ::std::os::raw::c_char,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LoadBankMemory(
        system: *mut FMOD_STUDIO_SYSTEM,
        buffer: *const ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
        mode: FMOD_STUDIO_LOAD_MEMORY_MODE,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LoadBankCustom(
        system: *mut FMOD_STUDIO_SYSTEM,
        info: *const FMOD_STUDIO_BANK_INFO,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_RegisterPlugin(
        system: *mut FMOD_STUDIO_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_UnregisterPlugin(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_UnloadAll(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_FlushCommands(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_FlushSampleLoading(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_StartCommandCapture(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const ::std::os::raw::c_char,
        flags: FMOD_STUDIO_COMMANDCAPTURE_FLAGS,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_StopCommandCapture(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_LoadCommandReplay(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const ::std::os::raw::c_char,
        flags: FMOD_STUDIO_COMMANDREPLAY_FLAGS,
        replay: *mut *mut FMOD_STUDIO_COMMANDREPLAY,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBankCount(
        system: *mut FMOD_STUDIO_SYSTEM,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBankList(
        system: *mut FMOD_STUDIO_SYSTEM,
        array: *mut *mut FMOD_STUDIO_BANK,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterDescriptionCount(
        system: *mut FMOD_STUDIO_SYSTEM,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetParameterDescriptionList(
        system: *mut FMOD_STUDIO_SYSTEM,
        array: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetCPUUsage(
        system: *mut FMOD_STUDIO_SYSTEM,
        usage: *mut FMOD_STUDIO_CPU_USAGE,
        usage_core: *mut FMOD_CPU_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetBufferUsage(
        system: *mut FMOD_STUDIO_SYSTEM,
        usage: *mut FMOD_STUDIO_BUFFER_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_ResetBufferUsage(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetCallback(
        system: *mut FMOD_STUDIO_SYSTEM,
        callback: FMOD_STUDIO_SYSTEM_CALLBACK,
        callbackmask: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_SetUserData(
        system: *mut FMOD_STUDIO_SYSTEM,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetUserData(
        system: *mut FMOD_STUDIO_SYSTEM,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_System_GetMemoryUsage(
        system: *mut FMOD_STUDIO_SYSTEM,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_EventDescription_IsValid(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: *mut FMOD_GUID,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetPath(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: ::std::os::raw::c_int,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByName(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const ::std::os::raw::c_char,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: FMOD_STUDIO_PARAMETER_ID,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: ::std::os::raw::c_int,
        labelindex: ::std::os::raw::c_int,
        label: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByName(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const ::std::os::raw::c_char,
        labelindex: ::std::os::raw::c_int,
        label: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: FMOD_STUDIO_PARAMETER_ID,
        labelindex: ::std::os::raw::c_int,
        label: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetUserPropertyCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetUserPropertyByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: ::std::os::raw::c_int,
        property: *mut FMOD_STUDIO_USER_PROPERTY,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetUserProperty(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const ::std::os::raw::c_char,
        property: *mut FMOD_STUDIO_USER_PROPERTY,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetLength(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        length: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetMinMaxDistance(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        min: *mut f32,
        max: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetSoundSize(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        size: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_IsSnapshot(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        snapshot: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_IsOneshot(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        oneshot: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_IsStream(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        isStream: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_Is3D(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        is3D: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_IsDopplerEnabled(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        doppler: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_HasSustainPoint(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        sustainPoint: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_CreateInstance(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetInstanceCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetInstanceList(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        array: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_LoadSampleData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_UnloadSampleData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetSampleLoadingState(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_ReleaseAllInstances(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_SetCallback(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        callback: FMOD_STUDIO_EVENT_CALLBACK,
        callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_GetUserData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventDescription_SetUserData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_EventInstance_IsValid(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetDescription(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        description: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetSystem(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        system: *mut *mut FMOD_STUDIO_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetVolume(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        volume: *mut f32,
        finalvolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetVolume(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        volume: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetPitch(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        pitch: *mut f32,
        finalpitch: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetPitch(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        pitch: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_Get3DAttributes(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_Set3DAttributes(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetListenerMask(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mask: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetListenerMask(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mask: ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetProperty(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: FMOD_STUDIO_EVENT_PROPERTY,
        value: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetProperty(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: FMOD_STUDIO_EVENT_PROPERTY,
        value: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetReverbLevel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: ::std::os::raw::c_int,
        level: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetReverbLevel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: ::std::os::raw::c_int,
        level: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetPaused(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetPaused(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_Start(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_Stop(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mode: FMOD_STUDIO_STOP_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetTimelinePosition(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        position: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetTimelinePosition(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        position: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetPlaybackState(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        state: *mut FMOD_STUDIO_PLAYBACK_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetChannelGroup(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetMinMaxDistance(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        min: *mut f32,
        max: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_Release(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_IsVirtual(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        virtualstate: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetParameterByName(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const ::std::os::raw::c_char,
        value: *mut f32,
        finalvalue: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetParameterByName(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const ::std::os::raw::c_char,
        value: f32,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetParameterByNameWithLabel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const ::std::os::raw::c_char,
        label: *const ::std::os::raw::c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetParameterByID(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: *mut f32,
        finalvalue: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetParameterByID(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: f32,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetParameterByIDWithLabel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        label: *const ::std::os::raw::c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetParametersByIDs(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        ids: *const FMOD_STUDIO_PARAMETER_ID,
        values: *mut f32,
        count: ::std::os::raw::c_int,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_KeyOff(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetCallback(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        callback: FMOD_STUDIO_EVENT_CALLBACK,
        callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetUserData(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_SetUserData(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetCPUUsage(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        exclusive: *mut ::std::os::raw::c_uint,
        inclusive: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_EventInstance_GetMemoryUsage(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_Bus_IsValid(bus: *mut FMOD_STUDIO_BUS) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetID(bus: *mut FMOD_STUDIO_BUS, id: *mut FMOD_GUID) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetPath(
        bus: *mut FMOD_STUDIO_BUS,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetVolume(
        bus: *mut FMOD_STUDIO_BUS,
        volume: *mut f32,
        finalvolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_SetVolume(bus: *mut FMOD_STUDIO_BUS, volume: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetPaused(
        bus: *mut FMOD_STUDIO_BUS,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_SetPaused(bus: *mut FMOD_STUDIO_BUS, paused: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetMute(bus: *mut FMOD_STUDIO_BUS, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_SetMute(bus: *mut FMOD_STUDIO_BUS, mute: FMOD_BOOL) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_StopAllEvents(
        bus: *mut FMOD_STUDIO_BUS,
        mode: FMOD_STUDIO_STOP_MODE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetPortIndex(
        bus: *mut FMOD_STUDIO_BUS,
        index: *mut FMOD_PORT_INDEX,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_SetPortIndex(
        bus: *mut FMOD_STUDIO_BUS,
        index: FMOD_PORT_INDEX,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_LockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_UnlockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetChannelGroup(
        bus: *mut FMOD_STUDIO_BUS,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetCPUUsage(
        bus: *mut FMOD_STUDIO_BUS,
        exclusive: *mut ::std::os::raw::c_uint,
        inclusive: *mut ::std::os::raw::c_uint,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bus_GetMemoryUsage(
        bus: *mut FMOD_STUDIO_BUS,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_VCA_IsValid(vca: *mut FMOD_STUDIO_VCA) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_VCA_GetID(vca: *mut FMOD_STUDIO_VCA, id: *mut FMOD_GUID) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_VCA_GetPath(
        vca: *mut FMOD_STUDIO_VCA,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_VCA_GetVolume(
        vca: *mut FMOD_STUDIO_VCA,
        volume: *mut f32,
        finalvolume: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_VCA_SetVolume(vca: *mut FMOD_STUDIO_VCA, volume: f32) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_Bank_IsValid(bank: *mut FMOD_STUDIO_BANK) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetID(bank: *mut FMOD_STUDIO_BANK, id: *mut FMOD_GUID) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetPath(
        bank: *mut FMOD_STUDIO_BANK,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_Unload(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_LoadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_UnloadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetLoadingState(
        bank: *mut FMOD_STUDIO_BANK,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetSampleLoadingState(
        bank: *mut FMOD_STUDIO_BANK,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetStringCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetStringInfo(
        bank: *mut FMOD_STUDIO_BANK,
        index: ::std::os::raw::c_int,
        id: *mut FMOD_GUID,
        path: *mut ::std::os::raw::c_char,
        size: ::std::os::raw::c_int,
        retrieved: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetEventCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetEventList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetBusCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetBusList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_BUS,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetVCACount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetVCAList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_VCA,
        capacity: ::std::os::raw::c_int,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_GetUserData(
        bank: *mut FMOD_STUDIO_BANK,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_Bank_SetUserData(
        bank: *mut FMOD_STUDIO_BANK,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    pub fn FMOD_Studio_CommandReplay_IsValid(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_BOOL;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetSystem(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        system: *mut *mut FMOD_STUDIO_SYSTEM,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetLength(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        length: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetCommandCount(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        count: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetCommandInfo(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
        info: *mut FMOD_STUDIO_COMMAND_INFO,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetCommandString(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
        buffer: *mut ::std::os::raw::c_char,
        length: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetCommandAtTime(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        time: f32,
        commandindex: *mut ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetBankPath(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        bankPath: *const ::std::os::raw::c_char,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_Start(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_Stop(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SeekToTime(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        time: f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SeekToCommand(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: ::std::os::raw::c_int,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetPaused(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetPaused(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetPlaybackState(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        state: *mut FMOD_STUDIO_PLAYBACK_STATE,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetCurrentCommand(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: *mut ::std::os::raw::c_int,
        currenttime: *mut f32,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_Release(replay: *mut FMOD_STUDIO_COMMANDREPLAY)
        -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetFrameCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetLoadBankCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetCreateInstanceCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_GetUserData(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        userdata: *mut *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}
unsafe extern "C" {
    #[must_use]
    pub fn FMOD_Studio_CommandReplay_SetUserData(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        userdata: *mut ::std::os::raw::c_void,
    ) -> FMOD_RESULT;
}