1pub const FMOD_VERSION: u32 = 131847;
4pub const FMOD_BUILDNUMBER: u32 = 150747;
5pub const FMOD_DEBUG_LEVEL_NONE: u32 = 0;
6pub const FMOD_DEBUG_LEVEL_ERROR: u32 = 1;
7pub const FMOD_DEBUG_LEVEL_WARNING: u32 = 2;
8pub const FMOD_DEBUG_LEVEL_LOG: u32 = 4;
9pub const FMOD_DEBUG_TYPE_MEMORY: u32 = 256;
10pub const FMOD_DEBUG_TYPE_FILE: u32 = 512;
11pub const FMOD_DEBUG_TYPE_CODEC: u32 = 1024;
12pub const FMOD_DEBUG_TYPE_TRACE: u32 = 2048;
13pub const FMOD_DEBUG_DISPLAY_TIMESTAMPS: u32 = 65536;
14pub const FMOD_DEBUG_DISPLAY_LINENUMBERS: u32 = 131072;
15pub const FMOD_DEBUG_DISPLAY_THREAD: u32 = 262144;
16pub const FMOD_MEMORY_NORMAL: u32 = 0;
17pub const FMOD_MEMORY_STREAM_FILE: u32 = 1;
18pub const FMOD_MEMORY_STREAM_DECODE: u32 = 2;
19pub const FMOD_MEMORY_SAMPLEDATA: u32 = 4;
20pub const FMOD_MEMORY_DSP_BUFFER: u32 = 8;
21pub const FMOD_MEMORY_PLUGIN: u32 = 16;
22pub const FMOD_MEMORY_PERSISTENT: u32 = 2097152;
23pub const FMOD_MEMORY_ALL: u32 = 4294967295;
24pub const FMOD_INIT_NORMAL: u32 = 0;
25pub const FMOD_INIT_STREAM_FROM_UPDATE: u32 = 1;
26pub const FMOD_INIT_MIX_FROM_UPDATE: u32 = 2;
27pub const FMOD_INIT_3D_RIGHTHANDED: u32 = 4;
28pub const FMOD_INIT_CLIP_OUTPUT: u32 = 8;
29pub const FMOD_INIT_CHANNEL_LOWPASS: u32 = 256;
30pub const FMOD_INIT_CHANNEL_DISTANCEFILTER: u32 = 512;
31pub const FMOD_INIT_PROFILE_ENABLE: u32 = 65536;
32pub const FMOD_INIT_VOL0_BECOMES_VIRTUAL: u32 = 131072;
33pub const FMOD_INIT_GEOMETRY_USECLOSEST: u32 = 262144;
34pub const FMOD_INIT_PREFER_DOLBY_DOWNMIX: u32 = 524288;
35pub const FMOD_INIT_THREAD_UNSAFE: u32 = 1048576;
36pub const FMOD_INIT_PROFILE_METER_ALL: u32 = 2097152;
37pub const FMOD_INIT_MEMORY_TRACKING: u32 = 4194304;
38pub const FMOD_DRIVER_STATE_CONNECTED: u32 = 1;
39pub const FMOD_DRIVER_STATE_DEFAULT: u32 = 2;
40pub const FMOD_TIMEUNIT_MS: u32 = 1;
41pub const FMOD_TIMEUNIT_PCM: u32 = 2;
42pub const FMOD_TIMEUNIT_PCMBYTES: u32 = 4;
43pub const FMOD_TIMEUNIT_RAWBYTES: u32 = 8;
44pub const FMOD_TIMEUNIT_PCMFRACTION: u32 = 16;
45pub const FMOD_TIMEUNIT_MODORDER: u32 = 256;
46pub const FMOD_TIMEUNIT_MODROW: u32 = 512;
47pub const FMOD_TIMEUNIT_MODPATTERN: u32 = 1024;
48pub const FMOD_SYSTEM_CALLBACK_DEVICELISTCHANGED: u32 = 1;
49pub const FMOD_SYSTEM_CALLBACK_DEVICELOST: u32 = 2;
50pub const FMOD_SYSTEM_CALLBACK_MEMORYALLOCATIONFAILED: u32 = 4;
51pub const FMOD_SYSTEM_CALLBACK_THREADCREATED: u32 = 8;
52pub const FMOD_SYSTEM_CALLBACK_BADDSPCONNECTION: u32 = 16;
53pub const FMOD_SYSTEM_CALLBACK_PREMIX: u32 = 32;
54pub const FMOD_SYSTEM_CALLBACK_POSTMIX: u32 = 64;
55pub const FMOD_SYSTEM_CALLBACK_ERROR: u32 = 128;
56pub const FMOD_SYSTEM_CALLBACK_THREADDESTROYED: u32 = 256;
57pub const FMOD_SYSTEM_CALLBACK_PREUPDATE: u32 = 512;
58pub const FMOD_SYSTEM_CALLBACK_POSTUPDATE: u32 = 1024;
59pub const FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED: u32 = 2048;
60pub const FMOD_SYSTEM_CALLBACK_BUFFEREDNOMIX: u32 = 4096;
61pub const FMOD_SYSTEM_CALLBACK_DEVICEREINITIALIZE: u32 = 8192;
62pub const FMOD_SYSTEM_CALLBACK_OUTPUTUNDERRUN: u32 = 16384;
63pub const FMOD_SYSTEM_CALLBACK_RECORDPOSITIONCHANGED: u32 = 32768;
64pub const FMOD_SYSTEM_CALLBACK_ALL: u32 = 4294967295;
65pub const FMOD_DEFAULT: u32 = 0;
66pub const FMOD_LOOP_OFF: u32 = 1;
67pub const FMOD_LOOP_NORMAL: u32 = 2;
68pub const FMOD_LOOP_BIDI: u32 = 4;
69pub const FMOD_2D: u32 = 8;
70pub const FMOD_3D: u32 = 16;
71pub const FMOD_CREATESTREAM: u32 = 128;
72pub const FMOD_CREATESAMPLE: u32 = 256;
73pub const FMOD_CREATECOMPRESSEDSAMPLE: u32 = 512;
74pub const FMOD_OPENUSER: u32 = 1024;
75pub const FMOD_OPENMEMORY: u32 = 2048;
76pub const FMOD_OPENMEMORY_POINT: u32 = 268435456;
77pub const FMOD_OPENRAW: u32 = 4096;
78pub const FMOD_OPENONLY: u32 = 8192;
79pub const FMOD_ACCURATETIME: u32 = 16384;
80pub const FMOD_MPEGSEARCH: u32 = 32768;
81pub const FMOD_NONBLOCKING: u32 = 65536;
82pub const FMOD_UNIQUE: u32 = 131072;
83pub const FMOD_3D_HEADRELATIVE: u32 = 262144;
84pub const FMOD_3D_WORLDRELATIVE: u32 = 524288;
85pub const FMOD_3D_INVERSEROLLOFF: u32 = 1048576;
86pub const FMOD_3D_LINEARROLLOFF: u32 = 2097152;
87pub const FMOD_3D_LINEARSQUAREROLLOFF: u32 = 4194304;
88pub const FMOD_3D_INVERSETAPEREDROLLOFF: u32 = 8388608;
89pub const FMOD_3D_CUSTOMROLLOFF: u32 = 67108864;
90pub const FMOD_3D_IGNOREGEOMETRY: u32 = 1073741824;
91pub const FMOD_IGNORETAGS: u32 = 33554432;
92pub const FMOD_LOWMEM: u32 = 134217728;
93pub const FMOD_VIRTUAL_PLAYFROMSTART: u32 = 2147483648;
94pub const FMOD_CHANNELMASK_FRONT_LEFT: u32 = 1;
95pub const FMOD_CHANNELMASK_FRONT_RIGHT: u32 = 2;
96pub const FMOD_CHANNELMASK_FRONT_CENTER: u32 = 4;
97pub const FMOD_CHANNELMASK_LOW_FREQUENCY: u32 = 8;
98pub const FMOD_CHANNELMASK_SURROUND_LEFT: u32 = 16;
99pub const FMOD_CHANNELMASK_SURROUND_RIGHT: u32 = 32;
100pub const FMOD_CHANNELMASK_BACK_LEFT: u32 = 64;
101pub const FMOD_CHANNELMASK_BACK_RIGHT: u32 = 128;
102pub const FMOD_CHANNELMASK_BACK_CENTER: u32 = 256;
103pub const FMOD_CHANNELMASK_MONO: u32 = 1;
104pub const FMOD_CHANNELMASK_STEREO: u32 = 3;
105pub const FMOD_CHANNELMASK_LRC: u32 = 7;
106pub const FMOD_CHANNELMASK_QUAD: u32 = 51;
107pub const FMOD_CHANNELMASK_SURROUND: u32 = 55;
108pub const FMOD_CHANNELMASK_5POINT1: u32 = 63;
109pub const FMOD_CHANNELMASK_5POINT1_REARS: u32 = 207;
110pub const FMOD_CHANNELMASK_7POINT0: u32 = 247;
111pub const FMOD_CHANNELMASK_7POINT1: u32 = 255;
112pub const FMOD_PORT_INDEX_NONE: i32 = -1;
113pub const FMOD_THREAD_PRIORITY_PLATFORM_MIN: i32 = -32768;
114pub const FMOD_THREAD_PRIORITY_PLATFORM_MAX: u32 = 32768;
115pub const FMOD_THREAD_PRIORITY_DEFAULT: i32 = -32769;
116pub const FMOD_THREAD_PRIORITY_LOW: i32 = -32770;
117pub const FMOD_THREAD_PRIORITY_MEDIUM: i32 = -32771;
118pub const FMOD_THREAD_PRIORITY_HIGH: i32 = -32772;
119pub const FMOD_THREAD_PRIORITY_VERY_HIGH: i32 = -32773;
120pub const FMOD_THREAD_PRIORITY_EXTREME: i32 = -32774;
121pub const FMOD_THREAD_PRIORITY_CRITICAL: i32 = -32775;
122pub const FMOD_THREAD_PRIORITY_MIXER: i32 = -32774;
123pub const FMOD_THREAD_PRIORITY_FEEDER: i32 = -32775;
124pub const FMOD_THREAD_PRIORITY_STREAM: i32 = -32773;
125pub const FMOD_THREAD_PRIORITY_FILE: i32 = -32772;
126pub const FMOD_THREAD_PRIORITY_NONBLOCKING: i32 = -32772;
127pub const FMOD_THREAD_PRIORITY_RECORD: i32 = -32772;
128pub const FMOD_THREAD_PRIORITY_GEOMETRY: i32 = -32770;
129pub const FMOD_THREAD_PRIORITY_PROFILER: i32 = -32771;
130pub const FMOD_THREAD_PRIORITY_STUDIO_UPDATE: i32 = -32771;
131pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_BANK: i32 = -32771;
132pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_SAMPLE: i32 = -32771;
133pub const FMOD_THREAD_PRIORITY_CONVOLUTION1: i32 = -32773;
134pub const FMOD_THREAD_PRIORITY_CONVOLUTION2: i32 = -32773;
135pub const FMOD_THREAD_STACK_SIZE_DEFAULT: u32 = 0;
136pub const FMOD_THREAD_STACK_SIZE_MIXER: u32 = 81920;
137pub const FMOD_THREAD_STACK_SIZE_FEEDER: u32 = 16384;
138pub const FMOD_THREAD_STACK_SIZE_STREAM: u32 = 98304;
139pub const FMOD_THREAD_STACK_SIZE_FILE: u32 = 65536;
140pub const FMOD_THREAD_STACK_SIZE_NONBLOCKING: u32 = 114688;
141pub const FMOD_THREAD_STACK_SIZE_RECORD: u32 = 16384;
142pub const FMOD_THREAD_STACK_SIZE_GEOMETRY: u32 = 49152;
143pub const FMOD_THREAD_STACK_SIZE_PROFILER: u32 = 131072;
144pub const FMOD_THREAD_STACK_SIZE_STUDIO_UPDATE: u32 = 98304;
145pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_BANK: u32 = 98304;
146pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_SAMPLE: u32 = 98304;
147pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION1: u32 = 16384;
148pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION2: u32 = 16384;
149pub const FMOD_THREAD_AFFINITY_GROUP_DEFAULT: u64 = 4611686018427387904;
150pub const FMOD_THREAD_AFFINITY_GROUP_A: u64 = 4611686018427387905;
151pub const FMOD_THREAD_AFFINITY_GROUP_B: u64 = 4611686018427387906;
152pub const FMOD_THREAD_AFFINITY_GROUP_C: u64 = 4611686018427387907;
153pub const FMOD_THREAD_AFFINITY_MIXER: u64 = 4611686018427387905;
154pub const FMOD_THREAD_AFFINITY_FEEDER: u64 = 4611686018427387907;
155pub const FMOD_THREAD_AFFINITY_STREAM: u64 = 4611686018427387907;
156pub const FMOD_THREAD_AFFINITY_FILE: u64 = 4611686018427387907;
157pub const FMOD_THREAD_AFFINITY_NONBLOCKING: u64 = 4611686018427387907;
158pub const FMOD_THREAD_AFFINITY_RECORD: u64 = 4611686018427387907;
159pub const FMOD_THREAD_AFFINITY_GEOMETRY: u64 = 4611686018427387907;
160pub const FMOD_THREAD_AFFINITY_PROFILER: u64 = 4611686018427387907;
161pub const FMOD_THREAD_AFFINITY_STUDIO_UPDATE: u64 = 4611686018427387906;
162pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_BANK: u64 = 4611686018427387907;
163pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_SAMPLE: u64 = 4611686018427387907;
164pub const FMOD_THREAD_AFFINITY_CONVOLUTION1: u64 = 4611686018427387907;
165pub const FMOD_THREAD_AFFINITY_CONVOLUTION2: u64 = 4611686018427387907;
166pub const FMOD_THREAD_AFFINITY_CORE_ALL: u32 = 0;
167pub const FMOD_THREAD_AFFINITY_CORE_0: u32 = 1;
168pub const FMOD_THREAD_AFFINITY_CORE_1: u32 = 2;
169pub const FMOD_THREAD_AFFINITY_CORE_2: u32 = 4;
170pub const FMOD_THREAD_AFFINITY_CORE_3: u32 = 8;
171pub const FMOD_THREAD_AFFINITY_CORE_4: u32 = 16;
172pub const FMOD_THREAD_AFFINITY_CORE_5: u32 = 32;
173pub const FMOD_THREAD_AFFINITY_CORE_6: u32 = 64;
174pub const FMOD_THREAD_AFFINITY_CORE_7: u32 = 128;
175pub const FMOD_THREAD_AFFINITY_CORE_8: u32 = 256;
176pub const FMOD_THREAD_AFFINITY_CORE_9: u32 = 512;
177pub const FMOD_THREAD_AFFINITY_CORE_10: u32 = 1024;
178pub const FMOD_THREAD_AFFINITY_CORE_11: u32 = 2048;
179pub const FMOD_THREAD_AFFINITY_CORE_12: u32 = 4096;
180pub const FMOD_THREAD_AFFINITY_CORE_13: u32 = 8192;
181pub const FMOD_THREAD_AFFINITY_CORE_14: u32 = 16384;
182pub const FMOD_THREAD_AFFINITY_CORE_15: u32 = 32768;
183pub const FMOD_MAX_CHANNEL_WIDTH: u32 = 32;
184pub const FMOD_MAX_SYSTEMS: u32 = 8;
185pub const FMOD_MAX_LISTENERS: u32 = 8;
186pub const FMOD_REVERB_MAXINSTANCES: u32 = 4;
187pub const FMOD_CODEC_PLUGIN_VERSION: u32 = 1;
188pub const FMOD_CODEC_SEEK_METHOD_SET: u32 = 0;
189pub const FMOD_CODEC_SEEK_METHOD_CURRENT: u32 = 1;
190pub const FMOD_CODEC_SEEK_METHOD_END: u32 = 2;
191pub const FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES: u32 = 66;
192pub const FMOD_PLUGIN_SDK_VERSION: u32 = 110;
193pub const FMOD_DSP_GETPARAM_VALUESTR_LENGTH: u32 = 32;
194pub const FMOD_OUTPUT_PLUGIN_VERSION: u32 = 5;
195pub const FMOD_OUTPUT_METHOD_MIX_DIRECT: u32 = 0;
196pub const FMOD_OUTPUT_METHOD_MIX_BUFFERED: u32 = 1;
197pub const __bool_true_false_are_defined: u32 = 1;
198pub const true_: u32 = 1;
199pub const false_: u32 = 0;
200pub const FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT: u32 = 32;
201pub const FMOD_STUDIO_INIT_NORMAL: u32 = 0;
202pub const FMOD_STUDIO_INIT_LIVEUPDATE: u32 = 1;
203pub const FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS: u32 = 2;
204pub const FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE: u32 = 4;
205pub const FMOD_STUDIO_INIT_DEFERRED_CALLBACKS: u32 = 8;
206pub const FMOD_STUDIO_INIT_LOAD_FROM_UPDATE: u32 = 16;
207pub const FMOD_STUDIO_INIT_MEMORY_TRACKING: u32 = 32;
208pub const FMOD_STUDIO_PARAMETER_READONLY: u32 = 1;
209pub const FMOD_STUDIO_PARAMETER_AUTOMATIC: u32 = 2;
210pub const FMOD_STUDIO_PARAMETER_GLOBAL: u32 = 4;
211pub const FMOD_STUDIO_PARAMETER_DISCRETE: u32 = 8;
212pub const FMOD_STUDIO_PARAMETER_LABELED: u32 = 16;
213pub const FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE: u32 = 1;
214pub const FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE: u32 = 2;
215pub const FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD: u32 = 4;
216pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED: u32 = 8;
217pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED: u32 = 16;
218pub const FMOD_STUDIO_SYSTEM_CALLBACK_ALL: u32 = 4294967295;
219pub const FMOD_STUDIO_EVENT_CALLBACK_CREATED: u32 = 1;
220pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROYED: u32 = 2;
221pub const FMOD_STUDIO_EVENT_CALLBACK_STARTING: u32 = 4;
222pub const FMOD_STUDIO_EVENT_CALLBACK_STARTED: u32 = 8;
223pub const FMOD_STUDIO_EVENT_CALLBACK_RESTARTED: u32 = 16;
224pub const FMOD_STUDIO_EVENT_CALLBACK_STOPPED: u32 = 32;
225pub const FMOD_STUDIO_EVENT_CALLBACK_START_FAILED: u32 = 64;
226pub const FMOD_STUDIO_EVENT_CALLBACK_CREATE_PROGRAMMER_SOUND: u32 = 128;
227pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROY_PROGRAMMER_SOUND: u32 = 256;
228pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_CREATED: u32 = 512;
229pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_DESTROYED: u32 = 1024;
230pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_MARKER: u32 = 2048;
231pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_BEAT: u32 = 4096;
232pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_PLAYED: u32 = 8192;
233pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_STOPPED: u32 = 16384;
234pub const FMOD_STUDIO_EVENT_CALLBACK_REAL_TO_VIRTUAL: u32 = 32768;
235pub const FMOD_STUDIO_EVENT_CALLBACK_VIRTUAL_TO_REAL: u32 = 65536;
236pub const FMOD_STUDIO_EVENT_CALLBACK_START_EVENT_COMMAND: u32 = 131072;
237pub const FMOD_STUDIO_EVENT_CALLBACK_NESTED_TIMELINE_BEAT: u32 = 262144;
238pub const FMOD_STUDIO_EVENT_CALLBACK_ALL: u32 = 4294967295;
239pub const FMOD_STUDIO_LOAD_BANK_NORMAL: u32 = 0;
240pub const FMOD_STUDIO_LOAD_BANK_NONBLOCKING: u32 = 1;
241pub const FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES: u32 = 2;
242pub const FMOD_STUDIO_LOAD_BANK_UNENCRYPTED: u32 = 4;
243pub const FMOD_STUDIO_COMMANDCAPTURE_NORMAL: u32 = 0;
244pub const FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH: u32 = 1;
245pub const FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE: u32 = 2;
246pub const FMOD_STUDIO_COMMANDREPLAY_NORMAL: u32 = 0;
247pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP: u32 = 1;
248pub const FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD: u32 = 2;
249pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD: u32 = 4;
250#[repr(transparent)]
251#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
252pub struct FMOD_BOOL(pub ::std::os::raw::c_int);
253#[repr(C)]
254#[derive(Debug, Copy, Clone)]
255pub struct FMOD_SYSTEM {
256 _unused: [u8; 0],
257}
258#[repr(C)]
259#[derive(Debug, Copy, Clone)]
260pub struct FMOD_SOUND {
261 _unused: [u8; 0],
262}
263#[repr(C)]
264#[derive(Debug, Copy, Clone)]
265pub struct FMOD_CHANNELCONTROL {
266 _unused: [u8; 0],
267}
268#[repr(C)]
269#[derive(Debug, Copy, Clone)]
270pub struct FMOD_CHANNEL {
271 _unused: [u8; 0],
272}
273#[repr(C)]
274#[derive(Debug, Copy, Clone)]
275pub struct FMOD_CHANNELGROUP {
276 _unused: [u8; 0],
277}
278#[repr(C)]
279#[derive(Debug, Copy, Clone)]
280pub struct FMOD_SOUNDGROUP {
281 _unused: [u8; 0],
282}
283#[repr(C)]
284#[derive(Debug, Copy, Clone)]
285pub struct FMOD_REVERB3D {
286 _unused: [u8; 0],
287}
288#[repr(C)]
289#[derive(Debug, Copy, Clone)]
290pub struct FMOD_DSP {
291 _unused: [u8; 0],
292}
293#[repr(C)]
294#[derive(Debug, Copy, Clone)]
295pub struct FMOD_DSPCONNECTION {
296 _unused: [u8; 0],
297}
298#[repr(C)]
299#[derive(Debug, Copy, Clone)]
300pub struct FMOD_POLYGON {
301 _unused: [u8; 0],
302}
303#[repr(C)]
304#[derive(Debug, Copy, Clone)]
305pub struct FMOD_GEOMETRY {
306 _unused: [u8; 0],
307}
308#[repr(C)]
309#[derive(Debug, Copy, Clone)]
310pub struct FMOD_SYNCPOINT {
311 _unused: [u8; 0],
312}
313pub type FMOD_DEBUG_FLAGS = ::std::os::raw::c_uint;
314pub type FMOD_MEMORY_TYPE = ::std::os::raw::c_uint;
315pub type FMOD_INITFLAGS = ::std::os::raw::c_uint;
316pub type FMOD_DRIVER_STATE = ::std::os::raw::c_uint;
317pub type FMOD_TIMEUNIT = ::std::os::raw::c_uint;
318pub type FMOD_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
319pub type FMOD_MODE = ::std::os::raw::c_uint;
320pub type FMOD_CHANNELMASK = ::std::os::raw::c_uint;
321pub type FMOD_PORT_INDEX = ::std::os::raw::c_ulonglong;
322pub type FMOD_THREAD_PRIORITY = ::std::os::raw::c_int;
323pub type FMOD_THREAD_STACK_SIZE = ::std::os::raw::c_uint;
324pub type FMOD_THREAD_AFFINITY = ::std::os::raw::c_longlong;
325pub const FMOD_THREAD_TYPE_MIXER: FMOD_THREAD_TYPE = 0;
326pub const FMOD_THREAD_TYPE_FEEDER: FMOD_THREAD_TYPE = 1;
327pub const FMOD_THREAD_TYPE_STREAM: FMOD_THREAD_TYPE = 2;
328pub const FMOD_THREAD_TYPE_FILE: FMOD_THREAD_TYPE = 3;
329pub const FMOD_THREAD_TYPE_NONBLOCKING: FMOD_THREAD_TYPE = 4;
330pub const FMOD_THREAD_TYPE_RECORD: FMOD_THREAD_TYPE = 5;
331pub const FMOD_THREAD_TYPE_GEOMETRY: FMOD_THREAD_TYPE = 6;
332pub const FMOD_THREAD_TYPE_PROFILER: FMOD_THREAD_TYPE = 7;
333pub const FMOD_THREAD_TYPE_STUDIO_UPDATE: FMOD_THREAD_TYPE = 8;
334pub const FMOD_THREAD_TYPE_STUDIO_LOAD_BANK: FMOD_THREAD_TYPE = 9;
335pub const FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE: FMOD_THREAD_TYPE = 10;
336pub const FMOD_THREAD_TYPE_CONVOLUTION1: FMOD_THREAD_TYPE = 11;
337pub const FMOD_THREAD_TYPE_CONVOLUTION2: FMOD_THREAD_TYPE = 12;
338pub const FMOD_THREAD_TYPE_MAX: FMOD_THREAD_TYPE = 13;
339pub const FMOD_THREAD_TYPE_FORCEINT: FMOD_THREAD_TYPE = 65536;
340pub type FMOD_THREAD_TYPE = ::std::os::raw::c_uint;
341impl FMOD_RESULT {
342 pub const FMOD_OK: FMOD_RESULT = FMOD_RESULT(0);
343}
344impl FMOD_RESULT {
345 pub const FMOD_ERR_BADCOMMAND: FMOD_RESULT = FMOD_RESULT(1);
346}
347impl FMOD_RESULT {
348 pub const FMOD_ERR_CHANNEL_ALLOC: FMOD_RESULT = FMOD_RESULT(2);
349}
350impl FMOD_RESULT {
351 pub const FMOD_ERR_CHANNEL_STOLEN: FMOD_RESULT = FMOD_RESULT(3);
352}
353impl FMOD_RESULT {
354 pub const FMOD_ERR_DMA: FMOD_RESULT = FMOD_RESULT(4);
355}
356impl FMOD_RESULT {
357 pub const FMOD_ERR_DSP_CONNECTION: FMOD_RESULT = FMOD_RESULT(5);
358}
359impl FMOD_RESULT {
360 pub const FMOD_ERR_DSP_DONTPROCESS: FMOD_RESULT = FMOD_RESULT(6);
361}
362impl FMOD_RESULT {
363 pub const FMOD_ERR_DSP_FORMAT: FMOD_RESULT = FMOD_RESULT(7);
364}
365impl FMOD_RESULT {
366 pub const FMOD_ERR_DSP_INUSE: FMOD_RESULT = FMOD_RESULT(8);
367}
368impl FMOD_RESULT {
369 pub const FMOD_ERR_DSP_NOTFOUND: FMOD_RESULT = FMOD_RESULT(9);
370}
371impl FMOD_RESULT {
372 pub const FMOD_ERR_DSP_RESERVED: FMOD_RESULT = FMOD_RESULT(10);
373}
374impl FMOD_RESULT {
375 pub const FMOD_ERR_DSP_SILENCE: FMOD_RESULT = FMOD_RESULT(11);
376}
377impl FMOD_RESULT {
378 pub const FMOD_ERR_DSP_TYPE: FMOD_RESULT = FMOD_RESULT(12);
379}
380impl FMOD_RESULT {
381 pub const FMOD_ERR_FILE_BAD: FMOD_RESULT = FMOD_RESULT(13);
382}
383impl FMOD_RESULT {
384 pub const FMOD_ERR_FILE_COULDNOTSEEK: FMOD_RESULT = FMOD_RESULT(14);
385}
386impl FMOD_RESULT {
387 pub const FMOD_ERR_FILE_DISKEJECTED: FMOD_RESULT = FMOD_RESULT(15);
388}
389impl FMOD_RESULT {
390 pub const FMOD_ERR_FILE_EOF: FMOD_RESULT = FMOD_RESULT(16);
391}
392impl FMOD_RESULT {
393 pub const FMOD_ERR_FILE_ENDOFDATA: FMOD_RESULT = FMOD_RESULT(17);
394}
395impl FMOD_RESULT {
396 pub const FMOD_ERR_FILE_NOTFOUND: FMOD_RESULT = FMOD_RESULT(18);
397}
398impl FMOD_RESULT {
399 pub const FMOD_ERR_FORMAT: FMOD_RESULT = FMOD_RESULT(19);
400}
401impl FMOD_RESULT {
402 pub const FMOD_ERR_HEADER_MISMATCH: FMOD_RESULT = FMOD_RESULT(20);
403}
404impl FMOD_RESULT {
405 pub const FMOD_ERR_HTTP: FMOD_RESULT = FMOD_RESULT(21);
406}
407impl FMOD_RESULT {
408 pub const FMOD_ERR_HTTP_ACCESS: FMOD_RESULT = FMOD_RESULT(22);
409}
410impl FMOD_RESULT {
411 pub const FMOD_ERR_HTTP_PROXY_AUTH: FMOD_RESULT = FMOD_RESULT(23);
412}
413impl FMOD_RESULT {
414 pub const FMOD_ERR_HTTP_SERVER_ERROR: FMOD_RESULT = FMOD_RESULT(24);
415}
416impl FMOD_RESULT {
417 pub const FMOD_ERR_HTTP_TIMEOUT: FMOD_RESULT = FMOD_RESULT(25);
418}
419impl FMOD_RESULT {
420 pub const FMOD_ERR_INITIALIZATION: FMOD_RESULT = FMOD_RESULT(26);
421}
422impl FMOD_RESULT {
423 pub const FMOD_ERR_INITIALIZED: FMOD_RESULT = FMOD_RESULT(27);
424}
425impl FMOD_RESULT {
426 pub const FMOD_ERR_INTERNAL: FMOD_RESULT = FMOD_RESULT(28);
427}
428impl FMOD_RESULT {
429 pub const FMOD_ERR_INVALID_FLOAT: FMOD_RESULT = FMOD_RESULT(29);
430}
431impl FMOD_RESULT {
432 pub const FMOD_ERR_INVALID_HANDLE: FMOD_RESULT = FMOD_RESULT(30);
433}
434impl FMOD_RESULT {
435 pub const FMOD_ERR_INVALID_PARAM: FMOD_RESULT = FMOD_RESULT(31);
436}
437impl FMOD_RESULT {
438 pub const FMOD_ERR_INVALID_POSITION: FMOD_RESULT = FMOD_RESULT(32);
439}
440impl FMOD_RESULT {
441 pub const FMOD_ERR_INVALID_SPEAKER: FMOD_RESULT = FMOD_RESULT(33);
442}
443impl FMOD_RESULT {
444 pub const FMOD_ERR_INVALID_SYNCPOINT: FMOD_RESULT = FMOD_RESULT(34);
445}
446impl FMOD_RESULT {
447 pub const FMOD_ERR_INVALID_THREAD: FMOD_RESULT = FMOD_RESULT(35);
448}
449impl FMOD_RESULT {
450 pub const FMOD_ERR_INVALID_VECTOR: FMOD_RESULT = FMOD_RESULT(36);
451}
452impl FMOD_RESULT {
453 pub const FMOD_ERR_MAXAUDIBLE: FMOD_RESULT = FMOD_RESULT(37);
454}
455impl FMOD_RESULT {
456 pub const FMOD_ERR_MEMORY: FMOD_RESULT = FMOD_RESULT(38);
457}
458impl FMOD_RESULT {
459 pub const FMOD_ERR_MEMORY_CANTPOINT: FMOD_RESULT = FMOD_RESULT(39);
460}
461impl FMOD_RESULT {
462 pub const FMOD_ERR_NEEDS3D: FMOD_RESULT = FMOD_RESULT(40);
463}
464impl FMOD_RESULT {
465 pub const FMOD_ERR_NEEDSHARDWARE: FMOD_RESULT = FMOD_RESULT(41);
466}
467impl FMOD_RESULT {
468 pub const FMOD_ERR_NET_CONNECT: FMOD_RESULT = FMOD_RESULT(42);
469}
470impl FMOD_RESULT {
471 pub const FMOD_ERR_NET_SOCKET_ERROR: FMOD_RESULT = FMOD_RESULT(43);
472}
473impl FMOD_RESULT {
474 pub const FMOD_ERR_NET_URL: FMOD_RESULT = FMOD_RESULT(44);
475}
476impl FMOD_RESULT {
477 pub const FMOD_ERR_NET_WOULD_BLOCK: FMOD_RESULT = FMOD_RESULT(45);
478}
479impl FMOD_RESULT {
480 pub const FMOD_ERR_NOTREADY: FMOD_RESULT = FMOD_RESULT(46);
481}
482impl FMOD_RESULT {
483 pub const FMOD_ERR_OUTPUT_ALLOCATED: FMOD_RESULT = FMOD_RESULT(47);
484}
485impl FMOD_RESULT {
486 pub const FMOD_ERR_OUTPUT_CREATEBUFFER: FMOD_RESULT = FMOD_RESULT(48);
487}
488impl FMOD_RESULT {
489 pub const FMOD_ERR_OUTPUT_DRIVERCALL: FMOD_RESULT = FMOD_RESULT(49);
490}
491impl FMOD_RESULT {
492 pub const FMOD_ERR_OUTPUT_FORMAT: FMOD_RESULT = FMOD_RESULT(50);
493}
494impl FMOD_RESULT {
495 pub const FMOD_ERR_OUTPUT_INIT: FMOD_RESULT = FMOD_RESULT(51);
496}
497impl FMOD_RESULT {
498 pub const FMOD_ERR_OUTPUT_NODRIVERS: FMOD_RESULT = FMOD_RESULT(52);
499}
500impl FMOD_RESULT {
501 pub const FMOD_ERR_PLUGIN: FMOD_RESULT = FMOD_RESULT(53);
502}
503impl FMOD_RESULT {
504 pub const FMOD_ERR_PLUGIN_MISSING: FMOD_RESULT = FMOD_RESULT(54);
505}
506impl FMOD_RESULT {
507 pub const FMOD_ERR_PLUGIN_RESOURCE: FMOD_RESULT = FMOD_RESULT(55);
508}
509impl FMOD_RESULT {
510 pub const FMOD_ERR_PLUGIN_VERSION: FMOD_RESULT = FMOD_RESULT(56);
511}
512impl FMOD_RESULT {
513 pub const FMOD_ERR_RECORD: FMOD_RESULT = FMOD_RESULT(57);
514}
515impl FMOD_RESULT {
516 pub const FMOD_ERR_REVERB_CHANNELGROUP: FMOD_RESULT = FMOD_RESULT(58);
517}
518impl FMOD_RESULT {
519 pub const FMOD_ERR_REVERB_INSTANCE: FMOD_RESULT = FMOD_RESULT(59);
520}
521impl FMOD_RESULT {
522 pub const FMOD_ERR_SUBSOUNDS: FMOD_RESULT = FMOD_RESULT(60);
523}
524impl FMOD_RESULT {
525 pub const FMOD_ERR_SUBSOUND_ALLOCATED: FMOD_RESULT = FMOD_RESULT(61);
526}
527impl FMOD_RESULT {
528 pub const FMOD_ERR_SUBSOUND_CANTMOVE: FMOD_RESULT = FMOD_RESULT(62);
529}
530impl FMOD_RESULT {
531 pub const FMOD_ERR_TAGNOTFOUND: FMOD_RESULT = FMOD_RESULT(63);
532}
533impl FMOD_RESULT {
534 pub const FMOD_ERR_TOOMANYCHANNELS: FMOD_RESULT = FMOD_RESULT(64);
535}
536impl FMOD_RESULT {
537 pub const FMOD_ERR_TRUNCATED: FMOD_RESULT = FMOD_RESULT(65);
538}
539impl FMOD_RESULT {
540 pub const FMOD_ERR_UNIMPLEMENTED: FMOD_RESULT = FMOD_RESULT(66);
541}
542impl FMOD_RESULT {
543 pub const FMOD_ERR_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(67);
544}
545impl FMOD_RESULT {
546 pub const FMOD_ERR_UNSUPPORTED: FMOD_RESULT = FMOD_RESULT(68);
547}
548impl FMOD_RESULT {
549 pub const FMOD_ERR_VERSION: FMOD_RESULT = FMOD_RESULT(69);
550}
551impl FMOD_RESULT {
552 pub const FMOD_ERR_EVENT_ALREADY_LOADED: FMOD_RESULT = FMOD_RESULT(70);
553}
554impl FMOD_RESULT {
555 pub const FMOD_ERR_EVENT_LIVEUPDATE_BUSY: FMOD_RESULT = FMOD_RESULT(71);
556}
557impl FMOD_RESULT {
558 pub const FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH: FMOD_RESULT = FMOD_RESULT(72);
559}
560impl FMOD_RESULT {
561 pub const FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT: FMOD_RESULT = FMOD_RESULT(73);
562}
563impl FMOD_RESULT {
564 pub const FMOD_ERR_EVENT_NOTFOUND: FMOD_RESULT = FMOD_RESULT(74);
565}
566impl FMOD_RESULT {
567 pub const FMOD_ERR_STUDIO_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(75);
568}
569impl FMOD_RESULT {
570 pub const FMOD_ERR_STUDIO_NOT_LOADED: FMOD_RESULT = FMOD_RESULT(76);
571}
572impl FMOD_RESULT {
573 pub const FMOD_ERR_INVALID_STRING: FMOD_RESULT = FMOD_RESULT(77);
574}
575impl FMOD_RESULT {
576 pub const FMOD_ERR_ALREADY_LOCKED: FMOD_RESULT = FMOD_RESULT(78);
577}
578impl FMOD_RESULT {
579 pub const FMOD_ERR_NOT_LOCKED: FMOD_RESULT = FMOD_RESULT(79);
580}
581impl FMOD_RESULT {
582 pub const FMOD_ERR_RECORD_DISCONNECTED: FMOD_RESULT = FMOD_RESULT(80);
583}
584impl FMOD_RESULT {
585 pub const FMOD_ERR_TOOMANYSAMPLES: FMOD_RESULT = FMOD_RESULT(81);
586}
587impl FMOD_RESULT {
588 pub const FMOD_RESULT_FORCEINT: FMOD_RESULT = FMOD_RESULT(65536);
589}
590#[repr(transparent)]
591#[must_use]
592#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
593pub struct FMOD_RESULT(pub ::std::os::raw::c_uint);
594pub const FMOD_CHANNELCONTROL_CHANNEL: FMOD_CHANNELCONTROL_TYPE = 0;
595pub const FMOD_CHANNELCONTROL_CHANNELGROUP: FMOD_CHANNELCONTROL_TYPE = 1;
596pub const FMOD_CHANNELCONTROL_MAX: FMOD_CHANNELCONTROL_TYPE = 2;
597pub const FMOD_CHANNELCONTROL_FORCEINT: FMOD_CHANNELCONTROL_TYPE = 65536;
598pub type FMOD_CHANNELCONTROL_TYPE = ::std::os::raw::c_uint;
599pub const FMOD_OUTPUTTYPE_AUTODETECT: FMOD_OUTPUTTYPE = 0;
600pub const FMOD_OUTPUTTYPE_UNKNOWN: FMOD_OUTPUTTYPE = 1;
601pub const FMOD_OUTPUTTYPE_NOSOUND: FMOD_OUTPUTTYPE = 2;
602pub const FMOD_OUTPUTTYPE_WAVWRITER: FMOD_OUTPUTTYPE = 3;
603pub const FMOD_OUTPUTTYPE_NOSOUND_NRT: FMOD_OUTPUTTYPE = 4;
604pub const FMOD_OUTPUTTYPE_WAVWRITER_NRT: FMOD_OUTPUTTYPE = 5;
605pub const FMOD_OUTPUTTYPE_WASAPI: FMOD_OUTPUTTYPE = 6;
606pub const FMOD_OUTPUTTYPE_ASIO: FMOD_OUTPUTTYPE = 7;
607pub const FMOD_OUTPUTTYPE_PULSEAUDIO: FMOD_OUTPUTTYPE = 8;
608pub const FMOD_OUTPUTTYPE_ALSA: FMOD_OUTPUTTYPE = 9;
609pub const FMOD_OUTPUTTYPE_COREAUDIO: FMOD_OUTPUTTYPE = 10;
610pub const FMOD_OUTPUTTYPE_AUDIOTRACK: FMOD_OUTPUTTYPE = 11;
611pub const FMOD_OUTPUTTYPE_OPENSL: FMOD_OUTPUTTYPE = 12;
612pub const FMOD_OUTPUTTYPE_AUDIOOUT: FMOD_OUTPUTTYPE = 13;
613pub const FMOD_OUTPUTTYPE_AUDIO3D: FMOD_OUTPUTTYPE = 14;
614pub const FMOD_OUTPUTTYPE_WEBAUDIO: FMOD_OUTPUTTYPE = 15;
615pub const FMOD_OUTPUTTYPE_NNAUDIO: FMOD_OUTPUTTYPE = 16;
616pub const FMOD_OUTPUTTYPE_WINSONIC: FMOD_OUTPUTTYPE = 17;
617pub const FMOD_OUTPUTTYPE_AAUDIO: FMOD_OUTPUTTYPE = 18;
618pub const FMOD_OUTPUTTYPE_AUDIOWORKLET: FMOD_OUTPUTTYPE = 19;
619pub const FMOD_OUTPUTTYPE_PHASE: FMOD_OUTPUTTYPE = 20;
620pub const FMOD_OUTPUTTYPE_OHAUDIO: FMOD_OUTPUTTYPE = 21;
621pub const FMOD_OUTPUTTYPE_MAX: FMOD_OUTPUTTYPE = 22;
622pub const FMOD_OUTPUTTYPE_FORCEINT: FMOD_OUTPUTTYPE = 65536;
623pub type FMOD_OUTPUTTYPE = ::std::os::raw::c_uint;
624pub const FMOD_DEBUG_MODE_TTY: FMOD_DEBUG_MODE = 0;
625pub const FMOD_DEBUG_MODE_FILE: FMOD_DEBUG_MODE = 1;
626pub const FMOD_DEBUG_MODE_CALLBACK: FMOD_DEBUG_MODE = 2;
627pub const FMOD_DEBUG_MODE_FORCEINT: FMOD_DEBUG_MODE = 65536;
628pub type FMOD_DEBUG_MODE = ::std::os::raw::c_uint;
629pub const FMOD_SPEAKERMODE_DEFAULT: FMOD_SPEAKERMODE = 0;
630pub const FMOD_SPEAKERMODE_RAW: FMOD_SPEAKERMODE = 1;
631pub const FMOD_SPEAKERMODE_MONO: FMOD_SPEAKERMODE = 2;
632pub const FMOD_SPEAKERMODE_STEREO: FMOD_SPEAKERMODE = 3;
633pub const FMOD_SPEAKERMODE_QUAD: FMOD_SPEAKERMODE = 4;
634pub const FMOD_SPEAKERMODE_SURROUND: FMOD_SPEAKERMODE = 5;
635pub const FMOD_SPEAKERMODE_5POINT1: FMOD_SPEAKERMODE = 6;
636pub const FMOD_SPEAKERMODE_7POINT1: FMOD_SPEAKERMODE = 7;
637pub const FMOD_SPEAKERMODE_7POINT1POINT4: FMOD_SPEAKERMODE = 8;
638pub const FMOD_SPEAKERMODE_MAX: FMOD_SPEAKERMODE = 9;
639pub const FMOD_SPEAKERMODE_FORCEINT: FMOD_SPEAKERMODE = 65536;
640pub type FMOD_SPEAKERMODE = ::std::os::raw::c_uint;
641pub const FMOD_SPEAKER_NONE: FMOD_SPEAKER = -1;
642pub const FMOD_SPEAKER_FRONT_LEFT: FMOD_SPEAKER = 0;
643pub const FMOD_SPEAKER_FRONT_RIGHT: FMOD_SPEAKER = 1;
644pub const FMOD_SPEAKER_FRONT_CENTER: FMOD_SPEAKER = 2;
645pub const FMOD_SPEAKER_LOW_FREQUENCY: FMOD_SPEAKER = 3;
646pub const FMOD_SPEAKER_SURROUND_LEFT: FMOD_SPEAKER = 4;
647pub const FMOD_SPEAKER_SURROUND_RIGHT: FMOD_SPEAKER = 5;
648pub const FMOD_SPEAKER_BACK_LEFT: FMOD_SPEAKER = 6;
649pub const FMOD_SPEAKER_BACK_RIGHT: FMOD_SPEAKER = 7;
650pub const FMOD_SPEAKER_TOP_FRONT_LEFT: FMOD_SPEAKER = 8;
651pub const FMOD_SPEAKER_TOP_FRONT_RIGHT: FMOD_SPEAKER = 9;
652pub const FMOD_SPEAKER_TOP_BACK_LEFT: FMOD_SPEAKER = 10;
653pub const FMOD_SPEAKER_TOP_BACK_RIGHT: FMOD_SPEAKER = 11;
654pub const FMOD_SPEAKER_MAX: FMOD_SPEAKER = 12;
655pub const FMOD_SPEAKER_FORCEINT: FMOD_SPEAKER = 65536;
656pub type FMOD_SPEAKER = ::std::os::raw::c_int;
657pub const FMOD_CHANNELORDER_DEFAULT: FMOD_CHANNELORDER = 0;
658pub const FMOD_CHANNELORDER_WAVEFORMAT: FMOD_CHANNELORDER = 1;
659pub const FMOD_CHANNELORDER_PROTOOLS: FMOD_CHANNELORDER = 2;
660pub const FMOD_CHANNELORDER_ALLMONO: FMOD_CHANNELORDER = 3;
661pub const FMOD_CHANNELORDER_ALLSTEREO: FMOD_CHANNELORDER = 4;
662pub const FMOD_CHANNELORDER_ALSA: FMOD_CHANNELORDER = 5;
663pub const FMOD_CHANNELORDER_MAX: FMOD_CHANNELORDER = 6;
664pub const FMOD_CHANNELORDER_FORCEINT: FMOD_CHANNELORDER = 65536;
665pub type FMOD_CHANNELORDER = ::std::os::raw::c_uint;
666pub const FMOD_PLUGINTYPE_OUTPUT: FMOD_PLUGINTYPE = 0;
667pub const FMOD_PLUGINTYPE_CODEC: FMOD_PLUGINTYPE = 1;
668pub const FMOD_PLUGINTYPE_DSP: FMOD_PLUGINTYPE = 2;
669pub const FMOD_PLUGINTYPE_MAX: FMOD_PLUGINTYPE = 3;
670pub const FMOD_PLUGINTYPE_FORCEINT: FMOD_PLUGINTYPE = 65536;
671pub type FMOD_PLUGINTYPE = ::std::os::raw::c_uint;
672pub const FMOD_SOUND_TYPE_UNKNOWN: FMOD_SOUND_TYPE = 0;
673pub const FMOD_SOUND_TYPE_AIFF: FMOD_SOUND_TYPE = 1;
674pub const FMOD_SOUND_TYPE_ASF: FMOD_SOUND_TYPE = 2;
675pub const FMOD_SOUND_TYPE_DLS: FMOD_SOUND_TYPE = 3;
676pub const FMOD_SOUND_TYPE_FLAC: FMOD_SOUND_TYPE = 4;
677pub const FMOD_SOUND_TYPE_FSB: FMOD_SOUND_TYPE = 5;
678pub const FMOD_SOUND_TYPE_IT: FMOD_SOUND_TYPE = 6;
679pub const FMOD_SOUND_TYPE_MIDI: FMOD_SOUND_TYPE = 7;
680pub const FMOD_SOUND_TYPE_MOD: FMOD_SOUND_TYPE = 8;
681pub const FMOD_SOUND_TYPE_MPEG: FMOD_SOUND_TYPE = 9;
682pub const FMOD_SOUND_TYPE_OGGVORBIS: FMOD_SOUND_TYPE = 10;
683pub const FMOD_SOUND_TYPE_PLAYLIST: FMOD_SOUND_TYPE = 11;
684pub const FMOD_SOUND_TYPE_RAW: FMOD_SOUND_TYPE = 12;
685pub const FMOD_SOUND_TYPE_S3M: FMOD_SOUND_TYPE = 13;
686pub const FMOD_SOUND_TYPE_USER: FMOD_SOUND_TYPE = 14;
687pub const FMOD_SOUND_TYPE_WAV: FMOD_SOUND_TYPE = 15;
688pub const FMOD_SOUND_TYPE_XM: FMOD_SOUND_TYPE = 16;
689pub const FMOD_SOUND_TYPE_XMA: FMOD_SOUND_TYPE = 17;
690pub const FMOD_SOUND_TYPE_AUDIOQUEUE: FMOD_SOUND_TYPE = 18;
691pub const FMOD_SOUND_TYPE_AT9: FMOD_SOUND_TYPE = 19;
692pub const FMOD_SOUND_TYPE_VORBIS: FMOD_SOUND_TYPE = 20;
693pub const FMOD_SOUND_TYPE_MEDIA_FOUNDATION: FMOD_SOUND_TYPE = 21;
694pub const FMOD_SOUND_TYPE_MEDIACODEC: FMOD_SOUND_TYPE = 22;
695pub const FMOD_SOUND_TYPE_FADPCM: FMOD_SOUND_TYPE = 23;
696pub const FMOD_SOUND_TYPE_OPUS: FMOD_SOUND_TYPE = 24;
697pub const FMOD_SOUND_TYPE_MAX: FMOD_SOUND_TYPE = 25;
698pub const FMOD_SOUND_TYPE_FORCEINT: FMOD_SOUND_TYPE = 65536;
699pub type FMOD_SOUND_TYPE = ::std::os::raw::c_uint;
700pub const FMOD_SOUND_FORMAT_NONE: FMOD_SOUND_FORMAT = 0;
701pub const FMOD_SOUND_FORMAT_PCM8: FMOD_SOUND_FORMAT = 1;
702pub const FMOD_SOUND_FORMAT_PCM16: FMOD_SOUND_FORMAT = 2;
703pub const FMOD_SOUND_FORMAT_PCM24: FMOD_SOUND_FORMAT = 3;
704pub const FMOD_SOUND_FORMAT_PCM32: FMOD_SOUND_FORMAT = 4;
705pub const FMOD_SOUND_FORMAT_PCMFLOAT: FMOD_SOUND_FORMAT = 5;
706pub const FMOD_SOUND_FORMAT_BITSTREAM: FMOD_SOUND_FORMAT = 6;
707pub const FMOD_SOUND_FORMAT_MAX: FMOD_SOUND_FORMAT = 7;
708pub const FMOD_SOUND_FORMAT_FORCEINT: FMOD_SOUND_FORMAT = 65536;
709pub type FMOD_SOUND_FORMAT = ::std::os::raw::c_uint;
710pub const FMOD_OPENSTATE_READY: FMOD_OPENSTATE = 0;
711pub const FMOD_OPENSTATE_LOADING: FMOD_OPENSTATE = 1;
712pub const FMOD_OPENSTATE_ERROR: FMOD_OPENSTATE = 2;
713pub const FMOD_OPENSTATE_CONNECTING: FMOD_OPENSTATE = 3;
714pub const FMOD_OPENSTATE_BUFFERING: FMOD_OPENSTATE = 4;
715pub const FMOD_OPENSTATE_SEEKING: FMOD_OPENSTATE = 5;
716pub const FMOD_OPENSTATE_PLAYING: FMOD_OPENSTATE = 6;
717pub const FMOD_OPENSTATE_SETPOSITION: FMOD_OPENSTATE = 7;
718pub const FMOD_OPENSTATE_MAX: FMOD_OPENSTATE = 8;
719pub const FMOD_OPENSTATE_FORCEINT: FMOD_OPENSTATE = 65536;
720pub type FMOD_OPENSTATE = ::std::os::raw::c_uint;
721pub const FMOD_SOUNDGROUP_BEHAVIOR_FAIL: FMOD_SOUNDGROUP_BEHAVIOR = 0;
722pub const FMOD_SOUNDGROUP_BEHAVIOR_MUTE: FMOD_SOUNDGROUP_BEHAVIOR = 1;
723pub const FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST: FMOD_SOUNDGROUP_BEHAVIOR = 2;
724pub const FMOD_SOUNDGROUP_BEHAVIOR_MAX: FMOD_SOUNDGROUP_BEHAVIOR = 3;
725pub const FMOD_SOUNDGROUP_BEHAVIOR_FORCEINT: FMOD_SOUNDGROUP_BEHAVIOR = 65536;
726pub type FMOD_SOUNDGROUP_BEHAVIOR = ::std::os::raw::c_uint;
727pub const FMOD_CHANNELCONTROL_CALLBACK_END: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 0;
728pub const FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 1;
729pub const FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 2;
730pub const FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 3;
731pub const FMOD_CHANNELCONTROL_CALLBACK_MAX: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 4;
732pub const FMOD_CHANNELCONTROL_CALLBACK_FORCEINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 65536;
733pub type FMOD_CHANNELCONTROL_CALLBACK_TYPE = ::std::os::raw::c_uint;
734pub const FMOD_CHANNELCONTROL_DSP_HEAD: FMOD_CHANNELCONTROL_DSP_INDEX = -1;
735pub const FMOD_CHANNELCONTROL_DSP_FADER: FMOD_CHANNELCONTROL_DSP_INDEX = -2;
736pub const FMOD_CHANNELCONTROL_DSP_TAIL: FMOD_CHANNELCONTROL_DSP_INDEX = -3;
737pub const FMOD_CHANNELCONTROL_DSP_FORCEINT: FMOD_CHANNELCONTROL_DSP_INDEX = 65536;
738pub type FMOD_CHANNELCONTROL_DSP_INDEX = ::std::os::raw::c_int;
739pub const FMOD_ERRORCALLBACK_INSTANCETYPE_NONE: FMOD_ERRORCALLBACK_INSTANCETYPE = 0;
740pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 1;
741pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL: FMOD_ERRORCALLBACK_INSTANCETYPE = 2;
742pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 3;
743pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL: FMOD_ERRORCALLBACK_INSTANCETYPE = 4;
744pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND: FMOD_ERRORCALLBACK_INSTANCETYPE = 5;
745pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 6;
746pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSP: FMOD_ERRORCALLBACK_INSTANCETYPE = 7;
747pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION: FMOD_ERRORCALLBACK_INSTANCETYPE = 8;
748pub const FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY: FMOD_ERRORCALLBACK_INSTANCETYPE = 9;
749pub const FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D: FMOD_ERRORCALLBACK_INSTANCETYPE = 10;
750pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 11;
751pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION: FMOD_ERRORCALLBACK_INSTANCETYPE =
752 12;
753pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE: FMOD_ERRORCALLBACK_INSTANCETYPE =
754 13;
755pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE:
756 FMOD_ERRORCALLBACK_INSTANCETYPE = 14;
757pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS: FMOD_ERRORCALLBACK_INSTANCETYPE = 15;
758pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA: FMOD_ERRORCALLBACK_INSTANCETYPE = 16;
759pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK: FMOD_ERRORCALLBACK_INSTANCETYPE = 17;
760pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY: FMOD_ERRORCALLBACK_INSTANCETYPE =
761 18;
762pub const FMOD_ERRORCALLBACK_INSTANCETYPE_FORCEINT: FMOD_ERRORCALLBACK_INSTANCETYPE = 65536;
763pub type FMOD_ERRORCALLBACK_INSTANCETYPE = ::std::os::raw::c_uint;
764pub const FMOD_DSP_RESAMPLER_DEFAULT: FMOD_DSP_RESAMPLER = 0;
765pub const FMOD_DSP_RESAMPLER_NOINTERP: FMOD_DSP_RESAMPLER = 1;
766pub const FMOD_DSP_RESAMPLER_LINEAR: FMOD_DSP_RESAMPLER = 2;
767pub const FMOD_DSP_RESAMPLER_CUBIC: FMOD_DSP_RESAMPLER = 3;
768pub const FMOD_DSP_RESAMPLER_SPLINE: FMOD_DSP_RESAMPLER = 4;
769pub const FMOD_DSP_RESAMPLER_MAX: FMOD_DSP_RESAMPLER = 5;
770pub const FMOD_DSP_RESAMPLER_FORCEINT: FMOD_DSP_RESAMPLER = 65536;
771pub type FMOD_DSP_RESAMPLER = ::std::os::raw::c_uint;
772pub const FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE: FMOD_DSP_CALLBACK_TYPE = 0;
773pub const FMOD_DSP_CALLBACK_MAX: FMOD_DSP_CALLBACK_TYPE = 1;
774pub const FMOD_DSP_CALLBACK_FORCEINT: FMOD_DSP_CALLBACK_TYPE = 65536;
775pub type FMOD_DSP_CALLBACK_TYPE = ::std::os::raw::c_uint;
776pub const FMOD_DSPCONNECTION_TYPE_STANDARD: FMOD_DSPCONNECTION_TYPE = 0;
777pub const FMOD_DSPCONNECTION_TYPE_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 1;
778pub const FMOD_DSPCONNECTION_TYPE_SEND: FMOD_DSPCONNECTION_TYPE = 2;
779pub const FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 3;
780pub const FMOD_DSPCONNECTION_TYPE_MAX: FMOD_DSPCONNECTION_TYPE = 4;
781pub const FMOD_DSPCONNECTION_TYPE_FORCEINT: FMOD_DSPCONNECTION_TYPE = 65536;
782pub type FMOD_DSPCONNECTION_TYPE = ::std::os::raw::c_uint;
783pub const FMOD_TAGTYPE_UNKNOWN: FMOD_TAGTYPE = 0;
784pub const FMOD_TAGTYPE_ID3V1: FMOD_TAGTYPE = 1;
785pub const FMOD_TAGTYPE_ID3V2: FMOD_TAGTYPE = 2;
786pub const FMOD_TAGTYPE_VORBISCOMMENT: FMOD_TAGTYPE = 3;
787pub const FMOD_TAGTYPE_SHOUTCAST: FMOD_TAGTYPE = 4;
788pub const FMOD_TAGTYPE_ICECAST: FMOD_TAGTYPE = 5;
789pub const FMOD_TAGTYPE_ASF: FMOD_TAGTYPE = 6;
790pub const FMOD_TAGTYPE_MIDI: FMOD_TAGTYPE = 7;
791pub const FMOD_TAGTYPE_PLAYLIST: FMOD_TAGTYPE = 8;
792pub const FMOD_TAGTYPE_FMOD: FMOD_TAGTYPE = 9;
793pub const FMOD_TAGTYPE_USER: FMOD_TAGTYPE = 10;
794pub const FMOD_TAGTYPE_MAX: FMOD_TAGTYPE = 11;
795pub const FMOD_TAGTYPE_FORCEINT: FMOD_TAGTYPE = 65536;
796pub type FMOD_TAGTYPE = ::std::os::raw::c_uint;
797pub const FMOD_TAGDATATYPE_BINARY: FMOD_TAGDATATYPE = 0;
798pub const FMOD_TAGDATATYPE_INT: FMOD_TAGDATATYPE = 1;
799pub const FMOD_TAGDATATYPE_FLOAT: FMOD_TAGDATATYPE = 2;
800pub const FMOD_TAGDATATYPE_STRING: FMOD_TAGDATATYPE = 3;
801pub const FMOD_TAGDATATYPE_STRING_UTF16: FMOD_TAGDATATYPE = 4;
802pub const FMOD_TAGDATATYPE_STRING_UTF16BE: FMOD_TAGDATATYPE = 5;
803pub const FMOD_TAGDATATYPE_STRING_UTF8: FMOD_TAGDATATYPE = 6;
804pub const FMOD_TAGDATATYPE_MAX: FMOD_TAGDATATYPE = 7;
805pub const FMOD_TAGDATATYPE_FORCEINT: FMOD_TAGDATATYPE = 65536;
806pub type FMOD_TAGDATATYPE = ::std::os::raw::c_uint;
807pub const FMOD_PORT_TYPE_MUSIC: FMOD_PORT_TYPE = 0;
808pub const FMOD_PORT_TYPE_COPYRIGHT_MUSIC: FMOD_PORT_TYPE = 1;
809pub const FMOD_PORT_TYPE_VOICE: FMOD_PORT_TYPE = 2;
810pub const FMOD_PORT_TYPE_CONTROLLER: FMOD_PORT_TYPE = 3;
811pub const FMOD_PORT_TYPE_PERSONAL: FMOD_PORT_TYPE = 4;
812pub const FMOD_PORT_TYPE_VIBRATION: FMOD_PORT_TYPE = 5;
813pub const FMOD_PORT_TYPE_AUX: FMOD_PORT_TYPE = 6;
814pub const FMOD_PORT_TYPE_PASSTHROUGH: FMOD_PORT_TYPE = 7;
815pub const FMOD_PORT_TYPE_VR_VIBRATION: FMOD_PORT_TYPE = 8;
816pub const FMOD_PORT_TYPE_MAX: FMOD_PORT_TYPE = 9;
817pub const FMOD_PORT_TYPE_FORCEINT: FMOD_PORT_TYPE = 65536;
818pub type FMOD_PORT_TYPE = ::std::os::raw::c_uint;
819pub type FMOD_DEBUG_CALLBACK = ::std::option::Option<
820 unsafe extern "C" fn(
821 flags: FMOD_DEBUG_FLAGS,
822 file: *const ::std::os::raw::c_char,
823 line: ::std::os::raw::c_int,
824 func: *const ::std::os::raw::c_char,
825 message: *const ::std::os::raw::c_char,
826 ) -> FMOD_RESULT,
827>;
828pub type FMOD_SYSTEM_CALLBACK = ::std::option::Option<
829 unsafe extern "C" fn(
830 system: *mut FMOD_SYSTEM,
831 type_: FMOD_SYSTEM_CALLBACK_TYPE,
832 commanddata1: *mut ::std::os::raw::c_void,
833 commanddata2: *mut ::std::os::raw::c_void,
834 userdata: *mut ::std::os::raw::c_void,
835 ) -> FMOD_RESULT,
836>;
837pub type FMOD_CHANNELCONTROL_CALLBACK = ::std::option::Option<
838 unsafe extern "C" fn(
839 channelcontrol: *mut FMOD_CHANNELCONTROL,
840 controltype: FMOD_CHANNELCONTROL_TYPE,
841 callbacktype: FMOD_CHANNELCONTROL_CALLBACK_TYPE,
842 commanddata1: *mut ::std::os::raw::c_void,
843 commanddata2: *mut ::std::os::raw::c_void,
844 ) -> FMOD_RESULT,
845>;
846pub type FMOD_DSP_CALLBACK = ::std::option::Option<
847 unsafe extern "C" fn(
848 dsp: *mut FMOD_DSP,
849 type_: FMOD_DSP_CALLBACK_TYPE,
850 data: *mut ::std::os::raw::c_void,
851 ) -> FMOD_RESULT,
852>;
853pub type FMOD_SOUND_NONBLOCK_CALLBACK = ::std::option::Option<
854 unsafe extern "C" fn(sound: *mut FMOD_SOUND, result: FMOD_RESULT) -> FMOD_RESULT,
855>;
856pub type FMOD_SOUND_PCMREAD_CALLBACK = ::std::option::Option<
857 unsafe extern "C" fn(
858 sound: *mut FMOD_SOUND,
859 data: *mut ::std::os::raw::c_void,
860 datalen: ::std::os::raw::c_uint,
861 ) -> FMOD_RESULT,
862>;
863pub type FMOD_SOUND_PCMSETPOS_CALLBACK = ::std::option::Option<
864 unsafe extern "C" fn(
865 sound: *mut FMOD_SOUND,
866 subsound: ::std::os::raw::c_int,
867 position: ::std::os::raw::c_uint,
868 postype: FMOD_TIMEUNIT,
869 ) -> FMOD_RESULT,
870>;
871pub type FMOD_FILE_OPEN_CALLBACK = ::std::option::Option<
872 unsafe extern "C" fn(
873 name: *const ::std::os::raw::c_char,
874 filesize: *mut ::std::os::raw::c_uint,
875 handle: *mut *mut ::std::os::raw::c_void,
876 userdata: *mut ::std::os::raw::c_void,
877 ) -> FMOD_RESULT,
878>;
879pub type FMOD_FILE_CLOSE_CALLBACK = ::std::option::Option<
880 unsafe extern "C" fn(
881 handle: *mut ::std::os::raw::c_void,
882 userdata: *mut ::std::os::raw::c_void,
883 ) -> FMOD_RESULT,
884>;
885pub type FMOD_FILE_READ_CALLBACK = ::std::option::Option<
886 unsafe extern "C" fn(
887 handle: *mut ::std::os::raw::c_void,
888 buffer: *mut ::std::os::raw::c_void,
889 sizebytes: ::std::os::raw::c_uint,
890 bytesread: *mut ::std::os::raw::c_uint,
891 userdata: *mut ::std::os::raw::c_void,
892 ) -> FMOD_RESULT,
893>;
894pub type FMOD_FILE_SEEK_CALLBACK = ::std::option::Option<
895 unsafe extern "C" fn(
896 handle: *mut ::std::os::raw::c_void,
897 pos: ::std::os::raw::c_uint,
898 userdata: *mut ::std::os::raw::c_void,
899 ) -> FMOD_RESULT,
900>;
901pub type FMOD_FILE_ASYNCREAD_CALLBACK = ::std::option::Option<
902 unsafe extern "C" fn(
903 info: *mut FMOD_ASYNCREADINFO,
904 userdata: *mut ::std::os::raw::c_void,
905 ) -> FMOD_RESULT,
906>;
907pub type FMOD_FILE_ASYNCCANCEL_CALLBACK = ::std::option::Option<
908 unsafe extern "C" fn(
909 info: *mut FMOD_ASYNCREADINFO,
910 userdata: *mut ::std::os::raw::c_void,
911 ) -> FMOD_RESULT,
912>;
913pub type FMOD_FILE_ASYNCDONE_FUNC =
914 ::std::option::Option<unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, result: FMOD_RESULT)>;
915pub type FMOD_MEMORY_ALLOC_CALLBACK = ::std::option::Option<
916 unsafe extern "C" fn(
917 size: ::std::os::raw::c_uint,
918 type_: FMOD_MEMORY_TYPE,
919 sourcestr: *const ::std::os::raw::c_char,
920 ) -> *mut ::std::os::raw::c_void,
921>;
922pub type FMOD_MEMORY_REALLOC_CALLBACK = ::std::option::Option<
923 unsafe extern "C" fn(
924 ptr: *mut ::std::os::raw::c_void,
925 size: ::std::os::raw::c_uint,
926 type_: FMOD_MEMORY_TYPE,
927 sourcestr: *const ::std::os::raw::c_char,
928 ) -> *mut ::std::os::raw::c_void,
929>;
930pub type FMOD_MEMORY_FREE_CALLBACK = ::std::option::Option<
931 unsafe extern "C" fn(
932 ptr: *mut ::std::os::raw::c_void,
933 type_: FMOD_MEMORY_TYPE,
934 sourcestr: *const ::std::os::raw::c_char,
935 ),
936>;
937pub type FMOD_3D_ROLLOFF_CALLBACK = ::std::option::Option<
938 unsafe extern "C" fn(channelcontrol: *mut FMOD_CHANNELCONTROL, distance: f32) -> f32,
939>;
940#[repr(C)]
941#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
942pub struct FMOD_ASYNCREADINFO {
943 pub handle: *mut ::std::os::raw::c_void,
944 pub offset: ::std::os::raw::c_uint,
945 pub sizebytes: ::std::os::raw::c_uint,
946 pub priority: ::std::os::raw::c_int,
947 pub userdata: *mut ::std::os::raw::c_void,
948 pub buffer: *mut ::std::os::raw::c_void,
949 pub bytesread: ::std::os::raw::c_uint,
950 pub done: FMOD_FILE_ASYNCDONE_FUNC,
951}
952#[allow(clippy::unnecessary_operation, clippy::identity_op)]
953const _: () = {
954 ["Size of FMOD_ASYNCREADINFO"][::std::mem::size_of::<FMOD_ASYNCREADINFO>() - 56usize];
955 ["Alignment of FMOD_ASYNCREADINFO"][::std::mem::align_of::<FMOD_ASYNCREADINFO>() - 8usize];
956 ["Offset of field: FMOD_ASYNCREADINFO::handle"]
957 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, handle) - 0usize];
958 ["Offset of field: FMOD_ASYNCREADINFO::offset"]
959 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, offset) - 8usize];
960 ["Offset of field: FMOD_ASYNCREADINFO::sizebytes"]
961 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, sizebytes) - 12usize];
962 ["Offset of field: FMOD_ASYNCREADINFO::priority"]
963 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, priority) - 16usize];
964 ["Offset of field: FMOD_ASYNCREADINFO::userdata"]
965 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, userdata) - 24usize];
966 ["Offset of field: FMOD_ASYNCREADINFO::buffer"]
967 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, buffer) - 32usize];
968 ["Offset of field: FMOD_ASYNCREADINFO::bytesread"]
969 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, bytesread) - 40usize];
970 ["Offset of field: FMOD_ASYNCREADINFO::done"]
971 [::std::mem::offset_of!(FMOD_ASYNCREADINFO, done) - 48usize];
972};
973impl Default for FMOD_ASYNCREADINFO {
974 fn default() -> Self {
975 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
976 unsafe {
977 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
978 s.assume_init()
979 }
980 }
981}
982#[repr(C)]
983#[derive(Debug, Default, Copy, Clone, PartialEq)]
984pub struct FMOD_VECTOR {
985 pub x: f32,
986 pub y: f32,
987 pub z: f32,
988}
989#[allow(clippy::unnecessary_operation, clippy::identity_op)]
990const _: () = {
991 ["Size of FMOD_VECTOR"][::std::mem::size_of::<FMOD_VECTOR>() - 12usize];
992 ["Alignment of FMOD_VECTOR"][::std::mem::align_of::<FMOD_VECTOR>() - 4usize];
993 ["Offset of field: FMOD_VECTOR::x"][::std::mem::offset_of!(FMOD_VECTOR, x) - 0usize];
994 ["Offset of field: FMOD_VECTOR::y"][::std::mem::offset_of!(FMOD_VECTOR, y) - 4usize];
995 ["Offset of field: FMOD_VECTOR::z"][::std::mem::offset_of!(FMOD_VECTOR, z) - 8usize];
996};
997#[repr(C)]
998#[derive(Debug, Default, Copy, Clone, PartialEq)]
999pub struct FMOD_3D_ATTRIBUTES {
1000 pub position: FMOD_VECTOR,
1001 pub velocity: FMOD_VECTOR,
1002 pub forward: FMOD_VECTOR,
1003 pub up: FMOD_VECTOR,
1004}
1005#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1006const _: () = {
1007 ["Size of FMOD_3D_ATTRIBUTES"][::std::mem::size_of::<FMOD_3D_ATTRIBUTES>() - 48usize];
1008 ["Alignment of FMOD_3D_ATTRIBUTES"][::std::mem::align_of::<FMOD_3D_ATTRIBUTES>() - 4usize];
1009 ["Offset of field: FMOD_3D_ATTRIBUTES::position"]
1010 [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, position) - 0usize];
1011 ["Offset of field: FMOD_3D_ATTRIBUTES::velocity"]
1012 [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, velocity) - 12usize];
1013 ["Offset of field: FMOD_3D_ATTRIBUTES::forward"]
1014 [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, forward) - 24usize];
1015 ["Offset of field: FMOD_3D_ATTRIBUTES::up"]
1016 [::std::mem::offset_of!(FMOD_3D_ATTRIBUTES, up) - 36usize];
1017};
1018#[repr(C)]
1019#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
1020pub struct FMOD_GUID {
1021 pub Data1: ::std::os::raw::c_uint,
1022 pub Data2: ::std::os::raw::c_ushort,
1023 pub Data3: ::std::os::raw::c_ushort,
1024 pub Data4: [::std::os::raw::c_uchar; 8usize],
1025}
1026#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1027const _: () = {
1028 ["Size of FMOD_GUID"][::std::mem::size_of::<FMOD_GUID>() - 16usize];
1029 ["Alignment of FMOD_GUID"][::std::mem::align_of::<FMOD_GUID>() - 4usize];
1030 ["Offset of field: FMOD_GUID::Data1"][::std::mem::offset_of!(FMOD_GUID, Data1) - 0usize];
1031 ["Offset of field: FMOD_GUID::Data2"][::std::mem::offset_of!(FMOD_GUID, Data2) - 4usize];
1032 ["Offset of field: FMOD_GUID::Data3"][::std::mem::offset_of!(FMOD_GUID, Data3) - 6usize];
1033 ["Offset of field: FMOD_GUID::Data4"][::std::mem::offset_of!(FMOD_GUID, Data4) - 8usize];
1034};
1035#[repr(C)]
1036#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1037pub struct FMOD_PLUGINLIST {
1038 pub type_: FMOD_PLUGINTYPE,
1039 pub description: *mut ::std::os::raw::c_void,
1040}
1041#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1042const _: () = {
1043 ["Size of FMOD_PLUGINLIST"][::std::mem::size_of::<FMOD_PLUGINLIST>() - 16usize];
1044 ["Alignment of FMOD_PLUGINLIST"][::std::mem::align_of::<FMOD_PLUGINLIST>() - 8usize];
1045 ["Offset of field: FMOD_PLUGINLIST::type_"]
1046 [::std::mem::offset_of!(FMOD_PLUGINLIST, type_) - 0usize];
1047 ["Offset of field: FMOD_PLUGINLIST::description"]
1048 [::std::mem::offset_of!(FMOD_PLUGINLIST, description) - 8usize];
1049};
1050impl Default for FMOD_PLUGINLIST {
1051 fn default() -> Self {
1052 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1053 unsafe {
1054 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1055 s.assume_init()
1056 }
1057 }
1058}
1059#[repr(C)]
1060#[derive(Debug, Copy, Clone, PartialEq)]
1061pub struct FMOD_ADVANCEDSETTINGS {
1062 pub cbSize: ::std::os::raw::c_int,
1063 pub maxMPEGCodecs: ::std::os::raw::c_int,
1064 pub maxADPCMCodecs: ::std::os::raw::c_int,
1065 pub maxXMACodecs: ::std::os::raw::c_int,
1066 pub maxVorbisCodecs: ::std::os::raw::c_int,
1067 pub maxAT9Codecs: ::std::os::raw::c_int,
1068 pub maxFADPCMCodecs: ::std::os::raw::c_int,
1069 pub maxOpusCodecs: ::std::os::raw::c_int,
1070 pub ASIONumChannels: ::std::os::raw::c_int,
1071 pub ASIOChannelList: *mut *mut ::std::os::raw::c_char,
1072 pub ASIOSpeakerList: *mut FMOD_SPEAKER,
1073 pub vol0virtualvol: f32,
1074 pub defaultDecodeBufferSize: ::std::os::raw::c_uint,
1075 pub profilePort: ::std::os::raw::c_ushort,
1076 pub geometryMaxFadeTime: ::std::os::raw::c_uint,
1077 pub distanceFilterCenterFreq: f32,
1078 pub reverb3Dinstance: ::std::os::raw::c_int,
1079 pub DSPBufferPoolSize: ::std::os::raw::c_int,
1080 pub resamplerMethod: FMOD_DSP_RESAMPLER,
1081 pub randomSeed: ::std::os::raw::c_uint,
1082 pub maxConvolutionThreads: ::std::os::raw::c_int,
1083 pub maxSpatialObjects: ::std::os::raw::c_int,
1084}
1085#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1086const _: () = {
1087 ["Size of FMOD_ADVANCEDSETTINGS"][::std::mem::size_of::<FMOD_ADVANCEDSETTINGS>() - 104usize];
1088 ["Alignment of FMOD_ADVANCEDSETTINGS"]
1089 [::std::mem::align_of::<FMOD_ADVANCEDSETTINGS>() - 8usize];
1090 ["Offset of field: FMOD_ADVANCEDSETTINGS::cbSize"]
1091 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, cbSize) - 0usize];
1092 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxMPEGCodecs"]
1093 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxMPEGCodecs) - 4usize];
1094 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxADPCMCodecs"]
1095 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxADPCMCodecs) - 8usize];
1096 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxXMACodecs"]
1097 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxXMACodecs) - 12usize];
1098 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxVorbisCodecs"]
1099 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxVorbisCodecs) - 16usize];
1100 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxAT9Codecs"]
1101 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxAT9Codecs) - 20usize];
1102 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxFADPCMCodecs"]
1103 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxFADPCMCodecs) - 24usize];
1104 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxOpusCodecs"]
1105 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxOpusCodecs) - 28usize];
1106 ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIONumChannels"]
1107 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIONumChannels) - 32usize];
1108 ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIOChannelList"]
1109 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIOChannelList) - 40usize];
1110 ["Offset of field: FMOD_ADVANCEDSETTINGS::ASIOSpeakerList"]
1111 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, ASIOSpeakerList) - 48usize];
1112 ["Offset of field: FMOD_ADVANCEDSETTINGS::vol0virtualvol"]
1113 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, vol0virtualvol) - 56usize];
1114 ["Offset of field: FMOD_ADVANCEDSETTINGS::defaultDecodeBufferSize"]
1115 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, defaultDecodeBufferSize) - 60usize];
1116 ["Offset of field: FMOD_ADVANCEDSETTINGS::profilePort"]
1117 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, profilePort) - 64usize];
1118 ["Offset of field: FMOD_ADVANCEDSETTINGS::geometryMaxFadeTime"]
1119 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, geometryMaxFadeTime) - 68usize];
1120 ["Offset of field: FMOD_ADVANCEDSETTINGS::distanceFilterCenterFreq"]
1121 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, distanceFilterCenterFreq) - 72usize];
1122 ["Offset of field: FMOD_ADVANCEDSETTINGS::reverb3Dinstance"]
1123 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, reverb3Dinstance) - 76usize];
1124 ["Offset of field: FMOD_ADVANCEDSETTINGS::DSPBufferPoolSize"]
1125 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, DSPBufferPoolSize) - 80usize];
1126 ["Offset of field: FMOD_ADVANCEDSETTINGS::resamplerMethod"]
1127 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, resamplerMethod) - 84usize];
1128 ["Offset of field: FMOD_ADVANCEDSETTINGS::randomSeed"]
1129 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, randomSeed) - 88usize];
1130 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxConvolutionThreads"]
1131 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxConvolutionThreads) - 92usize];
1132 ["Offset of field: FMOD_ADVANCEDSETTINGS::maxSpatialObjects"]
1133 [::std::mem::offset_of!(FMOD_ADVANCEDSETTINGS, maxSpatialObjects) - 96usize];
1134};
1135impl Default for FMOD_ADVANCEDSETTINGS {
1136 fn default() -> Self {
1137 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1138 unsafe {
1139 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1140 s.assume_init()
1141 }
1142 }
1143}
1144#[repr(C)]
1145#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1146pub struct FMOD_TAG {
1147 pub type_: FMOD_TAGTYPE,
1148 pub datatype: FMOD_TAGDATATYPE,
1149 pub name: *mut ::std::os::raw::c_char,
1150 pub data: *mut ::std::os::raw::c_void,
1151 pub datalen: ::std::os::raw::c_uint,
1152 pub updated: FMOD_BOOL,
1153}
1154#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1155const _: () = {
1156 ["Size of FMOD_TAG"][::std::mem::size_of::<FMOD_TAG>() - 32usize];
1157 ["Alignment of FMOD_TAG"][::std::mem::align_of::<FMOD_TAG>() - 8usize];
1158 ["Offset of field: FMOD_TAG::type_"][::std::mem::offset_of!(FMOD_TAG, type_) - 0usize];
1159 ["Offset of field: FMOD_TAG::datatype"][::std::mem::offset_of!(FMOD_TAG, datatype) - 4usize];
1160 ["Offset of field: FMOD_TAG::name"][::std::mem::offset_of!(FMOD_TAG, name) - 8usize];
1161 ["Offset of field: FMOD_TAG::data"][::std::mem::offset_of!(FMOD_TAG, data) - 16usize];
1162 ["Offset of field: FMOD_TAG::datalen"][::std::mem::offset_of!(FMOD_TAG, datalen) - 24usize];
1163 ["Offset of field: FMOD_TAG::updated"][::std::mem::offset_of!(FMOD_TAG, updated) - 28usize];
1164};
1165impl Default for FMOD_TAG {
1166 fn default() -> Self {
1167 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1168 unsafe {
1169 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1170 s.assume_init()
1171 }
1172 }
1173}
1174#[repr(C)]
1175#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1176pub struct FMOD_CREATESOUNDEXINFO {
1177 pub cbsize: ::std::os::raw::c_int,
1178 pub length: ::std::os::raw::c_uint,
1179 pub fileoffset: ::std::os::raw::c_uint,
1180 pub numchannels: ::std::os::raw::c_int,
1181 pub defaultfrequency: ::std::os::raw::c_int,
1182 pub format: FMOD_SOUND_FORMAT,
1183 pub decodebuffersize: ::std::os::raw::c_uint,
1184 pub initialsubsound: ::std::os::raw::c_int,
1185 pub numsubsounds: ::std::os::raw::c_int,
1186 pub inclusionlist: *mut ::std::os::raw::c_int,
1187 pub inclusionlistnum: ::std::os::raw::c_int,
1188 pub pcmreadcallback: FMOD_SOUND_PCMREAD_CALLBACK,
1189 pub pcmsetposcallback: FMOD_SOUND_PCMSETPOS_CALLBACK,
1190 pub nonblockcallback: FMOD_SOUND_NONBLOCK_CALLBACK,
1191 pub dlsname: *const ::std::os::raw::c_char,
1192 pub encryptionkey: *const ::std::os::raw::c_char,
1193 pub maxpolyphony: ::std::os::raw::c_int,
1194 pub userdata: *mut ::std::os::raw::c_void,
1195 pub suggestedsoundtype: FMOD_SOUND_TYPE,
1196 pub fileuseropen: FMOD_FILE_OPEN_CALLBACK,
1197 pub fileuserclose: FMOD_FILE_CLOSE_CALLBACK,
1198 pub fileuserread: FMOD_FILE_READ_CALLBACK,
1199 pub fileuserseek: FMOD_FILE_SEEK_CALLBACK,
1200 pub fileuserasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
1201 pub fileuserasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
1202 pub fileuserdata: *mut ::std::os::raw::c_void,
1203 pub filebuffersize: ::std::os::raw::c_int,
1204 pub channelorder: FMOD_CHANNELORDER,
1205 pub initialsoundgroup: *mut FMOD_SOUNDGROUP,
1206 pub initialseekposition: ::std::os::raw::c_uint,
1207 pub initialseekpostype: FMOD_TIMEUNIT,
1208 pub ignoresetfilesystem: ::std::os::raw::c_int,
1209 pub audioqueuepolicy: ::std::os::raw::c_uint,
1210 pub minmidigranularity: ::std::os::raw::c_uint,
1211 pub nonblockthreadid: ::std::os::raw::c_int,
1212 pub fsbguid: *mut FMOD_GUID,
1213}
1214#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1215const _: () = {
1216 ["Size of FMOD_CREATESOUNDEXINFO"][::std::mem::size_of::<FMOD_CREATESOUNDEXINFO>() - 224usize];
1217 ["Alignment of FMOD_CREATESOUNDEXINFO"]
1218 [::std::mem::align_of::<FMOD_CREATESOUNDEXINFO>() - 8usize];
1219 ["Offset of field: FMOD_CREATESOUNDEXINFO::cbsize"]
1220 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, cbsize) - 0usize];
1221 ["Offset of field: FMOD_CREATESOUNDEXINFO::length"]
1222 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, length) - 4usize];
1223 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileoffset"]
1224 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileoffset) - 8usize];
1225 ["Offset of field: FMOD_CREATESOUNDEXINFO::numchannels"]
1226 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, numchannels) - 12usize];
1227 ["Offset of field: FMOD_CREATESOUNDEXINFO::defaultfrequency"]
1228 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, defaultfrequency) - 16usize];
1229 ["Offset of field: FMOD_CREATESOUNDEXINFO::format"]
1230 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, format) - 20usize];
1231 ["Offset of field: FMOD_CREATESOUNDEXINFO::decodebuffersize"]
1232 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, decodebuffersize) - 24usize];
1233 ["Offset of field: FMOD_CREATESOUNDEXINFO::initialsubsound"]
1234 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialsubsound) - 28usize];
1235 ["Offset of field: FMOD_CREATESOUNDEXINFO::numsubsounds"]
1236 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, numsubsounds) - 32usize];
1237 ["Offset of field: FMOD_CREATESOUNDEXINFO::inclusionlist"]
1238 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, inclusionlist) - 40usize];
1239 ["Offset of field: FMOD_CREATESOUNDEXINFO::inclusionlistnum"]
1240 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, inclusionlistnum) - 48usize];
1241 ["Offset of field: FMOD_CREATESOUNDEXINFO::pcmreadcallback"]
1242 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, pcmreadcallback) - 56usize];
1243 ["Offset of field: FMOD_CREATESOUNDEXINFO::pcmsetposcallback"]
1244 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, pcmsetposcallback) - 64usize];
1245 ["Offset of field: FMOD_CREATESOUNDEXINFO::nonblockcallback"]
1246 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, nonblockcallback) - 72usize];
1247 ["Offset of field: FMOD_CREATESOUNDEXINFO::dlsname"]
1248 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, dlsname) - 80usize];
1249 ["Offset of field: FMOD_CREATESOUNDEXINFO::encryptionkey"]
1250 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, encryptionkey) - 88usize];
1251 ["Offset of field: FMOD_CREATESOUNDEXINFO::maxpolyphony"]
1252 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, maxpolyphony) - 96usize];
1253 ["Offset of field: FMOD_CREATESOUNDEXINFO::userdata"]
1254 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, userdata) - 104usize];
1255 ["Offset of field: FMOD_CREATESOUNDEXINFO::suggestedsoundtype"]
1256 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, suggestedsoundtype) - 112usize];
1257 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuseropen"]
1258 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuseropen) - 120usize];
1259 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserclose"]
1260 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserclose) - 128usize];
1261 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserread"]
1262 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserread) - 136usize];
1263 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserseek"]
1264 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserseek) - 144usize];
1265 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserasyncread"]
1266 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserasyncread) - 152usize];
1267 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserasynccancel"]
1268 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserasynccancel) - 160usize];
1269 ["Offset of field: FMOD_CREATESOUNDEXINFO::fileuserdata"]
1270 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fileuserdata) - 168usize];
1271 ["Offset of field: FMOD_CREATESOUNDEXINFO::filebuffersize"]
1272 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, filebuffersize) - 176usize];
1273 ["Offset of field: FMOD_CREATESOUNDEXINFO::channelorder"]
1274 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, channelorder) - 180usize];
1275 ["Offset of field: FMOD_CREATESOUNDEXINFO::initialsoundgroup"]
1276 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialsoundgroup) - 184usize];
1277 ["Offset of field: FMOD_CREATESOUNDEXINFO::initialseekposition"]
1278 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialseekposition) - 192usize];
1279 ["Offset of field: FMOD_CREATESOUNDEXINFO::initialseekpostype"]
1280 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, initialseekpostype) - 196usize];
1281 ["Offset of field: FMOD_CREATESOUNDEXINFO::ignoresetfilesystem"]
1282 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, ignoresetfilesystem) - 200usize];
1283 ["Offset of field: FMOD_CREATESOUNDEXINFO::audioqueuepolicy"]
1284 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, audioqueuepolicy) - 204usize];
1285 ["Offset of field: FMOD_CREATESOUNDEXINFO::minmidigranularity"]
1286 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, minmidigranularity) - 208usize];
1287 ["Offset of field: FMOD_CREATESOUNDEXINFO::nonblockthreadid"]
1288 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, nonblockthreadid) - 212usize];
1289 ["Offset of field: FMOD_CREATESOUNDEXINFO::fsbguid"]
1290 [::std::mem::offset_of!(FMOD_CREATESOUNDEXINFO, fsbguid) - 216usize];
1291};
1292impl Default for FMOD_CREATESOUNDEXINFO {
1293 fn default() -> Self {
1294 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1295 unsafe {
1296 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1297 s.assume_init()
1298 }
1299 }
1300}
1301#[repr(C)]
1302#[derive(Debug, Default, Copy, Clone, PartialEq)]
1303pub struct FMOD_REVERB_PROPERTIES {
1304 pub DecayTime: f32,
1305 pub EarlyDelay: f32,
1306 pub LateDelay: f32,
1307 pub HFReference: f32,
1308 pub HFDecayRatio: f32,
1309 pub Diffusion: f32,
1310 pub Density: f32,
1311 pub LowShelfFrequency: f32,
1312 pub LowShelfGain: f32,
1313 pub HighCut: f32,
1314 pub EarlyLateMix: f32,
1315 pub WetLevel: f32,
1316}
1317#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1318const _: () = {
1319 ["Size of FMOD_REVERB_PROPERTIES"][::std::mem::size_of::<FMOD_REVERB_PROPERTIES>() - 48usize];
1320 ["Alignment of FMOD_REVERB_PROPERTIES"]
1321 [::std::mem::align_of::<FMOD_REVERB_PROPERTIES>() - 4usize];
1322 ["Offset of field: FMOD_REVERB_PROPERTIES::DecayTime"]
1323 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, DecayTime) - 0usize];
1324 ["Offset of field: FMOD_REVERB_PROPERTIES::EarlyDelay"]
1325 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, EarlyDelay) - 4usize];
1326 ["Offset of field: FMOD_REVERB_PROPERTIES::LateDelay"]
1327 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LateDelay) - 8usize];
1328 ["Offset of field: FMOD_REVERB_PROPERTIES::HFReference"]
1329 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HFReference) - 12usize];
1330 ["Offset of field: FMOD_REVERB_PROPERTIES::HFDecayRatio"]
1331 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HFDecayRatio) - 16usize];
1332 ["Offset of field: FMOD_REVERB_PROPERTIES::Diffusion"]
1333 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, Diffusion) - 20usize];
1334 ["Offset of field: FMOD_REVERB_PROPERTIES::Density"]
1335 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, Density) - 24usize];
1336 ["Offset of field: FMOD_REVERB_PROPERTIES::LowShelfFrequency"]
1337 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LowShelfFrequency) - 28usize];
1338 ["Offset of field: FMOD_REVERB_PROPERTIES::LowShelfGain"]
1339 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, LowShelfGain) - 32usize];
1340 ["Offset of field: FMOD_REVERB_PROPERTIES::HighCut"]
1341 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, HighCut) - 36usize];
1342 ["Offset of field: FMOD_REVERB_PROPERTIES::EarlyLateMix"]
1343 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, EarlyLateMix) - 40usize];
1344 ["Offset of field: FMOD_REVERB_PROPERTIES::WetLevel"]
1345 [::std::mem::offset_of!(FMOD_REVERB_PROPERTIES, WetLevel) - 44usize];
1346};
1347#[repr(C)]
1348#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1349pub struct FMOD_ERRORCALLBACK_INFO {
1350 pub result: FMOD_RESULT,
1351 pub instancetype: FMOD_ERRORCALLBACK_INSTANCETYPE,
1352 pub instance: *mut ::std::os::raw::c_void,
1353 pub functionname: *const ::std::os::raw::c_char,
1354 pub functionparams: *const ::std::os::raw::c_char,
1355}
1356#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1357const _: () = {
1358 ["Size of FMOD_ERRORCALLBACK_INFO"][::std::mem::size_of::<FMOD_ERRORCALLBACK_INFO>() - 32usize];
1359 ["Alignment of FMOD_ERRORCALLBACK_INFO"]
1360 [::std::mem::align_of::<FMOD_ERRORCALLBACK_INFO>() - 8usize];
1361 ["Offset of field: FMOD_ERRORCALLBACK_INFO::result"]
1362 [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, result) - 0usize];
1363 ["Offset of field: FMOD_ERRORCALLBACK_INFO::instancetype"]
1364 [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, instancetype) - 4usize];
1365 ["Offset of field: FMOD_ERRORCALLBACK_INFO::instance"]
1366 [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, instance) - 8usize];
1367 ["Offset of field: FMOD_ERRORCALLBACK_INFO::functionname"]
1368 [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, functionname) - 16usize];
1369 ["Offset of field: FMOD_ERRORCALLBACK_INFO::functionparams"]
1370 [::std::mem::offset_of!(FMOD_ERRORCALLBACK_INFO, functionparams) - 24usize];
1371};
1372impl Default for FMOD_ERRORCALLBACK_INFO {
1373 fn default() -> Self {
1374 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1375 unsafe {
1376 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1377 s.assume_init()
1378 }
1379 }
1380}
1381#[repr(C)]
1382#[derive(Debug, Default, Copy, Clone, PartialEq)]
1383pub struct FMOD_CPU_USAGE {
1384 pub dsp: f32,
1385 pub stream: f32,
1386 pub geometry: f32,
1387 pub update: f32,
1388 pub convolution1: f32,
1389 pub convolution2: f32,
1390}
1391#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1392const _: () = {
1393 ["Size of FMOD_CPU_USAGE"][::std::mem::size_of::<FMOD_CPU_USAGE>() - 24usize];
1394 ["Alignment of FMOD_CPU_USAGE"][::std::mem::align_of::<FMOD_CPU_USAGE>() - 4usize];
1395 ["Offset of field: FMOD_CPU_USAGE::dsp"][::std::mem::offset_of!(FMOD_CPU_USAGE, dsp) - 0usize];
1396 ["Offset of field: FMOD_CPU_USAGE::stream"]
1397 [::std::mem::offset_of!(FMOD_CPU_USAGE, stream) - 4usize];
1398 ["Offset of field: FMOD_CPU_USAGE::geometry"]
1399 [::std::mem::offset_of!(FMOD_CPU_USAGE, geometry) - 8usize];
1400 ["Offset of field: FMOD_CPU_USAGE::update"]
1401 [::std::mem::offset_of!(FMOD_CPU_USAGE, update) - 12usize];
1402 ["Offset of field: FMOD_CPU_USAGE::convolution1"]
1403 [::std::mem::offset_of!(FMOD_CPU_USAGE, convolution1) - 16usize];
1404 ["Offset of field: FMOD_CPU_USAGE::convolution2"]
1405 [::std::mem::offset_of!(FMOD_CPU_USAGE, convolution2) - 20usize];
1406};
1407#[repr(C)]
1408#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1409pub struct FMOD_DSP_DATA_PARAMETER_INFO {
1410 pub data: *mut ::std::os::raw::c_void,
1411 pub length: ::std::os::raw::c_uint,
1412 pub index: ::std::os::raw::c_int,
1413}
1414#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1415const _: () = {
1416 ["Size of FMOD_DSP_DATA_PARAMETER_INFO"]
1417 [::std::mem::size_of::<FMOD_DSP_DATA_PARAMETER_INFO>() - 16usize];
1418 ["Alignment of FMOD_DSP_DATA_PARAMETER_INFO"]
1419 [::std::mem::align_of::<FMOD_DSP_DATA_PARAMETER_INFO>() - 8usize];
1420 ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::data"]
1421 [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, data) - 0usize];
1422 ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::length"]
1423 [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, length) - 8usize];
1424 ["Offset of field: FMOD_DSP_DATA_PARAMETER_INFO::index"]
1425 [::std::mem::offset_of!(FMOD_DSP_DATA_PARAMETER_INFO, index) - 12usize];
1426};
1427impl Default for FMOD_DSP_DATA_PARAMETER_INFO {
1428 fn default() -> Self {
1429 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1430 unsafe {
1431 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1432 s.assume_init()
1433 }
1434 }
1435}
1436pub type FMOD_CODEC_SEEK_METHOD = ::std::os::raw::c_int;
1437pub type FMOD_CODEC_OPEN_CALLBACK = ::std::option::Option<
1438 unsafe extern "C" fn(
1439 codec_state: *mut FMOD_CODEC_STATE,
1440 usermode: FMOD_MODE,
1441 userexinfo: *mut FMOD_CREATESOUNDEXINFO,
1442 ) -> FMOD_RESULT,
1443>;
1444pub type FMOD_CODEC_CLOSE_CALLBACK =
1445 ::std::option::Option<unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE) -> FMOD_RESULT>;
1446pub type FMOD_CODEC_READ_CALLBACK = ::std::option::Option<
1447 unsafe extern "C" fn(
1448 codec_state: *mut FMOD_CODEC_STATE,
1449 buffer: *mut ::std::os::raw::c_void,
1450 samples_in: ::std::os::raw::c_uint,
1451 samples_out: *mut ::std::os::raw::c_uint,
1452 ) -> FMOD_RESULT,
1453>;
1454pub type FMOD_CODEC_GETLENGTH_CALLBACK = ::std::option::Option<
1455 unsafe extern "C" fn(
1456 codec_state: *mut FMOD_CODEC_STATE,
1457 length: *mut ::std::os::raw::c_uint,
1458 lengthtype: FMOD_TIMEUNIT,
1459 ) -> FMOD_RESULT,
1460>;
1461pub type FMOD_CODEC_SETPOSITION_CALLBACK = ::std::option::Option<
1462 unsafe extern "C" fn(
1463 codec_state: *mut FMOD_CODEC_STATE,
1464 subsound: ::std::os::raw::c_int,
1465 position: ::std::os::raw::c_uint,
1466 postype: FMOD_TIMEUNIT,
1467 ) -> FMOD_RESULT,
1468>;
1469pub type FMOD_CODEC_GETPOSITION_CALLBACK = ::std::option::Option<
1470 unsafe extern "C" fn(
1471 codec_state: *mut FMOD_CODEC_STATE,
1472 position: *mut ::std::os::raw::c_uint,
1473 postype: FMOD_TIMEUNIT,
1474 ) -> FMOD_RESULT,
1475>;
1476pub type FMOD_CODEC_SOUNDCREATE_CALLBACK = ::std::option::Option<
1477 unsafe extern "C" fn(
1478 codec_state: *mut FMOD_CODEC_STATE,
1479 subsound: ::std::os::raw::c_int,
1480 sound: *mut FMOD_SOUND,
1481 ) -> FMOD_RESULT,
1482>;
1483pub type FMOD_CODEC_GETWAVEFORMAT_CALLBACK = ::std::option::Option<
1484 unsafe extern "C" fn(
1485 codec_state: *mut FMOD_CODEC_STATE,
1486 index: ::std::os::raw::c_int,
1487 waveformat: *mut FMOD_CODEC_WAVEFORMAT,
1488 ) -> FMOD_RESULT,
1489>;
1490pub type FMOD_CODEC_METADATA_FUNC = ::std::option::Option<
1491 unsafe extern "C" fn(
1492 codec_state: *mut FMOD_CODEC_STATE,
1493 tagtype: FMOD_TAGTYPE,
1494 name: *mut ::std::os::raw::c_char,
1495 data: *mut ::std::os::raw::c_void,
1496 datalen: ::std::os::raw::c_uint,
1497 datatype: FMOD_TAGDATATYPE,
1498 unique: ::std::os::raw::c_int,
1499 ) -> FMOD_RESULT,
1500>;
1501pub type FMOD_CODEC_ALLOC_FUNC = ::std::option::Option<
1502 unsafe extern "C" fn(
1503 size: ::std::os::raw::c_uint,
1504 align: ::std::os::raw::c_uint,
1505 file: *const ::std::os::raw::c_char,
1506 line: ::std::os::raw::c_int,
1507 ) -> *mut ::std::os::raw::c_void,
1508>;
1509pub type FMOD_CODEC_FREE_FUNC = ::std::option::Option<
1510 unsafe extern "C" fn(
1511 ptr: *mut ::std::os::raw::c_void,
1512 file: *const ::std::os::raw::c_char,
1513 line: ::std::os::raw::c_int,
1514 ),
1515>;
1516pub type FMOD_CODEC_LOG_FUNC = ::std::option::Option<
1517 unsafe extern "C" fn(
1518 level: FMOD_DEBUG_FLAGS,
1519 file: *const ::std::os::raw::c_char,
1520 line: ::std::os::raw::c_int,
1521 function: *const ::std::os::raw::c_char,
1522 string: *const ::std::os::raw::c_char,
1523 ...
1524 ),
1525>;
1526pub type FMOD_CODEC_FILE_READ_FUNC = ::std::option::Option<
1527 unsafe extern "C" fn(
1528 codec_state: *mut FMOD_CODEC_STATE,
1529 buffer: *mut ::std::os::raw::c_void,
1530 sizebytes: ::std::os::raw::c_uint,
1531 bytesread: *mut ::std::os::raw::c_uint,
1532 ) -> FMOD_RESULT,
1533>;
1534pub type FMOD_CODEC_FILE_SEEK_FUNC = ::std::option::Option<
1535 unsafe extern "C" fn(
1536 codec_state: *mut FMOD_CODEC_STATE,
1537 pos: ::std::os::raw::c_uint,
1538 method: FMOD_CODEC_SEEK_METHOD,
1539 ) -> FMOD_RESULT,
1540>;
1541pub type FMOD_CODEC_FILE_TELL_FUNC = ::std::option::Option<
1542 unsafe extern "C" fn(
1543 codec_state: *mut FMOD_CODEC_STATE,
1544 pos: *mut ::std::os::raw::c_uint,
1545 ) -> FMOD_RESULT,
1546>;
1547pub type FMOD_CODEC_FILE_SIZE_FUNC = ::std::option::Option<
1548 unsafe extern "C" fn(
1549 codec_state: *mut FMOD_CODEC_STATE,
1550 size: *mut ::std::os::raw::c_uint,
1551 ) -> FMOD_RESULT,
1552>;
1553#[repr(C)]
1554#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1555pub struct FMOD_CODEC_DESCRIPTION {
1556 pub apiversion: ::std::os::raw::c_uint,
1557 pub name: *const ::std::os::raw::c_char,
1558 pub version: ::std::os::raw::c_uint,
1559 pub defaultasstream: ::std::os::raw::c_int,
1560 pub timeunits: FMOD_TIMEUNIT,
1561 pub open: FMOD_CODEC_OPEN_CALLBACK,
1562 pub close: FMOD_CODEC_CLOSE_CALLBACK,
1563 pub read: FMOD_CODEC_READ_CALLBACK,
1564 pub getlength: FMOD_CODEC_GETLENGTH_CALLBACK,
1565 pub setposition: FMOD_CODEC_SETPOSITION_CALLBACK,
1566 pub getposition: FMOD_CODEC_GETPOSITION_CALLBACK,
1567 pub soundcreate: FMOD_CODEC_SOUNDCREATE_CALLBACK,
1568 pub getwaveformat: FMOD_CODEC_GETWAVEFORMAT_CALLBACK,
1569}
1570#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1571const _: () = {
1572 ["Size of FMOD_CODEC_DESCRIPTION"][::std::mem::size_of::<FMOD_CODEC_DESCRIPTION>() - 96usize];
1573 ["Alignment of FMOD_CODEC_DESCRIPTION"]
1574 [::std::mem::align_of::<FMOD_CODEC_DESCRIPTION>() - 8usize];
1575 ["Offset of field: FMOD_CODEC_DESCRIPTION::apiversion"]
1576 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, apiversion) - 0usize];
1577 ["Offset of field: FMOD_CODEC_DESCRIPTION::name"]
1578 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, name) - 8usize];
1579 ["Offset of field: FMOD_CODEC_DESCRIPTION::version"]
1580 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, version) - 16usize];
1581 ["Offset of field: FMOD_CODEC_DESCRIPTION::defaultasstream"]
1582 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, defaultasstream) - 20usize];
1583 ["Offset of field: FMOD_CODEC_DESCRIPTION::timeunits"]
1584 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, timeunits) - 24usize];
1585 ["Offset of field: FMOD_CODEC_DESCRIPTION::open"]
1586 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, open) - 32usize];
1587 ["Offset of field: FMOD_CODEC_DESCRIPTION::close"]
1588 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, close) - 40usize];
1589 ["Offset of field: FMOD_CODEC_DESCRIPTION::read"]
1590 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, read) - 48usize];
1591 ["Offset of field: FMOD_CODEC_DESCRIPTION::getlength"]
1592 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getlength) - 56usize];
1593 ["Offset of field: FMOD_CODEC_DESCRIPTION::setposition"]
1594 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, setposition) - 64usize];
1595 ["Offset of field: FMOD_CODEC_DESCRIPTION::getposition"]
1596 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getposition) - 72usize];
1597 ["Offset of field: FMOD_CODEC_DESCRIPTION::soundcreate"]
1598 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, soundcreate) - 80usize];
1599 ["Offset of field: FMOD_CODEC_DESCRIPTION::getwaveformat"]
1600 [::std::mem::offset_of!(FMOD_CODEC_DESCRIPTION, getwaveformat) - 88usize];
1601};
1602impl Default for FMOD_CODEC_DESCRIPTION {
1603 fn default() -> Self {
1604 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1605 unsafe {
1606 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1607 s.assume_init()
1608 }
1609 }
1610}
1611#[repr(C)]
1612#[derive(Debug, Copy, Clone, PartialEq)]
1613pub struct FMOD_CODEC_WAVEFORMAT {
1614 pub name: *const ::std::os::raw::c_char,
1615 pub format: FMOD_SOUND_FORMAT,
1616 pub channels: ::std::os::raw::c_int,
1617 pub frequency: ::std::os::raw::c_int,
1618 pub lengthbytes: ::std::os::raw::c_uint,
1619 pub lengthpcm: ::std::os::raw::c_uint,
1620 pub pcmblocksize: ::std::os::raw::c_uint,
1621 pub loopstart: ::std::os::raw::c_int,
1622 pub loopend: ::std::os::raw::c_int,
1623 pub mode: FMOD_MODE,
1624 pub channelmask: FMOD_CHANNELMASK,
1625 pub channelorder: FMOD_CHANNELORDER,
1626 pub peakvolume: f32,
1627}
1628#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1629const _: () = {
1630 ["Size of FMOD_CODEC_WAVEFORMAT"][::std::mem::size_of::<FMOD_CODEC_WAVEFORMAT>() - 56usize];
1631 ["Alignment of FMOD_CODEC_WAVEFORMAT"]
1632 [::std::mem::align_of::<FMOD_CODEC_WAVEFORMAT>() - 8usize];
1633 ["Offset of field: FMOD_CODEC_WAVEFORMAT::name"]
1634 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, name) - 0usize];
1635 ["Offset of field: FMOD_CODEC_WAVEFORMAT::format"]
1636 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, format) - 8usize];
1637 ["Offset of field: FMOD_CODEC_WAVEFORMAT::channels"]
1638 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channels) - 12usize];
1639 ["Offset of field: FMOD_CODEC_WAVEFORMAT::frequency"]
1640 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, frequency) - 16usize];
1641 ["Offset of field: FMOD_CODEC_WAVEFORMAT::lengthbytes"]
1642 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, lengthbytes) - 20usize];
1643 ["Offset of field: FMOD_CODEC_WAVEFORMAT::lengthpcm"]
1644 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, lengthpcm) - 24usize];
1645 ["Offset of field: FMOD_CODEC_WAVEFORMAT::pcmblocksize"]
1646 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, pcmblocksize) - 28usize];
1647 ["Offset of field: FMOD_CODEC_WAVEFORMAT::loopstart"]
1648 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, loopstart) - 32usize];
1649 ["Offset of field: FMOD_CODEC_WAVEFORMAT::loopend"]
1650 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, loopend) - 36usize];
1651 ["Offset of field: FMOD_CODEC_WAVEFORMAT::mode"]
1652 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, mode) - 40usize];
1653 ["Offset of field: FMOD_CODEC_WAVEFORMAT::channelmask"]
1654 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channelmask) - 44usize];
1655 ["Offset of field: FMOD_CODEC_WAVEFORMAT::channelorder"]
1656 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, channelorder) - 48usize];
1657 ["Offset of field: FMOD_CODEC_WAVEFORMAT::peakvolume"]
1658 [::std::mem::offset_of!(FMOD_CODEC_WAVEFORMAT, peakvolume) - 52usize];
1659};
1660impl Default for FMOD_CODEC_WAVEFORMAT {
1661 fn default() -> Self {
1662 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1663 unsafe {
1664 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1665 s.assume_init()
1666 }
1667 }
1668}
1669#[repr(C)]
1670#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
1671pub struct FMOD_CODEC_STATE_FUNCTIONS {
1672 pub metadata: FMOD_CODEC_METADATA_FUNC,
1673 pub alloc: FMOD_CODEC_ALLOC_FUNC,
1674 pub free: FMOD_CODEC_FREE_FUNC,
1675 pub log: FMOD_CODEC_LOG_FUNC,
1676 pub read: FMOD_CODEC_FILE_READ_FUNC,
1677 pub seek: FMOD_CODEC_FILE_SEEK_FUNC,
1678 pub tell: FMOD_CODEC_FILE_TELL_FUNC,
1679 pub size: FMOD_CODEC_FILE_SIZE_FUNC,
1680}
1681#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1682const _: () = {
1683 ["Size of FMOD_CODEC_STATE_FUNCTIONS"]
1684 [::std::mem::size_of::<FMOD_CODEC_STATE_FUNCTIONS>() - 64usize];
1685 ["Alignment of FMOD_CODEC_STATE_FUNCTIONS"]
1686 [::std::mem::align_of::<FMOD_CODEC_STATE_FUNCTIONS>() - 8usize];
1687 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::metadata"]
1688 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, metadata) - 0usize];
1689 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::alloc"]
1690 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, alloc) - 8usize];
1691 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::free"]
1692 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, free) - 16usize];
1693 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::log"]
1694 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, log) - 24usize];
1695 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::read"]
1696 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, read) - 32usize];
1697 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::seek"]
1698 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, seek) - 40usize];
1699 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::tell"]
1700 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, tell) - 48usize];
1701 ["Offset of field: FMOD_CODEC_STATE_FUNCTIONS::size"]
1702 [::std::mem::offset_of!(FMOD_CODEC_STATE_FUNCTIONS, size) - 56usize];
1703};
1704#[repr(C)]
1705#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1706pub struct FMOD_CODEC_STATE {
1707 pub plugindata: *mut ::std::os::raw::c_void,
1708 pub waveformat: *mut FMOD_CODEC_WAVEFORMAT,
1709 pub functions: *mut FMOD_CODEC_STATE_FUNCTIONS,
1710 pub numsubsounds: ::std::os::raw::c_int,
1711}
1712#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1713const _: () = {
1714 ["Size of FMOD_CODEC_STATE"][::std::mem::size_of::<FMOD_CODEC_STATE>() - 32usize];
1715 ["Alignment of FMOD_CODEC_STATE"][::std::mem::align_of::<FMOD_CODEC_STATE>() - 8usize];
1716 ["Offset of field: FMOD_CODEC_STATE::plugindata"]
1717 [::std::mem::offset_of!(FMOD_CODEC_STATE, plugindata) - 0usize];
1718 ["Offset of field: FMOD_CODEC_STATE::waveformat"]
1719 [::std::mem::offset_of!(FMOD_CODEC_STATE, waveformat) - 8usize];
1720 ["Offset of field: FMOD_CODEC_STATE::functions"]
1721 [::std::mem::offset_of!(FMOD_CODEC_STATE, functions) - 16usize];
1722 ["Offset of field: FMOD_CODEC_STATE::numsubsounds"]
1723 [::std::mem::offset_of!(FMOD_CODEC_STATE, numsubsounds) - 24usize];
1724};
1725impl Default for FMOD_CODEC_STATE {
1726 fn default() -> Self {
1727 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1728 unsafe {
1729 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1730 s.assume_init()
1731 }
1732 }
1733}
1734pub const FMOD_DSP_TYPE_UNKNOWN: FMOD_DSP_TYPE = 0;
1735pub const FMOD_DSP_TYPE_MIXER: FMOD_DSP_TYPE = 1;
1736pub const FMOD_DSP_TYPE_OSCILLATOR: FMOD_DSP_TYPE = 2;
1737pub const FMOD_DSP_TYPE_LOWPASS: FMOD_DSP_TYPE = 3;
1738pub const FMOD_DSP_TYPE_ITLOWPASS: FMOD_DSP_TYPE = 4;
1739pub const FMOD_DSP_TYPE_HIGHPASS: FMOD_DSP_TYPE = 5;
1740pub const FMOD_DSP_TYPE_ECHO: FMOD_DSP_TYPE = 6;
1741pub const FMOD_DSP_TYPE_FADER: FMOD_DSP_TYPE = 7;
1742pub const FMOD_DSP_TYPE_FLANGE: FMOD_DSP_TYPE = 8;
1743pub const FMOD_DSP_TYPE_DISTORTION: FMOD_DSP_TYPE = 9;
1744pub const FMOD_DSP_TYPE_NORMALIZE: FMOD_DSP_TYPE = 10;
1745pub const FMOD_DSP_TYPE_LIMITER: FMOD_DSP_TYPE = 11;
1746pub const FMOD_DSP_TYPE_PARAMEQ: FMOD_DSP_TYPE = 12;
1747pub const FMOD_DSP_TYPE_PITCHSHIFT: FMOD_DSP_TYPE = 13;
1748pub const FMOD_DSP_TYPE_CHORUS: FMOD_DSP_TYPE = 14;
1749pub const FMOD_DSP_TYPE_ITECHO: FMOD_DSP_TYPE = 15;
1750pub const FMOD_DSP_TYPE_COMPRESSOR: FMOD_DSP_TYPE = 16;
1751pub const FMOD_DSP_TYPE_SFXREVERB: FMOD_DSP_TYPE = 17;
1752pub const FMOD_DSP_TYPE_LOWPASS_SIMPLE: FMOD_DSP_TYPE = 18;
1753pub const FMOD_DSP_TYPE_DELAY: FMOD_DSP_TYPE = 19;
1754pub const FMOD_DSP_TYPE_TREMOLO: FMOD_DSP_TYPE = 20;
1755pub const FMOD_DSP_TYPE_SEND: FMOD_DSP_TYPE = 21;
1756pub const FMOD_DSP_TYPE_RETURN: FMOD_DSP_TYPE = 22;
1757pub const FMOD_DSP_TYPE_HIGHPASS_SIMPLE: FMOD_DSP_TYPE = 23;
1758pub const FMOD_DSP_TYPE_PAN: FMOD_DSP_TYPE = 24;
1759pub const FMOD_DSP_TYPE_THREE_EQ: FMOD_DSP_TYPE = 25;
1760pub const FMOD_DSP_TYPE_FFT: FMOD_DSP_TYPE = 26;
1761pub const FMOD_DSP_TYPE_LOUDNESS_METER: FMOD_DSP_TYPE = 27;
1762pub const FMOD_DSP_TYPE_CONVOLUTIONREVERB: FMOD_DSP_TYPE = 28;
1763pub const FMOD_DSP_TYPE_CHANNELMIX: FMOD_DSP_TYPE = 29;
1764pub const FMOD_DSP_TYPE_TRANSCEIVER: FMOD_DSP_TYPE = 30;
1765pub const FMOD_DSP_TYPE_OBJECTPAN: FMOD_DSP_TYPE = 31;
1766pub const FMOD_DSP_TYPE_MULTIBAND_EQ: FMOD_DSP_TYPE = 32;
1767pub const FMOD_DSP_TYPE_MULTIBAND_DYNAMICS: FMOD_DSP_TYPE = 33;
1768pub const FMOD_DSP_TYPE_MAX: FMOD_DSP_TYPE = 34;
1769pub const FMOD_DSP_TYPE_FORCEINT: FMOD_DSP_TYPE = 65536;
1770pub type FMOD_DSP_TYPE = ::std::os::raw::c_uint;
1771pub const FMOD_DSP_OSCILLATOR_TYPE: FMOD_DSP_OSCILLATOR = 0;
1772pub const FMOD_DSP_OSCILLATOR_RATE: FMOD_DSP_OSCILLATOR = 1;
1773pub type FMOD_DSP_OSCILLATOR = ::std::os::raw::c_uint;
1774pub const FMOD_DSP_LOWPASS_CUTOFF: FMOD_DSP_LOWPASS = 0;
1775pub const FMOD_DSP_LOWPASS_RESONANCE: FMOD_DSP_LOWPASS = 1;
1776pub type FMOD_DSP_LOWPASS = ::std::os::raw::c_uint;
1777pub const FMOD_DSP_ITLOWPASS_CUTOFF: FMOD_DSP_ITLOWPASS = 0;
1778pub const FMOD_DSP_ITLOWPASS_RESONANCE: FMOD_DSP_ITLOWPASS = 1;
1779pub type FMOD_DSP_ITLOWPASS = ::std::os::raw::c_uint;
1780pub const FMOD_DSP_HIGHPASS_CUTOFF: FMOD_DSP_HIGHPASS = 0;
1781pub const FMOD_DSP_HIGHPASS_RESONANCE: FMOD_DSP_HIGHPASS = 1;
1782pub type FMOD_DSP_HIGHPASS = ::std::os::raw::c_uint;
1783pub const FMOD_DSP_ECHO_DELAY: FMOD_DSP_ECHO = 0;
1784pub const FMOD_DSP_ECHO_FEEDBACK: FMOD_DSP_ECHO = 1;
1785pub const FMOD_DSP_ECHO_DRYLEVEL: FMOD_DSP_ECHO = 2;
1786pub const FMOD_DSP_ECHO_WETLEVEL: FMOD_DSP_ECHO = 3;
1787pub const FMOD_DSP_ECHO_DELAYCHANGEMODE: FMOD_DSP_ECHO = 4;
1788pub type FMOD_DSP_ECHO = ::std::os::raw::c_uint;
1789pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_FADE: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 0;
1790pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_LERP: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 1;
1791pub const FMOD_DSP_ECHO_DELAYCHANGEMODE_NONE: FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = 2;
1792pub type FMOD_DSP_ECHO_DELAYCHANGEMODE_TYPE = ::std::os::raw::c_uint;
1793pub const FMOD_DSP_FADER_GAIN: FMOD_DSP_FADER = 0;
1794pub const FMOD_DSP_FADER_OVERALL_GAIN: FMOD_DSP_FADER = 1;
1795pub type FMOD_DSP_FADER = ::std::os::raw::c_uint;
1796pub const FMOD_DSP_FLANGE_MIX: FMOD_DSP_FLANGE = 0;
1797pub const FMOD_DSP_FLANGE_DEPTH: FMOD_DSP_FLANGE = 1;
1798pub const FMOD_DSP_FLANGE_RATE: FMOD_DSP_FLANGE = 2;
1799pub type FMOD_DSP_FLANGE = ::std::os::raw::c_uint;
1800pub const FMOD_DSP_DISTORTION_LEVEL: FMOD_DSP_DISTORTION = 0;
1801pub type FMOD_DSP_DISTORTION = ::std::os::raw::c_uint;
1802pub const FMOD_DSP_NORMALIZE_FADETIME: FMOD_DSP_NORMALIZE = 0;
1803pub const FMOD_DSP_NORMALIZE_THRESHOLD: FMOD_DSP_NORMALIZE = 1;
1804pub const FMOD_DSP_NORMALIZE_MAXAMP: FMOD_DSP_NORMALIZE = 2;
1805pub type FMOD_DSP_NORMALIZE = ::std::os::raw::c_uint;
1806pub const FMOD_DSP_LIMITER_RELEASETIME: FMOD_DSP_LIMITER = 0;
1807pub const FMOD_DSP_LIMITER_CEILING: FMOD_DSP_LIMITER = 1;
1808pub const FMOD_DSP_LIMITER_MAXIMIZERGAIN: FMOD_DSP_LIMITER = 2;
1809pub const FMOD_DSP_LIMITER_MODE: FMOD_DSP_LIMITER = 3;
1810pub type FMOD_DSP_LIMITER = ::std::os::raw::c_uint;
1811pub const FMOD_DSP_PARAMEQ_CENTER: FMOD_DSP_PARAMEQ = 0;
1812pub const FMOD_DSP_PARAMEQ_BANDWIDTH: FMOD_DSP_PARAMEQ = 1;
1813pub const FMOD_DSP_PARAMEQ_GAIN: FMOD_DSP_PARAMEQ = 2;
1814pub type FMOD_DSP_PARAMEQ = ::std::os::raw::c_uint;
1815pub const FMOD_DSP_MULTIBAND_EQ_A_FILTER: FMOD_DSP_MULTIBAND_EQ = 0;
1816pub const FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 1;
1817pub const FMOD_DSP_MULTIBAND_EQ_A_Q: FMOD_DSP_MULTIBAND_EQ = 2;
1818pub const FMOD_DSP_MULTIBAND_EQ_A_GAIN: FMOD_DSP_MULTIBAND_EQ = 3;
1819pub const FMOD_DSP_MULTIBAND_EQ_B_FILTER: FMOD_DSP_MULTIBAND_EQ = 4;
1820pub const FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 5;
1821pub const FMOD_DSP_MULTIBAND_EQ_B_Q: FMOD_DSP_MULTIBAND_EQ = 6;
1822pub const FMOD_DSP_MULTIBAND_EQ_B_GAIN: FMOD_DSP_MULTIBAND_EQ = 7;
1823pub const FMOD_DSP_MULTIBAND_EQ_C_FILTER: FMOD_DSP_MULTIBAND_EQ = 8;
1824pub const FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 9;
1825pub const FMOD_DSP_MULTIBAND_EQ_C_Q: FMOD_DSP_MULTIBAND_EQ = 10;
1826pub const FMOD_DSP_MULTIBAND_EQ_C_GAIN: FMOD_DSP_MULTIBAND_EQ = 11;
1827pub const FMOD_DSP_MULTIBAND_EQ_D_FILTER: FMOD_DSP_MULTIBAND_EQ = 12;
1828pub const FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 13;
1829pub const FMOD_DSP_MULTIBAND_EQ_D_Q: FMOD_DSP_MULTIBAND_EQ = 14;
1830pub const FMOD_DSP_MULTIBAND_EQ_D_GAIN: FMOD_DSP_MULTIBAND_EQ = 15;
1831pub const FMOD_DSP_MULTIBAND_EQ_E_FILTER: FMOD_DSP_MULTIBAND_EQ = 16;
1832pub const FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 17;
1833pub const FMOD_DSP_MULTIBAND_EQ_E_Q: FMOD_DSP_MULTIBAND_EQ = 18;
1834pub const FMOD_DSP_MULTIBAND_EQ_E_GAIN: FMOD_DSP_MULTIBAND_EQ = 19;
1835pub type FMOD_DSP_MULTIBAND_EQ = ::std::os::raw::c_uint;
1836pub const FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 0;
1837pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 1;
1838pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 2;
1839pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 3;
1840pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 4;
1841pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 5;
1842pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 6;
1843pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 7;
1844pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 8;
1845pub const FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 9;
1846pub const FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 10;
1847pub const FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 11;
1848pub const FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 12;
1849pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_6DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 13;
1850pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_6DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 14;
1851pub type FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = ::std::os::raw::c_uint;
1852pub const FMOD_DSP_MULTIBAND_DYNAMICS_LOWER_FREQUENCY: FMOD_DSP_MULTIBAND_DYNAMICS = 0;
1853pub const FMOD_DSP_MULTIBAND_DYNAMICS_UPPER_FREQUENCY: FMOD_DSP_MULTIBAND_DYNAMICS = 1;
1854pub const FMOD_DSP_MULTIBAND_DYNAMICS_LINKED: FMOD_DSP_MULTIBAND_DYNAMICS = 2;
1855pub const FMOD_DSP_MULTIBAND_DYNAMICS_USE_SIDECHAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 3;
1856pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 4;
1857pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 5;
1858pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 6;
1859pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 7;
1860pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 8;
1861pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 9;
1862pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 10;
1863pub const FMOD_DSP_MULTIBAND_DYNAMICS_A_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 11;
1864pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 12;
1865pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 13;
1866pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 14;
1867pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 15;
1868pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 16;
1869pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 17;
1870pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 18;
1871pub const FMOD_DSP_MULTIBAND_DYNAMICS_B_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 19;
1872pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_MODE: FMOD_DSP_MULTIBAND_DYNAMICS = 20;
1873pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_GAIN: FMOD_DSP_MULTIBAND_DYNAMICS = 21;
1874pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_THRESHOLD: FMOD_DSP_MULTIBAND_DYNAMICS = 22;
1875pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RATIO: FMOD_DSP_MULTIBAND_DYNAMICS = 23;
1876pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_ATTACK: FMOD_DSP_MULTIBAND_DYNAMICS = 24;
1877pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RELEASE: FMOD_DSP_MULTIBAND_DYNAMICS = 25;
1878pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_GAIN_MAKEUP: FMOD_DSP_MULTIBAND_DYNAMICS = 26;
1879pub const FMOD_DSP_MULTIBAND_DYNAMICS_C_RESPONSE_DATA: FMOD_DSP_MULTIBAND_DYNAMICS = 27;
1880pub type FMOD_DSP_MULTIBAND_DYNAMICS = ::std::os::raw::c_uint;
1881pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_DISABLED: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 0;
1882pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_COMPRESS_UP: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 1;
1883pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_COMPRESS_DOWN: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 2;
1884pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_EXPAND_UP: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 3;
1885pub const FMOD_DSP_MULTIBAND_DYNAMICS_MODE_EXPAND_DOWN: FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = 4;
1886pub type FMOD_DSP_MULTIBAND_DYNAMICS_MODE_TYPE = ::std::os::raw::c_uint;
1887pub const FMOD_DSP_PITCHSHIFT_PITCH: FMOD_DSP_PITCHSHIFT = 0;
1888pub const FMOD_DSP_PITCHSHIFT_FFTSIZE: FMOD_DSP_PITCHSHIFT = 1;
1889pub const FMOD_DSP_PITCHSHIFT_OVERLAP: FMOD_DSP_PITCHSHIFT = 2;
1890pub const FMOD_DSP_PITCHSHIFT_MAXCHANNELS: FMOD_DSP_PITCHSHIFT = 3;
1891pub type FMOD_DSP_PITCHSHIFT = ::std::os::raw::c_uint;
1892pub const FMOD_DSP_CHORUS_MIX: FMOD_DSP_CHORUS = 0;
1893pub const FMOD_DSP_CHORUS_RATE: FMOD_DSP_CHORUS = 1;
1894pub const FMOD_DSP_CHORUS_DEPTH: FMOD_DSP_CHORUS = 2;
1895pub type FMOD_DSP_CHORUS = ::std::os::raw::c_uint;
1896pub const FMOD_DSP_ITECHO_WETDRYMIX: FMOD_DSP_ITECHO = 0;
1897pub const FMOD_DSP_ITECHO_FEEDBACK: FMOD_DSP_ITECHO = 1;
1898pub const FMOD_DSP_ITECHO_LEFTDELAY: FMOD_DSP_ITECHO = 2;
1899pub const FMOD_DSP_ITECHO_RIGHTDELAY: FMOD_DSP_ITECHO = 3;
1900pub const FMOD_DSP_ITECHO_PANDELAY: FMOD_DSP_ITECHO = 4;
1901pub type FMOD_DSP_ITECHO = ::std::os::raw::c_uint;
1902pub const FMOD_DSP_COMPRESSOR_THRESHOLD: FMOD_DSP_COMPRESSOR = 0;
1903pub const FMOD_DSP_COMPRESSOR_RATIO: FMOD_DSP_COMPRESSOR = 1;
1904pub const FMOD_DSP_COMPRESSOR_ATTACK: FMOD_DSP_COMPRESSOR = 2;
1905pub const FMOD_DSP_COMPRESSOR_RELEASE: FMOD_DSP_COMPRESSOR = 3;
1906pub const FMOD_DSP_COMPRESSOR_GAINMAKEUP: FMOD_DSP_COMPRESSOR = 4;
1907pub const FMOD_DSP_COMPRESSOR_USESIDECHAIN: FMOD_DSP_COMPRESSOR = 5;
1908pub const FMOD_DSP_COMPRESSOR_LINKED: FMOD_DSP_COMPRESSOR = 6;
1909pub type FMOD_DSP_COMPRESSOR = ::std::os::raw::c_uint;
1910pub const FMOD_DSP_SFXREVERB_DECAYTIME: FMOD_DSP_SFXREVERB = 0;
1911pub const FMOD_DSP_SFXREVERB_EARLYDELAY: FMOD_DSP_SFXREVERB = 1;
1912pub const FMOD_DSP_SFXREVERB_LATEDELAY: FMOD_DSP_SFXREVERB = 2;
1913pub const FMOD_DSP_SFXREVERB_HFREFERENCE: FMOD_DSP_SFXREVERB = 3;
1914pub const FMOD_DSP_SFXREVERB_HFDECAYRATIO: FMOD_DSP_SFXREVERB = 4;
1915pub const FMOD_DSP_SFXREVERB_DIFFUSION: FMOD_DSP_SFXREVERB = 5;
1916pub const FMOD_DSP_SFXREVERB_DENSITY: FMOD_DSP_SFXREVERB = 6;
1917pub const FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY: FMOD_DSP_SFXREVERB = 7;
1918pub const FMOD_DSP_SFXREVERB_LOWSHELFGAIN: FMOD_DSP_SFXREVERB = 8;
1919pub const FMOD_DSP_SFXREVERB_HIGHCUT: FMOD_DSP_SFXREVERB = 9;
1920pub const FMOD_DSP_SFXREVERB_EARLYLATEMIX: FMOD_DSP_SFXREVERB = 10;
1921pub const FMOD_DSP_SFXREVERB_WETLEVEL: FMOD_DSP_SFXREVERB = 11;
1922pub const FMOD_DSP_SFXREVERB_DRYLEVEL: FMOD_DSP_SFXREVERB = 12;
1923pub type FMOD_DSP_SFXREVERB = ::std::os::raw::c_uint;
1924pub const FMOD_DSP_LOWPASS_SIMPLE_CUTOFF: FMOD_DSP_LOWPASS_SIMPLE = 0;
1925pub type FMOD_DSP_LOWPASS_SIMPLE = ::std::os::raw::c_uint;
1926pub const FMOD_DSP_DELAY_CH0: FMOD_DSP_DELAY = 0;
1927pub const FMOD_DSP_DELAY_CH1: FMOD_DSP_DELAY = 1;
1928pub const FMOD_DSP_DELAY_CH2: FMOD_DSP_DELAY = 2;
1929pub const FMOD_DSP_DELAY_CH3: FMOD_DSP_DELAY = 3;
1930pub const FMOD_DSP_DELAY_CH4: FMOD_DSP_DELAY = 4;
1931pub const FMOD_DSP_DELAY_CH5: FMOD_DSP_DELAY = 5;
1932pub const FMOD_DSP_DELAY_CH6: FMOD_DSP_DELAY = 6;
1933pub const FMOD_DSP_DELAY_CH7: FMOD_DSP_DELAY = 7;
1934pub const FMOD_DSP_DELAY_CH8: FMOD_DSP_DELAY = 8;
1935pub const FMOD_DSP_DELAY_CH9: FMOD_DSP_DELAY = 9;
1936pub const FMOD_DSP_DELAY_CH10: FMOD_DSP_DELAY = 10;
1937pub const FMOD_DSP_DELAY_CH11: FMOD_DSP_DELAY = 11;
1938pub const FMOD_DSP_DELAY_CH12: FMOD_DSP_DELAY = 12;
1939pub const FMOD_DSP_DELAY_CH13: FMOD_DSP_DELAY = 13;
1940pub const FMOD_DSP_DELAY_CH14: FMOD_DSP_DELAY = 14;
1941pub const FMOD_DSP_DELAY_CH15: FMOD_DSP_DELAY = 15;
1942pub const FMOD_DSP_DELAY_MAXDELAY: FMOD_DSP_DELAY = 16;
1943pub type FMOD_DSP_DELAY = ::std::os::raw::c_uint;
1944pub const FMOD_DSP_TREMOLO_FREQUENCY: FMOD_DSP_TREMOLO = 0;
1945pub const FMOD_DSP_TREMOLO_DEPTH: FMOD_DSP_TREMOLO = 1;
1946pub const FMOD_DSP_TREMOLO_SHAPE: FMOD_DSP_TREMOLO = 2;
1947pub const FMOD_DSP_TREMOLO_SKEW: FMOD_DSP_TREMOLO = 3;
1948pub const FMOD_DSP_TREMOLO_DUTY: FMOD_DSP_TREMOLO = 4;
1949pub const FMOD_DSP_TREMOLO_SQUARE: FMOD_DSP_TREMOLO = 5;
1950pub const FMOD_DSP_TREMOLO_PHASE: FMOD_DSP_TREMOLO = 6;
1951pub const FMOD_DSP_TREMOLO_SPREAD: FMOD_DSP_TREMOLO = 7;
1952pub type FMOD_DSP_TREMOLO = ::std::os::raw::c_uint;
1953pub const FMOD_DSP_SEND_RETURNID: FMOD_DSP_SEND = 0;
1954pub const FMOD_DSP_SEND_LEVEL: FMOD_DSP_SEND = 1;
1955pub type FMOD_DSP_SEND = ::std::os::raw::c_uint;
1956pub const FMOD_DSP_RETURN_ID: FMOD_DSP_RETURN = 0;
1957pub const FMOD_DSP_RETURN_INPUT_SPEAKER_MODE: FMOD_DSP_RETURN = 1;
1958pub type FMOD_DSP_RETURN = ::std::os::raw::c_uint;
1959pub const FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF: FMOD_DSP_HIGHPASS_SIMPLE = 0;
1960pub type FMOD_DSP_HIGHPASS_SIMPLE = ::std::os::raw::c_uint;
1961pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 0;
1962pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 1;
1963pub type FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = ::std::os::raw::c_uint;
1964pub const FMOD_DSP_PAN_MODE_MONO: FMOD_DSP_PAN_MODE_TYPE = 0;
1965pub const FMOD_DSP_PAN_MODE_STEREO: FMOD_DSP_PAN_MODE_TYPE = 1;
1966pub const FMOD_DSP_PAN_MODE_SURROUND: FMOD_DSP_PAN_MODE_TYPE = 2;
1967pub type FMOD_DSP_PAN_MODE_TYPE = ::std::os::raw::c_uint;
1968pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 0;
1969pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEAR: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 1;
1970pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSE: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 2;
1971pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 3;
1972pub const FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 4;
1973pub type FMOD_DSP_PAN_3D_ROLLOFF_TYPE = ::std::os::raw::c_uint;
1974pub const FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 0;
1975pub const FMOD_DSP_PAN_3D_EXTENT_MODE_USER: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 1;
1976pub const FMOD_DSP_PAN_3D_EXTENT_MODE_OFF: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 2;
1977pub type FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = ::std::os::raw::c_uint;
1978pub const FMOD_DSP_PAN_MODE: FMOD_DSP_PAN = 0;
1979pub const FMOD_DSP_PAN_2D_STEREO_POSITION: FMOD_DSP_PAN = 1;
1980pub const FMOD_DSP_PAN_2D_DIRECTION: FMOD_DSP_PAN = 2;
1981pub const FMOD_DSP_PAN_2D_EXTENT: FMOD_DSP_PAN = 3;
1982pub const FMOD_DSP_PAN_2D_ROTATION: FMOD_DSP_PAN = 4;
1983pub const FMOD_DSP_PAN_2D_LFE_LEVEL: FMOD_DSP_PAN = 5;
1984pub const FMOD_DSP_PAN_2D_STEREO_MODE: FMOD_DSP_PAN = 6;
1985pub const FMOD_DSP_PAN_2D_STEREO_SEPARATION: FMOD_DSP_PAN = 7;
1986pub const FMOD_DSP_PAN_2D_STEREO_AXIS: FMOD_DSP_PAN = 8;
1987pub const FMOD_DSP_PAN_ENABLED_SPEAKERS: FMOD_DSP_PAN = 9;
1988pub const FMOD_DSP_PAN_3D_POSITION: FMOD_DSP_PAN = 10;
1989pub const FMOD_DSP_PAN_3D_ROLLOFF: FMOD_DSP_PAN = 11;
1990pub const FMOD_DSP_PAN_3D_MIN_DISTANCE: FMOD_DSP_PAN = 12;
1991pub const FMOD_DSP_PAN_3D_MAX_DISTANCE: FMOD_DSP_PAN = 13;
1992pub const FMOD_DSP_PAN_3D_EXTENT_MODE: FMOD_DSP_PAN = 14;
1993pub const FMOD_DSP_PAN_3D_SOUND_SIZE: FMOD_DSP_PAN = 15;
1994pub const FMOD_DSP_PAN_3D_MIN_EXTENT: FMOD_DSP_PAN = 16;
1995pub const FMOD_DSP_PAN_3D_PAN_BLEND: FMOD_DSP_PAN = 17;
1996pub const FMOD_DSP_PAN_LFE_UPMIX_ENABLED: FMOD_DSP_PAN = 18;
1997pub const FMOD_DSP_PAN_OVERALL_GAIN: FMOD_DSP_PAN = 19;
1998pub const FMOD_DSP_PAN_SURROUND_SPEAKER_MODE: FMOD_DSP_PAN = 20;
1999pub const FMOD_DSP_PAN_2D_HEIGHT_BLEND: FMOD_DSP_PAN = 21;
2000pub const FMOD_DSP_PAN_ATTENUATION_RANGE: FMOD_DSP_PAN = 22;
2001pub const FMOD_DSP_PAN_OVERRIDE_RANGE: FMOD_DSP_PAN = 23;
2002pub type FMOD_DSP_PAN = ::std::os::raw::c_uint;
2003pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 0;
2004pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 1;
2005pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 2;
2006pub type FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = ::std::os::raw::c_uint;
2007pub const FMOD_DSP_THREE_EQ_LOWGAIN: FMOD_DSP_THREE_EQ = 0;
2008pub const FMOD_DSP_THREE_EQ_MIDGAIN: FMOD_DSP_THREE_EQ = 1;
2009pub const FMOD_DSP_THREE_EQ_HIGHGAIN: FMOD_DSP_THREE_EQ = 2;
2010pub const FMOD_DSP_THREE_EQ_LOWCROSSOVER: FMOD_DSP_THREE_EQ = 3;
2011pub const FMOD_DSP_THREE_EQ_HIGHCROSSOVER: FMOD_DSP_THREE_EQ = 4;
2012pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE: FMOD_DSP_THREE_EQ = 5;
2013pub type FMOD_DSP_THREE_EQ = ::std::os::raw::c_uint;
2014pub const FMOD_DSP_FFT_WINDOW_RECT: FMOD_DSP_FFT_WINDOW_TYPE = 0;
2015pub const FMOD_DSP_FFT_WINDOW_TRIANGLE: FMOD_DSP_FFT_WINDOW_TYPE = 1;
2016pub const FMOD_DSP_FFT_WINDOW_HAMMING: FMOD_DSP_FFT_WINDOW_TYPE = 2;
2017pub const FMOD_DSP_FFT_WINDOW_HANNING: FMOD_DSP_FFT_WINDOW_TYPE = 3;
2018pub const FMOD_DSP_FFT_WINDOW_BLACKMAN: FMOD_DSP_FFT_WINDOW_TYPE = 4;
2019pub const FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS: FMOD_DSP_FFT_WINDOW_TYPE = 5;
2020pub type FMOD_DSP_FFT_WINDOW_TYPE = ::std::os::raw::c_uint;
2021pub const FMOD_DSP_FFT_DOWNMIX_NONE: FMOD_DSP_FFT_DOWNMIX_TYPE = 0;
2022pub const FMOD_DSP_FFT_DOWNMIX_MONO: FMOD_DSP_FFT_DOWNMIX_TYPE = 1;
2023pub type FMOD_DSP_FFT_DOWNMIX_TYPE = ::std::os::raw::c_uint;
2024pub const FMOD_DSP_FFT_WINDOWSIZE: FMOD_DSP_FFT = 0;
2025pub const FMOD_DSP_FFT_WINDOW: FMOD_DSP_FFT = 1;
2026pub const FMOD_DSP_FFT_BAND_START_FREQ: FMOD_DSP_FFT = 2;
2027pub const FMOD_DSP_FFT_BAND_STOP_FREQ: FMOD_DSP_FFT = 3;
2028pub const FMOD_DSP_FFT_SPECTRUMDATA: FMOD_DSP_FFT = 4;
2029pub const FMOD_DSP_FFT_RMS: FMOD_DSP_FFT = 5;
2030pub const FMOD_DSP_FFT_SPECTRAL_CENTROID: FMOD_DSP_FFT = 6;
2031pub const FMOD_DSP_FFT_IMMEDIATE_MODE: FMOD_DSP_FFT = 7;
2032pub const FMOD_DSP_FFT_DOWNMIX: FMOD_DSP_FFT = 8;
2033pub const FMOD_DSP_FFT_CHANNEL: FMOD_DSP_FFT = 9;
2034pub type FMOD_DSP_FFT = ::std::os::raw::c_uint;
2035pub const FMOD_DSP_LOUDNESS_METER_STATE: FMOD_DSP_LOUDNESS_METER = 0;
2036pub const FMOD_DSP_LOUDNESS_METER_WEIGHTING: FMOD_DSP_LOUDNESS_METER = 1;
2037pub const FMOD_DSP_LOUDNESS_METER_INFO: FMOD_DSP_LOUDNESS_METER = 2;
2038pub type FMOD_DSP_LOUDNESS_METER = ::std::os::raw::c_uint;
2039pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -3;
2040pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -2;
2041pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -1;
2042pub const FMOD_DSP_LOUDNESS_METER_STATE_PAUSED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 0;
2043pub const FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 1;
2044pub type FMOD_DSP_LOUDNESS_METER_STATE_TYPE = ::std::os::raw::c_int;
2045#[repr(C)]
2046#[derive(Debug, Copy, Clone, PartialEq)]
2047pub struct FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
2048 pub momentaryloudness: f32,
2049 pub shorttermloudness: f32,
2050 pub integratedloudness: f32,
2051 pub loudness10thpercentile: f32,
2052 pub loudness95thpercentile: f32,
2053 pub loudnesshistogram: [f32; 66usize],
2054 pub maxtruepeak: f32,
2055 pub maxmomentaryloudness: f32,
2056}
2057#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2058const _: () = {
2059 ["Size of FMOD_DSP_LOUDNESS_METER_INFO_TYPE"]
2060 [::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>() - 292usize];
2061 ["Alignment of FMOD_DSP_LOUDNESS_METER_INFO_TYPE"]
2062 [::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>() - 4usize];
2063 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::momentaryloudness"]
2064 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, momentaryloudness) - 0usize];
2065 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::shorttermloudness"]
2066 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, shorttermloudness) - 4usize];
2067 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::integratedloudness"]
2068 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, integratedloudness) - 8usize];
2069 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudness10thpercentile"][::std::mem::offset_of!(
2070 FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
2071 loudness10thpercentile
2072 ) - 12usize];
2073 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudness95thpercentile"][::std::mem::offset_of!(
2074 FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
2075 loudness95thpercentile
2076 ) - 16usize];
2077 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::loudnesshistogram"]
2078 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, loudnesshistogram) - 20usize];
2079 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::maxtruepeak"]
2080 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE, maxtruepeak) - 284usize];
2081 ["Offset of field: FMOD_DSP_LOUDNESS_METER_INFO_TYPE::maxmomentaryloudness"][::std::mem::offset_of!(
2082 FMOD_DSP_LOUDNESS_METER_INFO_TYPE,
2083 maxmomentaryloudness
2084 ) - 288usize];
2085};
2086impl Default for FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
2087 fn default() -> Self {
2088 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2089 unsafe {
2090 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2091 s.assume_init()
2092 }
2093 }
2094}
2095#[repr(C)]
2096#[derive(Debug, Default, Copy, Clone, PartialEq)]
2097pub struct FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
2098 pub channelweight: [f32; 32usize],
2099}
2100#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2101const _: () = {
2102 ["Size of FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE"]
2103 [::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>() - 128usize];
2104 ["Alignment of FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE"]
2105 [::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>() - 4usize];
2106 ["Offset of field: FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE::channelweight"]
2107 [::std::mem::offset_of!(FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE, channelweight) - 0usize];
2108};
2109pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR: FMOD_DSP_CONVOLUTION_REVERB = 0;
2110pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET: FMOD_DSP_CONVOLUTION_REVERB = 1;
2111pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY: FMOD_DSP_CONVOLUTION_REVERB = 2;
2112pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED: FMOD_DSP_CONVOLUTION_REVERB = 3;
2113pub type FMOD_DSP_CONVOLUTION_REVERB = ::std::os::raw::c_uint;
2114pub const FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT: FMOD_DSP_CHANNELMIX_OUTPUT = 0;
2115pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO: FMOD_DSP_CHANNELMIX_OUTPUT = 1;
2116pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO: FMOD_DSP_CHANNELMIX_OUTPUT = 2;
2117pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD: FMOD_DSP_CHANNELMIX_OUTPUT = 3;
2118pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 4;
2119pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 5;
2120pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE: FMOD_DSP_CHANNELMIX_OUTPUT = 6;
2121pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4: FMOD_DSP_CHANNELMIX_OUTPUT = 7;
2122pub type FMOD_DSP_CHANNELMIX_OUTPUT = ::std::os::raw::c_uint;
2123pub const FMOD_DSP_CHANNELMIX_OUTPUTGROUPING: FMOD_DSP_CHANNELMIX = 0;
2124pub const FMOD_DSP_CHANNELMIX_GAIN_CH0: FMOD_DSP_CHANNELMIX = 1;
2125pub const FMOD_DSP_CHANNELMIX_GAIN_CH1: FMOD_DSP_CHANNELMIX = 2;
2126pub const FMOD_DSP_CHANNELMIX_GAIN_CH2: FMOD_DSP_CHANNELMIX = 3;
2127pub const FMOD_DSP_CHANNELMIX_GAIN_CH3: FMOD_DSP_CHANNELMIX = 4;
2128pub const FMOD_DSP_CHANNELMIX_GAIN_CH4: FMOD_DSP_CHANNELMIX = 5;
2129pub const FMOD_DSP_CHANNELMIX_GAIN_CH5: FMOD_DSP_CHANNELMIX = 6;
2130pub const FMOD_DSP_CHANNELMIX_GAIN_CH6: FMOD_DSP_CHANNELMIX = 7;
2131pub const FMOD_DSP_CHANNELMIX_GAIN_CH7: FMOD_DSP_CHANNELMIX = 8;
2132pub const FMOD_DSP_CHANNELMIX_GAIN_CH8: FMOD_DSP_CHANNELMIX = 9;
2133pub const FMOD_DSP_CHANNELMIX_GAIN_CH9: FMOD_DSP_CHANNELMIX = 10;
2134pub const FMOD_DSP_CHANNELMIX_GAIN_CH10: FMOD_DSP_CHANNELMIX = 11;
2135pub const FMOD_DSP_CHANNELMIX_GAIN_CH11: FMOD_DSP_CHANNELMIX = 12;
2136pub const FMOD_DSP_CHANNELMIX_GAIN_CH12: FMOD_DSP_CHANNELMIX = 13;
2137pub const FMOD_DSP_CHANNELMIX_GAIN_CH13: FMOD_DSP_CHANNELMIX = 14;
2138pub const FMOD_DSP_CHANNELMIX_GAIN_CH14: FMOD_DSP_CHANNELMIX = 15;
2139pub const FMOD_DSP_CHANNELMIX_GAIN_CH15: FMOD_DSP_CHANNELMIX = 16;
2140pub const FMOD_DSP_CHANNELMIX_GAIN_CH16: FMOD_DSP_CHANNELMIX = 17;
2141pub const FMOD_DSP_CHANNELMIX_GAIN_CH17: FMOD_DSP_CHANNELMIX = 18;
2142pub const FMOD_DSP_CHANNELMIX_GAIN_CH18: FMOD_DSP_CHANNELMIX = 19;
2143pub const FMOD_DSP_CHANNELMIX_GAIN_CH19: FMOD_DSP_CHANNELMIX = 20;
2144pub const FMOD_DSP_CHANNELMIX_GAIN_CH20: FMOD_DSP_CHANNELMIX = 21;
2145pub const FMOD_DSP_CHANNELMIX_GAIN_CH21: FMOD_DSP_CHANNELMIX = 22;
2146pub const FMOD_DSP_CHANNELMIX_GAIN_CH22: FMOD_DSP_CHANNELMIX = 23;
2147pub const FMOD_DSP_CHANNELMIX_GAIN_CH23: FMOD_DSP_CHANNELMIX = 24;
2148pub const FMOD_DSP_CHANNELMIX_GAIN_CH24: FMOD_DSP_CHANNELMIX = 25;
2149pub const FMOD_DSP_CHANNELMIX_GAIN_CH25: FMOD_DSP_CHANNELMIX = 26;
2150pub const FMOD_DSP_CHANNELMIX_GAIN_CH26: FMOD_DSP_CHANNELMIX = 27;
2151pub const FMOD_DSP_CHANNELMIX_GAIN_CH27: FMOD_DSP_CHANNELMIX = 28;
2152pub const FMOD_DSP_CHANNELMIX_GAIN_CH28: FMOD_DSP_CHANNELMIX = 29;
2153pub const FMOD_DSP_CHANNELMIX_GAIN_CH29: FMOD_DSP_CHANNELMIX = 30;
2154pub const FMOD_DSP_CHANNELMIX_GAIN_CH30: FMOD_DSP_CHANNELMIX = 31;
2155pub const FMOD_DSP_CHANNELMIX_GAIN_CH31: FMOD_DSP_CHANNELMIX = 32;
2156pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH0: FMOD_DSP_CHANNELMIX = 33;
2157pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH1: FMOD_DSP_CHANNELMIX = 34;
2158pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH2: FMOD_DSP_CHANNELMIX = 35;
2159pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH3: FMOD_DSP_CHANNELMIX = 36;
2160pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH4: FMOD_DSP_CHANNELMIX = 37;
2161pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH5: FMOD_DSP_CHANNELMIX = 38;
2162pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH6: FMOD_DSP_CHANNELMIX = 39;
2163pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH7: FMOD_DSP_CHANNELMIX = 40;
2164pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH8: FMOD_DSP_CHANNELMIX = 41;
2165pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH9: FMOD_DSP_CHANNELMIX = 42;
2166pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH10: FMOD_DSP_CHANNELMIX = 43;
2167pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH11: FMOD_DSP_CHANNELMIX = 44;
2168pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH12: FMOD_DSP_CHANNELMIX = 45;
2169pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH13: FMOD_DSP_CHANNELMIX = 46;
2170pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH14: FMOD_DSP_CHANNELMIX = 47;
2171pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH15: FMOD_DSP_CHANNELMIX = 48;
2172pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH16: FMOD_DSP_CHANNELMIX = 49;
2173pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH17: FMOD_DSP_CHANNELMIX = 50;
2174pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH18: FMOD_DSP_CHANNELMIX = 51;
2175pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH19: FMOD_DSP_CHANNELMIX = 52;
2176pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH20: FMOD_DSP_CHANNELMIX = 53;
2177pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH21: FMOD_DSP_CHANNELMIX = 54;
2178pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH22: FMOD_DSP_CHANNELMIX = 55;
2179pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH23: FMOD_DSP_CHANNELMIX = 56;
2180pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH24: FMOD_DSP_CHANNELMIX = 57;
2181pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH25: FMOD_DSP_CHANNELMIX = 58;
2182pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH26: FMOD_DSP_CHANNELMIX = 59;
2183pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH27: FMOD_DSP_CHANNELMIX = 60;
2184pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH28: FMOD_DSP_CHANNELMIX = 61;
2185pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH29: FMOD_DSP_CHANNELMIX = 62;
2186pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH30: FMOD_DSP_CHANNELMIX = 63;
2187pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH31: FMOD_DSP_CHANNELMIX = 64;
2188pub type FMOD_DSP_CHANNELMIX = ::std::os::raw::c_uint;
2189pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = -1;
2190pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 0;
2191pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 1;
2192pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 2;
2193pub type FMOD_DSP_TRANSCEIVER_SPEAKERMODE = ::std::os::raw::c_int;
2194pub const FMOD_DSP_TRANSCEIVER_TRANSMIT: FMOD_DSP_TRANSCEIVER = 0;
2195pub const FMOD_DSP_TRANSCEIVER_GAIN: FMOD_DSP_TRANSCEIVER = 1;
2196pub const FMOD_DSP_TRANSCEIVER_CHANNEL: FMOD_DSP_TRANSCEIVER = 2;
2197pub const FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE: FMOD_DSP_TRANSCEIVER = 3;
2198pub type FMOD_DSP_TRANSCEIVER = ::std::os::raw::c_uint;
2199pub const FMOD_DSP_OBJECTPAN_3D_POSITION: FMOD_DSP_OBJECTPAN = 0;
2200pub const FMOD_DSP_OBJECTPAN_3D_ROLLOFF: FMOD_DSP_OBJECTPAN = 1;
2201pub const FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE: FMOD_DSP_OBJECTPAN = 2;
2202pub const FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE: FMOD_DSP_OBJECTPAN = 3;
2203pub const FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE: FMOD_DSP_OBJECTPAN = 4;
2204pub const FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE: FMOD_DSP_OBJECTPAN = 5;
2205pub const FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT: FMOD_DSP_OBJECTPAN = 6;
2206pub const FMOD_DSP_OBJECTPAN_OVERALL_GAIN: FMOD_DSP_OBJECTPAN = 7;
2207pub const FMOD_DSP_OBJECTPAN_OUTPUTGAIN: FMOD_DSP_OBJECTPAN = 8;
2208pub const FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE: FMOD_DSP_OBJECTPAN = 9;
2209pub const FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE: FMOD_DSP_OBJECTPAN = 10;
2210pub type FMOD_DSP_OBJECTPAN = ::std::os::raw::c_uint;
2211pub const FMOD_DSP_PROCESS_PERFORM: FMOD_DSP_PROCESS_OPERATION = 0;
2212pub const FMOD_DSP_PROCESS_QUERY: FMOD_DSP_PROCESS_OPERATION = 1;
2213pub type FMOD_DSP_PROCESS_OPERATION = ::std::os::raw::c_uint;
2214pub const FMOD_DSP_PAN_SURROUND_DEFAULT: FMOD_DSP_PAN_SURROUND_FLAGS = 0;
2215pub const FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED: FMOD_DSP_PAN_SURROUND_FLAGS = 1;
2216pub const FMOD_DSP_PAN_SURROUND_FLAGS_FORCEINT: FMOD_DSP_PAN_SURROUND_FLAGS = 65536;
2217pub type FMOD_DSP_PAN_SURROUND_FLAGS = ::std::os::raw::c_uint;
2218pub const FMOD_DSP_PARAMETER_TYPE_FLOAT: FMOD_DSP_PARAMETER_TYPE = 0;
2219pub const FMOD_DSP_PARAMETER_TYPE_INT: FMOD_DSP_PARAMETER_TYPE = 1;
2220pub const FMOD_DSP_PARAMETER_TYPE_BOOL: FMOD_DSP_PARAMETER_TYPE = 2;
2221pub const FMOD_DSP_PARAMETER_TYPE_DATA: FMOD_DSP_PARAMETER_TYPE = 3;
2222pub const FMOD_DSP_PARAMETER_TYPE_MAX: FMOD_DSP_PARAMETER_TYPE = 4;
2223pub const FMOD_DSP_PARAMETER_TYPE_FORCEINT: FMOD_DSP_PARAMETER_TYPE = 65536;
2224pub type FMOD_DSP_PARAMETER_TYPE = ::std::os::raw::c_uint;
2225pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 0;
2226pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 1;
2227pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR:
2228 FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 2;
2229pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_FORCEINT: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE =
2230 65536;
2231pub type FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = ::std::os::raw::c_uint;
2232pub const FMOD_DSP_PARAMETER_DATA_TYPE_USER: FMOD_DSP_PARAMETER_DATA_TYPE = 0;
2233pub const FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -1;
2234pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES: FMOD_DSP_PARAMETER_DATA_TYPE = -2;
2235pub const FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -3;
2236pub const FMOD_DSP_PARAMETER_DATA_TYPE_FFT: FMOD_DSP_PARAMETER_DATA_TYPE = -4;
2237pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI: FMOD_DSP_PARAMETER_DATA_TYPE = -5;
2238pub const FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE: FMOD_DSP_PARAMETER_DATA_TYPE = -6;
2239pub const FMOD_DSP_PARAMETER_DATA_TYPE_DYNAMIC_RESPONSE: FMOD_DSP_PARAMETER_DATA_TYPE = -7;
2240pub type FMOD_DSP_PARAMETER_DATA_TYPE = ::std::os::raw::c_int;
2241pub type FMOD_DSP_CREATE_CALLBACK =
2242 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
2243pub type FMOD_DSP_RELEASE_CALLBACK =
2244 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
2245pub type FMOD_DSP_RESET_CALLBACK =
2246 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
2247pub type FMOD_DSP_READ_CALLBACK = ::std::option::Option<
2248 unsafe extern "C" fn(
2249 dsp_state: *mut FMOD_DSP_STATE,
2250 inbuffer: *mut f32,
2251 outbuffer: *mut f32,
2252 length: ::std::os::raw::c_uint,
2253 inchannels: ::std::os::raw::c_int,
2254 outchannels: *mut ::std::os::raw::c_int,
2255 ) -> FMOD_RESULT,
2256>;
2257pub type FMOD_DSP_PROCESS_CALLBACK = ::std::option::Option<
2258 unsafe extern "C" fn(
2259 dsp_state: *mut FMOD_DSP_STATE,
2260 length: ::std::os::raw::c_uint,
2261 inbufferarray: *const FMOD_DSP_BUFFER_ARRAY,
2262 outbufferarray: *mut FMOD_DSP_BUFFER_ARRAY,
2263 inputsidle: FMOD_BOOL,
2264 op: FMOD_DSP_PROCESS_OPERATION,
2265 ) -> FMOD_RESULT,
2266>;
2267pub type FMOD_DSP_SETPOSITION_CALLBACK = ::std::option::Option<
2268 unsafe extern "C" fn(
2269 dsp_state: *mut FMOD_DSP_STATE,
2270 pos: ::std::os::raw::c_uint,
2271 ) -> FMOD_RESULT,
2272>;
2273pub type FMOD_DSP_SHOULDIPROCESS_CALLBACK = ::std::option::Option<
2274 unsafe extern "C" fn(
2275 dsp_state: *mut FMOD_DSP_STATE,
2276 inputsidle: FMOD_BOOL,
2277 length: ::std::os::raw::c_uint,
2278 inmask: FMOD_CHANNELMASK,
2279 inchannels: ::std::os::raw::c_int,
2280 speakermode: FMOD_SPEAKERMODE,
2281 ) -> FMOD_RESULT,
2282>;
2283pub type FMOD_DSP_SETPARAM_FLOAT_CALLBACK = ::std::option::Option<
2284 unsafe extern "C" fn(
2285 dsp_state: *mut FMOD_DSP_STATE,
2286 index: ::std::os::raw::c_int,
2287 value: f32,
2288 ) -> FMOD_RESULT,
2289>;
2290pub type FMOD_DSP_SETPARAM_INT_CALLBACK = ::std::option::Option<
2291 unsafe extern "C" fn(
2292 dsp_state: *mut FMOD_DSP_STATE,
2293 index: ::std::os::raw::c_int,
2294 value: ::std::os::raw::c_int,
2295 ) -> FMOD_RESULT,
2296>;
2297pub type FMOD_DSP_SETPARAM_BOOL_CALLBACK = ::std::option::Option<
2298 unsafe extern "C" fn(
2299 dsp_state: *mut FMOD_DSP_STATE,
2300 index: ::std::os::raw::c_int,
2301 value: FMOD_BOOL,
2302 ) -> FMOD_RESULT,
2303>;
2304pub type FMOD_DSP_SETPARAM_DATA_CALLBACK = ::std::option::Option<
2305 unsafe extern "C" fn(
2306 dsp_state: *mut FMOD_DSP_STATE,
2307 index: ::std::os::raw::c_int,
2308 data: *mut ::std::os::raw::c_void,
2309 length: ::std::os::raw::c_uint,
2310 ) -> FMOD_RESULT,
2311>;
2312pub type FMOD_DSP_GETPARAM_FLOAT_CALLBACK = ::std::option::Option<
2313 unsafe extern "C" fn(
2314 dsp_state: *mut FMOD_DSP_STATE,
2315 index: ::std::os::raw::c_int,
2316 value: *mut f32,
2317 valuestr: *mut ::std::os::raw::c_char,
2318 ) -> FMOD_RESULT,
2319>;
2320pub type FMOD_DSP_GETPARAM_INT_CALLBACK = ::std::option::Option<
2321 unsafe extern "C" fn(
2322 dsp_state: *mut FMOD_DSP_STATE,
2323 index: ::std::os::raw::c_int,
2324 value: *mut ::std::os::raw::c_int,
2325 valuestr: *mut ::std::os::raw::c_char,
2326 ) -> FMOD_RESULT,
2327>;
2328pub type FMOD_DSP_GETPARAM_BOOL_CALLBACK = ::std::option::Option<
2329 unsafe extern "C" fn(
2330 dsp_state: *mut FMOD_DSP_STATE,
2331 index: ::std::os::raw::c_int,
2332 value: *mut FMOD_BOOL,
2333 valuestr: *mut ::std::os::raw::c_char,
2334 ) -> FMOD_RESULT,
2335>;
2336pub type FMOD_DSP_GETPARAM_DATA_CALLBACK = ::std::option::Option<
2337 unsafe extern "C" fn(
2338 dsp_state: *mut FMOD_DSP_STATE,
2339 index: ::std::os::raw::c_int,
2340 data: *mut *mut ::std::os::raw::c_void,
2341 length: *mut ::std::os::raw::c_uint,
2342 valuestr: *mut ::std::os::raw::c_char,
2343 ) -> FMOD_RESULT,
2344>;
2345pub type FMOD_DSP_SYSTEM_REGISTER_CALLBACK =
2346 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
2347pub type FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK =
2348 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
2349pub type FMOD_DSP_SYSTEM_MIX_CALLBACK = ::std::option::Option<
2350 unsafe extern "C" fn(
2351 dsp_state: *mut FMOD_DSP_STATE,
2352 stage: ::std::os::raw::c_int,
2353 ) -> FMOD_RESULT,
2354>;
2355pub type FMOD_DSP_ALLOC_FUNC = ::std::option::Option<
2356 unsafe extern "C" fn(
2357 size: ::std::os::raw::c_uint,
2358 type_: FMOD_MEMORY_TYPE,
2359 sourcestr: *const ::std::os::raw::c_char,
2360 ) -> *mut ::std::os::raw::c_void,
2361>;
2362pub type FMOD_DSP_REALLOC_FUNC = ::std::option::Option<
2363 unsafe extern "C" fn(
2364 ptr: *mut ::std::os::raw::c_void,
2365 size: ::std::os::raw::c_uint,
2366 type_: FMOD_MEMORY_TYPE,
2367 sourcestr: *const ::std::os::raw::c_char,
2368 ) -> *mut ::std::os::raw::c_void,
2369>;
2370pub type FMOD_DSP_FREE_FUNC = ::std::option::Option<
2371 unsafe extern "C" fn(
2372 ptr: *mut ::std::os::raw::c_void,
2373 type_: FMOD_MEMORY_TYPE,
2374 sourcestr: *const ::std::os::raw::c_char,
2375 ),
2376>;
2377pub type FMOD_DSP_LOG_FUNC = ::std::option::Option<
2378 unsafe extern "C" fn(
2379 level: FMOD_DEBUG_FLAGS,
2380 file: *const ::std::os::raw::c_char,
2381 line: ::std::os::raw::c_int,
2382 function: *const ::std::os::raw::c_char,
2383 str_: *const ::std::os::raw::c_char,
2384 ...
2385 ),
2386>;
2387pub type FMOD_DSP_GETSAMPLERATE_FUNC = ::std::option::Option<
2388 unsafe extern "C" fn(
2389 dsp_state: *mut FMOD_DSP_STATE,
2390 rate: *mut ::std::os::raw::c_int,
2391 ) -> FMOD_RESULT,
2392>;
2393pub type FMOD_DSP_GETBLOCKSIZE_FUNC = ::std::option::Option<
2394 unsafe extern "C" fn(
2395 dsp_state: *mut FMOD_DSP_STATE,
2396 blocksize: *mut ::std::os::raw::c_uint,
2397 ) -> FMOD_RESULT,
2398>;
2399pub type FMOD_DSP_GETSPEAKERMODE_FUNC = ::std::option::Option<
2400 unsafe extern "C" fn(
2401 dsp_state: *mut FMOD_DSP_STATE,
2402 speakermode_mixer: *mut FMOD_SPEAKERMODE,
2403 speakermode_output: *mut FMOD_SPEAKERMODE,
2404 ) -> FMOD_RESULT,
2405>;
2406pub type FMOD_DSP_GETCLOCK_FUNC = ::std::option::Option<
2407 unsafe extern "C" fn(
2408 dsp_state: *mut FMOD_DSP_STATE,
2409 clock: *mut ::std::os::raw::c_ulonglong,
2410 offset: *mut ::std::os::raw::c_uint,
2411 length: *mut ::std::os::raw::c_uint,
2412 ) -> FMOD_RESULT,
2413>;
2414pub type FMOD_DSP_GETLISTENERATTRIBUTES_FUNC = ::std::option::Option<
2415 unsafe extern "C" fn(
2416 dsp_state: *mut FMOD_DSP_STATE,
2417 numlisteners: *mut ::std::os::raw::c_int,
2418 attributes: *mut FMOD_3D_ATTRIBUTES,
2419 ) -> FMOD_RESULT,
2420>;
2421pub type FMOD_DSP_GETUSERDATA_FUNC = ::std::option::Option<
2422 unsafe extern "C" fn(
2423 dsp_state: *mut FMOD_DSP_STATE,
2424 userdata: *mut *mut ::std::os::raw::c_void,
2425 ) -> FMOD_RESULT,
2426>;
2427pub type FMOD_DSP_DFT_FFTREAL_FUNC = ::std::option::Option<
2428 unsafe extern "C" fn(
2429 dsp_state: *mut FMOD_DSP_STATE,
2430 size: ::std::os::raw::c_int,
2431 signal: *const f32,
2432 dft: *mut FMOD_COMPLEX,
2433 window: *const f32,
2434 signalhop: ::std::os::raw::c_int,
2435 ) -> FMOD_RESULT,
2436>;
2437pub type FMOD_DSP_DFT_IFFTREAL_FUNC = ::std::option::Option<
2438 unsafe extern "C" fn(
2439 dsp_state: *mut FMOD_DSP_STATE,
2440 size: ::std::os::raw::c_int,
2441 dft: *const FMOD_COMPLEX,
2442 signal: *mut f32,
2443 window: *const f32,
2444 signalhop: ::std::os::raw::c_int,
2445 ) -> FMOD_RESULT,
2446>;
2447pub type FMOD_DSP_PAN_SUMMONOMATRIX_FUNC = ::std::option::Option<
2448 unsafe extern "C" fn(
2449 dsp_state: *mut FMOD_DSP_STATE,
2450 sourceSpeakerMode: FMOD_SPEAKERMODE,
2451 lowFrequencyGain: f32,
2452 overallGain: f32,
2453 matrix: *mut f32,
2454 ) -> FMOD_RESULT,
2455>;
2456pub type FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC = ::std::option::Option<
2457 unsafe extern "C" fn(
2458 dsp_state: *mut FMOD_DSP_STATE,
2459 sourceSpeakerMode: FMOD_SPEAKERMODE,
2460 pan: f32,
2461 lowFrequencyGain: f32,
2462 overallGain: f32,
2463 matrixHop: ::std::os::raw::c_int,
2464 matrix: *mut f32,
2465 ) -> FMOD_RESULT,
2466>;
2467pub type FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC = ::std::option::Option<
2468 unsafe extern "C" fn(
2469 dsp_state: *mut FMOD_DSP_STATE,
2470 sourceSpeakerMode: FMOD_SPEAKERMODE,
2471 targetSpeakerMode: FMOD_SPEAKERMODE,
2472 direction: f32,
2473 extent: f32,
2474 rotation: f32,
2475 lowFrequencyGain: f32,
2476 overallGain: f32,
2477 matrixHop: ::std::os::raw::c_int,
2478 matrix: *mut f32,
2479 flags: FMOD_DSP_PAN_SURROUND_FLAGS,
2480 ) -> FMOD_RESULT,
2481>;
2482pub type FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
2483 unsafe extern "C" fn(
2484 dsp_state: *mut FMOD_DSP_STATE,
2485 targetSpeakerMode: FMOD_SPEAKERMODE,
2486 direction: f32,
2487 extent: f32,
2488 lowFrequencyGain: f32,
2489 overallGain: f32,
2490 matrixHop: ::std::os::raw::c_int,
2491 matrix: *mut f32,
2492 ) -> FMOD_RESULT,
2493>;
2494pub type FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
2495 unsafe extern "C" fn(
2496 dsp_state: *mut FMOD_DSP_STATE,
2497 targetSpeakerMode: FMOD_SPEAKERMODE,
2498 direction: f32,
2499 extent: f32,
2500 rotation: f32,
2501 lowFrequencyGain: f32,
2502 overallGain: f32,
2503 matrixHop: ::std::os::raw::c_int,
2504 matrix: *mut f32,
2505 ) -> FMOD_RESULT,
2506>;
2507pub type FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC = ::std::option::Option<
2508 unsafe extern "C" fn(
2509 dsp_state: *mut FMOD_DSP_STATE,
2510 rolloff: FMOD_DSP_PAN_3D_ROLLOFF_TYPE,
2511 distance: f32,
2512 mindistance: f32,
2513 maxdistance: f32,
2514 gain: *mut f32,
2515 ) -> FMOD_RESULT,
2516>;
2517#[repr(C)]
2518#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2519pub struct FMOD_DSP_BUFFER_ARRAY {
2520 pub numbuffers: ::std::os::raw::c_int,
2521 pub buffernumchannels: *mut ::std::os::raw::c_int,
2522 pub bufferchannelmask: *mut FMOD_CHANNELMASK,
2523 pub buffers: *mut *mut f32,
2524 pub speakermode: FMOD_SPEAKERMODE,
2525}
2526#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2527const _: () = {
2528 ["Size of FMOD_DSP_BUFFER_ARRAY"][::std::mem::size_of::<FMOD_DSP_BUFFER_ARRAY>() - 40usize];
2529 ["Alignment of FMOD_DSP_BUFFER_ARRAY"]
2530 [::std::mem::align_of::<FMOD_DSP_BUFFER_ARRAY>() - 8usize];
2531 ["Offset of field: FMOD_DSP_BUFFER_ARRAY::numbuffers"]
2532 [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, numbuffers) - 0usize];
2533 ["Offset of field: FMOD_DSP_BUFFER_ARRAY::buffernumchannels"]
2534 [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, buffernumchannels) - 8usize];
2535 ["Offset of field: FMOD_DSP_BUFFER_ARRAY::bufferchannelmask"]
2536 [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, bufferchannelmask) - 16usize];
2537 ["Offset of field: FMOD_DSP_BUFFER_ARRAY::buffers"]
2538 [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, buffers) - 24usize];
2539 ["Offset of field: FMOD_DSP_BUFFER_ARRAY::speakermode"]
2540 [::std::mem::offset_of!(FMOD_DSP_BUFFER_ARRAY, speakermode) - 32usize];
2541};
2542impl Default for FMOD_DSP_BUFFER_ARRAY {
2543 fn default() -> Self {
2544 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2545 unsafe {
2546 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2547 s.assume_init()
2548 }
2549 }
2550}
2551#[repr(C)]
2552#[derive(Debug, Default, Copy, Clone, PartialEq)]
2553pub struct FMOD_COMPLEX {
2554 pub real: f32,
2555 pub imag: f32,
2556}
2557#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2558const _: () = {
2559 ["Size of FMOD_COMPLEX"][::std::mem::size_of::<FMOD_COMPLEX>() - 8usize];
2560 ["Alignment of FMOD_COMPLEX"][::std::mem::align_of::<FMOD_COMPLEX>() - 4usize];
2561 ["Offset of field: FMOD_COMPLEX::real"][::std::mem::offset_of!(FMOD_COMPLEX, real) - 0usize];
2562 ["Offset of field: FMOD_COMPLEX::imag"][::std::mem::offset_of!(FMOD_COMPLEX, imag) - 4usize];
2563};
2564#[repr(C)]
2565#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2566pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
2567 pub numpoints: ::std::os::raw::c_int,
2568 pub pointparamvalues: *mut f32,
2569 pub pointpositions: *mut f32,
2570}
2571#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2572const _: () = {
2573 ["Size of FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR"]
2574 [::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>() - 24usize];
2575 ["Alignment of FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR"]
2576 [::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>() - 8usize];
2577 ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::numpoints"][::std::mem::offset_of!(
2578 FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
2579 numpoints
2580 ) - 0usize];
2581 ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::pointparamvalues"][::std::mem::offset_of!(
2582 FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
2583 pointparamvalues
2584 )
2585 - 8usize];
2586 ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR::pointpositions"][::std::mem::offset_of!(
2587 FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
2588 pointpositions
2589 )
2590 - 16usize];
2591};
2592impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
2593 fn default() -> Self {
2594 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2595 unsafe {
2596 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2597 s.assume_init()
2598 }
2599 }
2600}
2601#[repr(C)]
2602#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2603pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING {
2604 pub type_: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE,
2605 pub piecewiselinearmapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
2606}
2607#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2608const _: () = {
2609 ["Size of FMOD_DSP_PARAMETER_FLOAT_MAPPING"]
2610 [::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>() - 32usize];
2611 ["Alignment of FMOD_DSP_PARAMETER_FLOAT_MAPPING"]
2612 [::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>() - 8usize];
2613 ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING::type_"]
2614 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FLOAT_MAPPING, type_) - 0usize];
2615 ["Offset of field: FMOD_DSP_PARAMETER_FLOAT_MAPPING::piecewiselinearmapping"]
2616 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FLOAT_MAPPING, piecewiselinearmapping) - 8usize];
2617};
2618impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING {
2619 fn default() -> Self {
2620 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2621 unsafe {
2622 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2623 s.assume_init()
2624 }
2625 }
2626}
2627#[repr(C)]
2628#[derive(Debug, Copy, Clone, PartialEq)]
2629pub struct FMOD_DSP_PARAMETER_DESC_FLOAT {
2630 pub min: f32,
2631 pub max: f32,
2632 pub defaultval: f32,
2633 pub mapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING,
2634}
2635#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2636const _: () = {
2637 ["Size of FMOD_DSP_PARAMETER_DESC_FLOAT"]
2638 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>() - 48usize];
2639 ["Alignment of FMOD_DSP_PARAMETER_DESC_FLOAT"]
2640 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>() - 8usize];
2641 ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::min"]
2642 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, min) - 0usize];
2643 ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::max"]
2644 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, max) - 4usize];
2645 ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::defaultval"]
2646 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, defaultval) - 8usize];
2647 ["Offset of field: FMOD_DSP_PARAMETER_DESC_FLOAT::mapping"]
2648 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_FLOAT, mapping) - 16usize];
2649};
2650impl Default for FMOD_DSP_PARAMETER_DESC_FLOAT {
2651 fn default() -> Self {
2652 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2653 unsafe {
2654 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2655 s.assume_init()
2656 }
2657 }
2658}
2659#[repr(C)]
2660#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2661pub struct FMOD_DSP_PARAMETER_DESC_INT {
2662 pub min: ::std::os::raw::c_int,
2663 pub max: ::std::os::raw::c_int,
2664 pub defaultval: ::std::os::raw::c_int,
2665 pub goestoinf: FMOD_BOOL,
2666 pub valuenames: *const *const ::std::os::raw::c_char,
2667}
2668#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2669const _: () = {
2670 ["Size of FMOD_DSP_PARAMETER_DESC_INT"]
2671 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_INT>() - 24usize];
2672 ["Alignment of FMOD_DSP_PARAMETER_DESC_INT"]
2673 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_INT>() - 8usize];
2674 ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::min"]
2675 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, min) - 0usize];
2676 ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::max"]
2677 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, max) - 4usize];
2678 ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::defaultval"]
2679 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, defaultval) - 8usize];
2680 ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::goestoinf"]
2681 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, goestoinf) - 12usize];
2682 ["Offset of field: FMOD_DSP_PARAMETER_DESC_INT::valuenames"]
2683 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_INT, valuenames) - 16usize];
2684};
2685impl Default for FMOD_DSP_PARAMETER_DESC_INT {
2686 fn default() -> Self {
2687 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2688 unsafe {
2689 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2690 s.assume_init()
2691 }
2692 }
2693}
2694#[repr(C)]
2695#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2696pub struct FMOD_DSP_PARAMETER_DESC_BOOL {
2697 pub defaultval: FMOD_BOOL,
2698 pub valuenames: *const *const ::std::os::raw::c_char,
2699}
2700#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2701const _: () = {
2702 ["Size of FMOD_DSP_PARAMETER_DESC_BOOL"]
2703 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_BOOL>() - 16usize];
2704 ["Alignment of FMOD_DSP_PARAMETER_DESC_BOOL"]
2705 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_BOOL>() - 8usize];
2706 ["Offset of field: FMOD_DSP_PARAMETER_DESC_BOOL::defaultval"]
2707 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_BOOL, defaultval) - 0usize];
2708 ["Offset of field: FMOD_DSP_PARAMETER_DESC_BOOL::valuenames"]
2709 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_BOOL, valuenames) - 8usize];
2710};
2711impl Default for FMOD_DSP_PARAMETER_DESC_BOOL {
2712 fn default() -> Self {
2713 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2714 unsafe {
2715 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2716 s.assume_init()
2717 }
2718 }
2719}
2720#[repr(C)]
2721#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
2722pub struct FMOD_DSP_PARAMETER_DESC_DATA {
2723 pub datatype: ::std::os::raw::c_int,
2724}
2725#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2726const _: () = {
2727 ["Size of FMOD_DSP_PARAMETER_DESC_DATA"]
2728 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_DATA>() - 4usize];
2729 ["Alignment of FMOD_DSP_PARAMETER_DESC_DATA"]
2730 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_DATA>() - 4usize];
2731 ["Offset of field: FMOD_DSP_PARAMETER_DESC_DATA::datatype"]
2732 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC_DATA, datatype) - 0usize];
2733};
2734#[repr(C)]
2735#[derive(Copy, Clone)]
2736pub struct FMOD_DSP_PARAMETER_DESC {
2737 pub type_: FMOD_DSP_PARAMETER_TYPE,
2738 pub name: [::std::os::raw::c_char; 16usize],
2739 pub label: [::std::os::raw::c_char; 16usize],
2740 pub description: *const ::std::os::raw::c_char,
2741 pub __bindgen_anon_1: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1,
2742}
2743#[repr(C)]
2744#[derive(Copy, Clone)]
2745pub union FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
2746 pub floatdesc: FMOD_DSP_PARAMETER_DESC_FLOAT,
2747 pub intdesc: FMOD_DSP_PARAMETER_DESC_INT,
2748 pub booldesc: FMOD_DSP_PARAMETER_DESC_BOOL,
2749 pub datadesc: FMOD_DSP_PARAMETER_DESC_DATA,
2750}
2751#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2752const _: () = {
2753 ["Size of FMOD_DSP_PARAMETER_DESC__bindgen_ty_1"]
2754 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>() - 48usize];
2755 ["Alignment of FMOD_DSP_PARAMETER_DESC__bindgen_ty_1"]
2756 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>() - 8usize];
2757 ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::floatdesc"]
2758 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, floatdesc) - 0usize];
2759 ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::intdesc"]
2760 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, intdesc) - 0usize];
2761 ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::booldesc"]
2762 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, booldesc) - 0usize];
2763 ["Offset of field: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1::datadesc"]
2764 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1, datadesc) - 0usize];
2765};
2766impl Default for FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
2767 fn default() -> Self {
2768 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2769 unsafe {
2770 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2771 s.assume_init()
2772 }
2773 }
2774}
2775#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2776const _: () = {
2777 ["Size of FMOD_DSP_PARAMETER_DESC"][::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC>() - 96usize];
2778 ["Alignment of FMOD_DSP_PARAMETER_DESC"]
2779 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC>() - 8usize];
2780 ["Offset of field: FMOD_DSP_PARAMETER_DESC::type_"]
2781 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, type_) - 0usize];
2782 ["Offset of field: FMOD_DSP_PARAMETER_DESC::name"]
2783 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, name) - 4usize];
2784 ["Offset of field: FMOD_DSP_PARAMETER_DESC::label"]
2785 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, label) - 20usize];
2786 ["Offset of field: FMOD_DSP_PARAMETER_DESC::description"]
2787 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DESC, description) - 40usize];
2788};
2789impl Default for FMOD_DSP_PARAMETER_DESC {
2790 fn default() -> Self {
2791 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2792 unsafe {
2793 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2794 s.assume_init()
2795 }
2796 }
2797}
2798#[repr(C)]
2799#[derive(Debug, Default, Copy, Clone, PartialEq)]
2800pub struct FMOD_DSP_PARAMETER_OVERALLGAIN {
2801 pub linear_gain: f32,
2802 pub linear_gain_additive: f32,
2803}
2804#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2805const _: () = {
2806 ["Size of FMOD_DSP_PARAMETER_OVERALLGAIN"]
2807 [::std::mem::size_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>() - 8usize];
2808 ["Alignment of FMOD_DSP_PARAMETER_OVERALLGAIN"]
2809 [::std::mem::align_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>() - 4usize];
2810 ["Offset of field: FMOD_DSP_PARAMETER_OVERALLGAIN::linear_gain"]
2811 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_OVERALLGAIN, linear_gain) - 0usize];
2812 ["Offset of field: FMOD_DSP_PARAMETER_OVERALLGAIN::linear_gain_additive"]
2813 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_OVERALLGAIN, linear_gain_additive) - 4usize];
2814};
2815#[repr(C)]
2816#[derive(Debug, Default, Copy, Clone, PartialEq)]
2817pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES {
2818 pub relative: FMOD_3D_ATTRIBUTES,
2819 pub absolute: FMOD_3D_ATTRIBUTES,
2820}
2821#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2822const _: () = {
2823 ["Size of FMOD_DSP_PARAMETER_3DATTRIBUTES"]
2824 [::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>() - 96usize];
2825 ["Alignment of FMOD_DSP_PARAMETER_3DATTRIBUTES"]
2826 [::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>() - 4usize];
2827 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES::relative"]
2828 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES, relative) - 0usize];
2829 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES::absolute"]
2830 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES, absolute) - 48usize];
2831};
2832#[repr(C)]
2833#[derive(Debug, Default, Copy, Clone, PartialEq)]
2834pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
2835 pub numlisteners: ::std::os::raw::c_int,
2836 pub relative: [FMOD_3D_ATTRIBUTES; 8usize],
2837 pub weight: [f32; 8usize],
2838 pub absolute: FMOD_3D_ATTRIBUTES,
2839}
2840#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2841const _: () = {
2842 ["Size of FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI"]
2843 [::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>() - 468usize];
2844 ["Alignment of FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI"]
2845 [::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>() - 4usize];
2846 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::numlisteners"]
2847 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, numlisteners) - 0usize];
2848 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::relative"]
2849 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, relative) - 4usize];
2850 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::weight"]
2851 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, weight) - 388usize];
2852 ["Offset of field: FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI::absolute"]
2853 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI, absolute) - 420usize];
2854};
2855#[repr(C)]
2856#[derive(Debug, Default, Copy, Clone, PartialEq)]
2857pub struct FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
2858 pub min: f32,
2859 pub max: f32,
2860}
2861#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2862const _: () = {
2863 ["Size of FMOD_DSP_PARAMETER_ATTENUATION_RANGE"]
2864 [::std::mem::size_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>() - 8usize];
2865 ["Alignment of FMOD_DSP_PARAMETER_ATTENUATION_RANGE"]
2866 [::std::mem::align_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>() - 4usize];
2867 ["Offset of field: FMOD_DSP_PARAMETER_ATTENUATION_RANGE::min"]
2868 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE, min) - 0usize];
2869 ["Offset of field: FMOD_DSP_PARAMETER_ATTENUATION_RANGE::max"]
2870 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE, max) - 4usize];
2871};
2872#[repr(C)]
2873#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
2874pub struct FMOD_DSP_PARAMETER_SIDECHAIN {
2875 pub sidechainenable: FMOD_BOOL,
2876}
2877#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2878const _: () = {
2879 ["Size of FMOD_DSP_PARAMETER_SIDECHAIN"]
2880 [::std::mem::size_of::<FMOD_DSP_PARAMETER_SIDECHAIN>() - 4usize];
2881 ["Alignment of FMOD_DSP_PARAMETER_SIDECHAIN"]
2882 [::std::mem::align_of::<FMOD_DSP_PARAMETER_SIDECHAIN>() - 4usize];
2883 ["Offset of field: FMOD_DSP_PARAMETER_SIDECHAIN::sidechainenable"]
2884 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_SIDECHAIN, sidechainenable) - 0usize];
2885};
2886#[repr(C)]
2887#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2888pub struct FMOD_DSP_PARAMETER_FFT {
2889 pub length: ::std::os::raw::c_int,
2890 pub numchannels: ::std::os::raw::c_int,
2891 pub spectrum: [*mut f32; 32usize],
2892}
2893#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2894const _: () = {
2895 ["Size of FMOD_DSP_PARAMETER_FFT"][::std::mem::size_of::<FMOD_DSP_PARAMETER_FFT>() - 264usize];
2896 ["Alignment of FMOD_DSP_PARAMETER_FFT"]
2897 [::std::mem::align_of::<FMOD_DSP_PARAMETER_FFT>() - 8usize];
2898 ["Offset of field: FMOD_DSP_PARAMETER_FFT::length"]
2899 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, length) - 0usize];
2900 ["Offset of field: FMOD_DSP_PARAMETER_FFT::numchannels"]
2901 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, numchannels) - 4usize];
2902 ["Offset of field: FMOD_DSP_PARAMETER_FFT::spectrum"]
2903 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_FFT, spectrum) - 8usize];
2904};
2905impl Default for FMOD_DSP_PARAMETER_FFT {
2906 fn default() -> Self {
2907 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2908 unsafe {
2909 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2910 s.assume_init()
2911 }
2912 }
2913}
2914#[repr(C)]
2915#[derive(Debug, Default, Copy, Clone, PartialEq)]
2916pub struct FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE {
2917 pub numchannels: ::std::os::raw::c_int,
2918 pub rms: [f32; 32usize],
2919}
2920#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2921const _: () = {
2922 ["Size of FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE"]
2923 [::std::mem::size_of::<FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE>() - 132usize];
2924 ["Alignment of FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE"]
2925 [::std::mem::align_of::<FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE>() - 4usize];
2926 ["Offset of field: FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE::numchannels"]
2927 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE, numchannels) - 0usize];
2928 ["Offset of field: FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE::rms"]
2929 [::std::mem::offset_of!(FMOD_DSP_PARAMETER_DYNAMIC_RESPONSE, rms) - 4usize];
2930};
2931#[repr(C)]
2932#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2933pub struct FMOD_DSP_DESCRIPTION {
2934 pub pluginsdkversion: ::std::os::raw::c_uint,
2935 pub name: [::std::os::raw::c_char; 32usize],
2936 pub version: ::std::os::raw::c_uint,
2937 pub numinputbuffers: ::std::os::raw::c_int,
2938 pub numoutputbuffers: ::std::os::raw::c_int,
2939 pub create: FMOD_DSP_CREATE_CALLBACK,
2940 pub release: FMOD_DSP_RELEASE_CALLBACK,
2941 pub reset: FMOD_DSP_RESET_CALLBACK,
2942 pub read: FMOD_DSP_READ_CALLBACK,
2943 pub process: FMOD_DSP_PROCESS_CALLBACK,
2944 pub setposition: FMOD_DSP_SETPOSITION_CALLBACK,
2945 pub numparameters: ::std::os::raw::c_int,
2946 pub paramdesc: *mut *mut FMOD_DSP_PARAMETER_DESC,
2947 pub setparameterfloat: FMOD_DSP_SETPARAM_FLOAT_CALLBACK,
2948 pub setparameterint: FMOD_DSP_SETPARAM_INT_CALLBACK,
2949 pub setparameterbool: FMOD_DSP_SETPARAM_BOOL_CALLBACK,
2950 pub setparameterdata: FMOD_DSP_SETPARAM_DATA_CALLBACK,
2951 pub getparameterfloat: FMOD_DSP_GETPARAM_FLOAT_CALLBACK,
2952 pub getparameterint: FMOD_DSP_GETPARAM_INT_CALLBACK,
2953 pub getparameterbool: FMOD_DSP_GETPARAM_BOOL_CALLBACK,
2954 pub getparameterdata: FMOD_DSP_GETPARAM_DATA_CALLBACK,
2955 pub shouldiprocess: FMOD_DSP_SHOULDIPROCESS_CALLBACK,
2956 pub userdata: *mut ::std::os::raw::c_void,
2957 pub sys_register: FMOD_DSP_SYSTEM_REGISTER_CALLBACK,
2958 pub sys_deregister: FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK,
2959 pub sys_mix: FMOD_DSP_SYSTEM_MIX_CALLBACK,
2960}
2961#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2962const _: () = {
2963 ["Size of FMOD_DSP_DESCRIPTION"][::std::mem::size_of::<FMOD_DSP_DESCRIPTION>() - 216usize];
2964 ["Alignment of FMOD_DSP_DESCRIPTION"][::std::mem::align_of::<FMOD_DSP_DESCRIPTION>() - 8usize];
2965 ["Offset of field: FMOD_DSP_DESCRIPTION::pluginsdkversion"]
2966 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, pluginsdkversion) - 0usize];
2967 ["Offset of field: FMOD_DSP_DESCRIPTION::name"]
2968 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, name) - 4usize];
2969 ["Offset of field: FMOD_DSP_DESCRIPTION::version"]
2970 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, version) - 36usize];
2971 ["Offset of field: FMOD_DSP_DESCRIPTION::numinputbuffers"]
2972 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numinputbuffers) - 40usize];
2973 ["Offset of field: FMOD_DSP_DESCRIPTION::numoutputbuffers"]
2974 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numoutputbuffers) - 44usize];
2975 ["Offset of field: FMOD_DSP_DESCRIPTION::create"]
2976 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, create) - 48usize];
2977 ["Offset of field: FMOD_DSP_DESCRIPTION::release"]
2978 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, release) - 56usize];
2979 ["Offset of field: FMOD_DSP_DESCRIPTION::reset"]
2980 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, reset) - 64usize];
2981 ["Offset of field: FMOD_DSP_DESCRIPTION::read"]
2982 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, read) - 72usize];
2983 ["Offset of field: FMOD_DSP_DESCRIPTION::process"]
2984 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, process) - 80usize];
2985 ["Offset of field: FMOD_DSP_DESCRIPTION::setposition"]
2986 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setposition) - 88usize];
2987 ["Offset of field: FMOD_DSP_DESCRIPTION::numparameters"]
2988 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, numparameters) - 96usize];
2989 ["Offset of field: FMOD_DSP_DESCRIPTION::paramdesc"]
2990 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, paramdesc) - 104usize];
2991 ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterfloat"]
2992 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterfloat) - 112usize];
2993 ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterint"]
2994 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterint) - 120usize];
2995 ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterbool"]
2996 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterbool) - 128usize];
2997 ["Offset of field: FMOD_DSP_DESCRIPTION::setparameterdata"]
2998 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, setparameterdata) - 136usize];
2999 ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterfloat"]
3000 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterfloat) - 144usize];
3001 ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterint"]
3002 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterint) - 152usize];
3003 ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterbool"]
3004 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterbool) - 160usize];
3005 ["Offset of field: FMOD_DSP_DESCRIPTION::getparameterdata"]
3006 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, getparameterdata) - 168usize];
3007 ["Offset of field: FMOD_DSP_DESCRIPTION::shouldiprocess"]
3008 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, shouldiprocess) - 176usize];
3009 ["Offset of field: FMOD_DSP_DESCRIPTION::userdata"]
3010 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, userdata) - 184usize];
3011 ["Offset of field: FMOD_DSP_DESCRIPTION::sys_register"]
3012 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_register) - 192usize];
3013 ["Offset of field: FMOD_DSP_DESCRIPTION::sys_deregister"]
3014 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_deregister) - 200usize];
3015 ["Offset of field: FMOD_DSP_DESCRIPTION::sys_mix"]
3016 [::std::mem::offset_of!(FMOD_DSP_DESCRIPTION, sys_mix) - 208usize];
3017};
3018impl Default for FMOD_DSP_DESCRIPTION {
3019 fn default() -> Self {
3020 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3021 unsafe {
3022 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3023 s.assume_init()
3024 }
3025 }
3026}
3027#[repr(C)]
3028#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
3029pub struct FMOD_DSP_STATE_DFT_FUNCTIONS {
3030 pub fftreal: FMOD_DSP_DFT_FFTREAL_FUNC,
3031 pub inversefftreal: FMOD_DSP_DFT_IFFTREAL_FUNC,
3032}
3033#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3034const _: () = {
3035 ["Size of FMOD_DSP_STATE_DFT_FUNCTIONS"]
3036 [::std::mem::size_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>() - 16usize];
3037 ["Alignment of FMOD_DSP_STATE_DFT_FUNCTIONS"]
3038 [::std::mem::align_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>() - 8usize];
3039 ["Offset of field: FMOD_DSP_STATE_DFT_FUNCTIONS::fftreal"]
3040 [::std::mem::offset_of!(FMOD_DSP_STATE_DFT_FUNCTIONS, fftreal) - 0usize];
3041 ["Offset of field: FMOD_DSP_STATE_DFT_FUNCTIONS::inversefftreal"]
3042 [::std::mem::offset_of!(FMOD_DSP_STATE_DFT_FUNCTIONS, inversefftreal) - 8usize];
3043};
3044#[repr(C)]
3045#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
3046pub struct FMOD_DSP_STATE_PAN_FUNCTIONS {
3047 pub summonomatrix: FMOD_DSP_PAN_SUMMONOMATRIX_FUNC,
3048 pub sumstereomatrix: FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC,
3049 pub sumsurroundmatrix: FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC,
3050 pub summonotosurroundmatrix: FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC,
3051 pub sumstereotosurroundmatrix: FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC,
3052 pub getrolloffgain: FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC,
3053}
3054#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3055const _: () = {
3056 ["Size of FMOD_DSP_STATE_PAN_FUNCTIONS"]
3057 [::std::mem::size_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>() - 48usize];
3058 ["Alignment of FMOD_DSP_STATE_PAN_FUNCTIONS"]
3059 [::std::mem::align_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>() - 8usize];
3060 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::summonomatrix"]
3061 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, summonomatrix) - 0usize];
3062 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumstereomatrix"]
3063 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumstereomatrix) - 8usize];
3064 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumsurroundmatrix"]
3065 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumsurroundmatrix) - 16usize];
3066 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::summonotosurroundmatrix"]
3067 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, summonotosurroundmatrix) - 24usize];
3068 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::sumstereotosurroundmatrix"]
3069 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, sumstereotosurroundmatrix) - 32usize];
3070 ["Offset of field: FMOD_DSP_STATE_PAN_FUNCTIONS::getrolloffgain"]
3071 [::std::mem::offset_of!(FMOD_DSP_STATE_PAN_FUNCTIONS, getrolloffgain) - 40usize];
3072};
3073#[repr(C)]
3074#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3075pub struct FMOD_DSP_STATE_FUNCTIONS {
3076 pub alloc: FMOD_DSP_ALLOC_FUNC,
3077 pub realloc: FMOD_DSP_REALLOC_FUNC,
3078 pub free: FMOD_DSP_FREE_FUNC,
3079 pub getsamplerate: FMOD_DSP_GETSAMPLERATE_FUNC,
3080 pub getblocksize: FMOD_DSP_GETBLOCKSIZE_FUNC,
3081 pub dft: *mut FMOD_DSP_STATE_DFT_FUNCTIONS,
3082 pub pan: *mut FMOD_DSP_STATE_PAN_FUNCTIONS,
3083 pub getspeakermode: FMOD_DSP_GETSPEAKERMODE_FUNC,
3084 pub getclock: FMOD_DSP_GETCLOCK_FUNC,
3085 pub getlistenerattributes: FMOD_DSP_GETLISTENERATTRIBUTES_FUNC,
3086 pub log: FMOD_DSP_LOG_FUNC,
3087 pub getuserdata: FMOD_DSP_GETUSERDATA_FUNC,
3088}
3089#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3090const _: () = {
3091 ["Size of FMOD_DSP_STATE_FUNCTIONS"]
3092 [::std::mem::size_of::<FMOD_DSP_STATE_FUNCTIONS>() - 96usize];
3093 ["Alignment of FMOD_DSP_STATE_FUNCTIONS"]
3094 [::std::mem::align_of::<FMOD_DSP_STATE_FUNCTIONS>() - 8usize];
3095 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::alloc"]
3096 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, alloc) - 0usize];
3097 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::realloc"]
3098 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, realloc) - 8usize];
3099 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::free"]
3100 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, free) - 16usize];
3101 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getsamplerate"]
3102 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getsamplerate) - 24usize];
3103 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getblocksize"]
3104 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getblocksize) - 32usize];
3105 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::dft"]
3106 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, dft) - 40usize];
3107 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::pan"]
3108 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, pan) - 48usize];
3109 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getspeakermode"]
3110 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getspeakermode) - 56usize];
3111 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getclock"]
3112 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getclock) - 64usize];
3113 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getlistenerattributes"]
3114 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getlistenerattributes) - 72usize];
3115 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::log"]
3116 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, log) - 80usize];
3117 ["Offset of field: FMOD_DSP_STATE_FUNCTIONS::getuserdata"]
3118 [::std::mem::offset_of!(FMOD_DSP_STATE_FUNCTIONS, getuserdata) - 88usize];
3119};
3120impl Default for FMOD_DSP_STATE_FUNCTIONS {
3121 fn default() -> Self {
3122 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3123 unsafe {
3124 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3125 s.assume_init()
3126 }
3127 }
3128}
3129#[repr(C)]
3130#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3131pub struct FMOD_DSP_STATE {
3132 pub instance: *mut ::std::os::raw::c_void,
3133 pub plugindata: *mut ::std::os::raw::c_void,
3134 pub channelmask: FMOD_CHANNELMASK,
3135 pub source_speakermode: FMOD_SPEAKERMODE,
3136 pub sidechaindata: *mut f32,
3137 pub sidechainchannels: ::std::os::raw::c_int,
3138 pub functions: *mut FMOD_DSP_STATE_FUNCTIONS,
3139 pub systemobject: ::std::os::raw::c_int,
3140}
3141#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3142const _: () = {
3143 ["Size of FMOD_DSP_STATE"][::std::mem::size_of::<FMOD_DSP_STATE>() - 56usize];
3144 ["Alignment of FMOD_DSP_STATE"][::std::mem::align_of::<FMOD_DSP_STATE>() - 8usize];
3145 ["Offset of field: FMOD_DSP_STATE::instance"]
3146 [::std::mem::offset_of!(FMOD_DSP_STATE, instance) - 0usize];
3147 ["Offset of field: FMOD_DSP_STATE::plugindata"]
3148 [::std::mem::offset_of!(FMOD_DSP_STATE, plugindata) - 8usize];
3149 ["Offset of field: FMOD_DSP_STATE::channelmask"]
3150 [::std::mem::offset_of!(FMOD_DSP_STATE, channelmask) - 16usize];
3151 ["Offset of field: FMOD_DSP_STATE::source_speakermode"]
3152 [::std::mem::offset_of!(FMOD_DSP_STATE, source_speakermode) - 20usize];
3153 ["Offset of field: FMOD_DSP_STATE::sidechaindata"]
3154 [::std::mem::offset_of!(FMOD_DSP_STATE, sidechaindata) - 24usize];
3155 ["Offset of field: FMOD_DSP_STATE::sidechainchannels"]
3156 [::std::mem::offset_of!(FMOD_DSP_STATE, sidechainchannels) - 32usize];
3157 ["Offset of field: FMOD_DSP_STATE::functions"]
3158 [::std::mem::offset_of!(FMOD_DSP_STATE, functions) - 40usize];
3159 ["Offset of field: FMOD_DSP_STATE::systemobject"]
3160 [::std::mem::offset_of!(FMOD_DSP_STATE, systemobject) - 48usize];
3161};
3162impl Default for FMOD_DSP_STATE {
3163 fn default() -> Self {
3164 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3165 unsafe {
3166 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3167 s.assume_init()
3168 }
3169 }
3170}
3171#[repr(C)]
3172#[derive(Debug, Default, Copy, Clone, PartialEq)]
3173pub struct FMOD_DSP_METERING_INFO {
3174 pub numsamples: ::std::os::raw::c_int,
3175 pub peaklevel: [f32; 32usize],
3176 pub rmslevel: [f32; 32usize],
3177 pub numchannels: ::std::os::raw::c_short,
3178}
3179#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3180const _: () = {
3181 ["Size of FMOD_DSP_METERING_INFO"][::std::mem::size_of::<FMOD_DSP_METERING_INFO>() - 264usize];
3182 ["Alignment of FMOD_DSP_METERING_INFO"]
3183 [::std::mem::align_of::<FMOD_DSP_METERING_INFO>() - 4usize];
3184 ["Offset of field: FMOD_DSP_METERING_INFO::numsamples"]
3185 [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, numsamples) - 0usize];
3186 ["Offset of field: FMOD_DSP_METERING_INFO::peaklevel"]
3187 [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, peaklevel) - 4usize];
3188 ["Offset of field: FMOD_DSP_METERING_INFO::rmslevel"]
3189 [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, rmslevel) - 132usize];
3190 ["Offset of field: FMOD_DSP_METERING_INFO::numchannels"]
3191 [::std::mem::offset_of!(FMOD_DSP_METERING_INFO, numchannels) - 260usize];
3192};
3193pub type FMOD_OUTPUT_METHOD = ::std::os::raw::c_uint;
3194pub type FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK = ::std::option::Option<
3195 unsafe extern "C" fn(
3196 output_state: *mut FMOD_OUTPUT_STATE,
3197 numdrivers: *mut ::std::os::raw::c_int,
3198 ) -> FMOD_RESULT,
3199>;
3200pub type FMOD_OUTPUT_GETDRIVERINFO_CALLBACK = ::std::option::Option<
3201 unsafe extern "C" fn(
3202 output_state: *mut FMOD_OUTPUT_STATE,
3203 id: ::std::os::raw::c_int,
3204 name: *mut ::std::os::raw::c_char,
3205 namelen: ::std::os::raw::c_int,
3206 guid: *mut FMOD_GUID,
3207 systemrate: *mut ::std::os::raw::c_int,
3208 speakermode: *mut FMOD_SPEAKERMODE,
3209 speakermodechannels: *mut ::std::os::raw::c_int,
3210 ) -> FMOD_RESULT,
3211>;
3212pub type FMOD_OUTPUT_INIT_CALLBACK = ::std::option::Option<
3213 unsafe extern "C" fn(
3214 output_state: *mut FMOD_OUTPUT_STATE,
3215 selecteddriver: ::std::os::raw::c_int,
3216 flags: FMOD_INITFLAGS,
3217 outputrate: *mut ::std::os::raw::c_int,
3218 speakermode: *mut FMOD_SPEAKERMODE,
3219 speakermodechannels: *mut ::std::os::raw::c_int,
3220 outputformat: *mut FMOD_SOUND_FORMAT,
3221 dspbufferlength: ::std::os::raw::c_int,
3222 dspnumbuffers: *mut ::std::os::raw::c_int,
3223 dspnumadditionalbuffers: *mut ::std::os::raw::c_int,
3224 extradriverdata: *mut ::std::os::raw::c_void,
3225 ) -> FMOD_RESULT,
3226>;
3227pub type FMOD_OUTPUT_START_CALLBACK = ::std::option::Option<
3228 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3229>;
3230pub type FMOD_OUTPUT_STOP_CALLBACK = ::std::option::Option<
3231 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3232>;
3233pub type FMOD_OUTPUT_CLOSE_CALLBACK = ::std::option::Option<
3234 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3235>;
3236pub type FMOD_OUTPUT_UPDATE_CALLBACK = ::std::option::Option<
3237 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3238>;
3239pub type FMOD_OUTPUT_GETHANDLE_CALLBACK = ::std::option::Option<
3240 unsafe extern "C" fn(
3241 output_state: *mut FMOD_OUTPUT_STATE,
3242 handle: *mut *mut ::std::os::raw::c_void,
3243 ) -> FMOD_RESULT,
3244>;
3245pub type FMOD_OUTPUT_MIXER_CALLBACK = ::std::option::Option<
3246 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3247>;
3248pub type FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK = ::std::option::Option<
3249 unsafe extern "C" fn(
3250 output_state: *mut FMOD_OUTPUT_STATE,
3251 maxhardwareobjects: *mut ::std::os::raw::c_int,
3252 ) -> FMOD_RESULT,
3253>;
3254pub type FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK = ::std::option::Option<
3255 unsafe extern "C" fn(
3256 output_state: *mut FMOD_OUTPUT_STATE,
3257 object3d: *mut *mut ::std::os::raw::c_void,
3258 ) -> FMOD_RESULT,
3259>;
3260pub type FMOD_OUTPUT_OBJECT3DFREE_CALLBACK = ::std::option::Option<
3261 unsafe extern "C" fn(
3262 output_state: *mut FMOD_OUTPUT_STATE,
3263 object3d: *mut ::std::os::raw::c_void,
3264 ) -> FMOD_RESULT,
3265>;
3266pub type FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK = ::std::option::Option<
3267 unsafe extern "C" fn(
3268 output_state: *mut FMOD_OUTPUT_STATE,
3269 object3d: *mut ::std::os::raw::c_void,
3270 info: *const FMOD_OUTPUT_OBJECT3DINFO,
3271 ) -> FMOD_RESULT,
3272>;
3273pub type FMOD_OUTPUT_OPENPORT_CALLBACK = ::std::option::Option<
3274 unsafe extern "C" fn(
3275 output_state: *mut FMOD_OUTPUT_STATE,
3276 portType: FMOD_PORT_TYPE,
3277 portIndex: FMOD_PORT_INDEX,
3278 portId: *mut ::std::os::raw::c_int,
3279 portRate: *mut ::std::os::raw::c_int,
3280 portChannels: *mut ::std::os::raw::c_int,
3281 portFormat: *mut FMOD_SOUND_FORMAT,
3282 ) -> FMOD_RESULT,
3283>;
3284pub type FMOD_OUTPUT_CLOSEPORT_CALLBACK = ::std::option::Option<
3285 unsafe extern "C" fn(
3286 output_state: *mut FMOD_OUTPUT_STATE,
3287 portId: ::std::os::raw::c_int,
3288 ) -> FMOD_RESULT,
3289>;
3290pub type FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK = ::std::option::Option<
3291 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3292>;
3293pub type FMOD_OUTPUT_READFROMMIXER_FUNC = ::std::option::Option<
3294 unsafe extern "C" fn(
3295 output_state: *mut FMOD_OUTPUT_STATE,
3296 buffer: *mut ::std::os::raw::c_void,
3297 length: ::std::os::raw::c_uint,
3298 ) -> FMOD_RESULT,
3299>;
3300pub type FMOD_OUTPUT_COPYPORT_FUNC = ::std::option::Option<
3301 unsafe extern "C" fn(
3302 output_state: *mut FMOD_OUTPUT_STATE,
3303 portId: ::std::os::raw::c_int,
3304 buffer: *mut ::std::os::raw::c_void,
3305 length: ::std::os::raw::c_uint,
3306 ) -> FMOD_RESULT,
3307>;
3308pub type FMOD_OUTPUT_REQUESTRESET_FUNC = ::std::option::Option<
3309 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
3310>;
3311pub type FMOD_OUTPUT_ALLOC_FUNC = ::std::option::Option<
3312 unsafe extern "C" fn(
3313 size: ::std::os::raw::c_uint,
3314 align: ::std::os::raw::c_uint,
3315 file: *const ::std::os::raw::c_char,
3316 line: ::std::os::raw::c_int,
3317 ) -> *mut ::std::os::raw::c_void,
3318>;
3319pub type FMOD_OUTPUT_FREE_FUNC = ::std::option::Option<
3320 unsafe extern "C" fn(
3321 ptr: *mut ::std::os::raw::c_void,
3322 file: *const ::std::os::raw::c_char,
3323 line: ::std::os::raw::c_int,
3324 ),
3325>;
3326pub type FMOD_OUTPUT_LOG_FUNC = ::std::option::Option<
3327 unsafe extern "C" fn(
3328 level: FMOD_DEBUG_FLAGS,
3329 file: *const ::std::os::raw::c_char,
3330 line: ::std::os::raw::c_int,
3331 function: *const ::std::os::raw::c_char,
3332 string: *const ::std::os::raw::c_char,
3333 ...
3334 ),
3335>;
3336#[repr(C)]
3337#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3338pub struct FMOD_OUTPUT_DESCRIPTION {
3339 pub apiversion: ::std::os::raw::c_uint,
3340 pub name: *const ::std::os::raw::c_char,
3341 pub version: ::std::os::raw::c_uint,
3342 pub method: FMOD_OUTPUT_METHOD,
3343 pub getnumdrivers: FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK,
3344 pub getdriverinfo: FMOD_OUTPUT_GETDRIVERINFO_CALLBACK,
3345 pub init: FMOD_OUTPUT_INIT_CALLBACK,
3346 pub start: FMOD_OUTPUT_START_CALLBACK,
3347 pub stop: FMOD_OUTPUT_STOP_CALLBACK,
3348 pub close: FMOD_OUTPUT_CLOSE_CALLBACK,
3349 pub update: FMOD_OUTPUT_UPDATE_CALLBACK,
3350 pub gethandle: FMOD_OUTPUT_GETHANDLE_CALLBACK,
3351 pub mixer: FMOD_OUTPUT_MIXER_CALLBACK,
3352 pub object3dgetinfo: FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK,
3353 pub object3dalloc: FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK,
3354 pub object3dfree: FMOD_OUTPUT_OBJECT3DFREE_CALLBACK,
3355 pub object3dupdate: FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK,
3356 pub openport: FMOD_OUTPUT_OPENPORT_CALLBACK,
3357 pub closeport: FMOD_OUTPUT_CLOSEPORT_CALLBACK,
3358 pub devicelistchanged: FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK,
3359}
3360#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3361const _: () = {
3362 ["Size of FMOD_OUTPUT_DESCRIPTION"]
3363 [::std::mem::size_of::<FMOD_OUTPUT_DESCRIPTION>() - 152usize];
3364 ["Alignment of FMOD_OUTPUT_DESCRIPTION"]
3365 [::std::mem::align_of::<FMOD_OUTPUT_DESCRIPTION>() - 8usize];
3366 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::apiversion"]
3367 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, apiversion) - 0usize];
3368 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::name"]
3369 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, name) - 8usize];
3370 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::version"]
3371 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, version) - 16usize];
3372 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::method"]
3373 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, method) - 20usize];
3374 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::getnumdrivers"]
3375 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, getnumdrivers) - 24usize];
3376 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::getdriverinfo"]
3377 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, getdriverinfo) - 32usize];
3378 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::init"]
3379 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, init) - 40usize];
3380 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::start"]
3381 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, start) - 48usize];
3382 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::stop"]
3383 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, stop) - 56usize];
3384 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::close"]
3385 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, close) - 64usize];
3386 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::update"]
3387 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, update) - 72usize];
3388 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::gethandle"]
3389 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, gethandle) - 80usize];
3390 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::mixer"]
3391 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, mixer) - 88usize];
3392 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dgetinfo"]
3393 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dgetinfo) - 96usize];
3394 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dalloc"]
3395 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dalloc) - 104usize];
3396 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dfree"]
3397 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dfree) - 112usize];
3398 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::object3dupdate"]
3399 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, object3dupdate) - 120usize];
3400 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::openport"]
3401 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, openport) - 128usize];
3402 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::closeport"]
3403 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, closeport) - 136usize];
3404 ["Offset of field: FMOD_OUTPUT_DESCRIPTION::devicelistchanged"]
3405 [::std::mem::offset_of!(FMOD_OUTPUT_DESCRIPTION, devicelistchanged) - 144usize];
3406};
3407impl Default for FMOD_OUTPUT_DESCRIPTION {
3408 fn default() -> Self {
3409 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3410 unsafe {
3411 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3412 s.assume_init()
3413 }
3414 }
3415}
3416#[repr(C)]
3417#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3418pub struct FMOD_OUTPUT_STATE {
3419 pub plugindata: *mut ::std::os::raw::c_void,
3420 pub readfrommixer: FMOD_OUTPUT_READFROMMIXER_FUNC,
3421 pub alloc: FMOD_OUTPUT_ALLOC_FUNC,
3422 pub free: FMOD_OUTPUT_FREE_FUNC,
3423 pub log: FMOD_OUTPUT_LOG_FUNC,
3424 pub copyport: FMOD_OUTPUT_COPYPORT_FUNC,
3425 pub requestreset: FMOD_OUTPUT_REQUESTRESET_FUNC,
3426}
3427#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3428const _: () = {
3429 ["Size of FMOD_OUTPUT_STATE"][::std::mem::size_of::<FMOD_OUTPUT_STATE>() - 56usize];
3430 ["Alignment of FMOD_OUTPUT_STATE"][::std::mem::align_of::<FMOD_OUTPUT_STATE>() - 8usize];
3431 ["Offset of field: FMOD_OUTPUT_STATE::plugindata"]
3432 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, plugindata) - 0usize];
3433 ["Offset of field: FMOD_OUTPUT_STATE::readfrommixer"]
3434 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, readfrommixer) - 8usize];
3435 ["Offset of field: FMOD_OUTPUT_STATE::alloc"]
3436 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, alloc) - 16usize];
3437 ["Offset of field: FMOD_OUTPUT_STATE::free"]
3438 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, free) - 24usize];
3439 ["Offset of field: FMOD_OUTPUT_STATE::log"]
3440 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, log) - 32usize];
3441 ["Offset of field: FMOD_OUTPUT_STATE::copyport"]
3442 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, copyport) - 40usize];
3443 ["Offset of field: FMOD_OUTPUT_STATE::requestreset"]
3444 [::std::mem::offset_of!(FMOD_OUTPUT_STATE, requestreset) - 48usize];
3445};
3446impl Default for FMOD_OUTPUT_STATE {
3447 fn default() -> Self {
3448 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3449 unsafe {
3450 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3451 s.assume_init()
3452 }
3453 }
3454}
3455#[repr(C)]
3456#[derive(Debug, Copy, Clone, PartialEq)]
3457pub struct FMOD_OUTPUT_OBJECT3DINFO {
3458 pub buffer: *mut f32,
3459 pub bufferlength: ::std::os::raw::c_uint,
3460 pub position: FMOD_VECTOR,
3461 pub gain: f32,
3462 pub spread: f32,
3463 pub priority: f32,
3464}
3465#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3466const _: () = {
3467 ["Size of FMOD_OUTPUT_OBJECT3DINFO"]
3468 [::std::mem::size_of::<FMOD_OUTPUT_OBJECT3DINFO>() - 40usize];
3469 ["Alignment of FMOD_OUTPUT_OBJECT3DINFO"]
3470 [::std::mem::align_of::<FMOD_OUTPUT_OBJECT3DINFO>() - 8usize];
3471 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::buffer"]
3472 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, buffer) - 0usize];
3473 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::bufferlength"]
3474 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, bufferlength) - 8usize];
3475 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::position"]
3476 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, position) - 12usize];
3477 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::gain"]
3478 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, gain) - 24usize];
3479 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::spread"]
3480 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, spread) - 28usize];
3481 ["Offset of field: FMOD_OUTPUT_OBJECT3DINFO::priority"]
3482 [::std::mem::offset_of!(FMOD_OUTPUT_OBJECT3DINFO, priority) - 32usize];
3483};
3484impl Default for FMOD_OUTPUT_OBJECT3DINFO {
3485 fn default() -> Self {
3486 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3487 unsafe {
3488 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3489 s.assume_init()
3490 }
3491 }
3492}
3493unsafe extern "C" {
3494 #[must_use]
3495 pub fn FMOD_Memory_Initialize(
3496 poolmem: *mut ::std::os::raw::c_void,
3497 poollen: ::std::os::raw::c_int,
3498 useralloc: FMOD_MEMORY_ALLOC_CALLBACK,
3499 userrealloc: FMOD_MEMORY_REALLOC_CALLBACK,
3500 userfree: FMOD_MEMORY_FREE_CALLBACK,
3501 memtypeflags: FMOD_MEMORY_TYPE,
3502 ) -> FMOD_RESULT;
3503}
3504unsafe extern "C" {
3505 #[must_use]
3506 pub fn FMOD_Memory_GetStats(
3507 currentalloced: *mut ::std::os::raw::c_int,
3508 maxalloced: *mut ::std::os::raw::c_int,
3509 blocking: FMOD_BOOL,
3510 ) -> FMOD_RESULT;
3511}
3512unsafe extern "C" {
3513 #[must_use]
3514 pub fn FMOD_Debug_Initialize(
3515 flags: FMOD_DEBUG_FLAGS,
3516 mode: FMOD_DEBUG_MODE,
3517 callback: FMOD_DEBUG_CALLBACK,
3518 filename: *const ::std::os::raw::c_char,
3519 ) -> FMOD_RESULT;
3520}
3521unsafe extern "C" {
3522 #[must_use]
3523 pub fn FMOD_File_SetDiskBusy(busy: ::std::os::raw::c_int) -> FMOD_RESULT;
3524}
3525unsafe extern "C" {
3526 #[must_use]
3527 pub fn FMOD_File_GetDiskBusy(busy: *mut ::std::os::raw::c_int) -> FMOD_RESULT;
3528}
3529unsafe extern "C" {
3530 #[must_use]
3531 pub fn FMOD_Thread_SetAttributes(
3532 type_: FMOD_THREAD_TYPE,
3533 affinity: FMOD_THREAD_AFFINITY,
3534 priority: FMOD_THREAD_PRIORITY,
3535 stacksize: FMOD_THREAD_STACK_SIZE,
3536 ) -> FMOD_RESULT;
3537}
3538unsafe extern "C" {
3539 #[must_use]
3540 pub fn FMOD_System_Create(
3541 system: *mut *mut FMOD_SYSTEM,
3542 headerversion: ::std::os::raw::c_uint,
3543 ) -> FMOD_RESULT;
3544}
3545unsafe extern "C" {
3546 #[must_use]
3547 pub fn FMOD_System_Release(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
3548}
3549unsafe extern "C" {
3550 #[must_use]
3551 pub fn FMOD_System_SetOutput(system: *mut FMOD_SYSTEM, output: FMOD_OUTPUTTYPE) -> FMOD_RESULT;
3552}
3553unsafe extern "C" {
3554 #[must_use]
3555 pub fn FMOD_System_GetOutput(
3556 system: *mut FMOD_SYSTEM,
3557 output: *mut FMOD_OUTPUTTYPE,
3558 ) -> FMOD_RESULT;
3559}
3560unsafe extern "C" {
3561 #[must_use]
3562 pub fn FMOD_System_GetNumDrivers(
3563 system: *mut FMOD_SYSTEM,
3564 numdrivers: *mut ::std::os::raw::c_int,
3565 ) -> FMOD_RESULT;
3566}
3567unsafe extern "C" {
3568 #[must_use]
3569 pub fn FMOD_System_GetDriverInfo(
3570 system: *mut FMOD_SYSTEM,
3571 id: ::std::os::raw::c_int,
3572 name: *mut ::std::os::raw::c_char,
3573 namelen: ::std::os::raw::c_int,
3574 guid: *mut FMOD_GUID,
3575 systemrate: *mut ::std::os::raw::c_int,
3576 speakermode: *mut FMOD_SPEAKERMODE,
3577 speakermodechannels: *mut ::std::os::raw::c_int,
3578 ) -> FMOD_RESULT;
3579}
3580unsafe extern "C" {
3581 #[must_use]
3582 pub fn FMOD_System_SetDriver(
3583 system: *mut FMOD_SYSTEM,
3584 driver: ::std::os::raw::c_int,
3585 ) -> FMOD_RESULT;
3586}
3587unsafe extern "C" {
3588 #[must_use]
3589 pub fn FMOD_System_GetDriver(
3590 system: *mut FMOD_SYSTEM,
3591 driver: *mut ::std::os::raw::c_int,
3592 ) -> FMOD_RESULT;
3593}
3594unsafe extern "C" {
3595 #[must_use]
3596 pub fn FMOD_System_SetSoftwareChannels(
3597 system: *mut FMOD_SYSTEM,
3598 numsoftwarechannels: ::std::os::raw::c_int,
3599 ) -> FMOD_RESULT;
3600}
3601unsafe extern "C" {
3602 #[must_use]
3603 pub fn FMOD_System_GetSoftwareChannels(
3604 system: *mut FMOD_SYSTEM,
3605 numsoftwarechannels: *mut ::std::os::raw::c_int,
3606 ) -> FMOD_RESULT;
3607}
3608unsafe extern "C" {
3609 #[must_use]
3610 pub fn FMOD_System_SetSoftwareFormat(
3611 system: *mut FMOD_SYSTEM,
3612 samplerate: ::std::os::raw::c_int,
3613 speakermode: FMOD_SPEAKERMODE,
3614 numrawspeakers: ::std::os::raw::c_int,
3615 ) -> FMOD_RESULT;
3616}
3617unsafe extern "C" {
3618 #[must_use]
3619 pub fn FMOD_System_GetSoftwareFormat(
3620 system: *mut FMOD_SYSTEM,
3621 samplerate: *mut ::std::os::raw::c_int,
3622 speakermode: *mut FMOD_SPEAKERMODE,
3623 numrawspeakers: *mut ::std::os::raw::c_int,
3624 ) -> FMOD_RESULT;
3625}
3626unsafe extern "C" {
3627 #[must_use]
3628 pub fn FMOD_System_SetDSPBufferSize(
3629 system: *mut FMOD_SYSTEM,
3630 bufferlength: ::std::os::raw::c_uint,
3631 numbuffers: ::std::os::raw::c_int,
3632 ) -> FMOD_RESULT;
3633}
3634unsafe extern "C" {
3635 #[must_use]
3636 pub fn FMOD_System_GetDSPBufferSize(
3637 system: *mut FMOD_SYSTEM,
3638 bufferlength: *mut ::std::os::raw::c_uint,
3639 numbuffers: *mut ::std::os::raw::c_int,
3640 ) -> FMOD_RESULT;
3641}
3642unsafe extern "C" {
3643 #[must_use]
3644 pub fn FMOD_System_SetFileSystem(
3645 system: *mut FMOD_SYSTEM,
3646 useropen: FMOD_FILE_OPEN_CALLBACK,
3647 userclose: FMOD_FILE_CLOSE_CALLBACK,
3648 userread: FMOD_FILE_READ_CALLBACK,
3649 userseek: FMOD_FILE_SEEK_CALLBACK,
3650 userasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
3651 userasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
3652 blockalign: ::std::os::raw::c_int,
3653 ) -> FMOD_RESULT;
3654}
3655unsafe extern "C" {
3656 #[must_use]
3657 pub fn FMOD_System_AttachFileSystem(
3658 system: *mut FMOD_SYSTEM,
3659 useropen: FMOD_FILE_OPEN_CALLBACK,
3660 userclose: FMOD_FILE_CLOSE_CALLBACK,
3661 userread: FMOD_FILE_READ_CALLBACK,
3662 userseek: FMOD_FILE_SEEK_CALLBACK,
3663 ) -> FMOD_RESULT;
3664}
3665unsafe extern "C" {
3666 #[must_use]
3667 pub fn FMOD_System_SetAdvancedSettings(
3668 system: *mut FMOD_SYSTEM,
3669 settings: *mut FMOD_ADVANCEDSETTINGS,
3670 ) -> FMOD_RESULT;
3671}
3672unsafe extern "C" {
3673 #[must_use]
3674 pub fn FMOD_System_GetAdvancedSettings(
3675 system: *mut FMOD_SYSTEM,
3676 settings: *mut FMOD_ADVANCEDSETTINGS,
3677 ) -> FMOD_RESULT;
3678}
3679unsafe extern "C" {
3680 #[must_use]
3681 pub fn FMOD_System_SetCallback(
3682 system: *mut FMOD_SYSTEM,
3683 callback: FMOD_SYSTEM_CALLBACK,
3684 callbackmask: FMOD_SYSTEM_CALLBACK_TYPE,
3685 ) -> FMOD_RESULT;
3686}
3687unsafe extern "C" {
3688 #[must_use]
3689 pub fn FMOD_System_SetPluginPath(
3690 system: *mut FMOD_SYSTEM,
3691 path: *const ::std::os::raw::c_char,
3692 ) -> FMOD_RESULT;
3693}
3694unsafe extern "C" {
3695 #[must_use]
3696 pub fn FMOD_System_LoadPlugin(
3697 system: *mut FMOD_SYSTEM,
3698 filename: *const ::std::os::raw::c_char,
3699 handle: *mut ::std::os::raw::c_uint,
3700 priority: ::std::os::raw::c_uint,
3701 ) -> FMOD_RESULT;
3702}
3703unsafe extern "C" {
3704 #[must_use]
3705 pub fn FMOD_System_UnloadPlugin(
3706 system: *mut FMOD_SYSTEM,
3707 handle: ::std::os::raw::c_uint,
3708 ) -> FMOD_RESULT;
3709}
3710unsafe extern "C" {
3711 #[must_use]
3712 pub fn FMOD_System_GetNumNestedPlugins(
3713 system: *mut FMOD_SYSTEM,
3714 handle: ::std::os::raw::c_uint,
3715 count: *mut ::std::os::raw::c_int,
3716 ) -> FMOD_RESULT;
3717}
3718unsafe extern "C" {
3719 #[must_use]
3720 pub fn FMOD_System_GetNestedPlugin(
3721 system: *mut FMOD_SYSTEM,
3722 handle: ::std::os::raw::c_uint,
3723 index: ::std::os::raw::c_int,
3724 nestedhandle: *mut ::std::os::raw::c_uint,
3725 ) -> FMOD_RESULT;
3726}
3727unsafe extern "C" {
3728 #[must_use]
3729 pub fn FMOD_System_GetNumPlugins(
3730 system: *mut FMOD_SYSTEM,
3731 plugintype: FMOD_PLUGINTYPE,
3732 numplugins: *mut ::std::os::raw::c_int,
3733 ) -> FMOD_RESULT;
3734}
3735unsafe extern "C" {
3736 #[must_use]
3737 pub fn FMOD_System_GetPluginHandle(
3738 system: *mut FMOD_SYSTEM,
3739 plugintype: FMOD_PLUGINTYPE,
3740 index: ::std::os::raw::c_int,
3741 handle: *mut ::std::os::raw::c_uint,
3742 ) -> FMOD_RESULT;
3743}
3744unsafe extern "C" {
3745 #[must_use]
3746 pub fn FMOD_System_GetPluginInfo(
3747 system: *mut FMOD_SYSTEM,
3748 handle: ::std::os::raw::c_uint,
3749 plugintype: *mut FMOD_PLUGINTYPE,
3750 name: *mut ::std::os::raw::c_char,
3751 namelen: ::std::os::raw::c_int,
3752 version: *mut ::std::os::raw::c_uint,
3753 ) -> FMOD_RESULT;
3754}
3755unsafe extern "C" {
3756 #[must_use]
3757 pub fn FMOD_System_SetOutputByPlugin(
3758 system: *mut FMOD_SYSTEM,
3759 handle: ::std::os::raw::c_uint,
3760 ) -> FMOD_RESULT;
3761}
3762unsafe extern "C" {
3763 #[must_use]
3764 pub fn FMOD_System_GetOutputByPlugin(
3765 system: *mut FMOD_SYSTEM,
3766 handle: *mut ::std::os::raw::c_uint,
3767 ) -> FMOD_RESULT;
3768}
3769unsafe extern "C" {
3770 #[must_use]
3771 pub fn FMOD_System_CreateDSPByPlugin(
3772 system: *mut FMOD_SYSTEM,
3773 handle: ::std::os::raw::c_uint,
3774 dsp: *mut *mut FMOD_DSP,
3775 ) -> FMOD_RESULT;
3776}
3777unsafe extern "C" {
3778 #[must_use]
3779 pub fn FMOD_System_GetDSPInfoByPlugin(
3780 system: *mut FMOD_SYSTEM,
3781 handle: ::std::os::raw::c_uint,
3782 description: *mut *const FMOD_DSP_DESCRIPTION,
3783 ) -> FMOD_RESULT;
3784}
3785unsafe extern "C" {
3786 #[must_use]
3787 pub fn FMOD_System_RegisterCodec(
3788 system: *mut FMOD_SYSTEM,
3789 description: *mut FMOD_CODEC_DESCRIPTION,
3790 handle: *mut ::std::os::raw::c_uint,
3791 priority: ::std::os::raw::c_uint,
3792 ) -> FMOD_RESULT;
3793}
3794unsafe extern "C" {
3795 #[must_use]
3796 pub fn FMOD_System_RegisterDSP(
3797 system: *mut FMOD_SYSTEM,
3798 description: *const FMOD_DSP_DESCRIPTION,
3799 handle: *mut ::std::os::raw::c_uint,
3800 ) -> FMOD_RESULT;
3801}
3802unsafe extern "C" {
3803 #[must_use]
3804 pub fn FMOD_System_RegisterOutput(
3805 system: *mut FMOD_SYSTEM,
3806 description: *const FMOD_OUTPUT_DESCRIPTION,
3807 handle: *mut ::std::os::raw::c_uint,
3808 ) -> FMOD_RESULT;
3809}
3810unsafe extern "C" {
3811 #[must_use]
3812 pub fn FMOD_System_Init(
3813 system: *mut FMOD_SYSTEM,
3814 maxchannels: ::std::os::raw::c_int,
3815 flags: FMOD_INITFLAGS,
3816 extradriverdata: *mut ::std::os::raw::c_void,
3817 ) -> FMOD_RESULT;
3818}
3819unsafe extern "C" {
3820 #[must_use]
3821 pub fn FMOD_System_Close(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
3822}
3823unsafe extern "C" {
3824 #[must_use]
3825 pub fn FMOD_System_Update(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
3826}
3827unsafe extern "C" {
3828 #[must_use]
3829 pub fn FMOD_System_SetSpeakerPosition(
3830 system: *mut FMOD_SYSTEM,
3831 speaker: FMOD_SPEAKER,
3832 x: f32,
3833 y: f32,
3834 active: FMOD_BOOL,
3835 ) -> FMOD_RESULT;
3836}
3837unsafe extern "C" {
3838 #[must_use]
3839 pub fn FMOD_System_GetSpeakerPosition(
3840 system: *mut FMOD_SYSTEM,
3841 speaker: FMOD_SPEAKER,
3842 x: *mut f32,
3843 y: *mut f32,
3844 active: *mut FMOD_BOOL,
3845 ) -> FMOD_RESULT;
3846}
3847unsafe extern "C" {
3848 #[must_use]
3849 pub fn FMOD_System_SetStreamBufferSize(
3850 system: *mut FMOD_SYSTEM,
3851 filebuffersize: ::std::os::raw::c_uint,
3852 filebuffersizetype: FMOD_TIMEUNIT,
3853 ) -> FMOD_RESULT;
3854}
3855unsafe extern "C" {
3856 #[must_use]
3857 pub fn FMOD_System_GetStreamBufferSize(
3858 system: *mut FMOD_SYSTEM,
3859 filebuffersize: *mut ::std::os::raw::c_uint,
3860 filebuffersizetype: *mut FMOD_TIMEUNIT,
3861 ) -> FMOD_RESULT;
3862}
3863unsafe extern "C" {
3864 #[must_use]
3865 pub fn FMOD_System_Set3DSettings(
3866 system: *mut FMOD_SYSTEM,
3867 dopplerscale: f32,
3868 distancefactor: f32,
3869 rolloffscale: f32,
3870 ) -> FMOD_RESULT;
3871}
3872unsafe extern "C" {
3873 #[must_use]
3874 pub fn FMOD_System_Get3DSettings(
3875 system: *mut FMOD_SYSTEM,
3876 dopplerscale: *mut f32,
3877 distancefactor: *mut f32,
3878 rolloffscale: *mut f32,
3879 ) -> FMOD_RESULT;
3880}
3881unsafe extern "C" {
3882 #[must_use]
3883 pub fn FMOD_System_Set3DNumListeners(
3884 system: *mut FMOD_SYSTEM,
3885 numlisteners: ::std::os::raw::c_int,
3886 ) -> FMOD_RESULT;
3887}
3888unsafe extern "C" {
3889 #[must_use]
3890 pub fn FMOD_System_Get3DNumListeners(
3891 system: *mut FMOD_SYSTEM,
3892 numlisteners: *mut ::std::os::raw::c_int,
3893 ) -> FMOD_RESULT;
3894}
3895unsafe extern "C" {
3896 #[must_use]
3897 pub fn FMOD_System_Set3DListenerAttributes(
3898 system: *mut FMOD_SYSTEM,
3899 listener: ::std::os::raw::c_int,
3900 pos: *const FMOD_VECTOR,
3901 vel: *const FMOD_VECTOR,
3902 forward: *const FMOD_VECTOR,
3903 up: *const FMOD_VECTOR,
3904 ) -> FMOD_RESULT;
3905}
3906unsafe extern "C" {
3907 #[must_use]
3908 pub fn FMOD_System_Get3DListenerAttributes(
3909 system: *mut FMOD_SYSTEM,
3910 listener: ::std::os::raw::c_int,
3911 pos: *mut FMOD_VECTOR,
3912 vel: *mut FMOD_VECTOR,
3913 forward: *mut FMOD_VECTOR,
3914 up: *mut FMOD_VECTOR,
3915 ) -> FMOD_RESULT;
3916}
3917unsafe extern "C" {
3918 #[must_use]
3919 pub fn FMOD_System_Set3DRolloffCallback(
3920 system: *mut FMOD_SYSTEM,
3921 callback: FMOD_3D_ROLLOFF_CALLBACK,
3922 ) -> FMOD_RESULT;
3923}
3924unsafe extern "C" {
3925 #[must_use]
3926 pub fn FMOD_System_MixerSuspend(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
3927}
3928unsafe extern "C" {
3929 #[must_use]
3930 pub fn FMOD_System_MixerResume(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
3931}
3932unsafe extern "C" {
3933 #[must_use]
3934 pub fn FMOD_System_GetDefaultMixMatrix(
3935 system: *mut FMOD_SYSTEM,
3936 sourcespeakermode: FMOD_SPEAKERMODE,
3937 targetspeakermode: FMOD_SPEAKERMODE,
3938 matrix: *mut f32,
3939 matrixhop: ::std::os::raw::c_int,
3940 ) -> FMOD_RESULT;
3941}
3942unsafe extern "C" {
3943 #[must_use]
3944 pub fn FMOD_System_GetSpeakerModeChannels(
3945 system: *mut FMOD_SYSTEM,
3946 mode: FMOD_SPEAKERMODE,
3947 channels: *mut ::std::os::raw::c_int,
3948 ) -> FMOD_RESULT;
3949}
3950unsafe extern "C" {
3951 #[must_use]
3952 pub fn FMOD_System_GetVersion(
3953 system: *mut FMOD_SYSTEM,
3954 version: *mut ::std::os::raw::c_uint,
3955 buildnumber: *mut ::std::os::raw::c_uint,
3956 ) -> FMOD_RESULT;
3957}
3958unsafe extern "C" {
3959 #[must_use]
3960 pub fn FMOD_System_GetOutputHandle(
3961 system: *mut FMOD_SYSTEM,
3962 handle: *mut *mut ::std::os::raw::c_void,
3963 ) -> FMOD_RESULT;
3964}
3965unsafe extern "C" {
3966 #[must_use]
3967 pub fn FMOD_System_GetChannelsPlaying(
3968 system: *mut FMOD_SYSTEM,
3969 channels: *mut ::std::os::raw::c_int,
3970 realchannels: *mut ::std::os::raw::c_int,
3971 ) -> FMOD_RESULT;
3972}
3973unsafe extern "C" {
3974 #[must_use]
3975 pub fn FMOD_System_GetCPUUsage(
3976 system: *mut FMOD_SYSTEM,
3977 usage: *mut FMOD_CPU_USAGE,
3978 ) -> FMOD_RESULT;
3979}
3980unsafe extern "C" {
3981 #[must_use]
3982 pub fn FMOD_System_GetFileUsage(
3983 system: *mut FMOD_SYSTEM,
3984 sampleBytesRead: *mut ::std::os::raw::c_longlong,
3985 streamBytesRead: *mut ::std::os::raw::c_longlong,
3986 otherBytesRead: *mut ::std::os::raw::c_longlong,
3987 ) -> FMOD_RESULT;
3988}
3989unsafe extern "C" {
3990 #[must_use]
3991 pub fn FMOD_System_CreateSound(
3992 system: *mut FMOD_SYSTEM,
3993 name_or_data: *const ::std::os::raw::c_char,
3994 mode: FMOD_MODE,
3995 exinfo: *mut FMOD_CREATESOUNDEXINFO,
3996 sound: *mut *mut FMOD_SOUND,
3997 ) -> FMOD_RESULT;
3998}
3999unsafe extern "C" {
4000 #[must_use]
4001 pub fn FMOD_System_CreateStream(
4002 system: *mut FMOD_SYSTEM,
4003 name_or_data: *const ::std::os::raw::c_char,
4004 mode: FMOD_MODE,
4005 exinfo: *mut FMOD_CREATESOUNDEXINFO,
4006 sound: *mut *mut FMOD_SOUND,
4007 ) -> FMOD_RESULT;
4008}
4009unsafe extern "C" {
4010 #[must_use]
4011 pub fn FMOD_System_CreateDSP(
4012 system: *mut FMOD_SYSTEM,
4013 description: *const FMOD_DSP_DESCRIPTION,
4014 dsp: *mut *mut FMOD_DSP,
4015 ) -> FMOD_RESULT;
4016}
4017unsafe extern "C" {
4018 #[must_use]
4019 pub fn FMOD_System_CreateDSPByType(
4020 system: *mut FMOD_SYSTEM,
4021 type_: FMOD_DSP_TYPE,
4022 dsp: *mut *mut FMOD_DSP,
4023 ) -> FMOD_RESULT;
4024}
4025unsafe extern "C" {
4026 #[must_use]
4027 pub fn FMOD_System_CreateChannelGroup(
4028 system: *mut FMOD_SYSTEM,
4029 name: *const ::std::os::raw::c_char,
4030 channelgroup: *mut *mut FMOD_CHANNELGROUP,
4031 ) -> FMOD_RESULT;
4032}
4033unsafe extern "C" {
4034 #[must_use]
4035 pub fn FMOD_System_CreateSoundGroup(
4036 system: *mut FMOD_SYSTEM,
4037 name: *const ::std::os::raw::c_char,
4038 soundgroup: *mut *mut FMOD_SOUNDGROUP,
4039 ) -> FMOD_RESULT;
4040}
4041unsafe extern "C" {
4042 #[must_use]
4043 pub fn FMOD_System_CreateReverb3D(
4044 system: *mut FMOD_SYSTEM,
4045 reverb: *mut *mut FMOD_REVERB3D,
4046 ) -> FMOD_RESULT;
4047}
4048unsafe extern "C" {
4049 #[must_use]
4050 pub fn FMOD_System_PlaySound(
4051 system: *mut FMOD_SYSTEM,
4052 sound: *mut FMOD_SOUND,
4053 channelgroup: *mut FMOD_CHANNELGROUP,
4054 paused: FMOD_BOOL,
4055 channel: *mut *mut FMOD_CHANNEL,
4056 ) -> FMOD_RESULT;
4057}
4058unsafe extern "C" {
4059 #[must_use]
4060 pub fn FMOD_System_PlayDSP(
4061 system: *mut FMOD_SYSTEM,
4062 dsp: *mut FMOD_DSP,
4063 channelgroup: *mut FMOD_CHANNELGROUP,
4064 paused: FMOD_BOOL,
4065 channel: *mut *mut FMOD_CHANNEL,
4066 ) -> FMOD_RESULT;
4067}
4068unsafe extern "C" {
4069 #[must_use]
4070 pub fn FMOD_System_GetChannel(
4071 system: *mut FMOD_SYSTEM,
4072 channelid: ::std::os::raw::c_int,
4073 channel: *mut *mut FMOD_CHANNEL,
4074 ) -> FMOD_RESULT;
4075}
4076unsafe extern "C" {
4077 #[must_use]
4078 pub fn FMOD_System_GetDSPInfoByType(
4079 system: *mut FMOD_SYSTEM,
4080 type_: FMOD_DSP_TYPE,
4081 description: *mut *const FMOD_DSP_DESCRIPTION,
4082 ) -> FMOD_RESULT;
4083}
4084unsafe extern "C" {
4085 #[must_use]
4086 pub fn FMOD_System_GetMasterChannelGroup(
4087 system: *mut FMOD_SYSTEM,
4088 channelgroup: *mut *mut FMOD_CHANNELGROUP,
4089 ) -> FMOD_RESULT;
4090}
4091unsafe extern "C" {
4092 #[must_use]
4093 pub fn FMOD_System_GetMasterSoundGroup(
4094 system: *mut FMOD_SYSTEM,
4095 soundgroup: *mut *mut FMOD_SOUNDGROUP,
4096 ) -> FMOD_RESULT;
4097}
4098unsafe extern "C" {
4099 #[must_use]
4100 pub fn FMOD_System_AttachChannelGroupToPort(
4101 system: *mut FMOD_SYSTEM,
4102 portType: FMOD_PORT_TYPE,
4103 portIndex: FMOD_PORT_INDEX,
4104 channelgroup: *mut FMOD_CHANNELGROUP,
4105 passThru: FMOD_BOOL,
4106 ) -> FMOD_RESULT;
4107}
4108unsafe extern "C" {
4109 #[must_use]
4110 pub fn FMOD_System_DetachChannelGroupFromPort(
4111 system: *mut FMOD_SYSTEM,
4112 channelgroup: *mut FMOD_CHANNELGROUP,
4113 ) -> FMOD_RESULT;
4114}
4115unsafe extern "C" {
4116 #[must_use]
4117 pub fn FMOD_System_SetReverbProperties(
4118 system: *mut FMOD_SYSTEM,
4119 instance: ::std::os::raw::c_int,
4120 prop: *const FMOD_REVERB_PROPERTIES,
4121 ) -> FMOD_RESULT;
4122}
4123unsafe extern "C" {
4124 #[must_use]
4125 pub fn FMOD_System_GetReverbProperties(
4126 system: *mut FMOD_SYSTEM,
4127 instance: ::std::os::raw::c_int,
4128 prop: *mut FMOD_REVERB_PROPERTIES,
4129 ) -> FMOD_RESULT;
4130}
4131unsafe extern "C" {
4132 #[must_use]
4133 pub fn FMOD_System_LockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
4134}
4135unsafe extern "C" {
4136 #[must_use]
4137 pub fn FMOD_System_UnlockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
4138}
4139unsafe extern "C" {
4140 #[must_use]
4141 pub fn FMOD_System_GetRecordNumDrivers(
4142 system: *mut FMOD_SYSTEM,
4143 numdrivers: *mut ::std::os::raw::c_int,
4144 numconnected: *mut ::std::os::raw::c_int,
4145 ) -> FMOD_RESULT;
4146}
4147unsafe extern "C" {
4148 #[must_use]
4149 pub fn FMOD_System_GetRecordDriverInfo(
4150 system: *mut FMOD_SYSTEM,
4151 id: ::std::os::raw::c_int,
4152 name: *mut ::std::os::raw::c_char,
4153 namelen: ::std::os::raw::c_int,
4154 guid: *mut FMOD_GUID,
4155 systemrate: *mut ::std::os::raw::c_int,
4156 speakermode: *mut FMOD_SPEAKERMODE,
4157 speakermodechannels: *mut ::std::os::raw::c_int,
4158 state: *mut FMOD_DRIVER_STATE,
4159 ) -> FMOD_RESULT;
4160}
4161unsafe extern "C" {
4162 #[must_use]
4163 pub fn FMOD_System_GetRecordPosition(
4164 system: *mut FMOD_SYSTEM,
4165 id: ::std::os::raw::c_int,
4166 position: *mut ::std::os::raw::c_uint,
4167 ) -> FMOD_RESULT;
4168}
4169unsafe extern "C" {
4170 #[must_use]
4171 pub fn FMOD_System_RecordStart(
4172 system: *mut FMOD_SYSTEM,
4173 id: ::std::os::raw::c_int,
4174 sound: *mut FMOD_SOUND,
4175 loop_: FMOD_BOOL,
4176 ) -> FMOD_RESULT;
4177}
4178unsafe extern "C" {
4179 #[must_use]
4180 pub fn FMOD_System_RecordStop(
4181 system: *mut FMOD_SYSTEM,
4182 id: ::std::os::raw::c_int,
4183 ) -> FMOD_RESULT;
4184}
4185unsafe extern "C" {
4186 #[must_use]
4187 pub fn FMOD_System_IsRecording(
4188 system: *mut FMOD_SYSTEM,
4189 id: ::std::os::raw::c_int,
4190 recording: *mut FMOD_BOOL,
4191 ) -> FMOD_RESULT;
4192}
4193unsafe extern "C" {
4194 #[must_use]
4195 pub fn FMOD_System_CreateGeometry(
4196 system: *mut FMOD_SYSTEM,
4197 maxpolygons: ::std::os::raw::c_int,
4198 maxvertices: ::std::os::raw::c_int,
4199 geometry: *mut *mut FMOD_GEOMETRY,
4200 ) -> FMOD_RESULT;
4201}
4202unsafe extern "C" {
4203 #[must_use]
4204 pub fn FMOD_System_SetGeometrySettings(
4205 system: *mut FMOD_SYSTEM,
4206 maxworldsize: f32,
4207 ) -> FMOD_RESULT;
4208}
4209unsafe extern "C" {
4210 #[must_use]
4211 pub fn FMOD_System_GetGeometrySettings(
4212 system: *mut FMOD_SYSTEM,
4213 maxworldsize: *mut f32,
4214 ) -> FMOD_RESULT;
4215}
4216unsafe extern "C" {
4217 #[must_use]
4218 pub fn FMOD_System_LoadGeometry(
4219 system: *mut FMOD_SYSTEM,
4220 data: *const ::std::os::raw::c_void,
4221 datasize: ::std::os::raw::c_int,
4222 geometry: *mut *mut FMOD_GEOMETRY,
4223 ) -> FMOD_RESULT;
4224}
4225unsafe extern "C" {
4226 #[must_use]
4227 pub fn FMOD_System_GetGeometryOcclusion(
4228 system: *mut FMOD_SYSTEM,
4229 listener: *const FMOD_VECTOR,
4230 source: *const FMOD_VECTOR,
4231 direct: *mut f32,
4232 reverb: *mut f32,
4233 ) -> FMOD_RESULT;
4234}
4235unsafe extern "C" {
4236 #[must_use]
4237 pub fn FMOD_System_SetNetworkProxy(
4238 system: *mut FMOD_SYSTEM,
4239 proxy: *const ::std::os::raw::c_char,
4240 ) -> FMOD_RESULT;
4241}
4242unsafe extern "C" {
4243 #[must_use]
4244 pub fn FMOD_System_GetNetworkProxy(
4245 system: *mut FMOD_SYSTEM,
4246 proxy: *mut ::std::os::raw::c_char,
4247 proxylen: ::std::os::raw::c_int,
4248 ) -> FMOD_RESULT;
4249}
4250unsafe extern "C" {
4251 #[must_use]
4252 pub fn FMOD_System_SetNetworkTimeout(
4253 system: *mut FMOD_SYSTEM,
4254 timeout: ::std::os::raw::c_int,
4255 ) -> FMOD_RESULT;
4256}
4257unsafe extern "C" {
4258 #[must_use]
4259 pub fn FMOD_System_GetNetworkTimeout(
4260 system: *mut FMOD_SYSTEM,
4261 timeout: *mut ::std::os::raw::c_int,
4262 ) -> FMOD_RESULT;
4263}
4264unsafe extern "C" {
4265 #[must_use]
4266 pub fn FMOD_System_SetUserData(
4267 system: *mut FMOD_SYSTEM,
4268 userdata: *mut ::std::os::raw::c_void,
4269 ) -> FMOD_RESULT;
4270}
4271unsafe extern "C" {
4272 #[must_use]
4273 pub fn FMOD_System_GetUserData(
4274 system: *mut FMOD_SYSTEM,
4275 userdata: *mut *mut ::std::os::raw::c_void,
4276 ) -> FMOD_RESULT;
4277}
4278unsafe extern "C" {
4279 #[must_use]
4280 pub fn FMOD_Sound_Release(sound: *mut FMOD_SOUND) -> FMOD_RESULT;
4281}
4282unsafe extern "C" {
4283 #[must_use]
4284 pub fn FMOD_Sound_GetSystemObject(
4285 sound: *mut FMOD_SOUND,
4286 system: *mut *mut FMOD_SYSTEM,
4287 ) -> FMOD_RESULT;
4288}
4289unsafe extern "C" {
4290 #[must_use]
4291 pub fn FMOD_Sound_Lock(
4292 sound: *mut FMOD_SOUND,
4293 offset: ::std::os::raw::c_uint,
4294 length: ::std::os::raw::c_uint,
4295 ptr1: *mut *mut ::std::os::raw::c_void,
4296 ptr2: *mut *mut ::std::os::raw::c_void,
4297 len1: *mut ::std::os::raw::c_uint,
4298 len2: *mut ::std::os::raw::c_uint,
4299 ) -> FMOD_RESULT;
4300}
4301unsafe extern "C" {
4302 #[must_use]
4303 pub fn FMOD_Sound_Unlock(
4304 sound: *mut FMOD_SOUND,
4305 ptr1: *mut ::std::os::raw::c_void,
4306 ptr2: *mut ::std::os::raw::c_void,
4307 len1: ::std::os::raw::c_uint,
4308 len2: ::std::os::raw::c_uint,
4309 ) -> FMOD_RESULT;
4310}
4311unsafe extern "C" {
4312 #[must_use]
4313 pub fn FMOD_Sound_SetDefaults(
4314 sound: *mut FMOD_SOUND,
4315 frequency: f32,
4316 priority: ::std::os::raw::c_int,
4317 ) -> FMOD_RESULT;
4318}
4319unsafe extern "C" {
4320 #[must_use]
4321 pub fn FMOD_Sound_GetDefaults(
4322 sound: *mut FMOD_SOUND,
4323 frequency: *mut f32,
4324 priority: *mut ::std::os::raw::c_int,
4325 ) -> FMOD_RESULT;
4326}
4327unsafe extern "C" {
4328 #[must_use]
4329 pub fn FMOD_Sound_Set3DMinMaxDistance(
4330 sound: *mut FMOD_SOUND,
4331 min: f32,
4332 max: f32,
4333 ) -> FMOD_RESULT;
4334}
4335unsafe extern "C" {
4336 #[must_use]
4337 pub fn FMOD_Sound_Get3DMinMaxDistance(
4338 sound: *mut FMOD_SOUND,
4339 min: *mut f32,
4340 max: *mut f32,
4341 ) -> FMOD_RESULT;
4342}
4343unsafe extern "C" {
4344 #[must_use]
4345 pub fn FMOD_Sound_Set3DConeSettings(
4346 sound: *mut FMOD_SOUND,
4347 insideconeangle: f32,
4348 outsideconeangle: f32,
4349 outsidevolume: f32,
4350 ) -> FMOD_RESULT;
4351}
4352unsafe extern "C" {
4353 #[must_use]
4354 pub fn FMOD_Sound_Get3DConeSettings(
4355 sound: *mut FMOD_SOUND,
4356 insideconeangle: *mut f32,
4357 outsideconeangle: *mut f32,
4358 outsidevolume: *mut f32,
4359 ) -> FMOD_RESULT;
4360}
4361unsafe extern "C" {
4362 #[must_use]
4363 pub fn FMOD_Sound_Set3DCustomRolloff(
4364 sound: *mut FMOD_SOUND,
4365 points: *mut FMOD_VECTOR,
4366 numpoints: ::std::os::raw::c_int,
4367 ) -> FMOD_RESULT;
4368}
4369unsafe extern "C" {
4370 #[must_use]
4371 pub fn FMOD_Sound_Get3DCustomRolloff(
4372 sound: *mut FMOD_SOUND,
4373 points: *mut *mut FMOD_VECTOR,
4374 numpoints: *mut ::std::os::raw::c_int,
4375 ) -> FMOD_RESULT;
4376}
4377unsafe extern "C" {
4378 #[must_use]
4379 pub fn FMOD_Sound_GetSubSound(
4380 sound: *mut FMOD_SOUND,
4381 index: ::std::os::raw::c_int,
4382 subsound: *mut *mut FMOD_SOUND,
4383 ) -> FMOD_RESULT;
4384}
4385unsafe extern "C" {
4386 #[must_use]
4387 pub fn FMOD_Sound_GetSubSoundParent(
4388 sound: *mut FMOD_SOUND,
4389 parentsound: *mut *mut FMOD_SOUND,
4390 ) -> FMOD_RESULT;
4391}
4392unsafe extern "C" {
4393 #[must_use]
4394 pub fn FMOD_Sound_GetName(
4395 sound: *mut FMOD_SOUND,
4396 name: *mut ::std::os::raw::c_char,
4397 namelen: ::std::os::raw::c_int,
4398 ) -> FMOD_RESULT;
4399}
4400unsafe extern "C" {
4401 #[must_use]
4402 pub fn FMOD_Sound_GetLength(
4403 sound: *mut FMOD_SOUND,
4404 length: *mut ::std::os::raw::c_uint,
4405 lengthtype: FMOD_TIMEUNIT,
4406 ) -> FMOD_RESULT;
4407}
4408unsafe extern "C" {
4409 #[must_use]
4410 pub fn FMOD_Sound_GetFormat(
4411 sound: *mut FMOD_SOUND,
4412 type_: *mut FMOD_SOUND_TYPE,
4413 format: *mut FMOD_SOUND_FORMAT,
4414 channels: *mut ::std::os::raw::c_int,
4415 bits: *mut ::std::os::raw::c_int,
4416 ) -> FMOD_RESULT;
4417}
4418unsafe extern "C" {
4419 #[must_use]
4420 pub fn FMOD_Sound_GetNumSubSounds(
4421 sound: *mut FMOD_SOUND,
4422 numsubsounds: *mut ::std::os::raw::c_int,
4423 ) -> FMOD_RESULT;
4424}
4425unsafe extern "C" {
4426 #[must_use]
4427 pub fn FMOD_Sound_GetNumTags(
4428 sound: *mut FMOD_SOUND,
4429 numtags: *mut ::std::os::raw::c_int,
4430 numtagsupdated: *mut ::std::os::raw::c_int,
4431 ) -> FMOD_RESULT;
4432}
4433unsafe extern "C" {
4434 #[must_use]
4435 pub fn FMOD_Sound_GetTag(
4436 sound: *mut FMOD_SOUND,
4437 name: *const ::std::os::raw::c_char,
4438 index: ::std::os::raw::c_int,
4439 tag: *mut FMOD_TAG,
4440 ) -> FMOD_RESULT;
4441}
4442unsafe extern "C" {
4443 #[must_use]
4444 pub fn FMOD_Sound_GetOpenState(
4445 sound: *mut FMOD_SOUND,
4446 openstate: *mut FMOD_OPENSTATE,
4447 percentbuffered: *mut ::std::os::raw::c_uint,
4448 starving: *mut FMOD_BOOL,
4449 diskbusy: *mut FMOD_BOOL,
4450 ) -> FMOD_RESULT;
4451}
4452unsafe extern "C" {
4453 #[must_use]
4454 pub fn FMOD_Sound_ReadData(
4455 sound: *mut FMOD_SOUND,
4456 buffer: *mut ::std::os::raw::c_void,
4457 length: ::std::os::raw::c_uint,
4458 read: *mut ::std::os::raw::c_uint,
4459 ) -> FMOD_RESULT;
4460}
4461unsafe extern "C" {
4462 #[must_use]
4463 pub fn FMOD_Sound_SeekData(sound: *mut FMOD_SOUND, pcm: ::std::os::raw::c_uint) -> FMOD_RESULT;
4464}
4465unsafe extern "C" {
4466 #[must_use]
4467 pub fn FMOD_Sound_SetSoundGroup(
4468 sound: *mut FMOD_SOUND,
4469 soundgroup: *mut FMOD_SOUNDGROUP,
4470 ) -> FMOD_RESULT;
4471}
4472unsafe extern "C" {
4473 #[must_use]
4474 pub fn FMOD_Sound_GetSoundGroup(
4475 sound: *mut FMOD_SOUND,
4476 soundgroup: *mut *mut FMOD_SOUNDGROUP,
4477 ) -> FMOD_RESULT;
4478}
4479unsafe extern "C" {
4480 #[must_use]
4481 pub fn FMOD_Sound_GetNumSyncPoints(
4482 sound: *mut FMOD_SOUND,
4483 numsyncpoints: *mut ::std::os::raw::c_int,
4484 ) -> FMOD_RESULT;
4485}
4486unsafe extern "C" {
4487 #[must_use]
4488 pub fn FMOD_Sound_GetSyncPoint(
4489 sound: *mut FMOD_SOUND,
4490 index: ::std::os::raw::c_int,
4491 point: *mut *mut FMOD_SYNCPOINT,
4492 ) -> FMOD_RESULT;
4493}
4494unsafe extern "C" {
4495 #[must_use]
4496 pub fn FMOD_Sound_GetSyncPointInfo(
4497 sound: *mut FMOD_SOUND,
4498 point: *mut FMOD_SYNCPOINT,
4499 name: *mut ::std::os::raw::c_char,
4500 namelen: ::std::os::raw::c_int,
4501 offset: *mut ::std::os::raw::c_uint,
4502 offsettype: FMOD_TIMEUNIT,
4503 ) -> FMOD_RESULT;
4504}
4505unsafe extern "C" {
4506 #[must_use]
4507 pub fn FMOD_Sound_AddSyncPoint(
4508 sound: *mut FMOD_SOUND,
4509 offset: ::std::os::raw::c_uint,
4510 offsettype: FMOD_TIMEUNIT,
4511 name: *const ::std::os::raw::c_char,
4512 point: *mut *mut FMOD_SYNCPOINT,
4513 ) -> FMOD_RESULT;
4514}
4515unsafe extern "C" {
4516 #[must_use]
4517 pub fn FMOD_Sound_DeleteSyncPoint(
4518 sound: *mut FMOD_SOUND,
4519 point: *mut FMOD_SYNCPOINT,
4520 ) -> FMOD_RESULT;
4521}
4522unsafe extern "C" {
4523 #[must_use]
4524 pub fn FMOD_Sound_SetMode(sound: *mut FMOD_SOUND, mode: FMOD_MODE) -> FMOD_RESULT;
4525}
4526unsafe extern "C" {
4527 #[must_use]
4528 pub fn FMOD_Sound_GetMode(sound: *mut FMOD_SOUND, mode: *mut FMOD_MODE) -> FMOD_RESULT;
4529}
4530unsafe extern "C" {
4531 #[must_use]
4532 pub fn FMOD_Sound_SetLoopCount(
4533 sound: *mut FMOD_SOUND,
4534 loopcount: ::std::os::raw::c_int,
4535 ) -> FMOD_RESULT;
4536}
4537unsafe extern "C" {
4538 #[must_use]
4539 pub fn FMOD_Sound_GetLoopCount(
4540 sound: *mut FMOD_SOUND,
4541 loopcount: *mut ::std::os::raw::c_int,
4542 ) -> FMOD_RESULT;
4543}
4544unsafe extern "C" {
4545 #[must_use]
4546 pub fn FMOD_Sound_SetLoopPoints(
4547 sound: *mut FMOD_SOUND,
4548 loopstart: ::std::os::raw::c_uint,
4549 loopstarttype: FMOD_TIMEUNIT,
4550 loopend: ::std::os::raw::c_uint,
4551 loopendtype: FMOD_TIMEUNIT,
4552 ) -> FMOD_RESULT;
4553}
4554unsafe extern "C" {
4555 #[must_use]
4556 pub fn FMOD_Sound_GetLoopPoints(
4557 sound: *mut FMOD_SOUND,
4558 loopstart: *mut ::std::os::raw::c_uint,
4559 loopstarttype: FMOD_TIMEUNIT,
4560 loopend: *mut ::std::os::raw::c_uint,
4561 loopendtype: FMOD_TIMEUNIT,
4562 ) -> FMOD_RESULT;
4563}
4564unsafe extern "C" {
4565 #[must_use]
4566 pub fn FMOD_Sound_GetMusicNumChannels(
4567 sound: *mut FMOD_SOUND,
4568 numchannels: *mut ::std::os::raw::c_int,
4569 ) -> FMOD_RESULT;
4570}
4571unsafe extern "C" {
4572 #[must_use]
4573 pub fn FMOD_Sound_SetMusicChannelVolume(
4574 sound: *mut FMOD_SOUND,
4575 channel: ::std::os::raw::c_int,
4576 volume: f32,
4577 ) -> FMOD_RESULT;
4578}
4579unsafe extern "C" {
4580 #[must_use]
4581 pub fn FMOD_Sound_GetMusicChannelVolume(
4582 sound: *mut FMOD_SOUND,
4583 channel: ::std::os::raw::c_int,
4584 volume: *mut f32,
4585 ) -> FMOD_RESULT;
4586}
4587unsafe extern "C" {
4588 #[must_use]
4589 pub fn FMOD_Sound_SetMusicSpeed(sound: *mut FMOD_SOUND, speed: f32) -> FMOD_RESULT;
4590}
4591unsafe extern "C" {
4592 #[must_use]
4593 pub fn FMOD_Sound_GetMusicSpeed(sound: *mut FMOD_SOUND, speed: *mut f32) -> FMOD_RESULT;
4594}
4595unsafe extern "C" {
4596 #[must_use]
4597 pub fn FMOD_Sound_SetUserData(
4598 sound: *mut FMOD_SOUND,
4599 userdata: *mut ::std::os::raw::c_void,
4600 ) -> FMOD_RESULT;
4601}
4602unsafe extern "C" {
4603 #[must_use]
4604 pub fn FMOD_Sound_GetUserData(
4605 sound: *mut FMOD_SOUND,
4606 userdata: *mut *mut ::std::os::raw::c_void,
4607 ) -> FMOD_RESULT;
4608}
4609unsafe extern "C" {
4610 #[must_use]
4611 pub fn FMOD_Channel_GetSystemObject(
4612 channel: *mut FMOD_CHANNEL,
4613 system: *mut *mut FMOD_SYSTEM,
4614 ) -> FMOD_RESULT;
4615}
4616unsafe extern "C" {
4617 #[must_use]
4618 pub fn FMOD_Channel_Stop(channel: *mut FMOD_CHANNEL) -> FMOD_RESULT;
4619}
4620unsafe extern "C" {
4621 #[must_use]
4622 pub fn FMOD_Channel_SetPaused(channel: *mut FMOD_CHANNEL, paused: FMOD_BOOL) -> FMOD_RESULT;
4623}
4624unsafe extern "C" {
4625 #[must_use]
4626 pub fn FMOD_Channel_GetPaused(
4627 channel: *mut FMOD_CHANNEL,
4628 paused: *mut FMOD_BOOL,
4629 ) -> FMOD_RESULT;
4630}
4631unsafe extern "C" {
4632 #[must_use]
4633 pub fn FMOD_Channel_SetVolume(channel: *mut FMOD_CHANNEL, volume: f32) -> FMOD_RESULT;
4634}
4635unsafe extern "C" {
4636 #[must_use]
4637 pub fn FMOD_Channel_GetVolume(channel: *mut FMOD_CHANNEL, volume: *mut f32) -> FMOD_RESULT;
4638}
4639unsafe extern "C" {
4640 #[must_use]
4641 pub fn FMOD_Channel_SetVolumeRamp(channel: *mut FMOD_CHANNEL, ramp: FMOD_BOOL) -> FMOD_RESULT;
4642}
4643unsafe extern "C" {
4644 #[must_use]
4645 pub fn FMOD_Channel_GetVolumeRamp(
4646 channel: *mut FMOD_CHANNEL,
4647 ramp: *mut FMOD_BOOL,
4648 ) -> FMOD_RESULT;
4649}
4650unsafe extern "C" {
4651 #[must_use]
4652 pub fn FMOD_Channel_GetAudibility(
4653 channel: *mut FMOD_CHANNEL,
4654 audibility: *mut f32,
4655 ) -> FMOD_RESULT;
4656}
4657unsafe extern "C" {
4658 #[must_use]
4659 pub fn FMOD_Channel_SetPitch(channel: *mut FMOD_CHANNEL, pitch: f32) -> FMOD_RESULT;
4660}
4661unsafe extern "C" {
4662 #[must_use]
4663 pub fn FMOD_Channel_GetPitch(channel: *mut FMOD_CHANNEL, pitch: *mut f32) -> FMOD_RESULT;
4664}
4665unsafe extern "C" {
4666 #[must_use]
4667 pub fn FMOD_Channel_SetMute(channel: *mut FMOD_CHANNEL, mute: FMOD_BOOL) -> FMOD_RESULT;
4668}
4669unsafe extern "C" {
4670 #[must_use]
4671 pub fn FMOD_Channel_GetMute(channel: *mut FMOD_CHANNEL, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
4672}
4673unsafe extern "C" {
4674 #[must_use]
4675 pub fn FMOD_Channel_SetReverbProperties(
4676 channel: *mut FMOD_CHANNEL,
4677 instance: ::std::os::raw::c_int,
4678 wet: f32,
4679 ) -> FMOD_RESULT;
4680}
4681unsafe extern "C" {
4682 #[must_use]
4683 pub fn FMOD_Channel_GetReverbProperties(
4684 channel: *mut FMOD_CHANNEL,
4685 instance: ::std::os::raw::c_int,
4686 wet: *mut f32,
4687 ) -> FMOD_RESULT;
4688}
4689unsafe extern "C" {
4690 #[must_use]
4691 pub fn FMOD_Channel_SetLowPassGain(channel: *mut FMOD_CHANNEL, gain: f32) -> FMOD_RESULT;
4692}
4693unsafe extern "C" {
4694 #[must_use]
4695 pub fn FMOD_Channel_GetLowPassGain(channel: *mut FMOD_CHANNEL, gain: *mut f32) -> FMOD_RESULT;
4696}
4697unsafe extern "C" {
4698 #[must_use]
4699 pub fn FMOD_Channel_SetMode(channel: *mut FMOD_CHANNEL, mode: FMOD_MODE) -> FMOD_RESULT;
4700}
4701unsafe extern "C" {
4702 #[must_use]
4703 pub fn FMOD_Channel_GetMode(channel: *mut FMOD_CHANNEL, mode: *mut FMOD_MODE) -> FMOD_RESULT;
4704}
4705unsafe extern "C" {
4706 #[must_use]
4707 pub fn FMOD_Channel_SetCallback(
4708 channel: *mut FMOD_CHANNEL,
4709 callback: FMOD_CHANNELCONTROL_CALLBACK,
4710 ) -> FMOD_RESULT;
4711}
4712unsafe extern "C" {
4713 #[must_use]
4714 pub fn FMOD_Channel_IsPlaying(
4715 channel: *mut FMOD_CHANNEL,
4716 isplaying: *mut FMOD_BOOL,
4717 ) -> FMOD_RESULT;
4718}
4719unsafe extern "C" {
4720 #[must_use]
4721 pub fn FMOD_Channel_SetPan(channel: *mut FMOD_CHANNEL, pan: f32) -> FMOD_RESULT;
4722}
4723unsafe extern "C" {
4724 #[must_use]
4725 pub fn FMOD_Channel_SetMixLevelsOutput(
4726 channel: *mut FMOD_CHANNEL,
4727 frontleft: f32,
4728 frontright: f32,
4729 center: f32,
4730 lfe: f32,
4731 surroundleft: f32,
4732 surroundright: f32,
4733 backleft: f32,
4734 backright: f32,
4735 ) -> FMOD_RESULT;
4736}
4737unsafe extern "C" {
4738 #[must_use]
4739 pub fn FMOD_Channel_SetMixLevelsInput(
4740 channel: *mut FMOD_CHANNEL,
4741 levels: *mut f32,
4742 numlevels: ::std::os::raw::c_int,
4743 ) -> FMOD_RESULT;
4744}
4745unsafe extern "C" {
4746 #[must_use]
4747 pub fn FMOD_Channel_SetMixMatrix(
4748 channel: *mut FMOD_CHANNEL,
4749 matrix: *mut f32,
4750 outchannels: ::std::os::raw::c_int,
4751 inchannels: ::std::os::raw::c_int,
4752 inchannel_hop: ::std::os::raw::c_int,
4753 ) -> FMOD_RESULT;
4754}
4755unsafe extern "C" {
4756 #[must_use]
4757 pub fn FMOD_Channel_GetMixMatrix(
4758 channel: *mut FMOD_CHANNEL,
4759 matrix: *mut f32,
4760 outchannels: *mut ::std::os::raw::c_int,
4761 inchannels: *mut ::std::os::raw::c_int,
4762 inchannel_hop: ::std::os::raw::c_int,
4763 ) -> FMOD_RESULT;
4764}
4765unsafe extern "C" {
4766 #[must_use]
4767 pub fn FMOD_Channel_GetDSPClock(
4768 channel: *mut FMOD_CHANNEL,
4769 dspclock: *mut ::std::os::raw::c_ulonglong,
4770 parentclock: *mut ::std::os::raw::c_ulonglong,
4771 ) -> FMOD_RESULT;
4772}
4773unsafe extern "C" {
4774 #[must_use]
4775 pub fn FMOD_Channel_SetDelay(
4776 channel: *mut FMOD_CHANNEL,
4777 dspclock_start: ::std::os::raw::c_ulonglong,
4778 dspclock_end: ::std::os::raw::c_ulonglong,
4779 stopchannels: FMOD_BOOL,
4780 ) -> FMOD_RESULT;
4781}
4782unsafe extern "C" {
4783 #[must_use]
4784 pub fn FMOD_Channel_GetDelay(
4785 channel: *mut FMOD_CHANNEL,
4786 dspclock_start: *mut ::std::os::raw::c_ulonglong,
4787 dspclock_end: *mut ::std::os::raw::c_ulonglong,
4788 stopchannels: *mut FMOD_BOOL,
4789 ) -> FMOD_RESULT;
4790}
4791unsafe extern "C" {
4792 #[must_use]
4793 pub fn FMOD_Channel_AddFadePoint(
4794 channel: *mut FMOD_CHANNEL,
4795 dspclock: ::std::os::raw::c_ulonglong,
4796 volume: f32,
4797 ) -> FMOD_RESULT;
4798}
4799unsafe extern "C" {
4800 #[must_use]
4801 pub fn FMOD_Channel_SetFadePointRamp(
4802 channel: *mut FMOD_CHANNEL,
4803 dspclock: ::std::os::raw::c_ulonglong,
4804 volume: f32,
4805 ) -> FMOD_RESULT;
4806}
4807unsafe extern "C" {
4808 #[must_use]
4809 pub fn FMOD_Channel_RemoveFadePoints(
4810 channel: *mut FMOD_CHANNEL,
4811 dspclock_start: ::std::os::raw::c_ulonglong,
4812 dspclock_end: ::std::os::raw::c_ulonglong,
4813 ) -> FMOD_RESULT;
4814}
4815unsafe extern "C" {
4816 #[must_use]
4817 pub fn FMOD_Channel_GetFadePoints(
4818 channel: *mut FMOD_CHANNEL,
4819 numpoints: *mut ::std::os::raw::c_uint,
4820 point_dspclock: *mut ::std::os::raw::c_ulonglong,
4821 point_volume: *mut f32,
4822 ) -> FMOD_RESULT;
4823}
4824unsafe extern "C" {
4825 #[must_use]
4826 pub fn FMOD_Channel_GetDSP(
4827 channel: *mut FMOD_CHANNEL,
4828 index: ::std::os::raw::c_int,
4829 dsp: *mut *mut FMOD_DSP,
4830 ) -> FMOD_RESULT;
4831}
4832unsafe extern "C" {
4833 #[must_use]
4834 pub fn FMOD_Channel_AddDSP(
4835 channel: *mut FMOD_CHANNEL,
4836 index: ::std::os::raw::c_int,
4837 dsp: *mut FMOD_DSP,
4838 ) -> FMOD_RESULT;
4839}
4840unsafe extern "C" {
4841 #[must_use]
4842 pub fn FMOD_Channel_RemoveDSP(channel: *mut FMOD_CHANNEL, dsp: *mut FMOD_DSP) -> FMOD_RESULT;
4843}
4844unsafe extern "C" {
4845 #[must_use]
4846 pub fn FMOD_Channel_GetNumDSPs(
4847 channel: *mut FMOD_CHANNEL,
4848 numdsps: *mut ::std::os::raw::c_int,
4849 ) -> FMOD_RESULT;
4850}
4851unsafe extern "C" {
4852 #[must_use]
4853 pub fn FMOD_Channel_SetDSPIndex(
4854 channel: *mut FMOD_CHANNEL,
4855 dsp: *mut FMOD_DSP,
4856 index: ::std::os::raw::c_int,
4857 ) -> FMOD_RESULT;
4858}
4859unsafe extern "C" {
4860 #[must_use]
4861 pub fn FMOD_Channel_GetDSPIndex(
4862 channel: *mut FMOD_CHANNEL,
4863 dsp: *mut FMOD_DSP,
4864 index: *mut ::std::os::raw::c_int,
4865 ) -> FMOD_RESULT;
4866}
4867unsafe extern "C" {
4868 #[must_use]
4869 pub fn FMOD_Channel_Set3DAttributes(
4870 channel: *mut FMOD_CHANNEL,
4871 pos: *const FMOD_VECTOR,
4872 vel: *const FMOD_VECTOR,
4873 ) -> FMOD_RESULT;
4874}
4875unsafe extern "C" {
4876 #[must_use]
4877 pub fn FMOD_Channel_Get3DAttributes(
4878 channel: *mut FMOD_CHANNEL,
4879 pos: *mut FMOD_VECTOR,
4880 vel: *mut FMOD_VECTOR,
4881 ) -> FMOD_RESULT;
4882}
4883unsafe extern "C" {
4884 #[must_use]
4885 pub fn FMOD_Channel_Set3DMinMaxDistance(
4886 channel: *mut FMOD_CHANNEL,
4887 mindistance: f32,
4888 maxdistance: f32,
4889 ) -> FMOD_RESULT;
4890}
4891unsafe extern "C" {
4892 #[must_use]
4893 pub fn FMOD_Channel_Get3DMinMaxDistance(
4894 channel: *mut FMOD_CHANNEL,
4895 mindistance: *mut f32,
4896 maxdistance: *mut f32,
4897 ) -> FMOD_RESULT;
4898}
4899unsafe extern "C" {
4900 #[must_use]
4901 pub fn FMOD_Channel_Set3DConeSettings(
4902 channel: *mut FMOD_CHANNEL,
4903 insideconeangle: f32,
4904 outsideconeangle: f32,
4905 outsidevolume: f32,
4906 ) -> FMOD_RESULT;
4907}
4908unsafe extern "C" {
4909 #[must_use]
4910 pub fn FMOD_Channel_Get3DConeSettings(
4911 channel: *mut FMOD_CHANNEL,
4912 insideconeangle: *mut f32,
4913 outsideconeangle: *mut f32,
4914 outsidevolume: *mut f32,
4915 ) -> FMOD_RESULT;
4916}
4917unsafe extern "C" {
4918 #[must_use]
4919 pub fn FMOD_Channel_Set3DConeOrientation(
4920 channel: *mut FMOD_CHANNEL,
4921 orientation: *mut FMOD_VECTOR,
4922 ) -> FMOD_RESULT;
4923}
4924unsafe extern "C" {
4925 #[must_use]
4926 pub fn FMOD_Channel_Get3DConeOrientation(
4927 channel: *mut FMOD_CHANNEL,
4928 orientation: *mut FMOD_VECTOR,
4929 ) -> FMOD_RESULT;
4930}
4931unsafe extern "C" {
4932 #[must_use]
4933 pub fn FMOD_Channel_Set3DCustomRolloff(
4934 channel: *mut FMOD_CHANNEL,
4935 points: *mut FMOD_VECTOR,
4936 numpoints: ::std::os::raw::c_int,
4937 ) -> FMOD_RESULT;
4938}
4939unsafe extern "C" {
4940 #[must_use]
4941 pub fn FMOD_Channel_Get3DCustomRolloff(
4942 channel: *mut FMOD_CHANNEL,
4943 points: *mut *mut FMOD_VECTOR,
4944 numpoints: *mut ::std::os::raw::c_int,
4945 ) -> FMOD_RESULT;
4946}
4947unsafe extern "C" {
4948 #[must_use]
4949 pub fn FMOD_Channel_Set3DOcclusion(
4950 channel: *mut FMOD_CHANNEL,
4951 directocclusion: f32,
4952 reverbocclusion: f32,
4953 ) -> FMOD_RESULT;
4954}
4955unsafe extern "C" {
4956 #[must_use]
4957 pub fn FMOD_Channel_Get3DOcclusion(
4958 channel: *mut FMOD_CHANNEL,
4959 directocclusion: *mut f32,
4960 reverbocclusion: *mut f32,
4961 ) -> FMOD_RESULT;
4962}
4963unsafe extern "C" {
4964 #[must_use]
4965 pub fn FMOD_Channel_Set3DSpread(channel: *mut FMOD_CHANNEL, angle: f32) -> FMOD_RESULT;
4966}
4967unsafe extern "C" {
4968 #[must_use]
4969 pub fn FMOD_Channel_Get3DSpread(channel: *mut FMOD_CHANNEL, angle: *mut f32) -> FMOD_RESULT;
4970}
4971unsafe extern "C" {
4972 #[must_use]
4973 pub fn FMOD_Channel_Set3DLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
4974}
4975unsafe extern "C" {
4976 #[must_use]
4977 pub fn FMOD_Channel_Get3DLevel(channel: *mut FMOD_CHANNEL, level: *mut f32) -> FMOD_RESULT;
4978}
4979unsafe extern "C" {
4980 #[must_use]
4981 pub fn FMOD_Channel_Set3DDopplerLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
4982}
4983unsafe extern "C" {
4984 #[must_use]
4985 pub fn FMOD_Channel_Get3DDopplerLevel(
4986 channel: *mut FMOD_CHANNEL,
4987 level: *mut f32,
4988 ) -> FMOD_RESULT;
4989}
4990unsafe extern "C" {
4991 #[must_use]
4992 pub fn FMOD_Channel_Set3DDistanceFilter(
4993 channel: *mut FMOD_CHANNEL,
4994 custom: FMOD_BOOL,
4995 customLevel: f32,
4996 centerFreq: f32,
4997 ) -> FMOD_RESULT;
4998}
4999unsafe extern "C" {
5000 #[must_use]
5001 pub fn FMOD_Channel_Get3DDistanceFilter(
5002 channel: *mut FMOD_CHANNEL,
5003 custom: *mut FMOD_BOOL,
5004 customLevel: *mut f32,
5005 centerFreq: *mut f32,
5006 ) -> FMOD_RESULT;
5007}
5008unsafe extern "C" {
5009 #[must_use]
5010 pub fn FMOD_Channel_SetUserData(
5011 channel: *mut FMOD_CHANNEL,
5012 userdata: *mut ::std::os::raw::c_void,
5013 ) -> FMOD_RESULT;
5014}
5015unsafe extern "C" {
5016 #[must_use]
5017 pub fn FMOD_Channel_GetUserData(
5018 channel: *mut FMOD_CHANNEL,
5019 userdata: *mut *mut ::std::os::raw::c_void,
5020 ) -> FMOD_RESULT;
5021}
5022unsafe extern "C" {
5023 #[must_use]
5024 pub fn FMOD_Channel_SetFrequency(channel: *mut FMOD_CHANNEL, frequency: f32) -> FMOD_RESULT;
5025}
5026unsafe extern "C" {
5027 #[must_use]
5028 pub fn FMOD_Channel_GetFrequency(
5029 channel: *mut FMOD_CHANNEL,
5030 frequency: *mut f32,
5031 ) -> FMOD_RESULT;
5032}
5033unsafe extern "C" {
5034 #[must_use]
5035 pub fn FMOD_Channel_SetPriority(
5036 channel: *mut FMOD_CHANNEL,
5037 priority: ::std::os::raw::c_int,
5038 ) -> FMOD_RESULT;
5039}
5040unsafe extern "C" {
5041 #[must_use]
5042 pub fn FMOD_Channel_GetPriority(
5043 channel: *mut FMOD_CHANNEL,
5044 priority: *mut ::std::os::raw::c_int,
5045 ) -> FMOD_RESULT;
5046}
5047unsafe extern "C" {
5048 #[must_use]
5049 pub fn FMOD_Channel_SetPosition(
5050 channel: *mut FMOD_CHANNEL,
5051 position: ::std::os::raw::c_uint,
5052 postype: FMOD_TIMEUNIT,
5053 ) -> FMOD_RESULT;
5054}
5055unsafe extern "C" {
5056 #[must_use]
5057 pub fn FMOD_Channel_GetPosition(
5058 channel: *mut FMOD_CHANNEL,
5059 position: *mut ::std::os::raw::c_uint,
5060 postype: FMOD_TIMEUNIT,
5061 ) -> FMOD_RESULT;
5062}
5063unsafe extern "C" {
5064 #[must_use]
5065 pub fn FMOD_Channel_SetChannelGroup(
5066 channel: *mut FMOD_CHANNEL,
5067 channelgroup: *mut FMOD_CHANNELGROUP,
5068 ) -> FMOD_RESULT;
5069}
5070unsafe extern "C" {
5071 #[must_use]
5072 pub fn FMOD_Channel_GetChannelGroup(
5073 channel: *mut FMOD_CHANNEL,
5074 channelgroup: *mut *mut FMOD_CHANNELGROUP,
5075 ) -> FMOD_RESULT;
5076}
5077unsafe extern "C" {
5078 #[must_use]
5079 pub fn FMOD_Channel_SetLoopCount(
5080 channel: *mut FMOD_CHANNEL,
5081 loopcount: ::std::os::raw::c_int,
5082 ) -> FMOD_RESULT;
5083}
5084unsafe extern "C" {
5085 #[must_use]
5086 pub fn FMOD_Channel_GetLoopCount(
5087 channel: *mut FMOD_CHANNEL,
5088 loopcount: *mut ::std::os::raw::c_int,
5089 ) -> FMOD_RESULT;
5090}
5091unsafe extern "C" {
5092 #[must_use]
5093 pub fn FMOD_Channel_SetLoopPoints(
5094 channel: *mut FMOD_CHANNEL,
5095 loopstart: ::std::os::raw::c_uint,
5096 loopstarttype: FMOD_TIMEUNIT,
5097 loopend: ::std::os::raw::c_uint,
5098 loopendtype: FMOD_TIMEUNIT,
5099 ) -> FMOD_RESULT;
5100}
5101unsafe extern "C" {
5102 #[must_use]
5103 pub fn FMOD_Channel_GetLoopPoints(
5104 channel: *mut FMOD_CHANNEL,
5105 loopstart: *mut ::std::os::raw::c_uint,
5106 loopstarttype: FMOD_TIMEUNIT,
5107 loopend: *mut ::std::os::raw::c_uint,
5108 loopendtype: FMOD_TIMEUNIT,
5109 ) -> FMOD_RESULT;
5110}
5111unsafe extern "C" {
5112 #[must_use]
5113 pub fn FMOD_Channel_IsVirtual(
5114 channel: *mut FMOD_CHANNEL,
5115 isvirtual: *mut FMOD_BOOL,
5116 ) -> FMOD_RESULT;
5117}
5118unsafe extern "C" {
5119 #[must_use]
5120 pub fn FMOD_Channel_GetCurrentSound(
5121 channel: *mut FMOD_CHANNEL,
5122 sound: *mut *mut FMOD_SOUND,
5123 ) -> FMOD_RESULT;
5124}
5125unsafe extern "C" {
5126 #[must_use]
5127 pub fn FMOD_Channel_GetIndex(
5128 channel: *mut FMOD_CHANNEL,
5129 index: *mut ::std::os::raw::c_int,
5130 ) -> FMOD_RESULT;
5131}
5132unsafe extern "C" {
5133 #[must_use]
5134 pub fn FMOD_ChannelGroup_GetSystemObject(
5135 channelgroup: *mut FMOD_CHANNELGROUP,
5136 system: *mut *mut FMOD_SYSTEM,
5137 ) -> FMOD_RESULT;
5138}
5139unsafe extern "C" {
5140 #[must_use]
5141 pub fn FMOD_ChannelGroup_Stop(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
5142}
5143unsafe extern "C" {
5144 #[must_use]
5145 pub fn FMOD_ChannelGroup_SetPaused(
5146 channelgroup: *mut FMOD_CHANNELGROUP,
5147 paused: FMOD_BOOL,
5148 ) -> FMOD_RESULT;
5149}
5150unsafe extern "C" {
5151 #[must_use]
5152 pub fn FMOD_ChannelGroup_GetPaused(
5153 channelgroup: *mut FMOD_CHANNELGROUP,
5154 paused: *mut FMOD_BOOL,
5155 ) -> FMOD_RESULT;
5156}
5157unsafe extern "C" {
5158 #[must_use]
5159 pub fn FMOD_ChannelGroup_SetVolume(
5160 channelgroup: *mut FMOD_CHANNELGROUP,
5161 volume: f32,
5162 ) -> FMOD_RESULT;
5163}
5164unsafe extern "C" {
5165 #[must_use]
5166 pub fn FMOD_ChannelGroup_GetVolume(
5167 channelgroup: *mut FMOD_CHANNELGROUP,
5168 volume: *mut f32,
5169 ) -> FMOD_RESULT;
5170}
5171unsafe extern "C" {
5172 #[must_use]
5173 pub fn FMOD_ChannelGroup_SetVolumeRamp(
5174 channelgroup: *mut FMOD_CHANNELGROUP,
5175 ramp: FMOD_BOOL,
5176 ) -> FMOD_RESULT;
5177}
5178unsafe extern "C" {
5179 #[must_use]
5180 pub fn FMOD_ChannelGroup_GetVolumeRamp(
5181 channelgroup: *mut FMOD_CHANNELGROUP,
5182 ramp: *mut FMOD_BOOL,
5183 ) -> FMOD_RESULT;
5184}
5185unsafe extern "C" {
5186 #[must_use]
5187 pub fn FMOD_ChannelGroup_GetAudibility(
5188 channelgroup: *mut FMOD_CHANNELGROUP,
5189 audibility: *mut f32,
5190 ) -> FMOD_RESULT;
5191}
5192unsafe extern "C" {
5193 #[must_use]
5194 pub fn FMOD_ChannelGroup_SetPitch(
5195 channelgroup: *mut FMOD_CHANNELGROUP,
5196 pitch: f32,
5197 ) -> FMOD_RESULT;
5198}
5199unsafe extern "C" {
5200 #[must_use]
5201 pub fn FMOD_ChannelGroup_GetPitch(
5202 channelgroup: *mut FMOD_CHANNELGROUP,
5203 pitch: *mut f32,
5204 ) -> FMOD_RESULT;
5205}
5206unsafe extern "C" {
5207 #[must_use]
5208 pub fn FMOD_ChannelGroup_SetMute(
5209 channelgroup: *mut FMOD_CHANNELGROUP,
5210 mute: FMOD_BOOL,
5211 ) -> FMOD_RESULT;
5212}
5213unsafe extern "C" {
5214 #[must_use]
5215 pub fn FMOD_ChannelGroup_GetMute(
5216 channelgroup: *mut FMOD_CHANNELGROUP,
5217 mute: *mut FMOD_BOOL,
5218 ) -> FMOD_RESULT;
5219}
5220unsafe extern "C" {
5221 #[must_use]
5222 pub fn FMOD_ChannelGroup_SetReverbProperties(
5223 channelgroup: *mut FMOD_CHANNELGROUP,
5224 instance: ::std::os::raw::c_int,
5225 wet: f32,
5226 ) -> FMOD_RESULT;
5227}
5228unsafe extern "C" {
5229 #[must_use]
5230 pub fn FMOD_ChannelGroup_GetReverbProperties(
5231 channelgroup: *mut FMOD_CHANNELGROUP,
5232 instance: ::std::os::raw::c_int,
5233 wet: *mut f32,
5234 ) -> FMOD_RESULT;
5235}
5236unsafe extern "C" {
5237 #[must_use]
5238 pub fn FMOD_ChannelGroup_SetLowPassGain(
5239 channelgroup: *mut FMOD_CHANNELGROUP,
5240 gain: f32,
5241 ) -> FMOD_RESULT;
5242}
5243unsafe extern "C" {
5244 #[must_use]
5245 pub fn FMOD_ChannelGroup_GetLowPassGain(
5246 channelgroup: *mut FMOD_CHANNELGROUP,
5247 gain: *mut f32,
5248 ) -> FMOD_RESULT;
5249}
5250unsafe extern "C" {
5251 #[must_use]
5252 pub fn FMOD_ChannelGroup_SetMode(
5253 channelgroup: *mut FMOD_CHANNELGROUP,
5254 mode: FMOD_MODE,
5255 ) -> FMOD_RESULT;
5256}
5257unsafe extern "C" {
5258 #[must_use]
5259 pub fn FMOD_ChannelGroup_GetMode(
5260 channelgroup: *mut FMOD_CHANNELGROUP,
5261 mode: *mut FMOD_MODE,
5262 ) -> FMOD_RESULT;
5263}
5264unsafe extern "C" {
5265 #[must_use]
5266 pub fn FMOD_ChannelGroup_SetCallback(
5267 channelgroup: *mut FMOD_CHANNELGROUP,
5268 callback: FMOD_CHANNELCONTROL_CALLBACK,
5269 ) -> FMOD_RESULT;
5270}
5271unsafe extern "C" {
5272 #[must_use]
5273 pub fn FMOD_ChannelGroup_IsPlaying(
5274 channelgroup: *mut FMOD_CHANNELGROUP,
5275 isplaying: *mut FMOD_BOOL,
5276 ) -> FMOD_RESULT;
5277}
5278unsafe extern "C" {
5279 #[must_use]
5280 pub fn FMOD_ChannelGroup_SetPan(channelgroup: *mut FMOD_CHANNELGROUP, pan: f32) -> FMOD_RESULT;
5281}
5282unsafe extern "C" {
5283 #[must_use]
5284 pub fn FMOD_ChannelGroup_SetMixLevelsOutput(
5285 channelgroup: *mut FMOD_CHANNELGROUP,
5286 frontleft: f32,
5287 frontright: f32,
5288 center: f32,
5289 lfe: f32,
5290 surroundleft: f32,
5291 surroundright: f32,
5292 backleft: f32,
5293 backright: f32,
5294 ) -> FMOD_RESULT;
5295}
5296unsafe extern "C" {
5297 #[must_use]
5298 pub fn FMOD_ChannelGroup_SetMixLevelsInput(
5299 channelgroup: *mut FMOD_CHANNELGROUP,
5300 levels: *mut f32,
5301 numlevels: ::std::os::raw::c_int,
5302 ) -> FMOD_RESULT;
5303}
5304unsafe extern "C" {
5305 #[must_use]
5306 pub fn FMOD_ChannelGroup_SetMixMatrix(
5307 channelgroup: *mut FMOD_CHANNELGROUP,
5308 matrix: *mut f32,
5309 outchannels: ::std::os::raw::c_int,
5310 inchannels: ::std::os::raw::c_int,
5311 inchannel_hop: ::std::os::raw::c_int,
5312 ) -> FMOD_RESULT;
5313}
5314unsafe extern "C" {
5315 #[must_use]
5316 pub fn FMOD_ChannelGroup_GetMixMatrix(
5317 channelgroup: *mut FMOD_CHANNELGROUP,
5318 matrix: *mut f32,
5319 outchannels: *mut ::std::os::raw::c_int,
5320 inchannels: *mut ::std::os::raw::c_int,
5321 inchannel_hop: ::std::os::raw::c_int,
5322 ) -> FMOD_RESULT;
5323}
5324unsafe extern "C" {
5325 #[must_use]
5326 pub fn FMOD_ChannelGroup_GetDSPClock(
5327 channelgroup: *mut FMOD_CHANNELGROUP,
5328 dspclock: *mut ::std::os::raw::c_ulonglong,
5329 parentclock: *mut ::std::os::raw::c_ulonglong,
5330 ) -> FMOD_RESULT;
5331}
5332unsafe extern "C" {
5333 #[must_use]
5334 pub fn FMOD_ChannelGroup_SetDelay(
5335 channelgroup: *mut FMOD_CHANNELGROUP,
5336 dspclock_start: ::std::os::raw::c_ulonglong,
5337 dspclock_end: ::std::os::raw::c_ulonglong,
5338 stopchannels: FMOD_BOOL,
5339 ) -> FMOD_RESULT;
5340}
5341unsafe extern "C" {
5342 #[must_use]
5343 pub fn FMOD_ChannelGroup_GetDelay(
5344 channelgroup: *mut FMOD_CHANNELGROUP,
5345 dspclock_start: *mut ::std::os::raw::c_ulonglong,
5346 dspclock_end: *mut ::std::os::raw::c_ulonglong,
5347 stopchannels: *mut FMOD_BOOL,
5348 ) -> FMOD_RESULT;
5349}
5350unsafe extern "C" {
5351 #[must_use]
5352 pub fn FMOD_ChannelGroup_AddFadePoint(
5353 channelgroup: *mut FMOD_CHANNELGROUP,
5354 dspclock: ::std::os::raw::c_ulonglong,
5355 volume: f32,
5356 ) -> FMOD_RESULT;
5357}
5358unsafe extern "C" {
5359 #[must_use]
5360 pub fn FMOD_ChannelGroup_SetFadePointRamp(
5361 channelgroup: *mut FMOD_CHANNELGROUP,
5362 dspclock: ::std::os::raw::c_ulonglong,
5363 volume: f32,
5364 ) -> FMOD_RESULT;
5365}
5366unsafe extern "C" {
5367 #[must_use]
5368 pub fn FMOD_ChannelGroup_RemoveFadePoints(
5369 channelgroup: *mut FMOD_CHANNELGROUP,
5370 dspclock_start: ::std::os::raw::c_ulonglong,
5371 dspclock_end: ::std::os::raw::c_ulonglong,
5372 ) -> FMOD_RESULT;
5373}
5374unsafe extern "C" {
5375 #[must_use]
5376 pub fn FMOD_ChannelGroup_GetFadePoints(
5377 channelgroup: *mut FMOD_CHANNELGROUP,
5378 numpoints: *mut ::std::os::raw::c_uint,
5379 point_dspclock: *mut ::std::os::raw::c_ulonglong,
5380 point_volume: *mut f32,
5381 ) -> FMOD_RESULT;
5382}
5383unsafe extern "C" {
5384 #[must_use]
5385 pub fn FMOD_ChannelGroup_GetDSP(
5386 channelgroup: *mut FMOD_CHANNELGROUP,
5387 index: ::std::os::raw::c_int,
5388 dsp: *mut *mut FMOD_DSP,
5389 ) -> FMOD_RESULT;
5390}
5391unsafe extern "C" {
5392 #[must_use]
5393 pub fn FMOD_ChannelGroup_AddDSP(
5394 channelgroup: *mut FMOD_CHANNELGROUP,
5395 index: ::std::os::raw::c_int,
5396 dsp: *mut FMOD_DSP,
5397 ) -> FMOD_RESULT;
5398}
5399unsafe extern "C" {
5400 #[must_use]
5401 pub fn FMOD_ChannelGroup_RemoveDSP(
5402 channelgroup: *mut FMOD_CHANNELGROUP,
5403 dsp: *mut FMOD_DSP,
5404 ) -> FMOD_RESULT;
5405}
5406unsafe extern "C" {
5407 #[must_use]
5408 pub fn FMOD_ChannelGroup_GetNumDSPs(
5409 channelgroup: *mut FMOD_CHANNELGROUP,
5410 numdsps: *mut ::std::os::raw::c_int,
5411 ) -> FMOD_RESULT;
5412}
5413unsafe extern "C" {
5414 #[must_use]
5415 pub fn FMOD_ChannelGroup_SetDSPIndex(
5416 channelgroup: *mut FMOD_CHANNELGROUP,
5417 dsp: *mut FMOD_DSP,
5418 index: ::std::os::raw::c_int,
5419 ) -> FMOD_RESULT;
5420}
5421unsafe extern "C" {
5422 #[must_use]
5423 pub fn FMOD_ChannelGroup_GetDSPIndex(
5424 channelgroup: *mut FMOD_CHANNELGROUP,
5425 dsp: *mut FMOD_DSP,
5426 index: *mut ::std::os::raw::c_int,
5427 ) -> FMOD_RESULT;
5428}
5429unsafe extern "C" {
5430 #[must_use]
5431 pub fn FMOD_ChannelGroup_Set3DAttributes(
5432 channelgroup: *mut FMOD_CHANNELGROUP,
5433 pos: *const FMOD_VECTOR,
5434 vel: *const FMOD_VECTOR,
5435 ) -> FMOD_RESULT;
5436}
5437unsafe extern "C" {
5438 #[must_use]
5439 pub fn FMOD_ChannelGroup_Get3DAttributes(
5440 channelgroup: *mut FMOD_CHANNELGROUP,
5441 pos: *mut FMOD_VECTOR,
5442 vel: *mut FMOD_VECTOR,
5443 ) -> FMOD_RESULT;
5444}
5445unsafe extern "C" {
5446 #[must_use]
5447 pub fn FMOD_ChannelGroup_Set3DMinMaxDistance(
5448 channelgroup: *mut FMOD_CHANNELGROUP,
5449 mindistance: f32,
5450 maxdistance: f32,
5451 ) -> FMOD_RESULT;
5452}
5453unsafe extern "C" {
5454 #[must_use]
5455 pub fn FMOD_ChannelGroup_Get3DMinMaxDistance(
5456 channelgroup: *mut FMOD_CHANNELGROUP,
5457 mindistance: *mut f32,
5458 maxdistance: *mut f32,
5459 ) -> FMOD_RESULT;
5460}
5461unsafe extern "C" {
5462 #[must_use]
5463 pub fn FMOD_ChannelGroup_Set3DConeSettings(
5464 channelgroup: *mut FMOD_CHANNELGROUP,
5465 insideconeangle: f32,
5466 outsideconeangle: f32,
5467 outsidevolume: f32,
5468 ) -> FMOD_RESULT;
5469}
5470unsafe extern "C" {
5471 #[must_use]
5472 pub fn FMOD_ChannelGroup_Get3DConeSettings(
5473 channelgroup: *mut FMOD_CHANNELGROUP,
5474 insideconeangle: *mut f32,
5475 outsideconeangle: *mut f32,
5476 outsidevolume: *mut f32,
5477 ) -> FMOD_RESULT;
5478}
5479unsafe extern "C" {
5480 #[must_use]
5481 pub fn FMOD_ChannelGroup_Set3DConeOrientation(
5482 channelgroup: *mut FMOD_CHANNELGROUP,
5483 orientation: *mut FMOD_VECTOR,
5484 ) -> FMOD_RESULT;
5485}
5486unsafe extern "C" {
5487 #[must_use]
5488 pub fn FMOD_ChannelGroup_Get3DConeOrientation(
5489 channelgroup: *mut FMOD_CHANNELGROUP,
5490 orientation: *mut FMOD_VECTOR,
5491 ) -> FMOD_RESULT;
5492}
5493unsafe extern "C" {
5494 #[must_use]
5495 pub fn FMOD_ChannelGroup_Set3DCustomRolloff(
5496 channelgroup: *mut FMOD_CHANNELGROUP,
5497 points: *mut FMOD_VECTOR,
5498 numpoints: ::std::os::raw::c_int,
5499 ) -> FMOD_RESULT;
5500}
5501unsafe extern "C" {
5502 #[must_use]
5503 pub fn FMOD_ChannelGroup_Get3DCustomRolloff(
5504 channelgroup: *mut FMOD_CHANNELGROUP,
5505 points: *mut *mut FMOD_VECTOR,
5506 numpoints: *mut ::std::os::raw::c_int,
5507 ) -> FMOD_RESULT;
5508}
5509unsafe extern "C" {
5510 #[must_use]
5511 pub fn FMOD_ChannelGroup_Set3DOcclusion(
5512 channelgroup: *mut FMOD_CHANNELGROUP,
5513 directocclusion: f32,
5514 reverbocclusion: f32,
5515 ) -> FMOD_RESULT;
5516}
5517unsafe extern "C" {
5518 #[must_use]
5519 pub fn FMOD_ChannelGroup_Get3DOcclusion(
5520 channelgroup: *mut FMOD_CHANNELGROUP,
5521 directocclusion: *mut f32,
5522 reverbocclusion: *mut f32,
5523 ) -> FMOD_RESULT;
5524}
5525unsafe extern "C" {
5526 #[must_use]
5527 pub fn FMOD_ChannelGroup_Set3DSpread(
5528 channelgroup: *mut FMOD_CHANNELGROUP,
5529 angle: f32,
5530 ) -> FMOD_RESULT;
5531}
5532unsafe extern "C" {
5533 #[must_use]
5534 pub fn FMOD_ChannelGroup_Get3DSpread(
5535 channelgroup: *mut FMOD_CHANNELGROUP,
5536 angle: *mut f32,
5537 ) -> FMOD_RESULT;
5538}
5539unsafe extern "C" {
5540 #[must_use]
5541 pub fn FMOD_ChannelGroup_Set3DLevel(
5542 channelgroup: *mut FMOD_CHANNELGROUP,
5543 level: f32,
5544 ) -> FMOD_RESULT;
5545}
5546unsafe extern "C" {
5547 #[must_use]
5548 pub fn FMOD_ChannelGroup_Get3DLevel(
5549 channelgroup: *mut FMOD_CHANNELGROUP,
5550 level: *mut f32,
5551 ) -> FMOD_RESULT;
5552}
5553unsafe extern "C" {
5554 #[must_use]
5555 pub fn FMOD_ChannelGroup_Set3DDopplerLevel(
5556 channelgroup: *mut FMOD_CHANNELGROUP,
5557 level: f32,
5558 ) -> FMOD_RESULT;
5559}
5560unsafe extern "C" {
5561 #[must_use]
5562 pub fn FMOD_ChannelGroup_Get3DDopplerLevel(
5563 channelgroup: *mut FMOD_CHANNELGROUP,
5564 level: *mut f32,
5565 ) -> FMOD_RESULT;
5566}
5567unsafe extern "C" {
5568 #[must_use]
5569 pub fn FMOD_ChannelGroup_Set3DDistanceFilter(
5570 channelgroup: *mut FMOD_CHANNELGROUP,
5571 custom: FMOD_BOOL,
5572 customLevel: f32,
5573 centerFreq: f32,
5574 ) -> FMOD_RESULT;
5575}
5576unsafe extern "C" {
5577 #[must_use]
5578 pub fn FMOD_ChannelGroup_Get3DDistanceFilter(
5579 channelgroup: *mut FMOD_CHANNELGROUP,
5580 custom: *mut FMOD_BOOL,
5581 customLevel: *mut f32,
5582 centerFreq: *mut f32,
5583 ) -> FMOD_RESULT;
5584}
5585unsafe extern "C" {
5586 #[must_use]
5587 pub fn FMOD_ChannelGroup_SetUserData(
5588 channelgroup: *mut FMOD_CHANNELGROUP,
5589 userdata: *mut ::std::os::raw::c_void,
5590 ) -> FMOD_RESULT;
5591}
5592unsafe extern "C" {
5593 #[must_use]
5594 pub fn FMOD_ChannelGroup_GetUserData(
5595 channelgroup: *mut FMOD_CHANNELGROUP,
5596 userdata: *mut *mut ::std::os::raw::c_void,
5597 ) -> FMOD_RESULT;
5598}
5599unsafe extern "C" {
5600 #[must_use]
5601 pub fn FMOD_ChannelGroup_Release(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
5602}
5603unsafe extern "C" {
5604 #[must_use]
5605 pub fn FMOD_ChannelGroup_AddGroup(
5606 channelgroup: *mut FMOD_CHANNELGROUP,
5607 group: *mut FMOD_CHANNELGROUP,
5608 propagatedspclock: FMOD_BOOL,
5609 connection: *mut *mut FMOD_DSPCONNECTION,
5610 ) -> FMOD_RESULT;
5611}
5612unsafe extern "C" {
5613 #[must_use]
5614 pub fn FMOD_ChannelGroup_GetNumGroups(
5615 channelgroup: *mut FMOD_CHANNELGROUP,
5616 numgroups: *mut ::std::os::raw::c_int,
5617 ) -> FMOD_RESULT;
5618}
5619unsafe extern "C" {
5620 #[must_use]
5621 pub fn FMOD_ChannelGroup_GetGroup(
5622 channelgroup: *mut FMOD_CHANNELGROUP,
5623 index: ::std::os::raw::c_int,
5624 group: *mut *mut FMOD_CHANNELGROUP,
5625 ) -> FMOD_RESULT;
5626}
5627unsafe extern "C" {
5628 #[must_use]
5629 pub fn FMOD_ChannelGroup_GetParentGroup(
5630 channelgroup: *mut FMOD_CHANNELGROUP,
5631 group: *mut *mut FMOD_CHANNELGROUP,
5632 ) -> FMOD_RESULT;
5633}
5634unsafe extern "C" {
5635 #[must_use]
5636 pub fn FMOD_ChannelGroup_GetName(
5637 channelgroup: *mut FMOD_CHANNELGROUP,
5638 name: *mut ::std::os::raw::c_char,
5639 namelen: ::std::os::raw::c_int,
5640 ) -> FMOD_RESULT;
5641}
5642unsafe extern "C" {
5643 #[must_use]
5644 pub fn FMOD_ChannelGroup_GetNumChannels(
5645 channelgroup: *mut FMOD_CHANNELGROUP,
5646 numchannels: *mut ::std::os::raw::c_int,
5647 ) -> FMOD_RESULT;
5648}
5649unsafe extern "C" {
5650 #[must_use]
5651 pub fn FMOD_ChannelGroup_GetChannel(
5652 channelgroup: *mut FMOD_CHANNELGROUP,
5653 index: ::std::os::raw::c_int,
5654 channel: *mut *mut FMOD_CHANNEL,
5655 ) -> FMOD_RESULT;
5656}
5657unsafe extern "C" {
5658 #[must_use]
5659 pub fn FMOD_SoundGroup_Release(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
5660}
5661unsafe extern "C" {
5662 #[must_use]
5663 pub fn FMOD_SoundGroup_GetSystemObject(
5664 soundgroup: *mut FMOD_SOUNDGROUP,
5665 system: *mut *mut FMOD_SYSTEM,
5666 ) -> FMOD_RESULT;
5667}
5668unsafe extern "C" {
5669 #[must_use]
5670 pub fn FMOD_SoundGroup_SetMaxAudible(
5671 soundgroup: *mut FMOD_SOUNDGROUP,
5672 maxaudible: ::std::os::raw::c_int,
5673 ) -> FMOD_RESULT;
5674}
5675unsafe extern "C" {
5676 #[must_use]
5677 pub fn FMOD_SoundGroup_GetMaxAudible(
5678 soundgroup: *mut FMOD_SOUNDGROUP,
5679 maxaudible: *mut ::std::os::raw::c_int,
5680 ) -> FMOD_RESULT;
5681}
5682unsafe extern "C" {
5683 #[must_use]
5684 pub fn FMOD_SoundGroup_SetMaxAudibleBehavior(
5685 soundgroup: *mut FMOD_SOUNDGROUP,
5686 behavior: FMOD_SOUNDGROUP_BEHAVIOR,
5687 ) -> FMOD_RESULT;
5688}
5689unsafe extern "C" {
5690 #[must_use]
5691 pub fn FMOD_SoundGroup_GetMaxAudibleBehavior(
5692 soundgroup: *mut FMOD_SOUNDGROUP,
5693 behavior: *mut FMOD_SOUNDGROUP_BEHAVIOR,
5694 ) -> FMOD_RESULT;
5695}
5696unsafe extern "C" {
5697 #[must_use]
5698 pub fn FMOD_SoundGroup_SetMuteFadeSpeed(
5699 soundgroup: *mut FMOD_SOUNDGROUP,
5700 speed: f32,
5701 ) -> FMOD_RESULT;
5702}
5703unsafe extern "C" {
5704 #[must_use]
5705 pub fn FMOD_SoundGroup_GetMuteFadeSpeed(
5706 soundgroup: *mut FMOD_SOUNDGROUP,
5707 speed: *mut f32,
5708 ) -> FMOD_RESULT;
5709}
5710unsafe extern "C" {
5711 #[must_use]
5712 pub fn FMOD_SoundGroup_SetVolume(soundgroup: *mut FMOD_SOUNDGROUP, volume: f32) -> FMOD_RESULT;
5713}
5714unsafe extern "C" {
5715 #[must_use]
5716 pub fn FMOD_SoundGroup_GetVolume(
5717 soundgroup: *mut FMOD_SOUNDGROUP,
5718 volume: *mut f32,
5719 ) -> FMOD_RESULT;
5720}
5721unsafe extern "C" {
5722 #[must_use]
5723 pub fn FMOD_SoundGroup_Stop(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
5724}
5725unsafe extern "C" {
5726 #[must_use]
5727 pub fn FMOD_SoundGroup_GetName(
5728 soundgroup: *mut FMOD_SOUNDGROUP,
5729 name: *mut ::std::os::raw::c_char,
5730 namelen: ::std::os::raw::c_int,
5731 ) -> FMOD_RESULT;
5732}
5733unsafe extern "C" {
5734 #[must_use]
5735 pub fn FMOD_SoundGroup_GetNumSounds(
5736 soundgroup: *mut FMOD_SOUNDGROUP,
5737 numsounds: *mut ::std::os::raw::c_int,
5738 ) -> FMOD_RESULT;
5739}
5740unsafe extern "C" {
5741 #[must_use]
5742 pub fn FMOD_SoundGroup_GetSound(
5743 soundgroup: *mut FMOD_SOUNDGROUP,
5744 index: ::std::os::raw::c_int,
5745 sound: *mut *mut FMOD_SOUND,
5746 ) -> FMOD_RESULT;
5747}
5748unsafe extern "C" {
5749 #[must_use]
5750 pub fn FMOD_SoundGroup_GetNumPlaying(
5751 soundgroup: *mut FMOD_SOUNDGROUP,
5752 numplaying: *mut ::std::os::raw::c_int,
5753 ) -> FMOD_RESULT;
5754}
5755unsafe extern "C" {
5756 #[must_use]
5757 pub fn FMOD_SoundGroup_SetUserData(
5758 soundgroup: *mut FMOD_SOUNDGROUP,
5759 userdata: *mut ::std::os::raw::c_void,
5760 ) -> FMOD_RESULT;
5761}
5762unsafe extern "C" {
5763 #[must_use]
5764 pub fn FMOD_SoundGroup_GetUserData(
5765 soundgroup: *mut FMOD_SOUNDGROUP,
5766 userdata: *mut *mut ::std::os::raw::c_void,
5767 ) -> FMOD_RESULT;
5768}
5769unsafe extern "C" {
5770 #[must_use]
5771 pub fn FMOD_DSP_Release(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
5772}
5773unsafe extern "C" {
5774 #[must_use]
5775 pub fn FMOD_DSP_GetSystemObject(
5776 dsp: *mut FMOD_DSP,
5777 system: *mut *mut FMOD_SYSTEM,
5778 ) -> FMOD_RESULT;
5779}
5780unsafe extern "C" {
5781 #[must_use]
5782 pub fn FMOD_DSP_AddInput(
5783 dsp: *mut FMOD_DSP,
5784 input: *mut FMOD_DSP,
5785 connection: *mut *mut FMOD_DSPCONNECTION,
5786 type_: FMOD_DSPCONNECTION_TYPE,
5787 ) -> FMOD_RESULT;
5788}
5789unsafe extern "C" {
5790 #[must_use]
5791 pub fn FMOD_DSP_DisconnectFrom(
5792 dsp: *mut FMOD_DSP,
5793 target: *mut FMOD_DSP,
5794 connection: *mut FMOD_DSPCONNECTION,
5795 ) -> FMOD_RESULT;
5796}
5797unsafe extern "C" {
5798 #[must_use]
5799 pub fn FMOD_DSP_DisconnectAll(
5800 dsp: *mut FMOD_DSP,
5801 inputs: FMOD_BOOL,
5802 outputs: FMOD_BOOL,
5803 ) -> FMOD_RESULT;
5804}
5805unsafe extern "C" {
5806 #[must_use]
5807 pub fn FMOD_DSP_GetNumInputs(
5808 dsp: *mut FMOD_DSP,
5809 numinputs: *mut ::std::os::raw::c_int,
5810 ) -> FMOD_RESULT;
5811}
5812unsafe extern "C" {
5813 #[must_use]
5814 pub fn FMOD_DSP_GetNumOutputs(
5815 dsp: *mut FMOD_DSP,
5816 numoutputs: *mut ::std::os::raw::c_int,
5817 ) -> FMOD_RESULT;
5818}
5819unsafe extern "C" {
5820 #[must_use]
5821 pub fn FMOD_DSP_GetInput(
5822 dsp: *mut FMOD_DSP,
5823 index: ::std::os::raw::c_int,
5824 input: *mut *mut FMOD_DSP,
5825 inputconnection: *mut *mut FMOD_DSPCONNECTION,
5826 ) -> FMOD_RESULT;
5827}
5828unsafe extern "C" {
5829 #[must_use]
5830 pub fn FMOD_DSP_GetOutput(
5831 dsp: *mut FMOD_DSP,
5832 index: ::std::os::raw::c_int,
5833 output: *mut *mut FMOD_DSP,
5834 outputconnection: *mut *mut FMOD_DSPCONNECTION,
5835 ) -> FMOD_RESULT;
5836}
5837unsafe extern "C" {
5838 #[must_use]
5839 pub fn FMOD_DSP_SetActive(dsp: *mut FMOD_DSP, active: FMOD_BOOL) -> FMOD_RESULT;
5840}
5841unsafe extern "C" {
5842 #[must_use]
5843 pub fn FMOD_DSP_GetActive(dsp: *mut FMOD_DSP, active: *mut FMOD_BOOL) -> FMOD_RESULT;
5844}
5845unsafe extern "C" {
5846 #[must_use]
5847 pub fn FMOD_DSP_SetBypass(dsp: *mut FMOD_DSP, bypass: FMOD_BOOL) -> FMOD_RESULT;
5848}
5849unsafe extern "C" {
5850 #[must_use]
5851 pub fn FMOD_DSP_GetBypass(dsp: *mut FMOD_DSP, bypass: *mut FMOD_BOOL) -> FMOD_RESULT;
5852}
5853unsafe extern "C" {
5854 #[must_use]
5855 pub fn FMOD_DSP_SetWetDryMix(
5856 dsp: *mut FMOD_DSP,
5857 prewet: f32,
5858 postwet: f32,
5859 dry: f32,
5860 ) -> FMOD_RESULT;
5861}
5862unsafe extern "C" {
5863 #[must_use]
5864 pub fn FMOD_DSP_GetWetDryMix(
5865 dsp: *mut FMOD_DSP,
5866 prewet: *mut f32,
5867 postwet: *mut f32,
5868 dry: *mut f32,
5869 ) -> FMOD_RESULT;
5870}
5871unsafe extern "C" {
5872 #[must_use]
5873 pub fn FMOD_DSP_SetChannelFormat(
5874 dsp: *mut FMOD_DSP,
5875 channelmask: FMOD_CHANNELMASK,
5876 numchannels: ::std::os::raw::c_int,
5877 source_speakermode: FMOD_SPEAKERMODE,
5878 ) -> FMOD_RESULT;
5879}
5880unsafe extern "C" {
5881 #[must_use]
5882 pub fn FMOD_DSP_GetChannelFormat(
5883 dsp: *mut FMOD_DSP,
5884 channelmask: *mut FMOD_CHANNELMASK,
5885 numchannels: *mut ::std::os::raw::c_int,
5886 source_speakermode: *mut FMOD_SPEAKERMODE,
5887 ) -> FMOD_RESULT;
5888}
5889unsafe extern "C" {
5890 #[must_use]
5891 pub fn FMOD_DSP_GetOutputChannelFormat(
5892 dsp: *mut FMOD_DSP,
5893 inmask: FMOD_CHANNELMASK,
5894 inchannels: ::std::os::raw::c_int,
5895 inspeakermode: FMOD_SPEAKERMODE,
5896 outmask: *mut FMOD_CHANNELMASK,
5897 outchannels: *mut ::std::os::raw::c_int,
5898 outspeakermode: *mut FMOD_SPEAKERMODE,
5899 ) -> FMOD_RESULT;
5900}
5901unsafe extern "C" {
5902 #[must_use]
5903 pub fn FMOD_DSP_Reset(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
5904}
5905unsafe extern "C" {
5906 #[must_use]
5907 pub fn FMOD_DSP_SetCallback(dsp: *mut FMOD_DSP, callback: FMOD_DSP_CALLBACK) -> FMOD_RESULT;
5908}
5909unsafe extern "C" {
5910 #[must_use]
5911 pub fn FMOD_DSP_SetParameterFloat(
5912 dsp: *mut FMOD_DSP,
5913 index: ::std::os::raw::c_int,
5914 value: f32,
5915 ) -> FMOD_RESULT;
5916}
5917unsafe extern "C" {
5918 #[must_use]
5919 pub fn FMOD_DSP_SetParameterInt(
5920 dsp: *mut FMOD_DSP,
5921 index: ::std::os::raw::c_int,
5922 value: ::std::os::raw::c_int,
5923 ) -> FMOD_RESULT;
5924}
5925unsafe extern "C" {
5926 #[must_use]
5927 pub fn FMOD_DSP_SetParameterBool(
5928 dsp: *mut FMOD_DSP,
5929 index: ::std::os::raw::c_int,
5930 value: FMOD_BOOL,
5931 ) -> FMOD_RESULT;
5932}
5933unsafe extern "C" {
5934 #[must_use]
5935 pub fn FMOD_DSP_SetParameterData(
5936 dsp: *mut FMOD_DSP,
5937 index: ::std::os::raw::c_int,
5938 data: *mut ::std::os::raw::c_void,
5939 length: ::std::os::raw::c_uint,
5940 ) -> FMOD_RESULT;
5941}
5942unsafe extern "C" {
5943 #[must_use]
5944 pub fn FMOD_DSP_GetParameterFloat(
5945 dsp: *mut FMOD_DSP,
5946 index: ::std::os::raw::c_int,
5947 value: *mut f32,
5948 valuestr: *mut ::std::os::raw::c_char,
5949 valuestrlen: ::std::os::raw::c_int,
5950 ) -> FMOD_RESULT;
5951}
5952unsafe extern "C" {
5953 #[must_use]
5954 pub fn FMOD_DSP_GetParameterInt(
5955 dsp: *mut FMOD_DSP,
5956 index: ::std::os::raw::c_int,
5957 value: *mut ::std::os::raw::c_int,
5958 valuestr: *mut ::std::os::raw::c_char,
5959 valuestrlen: ::std::os::raw::c_int,
5960 ) -> FMOD_RESULT;
5961}
5962unsafe extern "C" {
5963 #[must_use]
5964 pub fn FMOD_DSP_GetParameterBool(
5965 dsp: *mut FMOD_DSP,
5966 index: ::std::os::raw::c_int,
5967 value: *mut FMOD_BOOL,
5968 valuestr: *mut ::std::os::raw::c_char,
5969 valuestrlen: ::std::os::raw::c_int,
5970 ) -> FMOD_RESULT;
5971}
5972unsafe extern "C" {
5973 #[must_use]
5974 pub fn FMOD_DSP_GetParameterData(
5975 dsp: *mut FMOD_DSP,
5976 index: ::std::os::raw::c_int,
5977 data: *mut *mut ::std::os::raw::c_void,
5978 length: *mut ::std::os::raw::c_uint,
5979 valuestr: *mut ::std::os::raw::c_char,
5980 valuestrlen: ::std::os::raw::c_int,
5981 ) -> FMOD_RESULT;
5982}
5983unsafe extern "C" {
5984 #[must_use]
5985 pub fn FMOD_DSP_GetNumParameters(
5986 dsp: *mut FMOD_DSP,
5987 numparams: *mut ::std::os::raw::c_int,
5988 ) -> FMOD_RESULT;
5989}
5990unsafe extern "C" {
5991 #[must_use]
5992 pub fn FMOD_DSP_GetParameterInfo(
5993 dsp: *mut FMOD_DSP,
5994 index: ::std::os::raw::c_int,
5995 desc: *mut *mut FMOD_DSP_PARAMETER_DESC,
5996 ) -> FMOD_RESULT;
5997}
5998unsafe extern "C" {
5999 #[must_use]
6000 pub fn FMOD_DSP_GetDataParameterIndex(
6001 dsp: *mut FMOD_DSP,
6002 datatype: ::std::os::raw::c_int,
6003 index: *mut ::std::os::raw::c_int,
6004 ) -> FMOD_RESULT;
6005}
6006unsafe extern "C" {
6007 #[must_use]
6008 pub fn FMOD_DSP_ShowConfigDialog(
6009 dsp: *mut FMOD_DSP,
6010 hwnd: *mut ::std::os::raw::c_void,
6011 show: FMOD_BOOL,
6012 ) -> FMOD_RESULT;
6013}
6014unsafe extern "C" {
6015 #[must_use]
6016 pub fn FMOD_DSP_GetInfo(
6017 dsp: *mut FMOD_DSP,
6018 name: *mut ::std::os::raw::c_char,
6019 version: *mut ::std::os::raw::c_uint,
6020 channels: *mut ::std::os::raw::c_int,
6021 configwidth: *mut ::std::os::raw::c_int,
6022 configheight: *mut ::std::os::raw::c_int,
6023 ) -> FMOD_RESULT;
6024}
6025unsafe extern "C" {
6026 #[must_use]
6027 pub fn FMOD_DSP_GetType(dsp: *mut FMOD_DSP, type_: *mut FMOD_DSP_TYPE) -> FMOD_RESULT;
6028}
6029unsafe extern "C" {
6030 #[must_use]
6031 pub fn FMOD_DSP_GetIdle(dsp: *mut FMOD_DSP, idle: *mut FMOD_BOOL) -> FMOD_RESULT;
6032}
6033unsafe extern "C" {
6034 #[must_use]
6035 pub fn FMOD_DSP_SetUserData(
6036 dsp: *mut FMOD_DSP,
6037 userdata: *mut ::std::os::raw::c_void,
6038 ) -> FMOD_RESULT;
6039}
6040unsafe extern "C" {
6041 #[must_use]
6042 pub fn FMOD_DSP_GetUserData(
6043 dsp: *mut FMOD_DSP,
6044 userdata: *mut *mut ::std::os::raw::c_void,
6045 ) -> FMOD_RESULT;
6046}
6047unsafe extern "C" {
6048 #[must_use]
6049 pub fn FMOD_DSP_SetMeteringEnabled(
6050 dsp: *mut FMOD_DSP,
6051 inputEnabled: FMOD_BOOL,
6052 outputEnabled: FMOD_BOOL,
6053 ) -> FMOD_RESULT;
6054}
6055unsafe extern "C" {
6056 #[must_use]
6057 pub fn FMOD_DSP_GetMeteringEnabled(
6058 dsp: *mut FMOD_DSP,
6059 inputEnabled: *mut FMOD_BOOL,
6060 outputEnabled: *mut FMOD_BOOL,
6061 ) -> FMOD_RESULT;
6062}
6063unsafe extern "C" {
6064 #[must_use]
6065 pub fn FMOD_DSP_GetMeteringInfo(
6066 dsp: *mut FMOD_DSP,
6067 inputInfo: *mut FMOD_DSP_METERING_INFO,
6068 outputInfo: *mut FMOD_DSP_METERING_INFO,
6069 ) -> FMOD_RESULT;
6070}
6071unsafe extern "C" {
6072 #[must_use]
6073 pub fn FMOD_DSP_GetCPUUsage(
6074 dsp: *mut FMOD_DSP,
6075 exclusive: *mut ::std::os::raw::c_uint,
6076 inclusive: *mut ::std::os::raw::c_uint,
6077 ) -> FMOD_RESULT;
6078}
6079unsafe extern "C" {
6080 #[must_use]
6081 pub fn FMOD_DSPConnection_GetInput(
6082 dspconnection: *mut FMOD_DSPCONNECTION,
6083 input: *mut *mut FMOD_DSP,
6084 ) -> FMOD_RESULT;
6085}
6086unsafe extern "C" {
6087 #[must_use]
6088 pub fn FMOD_DSPConnection_GetOutput(
6089 dspconnection: *mut FMOD_DSPCONNECTION,
6090 output: *mut *mut FMOD_DSP,
6091 ) -> FMOD_RESULT;
6092}
6093unsafe extern "C" {
6094 #[must_use]
6095 pub fn FMOD_DSPConnection_SetMix(
6096 dspconnection: *mut FMOD_DSPCONNECTION,
6097 volume: f32,
6098 ) -> FMOD_RESULT;
6099}
6100unsafe extern "C" {
6101 #[must_use]
6102 pub fn FMOD_DSPConnection_GetMix(
6103 dspconnection: *mut FMOD_DSPCONNECTION,
6104 volume: *mut f32,
6105 ) -> FMOD_RESULT;
6106}
6107unsafe extern "C" {
6108 #[must_use]
6109 pub fn FMOD_DSPConnection_SetMixMatrix(
6110 dspconnection: *mut FMOD_DSPCONNECTION,
6111 matrix: *mut f32,
6112 outchannels: ::std::os::raw::c_int,
6113 inchannels: ::std::os::raw::c_int,
6114 inchannel_hop: ::std::os::raw::c_int,
6115 ) -> FMOD_RESULT;
6116}
6117unsafe extern "C" {
6118 #[must_use]
6119 pub fn FMOD_DSPConnection_GetMixMatrix(
6120 dspconnection: *mut FMOD_DSPCONNECTION,
6121 matrix: *mut f32,
6122 outchannels: *mut ::std::os::raw::c_int,
6123 inchannels: *mut ::std::os::raw::c_int,
6124 inchannel_hop: ::std::os::raw::c_int,
6125 ) -> FMOD_RESULT;
6126}
6127unsafe extern "C" {
6128 #[must_use]
6129 pub fn FMOD_DSPConnection_GetType(
6130 dspconnection: *mut FMOD_DSPCONNECTION,
6131 type_: *mut FMOD_DSPCONNECTION_TYPE,
6132 ) -> FMOD_RESULT;
6133}
6134unsafe extern "C" {
6135 #[must_use]
6136 pub fn FMOD_DSPConnection_SetUserData(
6137 dspconnection: *mut FMOD_DSPCONNECTION,
6138 userdata: *mut ::std::os::raw::c_void,
6139 ) -> FMOD_RESULT;
6140}
6141unsafe extern "C" {
6142 #[must_use]
6143 pub fn FMOD_DSPConnection_GetUserData(
6144 dspconnection: *mut FMOD_DSPCONNECTION,
6145 userdata: *mut *mut ::std::os::raw::c_void,
6146 ) -> FMOD_RESULT;
6147}
6148unsafe extern "C" {
6149 #[must_use]
6150 pub fn FMOD_Geometry_Release(geometry: *mut FMOD_GEOMETRY) -> FMOD_RESULT;
6151}
6152unsafe extern "C" {
6153 #[must_use]
6154 pub fn FMOD_Geometry_AddPolygon(
6155 geometry: *mut FMOD_GEOMETRY,
6156 directocclusion: f32,
6157 reverbocclusion: f32,
6158 doublesided: FMOD_BOOL,
6159 numvertices: ::std::os::raw::c_int,
6160 vertices: *const FMOD_VECTOR,
6161 polygonindex: *mut ::std::os::raw::c_int,
6162 ) -> FMOD_RESULT;
6163}
6164unsafe extern "C" {
6165 #[must_use]
6166 pub fn FMOD_Geometry_GetNumPolygons(
6167 geometry: *mut FMOD_GEOMETRY,
6168 numpolygons: *mut ::std::os::raw::c_int,
6169 ) -> FMOD_RESULT;
6170}
6171unsafe extern "C" {
6172 #[must_use]
6173 pub fn FMOD_Geometry_GetMaxPolygons(
6174 geometry: *mut FMOD_GEOMETRY,
6175 maxpolygons: *mut ::std::os::raw::c_int,
6176 maxvertices: *mut ::std::os::raw::c_int,
6177 ) -> FMOD_RESULT;
6178}
6179unsafe extern "C" {
6180 #[must_use]
6181 pub fn FMOD_Geometry_GetPolygonNumVertices(
6182 geometry: *mut FMOD_GEOMETRY,
6183 index: ::std::os::raw::c_int,
6184 numvertices: *mut ::std::os::raw::c_int,
6185 ) -> FMOD_RESULT;
6186}
6187unsafe extern "C" {
6188 #[must_use]
6189 pub fn FMOD_Geometry_SetPolygonVertex(
6190 geometry: *mut FMOD_GEOMETRY,
6191 index: ::std::os::raw::c_int,
6192 vertexindex: ::std::os::raw::c_int,
6193 vertex: *const FMOD_VECTOR,
6194 ) -> FMOD_RESULT;
6195}
6196unsafe extern "C" {
6197 #[must_use]
6198 pub fn FMOD_Geometry_GetPolygonVertex(
6199 geometry: *mut FMOD_GEOMETRY,
6200 index: ::std::os::raw::c_int,
6201 vertexindex: ::std::os::raw::c_int,
6202 vertex: *mut FMOD_VECTOR,
6203 ) -> FMOD_RESULT;
6204}
6205unsafe extern "C" {
6206 #[must_use]
6207 pub fn FMOD_Geometry_SetPolygonAttributes(
6208 geometry: *mut FMOD_GEOMETRY,
6209 index: ::std::os::raw::c_int,
6210 directocclusion: f32,
6211 reverbocclusion: f32,
6212 doublesided: FMOD_BOOL,
6213 ) -> FMOD_RESULT;
6214}
6215unsafe extern "C" {
6216 #[must_use]
6217 pub fn FMOD_Geometry_GetPolygonAttributes(
6218 geometry: *mut FMOD_GEOMETRY,
6219 index: ::std::os::raw::c_int,
6220 directocclusion: *mut f32,
6221 reverbocclusion: *mut f32,
6222 doublesided: *mut FMOD_BOOL,
6223 ) -> FMOD_RESULT;
6224}
6225unsafe extern "C" {
6226 #[must_use]
6227 pub fn FMOD_Geometry_SetActive(geometry: *mut FMOD_GEOMETRY, active: FMOD_BOOL) -> FMOD_RESULT;
6228}
6229unsafe extern "C" {
6230 #[must_use]
6231 pub fn FMOD_Geometry_GetActive(
6232 geometry: *mut FMOD_GEOMETRY,
6233 active: *mut FMOD_BOOL,
6234 ) -> FMOD_RESULT;
6235}
6236unsafe extern "C" {
6237 #[must_use]
6238 pub fn FMOD_Geometry_SetRotation(
6239 geometry: *mut FMOD_GEOMETRY,
6240 forward: *const FMOD_VECTOR,
6241 up: *const FMOD_VECTOR,
6242 ) -> FMOD_RESULT;
6243}
6244unsafe extern "C" {
6245 #[must_use]
6246 pub fn FMOD_Geometry_GetRotation(
6247 geometry: *mut FMOD_GEOMETRY,
6248 forward: *mut FMOD_VECTOR,
6249 up: *mut FMOD_VECTOR,
6250 ) -> FMOD_RESULT;
6251}
6252unsafe extern "C" {
6253 #[must_use]
6254 pub fn FMOD_Geometry_SetPosition(
6255 geometry: *mut FMOD_GEOMETRY,
6256 position: *const FMOD_VECTOR,
6257 ) -> FMOD_RESULT;
6258}
6259unsafe extern "C" {
6260 #[must_use]
6261 pub fn FMOD_Geometry_GetPosition(
6262 geometry: *mut FMOD_GEOMETRY,
6263 position: *mut FMOD_VECTOR,
6264 ) -> FMOD_RESULT;
6265}
6266unsafe extern "C" {
6267 #[must_use]
6268 pub fn FMOD_Geometry_SetScale(
6269 geometry: *mut FMOD_GEOMETRY,
6270 scale: *const FMOD_VECTOR,
6271 ) -> FMOD_RESULT;
6272}
6273unsafe extern "C" {
6274 #[must_use]
6275 pub fn FMOD_Geometry_GetScale(
6276 geometry: *mut FMOD_GEOMETRY,
6277 scale: *mut FMOD_VECTOR,
6278 ) -> FMOD_RESULT;
6279}
6280unsafe extern "C" {
6281 #[must_use]
6282 pub fn FMOD_Geometry_Save(
6283 geometry: *mut FMOD_GEOMETRY,
6284 data: *mut ::std::os::raw::c_void,
6285 datasize: *mut ::std::os::raw::c_int,
6286 ) -> FMOD_RESULT;
6287}
6288unsafe extern "C" {
6289 #[must_use]
6290 pub fn FMOD_Geometry_SetUserData(
6291 geometry: *mut FMOD_GEOMETRY,
6292 userdata: *mut ::std::os::raw::c_void,
6293 ) -> FMOD_RESULT;
6294}
6295unsafe extern "C" {
6296 #[must_use]
6297 pub fn FMOD_Geometry_GetUserData(
6298 geometry: *mut FMOD_GEOMETRY,
6299 userdata: *mut *mut ::std::os::raw::c_void,
6300 ) -> FMOD_RESULT;
6301}
6302unsafe extern "C" {
6303 #[must_use]
6304 pub fn FMOD_Reverb3D_Release(reverb3d: *mut FMOD_REVERB3D) -> FMOD_RESULT;
6305}
6306unsafe extern "C" {
6307 #[must_use]
6308 pub fn FMOD_Reverb3D_Set3DAttributes(
6309 reverb3d: *mut FMOD_REVERB3D,
6310 position: *const FMOD_VECTOR,
6311 mindistance: f32,
6312 maxdistance: f32,
6313 ) -> FMOD_RESULT;
6314}
6315unsafe extern "C" {
6316 #[must_use]
6317 pub fn FMOD_Reverb3D_Get3DAttributes(
6318 reverb3d: *mut FMOD_REVERB3D,
6319 position: *mut FMOD_VECTOR,
6320 mindistance: *mut f32,
6321 maxdistance: *mut f32,
6322 ) -> FMOD_RESULT;
6323}
6324unsafe extern "C" {
6325 #[must_use]
6326 pub fn FMOD_Reverb3D_SetProperties(
6327 reverb3d: *mut FMOD_REVERB3D,
6328 properties: *const FMOD_REVERB_PROPERTIES,
6329 ) -> FMOD_RESULT;
6330}
6331unsafe extern "C" {
6332 #[must_use]
6333 pub fn FMOD_Reverb3D_GetProperties(
6334 reverb3d: *mut FMOD_REVERB3D,
6335 properties: *mut FMOD_REVERB_PROPERTIES,
6336 ) -> FMOD_RESULT;
6337}
6338unsafe extern "C" {
6339 #[must_use]
6340 pub fn FMOD_Reverb3D_SetActive(reverb3d: *mut FMOD_REVERB3D, active: FMOD_BOOL) -> FMOD_RESULT;
6341}
6342unsafe extern "C" {
6343 #[must_use]
6344 pub fn FMOD_Reverb3D_GetActive(
6345 reverb3d: *mut FMOD_REVERB3D,
6346 active: *mut FMOD_BOOL,
6347 ) -> FMOD_RESULT;
6348}
6349unsafe extern "C" {
6350 #[must_use]
6351 pub fn FMOD_Reverb3D_SetUserData(
6352 reverb3d: *mut FMOD_REVERB3D,
6353 userdata: *mut ::std::os::raw::c_void,
6354 ) -> FMOD_RESULT;
6355}
6356unsafe extern "C" {
6357 #[must_use]
6358 pub fn FMOD_Reverb3D_GetUserData(
6359 reverb3d: *mut FMOD_REVERB3D,
6360 userdata: *mut *mut ::std::os::raw::c_void,
6361 ) -> FMOD_RESULT;
6362}
6363unsafe extern "C" {
6364 pub fn FMOD_Channel_CastToControl(channel: *mut FMOD_CHANNEL) -> *mut FMOD_CHANNELCONTROL;
6365}
6366unsafe extern "C" {
6367 pub fn FMOD_ChannelGroup_CastToControl(
6368 group: *mut FMOD_CHANNELGROUP,
6369 ) -> *mut FMOD_CHANNELCONTROL;
6370}
6371unsafe extern "C" {
6372 #[must_use]
6373 pub fn FMOD_ChannelControl_GetSystemObject(
6374 channelcontrol: *mut FMOD_CHANNELCONTROL,
6375 system: *mut *mut FMOD_SYSTEM,
6376 ) -> FMOD_RESULT;
6377}
6378unsafe extern "C" {
6379 #[must_use]
6380 pub fn FMOD_ChannelControl_Stop(channelcontrol: *mut FMOD_CHANNELCONTROL) -> FMOD_RESULT;
6381}
6382unsafe extern "C" {
6383 #[must_use]
6384 pub fn FMOD_ChannelControl_SetPaused(
6385 channelcontrol: *mut FMOD_CHANNELCONTROL,
6386 paused: bool,
6387 ) -> FMOD_RESULT;
6388}
6389unsafe extern "C" {
6390 #[must_use]
6391 pub fn FMOD_ChannelControl_GetPaused(
6392 channelcontrol: *mut FMOD_CHANNELCONTROL,
6393 paused: *mut bool,
6394 ) -> FMOD_RESULT;
6395}
6396unsafe extern "C" {
6397 #[must_use]
6398 pub fn FMOD_ChannelControl_SetVolume(
6399 channelcontrol: *mut FMOD_CHANNELCONTROL,
6400 volume: f32,
6401 ) -> FMOD_RESULT;
6402}
6403unsafe extern "C" {
6404 #[must_use]
6405 pub fn FMOD_ChannelControl_GetVolume(
6406 channelcontrol: *mut FMOD_CHANNELCONTROL,
6407 volume: *mut f32,
6408 ) -> FMOD_RESULT;
6409}
6410unsafe extern "C" {
6411 #[must_use]
6412 pub fn FMOD_ChannelControl_SetVolumeRamp(
6413 channelcontrol: *mut FMOD_CHANNELCONTROL,
6414 ramp: bool,
6415 ) -> FMOD_RESULT;
6416}
6417unsafe extern "C" {
6418 #[must_use]
6419 pub fn FMOD_ChannelControl_GetVolumeRamp(
6420 channelcontrol: *mut FMOD_CHANNELCONTROL,
6421 ramp: *mut bool,
6422 ) -> FMOD_RESULT;
6423}
6424unsafe extern "C" {
6425 #[must_use]
6426 pub fn FMOD_ChannelControl_GetAudibility(
6427 channelcontrol: *mut FMOD_CHANNELCONTROL,
6428 audibility: *mut f32,
6429 ) -> FMOD_RESULT;
6430}
6431unsafe extern "C" {
6432 #[must_use]
6433 pub fn FMOD_ChannelControl_SetPitch(
6434 channelcontrol: *mut FMOD_CHANNELCONTROL,
6435 pitch: f32,
6436 ) -> FMOD_RESULT;
6437}
6438unsafe extern "C" {
6439 #[must_use]
6440 pub fn FMOD_ChannelControl_GetPitch(
6441 channelcontrol: *mut FMOD_CHANNELCONTROL,
6442 pitch: *mut f32,
6443 ) -> FMOD_RESULT;
6444}
6445unsafe extern "C" {
6446 #[must_use]
6447 pub fn FMOD_ChannelControl_SetMute(
6448 channelcontrol: *mut FMOD_CHANNELCONTROL,
6449 mute: bool,
6450 ) -> FMOD_RESULT;
6451}
6452unsafe extern "C" {
6453 #[must_use]
6454 pub fn FMOD_ChannelControl_GetMute(
6455 channelcontrol: *mut FMOD_CHANNELCONTROL,
6456 mute: *mut bool,
6457 ) -> FMOD_RESULT;
6458}
6459unsafe extern "C" {
6460 #[must_use]
6461 pub fn FMOD_ChannelControl_SetReverbProperties(
6462 channelcontrol: *mut FMOD_CHANNELCONTROL,
6463 instance: ::std::os::raw::c_int,
6464 wet: f32,
6465 ) -> FMOD_RESULT;
6466}
6467unsafe extern "C" {
6468 #[must_use]
6469 pub fn FMOD_ChannelControl_GetReverbProperties(
6470 channelcontrol: *mut FMOD_CHANNELCONTROL,
6471 instance: ::std::os::raw::c_int,
6472 wet: *mut f32,
6473 ) -> FMOD_RESULT;
6474}
6475unsafe extern "C" {
6476 #[must_use]
6477 pub fn FMOD_ChannelControl_SetLowPassGain(
6478 channelcontrol: *mut FMOD_CHANNELCONTROL,
6479 gain: f32,
6480 ) -> FMOD_RESULT;
6481}
6482unsafe extern "C" {
6483 #[must_use]
6484 pub fn FMOD_ChannelControl_GetLowPassGain(
6485 channelcontrol: *mut FMOD_CHANNELCONTROL,
6486 gain: *mut f32,
6487 ) -> FMOD_RESULT;
6488}
6489unsafe extern "C" {
6490 #[must_use]
6491 pub fn FMOD_ChannelControl_SetMode(
6492 channelcontrol: *mut FMOD_CHANNELCONTROL,
6493 mode: FMOD_MODE,
6494 ) -> FMOD_RESULT;
6495}
6496unsafe extern "C" {
6497 #[must_use]
6498 pub fn FMOD_ChannelControl_GetMode(
6499 channelcontrol: *mut FMOD_CHANNELCONTROL,
6500 mode: *mut FMOD_MODE,
6501 ) -> FMOD_RESULT;
6502}
6503unsafe extern "C" {
6504 #[must_use]
6505 pub fn FMOD_ChannelControl_SetCallback(
6506 channelcontrol: *mut FMOD_CHANNELCONTROL,
6507 callback: FMOD_CHANNELCONTROL_CALLBACK,
6508 ) -> FMOD_RESULT;
6509}
6510unsafe extern "C" {
6511 #[must_use]
6512 pub fn FMOD_ChannelControl_IsPlaying(
6513 channelcontrol: *mut FMOD_CHANNELCONTROL,
6514 isplaying: *mut bool,
6515 ) -> FMOD_RESULT;
6516}
6517unsafe extern "C" {
6518 #[must_use]
6519 pub fn FMOD_ChannelControl_SetPan(
6520 channelcontrol: *mut FMOD_CHANNELCONTROL,
6521 pan: f32,
6522 ) -> FMOD_RESULT;
6523}
6524unsafe extern "C" {
6525 #[must_use]
6526 pub fn FMOD_ChannelControl_SetMixLevelsOutput(
6527 channelcontrol: *mut FMOD_CHANNELCONTROL,
6528 frontleft: f32,
6529 frontright: f32,
6530 center: f32,
6531 lfe: f32,
6532 surroundleft: f32,
6533 surroundright: f32,
6534 backleft: f32,
6535 backright: f32,
6536 ) -> FMOD_RESULT;
6537}
6538unsafe extern "C" {
6539 #[must_use]
6540 pub fn FMOD_ChannelControl_SetMixLevelsInput(
6541 channelcontrol: *mut FMOD_CHANNELCONTROL,
6542 levels: *mut f32,
6543 numlevels: ::std::os::raw::c_int,
6544 ) -> FMOD_RESULT;
6545}
6546unsafe extern "C" {
6547 #[must_use]
6548 pub fn FMOD_ChannelControl_SetMixMatrix(
6549 channelcontrol: *mut FMOD_CHANNELCONTROL,
6550 matrix: *mut f32,
6551 outchannels: ::std::os::raw::c_int,
6552 inchannels: ::std::os::raw::c_int,
6553 inchannel_hop: ::std::os::raw::c_int,
6554 ) -> FMOD_RESULT;
6555}
6556unsafe extern "C" {
6557 #[must_use]
6558 pub fn FMOD_ChannelControl_GetMixMatrix(
6559 channelcontrol: *mut FMOD_CHANNELCONTROL,
6560 matrix: *mut f32,
6561 outchannels: *mut ::std::os::raw::c_int,
6562 inchannels: *mut ::std::os::raw::c_int,
6563 inchannel_hop: ::std::os::raw::c_int,
6564 ) -> FMOD_RESULT;
6565}
6566unsafe extern "C" {
6567 #[must_use]
6568 pub fn FMOD_ChannelControl_GetDSPClock(
6569 channelcontrol: *mut FMOD_CHANNELCONTROL,
6570 dspclock: *mut ::std::os::raw::c_ulonglong,
6571 parentclock: *mut ::std::os::raw::c_ulonglong,
6572 ) -> FMOD_RESULT;
6573}
6574unsafe extern "C" {
6575 #[must_use]
6576 pub fn FMOD_ChannelControl_SetDelay(
6577 channelcontrol: *mut FMOD_CHANNELCONTROL,
6578 dspclock_start: ::std::os::raw::c_ulonglong,
6579 dspclock_end: ::std::os::raw::c_ulonglong,
6580 stopchannels: bool,
6581 ) -> FMOD_RESULT;
6582}
6583unsafe extern "C" {
6584 #[must_use]
6585 pub fn FMOD_ChannelControl_GetDelay(
6586 channelcontrol: *mut FMOD_CHANNELCONTROL,
6587 dspclock_start: *mut ::std::os::raw::c_ulonglong,
6588 dspclock_end: *mut ::std::os::raw::c_ulonglong,
6589 stopchannels: *mut bool,
6590 ) -> FMOD_RESULT;
6591}
6592unsafe extern "C" {
6593 #[must_use]
6594 pub fn FMOD_ChannelControl_AddFadePoint(
6595 channelcontrol: *mut FMOD_CHANNELCONTROL,
6596 dspclock: ::std::os::raw::c_ulonglong,
6597 volume: f32,
6598 ) -> FMOD_RESULT;
6599}
6600unsafe extern "C" {
6601 #[must_use]
6602 pub fn FMOD_ChannelControl_SetFadePointRamp(
6603 channelcontrol: *mut FMOD_CHANNELCONTROL,
6604 dspclock: ::std::os::raw::c_ulonglong,
6605 volume: f32,
6606 ) -> FMOD_RESULT;
6607}
6608unsafe extern "C" {
6609 #[must_use]
6610 pub fn FMOD_ChannelControl_RemoveFadePoints(
6611 channelcontrol: *mut FMOD_CHANNELCONTROL,
6612 dspclock_start: ::std::os::raw::c_ulonglong,
6613 dspclock_end: ::std::os::raw::c_ulonglong,
6614 ) -> FMOD_RESULT;
6615}
6616unsafe extern "C" {
6617 #[must_use]
6618 pub fn FMOD_ChannelControl_GetFadePoints(
6619 channelcontrol: *mut FMOD_CHANNELCONTROL,
6620 numpoints: *mut ::std::os::raw::c_uint,
6621 point_dspclock: *mut ::std::os::raw::c_ulonglong,
6622 point_volume: *mut f32,
6623 ) -> FMOD_RESULT;
6624}
6625unsafe extern "C" {
6626 #[must_use]
6627 pub fn FMOD_ChannelControl_GetDSP(
6628 channelcontrol: *mut FMOD_CHANNELCONTROL,
6629 index: ::std::os::raw::c_int,
6630 dsp: *mut *mut FMOD_DSP,
6631 ) -> FMOD_RESULT;
6632}
6633unsafe extern "C" {
6634 #[must_use]
6635 pub fn FMOD_ChannelControl_AddDSP(
6636 channelcontrol: *mut FMOD_CHANNELCONTROL,
6637 index: ::std::os::raw::c_int,
6638 dsp: *mut FMOD_DSP,
6639 ) -> FMOD_RESULT;
6640}
6641unsafe extern "C" {
6642 #[must_use]
6643 pub fn FMOD_ChannelControl_RemoveDSP(
6644 channelcontrol: *mut FMOD_CHANNELCONTROL,
6645 dsp: *mut FMOD_DSP,
6646 ) -> FMOD_RESULT;
6647}
6648unsafe extern "C" {
6649 #[must_use]
6650 pub fn FMOD_ChannelControl_GetNumDSPs(
6651 channelcontrol: *mut FMOD_CHANNELCONTROL,
6652 numdsps: *mut ::std::os::raw::c_int,
6653 ) -> FMOD_RESULT;
6654}
6655unsafe extern "C" {
6656 #[must_use]
6657 pub fn FMOD_ChannelControl_SetDSPIndex(
6658 channelcontrol: *mut FMOD_CHANNELCONTROL,
6659 dsp: *mut FMOD_DSP,
6660 index: ::std::os::raw::c_int,
6661 ) -> FMOD_RESULT;
6662}
6663unsafe extern "C" {
6664 #[must_use]
6665 pub fn FMOD_ChannelControl_GetDSPIndex(
6666 channelcontrol: *mut FMOD_CHANNELCONTROL,
6667 dsp: *mut FMOD_DSP,
6668 index: *mut ::std::os::raw::c_int,
6669 ) -> FMOD_RESULT;
6670}
6671unsafe extern "C" {
6672 #[must_use]
6673 pub fn FMOD_ChannelControl_Set3DAttributes(
6674 channelcontrol: *mut FMOD_CHANNELCONTROL,
6675 pos: *const FMOD_VECTOR,
6676 vel: *const FMOD_VECTOR,
6677 ) -> FMOD_RESULT;
6678}
6679unsafe extern "C" {
6680 #[must_use]
6681 pub fn FMOD_ChannelControl_Get3DAttributes(
6682 channelcontrol: *mut FMOD_CHANNELCONTROL,
6683 pos: *mut FMOD_VECTOR,
6684 vel: *mut FMOD_VECTOR,
6685 ) -> FMOD_RESULT;
6686}
6687unsafe extern "C" {
6688 #[must_use]
6689 pub fn FMOD_ChannelControl_Set3DMinMaxDistance(
6690 channelcontrol: *mut FMOD_CHANNELCONTROL,
6691 mindistance: f32,
6692 maxdistance: f32,
6693 ) -> FMOD_RESULT;
6694}
6695unsafe extern "C" {
6696 #[must_use]
6697 pub fn FMOD_ChannelControl_Get3DMinMaxDistance(
6698 channelcontrol: *mut FMOD_CHANNELCONTROL,
6699 mindistance: *mut f32,
6700 maxdistance: *mut f32,
6701 ) -> FMOD_RESULT;
6702}
6703unsafe extern "C" {
6704 #[must_use]
6705 pub fn FMOD_ChannelControl_Set3DConeSettings(
6706 channelcontrol: *mut FMOD_CHANNELCONTROL,
6707 insideconeangle: f32,
6708 outsideconeangle: f32,
6709 outsidevolume: f32,
6710 ) -> FMOD_RESULT;
6711}
6712unsafe extern "C" {
6713 #[must_use]
6714 pub fn FMOD_ChannelControl_Get3DConeSettings(
6715 channelcontrol: *mut FMOD_CHANNELCONTROL,
6716 insideconeangle: *mut f32,
6717 outsideconeangle: *mut f32,
6718 outsidevolume: *mut f32,
6719 ) -> FMOD_RESULT;
6720}
6721unsafe extern "C" {
6722 #[must_use]
6723 pub fn FMOD_ChannelControl_Set3DConeOrientation(
6724 channelcontrol: *mut FMOD_CHANNELCONTROL,
6725 orientation: *mut FMOD_VECTOR,
6726 ) -> FMOD_RESULT;
6727}
6728unsafe extern "C" {
6729 #[must_use]
6730 pub fn FMOD_ChannelControl_Get3DConeOrientation(
6731 channelcontrol: *mut FMOD_CHANNELCONTROL,
6732 orientation: *mut FMOD_VECTOR,
6733 ) -> FMOD_RESULT;
6734}
6735unsafe extern "C" {
6736 #[must_use]
6737 pub fn FMOD_ChannelControl_Set3DCustomRolloff(
6738 channelcontrol: *mut FMOD_CHANNELCONTROL,
6739 points: *mut FMOD_VECTOR,
6740 numpoints: ::std::os::raw::c_int,
6741 ) -> FMOD_RESULT;
6742}
6743unsafe extern "C" {
6744 #[must_use]
6745 pub fn FMOD_ChannelControl_Get3DCustomRolloff(
6746 channelcontrol: *mut FMOD_CHANNELCONTROL,
6747 points: *mut *mut FMOD_VECTOR,
6748 numpoints: *mut ::std::os::raw::c_int,
6749 ) -> FMOD_RESULT;
6750}
6751unsafe extern "C" {
6752 #[must_use]
6753 pub fn FMOD_ChannelControl_Set3DOcclusion(
6754 channelcontrol: *mut FMOD_CHANNELCONTROL,
6755 directocclusion: f32,
6756 reverbocclusion: f32,
6757 ) -> FMOD_RESULT;
6758}
6759unsafe extern "C" {
6760 #[must_use]
6761 pub fn FMOD_ChannelControl_Get3DOcclusion(
6762 channelcontrol: *mut FMOD_CHANNELCONTROL,
6763 directocclusion: *mut f32,
6764 reverbocclusion: *mut f32,
6765 ) -> FMOD_RESULT;
6766}
6767unsafe extern "C" {
6768 #[must_use]
6769 pub fn FMOD_ChannelControl_Set3DSpread(
6770 channelcontrol: *mut FMOD_CHANNELCONTROL,
6771 angle: f32,
6772 ) -> FMOD_RESULT;
6773}
6774unsafe extern "C" {
6775 #[must_use]
6776 pub fn FMOD_ChannelControl_Get3DSpread(
6777 channelcontrol: *mut FMOD_CHANNELCONTROL,
6778 angle: *mut f32,
6779 ) -> FMOD_RESULT;
6780}
6781unsafe extern "C" {
6782 #[must_use]
6783 pub fn FMOD_ChannelControl_Set3DLevel(
6784 channelcontrol: *mut FMOD_CHANNELCONTROL,
6785 level: f32,
6786 ) -> FMOD_RESULT;
6787}
6788unsafe extern "C" {
6789 #[must_use]
6790 pub fn FMOD_ChannelControl_Get3DLevel(
6791 channelcontrol: *mut FMOD_CHANNELCONTROL,
6792 level: *mut f32,
6793 ) -> FMOD_RESULT;
6794}
6795unsafe extern "C" {
6796 #[must_use]
6797 pub fn FMOD_ChannelControl_Set3DDopplerLevel(
6798 channelcontrol: *mut FMOD_CHANNELCONTROL,
6799 level: f32,
6800 ) -> FMOD_RESULT;
6801}
6802unsafe extern "C" {
6803 #[must_use]
6804 pub fn FMOD_ChannelControl_Get3DDopplerLevel(
6805 channelcontrol: *mut FMOD_CHANNELCONTROL,
6806 level: *mut f32,
6807 ) -> FMOD_RESULT;
6808}
6809unsafe extern "C" {
6810 #[must_use]
6811 pub fn FMOD_ChannelControl_Set3DDistanceFilter(
6812 channelcontrol: *mut FMOD_CHANNELCONTROL,
6813 custom: bool,
6814 customLevel: f32,
6815 centerFreq: f32,
6816 ) -> FMOD_RESULT;
6817}
6818unsafe extern "C" {
6819 #[must_use]
6820 pub fn FMOD_ChannelControl_Get3DDistanceFilter(
6821 channelcontrol: *mut FMOD_CHANNELCONTROL,
6822 custom: *mut bool,
6823 customLevel: *mut f32,
6824 centerFreq: *mut f32,
6825 ) -> FMOD_RESULT;
6826}
6827unsafe extern "C" {
6828 #[must_use]
6829 pub fn FMOD_ChannelControl_SetUserData(
6830 channelcontrol: *mut FMOD_CHANNELCONTROL,
6831 userdata: *mut ::std::os::raw::c_void,
6832 ) -> FMOD_RESULT;
6833}
6834unsafe extern "C" {
6835 #[must_use]
6836 pub fn FMOD_ChannelControl_GetUserData(
6837 channelcontrol: *mut FMOD_CHANNELCONTROL,
6838 userdata: *mut *mut ::std::os::raw::c_void,
6839 ) -> FMOD_RESULT;
6840}
6841#[repr(C)]
6842#[derive(Debug, Copy, Clone)]
6843pub struct FMOD_STUDIO_SYSTEM {
6844 _unused: [u8; 0],
6845}
6846#[repr(C)]
6847#[derive(Debug, Copy, Clone)]
6848pub struct FMOD_STUDIO_EVENTDESCRIPTION {
6849 _unused: [u8; 0],
6850}
6851#[repr(C)]
6852#[derive(Debug, Copy, Clone)]
6853pub struct FMOD_STUDIO_EVENTINSTANCE {
6854 _unused: [u8; 0],
6855}
6856#[repr(C)]
6857#[derive(Debug, Copy, Clone)]
6858pub struct FMOD_STUDIO_BUS {
6859 _unused: [u8; 0],
6860}
6861#[repr(C)]
6862#[derive(Debug, Copy, Clone)]
6863pub struct FMOD_STUDIO_VCA {
6864 _unused: [u8; 0],
6865}
6866#[repr(C)]
6867#[derive(Debug, Copy, Clone)]
6868pub struct FMOD_STUDIO_BANK {
6869 _unused: [u8; 0],
6870}
6871#[repr(C)]
6872#[derive(Debug, Copy, Clone)]
6873pub struct FMOD_STUDIO_COMMANDREPLAY {
6874 _unused: [u8; 0],
6875}
6876pub type FMOD_STUDIO_INITFLAGS = ::std::os::raw::c_uint;
6877pub type FMOD_STUDIO_PARAMETER_FLAGS = ::std::os::raw::c_uint;
6878pub type FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
6879pub type FMOD_STUDIO_EVENT_CALLBACK_TYPE = ::std::os::raw::c_uint;
6880pub type FMOD_STUDIO_LOAD_BANK_FLAGS = ::std::os::raw::c_uint;
6881pub type FMOD_STUDIO_COMMANDCAPTURE_FLAGS = ::std::os::raw::c_uint;
6882pub type FMOD_STUDIO_COMMANDREPLAY_FLAGS = ::std::os::raw::c_uint;
6883pub const FMOD_STUDIO_LOADING_STATE_UNLOADING: FMOD_STUDIO_LOADING_STATE = 0;
6884pub const FMOD_STUDIO_LOADING_STATE_UNLOADED: FMOD_STUDIO_LOADING_STATE = 1;
6885pub const FMOD_STUDIO_LOADING_STATE_LOADING: FMOD_STUDIO_LOADING_STATE = 2;
6886pub const FMOD_STUDIO_LOADING_STATE_LOADED: FMOD_STUDIO_LOADING_STATE = 3;
6887pub const FMOD_STUDIO_LOADING_STATE_ERROR: FMOD_STUDIO_LOADING_STATE = 4;
6888pub const FMOD_STUDIO_LOADING_STATE_FORCEINT: FMOD_STUDIO_LOADING_STATE = 65536;
6889pub type FMOD_STUDIO_LOADING_STATE = ::std::os::raw::c_uint;
6890pub const FMOD_STUDIO_LOAD_MEMORY: FMOD_STUDIO_LOAD_MEMORY_MODE = 0;
6891pub const FMOD_STUDIO_LOAD_MEMORY_POINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 1;
6892pub const FMOD_STUDIO_LOAD_MEMORY_FORCEINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 65536;
6893pub type FMOD_STUDIO_LOAD_MEMORY_MODE = ::std::os::raw::c_uint;
6894pub const FMOD_STUDIO_PARAMETER_GAME_CONTROLLED: FMOD_STUDIO_PARAMETER_TYPE = 0;
6895pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE: FMOD_STUDIO_PARAMETER_TYPE = 1;
6896pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_CONE_ANGLE: FMOD_STUDIO_PARAMETER_TYPE = 2;
6897pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 3;
6898pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DIRECTION: FMOD_STUDIO_PARAMETER_TYPE = 4;
6899pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_ELEVATION: FMOD_STUDIO_PARAMETER_TYPE = 5;
6900pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_LISTENER_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 6;
6901pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED: FMOD_STUDIO_PARAMETER_TYPE = 7;
6902pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED_ABSOLUTE: FMOD_STUDIO_PARAMETER_TYPE = 8;
6903pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE_NORMALIZED: FMOD_STUDIO_PARAMETER_TYPE = 9;
6904pub const FMOD_STUDIO_PARAMETER_MAX: FMOD_STUDIO_PARAMETER_TYPE = 10;
6905pub const FMOD_STUDIO_PARAMETER_FORCEINT: FMOD_STUDIO_PARAMETER_TYPE = 65536;
6906pub type FMOD_STUDIO_PARAMETER_TYPE = ::std::os::raw::c_uint;
6907pub const FMOD_STUDIO_USER_PROPERTY_TYPE_INTEGER: FMOD_STUDIO_USER_PROPERTY_TYPE = 0;
6908pub const FMOD_STUDIO_USER_PROPERTY_TYPE_BOOLEAN: FMOD_STUDIO_USER_PROPERTY_TYPE = 1;
6909pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FLOAT: FMOD_STUDIO_USER_PROPERTY_TYPE = 2;
6910pub const FMOD_STUDIO_USER_PROPERTY_TYPE_STRING: FMOD_STUDIO_USER_PROPERTY_TYPE = 3;
6911pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FORCEINT: FMOD_STUDIO_USER_PROPERTY_TYPE = 65536;
6912pub type FMOD_STUDIO_USER_PROPERTY_TYPE = ::std::os::raw::c_uint;
6913pub const FMOD_STUDIO_EVENT_PROPERTY_CHANNELPRIORITY: FMOD_STUDIO_EVENT_PROPERTY = 0;
6914pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_DELAY: FMOD_STUDIO_EVENT_PROPERTY = 1;
6915pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_LOOKAHEAD: FMOD_STUDIO_EVENT_PROPERTY = 2;
6916pub const FMOD_STUDIO_EVENT_PROPERTY_MINIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 3;
6917pub const FMOD_STUDIO_EVENT_PROPERTY_MAXIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 4;
6918pub const FMOD_STUDIO_EVENT_PROPERTY_COOLDOWN: FMOD_STUDIO_EVENT_PROPERTY = 5;
6919pub const FMOD_STUDIO_EVENT_PROPERTY_MAX: FMOD_STUDIO_EVENT_PROPERTY = 6;
6920pub const FMOD_STUDIO_EVENT_PROPERTY_FORCEINT: FMOD_STUDIO_EVENT_PROPERTY = 65536;
6921pub type FMOD_STUDIO_EVENT_PROPERTY = ::std::os::raw::c_uint;
6922pub const FMOD_STUDIO_PLAYBACK_PLAYING: FMOD_STUDIO_PLAYBACK_STATE = 0;
6923pub const FMOD_STUDIO_PLAYBACK_SUSTAINING: FMOD_STUDIO_PLAYBACK_STATE = 1;
6924pub const FMOD_STUDIO_PLAYBACK_STOPPED: FMOD_STUDIO_PLAYBACK_STATE = 2;
6925pub const FMOD_STUDIO_PLAYBACK_STARTING: FMOD_STUDIO_PLAYBACK_STATE = 3;
6926pub const FMOD_STUDIO_PLAYBACK_STOPPING: FMOD_STUDIO_PLAYBACK_STATE = 4;
6927pub const FMOD_STUDIO_PLAYBACK_FORCEINT: FMOD_STUDIO_PLAYBACK_STATE = 65536;
6928pub type FMOD_STUDIO_PLAYBACK_STATE = ::std::os::raw::c_uint;
6929pub const FMOD_STUDIO_STOP_ALLOWFADEOUT: FMOD_STUDIO_STOP_MODE = 0;
6930pub const FMOD_STUDIO_STOP_IMMEDIATE: FMOD_STUDIO_STOP_MODE = 1;
6931pub const FMOD_STUDIO_STOP_FORCEINT: FMOD_STUDIO_STOP_MODE = 65536;
6932pub type FMOD_STUDIO_STOP_MODE = ::std::os::raw::c_uint;
6933pub const FMOD_STUDIO_INSTANCETYPE_NONE: FMOD_STUDIO_INSTANCETYPE = 0;
6934pub const FMOD_STUDIO_INSTANCETYPE_SYSTEM: FMOD_STUDIO_INSTANCETYPE = 1;
6935pub const FMOD_STUDIO_INSTANCETYPE_EVENTDESCRIPTION: FMOD_STUDIO_INSTANCETYPE = 2;
6936pub const FMOD_STUDIO_INSTANCETYPE_EVENTINSTANCE: FMOD_STUDIO_INSTANCETYPE = 3;
6937pub const FMOD_STUDIO_INSTANCETYPE_PARAMETERINSTANCE: FMOD_STUDIO_INSTANCETYPE = 4;
6938pub const FMOD_STUDIO_INSTANCETYPE_BUS: FMOD_STUDIO_INSTANCETYPE = 5;
6939pub const FMOD_STUDIO_INSTANCETYPE_VCA: FMOD_STUDIO_INSTANCETYPE = 6;
6940pub const FMOD_STUDIO_INSTANCETYPE_BANK: FMOD_STUDIO_INSTANCETYPE = 7;
6941pub const FMOD_STUDIO_INSTANCETYPE_COMMANDREPLAY: FMOD_STUDIO_INSTANCETYPE = 8;
6942pub const FMOD_STUDIO_INSTANCETYPE_FORCEINT: FMOD_STUDIO_INSTANCETYPE = 65536;
6943pub type FMOD_STUDIO_INSTANCETYPE = ::std::os::raw::c_uint;
6944#[repr(C)]
6945#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6946pub struct FMOD_STUDIO_BANK_INFO {
6947 pub size: ::std::os::raw::c_int,
6948 pub userdata: *mut ::std::os::raw::c_void,
6949 pub userdatalength: ::std::os::raw::c_int,
6950 pub opencallback: FMOD_FILE_OPEN_CALLBACK,
6951 pub closecallback: FMOD_FILE_CLOSE_CALLBACK,
6952 pub readcallback: FMOD_FILE_READ_CALLBACK,
6953 pub seekcallback: FMOD_FILE_SEEK_CALLBACK,
6954}
6955#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6956const _: () = {
6957 ["Size of FMOD_STUDIO_BANK_INFO"][::std::mem::size_of::<FMOD_STUDIO_BANK_INFO>() - 56usize];
6958 ["Alignment of FMOD_STUDIO_BANK_INFO"]
6959 [::std::mem::align_of::<FMOD_STUDIO_BANK_INFO>() - 8usize];
6960 ["Offset of field: FMOD_STUDIO_BANK_INFO::size"]
6961 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, size) - 0usize];
6962 ["Offset of field: FMOD_STUDIO_BANK_INFO::userdata"]
6963 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, userdata) - 8usize];
6964 ["Offset of field: FMOD_STUDIO_BANK_INFO::userdatalength"]
6965 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, userdatalength) - 16usize];
6966 ["Offset of field: FMOD_STUDIO_BANK_INFO::opencallback"]
6967 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, opencallback) - 24usize];
6968 ["Offset of field: FMOD_STUDIO_BANK_INFO::closecallback"]
6969 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, closecallback) - 32usize];
6970 ["Offset of field: FMOD_STUDIO_BANK_INFO::readcallback"]
6971 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, readcallback) - 40usize];
6972 ["Offset of field: FMOD_STUDIO_BANK_INFO::seekcallback"]
6973 [::std::mem::offset_of!(FMOD_STUDIO_BANK_INFO, seekcallback) - 48usize];
6974};
6975impl Default for FMOD_STUDIO_BANK_INFO {
6976 fn default() -> Self {
6977 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6978 unsafe {
6979 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6980 s.assume_init()
6981 }
6982 }
6983}
6984#[repr(C)]
6985#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
6986pub struct FMOD_STUDIO_PARAMETER_ID {
6987 pub data1: ::std::os::raw::c_uint,
6988 pub data2: ::std::os::raw::c_uint,
6989}
6990#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6991const _: () = {
6992 ["Size of FMOD_STUDIO_PARAMETER_ID"]
6993 [::std::mem::size_of::<FMOD_STUDIO_PARAMETER_ID>() - 8usize];
6994 ["Alignment of FMOD_STUDIO_PARAMETER_ID"]
6995 [::std::mem::align_of::<FMOD_STUDIO_PARAMETER_ID>() - 4usize];
6996 ["Offset of field: FMOD_STUDIO_PARAMETER_ID::data1"]
6997 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_ID, data1) - 0usize];
6998 ["Offset of field: FMOD_STUDIO_PARAMETER_ID::data2"]
6999 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_ID, data2) - 4usize];
7000};
7001#[repr(C)]
7002#[derive(Debug, Copy, Clone, PartialEq)]
7003pub struct FMOD_STUDIO_PARAMETER_DESCRIPTION {
7004 pub name: *const ::std::os::raw::c_char,
7005 pub id: FMOD_STUDIO_PARAMETER_ID,
7006 pub minimum: f32,
7007 pub maximum: f32,
7008 pub defaultvalue: f32,
7009 pub type_: FMOD_STUDIO_PARAMETER_TYPE,
7010 pub flags: FMOD_STUDIO_PARAMETER_FLAGS,
7011 pub guid: FMOD_GUID,
7012}
7013#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7014const _: () = {
7015 ["Size of FMOD_STUDIO_PARAMETER_DESCRIPTION"]
7016 [::std::mem::size_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>() - 56usize];
7017 ["Alignment of FMOD_STUDIO_PARAMETER_DESCRIPTION"]
7018 [::std::mem::align_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>() - 8usize];
7019 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::name"]
7020 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, name) - 0usize];
7021 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::id"]
7022 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, id) - 8usize];
7023 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::minimum"]
7024 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, minimum) - 16usize];
7025 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::maximum"]
7026 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, maximum) - 20usize];
7027 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::defaultvalue"]
7028 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, defaultvalue) - 24usize];
7029 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::type_"]
7030 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, type_) - 28usize];
7031 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::flags"]
7032 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, flags) - 32usize];
7033 ["Offset of field: FMOD_STUDIO_PARAMETER_DESCRIPTION::guid"]
7034 [::std::mem::offset_of!(FMOD_STUDIO_PARAMETER_DESCRIPTION, guid) - 36usize];
7035};
7036impl Default for FMOD_STUDIO_PARAMETER_DESCRIPTION {
7037 fn default() -> Self {
7038 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7039 unsafe {
7040 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7041 s.assume_init()
7042 }
7043 }
7044}
7045#[repr(C)]
7046#[derive(Copy, Clone)]
7047pub struct FMOD_STUDIO_USER_PROPERTY {
7048 pub name: *const ::std::os::raw::c_char,
7049 pub type_: FMOD_STUDIO_USER_PROPERTY_TYPE,
7050 pub __bindgen_anon_1: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1,
7051}
7052#[repr(C)]
7053#[derive(Copy, Clone)]
7054pub union FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
7055 pub intvalue: ::std::os::raw::c_int,
7056 pub boolvalue: FMOD_BOOL,
7057 pub floatvalue: f32,
7058 pub stringvalue: *const ::std::os::raw::c_char,
7059}
7060#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7061const _: () = {
7062 ["Size of FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1"]
7063 [::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>() - 8usize];
7064 ["Alignment of FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1"]
7065 [::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>() - 8usize];
7066 ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::intvalue"]
7067 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, intvalue) - 0usize];
7068 ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::boolvalue"]
7069 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, boolvalue) - 0usize];
7070 ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::floatvalue"]
7071 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, floatvalue) - 0usize];
7072 ["Offset of field: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1::stringvalue"]
7073 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1, stringvalue) - 0usize];
7074};
7075impl Default for FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
7076 fn default() -> Self {
7077 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7078 unsafe {
7079 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7080 s.assume_init()
7081 }
7082 }
7083}
7084#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7085const _: () = {
7086 ["Size of FMOD_STUDIO_USER_PROPERTY"]
7087 [::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY>() - 24usize];
7088 ["Alignment of FMOD_STUDIO_USER_PROPERTY"]
7089 [::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY>() - 8usize];
7090 ["Offset of field: FMOD_STUDIO_USER_PROPERTY::name"]
7091 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY, name) - 0usize];
7092 ["Offset of field: FMOD_STUDIO_USER_PROPERTY::type_"]
7093 [::std::mem::offset_of!(FMOD_STUDIO_USER_PROPERTY, type_) - 8usize];
7094};
7095impl Default for FMOD_STUDIO_USER_PROPERTY {
7096 fn default() -> Self {
7097 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7098 unsafe {
7099 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7100 s.assume_init()
7101 }
7102 }
7103}
7104#[repr(C)]
7105#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7106pub struct FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
7107 pub name: *const ::std::os::raw::c_char,
7108 pub sound: *mut FMOD_SOUND,
7109 pub subsoundIndex: ::std::os::raw::c_int,
7110}
7111#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7112const _: () = {
7113 ["Size of FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES"]
7114 [::std::mem::size_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>() - 24usize];
7115 ["Alignment of FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES"]
7116 [::std::mem::align_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>() - 8usize];
7117 ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::name"]
7118 [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, name) - 0usize];
7119 ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::sound"]
7120 [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, sound) - 8usize];
7121 ["Offset of field: FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES::subsoundIndex"]
7122 [::std::mem::offset_of!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES, subsoundIndex) - 16usize];
7123};
7124impl Default for FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
7125 fn default() -> Self {
7126 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7127 unsafe {
7128 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7129 s.assume_init()
7130 }
7131 }
7132}
7133#[repr(C)]
7134#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7135pub struct FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
7136 pub name: *const ::std::os::raw::c_char,
7137 pub dsp: *mut FMOD_DSP,
7138}
7139#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7140const _: () = {
7141 ["Size of FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES"]
7142 [::std::mem::size_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>() - 16usize];
7143 ["Alignment of FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES"]
7144 [::std::mem::align_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>() - 8usize];
7145 ["Offset of field: FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES::name"]
7146 [::std::mem::offset_of!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES, name) - 0usize];
7147 ["Offset of field: FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES::dsp"]
7148 [::std::mem::offset_of!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES, dsp) - 8usize];
7149};
7150impl Default for FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
7151 fn default() -> Self {
7152 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7153 unsafe {
7154 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7155 s.assume_init()
7156 }
7157 }
7158}
7159#[repr(C)]
7160#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7161pub struct FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
7162 pub name: *const ::std::os::raw::c_char,
7163 pub position: ::std::os::raw::c_int,
7164}
7165#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7166const _: () = {
7167 ["Size of FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES"]
7168 [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>() - 16usize];
7169 ["Alignment of FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES"]
7170 [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>() - 8usize];
7171 ["Offset of field: FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES::name"]
7172 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES, name) - 0usize];
7173 ["Offset of field: FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES::position"]
7174 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES, position) - 8usize];
7175};
7176impl Default for FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
7177 fn default() -> Self {
7178 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7179 unsafe {
7180 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7181 s.assume_init()
7182 }
7183 }
7184}
7185#[repr(C)]
7186#[derive(Debug, Default, Copy, Clone, PartialEq)]
7187pub struct FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
7188 pub bar: ::std::os::raw::c_int,
7189 pub beat: ::std::os::raw::c_int,
7190 pub position: ::std::os::raw::c_int,
7191 pub tempo: f32,
7192 pub timesignatureupper: ::std::os::raw::c_int,
7193 pub timesignaturelower: ::std::os::raw::c_int,
7194}
7195#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7196const _: () = {
7197 ["Size of FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES"]
7198 [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>() - 24usize];
7199 ["Alignment of FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES"]
7200 [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>() - 4usize];
7201 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::bar"]
7202 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, bar) - 0usize];
7203 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::beat"]
7204 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, beat) - 4usize];
7205 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::position"]
7206 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, position) - 8usize];
7207 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::tempo"]
7208 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES, tempo) - 12usize];
7209 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::timesignatureupper"][::std::mem::offset_of!(
7210 FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
7211 timesignatureupper
7212 ) - 16usize];
7213 ["Offset of field: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES::timesignaturelower"][::std::mem::offset_of!(
7214 FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
7215 timesignaturelower
7216 ) - 20usize];
7217};
7218#[repr(C)]
7219#[derive(Debug, Default, Copy, Clone, PartialEq)]
7220pub struct FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
7221 pub eventid: FMOD_GUID,
7222 pub properties: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
7223}
7224#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7225const _: () = {
7226 ["Size of FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES"]
7227 [::std::mem::size_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>() - 40usize];
7228 ["Alignment of FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES"]
7229 [::std::mem::align_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>() - 4usize];
7230 ["Offset of field: FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES::eventid"]
7231 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES, eventid) - 0usize];
7232 ["Offset of field: FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES::properties"]
7233 [::std::mem::offset_of!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES, properties) - 16usize];
7234};
7235#[repr(C)]
7236#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7237pub struct FMOD_STUDIO_ADVANCEDSETTINGS {
7238 pub cbsize: ::std::os::raw::c_int,
7239 pub commandqueuesize: ::std::os::raw::c_uint,
7240 pub handleinitialsize: ::std::os::raw::c_uint,
7241 pub studioupdateperiod: ::std::os::raw::c_int,
7242 pub idlesampledatapoolsize: ::std::os::raw::c_int,
7243 pub streamingscheduledelay: ::std::os::raw::c_uint,
7244 pub encryptionkey: *const ::std::os::raw::c_char,
7245}
7246#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7247const _: () = {
7248 ["Size of FMOD_STUDIO_ADVANCEDSETTINGS"]
7249 [::std::mem::size_of::<FMOD_STUDIO_ADVANCEDSETTINGS>() - 32usize];
7250 ["Alignment of FMOD_STUDIO_ADVANCEDSETTINGS"]
7251 [::std::mem::align_of::<FMOD_STUDIO_ADVANCEDSETTINGS>() - 8usize];
7252 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::cbsize"]
7253 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, cbsize) - 0usize];
7254 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::commandqueuesize"]
7255 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, commandqueuesize) - 4usize];
7256 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::handleinitialsize"]
7257 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, handleinitialsize) - 8usize];
7258 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::studioupdateperiod"]
7259 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, studioupdateperiod) - 12usize];
7260 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::idlesampledatapoolsize"]
7261 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, idlesampledatapoolsize) - 16usize];
7262 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::streamingscheduledelay"]
7263 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, streamingscheduledelay) - 20usize];
7264 ["Offset of field: FMOD_STUDIO_ADVANCEDSETTINGS::encryptionkey"]
7265 [::std::mem::offset_of!(FMOD_STUDIO_ADVANCEDSETTINGS, encryptionkey) - 24usize];
7266};
7267impl Default for FMOD_STUDIO_ADVANCEDSETTINGS {
7268 fn default() -> Self {
7269 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7270 unsafe {
7271 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7272 s.assume_init()
7273 }
7274 }
7275}
7276#[repr(C)]
7277#[derive(Debug, Default, Copy, Clone, PartialEq)]
7278pub struct FMOD_STUDIO_CPU_USAGE {
7279 pub update: f32,
7280}
7281#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7282const _: () = {
7283 ["Size of FMOD_STUDIO_CPU_USAGE"][::std::mem::size_of::<FMOD_STUDIO_CPU_USAGE>() - 4usize];
7284 ["Alignment of FMOD_STUDIO_CPU_USAGE"]
7285 [::std::mem::align_of::<FMOD_STUDIO_CPU_USAGE>() - 4usize];
7286 ["Offset of field: FMOD_STUDIO_CPU_USAGE::update"]
7287 [::std::mem::offset_of!(FMOD_STUDIO_CPU_USAGE, update) - 0usize];
7288};
7289#[repr(C)]
7290#[derive(Debug, Default, Copy, Clone, PartialEq)]
7291pub struct FMOD_STUDIO_BUFFER_INFO {
7292 pub currentusage: ::std::os::raw::c_int,
7293 pub peakusage: ::std::os::raw::c_int,
7294 pub capacity: ::std::os::raw::c_int,
7295 pub stallcount: ::std::os::raw::c_int,
7296 pub stalltime: f32,
7297}
7298#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7299const _: () = {
7300 ["Size of FMOD_STUDIO_BUFFER_INFO"][::std::mem::size_of::<FMOD_STUDIO_BUFFER_INFO>() - 20usize];
7301 ["Alignment of FMOD_STUDIO_BUFFER_INFO"]
7302 [::std::mem::align_of::<FMOD_STUDIO_BUFFER_INFO>() - 4usize];
7303 ["Offset of field: FMOD_STUDIO_BUFFER_INFO::currentusage"]
7304 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, currentusage) - 0usize];
7305 ["Offset of field: FMOD_STUDIO_BUFFER_INFO::peakusage"]
7306 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, peakusage) - 4usize];
7307 ["Offset of field: FMOD_STUDIO_BUFFER_INFO::capacity"]
7308 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, capacity) - 8usize];
7309 ["Offset of field: FMOD_STUDIO_BUFFER_INFO::stallcount"]
7310 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, stallcount) - 12usize];
7311 ["Offset of field: FMOD_STUDIO_BUFFER_INFO::stalltime"]
7312 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_INFO, stalltime) - 16usize];
7313};
7314#[repr(C)]
7315#[derive(Debug, Default, Copy, Clone, PartialEq)]
7316pub struct FMOD_STUDIO_BUFFER_USAGE {
7317 pub studiocommandqueue: FMOD_STUDIO_BUFFER_INFO,
7318 pub studiohandle: FMOD_STUDIO_BUFFER_INFO,
7319}
7320#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7321const _: () = {
7322 ["Size of FMOD_STUDIO_BUFFER_USAGE"]
7323 [::std::mem::size_of::<FMOD_STUDIO_BUFFER_USAGE>() - 40usize];
7324 ["Alignment of FMOD_STUDIO_BUFFER_USAGE"]
7325 [::std::mem::align_of::<FMOD_STUDIO_BUFFER_USAGE>() - 4usize];
7326 ["Offset of field: FMOD_STUDIO_BUFFER_USAGE::studiocommandqueue"]
7327 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_USAGE, studiocommandqueue) - 0usize];
7328 ["Offset of field: FMOD_STUDIO_BUFFER_USAGE::studiohandle"]
7329 [::std::mem::offset_of!(FMOD_STUDIO_BUFFER_USAGE, studiohandle) - 20usize];
7330};
7331#[repr(C)]
7332#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
7333pub struct FMOD_STUDIO_SOUND_INFO {
7334 pub name_or_data: *const ::std::os::raw::c_char,
7335 pub mode: FMOD_MODE,
7336 pub exinfo: FMOD_CREATESOUNDEXINFO,
7337 pub subsoundindex: ::std::os::raw::c_int,
7338}
7339#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7340const _: () = {
7341 ["Size of FMOD_STUDIO_SOUND_INFO"][::std::mem::size_of::<FMOD_STUDIO_SOUND_INFO>() - 248usize];
7342 ["Alignment of FMOD_STUDIO_SOUND_INFO"]
7343 [::std::mem::align_of::<FMOD_STUDIO_SOUND_INFO>() - 8usize];
7344 ["Offset of field: FMOD_STUDIO_SOUND_INFO::name_or_data"]
7345 [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, name_or_data) - 0usize];
7346 ["Offset of field: FMOD_STUDIO_SOUND_INFO::mode"]
7347 [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, mode) - 8usize];
7348 ["Offset of field: FMOD_STUDIO_SOUND_INFO::exinfo"]
7349 [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, exinfo) - 16usize];
7350 ["Offset of field: FMOD_STUDIO_SOUND_INFO::subsoundindex"]
7351 [::std::mem::offset_of!(FMOD_STUDIO_SOUND_INFO, subsoundindex) - 240usize];
7352};
7353impl Default for FMOD_STUDIO_SOUND_INFO {
7354 fn default() -> Self {
7355 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7356 unsafe {
7357 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7358 s.assume_init()
7359 }
7360 }
7361}
7362#[repr(C)]
7363#[derive(Debug, Copy, Clone, PartialEq)]
7364pub struct FMOD_STUDIO_COMMAND_INFO {
7365 pub commandname: *const ::std::os::raw::c_char,
7366 pub parentcommandindex: ::std::os::raw::c_int,
7367 pub framenumber: ::std::os::raw::c_int,
7368 pub frametime: f32,
7369 pub instancetype: FMOD_STUDIO_INSTANCETYPE,
7370 pub outputtype: FMOD_STUDIO_INSTANCETYPE,
7371 pub instancehandle: ::std::os::raw::c_uint,
7372 pub outputhandle: ::std::os::raw::c_uint,
7373}
7374#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7375const _: () = {
7376 ["Size of FMOD_STUDIO_COMMAND_INFO"]
7377 [::std::mem::size_of::<FMOD_STUDIO_COMMAND_INFO>() - 40usize];
7378 ["Alignment of FMOD_STUDIO_COMMAND_INFO"]
7379 [::std::mem::align_of::<FMOD_STUDIO_COMMAND_INFO>() - 8usize];
7380 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::commandname"]
7381 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, commandname) - 0usize];
7382 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::parentcommandindex"]
7383 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, parentcommandindex) - 8usize];
7384 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::framenumber"]
7385 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, framenumber) - 12usize];
7386 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::frametime"]
7387 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, frametime) - 16usize];
7388 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::instancetype"]
7389 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, instancetype) - 20usize];
7390 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::outputtype"]
7391 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, outputtype) - 24usize];
7392 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::instancehandle"]
7393 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, instancehandle) - 28usize];
7394 ["Offset of field: FMOD_STUDIO_COMMAND_INFO::outputhandle"]
7395 [::std::mem::offset_of!(FMOD_STUDIO_COMMAND_INFO, outputhandle) - 32usize];
7396};
7397impl Default for FMOD_STUDIO_COMMAND_INFO {
7398 fn default() -> Self {
7399 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7400 unsafe {
7401 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7402 s.assume_init()
7403 }
7404 }
7405}
7406#[repr(C)]
7407#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
7408pub struct FMOD_STUDIO_MEMORY_USAGE {
7409 pub exclusive: ::std::os::raw::c_int,
7410 pub inclusive: ::std::os::raw::c_int,
7411 pub sampledata: ::std::os::raw::c_int,
7412}
7413#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7414const _: () = {
7415 ["Size of FMOD_STUDIO_MEMORY_USAGE"]
7416 [::std::mem::size_of::<FMOD_STUDIO_MEMORY_USAGE>() - 12usize];
7417 ["Alignment of FMOD_STUDIO_MEMORY_USAGE"]
7418 [::std::mem::align_of::<FMOD_STUDIO_MEMORY_USAGE>() - 4usize];
7419 ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::exclusive"]
7420 [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, exclusive) - 0usize];
7421 ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::inclusive"]
7422 [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, inclusive) - 4usize];
7423 ["Offset of field: FMOD_STUDIO_MEMORY_USAGE::sampledata"]
7424 [::std::mem::offset_of!(FMOD_STUDIO_MEMORY_USAGE, sampledata) - 8usize];
7425};
7426pub type FMOD_STUDIO_SYSTEM_CALLBACK = ::std::option::Option<
7427 unsafe extern "C" fn(
7428 system: *mut FMOD_STUDIO_SYSTEM,
7429 type_: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
7430 commanddata: *mut ::std::os::raw::c_void,
7431 userdata: *mut ::std::os::raw::c_void,
7432 ) -> FMOD_RESULT,
7433>;
7434pub type FMOD_STUDIO_EVENT_CALLBACK = ::std::option::Option<
7435 unsafe extern "C" fn(
7436 type_: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
7437 event: *mut FMOD_STUDIO_EVENTINSTANCE,
7438 parameters: *mut ::std::os::raw::c_void,
7439 ) -> FMOD_RESULT,
7440>;
7441pub type FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK = ::std::option::Option<
7442 unsafe extern "C" fn(
7443 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
7444 commandindex: ::std::os::raw::c_int,
7445 currenttime: f32,
7446 userdata: *mut ::std::os::raw::c_void,
7447 ) -> FMOD_RESULT,
7448>;
7449pub type FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK = ::std::option::Option<
7450 unsafe extern "C" fn(
7451 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
7452 commandindex: ::std::os::raw::c_int,
7453 bankguid: *const FMOD_GUID,
7454 bankfilename: *const ::std::os::raw::c_char,
7455 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
7456 bank: *mut *mut FMOD_STUDIO_BANK,
7457 userdata: *mut ::std::os::raw::c_void,
7458 ) -> FMOD_RESULT,
7459>;
7460pub type FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK = ::std::option::Option<
7461 unsafe extern "C" fn(
7462 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
7463 commandindex: ::std::os::raw::c_int,
7464 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7465 instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
7466 userdata: *mut ::std::os::raw::c_void,
7467 ) -> FMOD_RESULT,
7468>;
7469unsafe extern "C" {
7470 #[must_use]
7471 pub fn FMOD_Studio_ParseID(
7472 idstring: *const ::std::os::raw::c_char,
7473 id: *mut FMOD_GUID,
7474 ) -> FMOD_RESULT;
7475}
7476unsafe extern "C" {
7477 #[must_use]
7478 pub fn FMOD_Studio_System_Create(
7479 system: *mut *mut FMOD_STUDIO_SYSTEM,
7480 headerversion: ::std::os::raw::c_uint,
7481 ) -> FMOD_RESULT;
7482}
7483unsafe extern "C" {
7484 pub fn FMOD_Studio_System_IsValid(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_BOOL;
7485}
7486unsafe extern "C" {
7487 #[must_use]
7488 pub fn FMOD_Studio_System_SetAdvancedSettings(
7489 system: *mut FMOD_STUDIO_SYSTEM,
7490 settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
7491 ) -> FMOD_RESULT;
7492}
7493unsafe extern "C" {
7494 #[must_use]
7495 pub fn FMOD_Studio_System_GetAdvancedSettings(
7496 system: *mut FMOD_STUDIO_SYSTEM,
7497 settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
7498 ) -> FMOD_RESULT;
7499}
7500unsafe extern "C" {
7501 #[must_use]
7502 pub fn FMOD_Studio_System_Initialize(
7503 system: *mut FMOD_STUDIO_SYSTEM,
7504 maxchannels: ::std::os::raw::c_int,
7505 studioflags: FMOD_STUDIO_INITFLAGS,
7506 flags: FMOD_INITFLAGS,
7507 extradriverdata: *mut ::std::os::raw::c_void,
7508 ) -> FMOD_RESULT;
7509}
7510unsafe extern "C" {
7511 #[must_use]
7512 pub fn FMOD_Studio_System_Release(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7513}
7514unsafe extern "C" {
7515 #[must_use]
7516 pub fn FMOD_Studio_System_Update(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7517}
7518unsafe extern "C" {
7519 #[must_use]
7520 pub fn FMOD_Studio_System_GetCoreSystem(
7521 system: *mut FMOD_STUDIO_SYSTEM,
7522 coresystem: *mut *mut FMOD_SYSTEM,
7523 ) -> FMOD_RESULT;
7524}
7525unsafe extern "C" {
7526 #[must_use]
7527 pub fn FMOD_Studio_System_GetEvent(
7528 system: *mut FMOD_STUDIO_SYSTEM,
7529 pathOrID: *const ::std::os::raw::c_char,
7530 event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
7531 ) -> FMOD_RESULT;
7532}
7533unsafe extern "C" {
7534 #[must_use]
7535 pub fn FMOD_Studio_System_GetBus(
7536 system: *mut FMOD_STUDIO_SYSTEM,
7537 pathOrID: *const ::std::os::raw::c_char,
7538 bus: *mut *mut FMOD_STUDIO_BUS,
7539 ) -> FMOD_RESULT;
7540}
7541unsafe extern "C" {
7542 #[must_use]
7543 pub fn FMOD_Studio_System_GetVCA(
7544 system: *mut FMOD_STUDIO_SYSTEM,
7545 pathOrID: *const ::std::os::raw::c_char,
7546 vca: *mut *mut FMOD_STUDIO_VCA,
7547 ) -> FMOD_RESULT;
7548}
7549unsafe extern "C" {
7550 #[must_use]
7551 pub fn FMOD_Studio_System_GetBank(
7552 system: *mut FMOD_STUDIO_SYSTEM,
7553 pathOrID: *const ::std::os::raw::c_char,
7554 bank: *mut *mut FMOD_STUDIO_BANK,
7555 ) -> FMOD_RESULT;
7556}
7557unsafe extern "C" {
7558 #[must_use]
7559 pub fn FMOD_Studio_System_GetEventByID(
7560 system: *mut FMOD_STUDIO_SYSTEM,
7561 id: *const FMOD_GUID,
7562 event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
7563 ) -> FMOD_RESULT;
7564}
7565unsafe extern "C" {
7566 #[must_use]
7567 pub fn FMOD_Studio_System_GetBusByID(
7568 system: *mut FMOD_STUDIO_SYSTEM,
7569 id: *const FMOD_GUID,
7570 bus: *mut *mut FMOD_STUDIO_BUS,
7571 ) -> FMOD_RESULT;
7572}
7573unsafe extern "C" {
7574 #[must_use]
7575 pub fn FMOD_Studio_System_GetVCAByID(
7576 system: *mut FMOD_STUDIO_SYSTEM,
7577 id: *const FMOD_GUID,
7578 vca: *mut *mut FMOD_STUDIO_VCA,
7579 ) -> FMOD_RESULT;
7580}
7581unsafe extern "C" {
7582 #[must_use]
7583 pub fn FMOD_Studio_System_GetBankByID(
7584 system: *mut FMOD_STUDIO_SYSTEM,
7585 id: *const FMOD_GUID,
7586 bank: *mut *mut FMOD_STUDIO_BANK,
7587 ) -> FMOD_RESULT;
7588}
7589unsafe extern "C" {
7590 #[must_use]
7591 pub fn FMOD_Studio_System_GetSoundInfo(
7592 system: *mut FMOD_STUDIO_SYSTEM,
7593 key: *const ::std::os::raw::c_char,
7594 info: *mut FMOD_STUDIO_SOUND_INFO,
7595 ) -> FMOD_RESULT;
7596}
7597unsafe extern "C" {
7598 #[must_use]
7599 pub fn FMOD_Studio_System_GetParameterDescriptionByName(
7600 system: *mut FMOD_STUDIO_SYSTEM,
7601 name: *const ::std::os::raw::c_char,
7602 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7603 ) -> FMOD_RESULT;
7604}
7605unsafe extern "C" {
7606 #[must_use]
7607 pub fn FMOD_Studio_System_GetParameterDescriptionByID(
7608 system: *mut FMOD_STUDIO_SYSTEM,
7609 id: FMOD_STUDIO_PARAMETER_ID,
7610 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7611 ) -> FMOD_RESULT;
7612}
7613unsafe extern "C" {
7614 #[must_use]
7615 pub fn FMOD_Studio_System_GetParameterLabelByName(
7616 system: *mut FMOD_STUDIO_SYSTEM,
7617 name: *const ::std::os::raw::c_char,
7618 labelindex: ::std::os::raw::c_int,
7619 label: *mut ::std::os::raw::c_char,
7620 size: ::std::os::raw::c_int,
7621 retrieved: *mut ::std::os::raw::c_int,
7622 ) -> FMOD_RESULT;
7623}
7624unsafe extern "C" {
7625 #[must_use]
7626 pub fn FMOD_Studio_System_GetParameterLabelByID(
7627 system: *mut FMOD_STUDIO_SYSTEM,
7628 id: FMOD_STUDIO_PARAMETER_ID,
7629 labelindex: ::std::os::raw::c_int,
7630 label: *mut ::std::os::raw::c_char,
7631 size: ::std::os::raw::c_int,
7632 retrieved: *mut ::std::os::raw::c_int,
7633 ) -> FMOD_RESULT;
7634}
7635unsafe extern "C" {
7636 #[must_use]
7637 pub fn FMOD_Studio_System_GetParameterByID(
7638 system: *mut FMOD_STUDIO_SYSTEM,
7639 id: FMOD_STUDIO_PARAMETER_ID,
7640 value: *mut f32,
7641 finalvalue: *mut f32,
7642 ) -> FMOD_RESULT;
7643}
7644unsafe extern "C" {
7645 #[must_use]
7646 pub fn FMOD_Studio_System_SetParameterByID(
7647 system: *mut FMOD_STUDIO_SYSTEM,
7648 id: FMOD_STUDIO_PARAMETER_ID,
7649 value: f32,
7650 ignoreseekspeed: FMOD_BOOL,
7651 ) -> FMOD_RESULT;
7652}
7653unsafe extern "C" {
7654 #[must_use]
7655 pub fn FMOD_Studio_System_SetParameterByIDWithLabel(
7656 system: *mut FMOD_STUDIO_SYSTEM,
7657 id: FMOD_STUDIO_PARAMETER_ID,
7658 label: *const ::std::os::raw::c_char,
7659 ignoreseekspeed: FMOD_BOOL,
7660 ) -> FMOD_RESULT;
7661}
7662unsafe extern "C" {
7663 #[must_use]
7664 pub fn FMOD_Studio_System_SetParametersByIDs(
7665 system: *mut FMOD_STUDIO_SYSTEM,
7666 ids: *const FMOD_STUDIO_PARAMETER_ID,
7667 values: *mut f32,
7668 count: ::std::os::raw::c_int,
7669 ignoreseekspeed: FMOD_BOOL,
7670 ) -> FMOD_RESULT;
7671}
7672unsafe extern "C" {
7673 #[must_use]
7674 pub fn FMOD_Studio_System_GetParameterByName(
7675 system: *mut FMOD_STUDIO_SYSTEM,
7676 name: *const ::std::os::raw::c_char,
7677 value: *mut f32,
7678 finalvalue: *mut f32,
7679 ) -> FMOD_RESULT;
7680}
7681unsafe extern "C" {
7682 #[must_use]
7683 pub fn FMOD_Studio_System_SetParameterByName(
7684 system: *mut FMOD_STUDIO_SYSTEM,
7685 name: *const ::std::os::raw::c_char,
7686 value: f32,
7687 ignoreseekspeed: FMOD_BOOL,
7688 ) -> FMOD_RESULT;
7689}
7690unsafe extern "C" {
7691 #[must_use]
7692 pub fn FMOD_Studio_System_SetParameterByNameWithLabel(
7693 system: *mut FMOD_STUDIO_SYSTEM,
7694 name: *const ::std::os::raw::c_char,
7695 label: *const ::std::os::raw::c_char,
7696 ignoreseekspeed: FMOD_BOOL,
7697 ) -> FMOD_RESULT;
7698}
7699unsafe extern "C" {
7700 #[must_use]
7701 pub fn FMOD_Studio_System_LookupID(
7702 system: *mut FMOD_STUDIO_SYSTEM,
7703 path: *const ::std::os::raw::c_char,
7704 id: *mut FMOD_GUID,
7705 ) -> FMOD_RESULT;
7706}
7707unsafe extern "C" {
7708 #[must_use]
7709 pub fn FMOD_Studio_System_LookupPath(
7710 system: *mut FMOD_STUDIO_SYSTEM,
7711 id: *const FMOD_GUID,
7712 path: *mut ::std::os::raw::c_char,
7713 size: ::std::os::raw::c_int,
7714 retrieved: *mut ::std::os::raw::c_int,
7715 ) -> FMOD_RESULT;
7716}
7717unsafe extern "C" {
7718 #[must_use]
7719 pub fn FMOD_Studio_System_GetNumListeners(
7720 system: *mut FMOD_STUDIO_SYSTEM,
7721 numlisteners: *mut ::std::os::raw::c_int,
7722 ) -> FMOD_RESULT;
7723}
7724unsafe extern "C" {
7725 #[must_use]
7726 pub fn FMOD_Studio_System_SetNumListeners(
7727 system: *mut FMOD_STUDIO_SYSTEM,
7728 numlisteners: ::std::os::raw::c_int,
7729 ) -> FMOD_RESULT;
7730}
7731unsafe extern "C" {
7732 #[must_use]
7733 pub fn FMOD_Studio_System_GetListenerAttributes(
7734 system: *mut FMOD_STUDIO_SYSTEM,
7735 index: ::std::os::raw::c_int,
7736 attributes: *mut FMOD_3D_ATTRIBUTES,
7737 attenuationposition: *mut FMOD_VECTOR,
7738 ) -> FMOD_RESULT;
7739}
7740unsafe extern "C" {
7741 #[must_use]
7742 pub fn FMOD_Studio_System_SetListenerAttributes(
7743 system: *mut FMOD_STUDIO_SYSTEM,
7744 index: ::std::os::raw::c_int,
7745 attributes: *const FMOD_3D_ATTRIBUTES,
7746 attenuationposition: *const FMOD_VECTOR,
7747 ) -> FMOD_RESULT;
7748}
7749unsafe extern "C" {
7750 #[must_use]
7751 pub fn FMOD_Studio_System_GetListenerWeight(
7752 system: *mut FMOD_STUDIO_SYSTEM,
7753 index: ::std::os::raw::c_int,
7754 weight: *mut f32,
7755 ) -> FMOD_RESULT;
7756}
7757unsafe extern "C" {
7758 #[must_use]
7759 pub fn FMOD_Studio_System_SetListenerWeight(
7760 system: *mut FMOD_STUDIO_SYSTEM,
7761 index: ::std::os::raw::c_int,
7762 weight: f32,
7763 ) -> FMOD_RESULT;
7764}
7765unsafe extern "C" {
7766 #[must_use]
7767 pub fn FMOD_Studio_System_LoadBankFile(
7768 system: *mut FMOD_STUDIO_SYSTEM,
7769 filename: *const ::std::os::raw::c_char,
7770 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
7771 bank: *mut *mut FMOD_STUDIO_BANK,
7772 ) -> FMOD_RESULT;
7773}
7774unsafe extern "C" {
7775 #[must_use]
7776 pub fn FMOD_Studio_System_LoadBankMemory(
7777 system: *mut FMOD_STUDIO_SYSTEM,
7778 buffer: *const ::std::os::raw::c_char,
7779 length: ::std::os::raw::c_int,
7780 mode: FMOD_STUDIO_LOAD_MEMORY_MODE,
7781 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
7782 bank: *mut *mut FMOD_STUDIO_BANK,
7783 ) -> FMOD_RESULT;
7784}
7785unsafe extern "C" {
7786 #[must_use]
7787 pub fn FMOD_Studio_System_LoadBankCustom(
7788 system: *mut FMOD_STUDIO_SYSTEM,
7789 info: *const FMOD_STUDIO_BANK_INFO,
7790 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
7791 bank: *mut *mut FMOD_STUDIO_BANK,
7792 ) -> FMOD_RESULT;
7793}
7794unsafe extern "C" {
7795 #[must_use]
7796 pub fn FMOD_Studio_System_RegisterPlugin(
7797 system: *mut FMOD_STUDIO_SYSTEM,
7798 description: *const FMOD_DSP_DESCRIPTION,
7799 ) -> FMOD_RESULT;
7800}
7801unsafe extern "C" {
7802 #[must_use]
7803 pub fn FMOD_Studio_System_UnregisterPlugin(
7804 system: *mut FMOD_STUDIO_SYSTEM,
7805 name: *const ::std::os::raw::c_char,
7806 ) -> FMOD_RESULT;
7807}
7808unsafe extern "C" {
7809 #[must_use]
7810 pub fn FMOD_Studio_System_UnloadAll(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7811}
7812unsafe extern "C" {
7813 #[must_use]
7814 pub fn FMOD_Studio_System_FlushCommands(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7815}
7816unsafe extern "C" {
7817 #[must_use]
7818 pub fn FMOD_Studio_System_FlushSampleLoading(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7819}
7820unsafe extern "C" {
7821 #[must_use]
7822 pub fn FMOD_Studio_System_StartCommandCapture(
7823 system: *mut FMOD_STUDIO_SYSTEM,
7824 filename: *const ::std::os::raw::c_char,
7825 flags: FMOD_STUDIO_COMMANDCAPTURE_FLAGS,
7826 ) -> FMOD_RESULT;
7827}
7828unsafe extern "C" {
7829 #[must_use]
7830 pub fn FMOD_Studio_System_StopCommandCapture(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7831}
7832unsafe extern "C" {
7833 #[must_use]
7834 pub fn FMOD_Studio_System_LoadCommandReplay(
7835 system: *mut FMOD_STUDIO_SYSTEM,
7836 filename: *const ::std::os::raw::c_char,
7837 flags: FMOD_STUDIO_COMMANDREPLAY_FLAGS,
7838 replay: *mut *mut FMOD_STUDIO_COMMANDREPLAY,
7839 ) -> FMOD_RESULT;
7840}
7841unsafe extern "C" {
7842 #[must_use]
7843 pub fn FMOD_Studio_System_GetBankCount(
7844 system: *mut FMOD_STUDIO_SYSTEM,
7845 count: *mut ::std::os::raw::c_int,
7846 ) -> FMOD_RESULT;
7847}
7848unsafe extern "C" {
7849 #[must_use]
7850 pub fn FMOD_Studio_System_GetBankList(
7851 system: *mut FMOD_STUDIO_SYSTEM,
7852 array: *mut *mut FMOD_STUDIO_BANK,
7853 capacity: ::std::os::raw::c_int,
7854 count: *mut ::std::os::raw::c_int,
7855 ) -> FMOD_RESULT;
7856}
7857unsafe extern "C" {
7858 #[must_use]
7859 pub fn FMOD_Studio_System_GetParameterDescriptionCount(
7860 system: *mut FMOD_STUDIO_SYSTEM,
7861 count: *mut ::std::os::raw::c_int,
7862 ) -> FMOD_RESULT;
7863}
7864unsafe extern "C" {
7865 #[must_use]
7866 pub fn FMOD_Studio_System_GetParameterDescriptionList(
7867 system: *mut FMOD_STUDIO_SYSTEM,
7868 array: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7869 capacity: ::std::os::raw::c_int,
7870 count: *mut ::std::os::raw::c_int,
7871 ) -> FMOD_RESULT;
7872}
7873unsafe extern "C" {
7874 #[must_use]
7875 pub fn FMOD_Studio_System_GetCPUUsage(
7876 system: *mut FMOD_STUDIO_SYSTEM,
7877 usage: *mut FMOD_STUDIO_CPU_USAGE,
7878 usage_core: *mut FMOD_CPU_USAGE,
7879 ) -> FMOD_RESULT;
7880}
7881unsafe extern "C" {
7882 #[must_use]
7883 pub fn FMOD_Studio_System_GetBufferUsage(
7884 system: *mut FMOD_STUDIO_SYSTEM,
7885 usage: *mut FMOD_STUDIO_BUFFER_USAGE,
7886 ) -> FMOD_RESULT;
7887}
7888unsafe extern "C" {
7889 #[must_use]
7890 pub fn FMOD_Studio_System_ResetBufferUsage(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
7891}
7892unsafe extern "C" {
7893 #[must_use]
7894 pub fn FMOD_Studio_System_SetCallback(
7895 system: *mut FMOD_STUDIO_SYSTEM,
7896 callback: FMOD_STUDIO_SYSTEM_CALLBACK,
7897 callbackmask: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
7898 ) -> FMOD_RESULT;
7899}
7900unsafe extern "C" {
7901 #[must_use]
7902 pub fn FMOD_Studio_System_SetUserData(
7903 system: *mut FMOD_STUDIO_SYSTEM,
7904 userdata: *mut ::std::os::raw::c_void,
7905 ) -> FMOD_RESULT;
7906}
7907unsafe extern "C" {
7908 #[must_use]
7909 pub fn FMOD_Studio_System_GetUserData(
7910 system: *mut FMOD_STUDIO_SYSTEM,
7911 userdata: *mut *mut ::std::os::raw::c_void,
7912 ) -> FMOD_RESULT;
7913}
7914unsafe extern "C" {
7915 #[must_use]
7916 pub fn FMOD_Studio_System_GetMemoryUsage(
7917 system: *mut FMOD_STUDIO_SYSTEM,
7918 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
7919 ) -> FMOD_RESULT;
7920}
7921unsafe extern "C" {
7922 pub fn FMOD_Studio_EventDescription_IsValid(
7923 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7924 ) -> FMOD_BOOL;
7925}
7926unsafe extern "C" {
7927 #[must_use]
7928 pub fn FMOD_Studio_EventDescription_GetID(
7929 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7930 id: *mut FMOD_GUID,
7931 ) -> FMOD_RESULT;
7932}
7933unsafe extern "C" {
7934 #[must_use]
7935 pub fn FMOD_Studio_EventDescription_GetPath(
7936 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7937 path: *mut ::std::os::raw::c_char,
7938 size: ::std::os::raw::c_int,
7939 retrieved: *mut ::std::os::raw::c_int,
7940 ) -> FMOD_RESULT;
7941}
7942unsafe extern "C" {
7943 #[must_use]
7944 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionCount(
7945 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7946 count: *mut ::std::os::raw::c_int,
7947 ) -> FMOD_RESULT;
7948}
7949unsafe extern "C" {
7950 #[must_use]
7951 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByIndex(
7952 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7953 index: ::std::os::raw::c_int,
7954 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7955 ) -> FMOD_RESULT;
7956}
7957unsafe extern "C" {
7958 #[must_use]
7959 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByName(
7960 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7961 name: *const ::std::os::raw::c_char,
7962 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7963 ) -> FMOD_RESULT;
7964}
7965unsafe extern "C" {
7966 #[must_use]
7967 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByID(
7968 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7969 id: FMOD_STUDIO_PARAMETER_ID,
7970 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
7971 ) -> FMOD_RESULT;
7972}
7973unsafe extern "C" {
7974 #[must_use]
7975 pub fn FMOD_Studio_EventDescription_GetParameterLabelByIndex(
7976 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7977 index: ::std::os::raw::c_int,
7978 labelindex: ::std::os::raw::c_int,
7979 label: *mut ::std::os::raw::c_char,
7980 size: ::std::os::raw::c_int,
7981 retrieved: *mut ::std::os::raw::c_int,
7982 ) -> FMOD_RESULT;
7983}
7984unsafe extern "C" {
7985 #[must_use]
7986 pub fn FMOD_Studio_EventDescription_GetParameterLabelByName(
7987 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7988 name: *const ::std::os::raw::c_char,
7989 labelindex: ::std::os::raw::c_int,
7990 label: *mut ::std::os::raw::c_char,
7991 size: ::std::os::raw::c_int,
7992 retrieved: *mut ::std::os::raw::c_int,
7993 ) -> FMOD_RESULT;
7994}
7995unsafe extern "C" {
7996 #[must_use]
7997 pub fn FMOD_Studio_EventDescription_GetParameterLabelByID(
7998 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
7999 id: FMOD_STUDIO_PARAMETER_ID,
8000 labelindex: ::std::os::raw::c_int,
8001 label: *mut ::std::os::raw::c_char,
8002 size: ::std::os::raw::c_int,
8003 retrieved: *mut ::std::os::raw::c_int,
8004 ) -> FMOD_RESULT;
8005}
8006unsafe extern "C" {
8007 #[must_use]
8008 pub fn FMOD_Studio_EventDescription_GetUserPropertyCount(
8009 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8010 count: *mut ::std::os::raw::c_int,
8011 ) -> FMOD_RESULT;
8012}
8013unsafe extern "C" {
8014 #[must_use]
8015 pub fn FMOD_Studio_EventDescription_GetUserPropertyByIndex(
8016 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8017 index: ::std::os::raw::c_int,
8018 property: *mut FMOD_STUDIO_USER_PROPERTY,
8019 ) -> FMOD_RESULT;
8020}
8021unsafe extern "C" {
8022 #[must_use]
8023 pub fn FMOD_Studio_EventDescription_GetUserProperty(
8024 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8025 name: *const ::std::os::raw::c_char,
8026 property: *mut FMOD_STUDIO_USER_PROPERTY,
8027 ) -> FMOD_RESULT;
8028}
8029unsafe extern "C" {
8030 #[must_use]
8031 pub fn FMOD_Studio_EventDescription_GetLength(
8032 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8033 length: *mut ::std::os::raw::c_int,
8034 ) -> FMOD_RESULT;
8035}
8036unsafe extern "C" {
8037 #[must_use]
8038 pub fn FMOD_Studio_EventDescription_GetMinMaxDistance(
8039 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8040 min: *mut f32,
8041 max: *mut f32,
8042 ) -> FMOD_RESULT;
8043}
8044unsafe extern "C" {
8045 #[must_use]
8046 pub fn FMOD_Studio_EventDescription_GetSoundSize(
8047 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8048 size: *mut f32,
8049 ) -> FMOD_RESULT;
8050}
8051unsafe extern "C" {
8052 #[must_use]
8053 pub fn FMOD_Studio_EventDescription_IsSnapshot(
8054 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8055 snapshot: *mut FMOD_BOOL,
8056 ) -> FMOD_RESULT;
8057}
8058unsafe extern "C" {
8059 #[must_use]
8060 pub fn FMOD_Studio_EventDescription_IsOneshot(
8061 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8062 oneshot: *mut FMOD_BOOL,
8063 ) -> FMOD_RESULT;
8064}
8065unsafe extern "C" {
8066 #[must_use]
8067 pub fn FMOD_Studio_EventDescription_IsStream(
8068 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8069 isStream: *mut FMOD_BOOL,
8070 ) -> FMOD_RESULT;
8071}
8072unsafe extern "C" {
8073 #[must_use]
8074 pub fn FMOD_Studio_EventDescription_Is3D(
8075 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8076 is3D: *mut FMOD_BOOL,
8077 ) -> FMOD_RESULT;
8078}
8079unsafe extern "C" {
8080 #[must_use]
8081 pub fn FMOD_Studio_EventDescription_IsDopplerEnabled(
8082 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8083 doppler: *mut FMOD_BOOL,
8084 ) -> FMOD_RESULT;
8085}
8086unsafe extern "C" {
8087 #[must_use]
8088 pub fn FMOD_Studio_EventDescription_HasSustainPoint(
8089 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8090 sustainPoint: *mut FMOD_BOOL,
8091 ) -> FMOD_RESULT;
8092}
8093unsafe extern "C" {
8094 #[must_use]
8095 pub fn FMOD_Studio_EventDescription_CreateInstance(
8096 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8097 instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
8098 ) -> FMOD_RESULT;
8099}
8100unsafe extern "C" {
8101 #[must_use]
8102 pub fn FMOD_Studio_EventDescription_GetInstanceCount(
8103 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8104 count: *mut ::std::os::raw::c_int,
8105 ) -> FMOD_RESULT;
8106}
8107unsafe extern "C" {
8108 #[must_use]
8109 pub fn FMOD_Studio_EventDescription_GetInstanceList(
8110 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8111 array: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
8112 capacity: ::std::os::raw::c_int,
8113 count: *mut ::std::os::raw::c_int,
8114 ) -> FMOD_RESULT;
8115}
8116unsafe extern "C" {
8117 #[must_use]
8118 pub fn FMOD_Studio_EventDescription_LoadSampleData(
8119 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8120 ) -> FMOD_RESULT;
8121}
8122unsafe extern "C" {
8123 #[must_use]
8124 pub fn FMOD_Studio_EventDescription_UnloadSampleData(
8125 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8126 ) -> FMOD_RESULT;
8127}
8128unsafe extern "C" {
8129 #[must_use]
8130 pub fn FMOD_Studio_EventDescription_GetSampleLoadingState(
8131 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8132 state: *mut FMOD_STUDIO_LOADING_STATE,
8133 ) -> FMOD_RESULT;
8134}
8135unsafe extern "C" {
8136 #[must_use]
8137 pub fn FMOD_Studio_EventDescription_ReleaseAllInstances(
8138 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8139 ) -> FMOD_RESULT;
8140}
8141unsafe extern "C" {
8142 #[must_use]
8143 pub fn FMOD_Studio_EventDescription_SetCallback(
8144 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8145 callback: FMOD_STUDIO_EVENT_CALLBACK,
8146 callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
8147 ) -> FMOD_RESULT;
8148}
8149unsafe extern "C" {
8150 #[must_use]
8151 pub fn FMOD_Studio_EventDescription_GetUserData(
8152 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8153 userdata: *mut *mut ::std::os::raw::c_void,
8154 ) -> FMOD_RESULT;
8155}
8156unsafe extern "C" {
8157 #[must_use]
8158 pub fn FMOD_Studio_EventDescription_SetUserData(
8159 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
8160 userdata: *mut ::std::os::raw::c_void,
8161 ) -> FMOD_RESULT;
8162}
8163unsafe extern "C" {
8164 pub fn FMOD_Studio_EventInstance_IsValid(
8165 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8166 ) -> FMOD_BOOL;
8167}
8168unsafe extern "C" {
8169 #[must_use]
8170 pub fn FMOD_Studio_EventInstance_GetDescription(
8171 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8172 description: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
8173 ) -> FMOD_RESULT;
8174}
8175unsafe extern "C" {
8176 #[must_use]
8177 pub fn FMOD_Studio_EventInstance_GetSystem(
8178 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8179 system: *mut *mut FMOD_STUDIO_SYSTEM,
8180 ) -> FMOD_RESULT;
8181}
8182unsafe extern "C" {
8183 #[must_use]
8184 pub fn FMOD_Studio_EventInstance_GetVolume(
8185 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8186 volume: *mut f32,
8187 finalvolume: *mut f32,
8188 ) -> FMOD_RESULT;
8189}
8190unsafe extern "C" {
8191 #[must_use]
8192 pub fn FMOD_Studio_EventInstance_SetVolume(
8193 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8194 volume: f32,
8195 ) -> FMOD_RESULT;
8196}
8197unsafe extern "C" {
8198 #[must_use]
8199 pub fn FMOD_Studio_EventInstance_GetPitch(
8200 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8201 pitch: *mut f32,
8202 finalpitch: *mut f32,
8203 ) -> FMOD_RESULT;
8204}
8205unsafe extern "C" {
8206 #[must_use]
8207 pub fn FMOD_Studio_EventInstance_SetPitch(
8208 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8209 pitch: f32,
8210 ) -> FMOD_RESULT;
8211}
8212unsafe extern "C" {
8213 #[must_use]
8214 pub fn FMOD_Studio_EventInstance_Get3DAttributes(
8215 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8216 attributes: *mut FMOD_3D_ATTRIBUTES,
8217 ) -> FMOD_RESULT;
8218}
8219unsafe extern "C" {
8220 #[must_use]
8221 pub fn FMOD_Studio_EventInstance_Set3DAttributes(
8222 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8223 attributes: *mut FMOD_3D_ATTRIBUTES,
8224 ) -> FMOD_RESULT;
8225}
8226unsafe extern "C" {
8227 #[must_use]
8228 pub fn FMOD_Studio_EventInstance_GetListenerMask(
8229 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8230 mask: *mut ::std::os::raw::c_uint,
8231 ) -> FMOD_RESULT;
8232}
8233unsafe extern "C" {
8234 #[must_use]
8235 pub fn FMOD_Studio_EventInstance_SetListenerMask(
8236 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8237 mask: ::std::os::raw::c_uint,
8238 ) -> FMOD_RESULT;
8239}
8240unsafe extern "C" {
8241 #[must_use]
8242 pub fn FMOD_Studio_EventInstance_GetProperty(
8243 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8244 index: FMOD_STUDIO_EVENT_PROPERTY,
8245 value: *mut f32,
8246 ) -> FMOD_RESULT;
8247}
8248unsafe extern "C" {
8249 #[must_use]
8250 pub fn FMOD_Studio_EventInstance_SetProperty(
8251 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8252 index: FMOD_STUDIO_EVENT_PROPERTY,
8253 value: f32,
8254 ) -> FMOD_RESULT;
8255}
8256unsafe extern "C" {
8257 #[must_use]
8258 pub fn FMOD_Studio_EventInstance_GetReverbLevel(
8259 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8260 index: ::std::os::raw::c_int,
8261 level: *mut f32,
8262 ) -> FMOD_RESULT;
8263}
8264unsafe extern "C" {
8265 #[must_use]
8266 pub fn FMOD_Studio_EventInstance_SetReverbLevel(
8267 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8268 index: ::std::os::raw::c_int,
8269 level: f32,
8270 ) -> FMOD_RESULT;
8271}
8272unsafe extern "C" {
8273 #[must_use]
8274 pub fn FMOD_Studio_EventInstance_GetPaused(
8275 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8276 paused: *mut FMOD_BOOL,
8277 ) -> FMOD_RESULT;
8278}
8279unsafe extern "C" {
8280 #[must_use]
8281 pub fn FMOD_Studio_EventInstance_SetPaused(
8282 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8283 paused: FMOD_BOOL,
8284 ) -> FMOD_RESULT;
8285}
8286unsafe extern "C" {
8287 #[must_use]
8288 pub fn FMOD_Studio_EventInstance_Start(
8289 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8290 ) -> FMOD_RESULT;
8291}
8292unsafe extern "C" {
8293 #[must_use]
8294 pub fn FMOD_Studio_EventInstance_Stop(
8295 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8296 mode: FMOD_STUDIO_STOP_MODE,
8297 ) -> FMOD_RESULT;
8298}
8299unsafe extern "C" {
8300 #[must_use]
8301 pub fn FMOD_Studio_EventInstance_GetTimelinePosition(
8302 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8303 position: *mut ::std::os::raw::c_int,
8304 ) -> FMOD_RESULT;
8305}
8306unsafe extern "C" {
8307 #[must_use]
8308 pub fn FMOD_Studio_EventInstance_SetTimelinePosition(
8309 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8310 position: ::std::os::raw::c_int,
8311 ) -> FMOD_RESULT;
8312}
8313unsafe extern "C" {
8314 #[must_use]
8315 pub fn FMOD_Studio_EventInstance_GetPlaybackState(
8316 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8317 state: *mut FMOD_STUDIO_PLAYBACK_STATE,
8318 ) -> FMOD_RESULT;
8319}
8320unsafe extern "C" {
8321 #[must_use]
8322 pub fn FMOD_Studio_EventInstance_GetChannelGroup(
8323 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8324 group: *mut *mut FMOD_CHANNELGROUP,
8325 ) -> FMOD_RESULT;
8326}
8327unsafe extern "C" {
8328 #[must_use]
8329 pub fn FMOD_Studio_EventInstance_GetMinMaxDistance(
8330 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8331 min: *mut f32,
8332 max: *mut f32,
8333 ) -> FMOD_RESULT;
8334}
8335unsafe extern "C" {
8336 #[must_use]
8337 pub fn FMOD_Studio_EventInstance_Release(
8338 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8339 ) -> FMOD_RESULT;
8340}
8341unsafe extern "C" {
8342 #[must_use]
8343 pub fn FMOD_Studio_EventInstance_IsVirtual(
8344 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8345 virtualstate: *mut FMOD_BOOL,
8346 ) -> FMOD_RESULT;
8347}
8348unsafe extern "C" {
8349 #[must_use]
8350 pub fn FMOD_Studio_EventInstance_GetParameterByName(
8351 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8352 name: *const ::std::os::raw::c_char,
8353 value: *mut f32,
8354 finalvalue: *mut f32,
8355 ) -> FMOD_RESULT;
8356}
8357unsafe extern "C" {
8358 #[must_use]
8359 pub fn FMOD_Studio_EventInstance_SetParameterByName(
8360 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8361 name: *const ::std::os::raw::c_char,
8362 value: f32,
8363 ignoreseekspeed: FMOD_BOOL,
8364 ) -> FMOD_RESULT;
8365}
8366unsafe extern "C" {
8367 #[must_use]
8368 pub fn FMOD_Studio_EventInstance_SetParameterByNameWithLabel(
8369 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8370 name: *const ::std::os::raw::c_char,
8371 label: *const ::std::os::raw::c_char,
8372 ignoreseekspeed: FMOD_BOOL,
8373 ) -> FMOD_RESULT;
8374}
8375unsafe extern "C" {
8376 #[must_use]
8377 pub fn FMOD_Studio_EventInstance_GetParameterByID(
8378 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8379 id: FMOD_STUDIO_PARAMETER_ID,
8380 value: *mut f32,
8381 finalvalue: *mut f32,
8382 ) -> FMOD_RESULT;
8383}
8384unsafe extern "C" {
8385 #[must_use]
8386 pub fn FMOD_Studio_EventInstance_SetParameterByID(
8387 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8388 id: FMOD_STUDIO_PARAMETER_ID,
8389 value: f32,
8390 ignoreseekspeed: FMOD_BOOL,
8391 ) -> FMOD_RESULT;
8392}
8393unsafe extern "C" {
8394 #[must_use]
8395 pub fn FMOD_Studio_EventInstance_SetParameterByIDWithLabel(
8396 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8397 id: FMOD_STUDIO_PARAMETER_ID,
8398 label: *const ::std::os::raw::c_char,
8399 ignoreseekspeed: FMOD_BOOL,
8400 ) -> FMOD_RESULT;
8401}
8402unsafe extern "C" {
8403 #[must_use]
8404 pub fn FMOD_Studio_EventInstance_SetParametersByIDs(
8405 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8406 ids: *const FMOD_STUDIO_PARAMETER_ID,
8407 values: *mut f32,
8408 count: ::std::os::raw::c_int,
8409 ignoreseekspeed: FMOD_BOOL,
8410 ) -> FMOD_RESULT;
8411}
8412unsafe extern "C" {
8413 #[must_use]
8414 pub fn FMOD_Studio_EventInstance_KeyOff(
8415 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8416 ) -> FMOD_RESULT;
8417}
8418unsafe extern "C" {
8419 #[must_use]
8420 pub fn FMOD_Studio_EventInstance_SetCallback(
8421 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8422 callback: FMOD_STUDIO_EVENT_CALLBACK,
8423 callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
8424 ) -> FMOD_RESULT;
8425}
8426unsafe extern "C" {
8427 #[must_use]
8428 pub fn FMOD_Studio_EventInstance_GetUserData(
8429 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8430 userdata: *mut *mut ::std::os::raw::c_void,
8431 ) -> FMOD_RESULT;
8432}
8433unsafe extern "C" {
8434 #[must_use]
8435 pub fn FMOD_Studio_EventInstance_SetUserData(
8436 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8437 userdata: *mut ::std::os::raw::c_void,
8438 ) -> FMOD_RESULT;
8439}
8440unsafe extern "C" {
8441 #[must_use]
8442 pub fn FMOD_Studio_EventInstance_GetCPUUsage(
8443 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8444 exclusive: *mut ::std::os::raw::c_uint,
8445 inclusive: *mut ::std::os::raw::c_uint,
8446 ) -> FMOD_RESULT;
8447}
8448unsafe extern "C" {
8449 #[must_use]
8450 pub fn FMOD_Studio_EventInstance_GetMemoryUsage(
8451 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
8452 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
8453 ) -> FMOD_RESULT;
8454}
8455unsafe extern "C" {
8456 pub fn FMOD_Studio_Bus_IsValid(bus: *mut FMOD_STUDIO_BUS) -> FMOD_BOOL;
8457}
8458unsafe extern "C" {
8459 #[must_use]
8460 pub fn FMOD_Studio_Bus_GetID(bus: *mut FMOD_STUDIO_BUS, id: *mut FMOD_GUID) -> FMOD_RESULT;
8461}
8462unsafe extern "C" {
8463 #[must_use]
8464 pub fn FMOD_Studio_Bus_GetPath(
8465 bus: *mut FMOD_STUDIO_BUS,
8466 path: *mut ::std::os::raw::c_char,
8467 size: ::std::os::raw::c_int,
8468 retrieved: *mut ::std::os::raw::c_int,
8469 ) -> FMOD_RESULT;
8470}
8471unsafe extern "C" {
8472 #[must_use]
8473 pub fn FMOD_Studio_Bus_GetVolume(
8474 bus: *mut FMOD_STUDIO_BUS,
8475 volume: *mut f32,
8476 finalvolume: *mut f32,
8477 ) -> FMOD_RESULT;
8478}
8479unsafe extern "C" {
8480 #[must_use]
8481 pub fn FMOD_Studio_Bus_SetVolume(bus: *mut FMOD_STUDIO_BUS, volume: f32) -> FMOD_RESULT;
8482}
8483unsafe extern "C" {
8484 #[must_use]
8485 pub fn FMOD_Studio_Bus_GetPaused(
8486 bus: *mut FMOD_STUDIO_BUS,
8487 paused: *mut FMOD_BOOL,
8488 ) -> FMOD_RESULT;
8489}
8490unsafe extern "C" {
8491 #[must_use]
8492 pub fn FMOD_Studio_Bus_SetPaused(bus: *mut FMOD_STUDIO_BUS, paused: FMOD_BOOL) -> FMOD_RESULT;
8493}
8494unsafe extern "C" {
8495 #[must_use]
8496 pub fn FMOD_Studio_Bus_GetMute(bus: *mut FMOD_STUDIO_BUS, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
8497}
8498unsafe extern "C" {
8499 #[must_use]
8500 pub fn FMOD_Studio_Bus_SetMute(bus: *mut FMOD_STUDIO_BUS, mute: FMOD_BOOL) -> FMOD_RESULT;
8501}
8502unsafe extern "C" {
8503 #[must_use]
8504 pub fn FMOD_Studio_Bus_StopAllEvents(
8505 bus: *mut FMOD_STUDIO_BUS,
8506 mode: FMOD_STUDIO_STOP_MODE,
8507 ) -> FMOD_RESULT;
8508}
8509unsafe extern "C" {
8510 #[must_use]
8511 pub fn FMOD_Studio_Bus_GetPortIndex(
8512 bus: *mut FMOD_STUDIO_BUS,
8513 index: *mut FMOD_PORT_INDEX,
8514 ) -> FMOD_RESULT;
8515}
8516unsafe extern "C" {
8517 #[must_use]
8518 pub fn FMOD_Studio_Bus_SetPortIndex(
8519 bus: *mut FMOD_STUDIO_BUS,
8520 index: FMOD_PORT_INDEX,
8521 ) -> FMOD_RESULT;
8522}
8523unsafe extern "C" {
8524 #[must_use]
8525 pub fn FMOD_Studio_Bus_LockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
8526}
8527unsafe extern "C" {
8528 #[must_use]
8529 pub fn FMOD_Studio_Bus_UnlockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
8530}
8531unsafe extern "C" {
8532 #[must_use]
8533 pub fn FMOD_Studio_Bus_GetChannelGroup(
8534 bus: *mut FMOD_STUDIO_BUS,
8535 group: *mut *mut FMOD_CHANNELGROUP,
8536 ) -> FMOD_RESULT;
8537}
8538unsafe extern "C" {
8539 #[must_use]
8540 pub fn FMOD_Studio_Bus_GetCPUUsage(
8541 bus: *mut FMOD_STUDIO_BUS,
8542 exclusive: *mut ::std::os::raw::c_uint,
8543 inclusive: *mut ::std::os::raw::c_uint,
8544 ) -> FMOD_RESULT;
8545}
8546unsafe extern "C" {
8547 #[must_use]
8548 pub fn FMOD_Studio_Bus_GetMemoryUsage(
8549 bus: *mut FMOD_STUDIO_BUS,
8550 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
8551 ) -> FMOD_RESULT;
8552}
8553unsafe extern "C" {
8554 pub fn FMOD_Studio_VCA_IsValid(vca: *mut FMOD_STUDIO_VCA) -> FMOD_BOOL;
8555}
8556unsafe extern "C" {
8557 #[must_use]
8558 pub fn FMOD_Studio_VCA_GetID(vca: *mut FMOD_STUDIO_VCA, id: *mut FMOD_GUID) -> FMOD_RESULT;
8559}
8560unsafe extern "C" {
8561 #[must_use]
8562 pub fn FMOD_Studio_VCA_GetPath(
8563 vca: *mut FMOD_STUDIO_VCA,
8564 path: *mut ::std::os::raw::c_char,
8565 size: ::std::os::raw::c_int,
8566 retrieved: *mut ::std::os::raw::c_int,
8567 ) -> FMOD_RESULT;
8568}
8569unsafe extern "C" {
8570 #[must_use]
8571 pub fn FMOD_Studio_VCA_GetVolume(
8572 vca: *mut FMOD_STUDIO_VCA,
8573 volume: *mut f32,
8574 finalvolume: *mut f32,
8575 ) -> FMOD_RESULT;
8576}
8577unsafe extern "C" {
8578 #[must_use]
8579 pub fn FMOD_Studio_VCA_SetVolume(vca: *mut FMOD_STUDIO_VCA, volume: f32) -> FMOD_RESULT;
8580}
8581unsafe extern "C" {
8582 pub fn FMOD_Studio_Bank_IsValid(bank: *mut FMOD_STUDIO_BANK) -> FMOD_BOOL;
8583}
8584unsafe extern "C" {
8585 #[must_use]
8586 pub fn FMOD_Studio_Bank_GetID(bank: *mut FMOD_STUDIO_BANK, id: *mut FMOD_GUID) -> FMOD_RESULT;
8587}
8588unsafe extern "C" {
8589 #[must_use]
8590 pub fn FMOD_Studio_Bank_GetPath(
8591 bank: *mut FMOD_STUDIO_BANK,
8592 path: *mut ::std::os::raw::c_char,
8593 size: ::std::os::raw::c_int,
8594 retrieved: *mut ::std::os::raw::c_int,
8595 ) -> FMOD_RESULT;
8596}
8597unsafe extern "C" {
8598 #[must_use]
8599 pub fn FMOD_Studio_Bank_Unload(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
8600}
8601unsafe extern "C" {
8602 #[must_use]
8603 pub fn FMOD_Studio_Bank_LoadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
8604}
8605unsafe extern "C" {
8606 #[must_use]
8607 pub fn FMOD_Studio_Bank_UnloadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
8608}
8609unsafe extern "C" {
8610 #[must_use]
8611 pub fn FMOD_Studio_Bank_GetLoadingState(
8612 bank: *mut FMOD_STUDIO_BANK,
8613 state: *mut FMOD_STUDIO_LOADING_STATE,
8614 ) -> FMOD_RESULT;
8615}
8616unsafe extern "C" {
8617 #[must_use]
8618 pub fn FMOD_Studio_Bank_GetSampleLoadingState(
8619 bank: *mut FMOD_STUDIO_BANK,
8620 state: *mut FMOD_STUDIO_LOADING_STATE,
8621 ) -> FMOD_RESULT;
8622}
8623unsafe extern "C" {
8624 #[must_use]
8625 pub fn FMOD_Studio_Bank_GetStringCount(
8626 bank: *mut FMOD_STUDIO_BANK,
8627 count: *mut ::std::os::raw::c_int,
8628 ) -> FMOD_RESULT;
8629}
8630unsafe extern "C" {
8631 #[must_use]
8632 pub fn FMOD_Studio_Bank_GetStringInfo(
8633 bank: *mut FMOD_STUDIO_BANK,
8634 index: ::std::os::raw::c_int,
8635 id: *mut FMOD_GUID,
8636 path: *mut ::std::os::raw::c_char,
8637 size: ::std::os::raw::c_int,
8638 retrieved: *mut ::std::os::raw::c_int,
8639 ) -> FMOD_RESULT;
8640}
8641unsafe extern "C" {
8642 #[must_use]
8643 pub fn FMOD_Studio_Bank_GetEventCount(
8644 bank: *mut FMOD_STUDIO_BANK,
8645 count: *mut ::std::os::raw::c_int,
8646 ) -> FMOD_RESULT;
8647}
8648unsafe extern "C" {
8649 #[must_use]
8650 pub fn FMOD_Studio_Bank_GetEventList(
8651 bank: *mut FMOD_STUDIO_BANK,
8652 array: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
8653 capacity: ::std::os::raw::c_int,
8654 count: *mut ::std::os::raw::c_int,
8655 ) -> FMOD_RESULT;
8656}
8657unsafe extern "C" {
8658 #[must_use]
8659 pub fn FMOD_Studio_Bank_GetBusCount(
8660 bank: *mut FMOD_STUDIO_BANK,
8661 count: *mut ::std::os::raw::c_int,
8662 ) -> FMOD_RESULT;
8663}
8664unsafe extern "C" {
8665 #[must_use]
8666 pub fn FMOD_Studio_Bank_GetBusList(
8667 bank: *mut FMOD_STUDIO_BANK,
8668 array: *mut *mut FMOD_STUDIO_BUS,
8669 capacity: ::std::os::raw::c_int,
8670 count: *mut ::std::os::raw::c_int,
8671 ) -> FMOD_RESULT;
8672}
8673unsafe extern "C" {
8674 #[must_use]
8675 pub fn FMOD_Studio_Bank_GetVCACount(
8676 bank: *mut FMOD_STUDIO_BANK,
8677 count: *mut ::std::os::raw::c_int,
8678 ) -> FMOD_RESULT;
8679}
8680unsafe extern "C" {
8681 #[must_use]
8682 pub fn FMOD_Studio_Bank_GetVCAList(
8683 bank: *mut FMOD_STUDIO_BANK,
8684 array: *mut *mut FMOD_STUDIO_VCA,
8685 capacity: ::std::os::raw::c_int,
8686 count: *mut ::std::os::raw::c_int,
8687 ) -> FMOD_RESULT;
8688}
8689unsafe extern "C" {
8690 #[must_use]
8691 pub fn FMOD_Studio_Bank_GetUserData(
8692 bank: *mut FMOD_STUDIO_BANK,
8693 userdata: *mut *mut ::std::os::raw::c_void,
8694 ) -> FMOD_RESULT;
8695}
8696unsafe extern "C" {
8697 #[must_use]
8698 pub fn FMOD_Studio_Bank_SetUserData(
8699 bank: *mut FMOD_STUDIO_BANK,
8700 userdata: *mut ::std::os::raw::c_void,
8701 ) -> FMOD_RESULT;
8702}
8703unsafe extern "C" {
8704 pub fn FMOD_Studio_CommandReplay_IsValid(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_BOOL;
8705}
8706unsafe extern "C" {
8707 #[must_use]
8708 pub fn FMOD_Studio_CommandReplay_GetSystem(
8709 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8710 system: *mut *mut FMOD_STUDIO_SYSTEM,
8711 ) -> FMOD_RESULT;
8712}
8713unsafe extern "C" {
8714 #[must_use]
8715 pub fn FMOD_Studio_CommandReplay_GetLength(
8716 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8717 length: *mut f32,
8718 ) -> FMOD_RESULT;
8719}
8720unsafe extern "C" {
8721 #[must_use]
8722 pub fn FMOD_Studio_CommandReplay_GetCommandCount(
8723 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8724 count: *mut ::std::os::raw::c_int,
8725 ) -> FMOD_RESULT;
8726}
8727unsafe extern "C" {
8728 #[must_use]
8729 pub fn FMOD_Studio_CommandReplay_GetCommandInfo(
8730 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8731 commandindex: ::std::os::raw::c_int,
8732 info: *mut FMOD_STUDIO_COMMAND_INFO,
8733 ) -> FMOD_RESULT;
8734}
8735unsafe extern "C" {
8736 #[must_use]
8737 pub fn FMOD_Studio_CommandReplay_GetCommandString(
8738 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8739 commandindex: ::std::os::raw::c_int,
8740 buffer: *mut ::std::os::raw::c_char,
8741 length: ::std::os::raw::c_int,
8742 ) -> FMOD_RESULT;
8743}
8744unsafe extern "C" {
8745 #[must_use]
8746 pub fn FMOD_Studio_CommandReplay_GetCommandAtTime(
8747 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8748 time: f32,
8749 commandindex: *mut ::std::os::raw::c_int,
8750 ) -> FMOD_RESULT;
8751}
8752unsafe extern "C" {
8753 #[must_use]
8754 pub fn FMOD_Studio_CommandReplay_SetBankPath(
8755 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8756 bankPath: *const ::std::os::raw::c_char,
8757 ) -> FMOD_RESULT;
8758}
8759unsafe extern "C" {
8760 #[must_use]
8761 pub fn FMOD_Studio_CommandReplay_Start(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
8762}
8763unsafe extern "C" {
8764 #[must_use]
8765 pub fn FMOD_Studio_CommandReplay_Stop(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
8766}
8767unsafe extern "C" {
8768 #[must_use]
8769 pub fn FMOD_Studio_CommandReplay_SeekToTime(
8770 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8771 time: f32,
8772 ) -> FMOD_RESULT;
8773}
8774unsafe extern "C" {
8775 #[must_use]
8776 pub fn FMOD_Studio_CommandReplay_SeekToCommand(
8777 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8778 commandindex: ::std::os::raw::c_int,
8779 ) -> FMOD_RESULT;
8780}
8781unsafe extern "C" {
8782 #[must_use]
8783 pub fn FMOD_Studio_CommandReplay_GetPaused(
8784 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8785 paused: *mut FMOD_BOOL,
8786 ) -> FMOD_RESULT;
8787}
8788unsafe extern "C" {
8789 #[must_use]
8790 pub fn FMOD_Studio_CommandReplay_SetPaused(
8791 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8792 paused: FMOD_BOOL,
8793 ) -> FMOD_RESULT;
8794}
8795unsafe extern "C" {
8796 #[must_use]
8797 pub fn FMOD_Studio_CommandReplay_GetPlaybackState(
8798 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8799 state: *mut FMOD_STUDIO_PLAYBACK_STATE,
8800 ) -> FMOD_RESULT;
8801}
8802unsafe extern "C" {
8803 #[must_use]
8804 pub fn FMOD_Studio_CommandReplay_GetCurrentCommand(
8805 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8806 commandindex: *mut ::std::os::raw::c_int,
8807 currenttime: *mut f32,
8808 ) -> FMOD_RESULT;
8809}
8810unsafe extern "C" {
8811 #[must_use]
8812 pub fn FMOD_Studio_CommandReplay_Release(replay: *mut FMOD_STUDIO_COMMANDREPLAY)
8813 -> FMOD_RESULT;
8814}
8815unsafe extern "C" {
8816 #[must_use]
8817 pub fn FMOD_Studio_CommandReplay_SetFrameCallback(
8818 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8819 callback: FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK,
8820 ) -> FMOD_RESULT;
8821}
8822unsafe extern "C" {
8823 #[must_use]
8824 pub fn FMOD_Studio_CommandReplay_SetLoadBankCallback(
8825 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8826 callback: FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK,
8827 ) -> FMOD_RESULT;
8828}
8829unsafe extern "C" {
8830 #[must_use]
8831 pub fn FMOD_Studio_CommandReplay_SetCreateInstanceCallback(
8832 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8833 callback: FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK,
8834 ) -> FMOD_RESULT;
8835}
8836unsafe extern "C" {
8837 #[must_use]
8838 pub fn FMOD_Studio_CommandReplay_GetUserData(
8839 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8840 userdata: *mut *mut ::std::os::raw::c_void,
8841 ) -> FMOD_RESULT;
8842}
8843unsafe extern "C" {
8844 #[must_use]
8845 pub fn FMOD_Studio_CommandReplay_SetUserData(
8846 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
8847 userdata: *mut ::std::os::raw::c_void,
8848 ) -> FMOD_RESULT;
8849}