libfmod 2.222.6

#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(unused_parens)]
use std::os::raw::{
    c_char, c_float, c_int, c_longlong, c_short, c_uchar, c_uint, c_ulonglong, c_ushort, c_void,
};
#[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],
}
#[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_BOOL = c_int;
pub const FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT: c_uint = 32;
pub const FMOD_VERSION: c_uint = 0x00020222;
pub const FMOD_MAX_CHANNEL_WIDTH: c_uint = 32;
pub const FMOD_MAX_SYSTEMS: c_uint = 8;
pub const FMOD_MAX_LISTENERS: c_uint = 8;
pub const FMOD_REVERB_MAXINSTANCES: c_uint = 4;
pub const FMOD_CODEC_PLUGIN_VERSION: c_uint = 1;
pub const FMOD_OUTPUT_PLUGIN_VERSION: c_uint = 5;
pub const FMOD_PLUGIN_SDK_VERSION: c_uint = 110;
pub const FMOD_DSP_GETPARAM_VALUESTR_LENGTH: c_uint = 32;
pub const FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES: c_uint = 66;
pub type FMOD_STUDIO_LOADING_STATE = c_int;
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_LOAD_MEMORY_MODE = c_int;
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_PARAMETER_TYPE = c_int;
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_USER_PROPERTY_TYPE = c_int;
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_EVENT_PROPERTY = c_int;
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_PLAYBACK_STATE = c_int;
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_STOP_MODE = c_int;
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_INSTANCETYPE = c_int;
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_THREAD_TYPE = c_int;
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_RESULT = c_int;
pub const FMOD_OK: FMOD_RESULT = 0;
pub const FMOD_ERR_BADCOMMAND: FMOD_RESULT = 1;
pub const FMOD_ERR_CHANNEL_ALLOC: FMOD_RESULT = 2;
pub const FMOD_ERR_CHANNEL_STOLEN: FMOD_RESULT = 3;
pub const FMOD_ERR_DMA: FMOD_RESULT = 4;
pub const FMOD_ERR_DSP_CONNECTION: FMOD_RESULT = 5;
pub const FMOD_ERR_DSP_DONTPROCESS: FMOD_RESULT = 6;
pub const FMOD_ERR_DSP_FORMAT: FMOD_RESULT = 7;
pub const FMOD_ERR_DSP_INUSE: FMOD_RESULT = 8;
pub const FMOD_ERR_DSP_NOTFOUND: FMOD_RESULT = 9;
pub const FMOD_ERR_DSP_RESERVED: FMOD_RESULT = 10;
pub const FMOD_ERR_DSP_SILENCE: FMOD_RESULT = 11;
pub const FMOD_ERR_DSP_TYPE: FMOD_RESULT = 12;
pub const FMOD_ERR_FILE_BAD: FMOD_RESULT = 13;
pub const FMOD_ERR_FILE_COULDNOTSEEK: FMOD_RESULT = 14;
pub const FMOD_ERR_FILE_DISKEJECTED: FMOD_RESULT = 15;
pub const FMOD_ERR_FILE_EOF: FMOD_RESULT = 16;
pub const FMOD_ERR_FILE_ENDOFDATA: FMOD_RESULT = 17;
pub const FMOD_ERR_FILE_NOTFOUND: FMOD_RESULT = 18;
pub const FMOD_ERR_FORMAT: FMOD_RESULT = 19;
pub const FMOD_ERR_HEADER_MISMATCH: FMOD_RESULT = 20;
pub const FMOD_ERR_HTTP: FMOD_RESULT = 21;
pub const FMOD_ERR_HTTP_ACCESS: FMOD_RESULT = 22;
pub const FMOD_ERR_HTTP_PROXY_AUTH: FMOD_RESULT = 23;
pub const FMOD_ERR_HTTP_SERVER_ERROR: FMOD_RESULT = 24;
pub const FMOD_ERR_HTTP_TIMEOUT: FMOD_RESULT = 25;
pub const FMOD_ERR_INITIALIZATION: FMOD_RESULT = 26;
pub const FMOD_ERR_INITIALIZED: FMOD_RESULT = 27;
pub const FMOD_ERR_INTERNAL: FMOD_RESULT = 28;
pub const FMOD_ERR_INVALID_FLOAT: FMOD_RESULT = 29;
pub const FMOD_ERR_INVALID_HANDLE: FMOD_RESULT = 30;
pub const FMOD_ERR_INVALID_PARAM: FMOD_RESULT = 31;
pub const FMOD_ERR_INVALID_POSITION: FMOD_RESULT = 32;
pub const FMOD_ERR_INVALID_SPEAKER: FMOD_RESULT = 33;
pub const FMOD_ERR_INVALID_SYNCPOINT: FMOD_RESULT = 34;
pub const FMOD_ERR_INVALID_THREAD: FMOD_RESULT = 35;
pub const FMOD_ERR_INVALID_VECTOR: FMOD_RESULT = 36;
pub const FMOD_ERR_MAXAUDIBLE: FMOD_RESULT = 37;
pub const FMOD_ERR_MEMORY: FMOD_RESULT = 38;
pub const FMOD_ERR_MEMORY_CANTPOINT: FMOD_RESULT = 39;
pub const FMOD_ERR_NEEDS3D: FMOD_RESULT = 40;
pub const FMOD_ERR_NEEDSHARDWARE: FMOD_RESULT = 41;
pub const FMOD_ERR_NET_CONNECT: FMOD_RESULT = 42;
pub const FMOD_ERR_NET_SOCKET_ERROR: FMOD_RESULT = 43;
pub const FMOD_ERR_NET_URL: FMOD_RESULT = 44;
pub const FMOD_ERR_NET_WOULD_BLOCK: FMOD_RESULT = 45;
pub const FMOD_ERR_NOTREADY: FMOD_RESULT = 46;
pub const FMOD_ERR_OUTPUT_ALLOCATED: FMOD_RESULT = 47;
pub const FMOD_ERR_OUTPUT_CREATEBUFFER: FMOD_RESULT = 48;
pub const FMOD_ERR_OUTPUT_DRIVERCALL: FMOD_RESULT = 49;
pub const FMOD_ERR_OUTPUT_FORMAT: FMOD_RESULT = 50;
pub const FMOD_ERR_OUTPUT_INIT: FMOD_RESULT = 51;
pub const FMOD_ERR_OUTPUT_NODRIVERS: FMOD_RESULT = 52;
pub const FMOD_ERR_PLUGIN: FMOD_RESULT = 53;
pub const FMOD_ERR_PLUGIN_MISSING: FMOD_RESULT = 54;
pub const FMOD_ERR_PLUGIN_RESOURCE: FMOD_RESULT = 55;
pub const FMOD_ERR_PLUGIN_VERSION: FMOD_RESULT = 56;
pub const FMOD_ERR_RECORD: FMOD_RESULT = 57;
pub const FMOD_ERR_REVERB_CHANNELGROUP: FMOD_RESULT = 58;
pub const FMOD_ERR_REVERB_INSTANCE: FMOD_RESULT = 59;
pub const FMOD_ERR_SUBSOUNDS: FMOD_RESULT = 60;
pub const FMOD_ERR_SUBSOUND_ALLOCATED: FMOD_RESULT = 61;
pub const FMOD_ERR_SUBSOUND_CANTMOVE: FMOD_RESULT = 62;
pub const FMOD_ERR_TAGNOTFOUND: FMOD_RESULT = 63;
pub const FMOD_ERR_TOOMANYCHANNELS: FMOD_RESULT = 64;
pub const FMOD_ERR_TRUNCATED: FMOD_RESULT = 65;
pub const FMOD_ERR_UNIMPLEMENTED: FMOD_RESULT = 66;
pub const FMOD_ERR_UNINITIALIZED: FMOD_RESULT = 67;
pub const FMOD_ERR_UNSUPPORTED: FMOD_RESULT = 68;
pub const FMOD_ERR_VERSION: FMOD_RESULT = 69;
pub const FMOD_ERR_EVENT_ALREADY_LOADED: FMOD_RESULT = 70;
pub const FMOD_ERR_EVENT_LIVEUPDATE_BUSY: FMOD_RESULT = 71;
pub const FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH: FMOD_RESULT = 72;
pub const FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT: FMOD_RESULT = 73;
pub const FMOD_ERR_EVENT_NOTFOUND: FMOD_RESULT = 74;
pub const FMOD_ERR_STUDIO_UNINITIALIZED: FMOD_RESULT = 75;
pub const FMOD_ERR_STUDIO_NOT_LOADED: FMOD_RESULT = 76;
pub const FMOD_ERR_INVALID_STRING: FMOD_RESULT = 77;
pub const FMOD_ERR_ALREADY_LOCKED: FMOD_RESULT = 78;
pub const FMOD_ERR_NOT_LOCKED: FMOD_RESULT = 79;
pub const FMOD_ERR_RECORD_DISCONNECTED: FMOD_RESULT = 80;
pub const FMOD_ERR_TOOMANYSAMPLES: FMOD_RESULT = 81;
pub const FMOD_RESULT_FORCEINT: FMOD_RESULT = 65536;
pub type FMOD_CHANNELCONTROL_TYPE = c_int;
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_OUTPUTTYPE = c_int;
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_DEBUG_MODE = c_int;
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_SPEAKERMODE = c_int;
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_SPEAKER = c_int;
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_CHANNELORDER = 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_PLUGINTYPE = c_int;
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_SOUND_TYPE = c_int;
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_FORMAT = c_int;
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_OPENSTATE = c_int;
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_SOUNDGROUP_BEHAVIOR = c_int;
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_CHANNELCONTROL_CALLBACK_TYPE = c_int;
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_DSP_INDEX = c_int;
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_ERRORCALLBACK_INSTANCETYPE = 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_DSP_RESAMPLER = c_int;
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_CALLBACK_TYPE = c_int;
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_DSPCONNECTION_TYPE = c_int;
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_TAGTYPE = c_int;
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_TAGDATATYPE = c_int;
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_PORT_TYPE = c_int;
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_MAX: FMOD_PORT_TYPE = 7;
pub const FMOD_PORT_TYPE_FORCEINT: FMOD_PORT_TYPE = 65536;
pub type FMOD_DSP_PROCESS_OPERATION = c_int;
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_PAN_SURROUND_FLAGS = c_int;
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_PARAMETER_TYPE = c_int;
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_FLOAT_MAPPING_TYPE = c_int;
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_DATA_TYPE = c_int;
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 type FMOD_DSP_TYPE = c_int;
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_VSTPLUGIN: FMOD_DSP_TYPE = 15;
pub const FMOD_DSP_TYPE_WINAMPPLUGIN: FMOD_DSP_TYPE = 16;
pub const FMOD_DSP_TYPE_ITECHO: FMOD_DSP_TYPE = 17;
pub const FMOD_DSP_TYPE_COMPRESSOR: FMOD_DSP_TYPE = 18;
pub const FMOD_DSP_TYPE_SFXREVERB: FMOD_DSP_TYPE = 19;
pub const FMOD_DSP_TYPE_LOWPASS_SIMPLE: FMOD_DSP_TYPE = 20;
pub const FMOD_DSP_TYPE_DELAY: FMOD_DSP_TYPE = 21;
pub const FMOD_DSP_TYPE_TREMOLO: FMOD_DSP_TYPE = 22;
pub const FMOD_DSP_TYPE_LADSPAPLUGIN: FMOD_DSP_TYPE = 23;
pub const FMOD_DSP_TYPE_SEND: FMOD_DSP_TYPE = 24;
pub const FMOD_DSP_TYPE_RETURN: FMOD_DSP_TYPE = 25;
pub const FMOD_DSP_TYPE_HIGHPASS_SIMPLE: FMOD_DSP_TYPE = 26;
pub const FMOD_DSP_TYPE_PAN: FMOD_DSP_TYPE = 27;
pub const FMOD_DSP_TYPE_THREE_EQ: FMOD_DSP_TYPE = 28;
pub const FMOD_DSP_TYPE_FFT: FMOD_DSP_TYPE = 29;
pub const FMOD_DSP_TYPE_LOUDNESS_METER: FMOD_DSP_TYPE = 30;
pub const FMOD_DSP_TYPE_ENVELOPEFOLLOWER: FMOD_DSP_TYPE = 31;
pub const FMOD_DSP_TYPE_CONVOLUTIONREVERB: FMOD_DSP_TYPE = 32;
pub const FMOD_DSP_TYPE_CHANNELMIX: FMOD_DSP_TYPE = 33;
pub const FMOD_DSP_TYPE_TRANSCEIVER: FMOD_DSP_TYPE = 34;
pub const FMOD_DSP_TYPE_OBJECTPAN: FMOD_DSP_TYPE = 35;
pub const FMOD_DSP_TYPE_MULTIBAND_EQ: FMOD_DSP_TYPE = 36;
pub const FMOD_DSP_TYPE_MAX: FMOD_DSP_TYPE = 37;
pub const FMOD_DSP_TYPE_FORCEINT: FMOD_DSP_TYPE = 65536;
pub type FMOD_DSP_OSCILLATOR = c_int;
pub const FMOD_DSP_OSCILLATOR_TYPE: FMOD_DSP_OSCILLATOR = 0;
pub const FMOD_DSP_OSCILLATOR_RATE: FMOD_DSP_OSCILLATOR = 1;
pub type FMOD_DSP_LOWPASS = c_int;
pub const FMOD_DSP_LOWPASS_CUTOFF: FMOD_DSP_LOWPASS = 0;
pub const FMOD_DSP_LOWPASS_RESONANCE: FMOD_DSP_LOWPASS = 1;
pub type FMOD_DSP_ITLOWPASS = c_int;
pub const FMOD_DSP_ITLOWPASS_CUTOFF: FMOD_DSP_ITLOWPASS = 0;
pub const FMOD_DSP_ITLOWPASS_RESONANCE: FMOD_DSP_ITLOWPASS = 1;
pub type FMOD_DSP_HIGHPASS = c_int;
pub const FMOD_DSP_HIGHPASS_CUTOFF: FMOD_DSP_HIGHPASS = 0;
pub const FMOD_DSP_HIGHPASS_RESONANCE: FMOD_DSP_HIGHPASS = 1;
pub type FMOD_DSP_ECHO = c_int;
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 type FMOD_DSP_FADER = c_int;
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_FLANGE = c_int;
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_DISTORTION = c_int;
pub const FMOD_DSP_DISTORTION_LEVEL: FMOD_DSP_DISTORTION = 0;
pub type FMOD_DSP_NORMALIZE = c_int;
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_LIMITER = c_int;
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_PARAMEQ = c_int;
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_MULTIBAND_EQ = c_int;
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_FILTER_TYPE = c_int;
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 type FMOD_DSP_PITCHSHIFT = c_int;
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_CHORUS = c_int;
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_ITECHO = c_int;
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_COMPRESSOR = c_int;
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_SFXREVERB = c_int;
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_LOWPASS_SIMPLE = c_int;
pub const FMOD_DSP_LOWPASS_SIMPLE_CUTOFF: FMOD_DSP_LOWPASS_SIMPLE = 0;
pub type FMOD_DSP_DELAY = c_int;
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_TREMOLO = c_int;
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_SEND = c_int;
pub const FMOD_DSP_SEND_RETURNID: FMOD_DSP_SEND = 0;
pub const FMOD_DSP_SEND_LEVEL: FMOD_DSP_SEND = 1;
pub type FMOD_DSP_RETURN = c_int;
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_HIGHPASS_SIMPLE = c_int;
pub const FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF: FMOD_DSP_HIGHPASS_SIMPLE = 0;
pub type FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = c_int;
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_MODE_TYPE = c_int;
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_3D_ROLLOFF_TYPE = c_int;
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_EXTENT_MODE_TYPE = c_int;
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 = c_int;
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_THREE_EQ_CROSSOVERSLOPE_TYPE = c_int;
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 = c_int;
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_FFT_WINDOW = c_int;
pub const FMOD_DSP_FFT_WINDOW_RECT: FMOD_DSP_FFT_WINDOW = 0;
pub const FMOD_DSP_FFT_WINDOW_TRIANGLE: FMOD_DSP_FFT_WINDOW = 1;
pub const FMOD_DSP_FFT_WINDOW_HAMMING: FMOD_DSP_FFT_WINDOW = 2;
pub const FMOD_DSP_FFT_WINDOW_HANNING: FMOD_DSP_FFT_WINDOW = 3;
pub const FMOD_DSP_FFT_WINDOW_BLACKMAN: FMOD_DSP_FFT_WINDOW = 4;
pub const FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS: FMOD_DSP_FFT_WINDOW = 5;
pub type FMOD_DSP_FFT = c_int;
pub const FMOD_DSP_FFT_WINDOWSIZE: FMOD_DSP_FFT = 0;
pub const FMOD_DSP_FFT_WINDOWTYPE: FMOD_DSP_FFT = 1;
pub const FMOD_DSP_FFT_SPECTRUMDATA: FMOD_DSP_FFT = 2;
pub const FMOD_DSP_FFT_DOMINANT_FREQ: FMOD_DSP_FFT = 3;
pub type FMOD_DSP_LOUDNESS_METER = c_int;
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_STATE_TYPE = c_int;
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_ENVELOPEFOLLOWER = c_int;
pub const FMOD_DSP_ENVELOPEFOLLOWER_ATTACK: FMOD_DSP_ENVELOPEFOLLOWER = 0;
pub const FMOD_DSP_ENVELOPEFOLLOWER_RELEASE: FMOD_DSP_ENVELOPEFOLLOWER = 1;
pub const FMOD_DSP_ENVELOPEFOLLOWER_ENVELOPE: FMOD_DSP_ENVELOPEFOLLOWER = 2;
pub const FMOD_DSP_ENVELOPEFOLLOWER_USESIDECHAIN: FMOD_DSP_ENVELOPEFOLLOWER = 3;
pub type FMOD_DSP_CONVOLUTION_REVERB = c_int;
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_CHANNELMIX_OUTPUT = c_int;
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 = c_int;
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_TRANSCEIVER_SPEAKERMODE = c_int;
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 = 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_OBJECTPAN = c_int;
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_STUDIO_INITFLAGS = c_uint;
pub const FMOD_STUDIO_INIT_NORMAL: FMOD_STUDIO_INITFLAGS = 0x00000000;
pub const FMOD_STUDIO_INIT_LIVEUPDATE: FMOD_STUDIO_INITFLAGS = 0x00000001;
pub const FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS: FMOD_STUDIO_INITFLAGS = 0x00000002;
pub const FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE: FMOD_STUDIO_INITFLAGS = 0x00000004;
pub const FMOD_STUDIO_INIT_DEFERRED_CALLBACKS: FMOD_STUDIO_INITFLAGS = 0x00000008;
pub const FMOD_STUDIO_INIT_LOAD_FROM_UPDATE: FMOD_STUDIO_INITFLAGS = 0x00000010;
pub const FMOD_STUDIO_INIT_MEMORY_TRACKING: FMOD_STUDIO_INITFLAGS = 0x00000020;
pub type FMOD_STUDIO_PARAMETER_FLAGS = c_uint;
pub const FMOD_STUDIO_PARAMETER_READONLY: FMOD_STUDIO_PARAMETER_FLAGS = 0x00000001;
pub const FMOD_STUDIO_PARAMETER_AUTOMATIC: FMOD_STUDIO_PARAMETER_FLAGS = 0x00000002;
pub const FMOD_STUDIO_PARAMETER_GLOBAL: FMOD_STUDIO_PARAMETER_FLAGS = 0x00000004;
pub const FMOD_STUDIO_PARAMETER_DISCRETE: FMOD_STUDIO_PARAMETER_FLAGS = 0x00000008;
pub const FMOD_STUDIO_PARAMETER_LABELED: FMOD_STUDIO_PARAMETER_FLAGS = 0x00000010;
pub type FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = c_uint;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = 0x00000001;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = 0x00000002;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = 0x00000004;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE =
    0x00000008;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE =
    0x00000010;
pub const FMOD_STUDIO_SYSTEM_CALLBACK_ALL: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = 0xFFFFFFFF;
pub type FMOD_STUDIO_EVENT_CALLBACK_TYPE = c_uint;
pub const FMOD_STUDIO_EVENT_CALLBACK_CREATED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000001;
pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROYED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000002;
pub const FMOD_STUDIO_EVENT_CALLBACK_STARTING: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000004;
pub const FMOD_STUDIO_EVENT_CALLBACK_STARTED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000008;
pub const FMOD_STUDIO_EVENT_CALLBACK_RESTARTED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000010;
pub const FMOD_STUDIO_EVENT_CALLBACK_STOPPED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000020;
pub const FMOD_STUDIO_EVENT_CALLBACK_START_FAILED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000040;
pub const FMOD_STUDIO_EVENT_CALLBACK_CREATE_PROGRAMMER_SOUND: FMOD_STUDIO_EVENT_CALLBACK_TYPE =
    0x00000080;
pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROY_PROGRAMMER_SOUND: FMOD_STUDIO_EVENT_CALLBACK_TYPE =
    0x00000100;
pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_CREATED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000200;
pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_DESTROYED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000400;
pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_MARKER: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00000800;
pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_BEAT: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00001000;
pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_PLAYED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00002000;
pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_STOPPED: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00004000;
pub const FMOD_STUDIO_EVENT_CALLBACK_REAL_TO_VIRTUAL: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00008000;
pub const FMOD_STUDIO_EVENT_CALLBACK_VIRTUAL_TO_REAL: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0x00010000;
pub const FMOD_STUDIO_EVENT_CALLBACK_START_EVENT_COMMAND: FMOD_STUDIO_EVENT_CALLBACK_TYPE =
    0x00020000;
pub const FMOD_STUDIO_EVENT_CALLBACK_NESTED_TIMELINE_BEAT: FMOD_STUDIO_EVENT_CALLBACK_TYPE =
    0x00040000;
pub const FMOD_STUDIO_EVENT_CALLBACK_ALL: FMOD_STUDIO_EVENT_CALLBACK_TYPE = 0xFFFFFFFF;
pub type FMOD_STUDIO_LOAD_BANK_FLAGS = c_uint;
pub const FMOD_STUDIO_LOAD_BANK_NORMAL: FMOD_STUDIO_LOAD_BANK_FLAGS = 0x00000000;
pub const FMOD_STUDIO_LOAD_BANK_NONBLOCKING: FMOD_STUDIO_LOAD_BANK_FLAGS = 0x00000001;
pub const FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES: FMOD_STUDIO_LOAD_BANK_FLAGS = 0x00000002;
pub const FMOD_STUDIO_LOAD_BANK_UNENCRYPTED: FMOD_STUDIO_LOAD_BANK_FLAGS = 0x00000004;
pub type FMOD_STUDIO_COMMANDCAPTURE_FLAGS = c_uint;
pub const FMOD_STUDIO_COMMANDCAPTURE_NORMAL: FMOD_STUDIO_COMMANDCAPTURE_FLAGS = 0x00000000;
pub const FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH: FMOD_STUDIO_COMMANDCAPTURE_FLAGS = 0x00000001;
pub const FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE: FMOD_STUDIO_COMMANDCAPTURE_FLAGS =
    0x00000002;
pub type FMOD_STUDIO_COMMANDREPLAY_FLAGS = c_uint;
pub const FMOD_STUDIO_COMMANDREPLAY_NORMAL: FMOD_STUDIO_COMMANDREPLAY_FLAGS = 0x00000000;
pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP: FMOD_STUDIO_COMMANDREPLAY_FLAGS = 0x00000001;
pub const FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD: FMOD_STUDIO_COMMANDREPLAY_FLAGS = 0x00000002;
pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD: FMOD_STUDIO_COMMANDREPLAY_FLAGS = 0x00000004;
pub type FMOD_DEBUG_FLAGS = c_uint;
pub const FMOD_DEBUG_LEVEL_NONE: FMOD_DEBUG_FLAGS = 0x00000000;
pub const FMOD_DEBUG_LEVEL_ERROR: FMOD_DEBUG_FLAGS = 0x00000001;
pub const FMOD_DEBUG_LEVEL_WARNING: FMOD_DEBUG_FLAGS = 0x00000002;
pub const FMOD_DEBUG_LEVEL_LOG: FMOD_DEBUG_FLAGS = 0x00000004;
pub const FMOD_DEBUG_TYPE_MEMORY: FMOD_DEBUG_FLAGS = 0x00000100;
pub const FMOD_DEBUG_TYPE_FILE: FMOD_DEBUG_FLAGS = 0x00000200;
pub const FMOD_DEBUG_TYPE_CODEC: FMOD_DEBUG_FLAGS = 0x00000400;
pub const FMOD_DEBUG_TYPE_TRACE: FMOD_DEBUG_FLAGS = 0x00000800;
pub const FMOD_DEBUG_DISPLAY_TIMESTAMPS: FMOD_DEBUG_FLAGS = 0x00010000;
pub const FMOD_DEBUG_DISPLAY_LINENUMBERS: FMOD_DEBUG_FLAGS = 0x00020000;
pub const FMOD_DEBUG_DISPLAY_THREAD: FMOD_DEBUG_FLAGS = 0x00040000;
pub type FMOD_MEMORY_TYPE = c_uint;
pub const FMOD_MEMORY_NORMAL: FMOD_MEMORY_TYPE = 0x00000000;
pub const FMOD_MEMORY_STREAM_FILE: FMOD_MEMORY_TYPE = 0x00000001;
pub const FMOD_MEMORY_STREAM_DECODE: FMOD_MEMORY_TYPE = 0x00000002;
pub const FMOD_MEMORY_SAMPLEDATA: FMOD_MEMORY_TYPE = 0x00000004;
pub const FMOD_MEMORY_DSP_BUFFER: FMOD_MEMORY_TYPE = 0x00000008;
pub const FMOD_MEMORY_PLUGIN: FMOD_MEMORY_TYPE = 0x00000010;
pub const FMOD_MEMORY_PERSISTENT: FMOD_MEMORY_TYPE = 0x00200000;
pub const FMOD_MEMORY_ALL: FMOD_MEMORY_TYPE = 0xFFFFFFFF;
pub type FMOD_INITFLAGS = c_uint;
pub const FMOD_INIT_NORMAL: FMOD_INITFLAGS = 0x00000000;
pub const FMOD_INIT_STREAM_FROM_UPDATE: FMOD_INITFLAGS = 0x00000001;
pub const FMOD_INIT_MIX_FROM_UPDATE: FMOD_INITFLAGS = 0x00000002;
pub const FMOD_INIT_3D_RIGHTHANDED: FMOD_INITFLAGS = 0x00000004;
pub const FMOD_INIT_CLIP_OUTPUT: FMOD_INITFLAGS = 0x00000008;
pub const FMOD_INIT_CHANNEL_LOWPASS: FMOD_INITFLAGS = 0x00000100;
pub const FMOD_INIT_CHANNEL_DISTANCEFILTER: FMOD_INITFLAGS = 0x00000200;
pub const FMOD_INIT_PROFILE_ENABLE: FMOD_INITFLAGS = 0x00010000;
pub const FMOD_INIT_VOL0_BECOMES_VIRTUAL: FMOD_INITFLAGS = 0x00020000;
pub const FMOD_INIT_GEOMETRY_USECLOSEST: FMOD_INITFLAGS = 0x00040000;
pub const FMOD_INIT_PREFER_DOLBY_DOWNMIX: FMOD_INITFLAGS = 0x00080000;
pub const FMOD_INIT_THREAD_UNSAFE: FMOD_INITFLAGS = 0x00100000;
pub const FMOD_INIT_PROFILE_METER_ALL: FMOD_INITFLAGS = 0x00200000;
pub const FMOD_INIT_MEMORY_TRACKING: FMOD_INITFLAGS = 0x00400000;
pub type FMOD_DRIVER_STATE = c_uint;
pub const FMOD_DRIVER_STATE_CONNECTED: FMOD_DRIVER_STATE = 0x00000001;
pub const FMOD_DRIVER_STATE_DEFAULT: FMOD_DRIVER_STATE = 0x00000002;
pub type FMOD_TIMEUNIT = c_uint;
pub const FMOD_TIMEUNIT_MS: FMOD_TIMEUNIT = 0x00000001;
pub const FMOD_TIMEUNIT_PCM: FMOD_TIMEUNIT = 0x00000002;
pub const FMOD_TIMEUNIT_PCMBYTES: FMOD_TIMEUNIT = 0x00000004;
pub const FMOD_TIMEUNIT_RAWBYTES: FMOD_TIMEUNIT = 0x00000008;
pub const FMOD_TIMEUNIT_PCMFRACTION: FMOD_TIMEUNIT = 0x00000010;
pub const FMOD_TIMEUNIT_MODORDER: FMOD_TIMEUNIT = 0x00000100;
pub const FMOD_TIMEUNIT_MODROW: FMOD_TIMEUNIT = 0x00000200;
pub const FMOD_TIMEUNIT_MODPATTERN: FMOD_TIMEUNIT = 0x00000400;
pub type FMOD_SYSTEM_CALLBACK_TYPE = c_uint;
pub const FMOD_SYSTEM_CALLBACK_DEVICELISTCHANGED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000001;
pub const FMOD_SYSTEM_CALLBACK_DEVICELOST: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000002;
pub const FMOD_SYSTEM_CALLBACK_MEMORYALLOCATIONFAILED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000004;
pub const FMOD_SYSTEM_CALLBACK_THREADCREATED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000008;
pub const FMOD_SYSTEM_CALLBACK_BADDSPCONNECTION: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000010;
pub const FMOD_SYSTEM_CALLBACK_PREMIX: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000020;
pub const FMOD_SYSTEM_CALLBACK_POSTMIX: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000040;
pub const FMOD_SYSTEM_CALLBACK_ERROR: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000080;
pub const FMOD_SYSTEM_CALLBACK_MIDMIX: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000100;
pub const FMOD_SYSTEM_CALLBACK_THREADDESTROYED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000200;
pub const FMOD_SYSTEM_CALLBACK_PREUPDATE: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000400;
pub const FMOD_SYSTEM_CALLBACK_POSTUPDATE: FMOD_SYSTEM_CALLBACK_TYPE = 0x00000800;
pub const FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00001000;
pub const FMOD_SYSTEM_CALLBACK_BUFFEREDNOMIX: FMOD_SYSTEM_CALLBACK_TYPE = 0x00002000;
pub const FMOD_SYSTEM_CALLBACK_DEVICEREINITIALIZE: FMOD_SYSTEM_CALLBACK_TYPE = 0x00004000;
pub const FMOD_SYSTEM_CALLBACK_OUTPUTUNDERRUN: FMOD_SYSTEM_CALLBACK_TYPE = 0x00008000;
pub const FMOD_SYSTEM_CALLBACK_RECORDPOSITIONCHANGED: FMOD_SYSTEM_CALLBACK_TYPE = 0x00010000;
pub const FMOD_SYSTEM_CALLBACK_ALL: FMOD_SYSTEM_CALLBACK_TYPE = 0xFFFFFFFF;
pub type FMOD_MODE = c_uint;
pub const FMOD_DEFAULT: FMOD_MODE = 0x00000000;
pub const FMOD_LOOP_OFF: FMOD_MODE = 0x00000001;
pub const FMOD_LOOP_NORMAL: FMOD_MODE = 0x00000002;
pub const FMOD_LOOP_BIDI: FMOD_MODE = 0x00000004;
pub const FMOD_2D: FMOD_MODE = 0x00000008;
pub const FMOD_3D: FMOD_MODE = 0x00000010;
pub const FMOD_CREATESTREAM: FMOD_MODE = 0x00000080;
pub const FMOD_CREATESAMPLE: FMOD_MODE = 0x00000100;
pub const FMOD_CREATECOMPRESSEDSAMPLE: FMOD_MODE = 0x00000200;
pub const FMOD_OPENUSER: FMOD_MODE = 0x00000400;
pub const FMOD_OPENMEMORY: FMOD_MODE = 0x00000800;
pub const FMOD_OPENMEMORY_POINT: FMOD_MODE = 0x10000000;
pub const FMOD_OPENRAW: FMOD_MODE = 0x00001000;
pub const FMOD_OPENONLY: FMOD_MODE = 0x00002000;
pub const FMOD_ACCURATETIME: FMOD_MODE = 0x00004000;
pub const FMOD_MPEGSEARCH: FMOD_MODE = 0x00008000;
pub const FMOD_NONBLOCKING: FMOD_MODE = 0x00010000;
pub const FMOD_UNIQUE: FMOD_MODE = 0x00020000;
pub const FMOD_3D_HEADRELATIVE: FMOD_MODE = 0x00040000;
pub const FMOD_3D_WORLDRELATIVE: FMOD_MODE = 0x00080000;
pub const FMOD_3D_INVERSEROLLOFF: FMOD_MODE = 0x00100000;
pub const FMOD_3D_LINEARROLLOFF: FMOD_MODE = 0x00200000;
pub const FMOD_3D_LINEARSQUAREROLLOFF: FMOD_MODE = 0x00400000;
pub const FMOD_3D_INVERSETAPEREDROLLOFF: FMOD_MODE = 0x00800000;
pub const FMOD_3D_CUSTOMROLLOFF: FMOD_MODE = 0x04000000;
pub const FMOD_3D_IGNOREGEOMETRY: FMOD_MODE = 0x40000000;
pub const FMOD_IGNORETAGS: FMOD_MODE = 0x02000000;
pub const FMOD_LOWMEM: FMOD_MODE = 0x08000000;
pub const FMOD_VIRTUAL_PLAYFROMSTART: FMOD_MODE = 0x80000000;
pub type FMOD_CHANNELMASK = c_uint;
pub const FMOD_CHANNELMASK_FRONT_LEFT: FMOD_CHANNELMASK = 0x00000001;
pub const FMOD_CHANNELMASK_FRONT_RIGHT: FMOD_CHANNELMASK = 0x00000002;
pub const FMOD_CHANNELMASK_FRONT_CENTER: FMOD_CHANNELMASK = 0x00000004;
pub const FMOD_CHANNELMASK_LOW_FREQUENCY: FMOD_CHANNELMASK = 0x00000008;
pub const FMOD_CHANNELMASK_SURROUND_LEFT: FMOD_CHANNELMASK = 0x00000010;
pub const FMOD_CHANNELMASK_SURROUND_RIGHT: FMOD_CHANNELMASK = 0x00000020;
pub const FMOD_CHANNELMASK_BACK_LEFT: FMOD_CHANNELMASK = 0x00000040;
pub const FMOD_CHANNELMASK_BACK_RIGHT: FMOD_CHANNELMASK = 0x00000080;
pub const FMOD_CHANNELMASK_BACK_CENTER: FMOD_CHANNELMASK = 0x00000100;
pub const FMOD_CHANNELMASK_MONO: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT);
pub const FMOD_CHANNELMASK_STEREO: FMOD_CHANNELMASK =
    (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT);
pub const FMOD_CHANNELMASK_LRC: FMOD_CHANNELMASK =
    (FMOD_CHANNELMASK_FRONT_LEFT | FMOD_CHANNELMASK_FRONT_RIGHT | FMOD_CHANNELMASK_FRONT_CENTER);
pub const FMOD_CHANNELMASK_QUAD: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_SURROUND_LEFT
    | FMOD_CHANNELMASK_SURROUND_RIGHT);
pub const FMOD_CHANNELMASK_SURROUND: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_FRONT_CENTER
    | FMOD_CHANNELMASK_SURROUND_LEFT
    | FMOD_CHANNELMASK_SURROUND_RIGHT);
pub const FMOD_CHANNELMASK_5POINT1: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_FRONT_CENTER
    | FMOD_CHANNELMASK_LOW_FREQUENCY
    | FMOD_CHANNELMASK_SURROUND_LEFT
    | FMOD_CHANNELMASK_SURROUND_RIGHT);
pub const FMOD_CHANNELMASK_5POINT1_REARS: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_FRONT_CENTER
    | FMOD_CHANNELMASK_LOW_FREQUENCY
    | FMOD_CHANNELMASK_BACK_LEFT
    | FMOD_CHANNELMASK_BACK_RIGHT);
pub const FMOD_CHANNELMASK_7POINT0: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_FRONT_CENTER
    | FMOD_CHANNELMASK_SURROUND_LEFT
    | FMOD_CHANNELMASK_SURROUND_RIGHT
    | FMOD_CHANNELMASK_BACK_LEFT
    | FMOD_CHANNELMASK_BACK_RIGHT);
pub const FMOD_CHANNELMASK_7POINT1: FMOD_CHANNELMASK = (FMOD_CHANNELMASK_FRONT_LEFT
    | FMOD_CHANNELMASK_FRONT_RIGHT
    | FMOD_CHANNELMASK_FRONT_CENTER
    | FMOD_CHANNELMASK_LOW_FREQUENCY
    | FMOD_CHANNELMASK_SURROUND_LEFT
    | FMOD_CHANNELMASK_SURROUND_RIGHT
    | FMOD_CHANNELMASK_BACK_LEFT
    | FMOD_CHANNELMASK_BACK_RIGHT);
pub type FMOD_PORT_INDEX = c_ulonglong;
pub const FMOD_PORT_INDEX_NONE: FMOD_PORT_INDEX = 0xFFFFFFFFFFFFFFFF;
pub const FMOD_PORT_INDEX_FLAG_VR_CONTROLLER: FMOD_PORT_INDEX = 0x1000000000000000;
pub type FMOD_THREAD_PRIORITY = c_int;
pub const FMOD_THREAD_PRIORITY_PLATFORM_MIN: FMOD_THREAD_PRIORITY = (-32 * 1024);
pub const FMOD_THREAD_PRIORITY_PLATFORM_MAX: FMOD_THREAD_PRIORITY = (32 * 1024);
pub const FMOD_THREAD_PRIORITY_DEFAULT: FMOD_THREAD_PRIORITY =
    (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 1);
pub const FMOD_THREAD_PRIORITY_LOW: FMOD_THREAD_PRIORITY = (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 2);
pub const FMOD_THREAD_PRIORITY_MEDIUM: FMOD_THREAD_PRIORITY =
    (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 3);
pub const FMOD_THREAD_PRIORITY_HIGH: FMOD_THREAD_PRIORITY = (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 4);
pub const FMOD_THREAD_PRIORITY_VERY_HIGH: FMOD_THREAD_PRIORITY =
    (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 5);
pub const FMOD_THREAD_PRIORITY_EXTREME: FMOD_THREAD_PRIORITY =
    (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 6);
pub const FMOD_THREAD_PRIORITY_CRITICAL: FMOD_THREAD_PRIORITY =
    (FMOD_THREAD_PRIORITY_PLATFORM_MIN - 7);
pub const FMOD_THREAD_PRIORITY_MIXER: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_EXTREME;
pub const FMOD_THREAD_PRIORITY_FEEDER: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_CRITICAL;
pub const FMOD_THREAD_PRIORITY_STREAM: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_VERY_HIGH;
pub const FMOD_THREAD_PRIORITY_FILE: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_HIGH;
pub const FMOD_THREAD_PRIORITY_NONBLOCKING: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_HIGH;
pub const FMOD_THREAD_PRIORITY_RECORD: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_HIGH;
pub const FMOD_THREAD_PRIORITY_GEOMETRY: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_LOW;
pub const FMOD_THREAD_PRIORITY_PROFILER: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_MEDIUM;
pub const FMOD_THREAD_PRIORITY_STUDIO_UPDATE: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_MEDIUM;
pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_BANK: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_MEDIUM;
pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_SAMPLE: FMOD_THREAD_PRIORITY =
    FMOD_THREAD_PRIORITY_MEDIUM;
pub const FMOD_THREAD_PRIORITY_CONVOLUTION1: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_VERY_HIGH;
pub const FMOD_THREAD_PRIORITY_CONVOLUTION2: FMOD_THREAD_PRIORITY = FMOD_THREAD_PRIORITY_VERY_HIGH;
pub type FMOD_THREAD_STACK_SIZE = c_uint;
pub const FMOD_THREAD_STACK_SIZE_DEFAULT: FMOD_THREAD_STACK_SIZE = 0;
pub const FMOD_THREAD_STACK_SIZE_MIXER: FMOD_THREAD_STACK_SIZE = (80 * 1024);
pub const FMOD_THREAD_STACK_SIZE_FEEDER: FMOD_THREAD_STACK_SIZE = (16 * 1024);
pub const FMOD_THREAD_STACK_SIZE_STREAM: FMOD_THREAD_STACK_SIZE = (96 * 1024);
pub const FMOD_THREAD_STACK_SIZE_FILE: FMOD_THREAD_STACK_SIZE = (64 * 1024);
pub const FMOD_THREAD_STACK_SIZE_NONBLOCKING: FMOD_THREAD_STACK_SIZE = (112 * 1024);
pub const FMOD_THREAD_STACK_SIZE_RECORD: FMOD_THREAD_STACK_SIZE = (16 * 1024);
pub const FMOD_THREAD_STACK_SIZE_GEOMETRY: FMOD_THREAD_STACK_SIZE = (48 * 1024);
pub const FMOD_THREAD_STACK_SIZE_PROFILER: FMOD_THREAD_STACK_SIZE = (128 * 1024);
pub const FMOD_THREAD_STACK_SIZE_STUDIO_UPDATE: FMOD_THREAD_STACK_SIZE = (96 * 1024);
pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_BANK: FMOD_THREAD_STACK_SIZE = (96 * 1024);
pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_SAMPLE: FMOD_THREAD_STACK_SIZE = (96 * 1024);
pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION1: FMOD_THREAD_STACK_SIZE = (16 * 1024);
pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION2: FMOD_THREAD_STACK_SIZE = (16 * 1024);
pub type FMOD_THREAD_AFFINITY = c_longlong;
pub const FMOD_THREAD_AFFINITY_GROUP_DEFAULT: FMOD_THREAD_AFFINITY = 0x4000000000000000;
pub const FMOD_THREAD_AFFINITY_GROUP_A: FMOD_THREAD_AFFINITY = 0x4000000000000001;
pub const FMOD_THREAD_AFFINITY_GROUP_B: FMOD_THREAD_AFFINITY = 0x4000000000000002;
pub const FMOD_THREAD_AFFINITY_GROUP_C: FMOD_THREAD_AFFINITY = 0x4000000000000003;
pub const FMOD_THREAD_AFFINITY_MIXER: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_A;
pub const FMOD_THREAD_AFFINITY_FEEDER: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_STREAM: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_FILE: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_NONBLOCKING: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_RECORD: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_GEOMETRY: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_PROFILER: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_STUDIO_UPDATE: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_B;
pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_BANK: FMOD_THREAD_AFFINITY =
    FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_SAMPLE: FMOD_THREAD_AFFINITY =
    FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_CONVOLUTION1: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_CONVOLUTION2: FMOD_THREAD_AFFINITY = FMOD_THREAD_AFFINITY_GROUP_C;
pub const FMOD_THREAD_AFFINITY_CORE_ALL: FMOD_THREAD_AFFINITY = 0;
pub const FMOD_THREAD_AFFINITY_CORE_0: FMOD_THREAD_AFFINITY = (1 << 0);
pub const FMOD_THREAD_AFFINITY_CORE_1: FMOD_THREAD_AFFINITY = (1 << 1);
pub const FMOD_THREAD_AFFINITY_CORE_2: FMOD_THREAD_AFFINITY = (1 << 2);
pub const FMOD_THREAD_AFFINITY_CORE_3: FMOD_THREAD_AFFINITY = (1 << 3);
pub const FMOD_THREAD_AFFINITY_CORE_4: FMOD_THREAD_AFFINITY = (1 << 4);
pub const FMOD_THREAD_AFFINITY_CORE_5: FMOD_THREAD_AFFINITY = (1 << 5);
pub const FMOD_THREAD_AFFINITY_CORE_6: FMOD_THREAD_AFFINITY = (1 << 6);
pub const FMOD_THREAD_AFFINITY_CORE_7: FMOD_THREAD_AFFINITY = (1 << 7);
pub const FMOD_THREAD_AFFINITY_CORE_8: FMOD_THREAD_AFFINITY = (1 << 8);
pub const FMOD_THREAD_AFFINITY_CORE_9: FMOD_THREAD_AFFINITY = (1 << 9);
pub const FMOD_THREAD_AFFINITY_CORE_10: FMOD_THREAD_AFFINITY = (1 << 10);
pub const FMOD_THREAD_AFFINITY_CORE_11: FMOD_THREAD_AFFINITY = (1 << 11);
pub const FMOD_THREAD_AFFINITY_CORE_12: FMOD_THREAD_AFFINITY = (1 << 12);
pub const FMOD_THREAD_AFFINITY_CORE_13: FMOD_THREAD_AFFINITY = (1 << 13);
pub const FMOD_THREAD_AFFINITY_CORE_14: FMOD_THREAD_AFFINITY = (1 << 14);
pub const FMOD_THREAD_AFFINITY_CORE_15: FMOD_THREAD_AFFINITY = (1 << 15);
pub type FMOD_CODEC_SEEK_METHOD = c_int;
pub const FMOD_CODEC_SEEK_METHOD_SET: FMOD_CODEC_SEEK_METHOD = 0;
pub const FMOD_CODEC_SEEK_METHOD_CURRENT: FMOD_CODEC_SEEK_METHOD = 1;
pub const FMOD_CODEC_SEEK_METHOD_END: FMOD_CODEC_SEEK_METHOD = 2;
pub type FMOD_OUTPUT_METHOD = c_uint;
pub const FMOD_OUTPUT_METHOD_MIX_DIRECT: FMOD_OUTPUT_METHOD = 0;
pub const FMOD_OUTPUT_METHOD_MIX_BUFFERED: FMOD_OUTPUT_METHOD = 1;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_BANK_INFO {
    pub size: c_int,
    pub userdata: *mut c_void,
    pub userdatalength: 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,
}
impl Default for FMOD_STUDIO_BANK_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_PARAMETER_ID {
    pub data1: c_uint,
    pub data2: c_uint,
}
impl Default for FMOD_STUDIO_PARAMETER_ID {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_PARAMETER_DESCRIPTION {
    pub name: *const c_char,
    pub id: FMOD_STUDIO_PARAMETER_ID,
    pub minimum: c_float,
    pub maximum: c_float,
    pub defaultvalue: c_float,
    pub type_: FMOD_STUDIO_PARAMETER_TYPE,
    pub flags: FMOD_STUDIO_PARAMETER_FLAGS,
    pub guid: FMOD_GUID,
}
impl Default for FMOD_STUDIO_PARAMETER_DESCRIPTION {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FMOD_STUDIO_USER_PROPERTY {
    pub name: *const c_char,
    pub type_: FMOD_STUDIO_USER_PROPERTY_TYPE,
    pub union: FMOD_STUDIO_USER_PROPERTY_UNION,
}
impl Default for FMOD_STUDIO_USER_PROPERTY {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FMOD_STUDIO_USER_PROPERTY_UNION {
    pub intvalue: c_int,
    pub boolvalue: FMOD_BOOL,
    pub floatvalue: c_float,
    pub stringvalue: *const c_char,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
    pub name: *const c_char,
    pub sound: *mut FMOD_SOUND,
    pub subsoundIndex: c_int,
}
impl Default for FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
    pub name: *const c_char,
    pub dsp: *mut FMOD_DSP,
}
impl Default for FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
    pub name: *const c_char,
    pub position: c_int,
}
impl Default for FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
    pub bar: c_int,
    pub beat: c_int,
    pub position: c_int,
    pub tempo: c_float,
    pub timesignatureupper: c_int,
    pub timesignaturelower: c_int,
}
impl Default for FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
    pub eventid: FMOD_GUID,
    pub properties: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
}
impl Default for FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_ADVANCEDSETTINGS {
    pub cbsize: c_int,
    pub commandqueuesize: c_uint,
    pub handleinitialsize: c_uint,
    pub studioupdateperiod: c_int,
    pub idlesampledatapoolsize: c_int,
    pub streamingscheduledelay: c_uint,
    pub encryptionkey: *const c_char,
}
impl Default for FMOD_STUDIO_ADVANCEDSETTINGS {
    fn default() -> Self {
        let mut value: Self = unsafe { std::mem::zeroed() };
        value.cbsize = std::mem::size_of::<FMOD_STUDIO_ADVANCEDSETTINGS>() as _;
        value
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_CPU_USAGE {
    pub update: c_float,
}
impl Default for FMOD_STUDIO_CPU_USAGE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_BUFFER_INFO {
    pub currentusage: c_int,
    pub peakusage: c_int,
    pub capacity: c_int,
    pub stallcount: c_int,
    pub stalltime: c_float,
}
impl Default for FMOD_STUDIO_BUFFER_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_BUFFER_USAGE {
    pub studiocommandqueue: FMOD_STUDIO_BUFFER_INFO,
    pub studiohandle: FMOD_STUDIO_BUFFER_INFO,
}
impl Default for FMOD_STUDIO_BUFFER_USAGE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_SOUND_INFO {
    pub name_or_data: *const c_char,
    pub mode: FMOD_MODE,
    pub exinfo: FMOD_CREATESOUNDEXINFO,
    pub subsoundindex: c_int,
}
impl Default for FMOD_STUDIO_SOUND_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_COMMAND_INFO {
    pub commandname: *const c_char,
    pub parentcommandindex: c_int,
    pub framenumber: c_int,
    pub frametime: c_float,
    pub instancetype: FMOD_STUDIO_INSTANCETYPE,
    pub outputtype: FMOD_STUDIO_INSTANCETYPE,
    pub instancehandle: c_uint,
    pub outputhandle: c_uint,
}
impl Default for FMOD_STUDIO_COMMAND_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_STUDIO_MEMORY_USAGE {
    pub exclusive: c_int,
    pub inclusive: c_int,
    pub sampledata: c_int,
}
impl Default for FMOD_STUDIO_MEMORY_USAGE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_ASYNCREADINFO {
    pub handle: *mut c_void,
    pub offset: c_uint,
    pub sizebytes: c_uint,
    pub priority: c_int,
    pub userdata: *mut c_void,
    pub buffer: *mut c_void,
    pub bytesread: c_uint,
    pub done: FMOD_FILE_ASYNCDONE_FUNC,
}
impl Default for FMOD_ASYNCREADINFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_VECTOR {
    pub x: c_float,
    pub y: c_float,
    pub z: c_float,
}
impl Default for FMOD_VECTOR {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_3D_ATTRIBUTES {
    pub position: FMOD_VECTOR,
    pub velocity: FMOD_VECTOR,
    pub forward: FMOD_VECTOR,
    pub up: FMOD_VECTOR,
}
impl Default for FMOD_3D_ATTRIBUTES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_GUID {
    pub Data1: c_uint,
    pub Data2: c_ushort,
    pub Data3: c_ushort,
    pub Data4: [c_uchar; 8 as usize],
}
impl Default for FMOD_GUID {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_PLUGINLIST {
    pub type_: FMOD_PLUGINTYPE,
    pub description: *mut c_void,
}
impl Default for FMOD_PLUGINLIST {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_ADVANCEDSETTINGS {
    pub cbSize: c_int,
    pub maxMPEGCodecs: c_int,
    pub maxADPCMCodecs: c_int,
    pub maxXMACodecs: c_int,
    pub maxVorbisCodecs: c_int,
    pub maxAT9Codecs: c_int,
    pub maxFADPCMCodecs: c_int,
    pub maxPCMCodecs: c_int,
    pub ASIONumChannels: c_int,
    pub ASIOChannelList: *mut *mut c_char,
    pub ASIOSpeakerList: *mut FMOD_SPEAKER,
    pub vol0virtualvol: c_float,
    pub defaultDecodeBufferSize: c_uint,
    pub profilePort: c_ushort,
    pub geometryMaxFadeTime: c_uint,
    pub distanceFilterCenterFreq: c_float,
    pub reverb3Dinstance: c_int,
    pub DSPBufferPoolSize: c_int,
    pub resamplerMethod: FMOD_DSP_RESAMPLER,
    pub randomSeed: c_uint,
    pub maxConvolutionThreads: c_int,
    pub maxOpusCodecs: c_int,
    pub maxSpatialObjects: c_int,
}
impl Default for FMOD_ADVANCEDSETTINGS {
    fn default() -> Self {
        let mut value: Self = unsafe { std::mem::zeroed() };
        value.cbSize = std::mem::size_of::<FMOD_ADVANCEDSETTINGS>() as _;
        value
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_TAG {
    pub type_: FMOD_TAGTYPE,
    pub datatype: FMOD_TAGDATATYPE,
    pub name: *mut c_char,
    pub data: *mut c_void,
    pub datalen: c_uint,
    pub updated: FMOD_BOOL,
}
impl Default for FMOD_TAG {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CREATESOUNDEXINFO {
    pub cbsize: c_int,
    pub length: c_uint,
    pub fileoffset: c_uint,
    pub numchannels: c_int,
    pub defaultfrequency: c_int,
    pub format: FMOD_SOUND_FORMAT,
    pub decodebuffersize: c_uint,
    pub initialsubsound: c_int,
    pub numsubsounds: c_int,
    pub inclusionlist: *mut c_int,
    pub inclusionlistnum: c_int,
    pub pcmreadcallback: FMOD_SOUND_PCMREAD_CALLBACK,
    pub pcmsetposcallback: FMOD_SOUND_PCMSETPOS_CALLBACK,
    pub nonblockcallback: FMOD_SOUND_NONBLOCK_CALLBACK,
    pub dlsname: *const c_char,
    pub encryptionkey: *const c_char,
    pub maxpolyphony: c_int,
    pub userdata: *mut 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 c_void,
    pub filebuffersize: c_int,
    pub channelorder: FMOD_CHANNELORDER,
    pub initialsoundgroup: *mut FMOD_SOUNDGROUP,
    pub initialseekposition: c_uint,
    pub initialseekpostype: FMOD_TIMEUNIT,
    pub ignoresetfilesystem: c_int,
    pub audioqueuepolicy: c_uint,
    pub minmidigranularity: c_uint,
    pub nonblockthreadid: c_int,
    pub fsbguid: *mut FMOD_GUID,
}
impl Default for FMOD_CREATESOUNDEXINFO {
    fn default() -> Self {
        let mut value: Self = unsafe { std::mem::zeroed() };
        value.cbsize = std::mem::size_of::<FMOD_CREATESOUNDEXINFO>() as _;
        value
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_REVERB_PROPERTIES {
    pub DecayTime: c_float,
    pub EarlyDelay: c_float,
    pub LateDelay: c_float,
    pub HFReference: c_float,
    pub HFDecayRatio: c_float,
    pub Diffusion: c_float,
    pub Density: c_float,
    pub LowShelfFrequency: c_float,
    pub LowShelfGain: c_float,
    pub HighCut: c_float,
    pub EarlyLateMix: c_float,
    pub WetLevel: c_float,
}
impl Default for FMOD_REVERB_PROPERTIES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_ERRORCALLBACK_INFO {
    pub result: FMOD_RESULT,
    pub instancetype: FMOD_ERRORCALLBACK_INSTANCETYPE,
    pub instance: *mut c_void,
    pub functionname: *const c_char,
    pub functionparams: *const c_char,
}
impl Default for FMOD_ERRORCALLBACK_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CPU_USAGE {
    pub dsp: c_float,
    pub stream: c_float,
    pub geometry: c_float,
    pub update: c_float,
    pub convolution1: c_float,
    pub convolution2: c_float,
}
impl Default for FMOD_CPU_USAGE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_DATA_PARAMETER_INFO {
    pub data: *mut c_void,
    pub length: c_uint,
    pub index: c_int,
}
impl Default for FMOD_DSP_DATA_PARAMETER_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CODEC_DESCRIPTION {
    pub apiversion: c_uint,
    pub name: *const c_char,
    pub version: c_uint,
    pub defaultasstream: 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,
}
impl Default for FMOD_CODEC_DESCRIPTION {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CODEC_WAVEFORMAT {
    pub name: *const c_char,
    pub format: FMOD_SOUND_FORMAT,
    pub channels: c_int,
    pub frequency: c_int,
    pub lengthbytes: c_uint,
    pub lengthpcm: c_uint,
    pub pcmblocksize: c_uint,
    pub loopstart: c_int,
    pub loopend: c_int,
    pub mode: FMOD_MODE,
    pub channelmask: FMOD_CHANNELMASK,
    pub channelorder: FMOD_CHANNELORDER,
    pub peakvolume: c_float,
}
impl Default for FMOD_CODEC_WAVEFORMAT {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
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,
}
impl Default for FMOD_CODEC_STATE_FUNCTIONS {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_CODEC_STATE {
    pub plugindata: *mut c_void,
    pub waveformat: *mut FMOD_CODEC_WAVEFORMAT,
    pub functions: *mut FMOD_CODEC_STATE_FUNCTIONS,
    pub numsubsounds: c_int,
}
impl Default for FMOD_CODEC_STATE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_OUTPUT_DESCRIPTION {
    pub apiversion: c_uint,
    pub name: *const c_char,
    pub version: 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,
}
impl Default for FMOD_OUTPUT_DESCRIPTION {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_OUTPUT_STATE {
    pub plugindata: *mut 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,
}
impl Default for FMOD_OUTPUT_STATE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_OUTPUT_OBJECT3DINFO {
    pub buffer: *mut c_float,
    pub bufferlength: c_uint,
    pub position: FMOD_VECTOR,
    pub gain: c_float,
    pub spread: c_float,
    pub priority: c_float,
}
impl Default for FMOD_OUTPUT_OBJECT3DINFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_BUFFER_ARRAY {
    pub numbuffers: c_int,
    pub buffernumchannels: *mut c_int,
    pub bufferchannelmask: *mut FMOD_CHANNELMASK,
    pub buffers: *mut *mut c_float,
    pub speakermode: FMOD_SPEAKERMODE,
}
impl Default for FMOD_DSP_BUFFER_ARRAY {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_COMPLEX {
    pub real: c_float,
    pub imag: c_float,
}
impl Default for FMOD_COMPLEX {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
    pub numpoints: c_int,
    pub pointparamvalues: *mut c_float,
    pub pointpositions: *mut c_float,
}
impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING {
    pub type_: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE,
    pub piecewiselinearmapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
}
impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC_FLOAT {
    pub min: c_float,
    pub max: c_float,
    pub defaultval: c_float,
    pub mapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING,
}
impl Default for FMOD_DSP_PARAMETER_DESC_FLOAT {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC_INT {
    pub min: c_int,
    pub max: c_int,
    pub defaultval: c_int,
    pub goestoinf: FMOD_BOOL,
    pub valuenames: *const *const c_char,
}
impl Default for FMOD_DSP_PARAMETER_DESC_INT {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC_BOOL {
    pub defaultval: FMOD_BOOL,
    pub valuenames: *const *const c_char,
}
impl Default for FMOD_DSP_PARAMETER_DESC_BOOL {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC_DATA {
    pub datatype: c_int,
}
impl Default for FMOD_DSP_PARAMETER_DESC_DATA {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_DESC {
    pub type_: FMOD_DSP_PARAMETER_TYPE,
    pub name: [c_char; 16 as usize],
    pub label: [c_char; 16 as usize],
    pub description: *const c_char,
    pub union: FMOD_DSP_PARAMETER_DESC_UNION,
}
impl Default for FMOD_DSP_PARAMETER_DESC {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union FMOD_DSP_PARAMETER_DESC_UNION {
    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,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_OVERALLGAIN {
    pub linear_gain: c_float,
    pub linear_gain_additive: c_float,
}
impl Default for FMOD_DSP_PARAMETER_OVERALLGAIN {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES {
    pub relative: FMOD_3D_ATTRIBUTES,
    pub absolute: FMOD_3D_ATTRIBUTES,
}
impl Default for FMOD_DSP_PARAMETER_3DATTRIBUTES {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
    pub numlisteners: c_int,
    pub relative: [FMOD_3D_ATTRIBUTES; FMOD_MAX_LISTENERS as usize],
    pub weight: [c_float; FMOD_MAX_LISTENERS as usize],
    pub absolute: FMOD_3D_ATTRIBUTES,
}
impl Default for FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
    pub min: c_float,
    pub max: c_float,
}
impl Default for FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_SIDECHAIN {
    pub sidechainenable: FMOD_BOOL,
}
impl Default for FMOD_DSP_PARAMETER_SIDECHAIN {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_PARAMETER_FFT {
    pub length: c_int,
    pub numchannels: c_int,
    pub spectrum: [*mut c_float; 32 as usize],
}
impl Default for FMOD_DSP_PARAMETER_FFT {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_DESCRIPTION {
    pub pluginsdkversion: c_uint,
    pub name: [c_char; 32 as usize],
    pub version: c_uint,
    pub numinputbuffers: c_int,
    pub numoutputbuffers: 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: 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 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,
}
impl Default for FMOD_DSP_DESCRIPTION {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_STATE_DFT_FUNCTIONS {
    pub fftreal: FMOD_DSP_DFT_FFTREAL_FUNC,
    pub inversefftreal: FMOD_DSP_DFT_IFFTREAL_FUNC,
}
impl Default for FMOD_DSP_STATE_DFT_FUNCTIONS {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
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,
}
impl Default for FMOD_DSP_STATE_PAN_FUNCTIONS {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
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,
}
impl Default for FMOD_DSP_STATE_FUNCTIONS {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_STATE {
    pub instance: *mut c_void,
    pub plugindata: *mut c_void,
    pub channelmask: FMOD_CHANNELMASK,
    pub source_speakermode: FMOD_SPEAKERMODE,
    pub sidechaindata: *mut c_float,
    pub sidechainchannels: c_int,
    pub functions: *mut FMOD_DSP_STATE_FUNCTIONS,
    pub systemobject: c_int,
}
impl Default for FMOD_DSP_STATE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_METERING_INFO {
    pub numsamples: c_int,
    pub peaklevel: [c_float; 32 as usize],
    pub rmslevel: [c_float; 32 as usize],
    pub numchannels: c_short,
}
impl Default for FMOD_DSP_METERING_INFO {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
    pub momentaryloudness: c_float,
    pub shorttermloudness: c_float,
    pub integratedloudness: c_float,
    pub loudness10thpercentile: c_float,
    pub loudness95thpercentile: c_float,
    pub loudnesshistogram: [c_float; FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES as usize],
    pub maxtruepeak: c_float,
    pub maxmomentaryloudness: c_float,
}
impl Default for FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
    pub channelweight: [c_float; 32 as usize],
}
impl Default for FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
    fn default() -> Self {
        unsafe { std::mem::zeroed() }
    }
}
pub const FMOD_PRESET_OFF: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1000.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 100.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 20.0,
    EarlyLateMix: 96.0,
    WetLevel: -80.0,
};
pub const FMOD_PRESET_GENERIC: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 83.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 14500.0,
    EarlyLateMix: 96.0,
    WetLevel: -8.0,
};
pub const FMOD_PRESET_PADDEDCELL: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 170.0,
    EarlyDelay: 1.0,
    LateDelay: 2.0,
    HFReference: 5000.0,
    HFDecayRatio: 10.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 160.0,
    EarlyLateMix: 84.0,
    WetLevel: -7.8,
};
pub const FMOD_PRESET_ROOM: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 400.0,
    EarlyDelay: 2.0,
    LateDelay: 3.0,
    HFReference: 5000.0,
    HFDecayRatio: 83.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 6050.0,
    EarlyLateMix: 88.0,
    WetLevel: -9.4,
};
pub const FMOD_PRESET_BATHROOM: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 54.0,
    Diffusion: 100.0,
    Density: 60.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 2900.0,
    EarlyLateMix: 83.0,
    WetLevel: 0.5,
};
pub const FMOD_PRESET_LIVINGROOM: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 500.0,
    EarlyDelay: 3.0,
    LateDelay: 4.0,
    HFReference: 5000.0,
    HFDecayRatio: 10.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 160.0,
    EarlyLateMix: 58.0,
    WetLevel: -19.0,
};
pub const FMOD_PRESET_STONEROOM: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 2300.0,
    EarlyDelay: 12.0,
    LateDelay: 17.0,
    HFReference: 5000.0,
    HFDecayRatio: 64.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 7800.0,
    EarlyLateMix: 71.0,
    WetLevel: -8.5,
};
pub const FMOD_PRESET_AUDITORIUM: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 4300.0,
    EarlyDelay: 20.0,
    LateDelay: 30.0,
    HFReference: 5000.0,
    HFDecayRatio: 59.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 5850.0,
    EarlyLateMix: 64.0,
    WetLevel: -11.7,
};
pub const FMOD_PRESET_CONCERTHALL: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 3900.0,
    EarlyDelay: 20.0,
    LateDelay: 29.0,
    HFReference: 5000.0,
    HFDecayRatio: 70.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 5650.0,
    EarlyLateMix: 80.0,
    WetLevel: -9.8,
};
pub const FMOD_PRESET_CAVE: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 2900.0,
    EarlyDelay: 15.0,
    LateDelay: 22.0,
    HFReference: 5000.0,
    HFDecayRatio: 100.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 20000.0,
    EarlyLateMix: 59.0,
    WetLevel: -11.3,
};
pub const FMOD_PRESET_ARENA: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 7200.0,
    EarlyDelay: 20.0,
    LateDelay: 30.0,
    HFReference: 5000.0,
    HFDecayRatio: 33.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 4500.0,
    EarlyLateMix: 80.0,
    WetLevel: -9.6,
};
pub const FMOD_PRESET_HANGAR: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 10000.0,
    EarlyDelay: 20.0,
    LateDelay: 30.0,
    HFReference: 5000.0,
    HFDecayRatio: 23.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 3400.0,
    EarlyLateMix: 72.0,
    WetLevel: -7.4,
};
pub const FMOD_PRESET_CARPETTEDHALLWAY: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 300.0,
    EarlyDelay: 2.0,
    LateDelay: 30.0,
    HFReference: 5000.0,
    HFDecayRatio: 10.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 500.0,
    EarlyLateMix: 56.0,
    WetLevel: -24.0,
};
pub const FMOD_PRESET_HALLWAY: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 59.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 7800.0,
    EarlyLateMix: 87.0,
    WetLevel: -5.5,
};
pub const FMOD_PRESET_STONECORRIDOR: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 270.0,
    EarlyDelay: 13.0,
    LateDelay: 20.0,
    HFReference: 5000.0,
    HFDecayRatio: 79.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 9000.0,
    EarlyLateMix: 86.0,
    WetLevel: -6.0,
};
pub const FMOD_PRESET_ALLEY: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 86.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 8300.0,
    EarlyLateMix: 80.0,
    WetLevel: -9.8,
};
pub const FMOD_PRESET_FOREST: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 162.0,
    LateDelay: 88.0,
    HFReference: 5000.0,
    HFDecayRatio: 54.0,
    Diffusion: 79.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 760.0,
    EarlyLateMix: 94.0,
    WetLevel: -12.3,
};
pub const FMOD_PRESET_CITY: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 67.0,
    Diffusion: 50.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 4050.0,
    EarlyLateMix: 66.0,
    WetLevel: -26.0,
};
pub const FMOD_PRESET_MOUNTAINS: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 300.0,
    LateDelay: 100.0,
    HFReference: 5000.0,
    HFDecayRatio: 21.0,
    Diffusion: 27.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 1220.0,
    EarlyLateMix: 82.0,
    WetLevel: -24.0,
};
pub const FMOD_PRESET_QUARRY: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 61.0,
    LateDelay: 25.0,
    HFReference: 5000.0,
    HFDecayRatio: 83.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 3400.0,
    EarlyLateMix: 100.0,
    WetLevel: -5.0,
};
pub const FMOD_PRESET_PLAIN: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 179.0,
    LateDelay: 100.0,
    HFReference: 5000.0,
    HFDecayRatio: 50.0,
    Diffusion: 21.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 1670.0,
    EarlyLateMix: 65.0,
    WetLevel: -28.0,
};
pub const FMOD_PRESET_PARKINGLOT: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1700.0,
    EarlyDelay: 8.0,
    LateDelay: 12.0,
    HFReference: 5000.0,
    HFDecayRatio: 100.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 20000.0,
    EarlyLateMix: 56.0,
    WetLevel: -19.5,
};
pub const FMOD_PRESET_SEWERPIPE: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 2800.0,
    EarlyDelay: 14.0,
    LateDelay: 21.0,
    HFReference: 5000.0,
    HFDecayRatio: 14.0,
    Diffusion: 80.0,
    Density: 60.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 3400.0,
    EarlyLateMix: 66.0,
    WetLevel: 1.2,
};
pub const FMOD_PRESET_UNDERWATER: FMOD_REVERB_PROPERTIES = FMOD_REVERB_PROPERTIES {
    DecayTime: 1500.0,
    EarlyDelay: 7.0,
    LateDelay: 11.0,
    HFReference: 5000.0,
    HFDecayRatio: 10.0,
    Diffusion: 100.0,
    Density: 100.0,
    LowShelfFrequency: 250.0,
    LowShelfGain: 0.0,
    HighCut: 500.0,
    EarlyLateMix: 92.0,
    WetLevel: 7.0,
};
pub type FMOD_STUDIO_SYSTEM_CALLBACK = Option<
    unsafe extern "C" fn(
        system: *mut FMOD_STUDIO_SYSTEM,
        type_: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
        commanddata: *mut c_void,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_EVENT_CALLBACK = Option<
    unsafe extern "C" fn(
        type_: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
        event: *mut FMOD_STUDIO_EVENTINSTANCE,
        parameters: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK = Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
        currenttime: c_float,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK = Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
        bankguid: *const FMOD_GUID,
        bankfilename: *const c_char,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK = Option<
    unsafe extern "C" fn(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DEBUG_CALLBACK = Option<
    unsafe extern "C" fn(
        flags: FMOD_DEBUG_FLAGS,
        file: *const c_char,
        line: c_int,
        func: *const c_char,
        message: *const c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_SYSTEM_CALLBACK = Option<
    unsafe extern "C" fn(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_SYSTEM_CALLBACK_TYPE,
        commanddata1: *mut c_void,
        commanddata2: *mut c_void,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CHANNELCONTROL_CALLBACK = Option<
    unsafe extern "C" fn(
        channelcontrol: *mut FMOD_CHANNELCONTROL,
        controltype: FMOD_CHANNELCONTROL_TYPE,
        callbacktype: FMOD_CHANNELCONTROL_CALLBACK_TYPE,
        commanddata1: *mut c_void,
        commanddata2: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp: *mut FMOD_DSP,
        type_: FMOD_DSP_CALLBACK_TYPE,
        data: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_SOUND_NONBLOCK_CALLBACK =
    Option<unsafe extern "C" fn(sound: *mut FMOD_SOUND, result: FMOD_RESULT) -> FMOD_RESULT>;
pub type FMOD_SOUND_PCMREAD_CALLBACK = Option<
    unsafe extern "C" fn(sound: *mut FMOD_SOUND, data: *mut c_void, datalen: c_uint) -> FMOD_RESULT,
>;
pub type FMOD_SOUND_PCMSETPOS_CALLBACK = Option<
    unsafe extern "C" fn(
        sound: *mut FMOD_SOUND,
        subsound: c_int,
        position: c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_OPEN_CALLBACK = Option<
    unsafe extern "C" fn(
        name: *const c_char,
        filesize: *mut c_uint,
        handle: *mut *mut c_void,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_CLOSE_CALLBACK =
    Option<unsafe extern "C" fn(handle: *mut c_void, userdata: *mut c_void) -> FMOD_RESULT>;
pub type FMOD_FILE_READ_CALLBACK = Option<
    unsafe extern "C" fn(
        handle: *mut c_void,
        buffer: *mut c_void,
        sizebytes: c_uint,
        bytesread: *mut c_uint,
        userdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_FILE_SEEK_CALLBACK = Option<
    unsafe extern "C" fn(handle: *mut c_void, pos: c_uint, userdata: *mut c_void) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCREAD_CALLBACK = Option<
    unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, userdata: *mut c_void) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCCANCEL_CALLBACK = Option<
    unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, userdata: *mut c_void) -> FMOD_RESULT,
>;
pub type FMOD_FILE_ASYNCDONE_FUNC =
    Option<unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, result: FMOD_RESULT)>;
pub type FMOD_MEMORY_ALLOC_CALLBACK = Option<
    unsafe extern "C" fn(
        size: c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const c_char,
    ) -> *mut c_void,
>;
pub type FMOD_MEMORY_REALLOC_CALLBACK = Option<
    unsafe extern "C" fn(
        ptr: *mut c_void,
        size: c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const c_char,
    ) -> *mut c_void,
>;
pub type FMOD_MEMORY_FREE_CALLBACK = Option<
    unsafe extern "C" fn(ptr: *mut c_void, type_: FMOD_MEMORY_TYPE, sourcestr: *const c_char),
>;
pub type FMOD_3D_ROLLOFF_CALLBACK = Option<
    unsafe extern "C" fn(channelcontrol: *mut FMOD_CHANNELCONTROL, distance: c_float) -> c_float,
>;
pub type FMOD_CODEC_OPEN_CALLBACK = 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 =
    Option<unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE) -> FMOD_RESULT>;
pub type FMOD_CODEC_READ_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        buffer: *mut c_void,
        samples_in: c_uint,
        samples_out: *mut c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETLENGTH_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        length: *mut c_uint,
        lengthtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_SETPOSITION_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        subsound: c_int,
        position: c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETPOSITION_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        position: *mut c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_SOUNDCREATE_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        subsound: c_int,
        sound: *mut FMOD_SOUND,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_GETWAVEFORMAT_CALLBACK = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        index: c_int,
        waveformat: *mut FMOD_CODEC_WAVEFORMAT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_METADATA_FUNC = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        tagtype: FMOD_TAGTYPE,
        name: *mut c_char,
        data: *mut c_void,
        datalen: c_uint,
        datatype: FMOD_TAGDATATYPE,
        unique: c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_ALLOC_FUNC = Option<
    unsafe extern "C" fn(
        size: c_uint,
        align: c_uint,
        file: *const c_char,
        line: c_int,
    ) -> *mut c_void,
>;
pub type FMOD_CODEC_FREE_FUNC =
    Option<unsafe extern "C" fn(ptr: *mut c_void, file: *const c_char, line: c_int)>;
pub type FMOD_CODEC_LOG_FUNC = Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const c_char,
        line: c_int,
        function: *const c_char,
        string: *const c_char,
        ...
    ),
>;
pub type FMOD_CODEC_FILE_READ_FUNC = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        buffer: *mut c_void,
        sizebytes: c_uint,
        bytesread: *mut c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_SEEK_FUNC = Option<
    unsafe extern "C" fn(
        codec_state: *mut FMOD_CODEC_STATE,
        pos: c_uint,
        method: FMOD_CODEC_SEEK_METHOD,
    ) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_TELL_FUNC = Option<
    unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE, pos: *mut c_uint) -> FMOD_RESULT,
>;
pub type FMOD_CODEC_FILE_SIZE_FUNC = Option<
    unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE, size: *mut c_uint) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        numdrivers: *mut c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_GETDRIVERINFO_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        id: c_int,
        name: *mut c_char,
        namelen: c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_INIT_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        selecteddriver: c_int,
        flags: FMOD_INITFLAGS,
        outputrate: *mut c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut c_int,
        outputformat: *mut FMOD_SOUND_FORMAT,
        dspbufferlength: c_int,
        dspnumbuffers: *mut c_int,
        dspnumadditionalbuffers: *mut c_int,
        extradriverdata: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_START_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_STOP_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_CLOSE_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_UPDATE_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_GETHANDLE_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        handle: *mut *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_MIXER_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        maxhardwareobjects: *mut c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DFREE_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut c_void,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        object3d: *mut c_void,
        info: *const FMOD_OUTPUT_OBJECT3DINFO,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_OPENPORT_CALLBACK = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        portType: FMOD_PORT_TYPE,
        portIndex: FMOD_PORT_INDEX,
        portId: *mut c_int,
        portRate: *mut c_int,
        portChannels: *mut c_int,
        portFormat: *mut FMOD_SOUND_FORMAT,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_CLOSEPORT_CALLBACK = Option<
    unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE, portId: c_int) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_READFROMMIXER_FUNC = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        buffer: *mut c_void,
        length: c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_COPYPORT_FUNC = Option<
    unsafe extern "C" fn(
        output_state: *mut FMOD_OUTPUT_STATE,
        portId: c_int,
        buffer: *mut c_void,
        length: c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_OUTPUT_REQUESTRESET_FUNC =
    Option<unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT>;
pub type FMOD_OUTPUT_ALLOC_FUNC = Option<
    unsafe extern "C" fn(
        size: c_uint,
        align: c_uint,
        file: *const c_char,
        line: c_int,
    ) -> *mut c_void,
>;
pub type FMOD_OUTPUT_FREE_FUNC =
    Option<unsafe extern "C" fn(ptr: *mut c_void, file: *const c_char, line: c_int)>;
pub type FMOD_OUTPUT_LOG_FUNC = Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const c_char,
        line: c_int,
        function: *const c_char,
        string: *const c_char,
        ...
    ),
>;
pub type FMOD_DSP_CREATE_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_RELEASE_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_RESET_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_READ_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        inbuffer: *mut c_float,
        outbuffer: *mut c_float,
        length: c_uint,
        inchannels: c_int,
        outchannels: *mut c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PROCESS_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        length: 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 =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, pos: c_uint) -> FMOD_RESULT>;
pub type FMOD_DSP_SHOULDIPROCESS_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        inputsidle: FMOD_BOOL,
        length: c_uint,
        inmask: FMOD_CHANNELMASK,
        inchannels: c_int,
        speakermode: FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_FLOAT_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        value: c_float,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_INT_CALLBACK = Option<
    unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, index: c_int, value: c_int) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_BOOL_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        value: FMOD_BOOL,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SETPARAM_DATA_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        data: *mut c_void,
        length: c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_FLOAT_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        value: *mut c_float,
        valuestr: *mut c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_INT_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        value: *mut c_int,
        valuestr: *mut c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_BOOL_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        value: *mut FMOD_BOOL,
        valuestr: *mut c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETPARAM_DATA_CALLBACK = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        index: c_int,
        data: *mut *mut c_void,
        length: *mut c_uint,
        valuestr: *mut c_char,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_SYSTEM_REGISTER_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
pub type FMOD_DSP_SYSTEM_MIX_CALLBACK =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, stage: c_int) -> FMOD_RESULT>;
pub type FMOD_DSP_ALLOC_FUNC = Option<
    unsafe extern "C" fn(
        size: c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const c_char,
    ) -> *mut c_void,
>;
pub type FMOD_DSP_REALLOC_FUNC = Option<
    unsafe extern "C" fn(
        ptr: *mut c_void,
        size: c_uint,
        type_: FMOD_MEMORY_TYPE,
        sourcestr: *const c_char,
    ) -> *mut c_void,
>;
pub type FMOD_DSP_FREE_FUNC = Option<
    unsafe extern "C" fn(ptr: *mut c_void, type_: FMOD_MEMORY_TYPE, sourcestr: *const c_char),
>;
pub type FMOD_DSP_LOG_FUNC = Option<
    unsafe extern "C" fn(
        level: FMOD_DEBUG_FLAGS,
        file: *const c_char,
        line: c_int,
        function: *const c_char,
        str: *const c_char,
        ...
    ),
>;
pub type FMOD_DSP_GETSAMPLERATE_FUNC =
    Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, rate: *mut c_int) -> FMOD_RESULT>;
pub type FMOD_DSP_GETBLOCKSIZE_FUNC = Option<
    unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, blocksize: *mut c_uint) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETSPEAKERMODE_FUNC = 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 = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        clock: *mut c_ulonglong,
        offset: *mut c_uint,
        length: *mut c_uint,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETLISTENERATTRIBUTES_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        numlisteners: *mut c_int,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_GETUSERDATA_FUNC = Option<
    unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE, userdata: *mut *mut c_void) -> FMOD_RESULT,
>;
pub type FMOD_DSP_DFT_FFTREAL_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        size: c_int,
        signal: *const c_float,
        dft: *mut FMOD_COMPLEX,
        window: *const c_float,
        signalhop: c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_DFT_IFFTREAL_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        size: c_int,
        dft: *const FMOD_COMPLEX,
        signal: *mut c_float,
        window: *const c_float,
        signalhop: c_int,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMMONOMATRIX_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        lowFrequencyGain: c_float,
        overallGain: c_float,
        matrix: *mut c_float,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        pan: c_float,
        lowFrequencyGain: c_float,
        overallGain: c_float,
        matrixHop: c_int,
        matrix: *mut c_float,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        sourceSpeakerMode: FMOD_SPEAKERMODE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: c_float,
        extent: c_float,
        rotation: c_float,
        lowFrequencyGain: c_float,
        overallGain: c_float,
        matrixHop: c_int,
        matrix: *mut c_float,
        flags: FMOD_DSP_PAN_SURROUND_FLAGS,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: c_float,
        extent: c_float,
        lowFrequencyGain: c_float,
        overallGain: c_float,
        matrixHop: c_int,
        matrix: *mut c_float,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        targetSpeakerMode: FMOD_SPEAKERMODE,
        direction: c_float,
        extent: c_float,
        rotation: c_float,
        lowFrequencyGain: c_float,
        overallGain: c_float,
        matrixHop: c_int,
        matrix: *mut c_float,
    ) -> FMOD_RESULT,
>;
pub type FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC = Option<
    unsafe extern "C" fn(
        dsp_state: *mut FMOD_DSP_STATE,
        rolloff: FMOD_DSP_PAN_3D_ROLLOFF_TYPE,
        distance: c_float,
        mindistance: c_float,
        maxdistance: c_float,
        gain: *mut c_float,
    ) -> FMOD_RESULT,
>;
extern "C" {
    pub fn FMOD_Studio_ParseID(idstring: *const c_char, id: *mut FMOD_GUID) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_Create(
        system: *mut *mut FMOD_STUDIO_SYSTEM,
        headerversion: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_IsValid(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_BOOL;
    pub fn FMOD_Studio_System_SetAdvancedSettings(
        system: *mut FMOD_STUDIO_SYSTEM,
        settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetAdvancedSettings(
        system: *mut FMOD_STUDIO_SYSTEM,
        settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_Initialize(
        system: *mut FMOD_STUDIO_SYSTEM,
        maxchannels: c_int,
        studioflags: FMOD_STUDIO_INITFLAGS,
        flags: FMOD_INITFLAGS,
        extradriverdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_Release(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_Update(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetCoreSystem(
        system: *mut FMOD_STUDIO_SYSTEM,
        coresystem: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetEvent(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const c_char,
        event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBus(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const c_char,
        bus: *mut *mut FMOD_STUDIO_BUS,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetVCA(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const c_char,
        vca: *mut *mut FMOD_STUDIO_VCA,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBank(
        system: *mut FMOD_STUDIO_SYSTEM,
        pathOrID: *const c_char,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetEventByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBusByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        bus: *mut *mut FMOD_STUDIO_BUS,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetVCAByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        vca: *mut *mut FMOD_STUDIO_VCA,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBankByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetSoundInfo(
        system: *mut FMOD_STUDIO_SYSTEM,
        key: *const c_char,
        info: *mut FMOD_STUDIO_SOUND_INFO,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterDescriptionByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterDescriptionByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterLabelByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
        labelindex: c_int,
        label: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterLabelByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        labelindex: c_int,
        label: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: *mut c_float,
        finalvalue: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetParameterByID(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: c_float,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetParameterByIDWithLabel(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: FMOD_STUDIO_PARAMETER_ID,
        label: *const c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetParametersByIDs(
        system: *mut FMOD_STUDIO_SYSTEM,
        ids: *const FMOD_STUDIO_PARAMETER_ID,
        values: *mut c_float,
        count: c_int,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
        value: *mut c_float,
        finalvalue: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetParameterByName(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
        value: c_float,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetParameterByNameWithLabel(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
        label: *const c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_LookupID(
        system: *mut FMOD_STUDIO_SYSTEM,
        path: *const c_char,
        id: *mut FMOD_GUID,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_LookupPath(
        system: *mut FMOD_STUDIO_SYSTEM,
        id: *const FMOD_GUID,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetNumListeners(
        system: *mut FMOD_STUDIO_SYSTEM,
        numlisteners: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetNumListeners(
        system: *mut FMOD_STUDIO_SYSTEM,
        numlisteners: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetListenerAttributes(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: c_int,
        attributes: *mut FMOD_3D_ATTRIBUTES,
        attenuationposition: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetListenerAttributes(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: c_int,
        attributes: *const FMOD_3D_ATTRIBUTES,
        attenuationposition: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetListenerWeight(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: c_int,
        weight: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetListenerWeight(
        system: *mut FMOD_STUDIO_SYSTEM,
        index: c_int,
        weight: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_LoadBankFile(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const c_char,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_LoadBankMemory(
        system: *mut FMOD_STUDIO_SYSTEM,
        buffer: *const c_char,
        length: c_int,
        mode: FMOD_STUDIO_LOAD_MEMORY_MODE,
        flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
        bank: *mut *mut FMOD_STUDIO_BANK,
    ) -> FMOD_RESULT;
    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;
    pub fn FMOD_Studio_System_RegisterPlugin(
        system: *mut FMOD_STUDIO_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_UnregisterPlugin(
        system: *mut FMOD_STUDIO_SYSTEM,
        name: *const c_char,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_UnloadAll(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_FlushCommands(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_FlushSampleLoading(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_StartCommandCapture(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const c_char,
        flags: FMOD_STUDIO_COMMANDCAPTURE_FLAGS,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_StopCommandCapture(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_LoadCommandReplay(
        system: *mut FMOD_STUDIO_SYSTEM,
        filename: *const c_char,
        flags: FMOD_STUDIO_COMMANDREPLAY_FLAGS,
        replay: *mut *mut FMOD_STUDIO_COMMANDREPLAY,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBankCount(
        system: *mut FMOD_STUDIO_SYSTEM,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetBankList(
        system: *mut FMOD_STUDIO_SYSTEM,
        array: *mut *mut FMOD_STUDIO_BANK,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterDescriptionCount(
        system: *mut FMOD_STUDIO_SYSTEM,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetParameterDescriptionList(
        system: *mut FMOD_STUDIO_SYSTEM,
        array: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    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;
    pub fn FMOD_Studio_System_GetBufferUsage(
        system: *mut FMOD_STUDIO_SYSTEM,
        usage: *mut FMOD_STUDIO_BUFFER_USAGE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_ResetBufferUsage(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetCallback(
        system: *mut FMOD_STUDIO_SYSTEM,
        callback: FMOD_STUDIO_SYSTEM_CALLBACK,
        callbackmask: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_SetUserData(
        system: *mut FMOD_STUDIO_SYSTEM,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetUserData(
        system: *mut FMOD_STUDIO_SYSTEM,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_System_GetMemoryUsage(
        system: *mut FMOD_STUDIO_SYSTEM,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_IsValid(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_BOOL;
    pub fn FMOD_Studio_EventDescription_GetID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: *mut FMOD_GUID,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetPath(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: c_int,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByName(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const c_char,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: FMOD_STUDIO_PARAMETER_ID,
        parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: c_int,
        labelindex: c_int,
        label: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByName(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const c_char,
        labelindex: c_int,
        label: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetParameterLabelByID(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        id: FMOD_STUDIO_PARAMETER_ID,
        labelindex: c_int,
        label: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetUserPropertyCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetUserPropertyByIndex(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        index: c_int,
        property: *mut FMOD_STUDIO_USER_PROPERTY,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetUserProperty(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        name: *const c_char,
        property: *mut FMOD_STUDIO_USER_PROPERTY,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetLength(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        length: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetMinMaxDistance(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        min: *mut c_float,
        max: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetSoundSize(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        size: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_IsSnapshot(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        snapshot: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_IsOneshot(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        oneshot: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_IsStream(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        isStream: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_Is3D(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        is3D: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_IsDopplerEnabled(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        doppler: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_HasSustainPoint(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        sustainPoint: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_CreateInstance(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetInstanceCount(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetInstanceList(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        array: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_LoadSampleData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_UnloadSampleData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetSampleLoadingState(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_ReleaseAllInstances(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_SetCallback(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        callback: FMOD_STUDIO_EVENT_CALLBACK,
        callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_GetUserData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventDescription_SetUserData(
        eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_IsValid(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_BOOL;
    pub fn FMOD_Studio_EventInstance_GetDescription(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        description: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetVolume(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        volume: *mut c_float,
        finalvolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetVolume(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetPitch(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        pitch: *mut c_float,
        finalpitch: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetPitch(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        pitch: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_Get3DAttributes(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_Set3DAttributes(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        attributes: *mut FMOD_3D_ATTRIBUTES,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetListenerMask(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mask: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetListenerMask(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mask: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetProperty(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: FMOD_STUDIO_EVENT_PROPERTY,
        value: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetProperty(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: FMOD_STUDIO_EVENT_PROPERTY,
        value: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetReverbLevel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: c_int,
        level: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetReverbLevel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        index: c_int,
        level: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetPaused(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetPaused(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_Start(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_Stop(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        mode: FMOD_STUDIO_STOP_MODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetTimelinePosition(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        position: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetTimelinePosition(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        position: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetPlaybackState(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        state: *mut FMOD_STUDIO_PLAYBACK_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetChannelGroup(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetMinMaxDistance(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        min: *mut c_float,
        max: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_Release(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_IsVirtual(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        virtualstate: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetParameterByName(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const c_char,
        value: *mut c_float,
        finalvalue: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetParameterByName(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const c_char,
        value: c_float,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetParameterByNameWithLabel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        name: *const c_char,
        label: *const c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetParameterByID(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: *mut c_float,
        finalvalue: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetParameterByID(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        value: c_float,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetParameterByIDWithLabel(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        id: FMOD_STUDIO_PARAMETER_ID,
        label: *const c_char,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetParametersByIDs(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        ids: *const FMOD_STUDIO_PARAMETER_ID,
        values: *mut c_float,
        count: c_int,
        ignoreseekspeed: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_KeyOff(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetCallback(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        callback: FMOD_STUDIO_EVENT_CALLBACK,
        callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetUserData(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_SetUserData(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetCPUUsage(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        exclusive: *mut c_uint,
        inclusive: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_EventInstance_GetMemoryUsage(
        eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_IsValid(bus: *mut FMOD_STUDIO_BUS) -> FMOD_BOOL;
    pub fn FMOD_Studio_Bus_GetID(bus: *mut FMOD_STUDIO_BUS, id: *mut FMOD_GUID) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetPath(
        bus: *mut FMOD_STUDIO_BUS,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetVolume(
        bus: *mut FMOD_STUDIO_BUS,
        volume: *mut c_float,
        finalvolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_SetVolume(bus: *mut FMOD_STUDIO_BUS, volume: c_float) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetPaused(
        bus: *mut FMOD_STUDIO_BUS,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_SetPaused(bus: *mut FMOD_STUDIO_BUS, paused: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetMute(bus: *mut FMOD_STUDIO_BUS, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_SetMute(bus: *mut FMOD_STUDIO_BUS, mute: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_StopAllEvents(
        bus: *mut FMOD_STUDIO_BUS,
        mode: FMOD_STUDIO_STOP_MODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetPortIndex(
        bus: *mut FMOD_STUDIO_BUS,
        index: *mut FMOD_PORT_INDEX,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_SetPortIndex(
        bus: *mut FMOD_STUDIO_BUS,
        index: FMOD_PORT_INDEX,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_LockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_UnlockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetChannelGroup(
        bus: *mut FMOD_STUDIO_BUS,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetCPUUsage(
        bus: *mut FMOD_STUDIO_BUS,
        exclusive: *mut c_uint,
        inclusive: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bus_GetMemoryUsage(
        bus: *mut FMOD_STUDIO_BUS,
        memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_VCA_IsValid(vca: *mut FMOD_STUDIO_VCA) -> FMOD_BOOL;
    pub fn FMOD_Studio_VCA_GetID(vca: *mut FMOD_STUDIO_VCA, id: *mut FMOD_GUID) -> FMOD_RESULT;
    pub fn FMOD_Studio_VCA_GetPath(
        vca: *mut FMOD_STUDIO_VCA,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_VCA_GetVolume(
        vca: *mut FMOD_STUDIO_VCA,
        volume: *mut c_float,
        finalvolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_VCA_SetVolume(vca: *mut FMOD_STUDIO_VCA, volume: c_float) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_IsValid(bank: *mut FMOD_STUDIO_BANK) -> FMOD_BOOL;
    pub fn FMOD_Studio_Bank_GetID(bank: *mut FMOD_STUDIO_BANK, id: *mut FMOD_GUID) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetPath(
        bank: *mut FMOD_STUDIO_BANK,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_Unload(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_LoadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_UnloadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetLoadingState(
        bank: *mut FMOD_STUDIO_BANK,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetSampleLoadingState(
        bank: *mut FMOD_STUDIO_BANK,
        state: *mut FMOD_STUDIO_LOADING_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetStringCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetStringInfo(
        bank: *mut FMOD_STUDIO_BANK,
        index: c_int,
        id: *mut FMOD_GUID,
        path: *mut c_char,
        size: c_int,
        retrieved: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetEventCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetEventList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetBusCount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetBusList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_BUS,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetVCACount(
        bank: *mut FMOD_STUDIO_BANK,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetVCAList(
        bank: *mut FMOD_STUDIO_BANK,
        array: *mut *mut FMOD_STUDIO_VCA,
        capacity: c_int,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_GetUserData(
        bank: *mut FMOD_STUDIO_BANK,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_Bank_SetUserData(
        bank: *mut FMOD_STUDIO_BANK,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_IsValid(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_BOOL;
    pub fn FMOD_Studio_CommandReplay_GetSystem(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        system: *mut *mut FMOD_STUDIO_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetLength(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        length: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetCommandCount(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetCommandInfo(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
        info: *mut FMOD_STUDIO_COMMAND_INFO,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetCommandString(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
        buffer: *mut c_char,
        length: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetCommandAtTime(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        time: c_float,
        commandindex: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetBankPath(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        bankPath: *const c_char,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_Start(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_Stop(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SeekToTime(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        time: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SeekToCommand(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetPaused(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetPaused(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetPlaybackState(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        state: *mut FMOD_STUDIO_PLAYBACK_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetCurrentCommand(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        commandindex: *mut c_int,
        currenttime: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_Release(replay: *mut FMOD_STUDIO_COMMANDREPLAY)
        -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetFrameCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetLoadBankCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetCreateInstanceCallback(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        callback: FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_GetUserData(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Studio_CommandReplay_SetUserData(
        replay: *mut FMOD_STUDIO_COMMANDREPLAY,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
}
extern "C" {
    pub fn FMOD_Memory_Initialize(
        poolmem: *mut c_void,
        poollen: c_int,
        useralloc: FMOD_MEMORY_ALLOC_CALLBACK,
        userrealloc: FMOD_MEMORY_REALLOC_CALLBACK,
        userfree: FMOD_MEMORY_FREE_CALLBACK,
        memtypeflags: FMOD_MEMORY_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_Memory_GetStats(
        currentalloced: *mut c_int,
        maxalloced: *mut c_int,
        blocking: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Debug_Initialize(
        flags: FMOD_DEBUG_FLAGS,
        mode: FMOD_DEBUG_MODE,
        callback: FMOD_DEBUG_CALLBACK,
        filename: *const c_char,
    ) -> FMOD_RESULT;
    pub fn FMOD_File_SetDiskBusy(busy: c_int) -> FMOD_RESULT;
    pub fn FMOD_File_GetDiskBusy(busy: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_Thread_SetAttributes(
        type_: FMOD_THREAD_TYPE,
        affinity: FMOD_THREAD_AFFINITY,
        priority: FMOD_THREAD_PRIORITY,
        stacksize: FMOD_THREAD_STACK_SIZE,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Create(system: *mut *mut FMOD_SYSTEM, headerversion: c_uint) -> FMOD_RESULT;
    pub fn FMOD_System_Release(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_SetOutput(system: *mut FMOD_SYSTEM, output: FMOD_OUTPUTTYPE) -> FMOD_RESULT;
    pub fn FMOD_System_GetOutput(
        system: *mut FMOD_SYSTEM,
        output: *mut FMOD_OUTPUTTYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetNumDrivers(
        system: *mut FMOD_SYSTEM,
        numdrivers: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetDriverInfo(
        system: *mut FMOD_SYSTEM,
        id: c_int,
        name: *mut c_char,
        namelen: c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetDriver(system: *mut FMOD_SYSTEM, driver: c_int) -> FMOD_RESULT;
    pub fn FMOD_System_GetDriver(system: *mut FMOD_SYSTEM, driver: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_System_SetSoftwareChannels(
        system: *mut FMOD_SYSTEM,
        numsoftwarechannels: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetSoftwareChannels(
        system: *mut FMOD_SYSTEM,
        numsoftwarechannels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetSoftwareFormat(
        system: *mut FMOD_SYSTEM,
        samplerate: c_int,
        speakermode: FMOD_SPEAKERMODE,
        numrawspeakers: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetSoftwareFormat(
        system: *mut FMOD_SYSTEM,
        samplerate: *mut c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        numrawspeakers: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetDSPBufferSize(
        system: *mut FMOD_SYSTEM,
        bufferlength: c_uint,
        numbuffers: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetDSPBufferSize(
        system: *mut FMOD_SYSTEM,
        bufferlength: *mut c_uint,
        numbuffers: *mut c_int,
    ) -> FMOD_RESULT;
    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: c_int,
    ) -> FMOD_RESULT;
    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;
    pub fn FMOD_System_SetAdvancedSettings(
        system: *mut FMOD_SYSTEM,
        settings: *mut FMOD_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetAdvancedSettings(
        system: *mut FMOD_SYSTEM,
        settings: *mut FMOD_ADVANCEDSETTINGS,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetCallback(
        system: *mut FMOD_SYSTEM,
        callback: FMOD_SYSTEM_CALLBACK,
        callbackmask: FMOD_SYSTEM_CALLBACK_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetPluginPath(system: *mut FMOD_SYSTEM, path: *const c_char) -> FMOD_RESULT;
    pub fn FMOD_System_LoadPlugin(
        system: *mut FMOD_SYSTEM,
        filename: *const c_char,
        handle: *mut c_uint,
        priority: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_UnloadPlugin(system: *mut FMOD_SYSTEM, handle: c_uint) -> FMOD_RESULT;
    pub fn FMOD_System_GetNumNestedPlugins(
        system: *mut FMOD_SYSTEM,
        handle: c_uint,
        count: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetNestedPlugin(
        system: *mut FMOD_SYSTEM,
        handle: c_uint,
        index: c_int,
        nestedhandle: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetNumPlugins(
        system: *mut FMOD_SYSTEM,
        plugintype: FMOD_PLUGINTYPE,
        numplugins: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetPluginHandle(
        system: *mut FMOD_SYSTEM,
        plugintype: FMOD_PLUGINTYPE,
        index: c_int,
        handle: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetPluginInfo(
        system: *mut FMOD_SYSTEM,
        handle: c_uint,
        plugintype: *mut FMOD_PLUGINTYPE,
        name: *mut c_char,
        namelen: c_int,
        version: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetOutputByPlugin(system: *mut FMOD_SYSTEM, handle: c_uint) -> FMOD_RESULT;
    pub fn FMOD_System_GetOutputByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateDSPByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: c_uint,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetDSPInfoByPlugin(
        system: *mut FMOD_SYSTEM,
        handle: c_uint,
        description: *const *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_RegisterCodec(
        system: *mut FMOD_SYSTEM,
        description: *mut FMOD_CODEC_DESCRIPTION,
        handle: *mut c_uint,
        priority: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_RegisterDSP(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
        handle: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_RegisterOutput(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_OUTPUT_DESCRIPTION,
        handle: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Init(
        system: *mut FMOD_SYSTEM,
        maxchannels: c_int,
        flags: FMOD_INITFLAGS,
        extradriverdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Close(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_Update(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_SetSpeakerPosition(
        system: *mut FMOD_SYSTEM,
        speaker: FMOD_SPEAKER,
        x: c_float,
        y: c_float,
        active: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetSpeakerPosition(
        system: *mut FMOD_SYSTEM,
        speaker: FMOD_SPEAKER,
        x: *mut c_float,
        y: *mut c_float,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetStreamBufferSize(
        system: *mut FMOD_SYSTEM,
        filebuffersize: c_uint,
        filebuffersizetype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetStreamBufferSize(
        system: *mut FMOD_SYSTEM,
        filebuffersize: *mut c_uint,
        filebuffersizetype: *mut FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Set3DSettings(
        system: *mut FMOD_SYSTEM,
        dopplerscale: c_float,
        distancefactor: c_float,
        rolloffscale: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Get3DSettings(
        system: *mut FMOD_SYSTEM,
        dopplerscale: *mut c_float,
        distancefactor: *mut c_float,
        rolloffscale: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Set3DNumListeners(
        system: *mut FMOD_SYSTEM,
        numlisteners: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Get3DNumListeners(
        system: *mut FMOD_SYSTEM,
        numlisteners: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Set3DListenerAttributes(
        system: *mut FMOD_SYSTEM,
        listener: c_int,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
        forward: *const FMOD_VECTOR,
        up: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Get3DListenerAttributes(
        system: *mut FMOD_SYSTEM,
        listener: c_int,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
        forward: *mut FMOD_VECTOR,
        up: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_Set3DRolloffCallback(
        system: *mut FMOD_SYSTEM,
        callback: FMOD_3D_ROLLOFF_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_MixerSuspend(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_MixerResume(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_GetDefaultMixMatrix(
        system: *mut FMOD_SYSTEM,
        sourcespeakermode: FMOD_SPEAKERMODE,
        targetspeakermode: FMOD_SPEAKERMODE,
        matrix: *mut c_float,
        matrixhop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetSpeakerModeChannels(
        system: *mut FMOD_SYSTEM,
        mode: FMOD_SPEAKERMODE,
        channels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetVersion(system: *mut FMOD_SYSTEM, version: *mut c_uint) -> FMOD_RESULT;
    pub fn FMOD_System_GetOutputHandle(
        system: *mut FMOD_SYSTEM,
        handle: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetChannelsPlaying(
        system: *mut FMOD_SYSTEM,
        channels: *mut c_int,
        realchannels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetCPUUsage(
        system: *mut FMOD_SYSTEM,
        usage: *mut FMOD_CPU_USAGE,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetFileUsage(
        system: *mut FMOD_SYSTEM,
        sampleBytesRead: *mut c_longlong,
        streamBytesRead: *mut c_longlong,
        otherBytesRead: *mut c_longlong,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateSound(
        system: *mut FMOD_SYSTEM,
        name_or_data: *const c_char,
        mode: FMOD_MODE,
        exinfo: *mut FMOD_CREATESOUNDEXINFO,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateStream(
        system: *mut FMOD_SYSTEM,
        name_or_data: *const c_char,
        mode: FMOD_MODE,
        exinfo: *mut FMOD_CREATESOUNDEXINFO,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateDSP(
        system: *mut FMOD_SYSTEM,
        description: *const FMOD_DSP_DESCRIPTION,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateDSPByType(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_DSP_TYPE,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateChannelGroup(
        system: *mut FMOD_SYSTEM,
        name: *const c_char,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateSoundGroup(
        system: *mut FMOD_SYSTEM,
        name: *const c_char,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateReverb3D(
        system: *mut FMOD_SYSTEM,
        reverb: *mut *mut FMOD_REVERB3D,
    ) -> FMOD_RESULT;
    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;
    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;
    pub fn FMOD_System_GetChannel(
        system: *mut FMOD_SYSTEM,
        channelid: c_int,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetDSPInfoByType(
        system: *mut FMOD_SYSTEM,
        type_: FMOD_DSP_TYPE,
        description: *const *const FMOD_DSP_DESCRIPTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetMasterChannelGroup(
        system: *mut FMOD_SYSTEM,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetMasterSoundGroup(
        system: *mut FMOD_SYSTEM,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
    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;
    pub fn FMOD_System_DetachChannelGroupFromPort(
        system: *mut FMOD_SYSTEM,
        channelgroup: *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetReverbProperties(
        system: *mut FMOD_SYSTEM,
        instance: c_int,
        prop: *const FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetReverbProperties(
        system: *mut FMOD_SYSTEM,
        instance: c_int,
        prop: *mut FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_LockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_UnlockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
    pub fn FMOD_System_GetRecordNumDrivers(
        system: *mut FMOD_SYSTEM,
        numdrivers: *mut c_int,
        numconnected: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetRecordDriverInfo(
        system: *mut FMOD_SYSTEM,
        id: c_int,
        name: *mut c_char,
        namelen: c_int,
        guid: *mut FMOD_GUID,
        systemrate: *mut c_int,
        speakermode: *mut FMOD_SPEAKERMODE,
        speakermodechannels: *mut c_int,
        state: *mut FMOD_DRIVER_STATE,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetRecordPosition(
        system: *mut FMOD_SYSTEM,
        id: c_int,
        position: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_RecordStart(
        system: *mut FMOD_SYSTEM,
        id: c_int,
        sound: *mut FMOD_SOUND,
        loop_: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_RecordStop(system: *mut FMOD_SYSTEM, id: c_int) -> FMOD_RESULT;
    pub fn FMOD_System_IsRecording(
        system: *mut FMOD_SYSTEM,
        id: c_int,
        recording: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_CreateGeometry(
        system: *mut FMOD_SYSTEM,
        maxpolygons: c_int,
        maxvertices: c_int,
        geometry: *mut *mut FMOD_GEOMETRY,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetGeometrySettings(
        system: *mut FMOD_SYSTEM,
        maxworldsize: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetGeometrySettings(
        system: *mut FMOD_SYSTEM,
        maxworldsize: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_LoadGeometry(
        system: *mut FMOD_SYSTEM,
        data: *const c_void,
        datasize: c_int,
        geometry: *mut *mut FMOD_GEOMETRY,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetGeometryOcclusion(
        system: *mut FMOD_SYSTEM,
        listener: *const FMOD_VECTOR,
        source: *const FMOD_VECTOR,
        direct: *mut c_float,
        reverb: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetNetworkProxy(
        system: *mut FMOD_SYSTEM,
        proxy: *const c_char,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_GetNetworkProxy(
        system: *mut FMOD_SYSTEM,
        proxy: *mut c_char,
        proxylen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetNetworkTimeout(system: *mut FMOD_SYSTEM, timeout: c_int) -> FMOD_RESULT;
    pub fn FMOD_System_GetNetworkTimeout(
        system: *mut FMOD_SYSTEM,
        timeout: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_System_SetUserData(system: *mut FMOD_SYSTEM, userdata: *mut c_void) -> FMOD_RESULT;
    pub fn FMOD_System_GetUserData(
        system: *mut FMOD_SYSTEM,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Release(sound: *mut FMOD_SOUND) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSystemObject(
        sound: *mut FMOD_SOUND,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Lock(
        sound: *mut FMOD_SOUND,
        offset: c_uint,
        length: c_uint,
        ptr1: *mut *mut c_void,
        ptr2: *mut *mut c_void,
        len1: *mut c_uint,
        len2: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Unlock(
        sound: *mut FMOD_SOUND,
        ptr1: *mut c_void,
        ptr2: *mut c_void,
        len1: c_uint,
        len2: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetDefaults(
        sound: *mut FMOD_SOUND,
        frequency: c_float,
        priority: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetDefaults(
        sound: *mut FMOD_SOUND,
        frequency: *mut c_float,
        priority: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Set3DMinMaxDistance(
        sound: *mut FMOD_SOUND,
        min: c_float,
        max: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Get3DMinMaxDistance(
        sound: *mut FMOD_SOUND,
        min: *mut c_float,
        max: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Set3DConeSettings(
        sound: *mut FMOD_SOUND,
        insideconeangle: c_float,
        outsideconeangle: c_float,
        outsidevolume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Get3DConeSettings(
        sound: *mut FMOD_SOUND,
        insideconeangle: *mut c_float,
        outsideconeangle: *mut c_float,
        outsidevolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Set3DCustomRolloff(
        sound: *mut FMOD_SOUND,
        points: *mut FMOD_VECTOR,
        numpoints: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_Get3DCustomRolloff(
        sound: *mut FMOD_SOUND,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSubSound(
        sound: *mut FMOD_SOUND,
        index: c_int,
        subsound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSubSoundParent(
        sound: *mut FMOD_SOUND,
        parentsound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetName(
        sound: *mut FMOD_SOUND,
        name: *mut c_char,
        namelen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetLength(
        sound: *mut FMOD_SOUND,
        length: *mut c_uint,
        lengthtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetFormat(
        sound: *mut FMOD_SOUND,
        type_: *mut FMOD_SOUND_TYPE,
        format: *mut FMOD_SOUND_FORMAT,
        channels: *mut c_int,
        bits: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetNumSubSounds(
        sound: *mut FMOD_SOUND,
        numsubsounds: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetNumTags(
        sound: *mut FMOD_SOUND,
        numtags: *mut c_int,
        numtagsupdated: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetTag(
        sound: *mut FMOD_SOUND,
        name: *const c_char,
        index: c_int,
        tag: *mut FMOD_TAG,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetOpenState(
        sound: *mut FMOD_SOUND,
        openstate: *mut FMOD_OPENSTATE,
        percentbuffered: *mut c_uint,
        starving: *mut FMOD_BOOL,
        diskbusy: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_ReadData(
        sound: *mut FMOD_SOUND,
        buffer: *mut c_void,
        length: c_uint,
        read: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_SeekData(sound: *mut FMOD_SOUND, pcm: c_uint) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetSoundGroup(
        sound: *mut FMOD_SOUND,
        soundgroup: *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSoundGroup(
        sound: *mut FMOD_SOUND,
        soundgroup: *mut *mut FMOD_SOUNDGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetNumSyncPoints(
        sound: *mut FMOD_SOUND,
        numsyncpoints: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSyncPoint(
        sound: *mut FMOD_SOUND,
        index: c_int,
        point: *mut *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetSyncPointInfo(
        sound: *mut FMOD_SOUND,
        point: *mut FMOD_SYNCPOINT,
        name: *mut c_char,
        namelen: c_int,
        offset: *mut c_uint,
        offsettype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_AddSyncPoint(
        sound: *mut FMOD_SOUND,
        offset: c_uint,
        offsettype: FMOD_TIMEUNIT,
        name: *const c_char,
        point: *mut *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_DeleteSyncPoint(
        sound: *mut FMOD_SOUND,
        point: *mut FMOD_SYNCPOINT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetMode(sound: *mut FMOD_SOUND, mode: FMOD_MODE) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetMode(sound: *mut FMOD_SOUND, mode: *mut FMOD_MODE) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetLoopCount(sound: *mut FMOD_SOUND, loopcount: c_int) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetLoopCount(sound: *mut FMOD_SOUND, loopcount: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetLoopPoints(
        sound: *mut FMOD_SOUND,
        loopstart: c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetLoopPoints(
        sound: *mut FMOD_SOUND,
        loopstart: *mut c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: *mut c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetMusicNumChannels(
        sound: *mut FMOD_SOUND,
        numchannels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetMusicChannelVolume(
        sound: *mut FMOD_SOUND,
        channel: c_int,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetMusicChannelVolume(
        sound: *mut FMOD_SOUND,
        channel: c_int,
        volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetMusicSpeed(sound: *mut FMOD_SOUND, speed: c_float) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetMusicSpeed(sound: *mut FMOD_SOUND, speed: *mut c_float) -> FMOD_RESULT;
    pub fn FMOD_Sound_SetUserData(sound: *mut FMOD_SOUND, userdata: *mut c_void) -> FMOD_RESULT;
    pub fn FMOD_Sound_GetUserData(
        sound: *mut FMOD_SOUND,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetSystemObject(
        channel: *mut FMOD_CHANNEL,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Stop(channel: *mut FMOD_CHANNEL) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetPaused(channel: *mut FMOD_CHANNEL, paused: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetPaused(
        channel: *mut FMOD_CHANNEL,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetVolume(channel: *mut FMOD_CHANNEL, volume: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetVolume(channel: *mut FMOD_CHANNEL, volume: *mut c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetVolumeRamp(channel: *mut FMOD_CHANNEL, ramp: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetVolumeRamp(
        channel: *mut FMOD_CHANNEL,
        ramp: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetAudibility(
        channel: *mut FMOD_CHANNEL,
        audibility: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetPitch(channel: *mut FMOD_CHANNEL, pitch: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetPitch(channel: *mut FMOD_CHANNEL, pitch: *mut c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetMute(channel: *mut FMOD_CHANNEL, mute: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetMute(channel: *mut FMOD_CHANNEL, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetReverbProperties(
        channel: *mut FMOD_CHANNEL,
        instance: c_int,
        wet: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetReverbProperties(
        channel: *mut FMOD_CHANNEL,
        instance: c_int,
        wet: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetLowPassGain(channel: *mut FMOD_CHANNEL, gain: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetLowPassGain(
        channel: *mut FMOD_CHANNEL,
        gain: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetMode(channel: *mut FMOD_CHANNEL, mode: FMOD_MODE) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetMode(channel: *mut FMOD_CHANNEL, mode: *mut FMOD_MODE) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetCallback(
        channel: *mut FMOD_CHANNEL,
        callback: FMOD_CHANNELCONTROL_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_IsPlaying(
        channel: *mut FMOD_CHANNEL,
        isplaying: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetPan(channel: *mut FMOD_CHANNEL, pan: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetMixLevelsOutput(
        channel: *mut FMOD_CHANNEL,
        frontleft: c_float,
        frontright: c_float,
        center: c_float,
        lfe: c_float,
        surroundleft: c_float,
        surroundright: c_float,
        backleft: c_float,
        backright: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetMixLevelsInput(
        channel: *mut FMOD_CHANNEL,
        levels: *mut c_float,
        numlevels: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetMixMatrix(
        channel: *mut FMOD_CHANNEL,
        matrix: *mut c_float,
        outchannels: c_int,
        inchannels: c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetMixMatrix(
        channel: *mut FMOD_CHANNEL,
        matrix: *mut c_float,
        outchannels: *mut c_int,
        inchannels: *mut c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetDSPClock(
        channel: *mut FMOD_CHANNEL,
        dspclock: *mut c_ulonglong,
        parentclock: *mut c_ulonglong,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetDelay(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: c_ulonglong,
        dspclock_end: c_ulonglong,
        stopchannels: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetDelay(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: *mut c_ulonglong,
        dspclock_end: *mut c_ulonglong,
        stopchannels: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_AddFadePoint(
        channel: *mut FMOD_CHANNEL,
        dspclock: c_ulonglong,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetFadePointRamp(
        channel: *mut FMOD_CHANNEL,
        dspclock: c_ulonglong,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_RemoveFadePoints(
        channel: *mut FMOD_CHANNEL,
        dspclock_start: c_ulonglong,
        dspclock_end: c_ulonglong,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetFadePoints(
        channel: *mut FMOD_CHANNEL,
        numpoints: *mut c_uint,
        point_dspclock: *mut c_ulonglong,
        point_volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetDSP(
        channel: *mut FMOD_CHANNEL,
        index: c_int,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_AddDSP(
        channel: *mut FMOD_CHANNEL,
        index: c_int,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_RemoveDSP(channel: *mut FMOD_CHANNEL, dsp: *mut FMOD_DSP) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetNumDSPs(channel: *mut FMOD_CHANNEL, numdsps: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetDSPIndex(
        channel: *mut FMOD_CHANNEL,
        dsp: *mut FMOD_DSP,
        index: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetDSPIndex(
        channel: *mut FMOD_CHANNEL,
        dsp: *mut FMOD_DSP,
        index: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DAttributes(
        channel: *mut FMOD_CHANNEL,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DAttributes(
        channel: *mut FMOD_CHANNEL,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DMinMaxDistance(
        channel: *mut FMOD_CHANNEL,
        mindistance: c_float,
        maxdistance: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DMinMaxDistance(
        channel: *mut FMOD_CHANNEL,
        mindistance: *mut c_float,
        maxdistance: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DConeSettings(
        channel: *mut FMOD_CHANNEL,
        insideconeangle: c_float,
        outsideconeangle: c_float,
        outsidevolume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DConeSettings(
        channel: *mut FMOD_CHANNEL,
        insideconeangle: *mut c_float,
        outsideconeangle: *mut c_float,
        outsidevolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DConeOrientation(
        channel: *mut FMOD_CHANNEL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DConeOrientation(
        channel: *mut FMOD_CHANNEL,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DCustomRolloff(
        channel: *mut FMOD_CHANNEL,
        points: *mut FMOD_VECTOR,
        numpoints: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DCustomRolloff(
        channel: *mut FMOD_CHANNEL,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DOcclusion(
        channel: *mut FMOD_CHANNEL,
        directocclusion: c_float,
        reverbocclusion: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DOcclusion(
        channel: *mut FMOD_CHANNEL,
        directocclusion: *mut c_float,
        reverbocclusion: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DSpread(channel: *mut FMOD_CHANNEL, angle: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DSpread(channel: *mut FMOD_CHANNEL, angle: *mut c_float)
        -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DLevel(channel: *mut FMOD_CHANNEL, level: c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DLevel(channel: *mut FMOD_CHANNEL, level: *mut c_float) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DDopplerLevel(
        channel: *mut FMOD_CHANNEL,
        level: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DDopplerLevel(
        channel: *mut FMOD_CHANNEL,
        level: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Set3DDistanceFilter(
        channel: *mut FMOD_CHANNEL,
        custom: FMOD_BOOL,
        customLevel: c_float,
        centerFreq: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_Get3DDistanceFilter(
        channel: *mut FMOD_CHANNEL,
        custom: *mut FMOD_BOOL,
        customLevel: *mut c_float,
        centerFreq: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetUserData(
        channel: *mut FMOD_CHANNEL,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetUserData(
        channel: *mut FMOD_CHANNEL,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetFrequency(channel: *mut FMOD_CHANNEL, frequency: c_float)
        -> FMOD_RESULT;
    pub fn FMOD_Channel_GetFrequency(
        channel: *mut FMOD_CHANNEL,
        frequency: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetPriority(channel: *mut FMOD_CHANNEL, priority: c_int) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetPriority(
        channel: *mut FMOD_CHANNEL,
        priority: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetPosition(
        channel: *mut FMOD_CHANNEL,
        position: c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetPosition(
        channel: *mut FMOD_CHANNEL,
        position: *mut c_uint,
        postype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetChannelGroup(
        channel: *mut FMOD_CHANNEL,
        channelgroup: *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetChannelGroup(
        channel: *mut FMOD_CHANNEL,
        channelgroup: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetLoopCount(channel: *mut FMOD_CHANNEL, loopcount: c_int) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetLoopCount(
        channel: *mut FMOD_CHANNEL,
        loopcount: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_SetLoopPoints(
        channel: *mut FMOD_CHANNEL,
        loopstart: c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetLoopPoints(
        channel: *mut FMOD_CHANNEL,
        loopstart: *mut c_uint,
        loopstarttype: FMOD_TIMEUNIT,
        loopend: *mut c_uint,
        loopendtype: FMOD_TIMEUNIT,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_IsVirtual(
        channel: *mut FMOD_CHANNEL,
        isvirtual: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetCurrentSound(
        channel: *mut FMOD_CHANNEL,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_Channel_GetIndex(channel: *mut FMOD_CHANNEL, index: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetSystemObject(
        channelgroup: *mut FMOD_CHANNELGROUP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Stop(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetPaused(
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetPaused(
        channelgroup: *mut FMOD_CHANNELGROUP,
        paused: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetVolume(
        channelgroup: *mut FMOD_CHANNELGROUP,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetVolume(
        channelgroup: *mut FMOD_CHANNELGROUP,
        volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetVolumeRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        ramp: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetVolumeRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        ramp: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetAudibility(
        channelgroup: *mut FMOD_CHANNELGROUP,
        audibility: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetPitch(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pitch: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetPitch(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pitch: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetMute(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mute: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetMute(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mute: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetReverbProperties(
        channelgroup: *mut FMOD_CHANNELGROUP,
        instance: c_int,
        wet: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetReverbProperties(
        channelgroup: *mut FMOD_CHANNELGROUP,
        instance: c_int,
        wet: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetLowPassGain(
        channelgroup: *mut FMOD_CHANNELGROUP,
        gain: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetLowPassGain(
        channelgroup: *mut FMOD_CHANNELGROUP,
        gain: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetMode(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mode: FMOD_MODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetMode(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mode: *mut FMOD_MODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetCallback(
        channelgroup: *mut FMOD_CHANNELGROUP,
        callback: FMOD_CHANNELCONTROL_CALLBACK,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_IsPlaying(
        channelgroup: *mut FMOD_CHANNELGROUP,
        isplaying: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetPan(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pan: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetMixLevelsOutput(
        channelgroup: *mut FMOD_CHANNELGROUP,
        frontleft: c_float,
        frontright: c_float,
        center: c_float,
        lfe: c_float,
        surroundleft: c_float,
        surroundright: c_float,
        backleft: c_float,
        backright: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetMixLevelsInput(
        channelgroup: *mut FMOD_CHANNELGROUP,
        levels: *mut c_float,
        numlevels: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetMixMatrix(
        channelgroup: *mut FMOD_CHANNELGROUP,
        matrix: *mut c_float,
        outchannels: c_int,
        inchannels: c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetMixMatrix(
        channelgroup: *mut FMOD_CHANNELGROUP,
        matrix: *mut c_float,
        outchannels: *mut c_int,
        inchannels: *mut c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetDSPClock(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: *mut c_ulonglong,
        parentclock: *mut c_ulonglong,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetDelay(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: c_ulonglong,
        dspclock_end: c_ulonglong,
        stopchannels: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetDelay(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: *mut c_ulonglong,
        dspclock_end: *mut c_ulonglong,
        stopchannels: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_AddFadePoint(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: c_ulonglong,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetFadePointRamp(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock: c_ulonglong,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_RemoveFadePoints(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dspclock_start: c_ulonglong,
        dspclock_end: c_ulonglong,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetFadePoints(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numpoints: *mut c_uint,
        point_dspclock: *mut c_ulonglong,
        point_volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: c_int,
        dsp: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_AddDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: c_int,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_RemoveDSP(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetNumDSPs(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numdsps: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetDSPIndex(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
        index: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetDSPIndex(
        channelgroup: *mut FMOD_CHANNELGROUP,
        dsp: *mut FMOD_DSP,
        index: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DAttributes(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pos: *const FMOD_VECTOR,
        vel: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DAttributes(
        channelgroup: *mut FMOD_CHANNELGROUP,
        pos: *mut FMOD_VECTOR,
        vel: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DMinMaxDistance(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mindistance: c_float,
        maxdistance: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DMinMaxDistance(
        channelgroup: *mut FMOD_CHANNELGROUP,
        mindistance: *mut c_float,
        maxdistance: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DConeSettings(
        channelgroup: *mut FMOD_CHANNELGROUP,
        insideconeangle: c_float,
        outsideconeangle: c_float,
        outsidevolume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DConeSettings(
        channelgroup: *mut FMOD_CHANNELGROUP,
        insideconeangle: *mut c_float,
        outsideconeangle: *mut c_float,
        outsidevolume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DConeOrientation(
        channelgroup: *mut FMOD_CHANNELGROUP,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DConeOrientation(
        channelgroup: *mut FMOD_CHANNELGROUP,
        orientation: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DCustomRolloff(
        channelgroup: *mut FMOD_CHANNELGROUP,
        points: *mut FMOD_VECTOR,
        numpoints: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DCustomRolloff(
        channelgroup: *mut FMOD_CHANNELGROUP,
        points: *mut *mut FMOD_VECTOR,
        numpoints: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DOcclusion(
        channelgroup: *mut FMOD_CHANNELGROUP,
        directocclusion: c_float,
        reverbocclusion: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DOcclusion(
        channelgroup: *mut FMOD_CHANNELGROUP,
        directocclusion: *mut c_float,
        reverbocclusion: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DSpread(
        channelgroup: *mut FMOD_CHANNELGROUP,
        angle: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DSpread(
        channelgroup: *mut FMOD_CHANNELGROUP,
        angle: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DDopplerLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DDopplerLevel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        level: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Set3DDistanceFilter(
        channelgroup: *mut FMOD_CHANNELGROUP,
        custom: FMOD_BOOL,
        customLevel: c_float,
        centerFreq: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Get3DDistanceFilter(
        channelgroup: *mut FMOD_CHANNELGROUP,
        custom: *mut FMOD_BOOL,
        customLevel: *mut c_float,
        centerFreq: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_SetUserData(
        channelgroup: *mut FMOD_CHANNELGROUP,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetUserData(
        channelgroup: *mut FMOD_CHANNELGROUP,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_Release(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_AddGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        group: *mut FMOD_CHANNELGROUP,
        propagatedspclock: FMOD_BOOL,
        connection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetNumGroups(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numgroups: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: c_int,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetParentGroup(
        channelgroup: *mut FMOD_CHANNELGROUP,
        group: *mut *mut FMOD_CHANNELGROUP,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetName(
        channelgroup: *mut FMOD_CHANNELGROUP,
        name: *mut c_char,
        namelen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetNumChannels(
        channelgroup: *mut FMOD_CHANNELGROUP,
        numchannels: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_ChannelGroup_GetChannel(
        channelgroup: *mut FMOD_CHANNELGROUP,
        index: c_int,
        channel: *mut *mut FMOD_CHANNEL,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_Release(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetSystemObject(
        soundgroup: *mut FMOD_SOUNDGROUP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_SetMaxAudible(
        soundgroup: *mut FMOD_SOUNDGROUP,
        maxaudible: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetMaxAudible(
        soundgroup: *mut FMOD_SOUNDGROUP,
        maxaudible: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_SetMaxAudibleBehavior(
        soundgroup: *mut FMOD_SOUNDGROUP,
        behavior: FMOD_SOUNDGROUP_BEHAVIOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetMaxAudibleBehavior(
        soundgroup: *mut FMOD_SOUNDGROUP,
        behavior: *mut FMOD_SOUNDGROUP_BEHAVIOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_SetMuteFadeSpeed(
        soundgroup: *mut FMOD_SOUNDGROUP,
        speed: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetMuteFadeSpeed(
        soundgroup: *mut FMOD_SOUNDGROUP,
        speed: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_SetVolume(
        soundgroup: *mut FMOD_SOUNDGROUP,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetVolume(
        soundgroup: *mut FMOD_SOUNDGROUP,
        volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_Stop(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetName(
        soundgroup: *mut FMOD_SOUNDGROUP,
        name: *mut c_char,
        namelen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetNumSounds(
        soundgroup: *mut FMOD_SOUNDGROUP,
        numsounds: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetSound(
        soundgroup: *mut FMOD_SOUNDGROUP,
        index: c_int,
        sound: *mut *mut FMOD_SOUND,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetNumPlaying(
        soundgroup: *mut FMOD_SOUNDGROUP,
        numplaying: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_SetUserData(
        soundgroup: *mut FMOD_SOUNDGROUP,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_SoundGroup_GetUserData(
        soundgroup: *mut FMOD_SOUNDGROUP,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_Release(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetSystemObject(
        dsp: *mut FMOD_DSP,
        system: *mut *mut FMOD_SYSTEM,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_AddInput(
        dsp: *mut FMOD_DSP,
        input: *mut FMOD_DSP,
        connection: *mut *mut FMOD_DSPCONNECTION,
        type_: FMOD_DSPCONNECTION_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_DisconnectFrom(
        dsp: *mut FMOD_DSP,
        target: *mut FMOD_DSP,
        connection: *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_DisconnectAll(
        dsp: *mut FMOD_DSP,
        inputs: FMOD_BOOL,
        outputs: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetNumInputs(dsp: *mut FMOD_DSP, numinputs: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetNumOutputs(dsp: *mut FMOD_DSP, numoutputs: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetInput(
        dsp: *mut FMOD_DSP,
        index: c_int,
        input: *mut *mut FMOD_DSP,
        inputconnection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetOutput(
        dsp: *mut FMOD_DSP,
        index: c_int,
        output: *mut *mut FMOD_DSP,
        outputconnection: *mut *mut FMOD_DSPCONNECTION,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetActive(dsp: *mut FMOD_DSP, active: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetActive(dsp: *mut FMOD_DSP, active: *mut FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetBypass(dsp: *mut FMOD_DSP, bypass: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetBypass(dsp: *mut FMOD_DSP, bypass: *mut FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetWetDryMix(
        dsp: *mut FMOD_DSP,
        prewet: c_float,
        postwet: c_float,
        dry: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetWetDryMix(
        dsp: *mut FMOD_DSP,
        prewet: *mut c_float,
        postwet: *mut c_float,
        dry: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetChannelFormat(
        dsp: *mut FMOD_DSP,
        channelmask: FMOD_CHANNELMASK,
        numchannels: c_int,
        source_speakermode: FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetChannelFormat(
        dsp: *mut FMOD_DSP,
        channelmask: *mut FMOD_CHANNELMASK,
        numchannels: *mut c_int,
        source_speakermode: *mut FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetOutputChannelFormat(
        dsp: *mut FMOD_DSP,
        inmask: FMOD_CHANNELMASK,
        inchannels: c_int,
        inspeakermode: FMOD_SPEAKERMODE,
        outmask: *mut FMOD_CHANNELMASK,
        outchannels: *mut c_int,
        outspeakermode: *mut FMOD_SPEAKERMODE,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_Reset(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetCallback(dsp: *mut FMOD_DSP, callback: FMOD_DSP_CALLBACK) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetParameterFloat(
        dsp: *mut FMOD_DSP,
        index: c_int,
        value: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetParameterInt(dsp: *mut FMOD_DSP, index: c_int, value: c_int) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetParameterBool(
        dsp: *mut FMOD_DSP,
        index: c_int,
        value: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetParameterData(
        dsp: *mut FMOD_DSP,
        index: c_int,
        data: *mut c_void,
        length: c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetParameterFloat(
        dsp: *mut FMOD_DSP,
        index: c_int,
        value: *mut c_float,
        valuestr: *mut c_char,
        valuestrlen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetParameterInt(
        dsp: *mut FMOD_DSP,
        index: c_int,
        value: *mut c_int,
        valuestr: *mut c_char,
        valuestrlen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetParameterBool(
        dsp: *mut FMOD_DSP,
        index: c_int,
        value: *mut FMOD_BOOL,
        valuestr: *mut c_char,
        valuestrlen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetParameterData(
        dsp: *mut FMOD_DSP,
        index: c_int,
        data: *mut *mut c_void,
        length: *mut c_uint,
        valuestr: *mut c_char,
        valuestrlen: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetNumParameters(dsp: *mut FMOD_DSP, numparams: *mut c_int) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetParameterInfo(
        dsp: *mut FMOD_DSP,
        index: c_int,
        desc: *mut *mut FMOD_DSP_PARAMETER_DESC,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetDataParameterIndex(
        dsp: *mut FMOD_DSP,
        datatype: c_int,
        index: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_ShowConfigDialog(
        dsp: *mut FMOD_DSP,
        hwnd: *mut c_void,
        show: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetInfo(
        dsp: *mut FMOD_DSP,
        name: *mut c_char,
        version: *mut c_uint,
        channels: *mut c_int,
        configwidth: *mut c_int,
        configheight: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetType(dsp: *mut FMOD_DSP, type_: *mut FMOD_DSP_TYPE) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetIdle(dsp: *mut FMOD_DSP, idle: *mut FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetUserData(dsp: *mut FMOD_DSP, userdata: *mut c_void) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetUserData(dsp: *mut FMOD_DSP, userdata: *mut *mut c_void) -> FMOD_RESULT;
    pub fn FMOD_DSP_SetMeteringEnabled(
        dsp: *mut FMOD_DSP,
        inputEnabled: FMOD_BOOL,
        outputEnabled: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetMeteringEnabled(
        dsp: *mut FMOD_DSP,
        inputEnabled: *mut FMOD_BOOL,
        outputEnabled: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetMeteringInfo(
        dsp: *mut FMOD_DSP,
        inputInfo: *mut FMOD_DSP_METERING_INFO,
        outputInfo: *mut FMOD_DSP_METERING_INFO,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSP_GetCPUUsage(
        dsp: *mut FMOD_DSP,
        exclusive: *mut c_uint,
        inclusive: *mut c_uint,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetInput(
        dspconnection: *mut FMOD_DSPCONNECTION,
        input: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetOutput(
        dspconnection: *mut FMOD_DSPCONNECTION,
        output: *mut *mut FMOD_DSP,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_SetMix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        volume: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetMix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        volume: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_SetMixMatrix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        matrix: *mut c_float,
        outchannels: c_int,
        inchannels: c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetMixMatrix(
        dspconnection: *mut FMOD_DSPCONNECTION,
        matrix: *mut c_float,
        outchannels: *mut c_int,
        inchannels: *mut c_int,
        inchannel_hop: c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetType(
        dspconnection: *mut FMOD_DSPCONNECTION,
        type_: *mut FMOD_DSPCONNECTION_TYPE,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_SetUserData(
        dspconnection: *mut FMOD_DSPCONNECTION,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_DSPConnection_GetUserData(
        dspconnection: *mut FMOD_DSPCONNECTION,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_Release(geometry: *mut FMOD_GEOMETRY) -> FMOD_RESULT;
    pub fn FMOD_Geometry_AddPolygon(
        geometry: *mut FMOD_GEOMETRY,
        directocclusion: c_float,
        reverbocclusion: c_float,
        doublesided: FMOD_BOOL,
        numvertices: c_int,
        vertices: *const FMOD_VECTOR,
        polygonindex: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetNumPolygons(
        geometry: *mut FMOD_GEOMETRY,
        numpolygons: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetMaxPolygons(
        geometry: *mut FMOD_GEOMETRY,
        maxpolygons: *mut c_int,
        maxvertices: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetPolygonNumVertices(
        geometry: *mut FMOD_GEOMETRY,
        index: c_int,
        numvertices: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetPolygonVertex(
        geometry: *mut FMOD_GEOMETRY,
        index: c_int,
        vertexindex: c_int,
        vertex: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetPolygonVertex(
        geometry: *mut FMOD_GEOMETRY,
        index: c_int,
        vertexindex: c_int,
        vertex: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetPolygonAttributes(
        geometry: *mut FMOD_GEOMETRY,
        index: c_int,
        directocclusion: c_float,
        reverbocclusion: c_float,
        doublesided: FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetPolygonAttributes(
        geometry: *mut FMOD_GEOMETRY,
        index: c_int,
        directocclusion: *mut c_float,
        reverbocclusion: *mut c_float,
        doublesided: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetActive(geometry: *mut FMOD_GEOMETRY, active: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetActive(
        geometry: *mut FMOD_GEOMETRY,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetRotation(
        geometry: *mut FMOD_GEOMETRY,
        forward: *const FMOD_VECTOR,
        up: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetRotation(
        geometry: *mut FMOD_GEOMETRY,
        forward: *mut FMOD_VECTOR,
        up: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetPosition(
        geometry: *mut FMOD_GEOMETRY,
        position: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetPosition(
        geometry: *mut FMOD_GEOMETRY,
        position: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetScale(
        geometry: *mut FMOD_GEOMETRY,
        scale: *const FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetScale(
        geometry: *mut FMOD_GEOMETRY,
        scale: *mut FMOD_VECTOR,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_Save(
        geometry: *mut FMOD_GEOMETRY,
        data: *mut c_void,
        datasize: *mut c_int,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_SetUserData(
        geometry: *mut FMOD_GEOMETRY,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Geometry_GetUserData(
        geometry: *mut FMOD_GEOMETRY,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_Release(reverb3d: *mut FMOD_REVERB3D) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_Set3DAttributes(
        reverb3d: *mut FMOD_REVERB3D,
        position: *const FMOD_VECTOR,
        mindistance: c_float,
        maxdistance: c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_Get3DAttributes(
        reverb3d: *mut FMOD_REVERB3D,
        position: *mut FMOD_VECTOR,
        mindistance: *mut c_float,
        maxdistance: *mut c_float,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_SetProperties(
        reverb3d: *mut FMOD_REVERB3D,
        properties: *const FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_GetProperties(
        reverb3d: *mut FMOD_REVERB3D,
        properties: *mut FMOD_REVERB_PROPERTIES,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_SetActive(reverb3d: *mut FMOD_REVERB3D, active: FMOD_BOOL) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_GetActive(
        reverb3d: *mut FMOD_REVERB3D,
        active: *mut FMOD_BOOL,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_SetUserData(
        reverb3d: *mut FMOD_REVERB3D,
        userdata: *mut c_void,
    ) -> FMOD_RESULT;
    pub fn FMOD_Reverb3D_GetUserData(
        reverb3d: *mut FMOD_REVERB3D,
        userdata: *mut *mut c_void,
    ) -> FMOD_RESULT;
}