1pub const FMOD_VERSION: u32 = 131616;
4pub const FMOD_DEBUG_LEVEL_NONE: u32 = 0;
5pub const FMOD_DEBUG_LEVEL_ERROR: u32 = 1;
6pub const FMOD_DEBUG_LEVEL_WARNING: u32 = 2;
7pub const FMOD_DEBUG_LEVEL_LOG: u32 = 4;
8pub const FMOD_DEBUG_TYPE_MEMORY: u32 = 256;
9pub const FMOD_DEBUG_TYPE_FILE: u32 = 512;
10pub const FMOD_DEBUG_TYPE_CODEC: u32 = 1024;
11pub const FMOD_DEBUG_TYPE_TRACE: u32 = 2048;
12pub const FMOD_DEBUG_DISPLAY_TIMESTAMPS: u32 = 65536;
13pub const FMOD_DEBUG_DISPLAY_LINENUMBERS: u32 = 131072;
14pub const FMOD_DEBUG_DISPLAY_THREAD: u32 = 262144;
15pub const FMOD_MEMORY_NORMAL: u32 = 0;
16pub const FMOD_MEMORY_STREAM_FILE: u32 = 1;
17pub const FMOD_MEMORY_STREAM_DECODE: u32 = 2;
18pub const FMOD_MEMORY_SAMPLEDATA: u32 = 4;
19pub const FMOD_MEMORY_DSP_BUFFER: u32 = 8;
20pub const FMOD_MEMORY_PLUGIN: u32 = 16;
21pub const FMOD_MEMORY_PERSISTENT: u32 = 2097152;
22pub const FMOD_MEMORY_ALL: u32 = 4294967295;
23pub const FMOD_INIT_NORMAL: u32 = 0;
24pub const FMOD_INIT_STREAM_FROM_UPDATE: u32 = 1;
25pub const FMOD_INIT_MIX_FROM_UPDATE: u32 = 2;
26pub const FMOD_INIT_3D_RIGHTHANDED: u32 = 4;
27pub const FMOD_INIT_CLIP_OUTPUT: u32 = 8;
28pub const FMOD_INIT_CHANNEL_LOWPASS: u32 = 256;
29pub const FMOD_INIT_CHANNEL_DISTANCEFILTER: u32 = 512;
30pub const FMOD_INIT_PROFILE_ENABLE: u32 = 65536;
31pub const FMOD_INIT_VOL0_BECOMES_VIRTUAL: u32 = 131072;
32pub const FMOD_INIT_GEOMETRY_USECLOSEST: u32 = 262144;
33pub const FMOD_INIT_PREFER_DOLBY_DOWNMIX: u32 = 524288;
34pub const FMOD_INIT_THREAD_UNSAFE: u32 = 1048576;
35pub const FMOD_INIT_PROFILE_METER_ALL: u32 = 2097152;
36pub const FMOD_INIT_MEMORY_TRACKING: u32 = 4194304;
37pub const FMOD_DRIVER_STATE_CONNECTED: u32 = 1;
38pub const FMOD_DRIVER_STATE_DEFAULT: u32 = 2;
39pub const FMOD_TIMEUNIT_MS: u32 = 1;
40pub const FMOD_TIMEUNIT_PCM: u32 = 2;
41pub const FMOD_TIMEUNIT_PCMBYTES: u32 = 4;
42pub const FMOD_TIMEUNIT_RAWBYTES: u32 = 8;
43pub const FMOD_TIMEUNIT_PCMFRACTION: u32 = 16;
44pub const FMOD_TIMEUNIT_MODORDER: u32 = 256;
45pub const FMOD_TIMEUNIT_MODROW: u32 = 512;
46pub const FMOD_TIMEUNIT_MODPATTERN: u32 = 1024;
47pub const FMOD_SYSTEM_CALLBACK_DEVICELISTCHANGED: u32 = 1;
48pub const FMOD_SYSTEM_CALLBACK_DEVICELOST: u32 = 2;
49pub const FMOD_SYSTEM_CALLBACK_MEMORYALLOCATIONFAILED: u32 = 4;
50pub const FMOD_SYSTEM_CALLBACK_THREADCREATED: u32 = 8;
51pub const FMOD_SYSTEM_CALLBACK_BADDSPCONNECTION: u32 = 16;
52pub const FMOD_SYSTEM_CALLBACK_PREMIX: u32 = 32;
53pub const FMOD_SYSTEM_CALLBACK_POSTMIX: u32 = 64;
54pub const FMOD_SYSTEM_CALLBACK_ERROR: u32 = 128;
55pub const FMOD_SYSTEM_CALLBACK_MIDMIX: u32 = 256;
56pub const FMOD_SYSTEM_CALLBACK_THREADDESTROYED: u32 = 512;
57pub const FMOD_SYSTEM_CALLBACK_PREUPDATE: u32 = 1024;
58pub const FMOD_SYSTEM_CALLBACK_POSTUPDATE: u32 = 2048;
59pub const FMOD_SYSTEM_CALLBACK_RECORDLISTCHANGED: u32 = 4096;
60pub const FMOD_SYSTEM_CALLBACK_BUFFEREDNOMIX: u32 = 8192;
61pub const FMOD_SYSTEM_CALLBACK_DEVICEREINITIALIZE: u32 = 16384;
62pub const FMOD_SYSTEM_CALLBACK_OUTPUTUNDERRUN: u32 = 32768;
63pub const FMOD_SYSTEM_CALLBACK_RECORDPOSITIONCHANGED: u32 = 65536;
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_PORT_INDEX_FLAG_VR_CONTROLLER: u64 = 1152921504606846976;
114pub const FMOD_THREAD_PRIORITY_PLATFORM_MIN: i32 = -32768;
115pub const FMOD_THREAD_PRIORITY_PLATFORM_MAX: u32 = 32768;
116pub const FMOD_THREAD_PRIORITY_DEFAULT: i32 = -32769;
117pub const FMOD_THREAD_PRIORITY_LOW: i32 = -32770;
118pub const FMOD_THREAD_PRIORITY_MEDIUM: i32 = -32771;
119pub const FMOD_THREAD_PRIORITY_HIGH: i32 = -32772;
120pub const FMOD_THREAD_PRIORITY_VERY_HIGH: i32 = -32773;
121pub const FMOD_THREAD_PRIORITY_EXTREME: i32 = -32774;
122pub const FMOD_THREAD_PRIORITY_CRITICAL: i32 = -32775;
123pub const FMOD_THREAD_PRIORITY_MIXER: i32 = -32774;
124pub const FMOD_THREAD_PRIORITY_FEEDER: i32 = -32775;
125pub const FMOD_THREAD_PRIORITY_STREAM: i32 = -32773;
126pub const FMOD_THREAD_PRIORITY_FILE: i32 = -32772;
127pub const FMOD_THREAD_PRIORITY_NONBLOCKING: i32 = -32772;
128pub const FMOD_THREAD_PRIORITY_RECORD: i32 = -32772;
129pub const FMOD_THREAD_PRIORITY_GEOMETRY: i32 = -32770;
130pub const FMOD_THREAD_PRIORITY_PROFILER: i32 = -32771;
131pub const FMOD_THREAD_PRIORITY_STUDIO_UPDATE: i32 = -32771;
132pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_BANK: i32 = -32771;
133pub const FMOD_THREAD_PRIORITY_STUDIO_LOAD_SAMPLE: i32 = -32771;
134pub const FMOD_THREAD_PRIORITY_CONVOLUTION1: i32 = -32773;
135pub const FMOD_THREAD_PRIORITY_CONVOLUTION2: i32 = -32773;
136pub const FMOD_THREAD_STACK_SIZE_DEFAULT: u32 = 0;
137pub const FMOD_THREAD_STACK_SIZE_MIXER: u32 = 81920;
138pub const FMOD_THREAD_STACK_SIZE_FEEDER: u32 = 16384;
139pub const FMOD_THREAD_STACK_SIZE_STREAM: u32 = 98304;
140pub const FMOD_THREAD_STACK_SIZE_FILE: u32 = 65536;
141pub const FMOD_THREAD_STACK_SIZE_NONBLOCKING: u32 = 114688;
142pub const FMOD_THREAD_STACK_SIZE_RECORD: u32 = 16384;
143pub const FMOD_THREAD_STACK_SIZE_GEOMETRY: u32 = 49152;
144pub const FMOD_THREAD_STACK_SIZE_PROFILER: u32 = 131072;
145pub const FMOD_THREAD_STACK_SIZE_STUDIO_UPDATE: u32 = 98304;
146pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_BANK: u32 = 98304;
147pub const FMOD_THREAD_STACK_SIZE_STUDIO_LOAD_SAMPLE: u32 = 98304;
148pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION1: u32 = 16384;
149pub const FMOD_THREAD_STACK_SIZE_CONVOLUTION2: u32 = 16384;
150pub const FMOD_THREAD_AFFINITY_GROUP_DEFAULT: u64 = 4611686018427387904;
151pub const FMOD_THREAD_AFFINITY_GROUP_A: u64 = 4611686018427387905;
152pub const FMOD_THREAD_AFFINITY_GROUP_B: u64 = 4611686018427387906;
153pub const FMOD_THREAD_AFFINITY_GROUP_C: u64 = 4611686018427387907;
154pub const FMOD_THREAD_AFFINITY_MIXER: u64 = 4611686018427387905;
155pub const FMOD_THREAD_AFFINITY_FEEDER: u64 = 4611686018427387907;
156pub const FMOD_THREAD_AFFINITY_STREAM: u64 = 4611686018427387907;
157pub const FMOD_THREAD_AFFINITY_FILE: u64 = 4611686018427387907;
158pub const FMOD_THREAD_AFFINITY_NONBLOCKING: u64 = 4611686018427387907;
159pub const FMOD_THREAD_AFFINITY_RECORD: u64 = 4611686018427387907;
160pub const FMOD_THREAD_AFFINITY_GEOMETRY: u64 = 4611686018427387907;
161pub const FMOD_THREAD_AFFINITY_PROFILER: u64 = 4611686018427387907;
162pub const FMOD_THREAD_AFFINITY_STUDIO_UPDATE: u64 = 4611686018427387906;
163pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_BANK: u64 = 4611686018427387907;
164pub const FMOD_THREAD_AFFINITY_STUDIO_LOAD_SAMPLE: u64 = 4611686018427387907;
165pub const FMOD_THREAD_AFFINITY_CONVOLUTION1: u64 = 4611686018427387907;
166pub const FMOD_THREAD_AFFINITY_CONVOLUTION2: u64 = 4611686018427387907;
167pub const FMOD_THREAD_AFFINITY_CORE_ALL: u32 = 0;
168pub const FMOD_THREAD_AFFINITY_CORE_0: u32 = 1;
169pub const FMOD_THREAD_AFFINITY_CORE_1: u32 = 2;
170pub const FMOD_THREAD_AFFINITY_CORE_2: u32 = 4;
171pub const FMOD_THREAD_AFFINITY_CORE_3: u32 = 8;
172pub const FMOD_THREAD_AFFINITY_CORE_4: u32 = 16;
173pub const FMOD_THREAD_AFFINITY_CORE_5: u32 = 32;
174pub const FMOD_THREAD_AFFINITY_CORE_6: u32 = 64;
175pub const FMOD_THREAD_AFFINITY_CORE_7: u32 = 128;
176pub const FMOD_THREAD_AFFINITY_CORE_8: u32 = 256;
177pub const FMOD_THREAD_AFFINITY_CORE_9: u32 = 512;
178pub const FMOD_THREAD_AFFINITY_CORE_10: u32 = 1024;
179pub const FMOD_THREAD_AFFINITY_CORE_11: u32 = 2048;
180pub const FMOD_THREAD_AFFINITY_CORE_12: u32 = 4096;
181pub const FMOD_THREAD_AFFINITY_CORE_13: u32 = 8192;
182pub const FMOD_THREAD_AFFINITY_CORE_14: u32 = 16384;
183pub const FMOD_THREAD_AFFINITY_CORE_15: u32 = 32768;
184pub const FMOD_MAX_CHANNEL_WIDTH: u32 = 32;
185pub const FMOD_MAX_SYSTEMS: u32 = 8;
186pub const FMOD_MAX_LISTENERS: u32 = 8;
187pub const FMOD_REVERB_MAXINSTANCES: u32 = 4;
188pub const FMOD_CODEC_PLUGIN_VERSION: u32 = 1;
189pub const FMOD_CODEC_SEEK_METHOD_SET: u32 = 0;
190pub const FMOD_CODEC_SEEK_METHOD_CURRENT: u32 = 1;
191pub const FMOD_CODEC_SEEK_METHOD_END: u32 = 2;
192pub const FMOD_DSP_LOUDNESS_METER_HISTOGRAM_SAMPLES: u32 = 66;
193pub const FMOD_PLUGIN_SDK_VERSION: u32 = 110;
194pub const FMOD_DSP_GETPARAM_VALUESTR_LENGTH: u32 = 32;
195pub const FMOD_OUTPUT_PLUGIN_VERSION: u32 = 5;
196pub const FMOD_OUTPUT_METHOD_MIX_DIRECT: u32 = 0;
197pub const FMOD_OUTPUT_METHOD_MIX_BUFFERED: u32 = 1;
198pub const __bool_true_false_are_defined: u32 = 1;
199pub const true_: u32 = 1;
200pub const false_: u32 = 0;
201pub const FMOD_STUDIO_LOAD_MEMORY_ALIGNMENT: u32 = 32;
202pub const FMOD_STUDIO_INIT_NORMAL: u32 = 0;
203pub const FMOD_STUDIO_INIT_LIVEUPDATE: u32 = 1;
204pub const FMOD_STUDIO_INIT_ALLOW_MISSING_PLUGINS: u32 = 2;
205pub const FMOD_STUDIO_INIT_SYNCHRONOUS_UPDATE: u32 = 4;
206pub const FMOD_STUDIO_INIT_DEFERRED_CALLBACKS: u32 = 8;
207pub const FMOD_STUDIO_INIT_LOAD_FROM_UPDATE: u32 = 16;
208pub const FMOD_STUDIO_INIT_MEMORY_TRACKING: u32 = 32;
209pub const FMOD_STUDIO_PARAMETER_READONLY: u32 = 1;
210pub const FMOD_STUDIO_PARAMETER_AUTOMATIC: u32 = 2;
211pub const FMOD_STUDIO_PARAMETER_GLOBAL: u32 = 4;
212pub const FMOD_STUDIO_PARAMETER_DISCRETE: u32 = 8;
213pub const FMOD_STUDIO_PARAMETER_LABELED: u32 = 16;
214pub const FMOD_STUDIO_SYSTEM_CALLBACK_PREUPDATE: u32 = 1;
215pub const FMOD_STUDIO_SYSTEM_CALLBACK_POSTUPDATE: u32 = 2;
216pub const FMOD_STUDIO_SYSTEM_CALLBACK_BANK_UNLOAD: u32 = 4;
217pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_CONNECTED: u32 = 8;
218pub const FMOD_STUDIO_SYSTEM_CALLBACK_LIVEUPDATE_DISCONNECTED: u32 = 16;
219pub const FMOD_STUDIO_SYSTEM_CALLBACK_ALL: u32 = 4294967295;
220pub const FMOD_STUDIO_EVENT_CALLBACK_CREATED: u32 = 1;
221pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROYED: u32 = 2;
222pub const FMOD_STUDIO_EVENT_CALLBACK_STARTING: u32 = 4;
223pub const FMOD_STUDIO_EVENT_CALLBACK_STARTED: u32 = 8;
224pub const FMOD_STUDIO_EVENT_CALLBACK_RESTARTED: u32 = 16;
225pub const FMOD_STUDIO_EVENT_CALLBACK_STOPPED: u32 = 32;
226pub const FMOD_STUDIO_EVENT_CALLBACK_START_FAILED: u32 = 64;
227pub const FMOD_STUDIO_EVENT_CALLBACK_CREATE_PROGRAMMER_SOUND: u32 = 128;
228pub const FMOD_STUDIO_EVENT_CALLBACK_DESTROY_PROGRAMMER_SOUND: u32 = 256;
229pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_CREATED: u32 = 512;
230pub const FMOD_STUDIO_EVENT_CALLBACK_PLUGIN_DESTROYED: u32 = 1024;
231pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_MARKER: u32 = 2048;
232pub const FMOD_STUDIO_EVENT_CALLBACK_TIMELINE_BEAT: u32 = 4096;
233pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_PLAYED: u32 = 8192;
234pub const FMOD_STUDIO_EVENT_CALLBACK_SOUND_STOPPED: u32 = 16384;
235pub const FMOD_STUDIO_EVENT_CALLBACK_REAL_TO_VIRTUAL: u32 = 32768;
236pub const FMOD_STUDIO_EVENT_CALLBACK_VIRTUAL_TO_REAL: u32 = 65536;
237pub const FMOD_STUDIO_EVENT_CALLBACK_START_EVENT_COMMAND: u32 = 131072;
238pub const FMOD_STUDIO_EVENT_CALLBACK_NESTED_TIMELINE_BEAT: u32 = 262144;
239pub const FMOD_STUDIO_EVENT_CALLBACK_ALL: u32 = 4294967295;
240pub const FMOD_STUDIO_LOAD_BANK_NORMAL: u32 = 0;
241pub const FMOD_STUDIO_LOAD_BANK_NONBLOCKING: u32 = 1;
242pub const FMOD_STUDIO_LOAD_BANK_DECOMPRESS_SAMPLES: u32 = 2;
243pub const FMOD_STUDIO_LOAD_BANK_UNENCRYPTED: u32 = 4;
244pub const FMOD_STUDIO_COMMANDCAPTURE_NORMAL: u32 = 0;
245pub const FMOD_STUDIO_COMMANDCAPTURE_FILEFLUSH: u32 = 1;
246pub const FMOD_STUDIO_COMMANDCAPTURE_SKIP_INITIAL_STATE: u32 = 2;
247pub const FMOD_STUDIO_COMMANDREPLAY_NORMAL: u32 = 0;
248pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_CLEANUP: u32 = 1;
249pub const FMOD_STUDIO_COMMANDREPLAY_FAST_FORWARD: u32 = 2;
250pub const FMOD_STUDIO_COMMANDREPLAY_SKIP_BANK_LOAD: u32 = 4;
251#[repr(transparent)]
252#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
253pub struct FMOD_BOOL(pub ::std::os::raw::c_int);
254#[repr(C)]
255#[derive(Debug, Copy, Clone)]
256pub struct FMOD_SYSTEM {
257 _unused: [u8; 0],
258}
259#[repr(C)]
260#[derive(Debug, Copy, Clone)]
261pub struct FMOD_SOUND {
262 _unused: [u8; 0],
263}
264#[repr(C)]
265#[derive(Debug, Copy, Clone)]
266pub struct FMOD_CHANNELCONTROL {
267 _unused: [u8; 0],
268}
269#[repr(C)]
270#[derive(Debug, Copy, Clone)]
271pub struct FMOD_CHANNEL {
272 _unused: [u8; 0],
273}
274#[repr(C)]
275#[derive(Debug, Copy, Clone)]
276pub struct FMOD_CHANNELGROUP {
277 _unused: [u8; 0],
278}
279#[repr(C)]
280#[derive(Debug, Copy, Clone)]
281pub struct FMOD_SOUNDGROUP {
282 _unused: [u8; 0],
283}
284#[repr(C)]
285#[derive(Debug, Copy, Clone)]
286pub struct FMOD_REVERB3D {
287 _unused: [u8; 0],
288}
289#[repr(C)]
290#[derive(Debug, Copy, Clone)]
291pub struct FMOD_DSP {
292 _unused: [u8; 0],
293}
294#[repr(C)]
295#[derive(Debug, Copy, Clone)]
296pub struct FMOD_DSPCONNECTION {
297 _unused: [u8; 0],
298}
299#[repr(C)]
300#[derive(Debug, Copy, Clone)]
301pub struct FMOD_POLYGON {
302 _unused: [u8; 0],
303}
304#[repr(C)]
305#[derive(Debug, Copy, Clone)]
306pub struct FMOD_GEOMETRY {
307 _unused: [u8; 0],
308}
309#[repr(C)]
310#[derive(Debug, Copy, Clone)]
311pub struct FMOD_SYNCPOINT {
312 _unused: [u8; 0],
313}
314pub type FMOD_DEBUG_FLAGS = ::std::os::raw::c_uint;
315pub type FMOD_MEMORY_TYPE = ::std::os::raw::c_uint;
316pub type FMOD_INITFLAGS = ::std::os::raw::c_uint;
317pub type FMOD_DRIVER_STATE = ::std::os::raw::c_uint;
318pub type FMOD_TIMEUNIT = ::std::os::raw::c_uint;
319pub type FMOD_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
320pub type FMOD_MODE = ::std::os::raw::c_uint;
321pub type FMOD_CHANNELMASK = ::std::os::raw::c_uint;
322pub type FMOD_PORT_INDEX = ::std::os::raw::c_ulonglong;
323pub type FMOD_THREAD_PRIORITY = ::std::os::raw::c_int;
324pub type FMOD_THREAD_STACK_SIZE = ::std::os::raw::c_uint;
325pub type FMOD_THREAD_AFFINITY = ::std::os::raw::c_longlong;
326pub const FMOD_THREAD_TYPE_MIXER: FMOD_THREAD_TYPE = 0;
327pub const FMOD_THREAD_TYPE_FEEDER: FMOD_THREAD_TYPE = 1;
328pub const FMOD_THREAD_TYPE_STREAM: FMOD_THREAD_TYPE = 2;
329pub const FMOD_THREAD_TYPE_FILE: FMOD_THREAD_TYPE = 3;
330pub const FMOD_THREAD_TYPE_NONBLOCKING: FMOD_THREAD_TYPE = 4;
331pub const FMOD_THREAD_TYPE_RECORD: FMOD_THREAD_TYPE = 5;
332pub const FMOD_THREAD_TYPE_GEOMETRY: FMOD_THREAD_TYPE = 6;
333pub const FMOD_THREAD_TYPE_PROFILER: FMOD_THREAD_TYPE = 7;
334pub const FMOD_THREAD_TYPE_STUDIO_UPDATE: FMOD_THREAD_TYPE = 8;
335pub const FMOD_THREAD_TYPE_STUDIO_LOAD_BANK: FMOD_THREAD_TYPE = 9;
336pub const FMOD_THREAD_TYPE_STUDIO_LOAD_SAMPLE: FMOD_THREAD_TYPE = 10;
337pub const FMOD_THREAD_TYPE_CONVOLUTION1: FMOD_THREAD_TYPE = 11;
338pub const FMOD_THREAD_TYPE_CONVOLUTION2: FMOD_THREAD_TYPE = 12;
339pub const FMOD_THREAD_TYPE_MAX: FMOD_THREAD_TYPE = 13;
340pub const FMOD_THREAD_TYPE_FORCEINT: FMOD_THREAD_TYPE = 65536;
341pub type FMOD_THREAD_TYPE = ::std::os::raw::c_uint;
342impl FMOD_RESULT {
343 pub const FMOD_OK: FMOD_RESULT = FMOD_RESULT(0);
344}
345impl FMOD_RESULT {
346 pub const FMOD_ERR_BADCOMMAND: FMOD_RESULT = FMOD_RESULT(1);
347}
348impl FMOD_RESULT {
349 pub const FMOD_ERR_CHANNEL_ALLOC: FMOD_RESULT = FMOD_RESULT(2);
350}
351impl FMOD_RESULT {
352 pub const FMOD_ERR_CHANNEL_STOLEN: FMOD_RESULT = FMOD_RESULT(3);
353}
354impl FMOD_RESULT {
355 pub const FMOD_ERR_DMA: FMOD_RESULT = FMOD_RESULT(4);
356}
357impl FMOD_RESULT {
358 pub const FMOD_ERR_DSP_CONNECTION: FMOD_RESULT = FMOD_RESULT(5);
359}
360impl FMOD_RESULT {
361 pub const FMOD_ERR_DSP_DONTPROCESS: FMOD_RESULT = FMOD_RESULT(6);
362}
363impl FMOD_RESULT {
364 pub const FMOD_ERR_DSP_FORMAT: FMOD_RESULT = FMOD_RESULT(7);
365}
366impl FMOD_RESULT {
367 pub const FMOD_ERR_DSP_INUSE: FMOD_RESULT = FMOD_RESULT(8);
368}
369impl FMOD_RESULT {
370 pub const FMOD_ERR_DSP_NOTFOUND: FMOD_RESULT = FMOD_RESULT(9);
371}
372impl FMOD_RESULT {
373 pub const FMOD_ERR_DSP_RESERVED: FMOD_RESULT = FMOD_RESULT(10);
374}
375impl FMOD_RESULT {
376 pub const FMOD_ERR_DSP_SILENCE: FMOD_RESULT = FMOD_RESULT(11);
377}
378impl FMOD_RESULT {
379 pub const FMOD_ERR_DSP_TYPE: FMOD_RESULT = FMOD_RESULT(12);
380}
381impl FMOD_RESULT {
382 pub const FMOD_ERR_FILE_BAD: FMOD_RESULT = FMOD_RESULT(13);
383}
384impl FMOD_RESULT {
385 pub const FMOD_ERR_FILE_COULDNOTSEEK: FMOD_RESULT = FMOD_RESULT(14);
386}
387impl FMOD_RESULT {
388 pub const FMOD_ERR_FILE_DISKEJECTED: FMOD_RESULT = FMOD_RESULT(15);
389}
390impl FMOD_RESULT {
391 pub const FMOD_ERR_FILE_EOF: FMOD_RESULT = FMOD_RESULT(16);
392}
393impl FMOD_RESULT {
394 pub const FMOD_ERR_FILE_ENDOFDATA: FMOD_RESULT = FMOD_RESULT(17);
395}
396impl FMOD_RESULT {
397 pub const FMOD_ERR_FILE_NOTFOUND: FMOD_RESULT = FMOD_RESULT(18);
398}
399impl FMOD_RESULT {
400 pub const FMOD_ERR_FORMAT: FMOD_RESULT = FMOD_RESULT(19);
401}
402impl FMOD_RESULT {
403 pub const FMOD_ERR_HEADER_MISMATCH: FMOD_RESULT = FMOD_RESULT(20);
404}
405impl FMOD_RESULT {
406 pub const FMOD_ERR_HTTP: FMOD_RESULT = FMOD_RESULT(21);
407}
408impl FMOD_RESULT {
409 pub const FMOD_ERR_HTTP_ACCESS: FMOD_RESULT = FMOD_RESULT(22);
410}
411impl FMOD_RESULT {
412 pub const FMOD_ERR_HTTP_PROXY_AUTH: FMOD_RESULT = FMOD_RESULT(23);
413}
414impl FMOD_RESULT {
415 pub const FMOD_ERR_HTTP_SERVER_ERROR: FMOD_RESULT = FMOD_RESULT(24);
416}
417impl FMOD_RESULT {
418 pub const FMOD_ERR_HTTP_TIMEOUT: FMOD_RESULT = FMOD_RESULT(25);
419}
420impl FMOD_RESULT {
421 pub const FMOD_ERR_INITIALIZATION: FMOD_RESULT = FMOD_RESULT(26);
422}
423impl FMOD_RESULT {
424 pub const FMOD_ERR_INITIALIZED: FMOD_RESULT = FMOD_RESULT(27);
425}
426impl FMOD_RESULT {
427 pub const FMOD_ERR_INTERNAL: FMOD_RESULT = FMOD_RESULT(28);
428}
429impl FMOD_RESULT {
430 pub const FMOD_ERR_INVALID_FLOAT: FMOD_RESULT = FMOD_RESULT(29);
431}
432impl FMOD_RESULT {
433 pub const FMOD_ERR_INVALID_HANDLE: FMOD_RESULT = FMOD_RESULT(30);
434}
435impl FMOD_RESULT {
436 pub const FMOD_ERR_INVALID_PARAM: FMOD_RESULT = FMOD_RESULT(31);
437}
438impl FMOD_RESULT {
439 pub const FMOD_ERR_INVALID_POSITION: FMOD_RESULT = FMOD_RESULT(32);
440}
441impl FMOD_RESULT {
442 pub const FMOD_ERR_INVALID_SPEAKER: FMOD_RESULT = FMOD_RESULT(33);
443}
444impl FMOD_RESULT {
445 pub const FMOD_ERR_INVALID_SYNCPOINT: FMOD_RESULT = FMOD_RESULT(34);
446}
447impl FMOD_RESULT {
448 pub const FMOD_ERR_INVALID_THREAD: FMOD_RESULT = FMOD_RESULT(35);
449}
450impl FMOD_RESULT {
451 pub const FMOD_ERR_INVALID_VECTOR: FMOD_RESULT = FMOD_RESULT(36);
452}
453impl FMOD_RESULT {
454 pub const FMOD_ERR_MAXAUDIBLE: FMOD_RESULT = FMOD_RESULT(37);
455}
456impl FMOD_RESULT {
457 pub const FMOD_ERR_MEMORY: FMOD_RESULT = FMOD_RESULT(38);
458}
459impl FMOD_RESULT {
460 pub const FMOD_ERR_MEMORY_CANTPOINT: FMOD_RESULT = FMOD_RESULT(39);
461}
462impl FMOD_RESULT {
463 pub const FMOD_ERR_NEEDS3D: FMOD_RESULT = FMOD_RESULT(40);
464}
465impl FMOD_RESULT {
466 pub const FMOD_ERR_NEEDSHARDWARE: FMOD_RESULT = FMOD_RESULT(41);
467}
468impl FMOD_RESULT {
469 pub const FMOD_ERR_NET_CONNECT: FMOD_RESULT = FMOD_RESULT(42);
470}
471impl FMOD_RESULT {
472 pub const FMOD_ERR_NET_SOCKET_ERROR: FMOD_RESULT = FMOD_RESULT(43);
473}
474impl FMOD_RESULT {
475 pub const FMOD_ERR_NET_URL: FMOD_RESULT = FMOD_RESULT(44);
476}
477impl FMOD_RESULT {
478 pub const FMOD_ERR_NET_WOULD_BLOCK: FMOD_RESULT = FMOD_RESULT(45);
479}
480impl FMOD_RESULT {
481 pub const FMOD_ERR_NOTREADY: FMOD_RESULT = FMOD_RESULT(46);
482}
483impl FMOD_RESULT {
484 pub const FMOD_ERR_OUTPUT_ALLOCATED: FMOD_RESULT = FMOD_RESULT(47);
485}
486impl FMOD_RESULT {
487 pub const FMOD_ERR_OUTPUT_CREATEBUFFER: FMOD_RESULT = FMOD_RESULT(48);
488}
489impl FMOD_RESULT {
490 pub const FMOD_ERR_OUTPUT_DRIVERCALL: FMOD_RESULT = FMOD_RESULT(49);
491}
492impl FMOD_RESULT {
493 pub const FMOD_ERR_OUTPUT_FORMAT: FMOD_RESULT = FMOD_RESULT(50);
494}
495impl FMOD_RESULT {
496 pub const FMOD_ERR_OUTPUT_INIT: FMOD_RESULT = FMOD_RESULT(51);
497}
498impl FMOD_RESULT {
499 pub const FMOD_ERR_OUTPUT_NODRIVERS: FMOD_RESULT = FMOD_RESULT(52);
500}
501impl FMOD_RESULT {
502 pub const FMOD_ERR_PLUGIN: FMOD_RESULT = FMOD_RESULT(53);
503}
504impl FMOD_RESULT {
505 pub const FMOD_ERR_PLUGIN_MISSING: FMOD_RESULT = FMOD_RESULT(54);
506}
507impl FMOD_RESULT {
508 pub const FMOD_ERR_PLUGIN_RESOURCE: FMOD_RESULT = FMOD_RESULT(55);
509}
510impl FMOD_RESULT {
511 pub const FMOD_ERR_PLUGIN_VERSION: FMOD_RESULT = FMOD_RESULT(56);
512}
513impl FMOD_RESULT {
514 pub const FMOD_ERR_RECORD: FMOD_RESULT = FMOD_RESULT(57);
515}
516impl FMOD_RESULT {
517 pub const FMOD_ERR_REVERB_CHANNELGROUP: FMOD_RESULT = FMOD_RESULT(58);
518}
519impl FMOD_RESULT {
520 pub const FMOD_ERR_REVERB_INSTANCE: FMOD_RESULT = FMOD_RESULT(59);
521}
522impl FMOD_RESULT {
523 pub const FMOD_ERR_SUBSOUNDS: FMOD_RESULT = FMOD_RESULT(60);
524}
525impl FMOD_RESULT {
526 pub const FMOD_ERR_SUBSOUND_ALLOCATED: FMOD_RESULT = FMOD_RESULT(61);
527}
528impl FMOD_RESULT {
529 pub const FMOD_ERR_SUBSOUND_CANTMOVE: FMOD_RESULT = FMOD_RESULT(62);
530}
531impl FMOD_RESULT {
532 pub const FMOD_ERR_TAGNOTFOUND: FMOD_RESULT = FMOD_RESULT(63);
533}
534impl FMOD_RESULT {
535 pub const FMOD_ERR_TOOMANYCHANNELS: FMOD_RESULT = FMOD_RESULT(64);
536}
537impl FMOD_RESULT {
538 pub const FMOD_ERR_TRUNCATED: FMOD_RESULT = FMOD_RESULT(65);
539}
540impl FMOD_RESULT {
541 pub const FMOD_ERR_UNIMPLEMENTED: FMOD_RESULT = FMOD_RESULT(66);
542}
543impl FMOD_RESULT {
544 pub const FMOD_ERR_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(67);
545}
546impl FMOD_RESULT {
547 pub const FMOD_ERR_UNSUPPORTED: FMOD_RESULT = FMOD_RESULT(68);
548}
549impl FMOD_RESULT {
550 pub const FMOD_ERR_VERSION: FMOD_RESULT = FMOD_RESULT(69);
551}
552impl FMOD_RESULT {
553 pub const FMOD_ERR_EVENT_ALREADY_LOADED: FMOD_RESULT = FMOD_RESULT(70);
554}
555impl FMOD_RESULT {
556 pub const FMOD_ERR_EVENT_LIVEUPDATE_BUSY: FMOD_RESULT = FMOD_RESULT(71);
557}
558impl FMOD_RESULT {
559 pub const FMOD_ERR_EVENT_LIVEUPDATE_MISMATCH: FMOD_RESULT = FMOD_RESULT(72);
560}
561impl FMOD_RESULT {
562 pub const FMOD_ERR_EVENT_LIVEUPDATE_TIMEOUT: FMOD_RESULT = FMOD_RESULT(73);
563}
564impl FMOD_RESULT {
565 pub const FMOD_ERR_EVENT_NOTFOUND: FMOD_RESULT = FMOD_RESULT(74);
566}
567impl FMOD_RESULT {
568 pub const FMOD_ERR_STUDIO_UNINITIALIZED: FMOD_RESULT = FMOD_RESULT(75);
569}
570impl FMOD_RESULT {
571 pub const FMOD_ERR_STUDIO_NOT_LOADED: FMOD_RESULT = FMOD_RESULT(76);
572}
573impl FMOD_RESULT {
574 pub const FMOD_ERR_INVALID_STRING: FMOD_RESULT = FMOD_RESULT(77);
575}
576impl FMOD_RESULT {
577 pub const FMOD_ERR_ALREADY_LOCKED: FMOD_RESULT = FMOD_RESULT(78);
578}
579impl FMOD_RESULT {
580 pub const FMOD_ERR_NOT_LOCKED: FMOD_RESULT = FMOD_RESULT(79);
581}
582impl FMOD_RESULT {
583 pub const FMOD_ERR_RECORD_DISCONNECTED: FMOD_RESULT = FMOD_RESULT(80);
584}
585impl FMOD_RESULT {
586 pub const FMOD_ERR_TOOMANYSAMPLES: FMOD_RESULT = FMOD_RESULT(81);
587}
588impl FMOD_RESULT {
589 pub const FMOD_RESULT_FORCEINT: FMOD_RESULT = FMOD_RESULT(65536);
590}
591#[repr(transparent)]
592#[must_use]
593#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
594pub struct FMOD_RESULT(pub ::std::os::raw::c_uint);
595pub const FMOD_CHANNELCONTROL_CHANNEL: FMOD_CHANNELCONTROL_TYPE = 0;
596pub const FMOD_CHANNELCONTROL_CHANNELGROUP: FMOD_CHANNELCONTROL_TYPE = 1;
597pub const FMOD_CHANNELCONTROL_MAX: FMOD_CHANNELCONTROL_TYPE = 2;
598pub const FMOD_CHANNELCONTROL_FORCEINT: FMOD_CHANNELCONTROL_TYPE = 65536;
599pub type FMOD_CHANNELCONTROL_TYPE = ::std::os::raw::c_uint;
600pub const FMOD_OUTPUTTYPE_AUTODETECT: FMOD_OUTPUTTYPE = 0;
601pub const FMOD_OUTPUTTYPE_UNKNOWN: FMOD_OUTPUTTYPE = 1;
602pub const FMOD_OUTPUTTYPE_NOSOUND: FMOD_OUTPUTTYPE = 2;
603pub const FMOD_OUTPUTTYPE_WAVWRITER: FMOD_OUTPUTTYPE = 3;
604pub const FMOD_OUTPUTTYPE_NOSOUND_NRT: FMOD_OUTPUTTYPE = 4;
605pub const FMOD_OUTPUTTYPE_WAVWRITER_NRT: FMOD_OUTPUTTYPE = 5;
606pub const FMOD_OUTPUTTYPE_WASAPI: FMOD_OUTPUTTYPE = 6;
607pub const FMOD_OUTPUTTYPE_ASIO: FMOD_OUTPUTTYPE = 7;
608pub const FMOD_OUTPUTTYPE_PULSEAUDIO: FMOD_OUTPUTTYPE = 8;
609pub const FMOD_OUTPUTTYPE_ALSA: FMOD_OUTPUTTYPE = 9;
610pub const FMOD_OUTPUTTYPE_COREAUDIO: FMOD_OUTPUTTYPE = 10;
611pub const FMOD_OUTPUTTYPE_AUDIOTRACK: FMOD_OUTPUTTYPE = 11;
612pub const FMOD_OUTPUTTYPE_OPENSL: FMOD_OUTPUTTYPE = 12;
613pub const FMOD_OUTPUTTYPE_AUDIOOUT: FMOD_OUTPUTTYPE = 13;
614pub const FMOD_OUTPUTTYPE_AUDIO3D: FMOD_OUTPUTTYPE = 14;
615pub const FMOD_OUTPUTTYPE_WEBAUDIO: FMOD_OUTPUTTYPE = 15;
616pub const FMOD_OUTPUTTYPE_NNAUDIO: FMOD_OUTPUTTYPE = 16;
617pub const FMOD_OUTPUTTYPE_WINSONIC: FMOD_OUTPUTTYPE = 17;
618pub const FMOD_OUTPUTTYPE_AAUDIO: FMOD_OUTPUTTYPE = 18;
619pub const FMOD_OUTPUTTYPE_AUDIOWORKLET: FMOD_OUTPUTTYPE = 19;
620pub const FMOD_OUTPUTTYPE_PHASE: FMOD_OUTPUTTYPE = 20;
621pub const FMOD_OUTPUTTYPE_OHAUDIO: FMOD_OUTPUTTYPE = 21;
622pub const FMOD_OUTPUTTYPE_MAX: FMOD_OUTPUTTYPE = 22;
623pub const FMOD_OUTPUTTYPE_FORCEINT: FMOD_OUTPUTTYPE = 65536;
624pub type FMOD_OUTPUTTYPE = ::std::os::raw::c_uint;
625pub const FMOD_DEBUG_MODE_TTY: FMOD_DEBUG_MODE = 0;
626pub const FMOD_DEBUG_MODE_FILE: FMOD_DEBUG_MODE = 1;
627pub const FMOD_DEBUG_MODE_CALLBACK: FMOD_DEBUG_MODE = 2;
628pub const FMOD_DEBUG_MODE_FORCEINT: FMOD_DEBUG_MODE = 65536;
629pub type FMOD_DEBUG_MODE = ::std::os::raw::c_uint;
630pub const FMOD_SPEAKERMODE_DEFAULT: FMOD_SPEAKERMODE = 0;
631pub const FMOD_SPEAKERMODE_RAW: FMOD_SPEAKERMODE = 1;
632pub const FMOD_SPEAKERMODE_MONO: FMOD_SPEAKERMODE = 2;
633pub const FMOD_SPEAKERMODE_STEREO: FMOD_SPEAKERMODE = 3;
634pub const FMOD_SPEAKERMODE_QUAD: FMOD_SPEAKERMODE = 4;
635pub const FMOD_SPEAKERMODE_SURROUND: FMOD_SPEAKERMODE = 5;
636pub const FMOD_SPEAKERMODE_5POINT1: FMOD_SPEAKERMODE = 6;
637pub const FMOD_SPEAKERMODE_7POINT1: FMOD_SPEAKERMODE = 7;
638pub const FMOD_SPEAKERMODE_7POINT1POINT4: FMOD_SPEAKERMODE = 8;
639pub const FMOD_SPEAKERMODE_MAX: FMOD_SPEAKERMODE = 9;
640pub const FMOD_SPEAKERMODE_FORCEINT: FMOD_SPEAKERMODE = 65536;
641pub type FMOD_SPEAKERMODE = ::std::os::raw::c_uint;
642pub const FMOD_SPEAKER_NONE: FMOD_SPEAKER = -1;
643pub const FMOD_SPEAKER_FRONT_LEFT: FMOD_SPEAKER = 0;
644pub const FMOD_SPEAKER_FRONT_RIGHT: FMOD_SPEAKER = 1;
645pub const FMOD_SPEAKER_FRONT_CENTER: FMOD_SPEAKER = 2;
646pub const FMOD_SPEAKER_LOW_FREQUENCY: FMOD_SPEAKER = 3;
647pub const FMOD_SPEAKER_SURROUND_LEFT: FMOD_SPEAKER = 4;
648pub const FMOD_SPEAKER_SURROUND_RIGHT: FMOD_SPEAKER = 5;
649pub const FMOD_SPEAKER_BACK_LEFT: FMOD_SPEAKER = 6;
650pub const FMOD_SPEAKER_BACK_RIGHT: FMOD_SPEAKER = 7;
651pub const FMOD_SPEAKER_TOP_FRONT_LEFT: FMOD_SPEAKER = 8;
652pub const FMOD_SPEAKER_TOP_FRONT_RIGHT: FMOD_SPEAKER = 9;
653pub const FMOD_SPEAKER_TOP_BACK_LEFT: FMOD_SPEAKER = 10;
654pub const FMOD_SPEAKER_TOP_BACK_RIGHT: FMOD_SPEAKER = 11;
655pub const FMOD_SPEAKER_MAX: FMOD_SPEAKER = 12;
656pub const FMOD_SPEAKER_FORCEINT: FMOD_SPEAKER = 65536;
657pub type FMOD_SPEAKER = ::std::os::raw::c_int;
658pub const FMOD_CHANNELORDER_DEFAULT: FMOD_CHANNELORDER = 0;
659pub const FMOD_CHANNELORDER_WAVEFORMAT: FMOD_CHANNELORDER = 1;
660pub const FMOD_CHANNELORDER_PROTOOLS: FMOD_CHANNELORDER = 2;
661pub const FMOD_CHANNELORDER_ALLMONO: FMOD_CHANNELORDER = 3;
662pub const FMOD_CHANNELORDER_ALLSTEREO: FMOD_CHANNELORDER = 4;
663pub const FMOD_CHANNELORDER_ALSA: FMOD_CHANNELORDER = 5;
664pub const FMOD_CHANNELORDER_MAX: FMOD_CHANNELORDER = 6;
665pub const FMOD_CHANNELORDER_FORCEINT: FMOD_CHANNELORDER = 65536;
666pub type FMOD_CHANNELORDER = ::std::os::raw::c_uint;
667pub const FMOD_PLUGINTYPE_OUTPUT: FMOD_PLUGINTYPE = 0;
668pub const FMOD_PLUGINTYPE_CODEC: FMOD_PLUGINTYPE = 1;
669pub const FMOD_PLUGINTYPE_DSP: FMOD_PLUGINTYPE = 2;
670pub const FMOD_PLUGINTYPE_MAX: FMOD_PLUGINTYPE = 3;
671pub const FMOD_PLUGINTYPE_FORCEINT: FMOD_PLUGINTYPE = 65536;
672pub type FMOD_PLUGINTYPE = ::std::os::raw::c_uint;
673pub const FMOD_SOUND_TYPE_UNKNOWN: FMOD_SOUND_TYPE = 0;
674pub const FMOD_SOUND_TYPE_AIFF: FMOD_SOUND_TYPE = 1;
675pub const FMOD_SOUND_TYPE_ASF: FMOD_SOUND_TYPE = 2;
676pub const FMOD_SOUND_TYPE_DLS: FMOD_SOUND_TYPE = 3;
677pub const FMOD_SOUND_TYPE_FLAC: FMOD_SOUND_TYPE = 4;
678pub const FMOD_SOUND_TYPE_FSB: FMOD_SOUND_TYPE = 5;
679pub const FMOD_SOUND_TYPE_IT: FMOD_SOUND_TYPE = 6;
680pub const FMOD_SOUND_TYPE_MIDI: FMOD_SOUND_TYPE = 7;
681pub const FMOD_SOUND_TYPE_MOD: FMOD_SOUND_TYPE = 8;
682pub const FMOD_SOUND_TYPE_MPEG: FMOD_SOUND_TYPE = 9;
683pub const FMOD_SOUND_TYPE_OGGVORBIS: FMOD_SOUND_TYPE = 10;
684pub const FMOD_SOUND_TYPE_PLAYLIST: FMOD_SOUND_TYPE = 11;
685pub const FMOD_SOUND_TYPE_RAW: FMOD_SOUND_TYPE = 12;
686pub const FMOD_SOUND_TYPE_S3M: FMOD_SOUND_TYPE = 13;
687pub const FMOD_SOUND_TYPE_USER: FMOD_SOUND_TYPE = 14;
688pub const FMOD_SOUND_TYPE_WAV: FMOD_SOUND_TYPE = 15;
689pub const FMOD_SOUND_TYPE_XM: FMOD_SOUND_TYPE = 16;
690pub const FMOD_SOUND_TYPE_XMA: FMOD_SOUND_TYPE = 17;
691pub const FMOD_SOUND_TYPE_AUDIOQUEUE: FMOD_SOUND_TYPE = 18;
692pub const FMOD_SOUND_TYPE_AT9: FMOD_SOUND_TYPE = 19;
693pub const FMOD_SOUND_TYPE_VORBIS: FMOD_SOUND_TYPE = 20;
694pub const FMOD_SOUND_TYPE_MEDIA_FOUNDATION: FMOD_SOUND_TYPE = 21;
695pub const FMOD_SOUND_TYPE_MEDIACODEC: FMOD_SOUND_TYPE = 22;
696pub const FMOD_SOUND_TYPE_FADPCM: FMOD_SOUND_TYPE = 23;
697pub const FMOD_SOUND_TYPE_OPUS: FMOD_SOUND_TYPE = 24;
698pub const FMOD_SOUND_TYPE_MAX: FMOD_SOUND_TYPE = 25;
699pub const FMOD_SOUND_TYPE_FORCEINT: FMOD_SOUND_TYPE = 65536;
700pub type FMOD_SOUND_TYPE = ::std::os::raw::c_uint;
701pub const FMOD_SOUND_FORMAT_NONE: FMOD_SOUND_FORMAT = 0;
702pub const FMOD_SOUND_FORMAT_PCM8: FMOD_SOUND_FORMAT = 1;
703pub const FMOD_SOUND_FORMAT_PCM16: FMOD_SOUND_FORMAT = 2;
704pub const FMOD_SOUND_FORMAT_PCM24: FMOD_SOUND_FORMAT = 3;
705pub const FMOD_SOUND_FORMAT_PCM32: FMOD_SOUND_FORMAT = 4;
706pub const FMOD_SOUND_FORMAT_PCMFLOAT: FMOD_SOUND_FORMAT = 5;
707pub const FMOD_SOUND_FORMAT_BITSTREAM: FMOD_SOUND_FORMAT = 6;
708pub const FMOD_SOUND_FORMAT_MAX: FMOD_SOUND_FORMAT = 7;
709pub const FMOD_SOUND_FORMAT_FORCEINT: FMOD_SOUND_FORMAT = 65536;
710pub type FMOD_SOUND_FORMAT = ::std::os::raw::c_uint;
711pub const FMOD_OPENSTATE_READY: FMOD_OPENSTATE = 0;
712pub const FMOD_OPENSTATE_LOADING: FMOD_OPENSTATE = 1;
713pub const FMOD_OPENSTATE_ERROR: FMOD_OPENSTATE = 2;
714pub const FMOD_OPENSTATE_CONNECTING: FMOD_OPENSTATE = 3;
715pub const FMOD_OPENSTATE_BUFFERING: FMOD_OPENSTATE = 4;
716pub const FMOD_OPENSTATE_SEEKING: FMOD_OPENSTATE = 5;
717pub const FMOD_OPENSTATE_PLAYING: FMOD_OPENSTATE = 6;
718pub const FMOD_OPENSTATE_SETPOSITION: FMOD_OPENSTATE = 7;
719pub const FMOD_OPENSTATE_MAX: FMOD_OPENSTATE = 8;
720pub const FMOD_OPENSTATE_FORCEINT: FMOD_OPENSTATE = 65536;
721pub type FMOD_OPENSTATE = ::std::os::raw::c_uint;
722pub const FMOD_SOUNDGROUP_BEHAVIOR_FAIL: FMOD_SOUNDGROUP_BEHAVIOR = 0;
723pub const FMOD_SOUNDGROUP_BEHAVIOR_MUTE: FMOD_SOUNDGROUP_BEHAVIOR = 1;
724pub const FMOD_SOUNDGROUP_BEHAVIOR_STEALLOWEST: FMOD_SOUNDGROUP_BEHAVIOR = 2;
725pub const FMOD_SOUNDGROUP_BEHAVIOR_MAX: FMOD_SOUNDGROUP_BEHAVIOR = 3;
726pub const FMOD_SOUNDGROUP_BEHAVIOR_FORCEINT: FMOD_SOUNDGROUP_BEHAVIOR = 65536;
727pub type FMOD_SOUNDGROUP_BEHAVIOR = ::std::os::raw::c_uint;
728pub const FMOD_CHANNELCONTROL_CALLBACK_END: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 0;
729pub const FMOD_CHANNELCONTROL_CALLBACK_VIRTUALVOICE: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 1;
730pub const FMOD_CHANNELCONTROL_CALLBACK_SYNCPOINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 2;
731pub const FMOD_CHANNELCONTROL_CALLBACK_OCCLUSION: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 3;
732pub const FMOD_CHANNELCONTROL_CALLBACK_MAX: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 4;
733pub const FMOD_CHANNELCONTROL_CALLBACK_FORCEINT: FMOD_CHANNELCONTROL_CALLBACK_TYPE = 65536;
734pub type FMOD_CHANNELCONTROL_CALLBACK_TYPE = ::std::os::raw::c_uint;
735pub const FMOD_CHANNELCONTROL_DSP_HEAD: FMOD_CHANNELCONTROL_DSP_INDEX = -1;
736pub const FMOD_CHANNELCONTROL_DSP_FADER: FMOD_CHANNELCONTROL_DSP_INDEX = -2;
737pub const FMOD_CHANNELCONTROL_DSP_TAIL: FMOD_CHANNELCONTROL_DSP_INDEX = -3;
738pub const FMOD_CHANNELCONTROL_DSP_FORCEINT: FMOD_CHANNELCONTROL_DSP_INDEX = 65536;
739pub type FMOD_CHANNELCONTROL_DSP_INDEX = ::std::os::raw::c_int;
740pub const FMOD_ERRORCALLBACK_INSTANCETYPE_NONE: FMOD_ERRORCALLBACK_INSTANCETYPE = 0;
741pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 1;
742pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNEL: FMOD_ERRORCALLBACK_INSTANCETYPE = 2;
743pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 3;
744pub const FMOD_ERRORCALLBACK_INSTANCETYPE_CHANNELCONTROL: FMOD_ERRORCALLBACK_INSTANCETYPE = 4;
745pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUND: FMOD_ERRORCALLBACK_INSTANCETYPE = 5;
746pub const FMOD_ERRORCALLBACK_INSTANCETYPE_SOUNDGROUP: FMOD_ERRORCALLBACK_INSTANCETYPE = 6;
747pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSP: FMOD_ERRORCALLBACK_INSTANCETYPE = 7;
748pub const FMOD_ERRORCALLBACK_INSTANCETYPE_DSPCONNECTION: FMOD_ERRORCALLBACK_INSTANCETYPE = 8;
749pub const FMOD_ERRORCALLBACK_INSTANCETYPE_GEOMETRY: FMOD_ERRORCALLBACK_INSTANCETYPE = 9;
750pub const FMOD_ERRORCALLBACK_INSTANCETYPE_REVERB3D: FMOD_ERRORCALLBACK_INSTANCETYPE = 10;
751pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_SYSTEM: FMOD_ERRORCALLBACK_INSTANCETYPE = 11;
752pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTDESCRIPTION: FMOD_ERRORCALLBACK_INSTANCETYPE =
753 12;
754pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_EVENTINSTANCE: FMOD_ERRORCALLBACK_INSTANCETYPE =
755 13;
756pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_PARAMETERINSTANCE:
757 FMOD_ERRORCALLBACK_INSTANCETYPE = 14;
758pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BUS: FMOD_ERRORCALLBACK_INSTANCETYPE = 15;
759pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_VCA: FMOD_ERRORCALLBACK_INSTANCETYPE = 16;
760pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_BANK: FMOD_ERRORCALLBACK_INSTANCETYPE = 17;
761pub const FMOD_ERRORCALLBACK_INSTANCETYPE_STUDIO_COMMANDREPLAY: FMOD_ERRORCALLBACK_INSTANCETYPE =
762 18;
763pub const FMOD_ERRORCALLBACK_INSTANCETYPE_FORCEINT: FMOD_ERRORCALLBACK_INSTANCETYPE = 65536;
764pub type FMOD_ERRORCALLBACK_INSTANCETYPE = ::std::os::raw::c_uint;
765pub const FMOD_DSP_RESAMPLER_DEFAULT: FMOD_DSP_RESAMPLER = 0;
766pub const FMOD_DSP_RESAMPLER_NOINTERP: FMOD_DSP_RESAMPLER = 1;
767pub const FMOD_DSP_RESAMPLER_LINEAR: FMOD_DSP_RESAMPLER = 2;
768pub const FMOD_DSP_RESAMPLER_CUBIC: FMOD_DSP_RESAMPLER = 3;
769pub const FMOD_DSP_RESAMPLER_SPLINE: FMOD_DSP_RESAMPLER = 4;
770pub const FMOD_DSP_RESAMPLER_MAX: FMOD_DSP_RESAMPLER = 5;
771pub const FMOD_DSP_RESAMPLER_FORCEINT: FMOD_DSP_RESAMPLER = 65536;
772pub type FMOD_DSP_RESAMPLER = ::std::os::raw::c_uint;
773pub const FMOD_DSP_CALLBACK_DATAPARAMETERRELEASE: FMOD_DSP_CALLBACK_TYPE = 0;
774pub const FMOD_DSP_CALLBACK_MAX: FMOD_DSP_CALLBACK_TYPE = 1;
775pub const FMOD_DSP_CALLBACK_FORCEINT: FMOD_DSP_CALLBACK_TYPE = 65536;
776pub type FMOD_DSP_CALLBACK_TYPE = ::std::os::raw::c_uint;
777pub const FMOD_DSPCONNECTION_TYPE_STANDARD: FMOD_DSPCONNECTION_TYPE = 0;
778pub const FMOD_DSPCONNECTION_TYPE_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 1;
779pub const FMOD_DSPCONNECTION_TYPE_SEND: FMOD_DSPCONNECTION_TYPE = 2;
780pub const FMOD_DSPCONNECTION_TYPE_SEND_SIDECHAIN: FMOD_DSPCONNECTION_TYPE = 3;
781pub const FMOD_DSPCONNECTION_TYPE_MAX: FMOD_DSPCONNECTION_TYPE = 4;
782pub const FMOD_DSPCONNECTION_TYPE_FORCEINT: FMOD_DSPCONNECTION_TYPE = 65536;
783pub type FMOD_DSPCONNECTION_TYPE = ::std::os::raw::c_uint;
784pub const FMOD_TAGTYPE_UNKNOWN: FMOD_TAGTYPE = 0;
785pub const FMOD_TAGTYPE_ID3V1: FMOD_TAGTYPE = 1;
786pub const FMOD_TAGTYPE_ID3V2: FMOD_TAGTYPE = 2;
787pub const FMOD_TAGTYPE_VORBISCOMMENT: FMOD_TAGTYPE = 3;
788pub const FMOD_TAGTYPE_SHOUTCAST: FMOD_TAGTYPE = 4;
789pub const FMOD_TAGTYPE_ICECAST: FMOD_TAGTYPE = 5;
790pub const FMOD_TAGTYPE_ASF: FMOD_TAGTYPE = 6;
791pub const FMOD_TAGTYPE_MIDI: FMOD_TAGTYPE = 7;
792pub const FMOD_TAGTYPE_PLAYLIST: FMOD_TAGTYPE = 8;
793pub const FMOD_TAGTYPE_FMOD: FMOD_TAGTYPE = 9;
794pub const FMOD_TAGTYPE_USER: FMOD_TAGTYPE = 10;
795pub const FMOD_TAGTYPE_MAX: FMOD_TAGTYPE = 11;
796pub const FMOD_TAGTYPE_FORCEINT: FMOD_TAGTYPE = 65536;
797pub type FMOD_TAGTYPE = ::std::os::raw::c_uint;
798pub const FMOD_TAGDATATYPE_BINARY: FMOD_TAGDATATYPE = 0;
799pub const FMOD_TAGDATATYPE_INT: FMOD_TAGDATATYPE = 1;
800pub const FMOD_TAGDATATYPE_FLOAT: FMOD_TAGDATATYPE = 2;
801pub const FMOD_TAGDATATYPE_STRING: FMOD_TAGDATATYPE = 3;
802pub const FMOD_TAGDATATYPE_STRING_UTF16: FMOD_TAGDATATYPE = 4;
803pub const FMOD_TAGDATATYPE_STRING_UTF16BE: FMOD_TAGDATATYPE = 5;
804pub const FMOD_TAGDATATYPE_STRING_UTF8: FMOD_TAGDATATYPE = 6;
805pub const FMOD_TAGDATATYPE_MAX: FMOD_TAGDATATYPE = 7;
806pub const FMOD_TAGDATATYPE_FORCEINT: FMOD_TAGDATATYPE = 65536;
807pub type FMOD_TAGDATATYPE = ::std::os::raw::c_uint;
808pub const FMOD_PORT_TYPE_MUSIC: FMOD_PORT_TYPE = 0;
809pub const FMOD_PORT_TYPE_COPYRIGHT_MUSIC: FMOD_PORT_TYPE = 1;
810pub const FMOD_PORT_TYPE_VOICE: FMOD_PORT_TYPE = 2;
811pub const FMOD_PORT_TYPE_CONTROLLER: FMOD_PORT_TYPE = 3;
812pub const FMOD_PORT_TYPE_PERSONAL: FMOD_PORT_TYPE = 4;
813pub const FMOD_PORT_TYPE_VIBRATION: FMOD_PORT_TYPE = 5;
814pub const FMOD_PORT_TYPE_AUX: FMOD_PORT_TYPE = 6;
815pub const FMOD_PORT_TYPE_MAX: FMOD_PORT_TYPE = 7;
816pub const FMOD_PORT_TYPE_FORCEINT: FMOD_PORT_TYPE = 65536;
817pub type FMOD_PORT_TYPE = ::std::os::raw::c_uint;
818pub type FMOD_DEBUG_CALLBACK = ::std::option::Option<
819 unsafe extern "C" fn(
820 flags: FMOD_DEBUG_FLAGS,
821 file: *const ::std::os::raw::c_char,
822 line: ::std::os::raw::c_int,
823 func: *const ::std::os::raw::c_char,
824 message: *const ::std::os::raw::c_char,
825 ) -> FMOD_RESULT,
826>;
827pub type FMOD_SYSTEM_CALLBACK = ::std::option::Option<
828 unsafe extern "C" fn(
829 system: *mut FMOD_SYSTEM,
830 type_: FMOD_SYSTEM_CALLBACK_TYPE,
831 commanddata1: *mut ::std::os::raw::c_void,
832 commanddata2: *mut ::std::os::raw::c_void,
833 userdata: *mut ::std::os::raw::c_void,
834 ) -> FMOD_RESULT,
835>;
836pub type FMOD_CHANNELCONTROL_CALLBACK = ::std::option::Option<
837 unsafe extern "C" fn(
838 channelcontrol: *mut FMOD_CHANNELCONTROL,
839 controltype: FMOD_CHANNELCONTROL_TYPE,
840 callbacktype: FMOD_CHANNELCONTROL_CALLBACK_TYPE,
841 commanddata1: *mut ::std::os::raw::c_void,
842 commanddata2: *mut ::std::os::raw::c_void,
843 ) -> FMOD_RESULT,
844>;
845pub type FMOD_DSP_CALLBACK = ::std::option::Option<
846 unsafe extern "C" fn(
847 dsp: *mut FMOD_DSP,
848 type_: FMOD_DSP_CALLBACK_TYPE,
849 data: *mut ::std::os::raw::c_void,
850 ) -> FMOD_RESULT,
851>;
852pub type FMOD_SOUND_NONBLOCK_CALLBACK = ::std::option::Option<
853 unsafe extern "C" fn(sound: *mut FMOD_SOUND, result: FMOD_RESULT) -> FMOD_RESULT,
854>;
855pub type FMOD_SOUND_PCMREAD_CALLBACK = ::std::option::Option<
856 unsafe extern "C" fn(
857 sound: *mut FMOD_SOUND,
858 data: *mut ::std::os::raw::c_void,
859 datalen: ::std::os::raw::c_uint,
860 ) -> FMOD_RESULT,
861>;
862pub type FMOD_SOUND_PCMSETPOS_CALLBACK = ::std::option::Option<
863 unsafe extern "C" fn(
864 sound: *mut FMOD_SOUND,
865 subsound: ::std::os::raw::c_int,
866 position: ::std::os::raw::c_uint,
867 postype: FMOD_TIMEUNIT,
868 ) -> FMOD_RESULT,
869>;
870pub type FMOD_FILE_OPEN_CALLBACK = ::std::option::Option<
871 unsafe extern "C" fn(
872 name: *const ::std::os::raw::c_char,
873 filesize: *mut ::std::os::raw::c_uint,
874 handle: *mut *mut ::std::os::raw::c_void,
875 userdata: *mut ::std::os::raw::c_void,
876 ) -> FMOD_RESULT,
877>;
878pub type FMOD_FILE_CLOSE_CALLBACK = ::std::option::Option<
879 unsafe extern "C" fn(
880 handle: *mut ::std::os::raw::c_void,
881 userdata: *mut ::std::os::raw::c_void,
882 ) -> FMOD_RESULT,
883>;
884pub type FMOD_FILE_READ_CALLBACK = ::std::option::Option<
885 unsafe extern "C" fn(
886 handle: *mut ::std::os::raw::c_void,
887 buffer: *mut ::std::os::raw::c_void,
888 sizebytes: ::std::os::raw::c_uint,
889 bytesread: *mut ::std::os::raw::c_uint,
890 userdata: *mut ::std::os::raw::c_void,
891 ) -> FMOD_RESULT,
892>;
893pub type FMOD_FILE_SEEK_CALLBACK = ::std::option::Option<
894 unsafe extern "C" fn(
895 handle: *mut ::std::os::raw::c_void,
896 pos: ::std::os::raw::c_uint,
897 userdata: *mut ::std::os::raw::c_void,
898 ) -> FMOD_RESULT,
899>;
900pub type FMOD_FILE_ASYNCREAD_CALLBACK = ::std::option::Option<
901 unsafe extern "C" fn(
902 info: *mut FMOD_ASYNCREADINFO,
903 userdata: *mut ::std::os::raw::c_void,
904 ) -> FMOD_RESULT,
905>;
906pub type FMOD_FILE_ASYNCCANCEL_CALLBACK = ::std::option::Option<
907 unsafe extern "C" fn(
908 info: *mut FMOD_ASYNCREADINFO,
909 userdata: *mut ::std::os::raw::c_void,
910 ) -> FMOD_RESULT,
911>;
912pub type FMOD_FILE_ASYNCDONE_FUNC =
913 ::std::option::Option<unsafe extern "C" fn(info: *mut FMOD_ASYNCREADINFO, result: FMOD_RESULT)>;
914pub type FMOD_MEMORY_ALLOC_CALLBACK = ::std::option::Option<
915 unsafe extern "C" fn(
916 size: ::std::os::raw::c_uint,
917 type_: FMOD_MEMORY_TYPE,
918 sourcestr: *const ::std::os::raw::c_char,
919 ) -> *mut ::std::os::raw::c_void,
920>;
921pub type FMOD_MEMORY_REALLOC_CALLBACK = ::std::option::Option<
922 unsafe extern "C" fn(
923 ptr: *mut ::std::os::raw::c_void,
924 size: ::std::os::raw::c_uint,
925 type_: FMOD_MEMORY_TYPE,
926 sourcestr: *const ::std::os::raw::c_char,
927 ) -> *mut ::std::os::raw::c_void,
928>;
929pub type FMOD_MEMORY_FREE_CALLBACK = ::std::option::Option<
930 unsafe extern "C" fn(
931 ptr: *mut ::std::os::raw::c_void,
932 type_: FMOD_MEMORY_TYPE,
933 sourcestr: *const ::std::os::raw::c_char,
934 ),
935>;
936pub type FMOD_3D_ROLLOFF_CALLBACK = ::std::option::Option<
937 unsafe extern "C" fn(channelcontrol: *mut FMOD_CHANNELCONTROL, distance: f32) -> f32,
938>;
939#[repr(C)]
940#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
941pub struct FMOD_ASYNCREADINFO {
942 pub handle: *mut ::std::os::raw::c_void,
943 pub offset: ::std::os::raw::c_uint,
944 pub sizebytes: ::std::os::raw::c_uint,
945 pub priority: ::std::os::raw::c_int,
946 pub userdata: *mut ::std::os::raw::c_void,
947 pub buffer: *mut ::std::os::raw::c_void,
948 pub bytesread: ::std::os::raw::c_uint,
949 pub done: FMOD_FILE_ASYNCDONE_FUNC,
950}
951#[test]
952fn bindgen_test_layout_FMOD_ASYNCREADINFO() {
953 const UNINIT: ::std::mem::MaybeUninit<FMOD_ASYNCREADINFO> = ::std::mem::MaybeUninit::uninit();
954 let ptr = UNINIT.as_ptr();
955 assert_eq!(
956 ::std::mem::size_of::<FMOD_ASYNCREADINFO>(),
957 56usize,
958 concat!("Size of: ", stringify!(FMOD_ASYNCREADINFO))
959 );
960 assert_eq!(
961 ::std::mem::align_of::<FMOD_ASYNCREADINFO>(),
962 8usize,
963 concat!("Alignment of ", stringify!(FMOD_ASYNCREADINFO))
964 );
965 assert_eq!(
966 unsafe { ::std::ptr::addr_of!((*ptr).handle) as usize - ptr as usize },
967 0usize,
968 concat!(
969 "Offset of field: ",
970 stringify!(FMOD_ASYNCREADINFO),
971 "::",
972 stringify!(handle)
973 )
974 );
975 assert_eq!(
976 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
977 8usize,
978 concat!(
979 "Offset of field: ",
980 stringify!(FMOD_ASYNCREADINFO),
981 "::",
982 stringify!(offset)
983 )
984 );
985 assert_eq!(
986 unsafe { ::std::ptr::addr_of!((*ptr).sizebytes) as usize - ptr as usize },
987 12usize,
988 concat!(
989 "Offset of field: ",
990 stringify!(FMOD_ASYNCREADINFO),
991 "::",
992 stringify!(sizebytes)
993 )
994 );
995 assert_eq!(
996 unsafe { ::std::ptr::addr_of!((*ptr).priority) as usize - ptr as usize },
997 16usize,
998 concat!(
999 "Offset of field: ",
1000 stringify!(FMOD_ASYNCREADINFO),
1001 "::",
1002 stringify!(priority)
1003 )
1004 );
1005 assert_eq!(
1006 unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
1007 24usize,
1008 concat!(
1009 "Offset of field: ",
1010 stringify!(FMOD_ASYNCREADINFO),
1011 "::",
1012 stringify!(userdata)
1013 )
1014 );
1015 assert_eq!(
1016 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
1017 32usize,
1018 concat!(
1019 "Offset of field: ",
1020 stringify!(FMOD_ASYNCREADINFO),
1021 "::",
1022 stringify!(buffer)
1023 )
1024 );
1025 assert_eq!(
1026 unsafe { ::std::ptr::addr_of!((*ptr).bytesread) as usize - ptr as usize },
1027 40usize,
1028 concat!(
1029 "Offset of field: ",
1030 stringify!(FMOD_ASYNCREADINFO),
1031 "::",
1032 stringify!(bytesread)
1033 )
1034 );
1035 assert_eq!(
1036 unsafe { ::std::ptr::addr_of!((*ptr).done) as usize - ptr as usize },
1037 48usize,
1038 concat!(
1039 "Offset of field: ",
1040 stringify!(FMOD_ASYNCREADINFO),
1041 "::",
1042 stringify!(done)
1043 )
1044 );
1045}
1046impl Default for FMOD_ASYNCREADINFO {
1047 fn default() -> Self {
1048 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1049 unsafe {
1050 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1051 s.assume_init()
1052 }
1053 }
1054}
1055#[repr(C)]
1056#[derive(Debug, Default, Copy, Clone, PartialEq)]
1057pub struct FMOD_VECTOR {
1058 pub x: f32,
1059 pub y: f32,
1060 pub z: f32,
1061}
1062#[test]
1063fn bindgen_test_layout_FMOD_VECTOR() {
1064 const UNINIT: ::std::mem::MaybeUninit<FMOD_VECTOR> = ::std::mem::MaybeUninit::uninit();
1065 let ptr = UNINIT.as_ptr();
1066 assert_eq!(
1067 ::std::mem::size_of::<FMOD_VECTOR>(),
1068 12usize,
1069 concat!("Size of: ", stringify!(FMOD_VECTOR))
1070 );
1071 assert_eq!(
1072 ::std::mem::align_of::<FMOD_VECTOR>(),
1073 4usize,
1074 concat!("Alignment of ", stringify!(FMOD_VECTOR))
1075 );
1076 assert_eq!(
1077 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
1078 0usize,
1079 concat!(
1080 "Offset of field: ",
1081 stringify!(FMOD_VECTOR),
1082 "::",
1083 stringify!(x)
1084 )
1085 );
1086 assert_eq!(
1087 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
1088 4usize,
1089 concat!(
1090 "Offset of field: ",
1091 stringify!(FMOD_VECTOR),
1092 "::",
1093 stringify!(y)
1094 )
1095 );
1096 assert_eq!(
1097 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
1098 8usize,
1099 concat!(
1100 "Offset of field: ",
1101 stringify!(FMOD_VECTOR),
1102 "::",
1103 stringify!(z)
1104 )
1105 );
1106}
1107#[repr(C)]
1108#[derive(Debug, Default, Copy, Clone, PartialEq)]
1109pub struct FMOD_3D_ATTRIBUTES {
1110 pub position: FMOD_VECTOR,
1111 pub velocity: FMOD_VECTOR,
1112 pub forward: FMOD_VECTOR,
1113 pub up: FMOD_VECTOR,
1114}
1115#[test]
1116fn bindgen_test_layout_FMOD_3D_ATTRIBUTES() {
1117 const UNINIT: ::std::mem::MaybeUninit<FMOD_3D_ATTRIBUTES> = ::std::mem::MaybeUninit::uninit();
1118 let ptr = UNINIT.as_ptr();
1119 assert_eq!(
1120 ::std::mem::size_of::<FMOD_3D_ATTRIBUTES>(),
1121 48usize,
1122 concat!("Size of: ", stringify!(FMOD_3D_ATTRIBUTES))
1123 );
1124 assert_eq!(
1125 ::std::mem::align_of::<FMOD_3D_ATTRIBUTES>(),
1126 4usize,
1127 concat!("Alignment of ", stringify!(FMOD_3D_ATTRIBUTES))
1128 );
1129 assert_eq!(
1130 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
1131 0usize,
1132 concat!(
1133 "Offset of field: ",
1134 stringify!(FMOD_3D_ATTRIBUTES),
1135 "::",
1136 stringify!(position)
1137 )
1138 );
1139 assert_eq!(
1140 unsafe { ::std::ptr::addr_of!((*ptr).velocity) as usize - ptr as usize },
1141 12usize,
1142 concat!(
1143 "Offset of field: ",
1144 stringify!(FMOD_3D_ATTRIBUTES),
1145 "::",
1146 stringify!(velocity)
1147 )
1148 );
1149 assert_eq!(
1150 unsafe { ::std::ptr::addr_of!((*ptr).forward) as usize - ptr as usize },
1151 24usize,
1152 concat!(
1153 "Offset of field: ",
1154 stringify!(FMOD_3D_ATTRIBUTES),
1155 "::",
1156 stringify!(forward)
1157 )
1158 );
1159 assert_eq!(
1160 unsafe { ::std::ptr::addr_of!((*ptr).up) as usize - ptr as usize },
1161 36usize,
1162 concat!(
1163 "Offset of field: ",
1164 stringify!(FMOD_3D_ATTRIBUTES),
1165 "::",
1166 stringify!(up)
1167 )
1168 );
1169}
1170#[repr(C)]
1171#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
1172pub struct FMOD_GUID {
1173 pub Data1: ::std::os::raw::c_uint,
1174 pub Data2: ::std::os::raw::c_ushort,
1175 pub Data3: ::std::os::raw::c_ushort,
1176 pub Data4: [::std::os::raw::c_uchar; 8usize],
1177}
1178#[test]
1179fn bindgen_test_layout_FMOD_GUID() {
1180 const UNINIT: ::std::mem::MaybeUninit<FMOD_GUID> = ::std::mem::MaybeUninit::uninit();
1181 let ptr = UNINIT.as_ptr();
1182 assert_eq!(
1183 ::std::mem::size_of::<FMOD_GUID>(),
1184 16usize,
1185 concat!("Size of: ", stringify!(FMOD_GUID))
1186 );
1187 assert_eq!(
1188 ::std::mem::align_of::<FMOD_GUID>(),
1189 4usize,
1190 concat!("Alignment of ", stringify!(FMOD_GUID))
1191 );
1192 assert_eq!(
1193 unsafe { ::std::ptr::addr_of!((*ptr).Data1) as usize - ptr as usize },
1194 0usize,
1195 concat!(
1196 "Offset of field: ",
1197 stringify!(FMOD_GUID),
1198 "::",
1199 stringify!(Data1)
1200 )
1201 );
1202 assert_eq!(
1203 unsafe { ::std::ptr::addr_of!((*ptr).Data2) as usize - ptr as usize },
1204 4usize,
1205 concat!(
1206 "Offset of field: ",
1207 stringify!(FMOD_GUID),
1208 "::",
1209 stringify!(Data2)
1210 )
1211 );
1212 assert_eq!(
1213 unsafe { ::std::ptr::addr_of!((*ptr).Data3) as usize - ptr as usize },
1214 6usize,
1215 concat!(
1216 "Offset of field: ",
1217 stringify!(FMOD_GUID),
1218 "::",
1219 stringify!(Data3)
1220 )
1221 );
1222 assert_eq!(
1223 unsafe { ::std::ptr::addr_of!((*ptr).Data4) as usize - ptr as usize },
1224 8usize,
1225 concat!(
1226 "Offset of field: ",
1227 stringify!(FMOD_GUID),
1228 "::",
1229 stringify!(Data4)
1230 )
1231 );
1232}
1233#[repr(C)]
1234#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1235pub struct FMOD_PLUGINLIST {
1236 pub type_: FMOD_PLUGINTYPE,
1237 pub description: *mut ::std::os::raw::c_void,
1238}
1239#[test]
1240fn bindgen_test_layout_FMOD_PLUGINLIST() {
1241 const UNINIT: ::std::mem::MaybeUninit<FMOD_PLUGINLIST> = ::std::mem::MaybeUninit::uninit();
1242 let ptr = UNINIT.as_ptr();
1243 assert_eq!(
1244 ::std::mem::size_of::<FMOD_PLUGINLIST>(),
1245 16usize,
1246 concat!("Size of: ", stringify!(FMOD_PLUGINLIST))
1247 );
1248 assert_eq!(
1249 ::std::mem::align_of::<FMOD_PLUGINLIST>(),
1250 8usize,
1251 concat!("Alignment of ", stringify!(FMOD_PLUGINLIST))
1252 );
1253 assert_eq!(
1254 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
1255 0usize,
1256 concat!(
1257 "Offset of field: ",
1258 stringify!(FMOD_PLUGINLIST),
1259 "::",
1260 stringify!(type_)
1261 )
1262 );
1263 assert_eq!(
1264 unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
1265 8usize,
1266 concat!(
1267 "Offset of field: ",
1268 stringify!(FMOD_PLUGINLIST),
1269 "::",
1270 stringify!(description)
1271 )
1272 );
1273}
1274impl Default for FMOD_PLUGINLIST {
1275 fn default() -> Self {
1276 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1277 unsafe {
1278 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1279 s.assume_init()
1280 }
1281 }
1282}
1283#[repr(C)]
1284#[derive(Debug, Copy, Clone, PartialEq)]
1285pub struct FMOD_ADVANCEDSETTINGS {
1286 pub cbSize: ::std::os::raw::c_int,
1287 pub maxMPEGCodecs: ::std::os::raw::c_int,
1288 pub maxADPCMCodecs: ::std::os::raw::c_int,
1289 pub maxXMACodecs: ::std::os::raw::c_int,
1290 pub maxVorbisCodecs: ::std::os::raw::c_int,
1291 pub maxAT9Codecs: ::std::os::raw::c_int,
1292 pub maxFADPCMCodecs: ::std::os::raw::c_int,
1293 pub maxPCMCodecs: ::std::os::raw::c_int,
1294 pub ASIONumChannels: ::std::os::raw::c_int,
1295 pub ASIOChannelList: *mut *mut ::std::os::raw::c_char,
1296 pub ASIOSpeakerList: *mut FMOD_SPEAKER,
1297 pub vol0virtualvol: f32,
1298 pub defaultDecodeBufferSize: ::std::os::raw::c_uint,
1299 pub profilePort: ::std::os::raw::c_ushort,
1300 pub geometryMaxFadeTime: ::std::os::raw::c_uint,
1301 pub distanceFilterCenterFreq: f32,
1302 pub reverb3Dinstance: ::std::os::raw::c_int,
1303 pub DSPBufferPoolSize: ::std::os::raw::c_int,
1304 pub resamplerMethod: FMOD_DSP_RESAMPLER,
1305 pub randomSeed: ::std::os::raw::c_uint,
1306 pub maxConvolutionThreads: ::std::os::raw::c_int,
1307 pub maxOpusCodecs: ::std::os::raw::c_int,
1308 pub maxSpatialObjects: ::std::os::raw::c_int,
1309}
1310#[test]
1311fn bindgen_test_layout_FMOD_ADVANCEDSETTINGS() {
1312 const UNINIT: ::std::mem::MaybeUninit<FMOD_ADVANCEDSETTINGS> =
1313 ::std::mem::MaybeUninit::uninit();
1314 let ptr = UNINIT.as_ptr();
1315 assert_eq!(
1316 ::std::mem::size_of::<FMOD_ADVANCEDSETTINGS>(),
1317 104usize,
1318 concat!("Size of: ", stringify!(FMOD_ADVANCEDSETTINGS))
1319 );
1320 assert_eq!(
1321 ::std::mem::align_of::<FMOD_ADVANCEDSETTINGS>(),
1322 8usize,
1323 concat!("Alignment of ", stringify!(FMOD_ADVANCEDSETTINGS))
1324 );
1325 assert_eq!(
1326 unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize },
1327 0usize,
1328 concat!(
1329 "Offset of field: ",
1330 stringify!(FMOD_ADVANCEDSETTINGS),
1331 "::",
1332 stringify!(cbSize)
1333 )
1334 );
1335 assert_eq!(
1336 unsafe { ::std::ptr::addr_of!((*ptr).maxMPEGCodecs) as usize - ptr as usize },
1337 4usize,
1338 concat!(
1339 "Offset of field: ",
1340 stringify!(FMOD_ADVANCEDSETTINGS),
1341 "::",
1342 stringify!(maxMPEGCodecs)
1343 )
1344 );
1345 assert_eq!(
1346 unsafe { ::std::ptr::addr_of!((*ptr).maxADPCMCodecs) as usize - ptr as usize },
1347 8usize,
1348 concat!(
1349 "Offset of field: ",
1350 stringify!(FMOD_ADVANCEDSETTINGS),
1351 "::",
1352 stringify!(maxADPCMCodecs)
1353 )
1354 );
1355 assert_eq!(
1356 unsafe { ::std::ptr::addr_of!((*ptr).maxXMACodecs) as usize - ptr as usize },
1357 12usize,
1358 concat!(
1359 "Offset of field: ",
1360 stringify!(FMOD_ADVANCEDSETTINGS),
1361 "::",
1362 stringify!(maxXMACodecs)
1363 )
1364 );
1365 assert_eq!(
1366 unsafe { ::std::ptr::addr_of!((*ptr).maxVorbisCodecs) as usize - ptr as usize },
1367 16usize,
1368 concat!(
1369 "Offset of field: ",
1370 stringify!(FMOD_ADVANCEDSETTINGS),
1371 "::",
1372 stringify!(maxVorbisCodecs)
1373 )
1374 );
1375 assert_eq!(
1376 unsafe { ::std::ptr::addr_of!((*ptr).maxAT9Codecs) as usize - ptr as usize },
1377 20usize,
1378 concat!(
1379 "Offset of field: ",
1380 stringify!(FMOD_ADVANCEDSETTINGS),
1381 "::",
1382 stringify!(maxAT9Codecs)
1383 )
1384 );
1385 assert_eq!(
1386 unsafe { ::std::ptr::addr_of!((*ptr).maxFADPCMCodecs) as usize - ptr as usize },
1387 24usize,
1388 concat!(
1389 "Offset of field: ",
1390 stringify!(FMOD_ADVANCEDSETTINGS),
1391 "::",
1392 stringify!(maxFADPCMCodecs)
1393 )
1394 );
1395 assert_eq!(
1396 unsafe { ::std::ptr::addr_of!((*ptr).maxPCMCodecs) as usize - ptr as usize },
1397 28usize,
1398 concat!(
1399 "Offset of field: ",
1400 stringify!(FMOD_ADVANCEDSETTINGS),
1401 "::",
1402 stringify!(maxPCMCodecs)
1403 )
1404 );
1405 assert_eq!(
1406 unsafe { ::std::ptr::addr_of!((*ptr).ASIONumChannels) as usize - ptr as usize },
1407 32usize,
1408 concat!(
1409 "Offset of field: ",
1410 stringify!(FMOD_ADVANCEDSETTINGS),
1411 "::",
1412 stringify!(ASIONumChannels)
1413 )
1414 );
1415 assert_eq!(
1416 unsafe { ::std::ptr::addr_of!((*ptr).ASIOChannelList) as usize - ptr as usize },
1417 40usize,
1418 concat!(
1419 "Offset of field: ",
1420 stringify!(FMOD_ADVANCEDSETTINGS),
1421 "::",
1422 stringify!(ASIOChannelList)
1423 )
1424 );
1425 assert_eq!(
1426 unsafe { ::std::ptr::addr_of!((*ptr).ASIOSpeakerList) as usize - ptr as usize },
1427 48usize,
1428 concat!(
1429 "Offset of field: ",
1430 stringify!(FMOD_ADVANCEDSETTINGS),
1431 "::",
1432 stringify!(ASIOSpeakerList)
1433 )
1434 );
1435 assert_eq!(
1436 unsafe { ::std::ptr::addr_of!((*ptr).vol0virtualvol) as usize - ptr as usize },
1437 56usize,
1438 concat!(
1439 "Offset of field: ",
1440 stringify!(FMOD_ADVANCEDSETTINGS),
1441 "::",
1442 stringify!(vol0virtualvol)
1443 )
1444 );
1445 assert_eq!(
1446 unsafe { ::std::ptr::addr_of!((*ptr).defaultDecodeBufferSize) as usize - ptr as usize },
1447 60usize,
1448 concat!(
1449 "Offset of field: ",
1450 stringify!(FMOD_ADVANCEDSETTINGS),
1451 "::",
1452 stringify!(defaultDecodeBufferSize)
1453 )
1454 );
1455 assert_eq!(
1456 unsafe { ::std::ptr::addr_of!((*ptr).profilePort) as usize - ptr as usize },
1457 64usize,
1458 concat!(
1459 "Offset of field: ",
1460 stringify!(FMOD_ADVANCEDSETTINGS),
1461 "::",
1462 stringify!(profilePort)
1463 )
1464 );
1465 assert_eq!(
1466 unsafe { ::std::ptr::addr_of!((*ptr).geometryMaxFadeTime) as usize - ptr as usize },
1467 68usize,
1468 concat!(
1469 "Offset of field: ",
1470 stringify!(FMOD_ADVANCEDSETTINGS),
1471 "::",
1472 stringify!(geometryMaxFadeTime)
1473 )
1474 );
1475 assert_eq!(
1476 unsafe { ::std::ptr::addr_of!((*ptr).distanceFilterCenterFreq) as usize - ptr as usize },
1477 72usize,
1478 concat!(
1479 "Offset of field: ",
1480 stringify!(FMOD_ADVANCEDSETTINGS),
1481 "::",
1482 stringify!(distanceFilterCenterFreq)
1483 )
1484 );
1485 assert_eq!(
1486 unsafe { ::std::ptr::addr_of!((*ptr).reverb3Dinstance) as usize - ptr as usize },
1487 76usize,
1488 concat!(
1489 "Offset of field: ",
1490 stringify!(FMOD_ADVANCEDSETTINGS),
1491 "::",
1492 stringify!(reverb3Dinstance)
1493 )
1494 );
1495 assert_eq!(
1496 unsafe { ::std::ptr::addr_of!((*ptr).DSPBufferPoolSize) as usize - ptr as usize },
1497 80usize,
1498 concat!(
1499 "Offset of field: ",
1500 stringify!(FMOD_ADVANCEDSETTINGS),
1501 "::",
1502 stringify!(DSPBufferPoolSize)
1503 )
1504 );
1505 assert_eq!(
1506 unsafe { ::std::ptr::addr_of!((*ptr).resamplerMethod) as usize - ptr as usize },
1507 84usize,
1508 concat!(
1509 "Offset of field: ",
1510 stringify!(FMOD_ADVANCEDSETTINGS),
1511 "::",
1512 stringify!(resamplerMethod)
1513 )
1514 );
1515 assert_eq!(
1516 unsafe { ::std::ptr::addr_of!((*ptr).randomSeed) as usize - ptr as usize },
1517 88usize,
1518 concat!(
1519 "Offset of field: ",
1520 stringify!(FMOD_ADVANCEDSETTINGS),
1521 "::",
1522 stringify!(randomSeed)
1523 )
1524 );
1525 assert_eq!(
1526 unsafe { ::std::ptr::addr_of!((*ptr).maxConvolutionThreads) as usize - ptr as usize },
1527 92usize,
1528 concat!(
1529 "Offset of field: ",
1530 stringify!(FMOD_ADVANCEDSETTINGS),
1531 "::",
1532 stringify!(maxConvolutionThreads)
1533 )
1534 );
1535 assert_eq!(
1536 unsafe { ::std::ptr::addr_of!((*ptr).maxOpusCodecs) as usize - ptr as usize },
1537 96usize,
1538 concat!(
1539 "Offset of field: ",
1540 stringify!(FMOD_ADVANCEDSETTINGS),
1541 "::",
1542 stringify!(maxOpusCodecs)
1543 )
1544 );
1545 assert_eq!(
1546 unsafe { ::std::ptr::addr_of!((*ptr).maxSpatialObjects) as usize - ptr as usize },
1547 100usize,
1548 concat!(
1549 "Offset of field: ",
1550 stringify!(FMOD_ADVANCEDSETTINGS),
1551 "::",
1552 stringify!(maxSpatialObjects)
1553 )
1554 );
1555}
1556impl Default for FMOD_ADVANCEDSETTINGS {
1557 fn default() -> Self {
1558 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1559 unsafe {
1560 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1561 s.assume_init()
1562 }
1563 }
1564}
1565#[repr(C)]
1566#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1567pub struct FMOD_TAG {
1568 pub type_: FMOD_TAGTYPE,
1569 pub datatype: FMOD_TAGDATATYPE,
1570 pub name: *mut ::std::os::raw::c_char,
1571 pub data: *mut ::std::os::raw::c_void,
1572 pub datalen: ::std::os::raw::c_uint,
1573 pub updated: FMOD_BOOL,
1574}
1575#[test]
1576fn bindgen_test_layout_FMOD_TAG() {
1577 const UNINIT: ::std::mem::MaybeUninit<FMOD_TAG> = ::std::mem::MaybeUninit::uninit();
1578 let ptr = UNINIT.as_ptr();
1579 assert_eq!(
1580 ::std::mem::size_of::<FMOD_TAG>(),
1581 32usize,
1582 concat!("Size of: ", stringify!(FMOD_TAG))
1583 );
1584 assert_eq!(
1585 ::std::mem::align_of::<FMOD_TAG>(),
1586 8usize,
1587 concat!("Alignment of ", stringify!(FMOD_TAG))
1588 );
1589 assert_eq!(
1590 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
1591 0usize,
1592 concat!(
1593 "Offset of field: ",
1594 stringify!(FMOD_TAG),
1595 "::",
1596 stringify!(type_)
1597 )
1598 );
1599 assert_eq!(
1600 unsafe { ::std::ptr::addr_of!((*ptr).datatype) as usize - ptr as usize },
1601 4usize,
1602 concat!(
1603 "Offset of field: ",
1604 stringify!(FMOD_TAG),
1605 "::",
1606 stringify!(datatype)
1607 )
1608 );
1609 assert_eq!(
1610 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
1611 8usize,
1612 concat!(
1613 "Offset of field: ",
1614 stringify!(FMOD_TAG),
1615 "::",
1616 stringify!(name)
1617 )
1618 );
1619 assert_eq!(
1620 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
1621 16usize,
1622 concat!(
1623 "Offset of field: ",
1624 stringify!(FMOD_TAG),
1625 "::",
1626 stringify!(data)
1627 )
1628 );
1629 assert_eq!(
1630 unsafe { ::std::ptr::addr_of!((*ptr).datalen) as usize - ptr as usize },
1631 24usize,
1632 concat!(
1633 "Offset of field: ",
1634 stringify!(FMOD_TAG),
1635 "::",
1636 stringify!(datalen)
1637 )
1638 );
1639 assert_eq!(
1640 unsafe { ::std::ptr::addr_of!((*ptr).updated) as usize - ptr as usize },
1641 28usize,
1642 concat!(
1643 "Offset of field: ",
1644 stringify!(FMOD_TAG),
1645 "::",
1646 stringify!(updated)
1647 )
1648 );
1649}
1650impl Default for FMOD_TAG {
1651 fn default() -> Self {
1652 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1653 unsafe {
1654 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1655 s.assume_init()
1656 }
1657 }
1658}
1659#[repr(C)]
1660#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
1661pub struct FMOD_CREATESOUNDEXINFO {
1662 pub cbsize: ::std::os::raw::c_int,
1663 pub length: ::std::os::raw::c_uint,
1664 pub fileoffset: ::std::os::raw::c_uint,
1665 pub numchannels: ::std::os::raw::c_int,
1666 pub defaultfrequency: ::std::os::raw::c_int,
1667 pub format: FMOD_SOUND_FORMAT,
1668 pub decodebuffersize: ::std::os::raw::c_uint,
1669 pub initialsubsound: ::std::os::raw::c_int,
1670 pub numsubsounds: ::std::os::raw::c_int,
1671 pub inclusionlist: *mut ::std::os::raw::c_int,
1672 pub inclusionlistnum: ::std::os::raw::c_int,
1673 pub pcmreadcallback: FMOD_SOUND_PCMREAD_CALLBACK,
1674 pub pcmsetposcallback: FMOD_SOUND_PCMSETPOS_CALLBACK,
1675 pub nonblockcallback: FMOD_SOUND_NONBLOCK_CALLBACK,
1676 pub dlsname: *const ::std::os::raw::c_char,
1677 pub encryptionkey: *const ::std::os::raw::c_char,
1678 pub maxpolyphony: ::std::os::raw::c_int,
1679 pub userdata: *mut ::std::os::raw::c_void,
1680 pub suggestedsoundtype: FMOD_SOUND_TYPE,
1681 pub fileuseropen: FMOD_FILE_OPEN_CALLBACK,
1682 pub fileuserclose: FMOD_FILE_CLOSE_CALLBACK,
1683 pub fileuserread: FMOD_FILE_READ_CALLBACK,
1684 pub fileuserseek: FMOD_FILE_SEEK_CALLBACK,
1685 pub fileuserasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
1686 pub fileuserasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
1687 pub fileuserdata: *mut ::std::os::raw::c_void,
1688 pub filebuffersize: ::std::os::raw::c_int,
1689 pub channelorder: FMOD_CHANNELORDER,
1690 pub initialsoundgroup: *mut FMOD_SOUNDGROUP,
1691 pub initialseekposition: ::std::os::raw::c_uint,
1692 pub initialseekpostype: FMOD_TIMEUNIT,
1693 pub ignoresetfilesystem: ::std::os::raw::c_int,
1694 pub audioqueuepolicy: ::std::os::raw::c_uint,
1695 pub minmidigranularity: ::std::os::raw::c_uint,
1696 pub nonblockthreadid: ::std::os::raw::c_int,
1697 pub fsbguid: *mut FMOD_GUID,
1698}
1699#[test]
1700fn bindgen_test_layout_FMOD_CREATESOUNDEXINFO() {
1701 const UNINIT: ::std::mem::MaybeUninit<FMOD_CREATESOUNDEXINFO> =
1702 ::std::mem::MaybeUninit::uninit();
1703 let ptr = UNINIT.as_ptr();
1704 assert_eq!(
1705 ::std::mem::size_of::<FMOD_CREATESOUNDEXINFO>(),
1706 224usize,
1707 concat!("Size of: ", stringify!(FMOD_CREATESOUNDEXINFO))
1708 );
1709 assert_eq!(
1710 ::std::mem::align_of::<FMOD_CREATESOUNDEXINFO>(),
1711 8usize,
1712 concat!("Alignment of ", stringify!(FMOD_CREATESOUNDEXINFO))
1713 );
1714 assert_eq!(
1715 unsafe { ::std::ptr::addr_of!((*ptr).cbsize) as usize - ptr as usize },
1716 0usize,
1717 concat!(
1718 "Offset of field: ",
1719 stringify!(FMOD_CREATESOUNDEXINFO),
1720 "::",
1721 stringify!(cbsize)
1722 )
1723 );
1724 assert_eq!(
1725 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
1726 4usize,
1727 concat!(
1728 "Offset of field: ",
1729 stringify!(FMOD_CREATESOUNDEXINFO),
1730 "::",
1731 stringify!(length)
1732 )
1733 );
1734 assert_eq!(
1735 unsafe { ::std::ptr::addr_of!((*ptr).fileoffset) as usize - ptr as usize },
1736 8usize,
1737 concat!(
1738 "Offset of field: ",
1739 stringify!(FMOD_CREATESOUNDEXINFO),
1740 "::",
1741 stringify!(fileoffset)
1742 )
1743 );
1744 assert_eq!(
1745 unsafe { ::std::ptr::addr_of!((*ptr).numchannels) as usize - ptr as usize },
1746 12usize,
1747 concat!(
1748 "Offset of field: ",
1749 stringify!(FMOD_CREATESOUNDEXINFO),
1750 "::",
1751 stringify!(numchannels)
1752 )
1753 );
1754 assert_eq!(
1755 unsafe { ::std::ptr::addr_of!((*ptr).defaultfrequency) as usize - ptr as usize },
1756 16usize,
1757 concat!(
1758 "Offset of field: ",
1759 stringify!(FMOD_CREATESOUNDEXINFO),
1760 "::",
1761 stringify!(defaultfrequency)
1762 )
1763 );
1764 assert_eq!(
1765 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
1766 20usize,
1767 concat!(
1768 "Offset of field: ",
1769 stringify!(FMOD_CREATESOUNDEXINFO),
1770 "::",
1771 stringify!(format)
1772 )
1773 );
1774 assert_eq!(
1775 unsafe { ::std::ptr::addr_of!((*ptr).decodebuffersize) as usize - ptr as usize },
1776 24usize,
1777 concat!(
1778 "Offset of field: ",
1779 stringify!(FMOD_CREATESOUNDEXINFO),
1780 "::",
1781 stringify!(decodebuffersize)
1782 )
1783 );
1784 assert_eq!(
1785 unsafe { ::std::ptr::addr_of!((*ptr).initialsubsound) as usize - ptr as usize },
1786 28usize,
1787 concat!(
1788 "Offset of field: ",
1789 stringify!(FMOD_CREATESOUNDEXINFO),
1790 "::",
1791 stringify!(initialsubsound)
1792 )
1793 );
1794 assert_eq!(
1795 unsafe { ::std::ptr::addr_of!((*ptr).numsubsounds) as usize - ptr as usize },
1796 32usize,
1797 concat!(
1798 "Offset of field: ",
1799 stringify!(FMOD_CREATESOUNDEXINFO),
1800 "::",
1801 stringify!(numsubsounds)
1802 )
1803 );
1804 assert_eq!(
1805 unsafe { ::std::ptr::addr_of!((*ptr).inclusionlist) as usize - ptr as usize },
1806 40usize,
1807 concat!(
1808 "Offset of field: ",
1809 stringify!(FMOD_CREATESOUNDEXINFO),
1810 "::",
1811 stringify!(inclusionlist)
1812 )
1813 );
1814 assert_eq!(
1815 unsafe { ::std::ptr::addr_of!((*ptr).inclusionlistnum) as usize - ptr as usize },
1816 48usize,
1817 concat!(
1818 "Offset of field: ",
1819 stringify!(FMOD_CREATESOUNDEXINFO),
1820 "::",
1821 stringify!(inclusionlistnum)
1822 )
1823 );
1824 assert_eq!(
1825 unsafe { ::std::ptr::addr_of!((*ptr).pcmreadcallback) as usize - ptr as usize },
1826 56usize,
1827 concat!(
1828 "Offset of field: ",
1829 stringify!(FMOD_CREATESOUNDEXINFO),
1830 "::",
1831 stringify!(pcmreadcallback)
1832 )
1833 );
1834 assert_eq!(
1835 unsafe { ::std::ptr::addr_of!((*ptr).pcmsetposcallback) as usize - ptr as usize },
1836 64usize,
1837 concat!(
1838 "Offset of field: ",
1839 stringify!(FMOD_CREATESOUNDEXINFO),
1840 "::",
1841 stringify!(pcmsetposcallback)
1842 )
1843 );
1844 assert_eq!(
1845 unsafe { ::std::ptr::addr_of!((*ptr).nonblockcallback) as usize - ptr as usize },
1846 72usize,
1847 concat!(
1848 "Offset of field: ",
1849 stringify!(FMOD_CREATESOUNDEXINFO),
1850 "::",
1851 stringify!(nonblockcallback)
1852 )
1853 );
1854 assert_eq!(
1855 unsafe { ::std::ptr::addr_of!((*ptr).dlsname) as usize - ptr as usize },
1856 80usize,
1857 concat!(
1858 "Offset of field: ",
1859 stringify!(FMOD_CREATESOUNDEXINFO),
1860 "::",
1861 stringify!(dlsname)
1862 )
1863 );
1864 assert_eq!(
1865 unsafe { ::std::ptr::addr_of!((*ptr).encryptionkey) as usize - ptr as usize },
1866 88usize,
1867 concat!(
1868 "Offset of field: ",
1869 stringify!(FMOD_CREATESOUNDEXINFO),
1870 "::",
1871 stringify!(encryptionkey)
1872 )
1873 );
1874 assert_eq!(
1875 unsafe { ::std::ptr::addr_of!((*ptr).maxpolyphony) as usize - ptr as usize },
1876 96usize,
1877 concat!(
1878 "Offset of field: ",
1879 stringify!(FMOD_CREATESOUNDEXINFO),
1880 "::",
1881 stringify!(maxpolyphony)
1882 )
1883 );
1884 assert_eq!(
1885 unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
1886 104usize,
1887 concat!(
1888 "Offset of field: ",
1889 stringify!(FMOD_CREATESOUNDEXINFO),
1890 "::",
1891 stringify!(userdata)
1892 )
1893 );
1894 assert_eq!(
1895 unsafe { ::std::ptr::addr_of!((*ptr).suggestedsoundtype) as usize - ptr as usize },
1896 112usize,
1897 concat!(
1898 "Offset of field: ",
1899 stringify!(FMOD_CREATESOUNDEXINFO),
1900 "::",
1901 stringify!(suggestedsoundtype)
1902 )
1903 );
1904 assert_eq!(
1905 unsafe { ::std::ptr::addr_of!((*ptr).fileuseropen) as usize - ptr as usize },
1906 120usize,
1907 concat!(
1908 "Offset of field: ",
1909 stringify!(FMOD_CREATESOUNDEXINFO),
1910 "::",
1911 stringify!(fileuseropen)
1912 )
1913 );
1914 assert_eq!(
1915 unsafe { ::std::ptr::addr_of!((*ptr).fileuserclose) as usize - ptr as usize },
1916 128usize,
1917 concat!(
1918 "Offset of field: ",
1919 stringify!(FMOD_CREATESOUNDEXINFO),
1920 "::",
1921 stringify!(fileuserclose)
1922 )
1923 );
1924 assert_eq!(
1925 unsafe { ::std::ptr::addr_of!((*ptr).fileuserread) as usize - ptr as usize },
1926 136usize,
1927 concat!(
1928 "Offset of field: ",
1929 stringify!(FMOD_CREATESOUNDEXINFO),
1930 "::",
1931 stringify!(fileuserread)
1932 )
1933 );
1934 assert_eq!(
1935 unsafe { ::std::ptr::addr_of!((*ptr).fileuserseek) as usize - ptr as usize },
1936 144usize,
1937 concat!(
1938 "Offset of field: ",
1939 stringify!(FMOD_CREATESOUNDEXINFO),
1940 "::",
1941 stringify!(fileuserseek)
1942 )
1943 );
1944 assert_eq!(
1945 unsafe { ::std::ptr::addr_of!((*ptr).fileuserasyncread) as usize - ptr as usize },
1946 152usize,
1947 concat!(
1948 "Offset of field: ",
1949 stringify!(FMOD_CREATESOUNDEXINFO),
1950 "::",
1951 stringify!(fileuserasyncread)
1952 )
1953 );
1954 assert_eq!(
1955 unsafe { ::std::ptr::addr_of!((*ptr).fileuserasynccancel) as usize - ptr as usize },
1956 160usize,
1957 concat!(
1958 "Offset of field: ",
1959 stringify!(FMOD_CREATESOUNDEXINFO),
1960 "::",
1961 stringify!(fileuserasynccancel)
1962 )
1963 );
1964 assert_eq!(
1965 unsafe { ::std::ptr::addr_of!((*ptr).fileuserdata) as usize - ptr as usize },
1966 168usize,
1967 concat!(
1968 "Offset of field: ",
1969 stringify!(FMOD_CREATESOUNDEXINFO),
1970 "::",
1971 stringify!(fileuserdata)
1972 )
1973 );
1974 assert_eq!(
1975 unsafe { ::std::ptr::addr_of!((*ptr).filebuffersize) as usize - ptr as usize },
1976 176usize,
1977 concat!(
1978 "Offset of field: ",
1979 stringify!(FMOD_CREATESOUNDEXINFO),
1980 "::",
1981 stringify!(filebuffersize)
1982 )
1983 );
1984 assert_eq!(
1985 unsafe { ::std::ptr::addr_of!((*ptr).channelorder) as usize - ptr as usize },
1986 180usize,
1987 concat!(
1988 "Offset of field: ",
1989 stringify!(FMOD_CREATESOUNDEXINFO),
1990 "::",
1991 stringify!(channelorder)
1992 )
1993 );
1994 assert_eq!(
1995 unsafe { ::std::ptr::addr_of!((*ptr).initialsoundgroup) as usize - ptr as usize },
1996 184usize,
1997 concat!(
1998 "Offset of field: ",
1999 stringify!(FMOD_CREATESOUNDEXINFO),
2000 "::",
2001 stringify!(initialsoundgroup)
2002 )
2003 );
2004 assert_eq!(
2005 unsafe { ::std::ptr::addr_of!((*ptr).initialseekposition) as usize - ptr as usize },
2006 192usize,
2007 concat!(
2008 "Offset of field: ",
2009 stringify!(FMOD_CREATESOUNDEXINFO),
2010 "::",
2011 stringify!(initialseekposition)
2012 )
2013 );
2014 assert_eq!(
2015 unsafe { ::std::ptr::addr_of!((*ptr).initialseekpostype) as usize - ptr as usize },
2016 196usize,
2017 concat!(
2018 "Offset of field: ",
2019 stringify!(FMOD_CREATESOUNDEXINFO),
2020 "::",
2021 stringify!(initialseekpostype)
2022 )
2023 );
2024 assert_eq!(
2025 unsafe { ::std::ptr::addr_of!((*ptr).ignoresetfilesystem) as usize - ptr as usize },
2026 200usize,
2027 concat!(
2028 "Offset of field: ",
2029 stringify!(FMOD_CREATESOUNDEXINFO),
2030 "::",
2031 stringify!(ignoresetfilesystem)
2032 )
2033 );
2034 assert_eq!(
2035 unsafe { ::std::ptr::addr_of!((*ptr).audioqueuepolicy) as usize - ptr as usize },
2036 204usize,
2037 concat!(
2038 "Offset of field: ",
2039 stringify!(FMOD_CREATESOUNDEXINFO),
2040 "::",
2041 stringify!(audioqueuepolicy)
2042 )
2043 );
2044 assert_eq!(
2045 unsafe { ::std::ptr::addr_of!((*ptr).minmidigranularity) as usize - ptr as usize },
2046 208usize,
2047 concat!(
2048 "Offset of field: ",
2049 stringify!(FMOD_CREATESOUNDEXINFO),
2050 "::",
2051 stringify!(minmidigranularity)
2052 )
2053 );
2054 assert_eq!(
2055 unsafe { ::std::ptr::addr_of!((*ptr).nonblockthreadid) as usize - ptr as usize },
2056 212usize,
2057 concat!(
2058 "Offset of field: ",
2059 stringify!(FMOD_CREATESOUNDEXINFO),
2060 "::",
2061 stringify!(nonblockthreadid)
2062 )
2063 );
2064 assert_eq!(
2065 unsafe { ::std::ptr::addr_of!((*ptr).fsbguid) as usize - ptr as usize },
2066 216usize,
2067 concat!(
2068 "Offset of field: ",
2069 stringify!(FMOD_CREATESOUNDEXINFO),
2070 "::",
2071 stringify!(fsbguid)
2072 )
2073 );
2074}
2075impl Default for FMOD_CREATESOUNDEXINFO {
2076 fn default() -> Self {
2077 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2078 unsafe {
2079 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2080 s.assume_init()
2081 }
2082 }
2083}
2084#[repr(C)]
2085#[derive(Debug, Default, Copy, Clone, PartialEq)]
2086pub struct FMOD_REVERB_PROPERTIES {
2087 pub DecayTime: f32,
2088 pub EarlyDelay: f32,
2089 pub LateDelay: f32,
2090 pub HFReference: f32,
2091 pub HFDecayRatio: f32,
2092 pub Diffusion: f32,
2093 pub Density: f32,
2094 pub LowShelfFrequency: f32,
2095 pub LowShelfGain: f32,
2096 pub HighCut: f32,
2097 pub EarlyLateMix: f32,
2098 pub WetLevel: f32,
2099}
2100#[test]
2101fn bindgen_test_layout_FMOD_REVERB_PROPERTIES() {
2102 const UNINIT: ::std::mem::MaybeUninit<FMOD_REVERB_PROPERTIES> =
2103 ::std::mem::MaybeUninit::uninit();
2104 let ptr = UNINIT.as_ptr();
2105 assert_eq!(
2106 ::std::mem::size_of::<FMOD_REVERB_PROPERTIES>(),
2107 48usize,
2108 concat!("Size of: ", stringify!(FMOD_REVERB_PROPERTIES))
2109 );
2110 assert_eq!(
2111 ::std::mem::align_of::<FMOD_REVERB_PROPERTIES>(),
2112 4usize,
2113 concat!("Alignment of ", stringify!(FMOD_REVERB_PROPERTIES))
2114 );
2115 assert_eq!(
2116 unsafe { ::std::ptr::addr_of!((*ptr).DecayTime) as usize - ptr as usize },
2117 0usize,
2118 concat!(
2119 "Offset of field: ",
2120 stringify!(FMOD_REVERB_PROPERTIES),
2121 "::",
2122 stringify!(DecayTime)
2123 )
2124 );
2125 assert_eq!(
2126 unsafe { ::std::ptr::addr_of!((*ptr).EarlyDelay) as usize - ptr as usize },
2127 4usize,
2128 concat!(
2129 "Offset of field: ",
2130 stringify!(FMOD_REVERB_PROPERTIES),
2131 "::",
2132 stringify!(EarlyDelay)
2133 )
2134 );
2135 assert_eq!(
2136 unsafe { ::std::ptr::addr_of!((*ptr).LateDelay) as usize - ptr as usize },
2137 8usize,
2138 concat!(
2139 "Offset of field: ",
2140 stringify!(FMOD_REVERB_PROPERTIES),
2141 "::",
2142 stringify!(LateDelay)
2143 )
2144 );
2145 assert_eq!(
2146 unsafe { ::std::ptr::addr_of!((*ptr).HFReference) as usize - ptr as usize },
2147 12usize,
2148 concat!(
2149 "Offset of field: ",
2150 stringify!(FMOD_REVERB_PROPERTIES),
2151 "::",
2152 stringify!(HFReference)
2153 )
2154 );
2155 assert_eq!(
2156 unsafe { ::std::ptr::addr_of!((*ptr).HFDecayRatio) as usize - ptr as usize },
2157 16usize,
2158 concat!(
2159 "Offset of field: ",
2160 stringify!(FMOD_REVERB_PROPERTIES),
2161 "::",
2162 stringify!(HFDecayRatio)
2163 )
2164 );
2165 assert_eq!(
2166 unsafe { ::std::ptr::addr_of!((*ptr).Diffusion) as usize - ptr as usize },
2167 20usize,
2168 concat!(
2169 "Offset of field: ",
2170 stringify!(FMOD_REVERB_PROPERTIES),
2171 "::",
2172 stringify!(Diffusion)
2173 )
2174 );
2175 assert_eq!(
2176 unsafe { ::std::ptr::addr_of!((*ptr).Density) as usize - ptr as usize },
2177 24usize,
2178 concat!(
2179 "Offset of field: ",
2180 stringify!(FMOD_REVERB_PROPERTIES),
2181 "::",
2182 stringify!(Density)
2183 )
2184 );
2185 assert_eq!(
2186 unsafe { ::std::ptr::addr_of!((*ptr).LowShelfFrequency) as usize - ptr as usize },
2187 28usize,
2188 concat!(
2189 "Offset of field: ",
2190 stringify!(FMOD_REVERB_PROPERTIES),
2191 "::",
2192 stringify!(LowShelfFrequency)
2193 )
2194 );
2195 assert_eq!(
2196 unsafe { ::std::ptr::addr_of!((*ptr).LowShelfGain) as usize - ptr as usize },
2197 32usize,
2198 concat!(
2199 "Offset of field: ",
2200 stringify!(FMOD_REVERB_PROPERTIES),
2201 "::",
2202 stringify!(LowShelfGain)
2203 )
2204 );
2205 assert_eq!(
2206 unsafe { ::std::ptr::addr_of!((*ptr).HighCut) as usize - ptr as usize },
2207 36usize,
2208 concat!(
2209 "Offset of field: ",
2210 stringify!(FMOD_REVERB_PROPERTIES),
2211 "::",
2212 stringify!(HighCut)
2213 )
2214 );
2215 assert_eq!(
2216 unsafe { ::std::ptr::addr_of!((*ptr).EarlyLateMix) as usize - ptr as usize },
2217 40usize,
2218 concat!(
2219 "Offset of field: ",
2220 stringify!(FMOD_REVERB_PROPERTIES),
2221 "::",
2222 stringify!(EarlyLateMix)
2223 )
2224 );
2225 assert_eq!(
2226 unsafe { ::std::ptr::addr_of!((*ptr).WetLevel) as usize - ptr as usize },
2227 44usize,
2228 concat!(
2229 "Offset of field: ",
2230 stringify!(FMOD_REVERB_PROPERTIES),
2231 "::",
2232 stringify!(WetLevel)
2233 )
2234 );
2235}
2236#[repr(C)]
2237#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2238pub struct FMOD_ERRORCALLBACK_INFO {
2239 pub result: FMOD_RESULT,
2240 pub instancetype: FMOD_ERRORCALLBACK_INSTANCETYPE,
2241 pub instance: *mut ::std::os::raw::c_void,
2242 pub functionname: *const ::std::os::raw::c_char,
2243 pub functionparams: *const ::std::os::raw::c_char,
2244}
2245#[test]
2246fn bindgen_test_layout_FMOD_ERRORCALLBACK_INFO() {
2247 const UNINIT: ::std::mem::MaybeUninit<FMOD_ERRORCALLBACK_INFO> =
2248 ::std::mem::MaybeUninit::uninit();
2249 let ptr = UNINIT.as_ptr();
2250 assert_eq!(
2251 ::std::mem::size_of::<FMOD_ERRORCALLBACK_INFO>(),
2252 32usize,
2253 concat!("Size of: ", stringify!(FMOD_ERRORCALLBACK_INFO))
2254 );
2255 assert_eq!(
2256 ::std::mem::align_of::<FMOD_ERRORCALLBACK_INFO>(),
2257 8usize,
2258 concat!("Alignment of ", stringify!(FMOD_ERRORCALLBACK_INFO))
2259 );
2260 assert_eq!(
2261 unsafe { ::std::ptr::addr_of!((*ptr).result) as usize - ptr as usize },
2262 0usize,
2263 concat!(
2264 "Offset of field: ",
2265 stringify!(FMOD_ERRORCALLBACK_INFO),
2266 "::",
2267 stringify!(result)
2268 )
2269 );
2270 assert_eq!(
2271 unsafe { ::std::ptr::addr_of!((*ptr).instancetype) as usize - ptr as usize },
2272 4usize,
2273 concat!(
2274 "Offset of field: ",
2275 stringify!(FMOD_ERRORCALLBACK_INFO),
2276 "::",
2277 stringify!(instancetype)
2278 )
2279 );
2280 assert_eq!(
2281 unsafe { ::std::ptr::addr_of!((*ptr).instance) as usize - ptr as usize },
2282 8usize,
2283 concat!(
2284 "Offset of field: ",
2285 stringify!(FMOD_ERRORCALLBACK_INFO),
2286 "::",
2287 stringify!(instance)
2288 )
2289 );
2290 assert_eq!(
2291 unsafe { ::std::ptr::addr_of!((*ptr).functionname) as usize - ptr as usize },
2292 16usize,
2293 concat!(
2294 "Offset of field: ",
2295 stringify!(FMOD_ERRORCALLBACK_INFO),
2296 "::",
2297 stringify!(functionname)
2298 )
2299 );
2300 assert_eq!(
2301 unsafe { ::std::ptr::addr_of!((*ptr).functionparams) as usize - ptr as usize },
2302 24usize,
2303 concat!(
2304 "Offset of field: ",
2305 stringify!(FMOD_ERRORCALLBACK_INFO),
2306 "::",
2307 stringify!(functionparams)
2308 )
2309 );
2310}
2311impl Default for FMOD_ERRORCALLBACK_INFO {
2312 fn default() -> Self {
2313 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2314 unsafe {
2315 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2316 s.assume_init()
2317 }
2318 }
2319}
2320#[repr(C)]
2321#[derive(Debug, Default, Copy, Clone, PartialEq)]
2322pub struct FMOD_CPU_USAGE {
2323 pub dsp: f32,
2324 pub stream: f32,
2325 pub geometry: f32,
2326 pub update: f32,
2327 pub convolution1: f32,
2328 pub convolution2: f32,
2329}
2330#[test]
2331fn bindgen_test_layout_FMOD_CPU_USAGE() {
2332 const UNINIT: ::std::mem::MaybeUninit<FMOD_CPU_USAGE> = ::std::mem::MaybeUninit::uninit();
2333 let ptr = UNINIT.as_ptr();
2334 assert_eq!(
2335 ::std::mem::size_of::<FMOD_CPU_USAGE>(),
2336 24usize,
2337 concat!("Size of: ", stringify!(FMOD_CPU_USAGE))
2338 );
2339 assert_eq!(
2340 ::std::mem::align_of::<FMOD_CPU_USAGE>(),
2341 4usize,
2342 concat!("Alignment of ", stringify!(FMOD_CPU_USAGE))
2343 );
2344 assert_eq!(
2345 unsafe { ::std::ptr::addr_of!((*ptr).dsp) as usize - ptr as usize },
2346 0usize,
2347 concat!(
2348 "Offset of field: ",
2349 stringify!(FMOD_CPU_USAGE),
2350 "::",
2351 stringify!(dsp)
2352 )
2353 );
2354 assert_eq!(
2355 unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
2356 4usize,
2357 concat!(
2358 "Offset of field: ",
2359 stringify!(FMOD_CPU_USAGE),
2360 "::",
2361 stringify!(stream)
2362 )
2363 );
2364 assert_eq!(
2365 unsafe { ::std::ptr::addr_of!((*ptr).geometry) as usize - ptr as usize },
2366 8usize,
2367 concat!(
2368 "Offset of field: ",
2369 stringify!(FMOD_CPU_USAGE),
2370 "::",
2371 stringify!(geometry)
2372 )
2373 );
2374 assert_eq!(
2375 unsafe { ::std::ptr::addr_of!((*ptr).update) as usize - ptr as usize },
2376 12usize,
2377 concat!(
2378 "Offset of field: ",
2379 stringify!(FMOD_CPU_USAGE),
2380 "::",
2381 stringify!(update)
2382 )
2383 );
2384 assert_eq!(
2385 unsafe { ::std::ptr::addr_of!((*ptr).convolution1) as usize - ptr as usize },
2386 16usize,
2387 concat!(
2388 "Offset of field: ",
2389 stringify!(FMOD_CPU_USAGE),
2390 "::",
2391 stringify!(convolution1)
2392 )
2393 );
2394 assert_eq!(
2395 unsafe { ::std::ptr::addr_of!((*ptr).convolution2) as usize - ptr as usize },
2396 20usize,
2397 concat!(
2398 "Offset of field: ",
2399 stringify!(FMOD_CPU_USAGE),
2400 "::",
2401 stringify!(convolution2)
2402 )
2403 );
2404}
2405#[repr(C)]
2406#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2407pub struct FMOD_DSP_DATA_PARAMETER_INFO {
2408 pub data: *mut ::std::os::raw::c_void,
2409 pub length: ::std::os::raw::c_uint,
2410 pub index: ::std::os::raw::c_int,
2411}
2412#[test]
2413fn bindgen_test_layout_FMOD_DSP_DATA_PARAMETER_INFO() {
2414 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_DATA_PARAMETER_INFO> =
2415 ::std::mem::MaybeUninit::uninit();
2416 let ptr = UNINIT.as_ptr();
2417 assert_eq!(
2418 ::std::mem::size_of::<FMOD_DSP_DATA_PARAMETER_INFO>(),
2419 16usize,
2420 concat!("Size of: ", stringify!(FMOD_DSP_DATA_PARAMETER_INFO))
2421 );
2422 assert_eq!(
2423 ::std::mem::align_of::<FMOD_DSP_DATA_PARAMETER_INFO>(),
2424 8usize,
2425 concat!("Alignment of ", stringify!(FMOD_DSP_DATA_PARAMETER_INFO))
2426 );
2427 assert_eq!(
2428 unsafe { ::std::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
2429 0usize,
2430 concat!(
2431 "Offset of field: ",
2432 stringify!(FMOD_DSP_DATA_PARAMETER_INFO),
2433 "::",
2434 stringify!(data)
2435 )
2436 );
2437 assert_eq!(
2438 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
2439 8usize,
2440 concat!(
2441 "Offset of field: ",
2442 stringify!(FMOD_DSP_DATA_PARAMETER_INFO),
2443 "::",
2444 stringify!(length)
2445 )
2446 );
2447 assert_eq!(
2448 unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
2449 12usize,
2450 concat!(
2451 "Offset of field: ",
2452 stringify!(FMOD_DSP_DATA_PARAMETER_INFO),
2453 "::",
2454 stringify!(index)
2455 )
2456 );
2457}
2458impl Default for FMOD_DSP_DATA_PARAMETER_INFO {
2459 fn default() -> Self {
2460 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2461 unsafe {
2462 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2463 s.assume_init()
2464 }
2465 }
2466}
2467pub type FMOD_CODEC_SEEK_METHOD = ::std::os::raw::c_int;
2468pub type FMOD_CODEC_OPEN_CALLBACK = ::std::option::Option<
2469 unsafe extern "C" fn(
2470 codec_state: *mut FMOD_CODEC_STATE,
2471 usermode: FMOD_MODE,
2472 userexinfo: *mut FMOD_CREATESOUNDEXINFO,
2473 ) -> FMOD_RESULT,
2474>;
2475pub type FMOD_CODEC_CLOSE_CALLBACK =
2476 ::std::option::Option<unsafe extern "C" fn(codec_state: *mut FMOD_CODEC_STATE) -> FMOD_RESULT>;
2477pub type FMOD_CODEC_READ_CALLBACK = ::std::option::Option<
2478 unsafe extern "C" fn(
2479 codec_state: *mut FMOD_CODEC_STATE,
2480 buffer: *mut ::std::os::raw::c_void,
2481 samples_in: ::std::os::raw::c_uint,
2482 samples_out: *mut ::std::os::raw::c_uint,
2483 ) -> FMOD_RESULT,
2484>;
2485pub type FMOD_CODEC_GETLENGTH_CALLBACK = ::std::option::Option<
2486 unsafe extern "C" fn(
2487 codec_state: *mut FMOD_CODEC_STATE,
2488 length: *mut ::std::os::raw::c_uint,
2489 lengthtype: FMOD_TIMEUNIT,
2490 ) -> FMOD_RESULT,
2491>;
2492pub type FMOD_CODEC_SETPOSITION_CALLBACK = ::std::option::Option<
2493 unsafe extern "C" fn(
2494 codec_state: *mut FMOD_CODEC_STATE,
2495 subsound: ::std::os::raw::c_int,
2496 position: ::std::os::raw::c_uint,
2497 postype: FMOD_TIMEUNIT,
2498 ) -> FMOD_RESULT,
2499>;
2500pub type FMOD_CODEC_GETPOSITION_CALLBACK = ::std::option::Option<
2501 unsafe extern "C" fn(
2502 codec_state: *mut FMOD_CODEC_STATE,
2503 position: *mut ::std::os::raw::c_uint,
2504 postype: FMOD_TIMEUNIT,
2505 ) -> FMOD_RESULT,
2506>;
2507pub type FMOD_CODEC_SOUNDCREATE_CALLBACK = ::std::option::Option<
2508 unsafe extern "C" fn(
2509 codec_state: *mut FMOD_CODEC_STATE,
2510 subsound: ::std::os::raw::c_int,
2511 sound: *mut FMOD_SOUND,
2512 ) -> FMOD_RESULT,
2513>;
2514pub type FMOD_CODEC_GETWAVEFORMAT_CALLBACK = ::std::option::Option<
2515 unsafe extern "C" fn(
2516 codec_state: *mut FMOD_CODEC_STATE,
2517 index: ::std::os::raw::c_int,
2518 waveformat: *mut FMOD_CODEC_WAVEFORMAT,
2519 ) -> FMOD_RESULT,
2520>;
2521pub type FMOD_CODEC_METADATA_FUNC = ::std::option::Option<
2522 unsafe extern "C" fn(
2523 codec_state: *mut FMOD_CODEC_STATE,
2524 tagtype: FMOD_TAGTYPE,
2525 name: *mut ::std::os::raw::c_char,
2526 data: *mut ::std::os::raw::c_void,
2527 datalen: ::std::os::raw::c_uint,
2528 datatype: FMOD_TAGDATATYPE,
2529 unique: ::std::os::raw::c_int,
2530 ) -> FMOD_RESULT,
2531>;
2532pub type FMOD_CODEC_ALLOC_FUNC = ::std::option::Option<
2533 unsafe extern "C" fn(
2534 size: ::std::os::raw::c_uint,
2535 align: ::std::os::raw::c_uint,
2536 file: *const ::std::os::raw::c_char,
2537 line: ::std::os::raw::c_int,
2538 ) -> *mut ::std::os::raw::c_void,
2539>;
2540pub type FMOD_CODEC_FREE_FUNC = ::std::option::Option<
2541 unsafe extern "C" fn(
2542 ptr: *mut ::std::os::raw::c_void,
2543 file: *const ::std::os::raw::c_char,
2544 line: ::std::os::raw::c_int,
2545 ),
2546>;
2547pub type FMOD_CODEC_LOG_FUNC = ::std::option::Option<
2548 unsafe extern "C" fn(
2549 level: FMOD_DEBUG_FLAGS,
2550 file: *const ::std::os::raw::c_char,
2551 line: ::std::os::raw::c_int,
2552 function: *const ::std::os::raw::c_char,
2553 string: *const ::std::os::raw::c_char,
2554 ...
2555 ),
2556>;
2557pub type FMOD_CODEC_FILE_READ_FUNC = ::std::option::Option<
2558 unsafe extern "C" fn(
2559 codec_state: *mut FMOD_CODEC_STATE,
2560 buffer: *mut ::std::os::raw::c_void,
2561 sizebytes: ::std::os::raw::c_uint,
2562 bytesread: *mut ::std::os::raw::c_uint,
2563 ) -> FMOD_RESULT,
2564>;
2565pub type FMOD_CODEC_FILE_SEEK_FUNC = ::std::option::Option<
2566 unsafe extern "C" fn(
2567 codec_state: *mut FMOD_CODEC_STATE,
2568 pos: ::std::os::raw::c_uint,
2569 method: FMOD_CODEC_SEEK_METHOD,
2570 ) -> FMOD_RESULT,
2571>;
2572pub type FMOD_CODEC_FILE_TELL_FUNC = ::std::option::Option<
2573 unsafe extern "C" fn(
2574 codec_state: *mut FMOD_CODEC_STATE,
2575 pos: *mut ::std::os::raw::c_uint,
2576 ) -> FMOD_RESULT,
2577>;
2578pub type FMOD_CODEC_FILE_SIZE_FUNC = ::std::option::Option<
2579 unsafe extern "C" fn(
2580 codec_state: *mut FMOD_CODEC_STATE,
2581 size: *mut ::std::os::raw::c_uint,
2582 ) -> FMOD_RESULT,
2583>;
2584#[repr(C)]
2585#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
2586pub struct FMOD_CODEC_DESCRIPTION {
2587 pub apiversion: ::std::os::raw::c_uint,
2588 pub name: *const ::std::os::raw::c_char,
2589 pub version: ::std::os::raw::c_uint,
2590 pub defaultasstream: ::std::os::raw::c_int,
2591 pub timeunits: FMOD_TIMEUNIT,
2592 pub open: FMOD_CODEC_OPEN_CALLBACK,
2593 pub close: FMOD_CODEC_CLOSE_CALLBACK,
2594 pub read: FMOD_CODEC_READ_CALLBACK,
2595 pub getlength: FMOD_CODEC_GETLENGTH_CALLBACK,
2596 pub setposition: FMOD_CODEC_SETPOSITION_CALLBACK,
2597 pub getposition: FMOD_CODEC_GETPOSITION_CALLBACK,
2598 pub soundcreate: FMOD_CODEC_SOUNDCREATE_CALLBACK,
2599 pub getwaveformat: FMOD_CODEC_GETWAVEFORMAT_CALLBACK,
2600}
2601#[test]
2602fn bindgen_test_layout_FMOD_CODEC_DESCRIPTION() {
2603 const UNINIT: ::std::mem::MaybeUninit<FMOD_CODEC_DESCRIPTION> =
2604 ::std::mem::MaybeUninit::uninit();
2605 let ptr = UNINIT.as_ptr();
2606 assert_eq!(
2607 ::std::mem::size_of::<FMOD_CODEC_DESCRIPTION>(),
2608 96usize,
2609 concat!("Size of: ", stringify!(FMOD_CODEC_DESCRIPTION))
2610 );
2611 assert_eq!(
2612 ::std::mem::align_of::<FMOD_CODEC_DESCRIPTION>(),
2613 8usize,
2614 concat!("Alignment of ", stringify!(FMOD_CODEC_DESCRIPTION))
2615 );
2616 assert_eq!(
2617 unsafe { ::std::ptr::addr_of!((*ptr).apiversion) as usize - ptr as usize },
2618 0usize,
2619 concat!(
2620 "Offset of field: ",
2621 stringify!(FMOD_CODEC_DESCRIPTION),
2622 "::",
2623 stringify!(apiversion)
2624 )
2625 );
2626 assert_eq!(
2627 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2628 8usize,
2629 concat!(
2630 "Offset of field: ",
2631 stringify!(FMOD_CODEC_DESCRIPTION),
2632 "::",
2633 stringify!(name)
2634 )
2635 );
2636 assert_eq!(
2637 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
2638 16usize,
2639 concat!(
2640 "Offset of field: ",
2641 stringify!(FMOD_CODEC_DESCRIPTION),
2642 "::",
2643 stringify!(version)
2644 )
2645 );
2646 assert_eq!(
2647 unsafe { ::std::ptr::addr_of!((*ptr).defaultasstream) as usize - ptr as usize },
2648 20usize,
2649 concat!(
2650 "Offset of field: ",
2651 stringify!(FMOD_CODEC_DESCRIPTION),
2652 "::",
2653 stringify!(defaultasstream)
2654 )
2655 );
2656 assert_eq!(
2657 unsafe { ::std::ptr::addr_of!((*ptr).timeunits) as usize - ptr as usize },
2658 24usize,
2659 concat!(
2660 "Offset of field: ",
2661 stringify!(FMOD_CODEC_DESCRIPTION),
2662 "::",
2663 stringify!(timeunits)
2664 )
2665 );
2666 assert_eq!(
2667 unsafe { ::std::ptr::addr_of!((*ptr).open) as usize - ptr as usize },
2668 32usize,
2669 concat!(
2670 "Offset of field: ",
2671 stringify!(FMOD_CODEC_DESCRIPTION),
2672 "::",
2673 stringify!(open)
2674 )
2675 );
2676 assert_eq!(
2677 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
2678 40usize,
2679 concat!(
2680 "Offset of field: ",
2681 stringify!(FMOD_CODEC_DESCRIPTION),
2682 "::",
2683 stringify!(close)
2684 )
2685 );
2686 assert_eq!(
2687 unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
2688 48usize,
2689 concat!(
2690 "Offset of field: ",
2691 stringify!(FMOD_CODEC_DESCRIPTION),
2692 "::",
2693 stringify!(read)
2694 )
2695 );
2696 assert_eq!(
2697 unsafe { ::std::ptr::addr_of!((*ptr).getlength) as usize - ptr as usize },
2698 56usize,
2699 concat!(
2700 "Offset of field: ",
2701 stringify!(FMOD_CODEC_DESCRIPTION),
2702 "::",
2703 stringify!(getlength)
2704 )
2705 );
2706 assert_eq!(
2707 unsafe { ::std::ptr::addr_of!((*ptr).setposition) as usize - ptr as usize },
2708 64usize,
2709 concat!(
2710 "Offset of field: ",
2711 stringify!(FMOD_CODEC_DESCRIPTION),
2712 "::",
2713 stringify!(setposition)
2714 )
2715 );
2716 assert_eq!(
2717 unsafe { ::std::ptr::addr_of!((*ptr).getposition) as usize - ptr as usize },
2718 72usize,
2719 concat!(
2720 "Offset of field: ",
2721 stringify!(FMOD_CODEC_DESCRIPTION),
2722 "::",
2723 stringify!(getposition)
2724 )
2725 );
2726 assert_eq!(
2727 unsafe { ::std::ptr::addr_of!((*ptr).soundcreate) as usize - ptr as usize },
2728 80usize,
2729 concat!(
2730 "Offset of field: ",
2731 stringify!(FMOD_CODEC_DESCRIPTION),
2732 "::",
2733 stringify!(soundcreate)
2734 )
2735 );
2736 assert_eq!(
2737 unsafe { ::std::ptr::addr_of!((*ptr).getwaveformat) as usize - ptr as usize },
2738 88usize,
2739 concat!(
2740 "Offset of field: ",
2741 stringify!(FMOD_CODEC_DESCRIPTION),
2742 "::",
2743 stringify!(getwaveformat)
2744 )
2745 );
2746}
2747impl Default for FMOD_CODEC_DESCRIPTION {
2748 fn default() -> Self {
2749 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2750 unsafe {
2751 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2752 s.assume_init()
2753 }
2754 }
2755}
2756#[repr(C)]
2757#[derive(Debug, Copy, Clone, PartialEq)]
2758pub struct FMOD_CODEC_WAVEFORMAT {
2759 pub name: *const ::std::os::raw::c_char,
2760 pub format: FMOD_SOUND_FORMAT,
2761 pub channels: ::std::os::raw::c_int,
2762 pub frequency: ::std::os::raw::c_int,
2763 pub lengthbytes: ::std::os::raw::c_uint,
2764 pub lengthpcm: ::std::os::raw::c_uint,
2765 pub pcmblocksize: ::std::os::raw::c_uint,
2766 pub loopstart: ::std::os::raw::c_int,
2767 pub loopend: ::std::os::raw::c_int,
2768 pub mode: FMOD_MODE,
2769 pub channelmask: FMOD_CHANNELMASK,
2770 pub channelorder: FMOD_CHANNELORDER,
2771 pub peakvolume: f32,
2772}
2773#[test]
2774fn bindgen_test_layout_FMOD_CODEC_WAVEFORMAT() {
2775 const UNINIT: ::std::mem::MaybeUninit<FMOD_CODEC_WAVEFORMAT> =
2776 ::std::mem::MaybeUninit::uninit();
2777 let ptr = UNINIT.as_ptr();
2778 assert_eq!(
2779 ::std::mem::size_of::<FMOD_CODEC_WAVEFORMAT>(),
2780 56usize,
2781 concat!("Size of: ", stringify!(FMOD_CODEC_WAVEFORMAT))
2782 );
2783 assert_eq!(
2784 ::std::mem::align_of::<FMOD_CODEC_WAVEFORMAT>(),
2785 8usize,
2786 concat!("Alignment of ", stringify!(FMOD_CODEC_WAVEFORMAT))
2787 );
2788 assert_eq!(
2789 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
2790 0usize,
2791 concat!(
2792 "Offset of field: ",
2793 stringify!(FMOD_CODEC_WAVEFORMAT),
2794 "::",
2795 stringify!(name)
2796 )
2797 );
2798 assert_eq!(
2799 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
2800 8usize,
2801 concat!(
2802 "Offset of field: ",
2803 stringify!(FMOD_CODEC_WAVEFORMAT),
2804 "::",
2805 stringify!(format)
2806 )
2807 );
2808 assert_eq!(
2809 unsafe { ::std::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
2810 12usize,
2811 concat!(
2812 "Offset of field: ",
2813 stringify!(FMOD_CODEC_WAVEFORMAT),
2814 "::",
2815 stringify!(channels)
2816 )
2817 );
2818 assert_eq!(
2819 unsafe { ::std::ptr::addr_of!((*ptr).frequency) as usize - ptr as usize },
2820 16usize,
2821 concat!(
2822 "Offset of field: ",
2823 stringify!(FMOD_CODEC_WAVEFORMAT),
2824 "::",
2825 stringify!(frequency)
2826 )
2827 );
2828 assert_eq!(
2829 unsafe { ::std::ptr::addr_of!((*ptr).lengthbytes) as usize - ptr as usize },
2830 20usize,
2831 concat!(
2832 "Offset of field: ",
2833 stringify!(FMOD_CODEC_WAVEFORMAT),
2834 "::",
2835 stringify!(lengthbytes)
2836 )
2837 );
2838 assert_eq!(
2839 unsafe { ::std::ptr::addr_of!((*ptr).lengthpcm) as usize - ptr as usize },
2840 24usize,
2841 concat!(
2842 "Offset of field: ",
2843 stringify!(FMOD_CODEC_WAVEFORMAT),
2844 "::",
2845 stringify!(lengthpcm)
2846 )
2847 );
2848 assert_eq!(
2849 unsafe { ::std::ptr::addr_of!((*ptr).pcmblocksize) as usize - ptr as usize },
2850 28usize,
2851 concat!(
2852 "Offset of field: ",
2853 stringify!(FMOD_CODEC_WAVEFORMAT),
2854 "::",
2855 stringify!(pcmblocksize)
2856 )
2857 );
2858 assert_eq!(
2859 unsafe { ::std::ptr::addr_of!((*ptr).loopstart) as usize - ptr as usize },
2860 32usize,
2861 concat!(
2862 "Offset of field: ",
2863 stringify!(FMOD_CODEC_WAVEFORMAT),
2864 "::",
2865 stringify!(loopstart)
2866 )
2867 );
2868 assert_eq!(
2869 unsafe { ::std::ptr::addr_of!((*ptr).loopend) as usize - ptr as usize },
2870 36usize,
2871 concat!(
2872 "Offset of field: ",
2873 stringify!(FMOD_CODEC_WAVEFORMAT),
2874 "::",
2875 stringify!(loopend)
2876 )
2877 );
2878 assert_eq!(
2879 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
2880 40usize,
2881 concat!(
2882 "Offset of field: ",
2883 stringify!(FMOD_CODEC_WAVEFORMAT),
2884 "::",
2885 stringify!(mode)
2886 )
2887 );
2888 assert_eq!(
2889 unsafe { ::std::ptr::addr_of!((*ptr).channelmask) as usize - ptr as usize },
2890 44usize,
2891 concat!(
2892 "Offset of field: ",
2893 stringify!(FMOD_CODEC_WAVEFORMAT),
2894 "::",
2895 stringify!(channelmask)
2896 )
2897 );
2898 assert_eq!(
2899 unsafe { ::std::ptr::addr_of!((*ptr).channelorder) as usize - ptr as usize },
2900 48usize,
2901 concat!(
2902 "Offset of field: ",
2903 stringify!(FMOD_CODEC_WAVEFORMAT),
2904 "::",
2905 stringify!(channelorder)
2906 )
2907 );
2908 assert_eq!(
2909 unsafe { ::std::ptr::addr_of!((*ptr).peakvolume) as usize - ptr as usize },
2910 52usize,
2911 concat!(
2912 "Offset of field: ",
2913 stringify!(FMOD_CODEC_WAVEFORMAT),
2914 "::",
2915 stringify!(peakvolume)
2916 )
2917 );
2918}
2919impl Default for FMOD_CODEC_WAVEFORMAT {
2920 fn default() -> Self {
2921 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2922 unsafe {
2923 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2924 s.assume_init()
2925 }
2926 }
2927}
2928#[repr(C)]
2929#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
2930pub struct FMOD_CODEC_STATE_FUNCTIONS {
2931 pub metadata: FMOD_CODEC_METADATA_FUNC,
2932 pub alloc: FMOD_CODEC_ALLOC_FUNC,
2933 pub free: FMOD_CODEC_FREE_FUNC,
2934 pub log: FMOD_CODEC_LOG_FUNC,
2935 pub read: FMOD_CODEC_FILE_READ_FUNC,
2936 pub seek: FMOD_CODEC_FILE_SEEK_FUNC,
2937 pub tell: FMOD_CODEC_FILE_TELL_FUNC,
2938 pub size: FMOD_CODEC_FILE_SIZE_FUNC,
2939}
2940#[test]
2941fn bindgen_test_layout_FMOD_CODEC_STATE_FUNCTIONS() {
2942 const UNINIT: ::std::mem::MaybeUninit<FMOD_CODEC_STATE_FUNCTIONS> =
2943 ::std::mem::MaybeUninit::uninit();
2944 let ptr = UNINIT.as_ptr();
2945 assert_eq!(
2946 ::std::mem::size_of::<FMOD_CODEC_STATE_FUNCTIONS>(),
2947 64usize,
2948 concat!("Size of: ", stringify!(FMOD_CODEC_STATE_FUNCTIONS))
2949 );
2950 assert_eq!(
2951 ::std::mem::align_of::<FMOD_CODEC_STATE_FUNCTIONS>(),
2952 8usize,
2953 concat!("Alignment of ", stringify!(FMOD_CODEC_STATE_FUNCTIONS))
2954 );
2955 assert_eq!(
2956 unsafe { ::std::ptr::addr_of!((*ptr).metadata) as usize - ptr as usize },
2957 0usize,
2958 concat!(
2959 "Offset of field: ",
2960 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
2961 "::",
2962 stringify!(metadata)
2963 )
2964 );
2965 assert_eq!(
2966 unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
2967 8usize,
2968 concat!(
2969 "Offset of field: ",
2970 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
2971 "::",
2972 stringify!(alloc)
2973 )
2974 );
2975 assert_eq!(
2976 unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
2977 16usize,
2978 concat!(
2979 "Offset of field: ",
2980 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
2981 "::",
2982 stringify!(free)
2983 )
2984 );
2985 assert_eq!(
2986 unsafe { ::std::ptr::addr_of!((*ptr).log) as usize - ptr as usize },
2987 24usize,
2988 concat!(
2989 "Offset of field: ",
2990 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
2991 "::",
2992 stringify!(log)
2993 )
2994 );
2995 assert_eq!(
2996 unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
2997 32usize,
2998 concat!(
2999 "Offset of field: ",
3000 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
3001 "::",
3002 stringify!(read)
3003 )
3004 );
3005 assert_eq!(
3006 unsafe { ::std::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
3007 40usize,
3008 concat!(
3009 "Offset of field: ",
3010 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
3011 "::",
3012 stringify!(seek)
3013 )
3014 );
3015 assert_eq!(
3016 unsafe { ::std::ptr::addr_of!((*ptr).tell) as usize - ptr as usize },
3017 48usize,
3018 concat!(
3019 "Offset of field: ",
3020 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
3021 "::",
3022 stringify!(tell)
3023 )
3024 );
3025 assert_eq!(
3026 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
3027 56usize,
3028 concat!(
3029 "Offset of field: ",
3030 stringify!(FMOD_CODEC_STATE_FUNCTIONS),
3031 "::",
3032 stringify!(size)
3033 )
3034 );
3035}
3036#[repr(C)]
3037#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3038pub struct FMOD_CODEC_STATE {
3039 pub plugindata: *mut ::std::os::raw::c_void,
3040 pub waveformat: *mut FMOD_CODEC_WAVEFORMAT,
3041 pub functions: *mut FMOD_CODEC_STATE_FUNCTIONS,
3042 pub numsubsounds: ::std::os::raw::c_int,
3043}
3044#[test]
3045fn bindgen_test_layout_FMOD_CODEC_STATE() {
3046 const UNINIT: ::std::mem::MaybeUninit<FMOD_CODEC_STATE> = ::std::mem::MaybeUninit::uninit();
3047 let ptr = UNINIT.as_ptr();
3048 assert_eq!(
3049 ::std::mem::size_of::<FMOD_CODEC_STATE>(),
3050 32usize,
3051 concat!("Size of: ", stringify!(FMOD_CODEC_STATE))
3052 );
3053 assert_eq!(
3054 ::std::mem::align_of::<FMOD_CODEC_STATE>(),
3055 8usize,
3056 concat!("Alignment of ", stringify!(FMOD_CODEC_STATE))
3057 );
3058 assert_eq!(
3059 unsafe { ::std::ptr::addr_of!((*ptr).plugindata) as usize - ptr as usize },
3060 0usize,
3061 concat!(
3062 "Offset of field: ",
3063 stringify!(FMOD_CODEC_STATE),
3064 "::",
3065 stringify!(plugindata)
3066 )
3067 );
3068 assert_eq!(
3069 unsafe { ::std::ptr::addr_of!((*ptr).waveformat) as usize - ptr as usize },
3070 8usize,
3071 concat!(
3072 "Offset of field: ",
3073 stringify!(FMOD_CODEC_STATE),
3074 "::",
3075 stringify!(waveformat)
3076 )
3077 );
3078 assert_eq!(
3079 unsafe { ::std::ptr::addr_of!((*ptr).functions) as usize - ptr as usize },
3080 16usize,
3081 concat!(
3082 "Offset of field: ",
3083 stringify!(FMOD_CODEC_STATE),
3084 "::",
3085 stringify!(functions)
3086 )
3087 );
3088 assert_eq!(
3089 unsafe { ::std::ptr::addr_of!((*ptr).numsubsounds) as usize - ptr as usize },
3090 24usize,
3091 concat!(
3092 "Offset of field: ",
3093 stringify!(FMOD_CODEC_STATE),
3094 "::",
3095 stringify!(numsubsounds)
3096 )
3097 );
3098}
3099impl Default for FMOD_CODEC_STATE {
3100 fn default() -> Self {
3101 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3102 unsafe {
3103 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3104 s.assume_init()
3105 }
3106 }
3107}
3108pub const FMOD_DSP_TYPE_UNKNOWN: FMOD_DSP_TYPE = 0;
3109pub const FMOD_DSP_TYPE_MIXER: FMOD_DSP_TYPE = 1;
3110pub const FMOD_DSP_TYPE_OSCILLATOR: FMOD_DSP_TYPE = 2;
3111pub const FMOD_DSP_TYPE_LOWPASS: FMOD_DSP_TYPE = 3;
3112pub const FMOD_DSP_TYPE_ITLOWPASS: FMOD_DSP_TYPE = 4;
3113pub const FMOD_DSP_TYPE_HIGHPASS: FMOD_DSP_TYPE = 5;
3114pub const FMOD_DSP_TYPE_ECHO: FMOD_DSP_TYPE = 6;
3115pub const FMOD_DSP_TYPE_FADER: FMOD_DSP_TYPE = 7;
3116pub const FMOD_DSP_TYPE_FLANGE: FMOD_DSP_TYPE = 8;
3117pub const FMOD_DSP_TYPE_DISTORTION: FMOD_DSP_TYPE = 9;
3118pub const FMOD_DSP_TYPE_NORMALIZE: FMOD_DSP_TYPE = 10;
3119pub const FMOD_DSP_TYPE_LIMITER: FMOD_DSP_TYPE = 11;
3120pub const FMOD_DSP_TYPE_PARAMEQ: FMOD_DSP_TYPE = 12;
3121pub const FMOD_DSP_TYPE_PITCHSHIFT: FMOD_DSP_TYPE = 13;
3122pub const FMOD_DSP_TYPE_CHORUS: FMOD_DSP_TYPE = 14;
3123pub const FMOD_DSP_TYPE_VSTPLUGIN: FMOD_DSP_TYPE = 15;
3124pub const FMOD_DSP_TYPE_WINAMPPLUGIN: FMOD_DSP_TYPE = 16;
3125pub const FMOD_DSP_TYPE_ITECHO: FMOD_DSP_TYPE = 17;
3126pub const FMOD_DSP_TYPE_COMPRESSOR: FMOD_DSP_TYPE = 18;
3127pub const FMOD_DSP_TYPE_SFXREVERB: FMOD_DSP_TYPE = 19;
3128pub const FMOD_DSP_TYPE_LOWPASS_SIMPLE: FMOD_DSP_TYPE = 20;
3129pub const FMOD_DSP_TYPE_DELAY: FMOD_DSP_TYPE = 21;
3130pub const FMOD_DSP_TYPE_TREMOLO: FMOD_DSP_TYPE = 22;
3131pub const FMOD_DSP_TYPE_LADSPAPLUGIN: FMOD_DSP_TYPE = 23;
3132pub const FMOD_DSP_TYPE_SEND: FMOD_DSP_TYPE = 24;
3133pub const FMOD_DSP_TYPE_RETURN: FMOD_DSP_TYPE = 25;
3134pub const FMOD_DSP_TYPE_HIGHPASS_SIMPLE: FMOD_DSP_TYPE = 26;
3135pub const FMOD_DSP_TYPE_PAN: FMOD_DSP_TYPE = 27;
3136pub const FMOD_DSP_TYPE_THREE_EQ: FMOD_DSP_TYPE = 28;
3137pub const FMOD_DSP_TYPE_FFT: FMOD_DSP_TYPE = 29;
3138pub const FMOD_DSP_TYPE_LOUDNESS_METER: FMOD_DSP_TYPE = 30;
3139pub const FMOD_DSP_TYPE_ENVELOPEFOLLOWER: FMOD_DSP_TYPE = 31;
3140pub const FMOD_DSP_TYPE_CONVOLUTIONREVERB: FMOD_DSP_TYPE = 32;
3141pub const FMOD_DSP_TYPE_CHANNELMIX: FMOD_DSP_TYPE = 33;
3142pub const FMOD_DSP_TYPE_TRANSCEIVER: FMOD_DSP_TYPE = 34;
3143pub const FMOD_DSP_TYPE_OBJECTPAN: FMOD_DSP_TYPE = 35;
3144pub const FMOD_DSP_TYPE_MULTIBAND_EQ: FMOD_DSP_TYPE = 36;
3145pub const FMOD_DSP_TYPE_MAX: FMOD_DSP_TYPE = 37;
3146pub const FMOD_DSP_TYPE_FORCEINT: FMOD_DSP_TYPE = 65536;
3147pub type FMOD_DSP_TYPE = ::std::os::raw::c_uint;
3148pub const FMOD_DSP_OSCILLATOR_TYPE: FMOD_DSP_OSCILLATOR = 0;
3149pub const FMOD_DSP_OSCILLATOR_RATE: FMOD_DSP_OSCILLATOR = 1;
3150pub type FMOD_DSP_OSCILLATOR = ::std::os::raw::c_uint;
3151pub const FMOD_DSP_LOWPASS_CUTOFF: FMOD_DSP_LOWPASS = 0;
3152pub const FMOD_DSP_LOWPASS_RESONANCE: FMOD_DSP_LOWPASS = 1;
3153pub type FMOD_DSP_LOWPASS = ::std::os::raw::c_uint;
3154pub const FMOD_DSP_ITLOWPASS_CUTOFF: FMOD_DSP_ITLOWPASS = 0;
3155pub const FMOD_DSP_ITLOWPASS_RESONANCE: FMOD_DSP_ITLOWPASS = 1;
3156pub type FMOD_DSP_ITLOWPASS = ::std::os::raw::c_uint;
3157pub const FMOD_DSP_HIGHPASS_CUTOFF: FMOD_DSP_HIGHPASS = 0;
3158pub const FMOD_DSP_HIGHPASS_RESONANCE: FMOD_DSP_HIGHPASS = 1;
3159pub type FMOD_DSP_HIGHPASS = ::std::os::raw::c_uint;
3160pub const FMOD_DSP_ECHO_DELAY: FMOD_DSP_ECHO = 0;
3161pub const FMOD_DSP_ECHO_FEEDBACK: FMOD_DSP_ECHO = 1;
3162pub const FMOD_DSP_ECHO_DRYLEVEL: FMOD_DSP_ECHO = 2;
3163pub const FMOD_DSP_ECHO_WETLEVEL: FMOD_DSP_ECHO = 3;
3164pub type FMOD_DSP_ECHO = ::std::os::raw::c_uint;
3165pub const FMOD_DSP_FADER_GAIN: FMOD_DSP_FADER = 0;
3166pub const FMOD_DSP_FADER_OVERALL_GAIN: FMOD_DSP_FADER = 1;
3167pub type FMOD_DSP_FADER = ::std::os::raw::c_uint;
3168pub const FMOD_DSP_FLANGE_MIX: FMOD_DSP_FLANGE = 0;
3169pub const FMOD_DSP_FLANGE_DEPTH: FMOD_DSP_FLANGE = 1;
3170pub const FMOD_DSP_FLANGE_RATE: FMOD_DSP_FLANGE = 2;
3171pub type FMOD_DSP_FLANGE = ::std::os::raw::c_uint;
3172pub const FMOD_DSP_DISTORTION_LEVEL: FMOD_DSP_DISTORTION = 0;
3173pub type FMOD_DSP_DISTORTION = ::std::os::raw::c_uint;
3174pub const FMOD_DSP_NORMALIZE_FADETIME: FMOD_DSP_NORMALIZE = 0;
3175pub const FMOD_DSP_NORMALIZE_THRESHOLD: FMOD_DSP_NORMALIZE = 1;
3176pub const FMOD_DSP_NORMALIZE_MAXAMP: FMOD_DSP_NORMALIZE = 2;
3177pub type FMOD_DSP_NORMALIZE = ::std::os::raw::c_uint;
3178pub const FMOD_DSP_LIMITER_RELEASETIME: FMOD_DSP_LIMITER = 0;
3179pub const FMOD_DSP_LIMITER_CEILING: FMOD_DSP_LIMITER = 1;
3180pub const FMOD_DSP_LIMITER_MAXIMIZERGAIN: FMOD_DSP_LIMITER = 2;
3181pub const FMOD_DSP_LIMITER_MODE: FMOD_DSP_LIMITER = 3;
3182pub type FMOD_DSP_LIMITER = ::std::os::raw::c_uint;
3183pub const FMOD_DSP_PARAMEQ_CENTER: FMOD_DSP_PARAMEQ = 0;
3184pub const FMOD_DSP_PARAMEQ_BANDWIDTH: FMOD_DSP_PARAMEQ = 1;
3185pub const FMOD_DSP_PARAMEQ_GAIN: FMOD_DSP_PARAMEQ = 2;
3186pub type FMOD_DSP_PARAMEQ = ::std::os::raw::c_uint;
3187pub const FMOD_DSP_MULTIBAND_EQ_A_FILTER: FMOD_DSP_MULTIBAND_EQ = 0;
3188pub const FMOD_DSP_MULTIBAND_EQ_A_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 1;
3189pub const FMOD_DSP_MULTIBAND_EQ_A_Q: FMOD_DSP_MULTIBAND_EQ = 2;
3190pub const FMOD_DSP_MULTIBAND_EQ_A_GAIN: FMOD_DSP_MULTIBAND_EQ = 3;
3191pub const FMOD_DSP_MULTIBAND_EQ_B_FILTER: FMOD_DSP_MULTIBAND_EQ = 4;
3192pub const FMOD_DSP_MULTIBAND_EQ_B_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 5;
3193pub const FMOD_DSP_MULTIBAND_EQ_B_Q: FMOD_DSP_MULTIBAND_EQ = 6;
3194pub const FMOD_DSP_MULTIBAND_EQ_B_GAIN: FMOD_DSP_MULTIBAND_EQ = 7;
3195pub const FMOD_DSP_MULTIBAND_EQ_C_FILTER: FMOD_DSP_MULTIBAND_EQ = 8;
3196pub const FMOD_DSP_MULTIBAND_EQ_C_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 9;
3197pub const FMOD_DSP_MULTIBAND_EQ_C_Q: FMOD_DSP_MULTIBAND_EQ = 10;
3198pub const FMOD_DSP_MULTIBAND_EQ_C_GAIN: FMOD_DSP_MULTIBAND_EQ = 11;
3199pub const FMOD_DSP_MULTIBAND_EQ_D_FILTER: FMOD_DSP_MULTIBAND_EQ = 12;
3200pub const FMOD_DSP_MULTIBAND_EQ_D_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 13;
3201pub const FMOD_DSP_MULTIBAND_EQ_D_Q: FMOD_DSP_MULTIBAND_EQ = 14;
3202pub const FMOD_DSP_MULTIBAND_EQ_D_GAIN: FMOD_DSP_MULTIBAND_EQ = 15;
3203pub const FMOD_DSP_MULTIBAND_EQ_E_FILTER: FMOD_DSP_MULTIBAND_EQ = 16;
3204pub const FMOD_DSP_MULTIBAND_EQ_E_FREQUENCY: FMOD_DSP_MULTIBAND_EQ = 17;
3205pub const FMOD_DSP_MULTIBAND_EQ_E_Q: FMOD_DSP_MULTIBAND_EQ = 18;
3206pub const FMOD_DSP_MULTIBAND_EQ_E_GAIN: FMOD_DSP_MULTIBAND_EQ = 19;
3207pub type FMOD_DSP_MULTIBAND_EQ = ::std::os::raw::c_uint;
3208pub const FMOD_DSP_MULTIBAND_EQ_FILTER_DISABLED: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 0;
3209pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 1;
3210pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 2;
3211pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 3;
3212pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_12DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 4;
3213pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_24DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 5;
3214pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHPASS_48DB: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 6;
3215pub const FMOD_DSP_MULTIBAND_EQ_FILTER_LOWSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 7;
3216pub const FMOD_DSP_MULTIBAND_EQ_FILTER_HIGHSHELF: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 8;
3217pub const FMOD_DSP_MULTIBAND_EQ_FILTER_PEAKING: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 9;
3218pub const FMOD_DSP_MULTIBAND_EQ_FILTER_BANDPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 10;
3219pub const FMOD_DSP_MULTIBAND_EQ_FILTER_NOTCH: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 11;
3220pub const FMOD_DSP_MULTIBAND_EQ_FILTER_ALLPASS: FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = 12;
3221pub type FMOD_DSP_MULTIBAND_EQ_FILTER_TYPE = ::std::os::raw::c_uint;
3222pub const FMOD_DSP_PITCHSHIFT_PITCH: FMOD_DSP_PITCHSHIFT = 0;
3223pub const FMOD_DSP_PITCHSHIFT_FFTSIZE: FMOD_DSP_PITCHSHIFT = 1;
3224pub const FMOD_DSP_PITCHSHIFT_OVERLAP: FMOD_DSP_PITCHSHIFT = 2;
3225pub const FMOD_DSP_PITCHSHIFT_MAXCHANNELS: FMOD_DSP_PITCHSHIFT = 3;
3226pub type FMOD_DSP_PITCHSHIFT = ::std::os::raw::c_uint;
3227pub const FMOD_DSP_CHORUS_MIX: FMOD_DSP_CHORUS = 0;
3228pub const FMOD_DSP_CHORUS_RATE: FMOD_DSP_CHORUS = 1;
3229pub const FMOD_DSP_CHORUS_DEPTH: FMOD_DSP_CHORUS = 2;
3230pub type FMOD_DSP_CHORUS = ::std::os::raw::c_uint;
3231pub const FMOD_DSP_ITECHO_WETDRYMIX: FMOD_DSP_ITECHO = 0;
3232pub const FMOD_DSP_ITECHO_FEEDBACK: FMOD_DSP_ITECHO = 1;
3233pub const FMOD_DSP_ITECHO_LEFTDELAY: FMOD_DSP_ITECHO = 2;
3234pub const FMOD_DSP_ITECHO_RIGHTDELAY: FMOD_DSP_ITECHO = 3;
3235pub const FMOD_DSP_ITECHO_PANDELAY: FMOD_DSP_ITECHO = 4;
3236pub type FMOD_DSP_ITECHO = ::std::os::raw::c_uint;
3237pub const FMOD_DSP_COMPRESSOR_THRESHOLD: FMOD_DSP_COMPRESSOR = 0;
3238pub const FMOD_DSP_COMPRESSOR_RATIO: FMOD_DSP_COMPRESSOR = 1;
3239pub const FMOD_DSP_COMPRESSOR_ATTACK: FMOD_DSP_COMPRESSOR = 2;
3240pub const FMOD_DSP_COMPRESSOR_RELEASE: FMOD_DSP_COMPRESSOR = 3;
3241pub const FMOD_DSP_COMPRESSOR_GAINMAKEUP: FMOD_DSP_COMPRESSOR = 4;
3242pub const FMOD_DSP_COMPRESSOR_USESIDECHAIN: FMOD_DSP_COMPRESSOR = 5;
3243pub const FMOD_DSP_COMPRESSOR_LINKED: FMOD_DSP_COMPRESSOR = 6;
3244pub type FMOD_DSP_COMPRESSOR = ::std::os::raw::c_uint;
3245pub const FMOD_DSP_SFXREVERB_DECAYTIME: FMOD_DSP_SFXREVERB = 0;
3246pub const FMOD_DSP_SFXREVERB_EARLYDELAY: FMOD_DSP_SFXREVERB = 1;
3247pub const FMOD_DSP_SFXREVERB_LATEDELAY: FMOD_DSP_SFXREVERB = 2;
3248pub const FMOD_DSP_SFXREVERB_HFREFERENCE: FMOD_DSP_SFXREVERB = 3;
3249pub const FMOD_DSP_SFXREVERB_HFDECAYRATIO: FMOD_DSP_SFXREVERB = 4;
3250pub const FMOD_DSP_SFXREVERB_DIFFUSION: FMOD_DSP_SFXREVERB = 5;
3251pub const FMOD_DSP_SFXREVERB_DENSITY: FMOD_DSP_SFXREVERB = 6;
3252pub const FMOD_DSP_SFXREVERB_LOWSHELFFREQUENCY: FMOD_DSP_SFXREVERB = 7;
3253pub const FMOD_DSP_SFXREVERB_LOWSHELFGAIN: FMOD_DSP_SFXREVERB = 8;
3254pub const FMOD_DSP_SFXREVERB_HIGHCUT: FMOD_DSP_SFXREVERB = 9;
3255pub const FMOD_DSP_SFXREVERB_EARLYLATEMIX: FMOD_DSP_SFXREVERB = 10;
3256pub const FMOD_DSP_SFXREVERB_WETLEVEL: FMOD_DSP_SFXREVERB = 11;
3257pub const FMOD_DSP_SFXREVERB_DRYLEVEL: FMOD_DSP_SFXREVERB = 12;
3258pub type FMOD_DSP_SFXREVERB = ::std::os::raw::c_uint;
3259pub const FMOD_DSP_LOWPASS_SIMPLE_CUTOFF: FMOD_DSP_LOWPASS_SIMPLE = 0;
3260pub type FMOD_DSP_LOWPASS_SIMPLE = ::std::os::raw::c_uint;
3261pub const FMOD_DSP_DELAY_CH0: FMOD_DSP_DELAY = 0;
3262pub const FMOD_DSP_DELAY_CH1: FMOD_DSP_DELAY = 1;
3263pub const FMOD_DSP_DELAY_CH2: FMOD_DSP_DELAY = 2;
3264pub const FMOD_DSP_DELAY_CH3: FMOD_DSP_DELAY = 3;
3265pub const FMOD_DSP_DELAY_CH4: FMOD_DSP_DELAY = 4;
3266pub const FMOD_DSP_DELAY_CH5: FMOD_DSP_DELAY = 5;
3267pub const FMOD_DSP_DELAY_CH6: FMOD_DSP_DELAY = 6;
3268pub const FMOD_DSP_DELAY_CH7: FMOD_DSP_DELAY = 7;
3269pub const FMOD_DSP_DELAY_CH8: FMOD_DSP_DELAY = 8;
3270pub const FMOD_DSP_DELAY_CH9: FMOD_DSP_DELAY = 9;
3271pub const FMOD_DSP_DELAY_CH10: FMOD_DSP_DELAY = 10;
3272pub const FMOD_DSP_DELAY_CH11: FMOD_DSP_DELAY = 11;
3273pub const FMOD_DSP_DELAY_CH12: FMOD_DSP_DELAY = 12;
3274pub const FMOD_DSP_DELAY_CH13: FMOD_DSP_DELAY = 13;
3275pub const FMOD_DSP_DELAY_CH14: FMOD_DSP_DELAY = 14;
3276pub const FMOD_DSP_DELAY_CH15: FMOD_DSP_DELAY = 15;
3277pub const FMOD_DSP_DELAY_MAXDELAY: FMOD_DSP_DELAY = 16;
3278pub type FMOD_DSP_DELAY = ::std::os::raw::c_uint;
3279pub const FMOD_DSP_TREMOLO_FREQUENCY: FMOD_DSP_TREMOLO = 0;
3280pub const FMOD_DSP_TREMOLO_DEPTH: FMOD_DSP_TREMOLO = 1;
3281pub const FMOD_DSP_TREMOLO_SHAPE: FMOD_DSP_TREMOLO = 2;
3282pub const FMOD_DSP_TREMOLO_SKEW: FMOD_DSP_TREMOLO = 3;
3283pub const FMOD_DSP_TREMOLO_DUTY: FMOD_DSP_TREMOLO = 4;
3284pub const FMOD_DSP_TREMOLO_SQUARE: FMOD_DSP_TREMOLO = 5;
3285pub const FMOD_DSP_TREMOLO_PHASE: FMOD_DSP_TREMOLO = 6;
3286pub const FMOD_DSP_TREMOLO_SPREAD: FMOD_DSP_TREMOLO = 7;
3287pub type FMOD_DSP_TREMOLO = ::std::os::raw::c_uint;
3288pub const FMOD_DSP_SEND_RETURNID: FMOD_DSP_SEND = 0;
3289pub const FMOD_DSP_SEND_LEVEL: FMOD_DSP_SEND = 1;
3290pub type FMOD_DSP_SEND = ::std::os::raw::c_uint;
3291pub const FMOD_DSP_RETURN_ID: FMOD_DSP_RETURN = 0;
3292pub const FMOD_DSP_RETURN_INPUT_SPEAKER_MODE: FMOD_DSP_RETURN = 1;
3293pub type FMOD_DSP_RETURN = ::std::os::raw::c_uint;
3294pub const FMOD_DSP_HIGHPASS_SIMPLE_CUTOFF: FMOD_DSP_HIGHPASS_SIMPLE = 0;
3295pub type FMOD_DSP_HIGHPASS_SIMPLE = ::std::os::raw::c_uint;
3296pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISTRIBUTED: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 0;
3297pub const FMOD_DSP_PAN_2D_STEREO_MODE_DISCRETE: FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = 1;
3298pub type FMOD_DSP_PAN_2D_STEREO_MODE_TYPE = ::std::os::raw::c_uint;
3299pub const FMOD_DSP_PAN_MODE_MONO: FMOD_DSP_PAN_MODE_TYPE = 0;
3300pub const FMOD_DSP_PAN_MODE_STEREO: FMOD_DSP_PAN_MODE_TYPE = 1;
3301pub const FMOD_DSP_PAN_MODE_SURROUND: FMOD_DSP_PAN_MODE_TYPE = 2;
3302pub type FMOD_DSP_PAN_MODE_TYPE = ::std::os::raw::c_uint;
3303pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEARSQUARED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 0;
3304pub const FMOD_DSP_PAN_3D_ROLLOFF_LINEAR: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 1;
3305pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSE: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 2;
3306pub const FMOD_DSP_PAN_3D_ROLLOFF_INVERSETAPERED: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 3;
3307pub const FMOD_DSP_PAN_3D_ROLLOFF_CUSTOM: FMOD_DSP_PAN_3D_ROLLOFF_TYPE = 4;
3308pub type FMOD_DSP_PAN_3D_ROLLOFF_TYPE = ::std::os::raw::c_uint;
3309pub const FMOD_DSP_PAN_3D_EXTENT_MODE_AUTO: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 0;
3310pub const FMOD_DSP_PAN_3D_EXTENT_MODE_USER: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 1;
3311pub const FMOD_DSP_PAN_3D_EXTENT_MODE_OFF: FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = 2;
3312pub type FMOD_DSP_PAN_3D_EXTENT_MODE_TYPE = ::std::os::raw::c_uint;
3313pub const FMOD_DSP_PAN_MODE: FMOD_DSP_PAN = 0;
3314pub const FMOD_DSP_PAN_2D_STEREO_POSITION: FMOD_DSP_PAN = 1;
3315pub const FMOD_DSP_PAN_2D_DIRECTION: FMOD_DSP_PAN = 2;
3316pub const FMOD_DSP_PAN_2D_EXTENT: FMOD_DSP_PAN = 3;
3317pub const FMOD_DSP_PAN_2D_ROTATION: FMOD_DSP_PAN = 4;
3318pub const FMOD_DSP_PAN_2D_LFE_LEVEL: FMOD_DSP_PAN = 5;
3319pub const FMOD_DSP_PAN_2D_STEREO_MODE: FMOD_DSP_PAN = 6;
3320pub const FMOD_DSP_PAN_2D_STEREO_SEPARATION: FMOD_DSP_PAN = 7;
3321pub const FMOD_DSP_PAN_2D_STEREO_AXIS: FMOD_DSP_PAN = 8;
3322pub const FMOD_DSP_PAN_ENABLED_SPEAKERS: FMOD_DSP_PAN = 9;
3323pub const FMOD_DSP_PAN_3D_POSITION: FMOD_DSP_PAN = 10;
3324pub const FMOD_DSP_PAN_3D_ROLLOFF: FMOD_DSP_PAN = 11;
3325pub const FMOD_DSP_PAN_3D_MIN_DISTANCE: FMOD_DSP_PAN = 12;
3326pub const FMOD_DSP_PAN_3D_MAX_DISTANCE: FMOD_DSP_PAN = 13;
3327pub const FMOD_DSP_PAN_3D_EXTENT_MODE: FMOD_DSP_PAN = 14;
3328pub const FMOD_DSP_PAN_3D_SOUND_SIZE: FMOD_DSP_PAN = 15;
3329pub const FMOD_DSP_PAN_3D_MIN_EXTENT: FMOD_DSP_PAN = 16;
3330pub const FMOD_DSP_PAN_3D_PAN_BLEND: FMOD_DSP_PAN = 17;
3331pub const FMOD_DSP_PAN_LFE_UPMIX_ENABLED: FMOD_DSP_PAN = 18;
3332pub const FMOD_DSP_PAN_OVERALL_GAIN: FMOD_DSP_PAN = 19;
3333pub const FMOD_DSP_PAN_SURROUND_SPEAKER_MODE: FMOD_DSP_PAN = 20;
3334pub const FMOD_DSP_PAN_2D_HEIGHT_BLEND: FMOD_DSP_PAN = 21;
3335pub const FMOD_DSP_PAN_ATTENUATION_RANGE: FMOD_DSP_PAN = 22;
3336pub const FMOD_DSP_PAN_OVERRIDE_RANGE: FMOD_DSP_PAN = 23;
3337pub type FMOD_DSP_PAN = ::std::os::raw::c_uint;
3338pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_12DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 0;
3339pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_24DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 1;
3340pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_48DB: FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = 2;
3341pub type FMOD_DSP_THREE_EQ_CROSSOVERSLOPE_TYPE = ::std::os::raw::c_uint;
3342pub const FMOD_DSP_THREE_EQ_LOWGAIN: FMOD_DSP_THREE_EQ = 0;
3343pub const FMOD_DSP_THREE_EQ_MIDGAIN: FMOD_DSP_THREE_EQ = 1;
3344pub const FMOD_DSP_THREE_EQ_HIGHGAIN: FMOD_DSP_THREE_EQ = 2;
3345pub const FMOD_DSP_THREE_EQ_LOWCROSSOVER: FMOD_DSP_THREE_EQ = 3;
3346pub const FMOD_DSP_THREE_EQ_HIGHCROSSOVER: FMOD_DSP_THREE_EQ = 4;
3347pub const FMOD_DSP_THREE_EQ_CROSSOVERSLOPE: FMOD_DSP_THREE_EQ = 5;
3348pub type FMOD_DSP_THREE_EQ = ::std::os::raw::c_uint;
3349pub const FMOD_DSP_FFT_WINDOW_RECT: FMOD_DSP_FFT_WINDOW = 0;
3350pub const FMOD_DSP_FFT_WINDOW_TRIANGLE: FMOD_DSP_FFT_WINDOW = 1;
3351pub const FMOD_DSP_FFT_WINDOW_HAMMING: FMOD_DSP_FFT_WINDOW = 2;
3352pub const FMOD_DSP_FFT_WINDOW_HANNING: FMOD_DSP_FFT_WINDOW = 3;
3353pub const FMOD_DSP_FFT_WINDOW_BLACKMAN: FMOD_DSP_FFT_WINDOW = 4;
3354pub const FMOD_DSP_FFT_WINDOW_BLACKMANHARRIS: FMOD_DSP_FFT_WINDOW = 5;
3355pub type FMOD_DSP_FFT_WINDOW = ::std::os::raw::c_uint;
3356pub const FMOD_DSP_FFT_WINDOWSIZE: FMOD_DSP_FFT = 0;
3357pub const FMOD_DSP_FFT_WINDOWTYPE: FMOD_DSP_FFT = 1;
3358pub const FMOD_DSP_FFT_SPECTRUMDATA: FMOD_DSP_FFT = 2;
3359pub const FMOD_DSP_FFT_DOMINANT_FREQ: FMOD_DSP_FFT = 3;
3360pub type FMOD_DSP_FFT = ::std::os::raw::c_uint;
3361pub const FMOD_DSP_LOUDNESS_METER_STATE: FMOD_DSP_LOUDNESS_METER = 0;
3362pub const FMOD_DSP_LOUDNESS_METER_WEIGHTING: FMOD_DSP_LOUDNESS_METER = 1;
3363pub const FMOD_DSP_LOUDNESS_METER_INFO: FMOD_DSP_LOUDNESS_METER = 2;
3364pub type FMOD_DSP_LOUDNESS_METER = ::std::os::raw::c_uint;
3365pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_INTEGRATED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -3;
3366pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_MAXPEAK: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -2;
3367pub const FMOD_DSP_LOUDNESS_METER_STATE_RESET_ALL: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = -1;
3368pub const FMOD_DSP_LOUDNESS_METER_STATE_PAUSED: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 0;
3369pub const FMOD_DSP_LOUDNESS_METER_STATE_ANALYZING: FMOD_DSP_LOUDNESS_METER_STATE_TYPE = 1;
3370pub type FMOD_DSP_LOUDNESS_METER_STATE_TYPE = ::std::os::raw::c_int;
3371#[repr(C)]
3372#[derive(Debug, Copy, Clone, PartialEq)]
3373pub struct FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
3374 pub momentaryloudness: f32,
3375 pub shorttermloudness: f32,
3376 pub integratedloudness: f32,
3377 pub loudness10thpercentile: f32,
3378 pub loudness95thpercentile: f32,
3379 pub loudnesshistogram: [f32; 66usize],
3380 pub maxtruepeak: f32,
3381 pub maxmomentaryloudness: f32,
3382}
3383#[test]
3384fn bindgen_test_layout_FMOD_DSP_LOUDNESS_METER_INFO_TYPE() {
3385 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_LOUDNESS_METER_INFO_TYPE> =
3386 ::std::mem::MaybeUninit::uninit();
3387 let ptr = UNINIT.as_ptr();
3388 assert_eq!(
3389 ::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>(),
3390 292usize,
3391 concat!("Size of: ", stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE))
3392 );
3393 assert_eq!(
3394 ::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_INFO_TYPE>(),
3395 4usize,
3396 concat!(
3397 "Alignment of ",
3398 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE)
3399 )
3400 );
3401 assert_eq!(
3402 unsafe { ::std::ptr::addr_of!((*ptr).momentaryloudness) as usize - ptr as usize },
3403 0usize,
3404 concat!(
3405 "Offset of field: ",
3406 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3407 "::",
3408 stringify!(momentaryloudness)
3409 )
3410 );
3411 assert_eq!(
3412 unsafe { ::std::ptr::addr_of!((*ptr).shorttermloudness) as usize - ptr as usize },
3413 4usize,
3414 concat!(
3415 "Offset of field: ",
3416 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3417 "::",
3418 stringify!(shorttermloudness)
3419 )
3420 );
3421 assert_eq!(
3422 unsafe { ::std::ptr::addr_of!((*ptr).integratedloudness) as usize - ptr as usize },
3423 8usize,
3424 concat!(
3425 "Offset of field: ",
3426 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3427 "::",
3428 stringify!(integratedloudness)
3429 )
3430 );
3431 assert_eq!(
3432 unsafe { ::std::ptr::addr_of!((*ptr).loudness10thpercentile) as usize - ptr as usize },
3433 12usize,
3434 concat!(
3435 "Offset of field: ",
3436 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3437 "::",
3438 stringify!(loudness10thpercentile)
3439 )
3440 );
3441 assert_eq!(
3442 unsafe { ::std::ptr::addr_of!((*ptr).loudness95thpercentile) as usize - ptr as usize },
3443 16usize,
3444 concat!(
3445 "Offset of field: ",
3446 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3447 "::",
3448 stringify!(loudness95thpercentile)
3449 )
3450 );
3451 assert_eq!(
3452 unsafe { ::std::ptr::addr_of!((*ptr).loudnesshistogram) as usize - ptr as usize },
3453 20usize,
3454 concat!(
3455 "Offset of field: ",
3456 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3457 "::",
3458 stringify!(loudnesshistogram)
3459 )
3460 );
3461 assert_eq!(
3462 unsafe { ::std::ptr::addr_of!((*ptr).maxtruepeak) as usize - ptr as usize },
3463 284usize,
3464 concat!(
3465 "Offset of field: ",
3466 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3467 "::",
3468 stringify!(maxtruepeak)
3469 )
3470 );
3471 assert_eq!(
3472 unsafe { ::std::ptr::addr_of!((*ptr).maxmomentaryloudness) as usize - ptr as usize },
3473 288usize,
3474 concat!(
3475 "Offset of field: ",
3476 stringify!(FMOD_DSP_LOUDNESS_METER_INFO_TYPE),
3477 "::",
3478 stringify!(maxmomentaryloudness)
3479 )
3480 );
3481}
3482impl Default for FMOD_DSP_LOUDNESS_METER_INFO_TYPE {
3483 fn default() -> Self {
3484 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3485 unsafe {
3486 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3487 s.assume_init()
3488 }
3489 }
3490}
3491#[repr(C)]
3492#[derive(Debug, Default, Copy, Clone, PartialEq)]
3493pub struct FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE {
3494 pub channelweight: [f32; 32usize],
3495}
3496#[test]
3497fn bindgen_test_layout_FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE() {
3498 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE> =
3499 ::std::mem::MaybeUninit::uninit();
3500 let ptr = UNINIT.as_ptr();
3501 assert_eq!(
3502 ::std::mem::size_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>(),
3503 128usize,
3504 concat!(
3505 "Size of: ",
3506 stringify!(FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE)
3507 )
3508 );
3509 assert_eq!(
3510 ::std::mem::align_of::<FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE>(),
3511 4usize,
3512 concat!(
3513 "Alignment of ",
3514 stringify!(FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE)
3515 )
3516 );
3517 assert_eq!(
3518 unsafe { ::std::ptr::addr_of!((*ptr).channelweight) as usize - ptr as usize },
3519 0usize,
3520 concat!(
3521 "Offset of field: ",
3522 stringify!(FMOD_DSP_LOUDNESS_METER_WEIGHTING_TYPE),
3523 "::",
3524 stringify!(channelweight)
3525 )
3526 );
3527}
3528pub const FMOD_DSP_ENVELOPEFOLLOWER_ATTACK: FMOD_DSP_ENVELOPEFOLLOWER = 0;
3529pub const FMOD_DSP_ENVELOPEFOLLOWER_RELEASE: FMOD_DSP_ENVELOPEFOLLOWER = 1;
3530pub const FMOD_DSP_ENVELOPEFOLLOWER_ENVELOPE: FMOD_DSP_ENVELOPEFOLLOWER = 2;
3531pub const FMOD_DSP_ENVELOPEFOLLOWER_USESIDECHAIN: FMOD_DSP_ENVELOPEFOLLOWER = 3;
3532pub type FMOD_DSP_ENVELOPEFOLLOWER = ::std::os::raw::c_uint;
3533pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_IR: FMOD_DSP_CONVOLUTION_REVERB = 0;
3534pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_WET: FMOD_DSP_CONVOLUTION_REVERB = 1;
3535pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_DRY: FMOD_DSP_CONVOLUTION_REVERB = 2;
3536pub const FMOD_DSP_CONVOLUTION_REVERB_PARAM_LINKED: FMOD_DSP_CONVOLUTION_REVERB = 3;
3537pub type FMOD_DSP_CONVOLUTION_REVERB = ::std::os::raw::c_uint;
3538pub const FMOD_DSP_CHANNELMIX_OUTPUT_DEFAULT: FMOD_DSP_CHANNELMIX_OUTPUT = 0;
3539pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLMONO: FMOD_DSP_CHANNELMIX_OUTPUT = 1;
3540pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLSTEREO: FMOD_DSP_CHANNELMIX_OUTPUT = 2;
3541pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLQUAD: FMOD_DSP_CHANNELMIX_OUTPUT = 3;
3542pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL5POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 4;
3543pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1: FMOD_DSP_CHANNELMIX_OUTPUT = 5;
3544pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALLLFE: FMOD_DSP_CHANNELMIX_OUTPUT = 6;
3545pub const FMOD_DSP_CHANNELMIX_OUTPUT_ALL7POINT1POINT4: FMOD_DSP_CHANNELMIX_OUTPUT = 7;
3546pub type FMOD_DSP_CHANNELMIX_OUTPUT = ::std::os::raw::c_uint;
3547pub const FMOD_DSP_CHANNELMIX_OUTPUTGROUPING: FMOD_DSP_CHANNELMIX = 0;
3548pub const FMOD_DSP_CHANNELMIX_GAIN_CH0: FMOD_DSP_CHANNELMIX = 1;
3549pub const FMOD_DSP_CHANNELMIX_GAIN_CH1: FMOD_DSP_CHANNELMIX = 2;
3550pub const FMOD_DSP_CHANNELMIX_GAIN_CH2: FMOD_DSP_CHANNELMIX = 3;
3551pub const FMOD_DSP_CHANNELMIX_GAIN_CH3: FMOD_DSP_CHANNELMIX = 4;
3552pub const FMOD_DSP_CHANNELMIX_GAIN_CH4: FMOD_DSP_CHANNELMIX = 5;
3553pub const FMOD_DSP_CHANNELMIX_GAIN_CH5: FMOD_DSP_CHANNELMIX = 6;
3554pub const FMOD_DSP_CHANNELMIX_GAIN_CH6: FMOD_DSP_CHANNELMIX = 7;
3555pub const FMOD_DSP_CHANNELMIX_GAIN_CH7: FMOD_DSP_CHANNELMIX = 8;
3556pub const FMOD_DSP_CHANNELMIX_GAIN_CH8: FMOD_DSP_CHANNELMIX = 9;
3557pub const FMOD_DSP_CHANNELMIX_GAIN_CH9: FMOD_DSP_CHANNELMIX = 10;
3558pub const FMOD_DSP_CHANNELMIX_GAIN_CH10: FMOD_DSP_CHANNELMIX = 11;
3559pub const FMOD_DSP_CHANNELMIX_GAIN_CH11: FMOD_DSP_CHANNELMIX = 12;
3560pub const FMOD_DSP_CHANNELMIX_GAIN_CH12: FMOD_DSP_CHANNELMIX = 13;
3561pub const FMOD_DSP_CHANNELMIX_GAIN_CH13: FMOD_DSP_CHANNELMIX = 14;
3562pub const FMOD_DSP_CHANNELMIX_GAIN_CH14: FMOD_DSP_CHANNELMIX = 15;
3563pub const FMOD_DSP_CHANNELMIX_GAIN_CH15: FMOD_DSP_CHANNELMIX = 16;
3564pub const FMOD_DSP_CHANNELMIX_GAIN_CH16: FMOD_DSP_CHANNELMIX = 17;
3565pub const FMOD_DSP_CHANNELMIX_GAIN_CH17: FMOD_DSP_CHANNELMIX = 18;
3566pub const FMOD_DSP_CHANNELMIX_GAIN_CH18: FMOD_DSP_CHANNELMIX = 19;
3567pub const FMOD_DSP_CHANNELMIX_GAIN_CH19: FMOD_DSP_CHANNELMIX = 20;
3568pub const FMOD_DSP_CHANNELMIX_GAIN_CH20: FMOD_DSP_CHANNELMIX = 21;
3569pub const FMOD_DSP_CHANNELMIX_GAIN_CH21: FMOD_DSP_CHANNELMIX = 22;
3570pub const FMOD_DSP_CHANNELMIX_GAIN_CH22: FMOD_DSP_CHANNELMIX = 23;
3571pub const FMOD_DSP_CHANNELMIX_GAIN_CH23: FMOD_DSP_CHANNELMIX = 24;
3572pub const FMOD_DSP_CHANNELMIX_GAIN_CH24: FMOD_DSP_CHANNELMIX = 25;
3573pub const FMOD_DSP_CHANNELMIX_GAIN_CH25: FMOD_DSP_CHANNELMIX = 26;
3574pub const FMOD_DSP_CHANNELMIX_GAIN_CH26: FMOD_DSP_CHANNELMIX = 27;
3575pub const FMOD_DSP_CHANNELMIX_GAIN_CH27: FMOD_DSP_CHANNELMIX = 28;
3576pub const FMOD_DSP_CHANNELMIX_GAIN_CH28: FMOD_DSP_CHANNELMIX = 29;
3577pub const FMOD_DSP_CHANNELMIX_GAIN_CH29: FMOD_DSP_CHANNELMIX = 30;
3578pub const FMOD_DSP_CHANNELMIX_GAIN_CH30: FMOD_DSP_CHANNELMIX = 31;
3579pub const FMOD_DSP_CHANNELMIX_GAIN_CH31: FMOD_DSP_CHANNELMIX = 32;
3580pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH0: FMOD_DSP_CHANNELMIX = 33;
3581pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH1: FMOD_DSP_CHANNELMIX = 34;
3582pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH2: FMOD_DSP_CHANNELMIX = 35;
3583pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH3: FMOD_DSP_CHANNELMIX = 36;
3584pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH4: FMOD_DSP_CHANNELMIX = 37;
3585pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH5: FMOD_DSP_CHANNELMIX = 38;
3586pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH6: FMOD_DSP_CHANNELMIX = 39;
3587pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH7: FMOD_DSP_CHANNELMIX = 40;
3588pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH8: FMOD_DSP_CHANNELMIX = 41;
3589pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH9: FMOD_DSP_CHANNELMIX = 42;
3590pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH10: FMOD_DSP_CHANNELMIX = 43;
3591pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH11: FMOD_DSP_CHANNELMIX = 44;
3592pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH12: FMOD_DSP_CHANNELMIX = 45;
3593pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH13: FMOD_DSP_CHANNELMIX = 46;
3594pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH14: FMOD_DSP_CHANNELMIX = 47;
3595pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH15: FMOD_DSP_CHANNELMIX = 48;
3596pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH16: FMOD_DSP_CHANNELMIX = 49;
3597pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH17: FMOD_DSP_CHANNELMIX = 50;
3598pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH18: FMOD_DSP_CHANNELMIX = 51;
3599pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH19: FMOD_DSP_CHANNELMIX = 52;
3600pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH20: FMOD_DSP_CHANNELMIX = 53;
3601pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH21: FMOD_DSP_CHANNELMIX = 54;
3602pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH22: FMOD_DSP_CHANNELMIX = 55;
3603pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH23: FMOD_DSP_CHANNELMIX = 56;
3604pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH24: FMOD_DSP_CHANNELMIX = 57;
3605pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH25: FMOD_DSP_CHANNELMIX = 58;
3606pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH26: FMOD_DSP_CHANNELMIX = 59;
3607pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH27: FMOD_DSP_CHANNELMIX = 60;
3608pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH28: FMOD_DSP_CHANNELMIX = 61;
3609pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH29: FMOD_DSP_CHANNELMIX = 62;
3610pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH30: FMOD_DSP_CHANNELMIX = 63;
3611pub const FMOD_DSP_CHANNELMIX_OUTPUT_CH31: FMOD_DSP_CHANNELMIX = 64;
3612pub type FMOD_DSP_CHANNELMIX = ::std::os::raw::c_uint;
3613pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_AUTO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = -1;
3614pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_MONO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 0;
3615pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_STEREO: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 1;
3616pub const FMOD_DSP_TRANSCEIVER_SPEAKERMODE_SURROUND: FMOD_DSP_TRANSCEIVER_SPEAKERMODE = 2;
3617pub type FMOD_DSP_TRANSCEIVER_SPEAKERMODE = ::std::os::raw::c_int;
3618pub const FMOD_DSP_TRANSCEIVER_TRANSMIT: FMOD_DSP_TRANSCEIVER = 0;
3619pub const FMOD_DSP_TRANSCEIVER_GAIN: FMOD_DSP_TRANSCEIVER = 1;
3620pub const FMOD_DSP_TRANSCEIVER_CHANNEL: FMOD_DSP_TRANSCEIVER = 2;
3621pub const FMOD_DSP_TRANSCEIVER_TRANSMITSPEAKERMODE: FMOD_DSP_TRANSCEIVER = 3;
3622pub type FMOD_DSP_TRANSCEIVER = ::std::os::raw::c_uint;
3623pub const FMOD_DSP_OBJECTPAN_3D_POSITION: FMOD_DSP_OBJECTPAN = 0;
3624pub const FMOD_DSP_OBJECTPAN_3D_ROLLOFF: FMOD_DSP_OBJECTPAN = 1;
3625pub const FMOD_DSP_OBJECTPAN_3D_MIN_DISTANCE: FMOD_DSP_OBJECTPAN = 2;
3626pub const FMOD_DSP_OBJECTPAN_3D_MAX_DISTANCE: FMOD_DSP_OBJECTPAN = 3;
3627pub const FMOD_DSP_OBJECTPAN_3D_EXTENT_MODE: FMOD_DSP_OBJECTPAN = 4;
3628pub const FMOD_DSP_OBJECTPAN_3D_SOUND_SIZE: FMOD_DSP_OBJECTPAN = 5;
3629pub const FMOD_DSP_OBJECTPAN_3D_MIN_EXTENT: FMOD_DSP_OBJECTPAN = 6;
3630pub const FMOD_DSP_OBJECTPAN_OVERALL_GAIN: FMOD_DSP_OBJECTPAN = 7;
3631pub const FMOD_DSP_OBJECTPAN_OUTPUTGAIN: FMOD_DSP_OBJECTPAN = 8;
3632pub const FMOD_DSP_OBJECTPAN_ATTENUATION_RANGE: FMOD_DSP_OBJECTPAN = 9;
3633pub const FMOD_DSP_OBJECTPAN_OVERRIDE_RANGE: FMOD_DSP_OBJECTPAN = 10;
3634pub type FMOD_DSP_OBJECTPAN = ::std::os::raw::c_uint;
3635pub const FMOD_DSP_PROCESS_PERFORM: FMOD_DSP_PROCESS_OPERATION = 0;
3636pub const FMOD_DSP_PROCESS_QUERY: FMOD_DSP_PROCESS_OPERATION = 1;
3637pub type FMOD_DSP_PROCESS_OPERATION = ::std::os::raw::c_uint;
3638pub const FMOD_DSP_PAN_SURROUND_DEFAULT: FMOD_DSP_PAN_SURROUND_FLAGS = 0;
3639pub const FMOD_DSP_PAN_SURROUND_ROTATION_NOT_BIASED: FMOD_DSP_PAN_SURROUND_FLAGS = 1;
3640pub const FMOD_DSP_PAN_SURROUND_FLAGS_FORCEINT: FMOD_DSP_PAN_SURROUND_FLAGS = 65536;
3641pub type FMOD_DSP_PAN_SURROUND_FLAGS = ::std::os::raw::c_uint;
3642pub const FMOD_DSP_PARAMETER_TYPE_FLOAT: FMOD_DSP_PARAMETER_TYPE = 0;
3643pub const FMOD_DSP_PARAMETER_TYPE_INT: FMOD_DSP_PARAMETER_TYPE = 1;
3644pub const FMOD_DSP_PARAMETER_TYPE_BOOL: FMOD_DSP_PARAMETER_TYPE = 2;
3645pub const FMOD_DSP_PARAMETER_TYPE_DATA: FMOD_DSP_PARAMETER_TYPE = 3;
3646pub const FMOD_DSP_PARAMETER_TYPE_MAX: FMOD_DSP_PARAMETER_TYPE = 4;
3647pub const FMOD_DSP_PARAMETER_TYPE_FORCEINT: FMOD_DSP_PARAMETER_TYPE = 65536;
3648pub type FMOD_DSP_PARAMETER_TYPE = ::std::os::raw::c_uint;
3649pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_LINEAR: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 0;
3650pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_AUTO: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 1;
3651pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_PIECEWISE_LINEAR:
3652 FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = 2;
3653pub const FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE_FORCEINT: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE =
3654 65536;
3655pub type FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE = ::std::os::raw::c_uint;
3656pub const FMOD_DSP_PARAMETER_DATA_TYPE_USER: FMOD_DSP_PARAMETER_DATA_TYPE = 0;
3657pub const FMOD_DSP_PARAMETER_DATA_TYPE_OVERALLGAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -1;
3658pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES: FMOD_DSP_PARAMETER_DATA_TYPE = -2;
3659pub const FMOD_DSP_PARAMETER_DATA_TYPE_SIDECHAIN: FMOD_DSP_PARAMETER_DATA_TYPE = -3;
3660pub const FMOD_DSP_PARAMETER_DATA_TYPE_FFT: FMOD_DSP_PARAMETER_DATA_TYPE = -4;
3661pub const FMOD_DSP_PARAMETER_DATA_TYPE_3DATTRIBUTES_MULTI: FMOD_DSP_PARAMETER_DATA_TYPE = -5;
3662pub const FMOD_DSP_PARAMETER_DATA_TYPE_ATTENUATION_RANGE: FMOD_DSP_PARAMETER_DATA_TYPE = -6;
3663pub type FMOD_DSP_PARAMETER_DATA_TYPE = ::std::os::raw::c_int;
3664pub type FMOD_DSP_CREATE_CALLBACK =
3665 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
3666pub type FMOD_DSP_RELEASE_CALLBACK =
3667 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
3668pub type FMOD_DSP_RESET_CALLBACK =
3669 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
3670pub type FMOD_DSP_READ_CALLBACK = ::std::option::Option<
3671 unsafe extern "C" fn(
3672 dsp_state: *mut FMOD_DSP_STATE,
3673 inbuffer: *mut f32,
3674 outbuffer: *mut f32,
3675 length: ::std::os::raw::c_uint,
3676 inchannels: ::std::os::raw::c_int,
3677 outchannels: *mut ::std::os::raw::c_int,
3678 ) -> FMOD_RESULT,
3679>;
3680pub type FMOD_DSP_PROCESS_CALLBACK = ::std::option::Option<
3681 unsafe extern "C" fn(
3682 dsp_state: *mut FMOD_DSP_STATE,
3683 length: ::std::os::raw::c_uint,
3684 inbufferarray: *const FMOD_DSP_BUFFER_ARRAY,
3685 outbufferarray: *mut FMOD_DSP_BUFFER_ARRAY,
3686 inputsidle: FMOD_BOOL,
3687 op: FMOD_DSP_PROCESS_OPERATION,
3688 ) -> FMOD_RESULT,
3689>;
3690pub type FMOD_DSP_SETPOSITION_CALLBACK = ::std::option::Option<
3691 unsafe extern "C" fn(
3692 dsp_state: *mut FMOD_DSP_STATE,
3693 pos: ::std::os::raw::c_uint,
3694 ) -> FMOD_RESULT,
3695>;
3696pub type FMOD_DSP_SHOULDIPROCESS_CALLBACK = ::std::option::Option<
3697 unsafe extern "C" fn(
3698 dsp_state: *mut FMOD_DSP_STATE,
3699 inputsidle: FMOD_BOOL,
3700 length: ::std::os::raw::c_uint,
3701 inmask: FMOD_CHANNELMASK,
3702 inchannels: ::std::os::raw::c_int,
3703 speakermode: FMOD_SPEAKERMODE,
3704 ) -> FMOD_RESULT,
3705>;
3706pub type FMOD_DSP_SETPARAM_FLOAT_CALLBACK = ::std::option::Option<
3707 unsafe extern "C" fn(
3708 dsp_state: *mut FMOD_DSP_STATE,
3709 index: ::std::os::raw::c_int,
3710 value: f32,
3711 ) -> FMOD_RESULT,
3712>;
3713pub type FMOD_DSP_SETPARAM_INT_CALLBACK = ::std::option::Option<
3714 unsafe extern "C" fn(
3715 dsp_state: *mut FMOD_DSP_STATE,
3716 index: ::std::os::raw::c_int,
3717 value: ::std::os::raw::c_int,
3718 ) -> FMOD_RESULT,
3719>;
3720pub type FMOD_DSP_SETPARAM_BOOL_CALLBACK = ::std::option::Option<
3721 unsafe extern "C" fn(
3722 dsp_state: *mut FMOD_DSP_STATE,
3723 index: ::std::os::raw::c_int,
3724 value: FMOD_BOOL,
3725 ) -> FMOD_RESULT,
3726>;
3727pub type FMOD_DSP_SETPARAM_DATA_CALLBACK = ::std::option::Option<
3728 unsafe extern "C" fn(
3729 dsp_state: *mut FMOD_DSP_STATE,
3730 index: ::std::os::raw::c_int,
3731 data: *mut ::std::os::raw::c_void,
3732 length: ::std::os::raw::c_uint,
3733 ) -> FMOD_RESULT,
3734>;
3735pub type FMOD_DSP_GETPARAM_FLOAT_CALLBACK = ::std::option::Option<
3736 unsafe extern "C" fn(
3737 dsp_state: *mut FMOD_DSP_STATE,
3738 index: ::std::os::raw::c_int,
3739 value: *mut f32,
3740 valuestr: *mut ::std::os::raw::c_char,
3741 ) -> FMOD_RESULT,
3742>;
3743pub type FMOD_DSP_GETPARAM_INT_CALLBACK = ::std::option::Option<
3744 unsafe extern "C" fn(
3745 dsp_state: *mut FMOD_DSP_STATE,
3746 index: ::std::os::raw::c_int,
3747 value: *mut ::std::os::raw::c_int,
3748 valuestr: *mut ::std::os::raw::c_char,
3749 ) -> FMOD_RESULT,
3750>;
3751pub type FMOD_DSP_GETPARAM_BOOL_CALLBACK = ::std::option::Option<
3752 unsafe extern "C" fn(
3753 dsp_state: *mut FMOD_DSP_STATE,
3754 index: ::std::os::raw::c_int,
3755 value: *mut FMOD_BOOL,
3756 valuestr: *mut ::std::os::raw::c_char,
3757 ) -> FMOD_RESULT,
3758>;
3759pub type FMOD_DSP_GETPARAM_DATA_CALLBACK = ::std::option::Option<
3760 unsafe extern "C" fn(
3761 dsp_state: *mut FMOD_DSP_STATE,
3762 index: ::std::os::raw::c_int,
3763 data: *mut *mut ::std::os::raw::c_void,
3764 length: *mut ::std::os::raw::c_uint,
3765 valuestr: *mut ::std::os::raw::c_char,
3766 ) -> FMOD_RESULT,
3767>;
3768pub type FMOD_DSP_SYSTEM_REGISTER_CALLBACK =
3769 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
3770pub type FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK =
3771 ::std::option::Option<unsafe extern "C" fn(dsp_state: *mut FMOD_DSP_STATE) -> FMOD_RESULT>;
3772pub type FMOD_DSP_SYSTEM_MIX_CALLBACK = ::std::option::Option<
3773 unsafe extern "C" fn(
3774 dsp_state: *mut FMOD_DSP_STATE,
3775 stage: ::std::os::raw::c_int,
3776 ) -> FMOD_RESULT,
3777>;
3778pub type FMOD_DSP_ALLOC_FUNC = ::std::option::Option<
3779 unsafe extern "C" fn(
3780 size: ::std::os::raw::c_uint,
3781 type_: FMOD_MEMORY_TYPE,
3782 sourcestr: *const ::std::os::raw::c_char,
3783 ) -> *mut ::std::os::raw::c_void,
3784>;
3785pub type FMOD_DSP_REALLOC_FUNC = ::std::option::Option<
3786 unsafe extern "C" fn(
3787 ptr: *mut ::std::os::raw::c_void,
3788 size: ::std::os::raw::c_uint,
3789 type_: FMOD_MEMORY_TYPE,
3790 sourcestr: *const ::std::os::raw::c_char,
3791 ) -> *mut ::std::os::raw::c_void,
3792>;
3793pub type FMOD_DSP_FREE_FUNC = ::std::option::Option<
3794 unsafe extern "C" fn(
3795 ptr: *mut ::std::os::raw::c_void,
3796 type_: FMOD_MEMORY_TYPE,
3797 sourcestr: *const ::std::os::raw::c_char,
3798 ),
3799>;
3800pub type FMOD_DSP_LOG_FUNC = ::std::option::Option<
3801 unsafe extern "C" fn(
3802 level: FMOD_DEBUG_FLAGS,
3803 file: *const ::std::os::raw::c_char,
3804 line: ::std::os::raw::c_int,
3805 function: *const ::std::os::raw::c_char,
3806 str_: *const ::std::os::raw::c_char,
3807 ...
3808 ),
3809>;
3810pub type FMOD_DSP_GETSAMPLERATE_FUNC = ::std::option::Option<
3811 unsafe extern "C" fn(
3812 dsp_state: *mut FMOD_DSP_STATE,
3813 rate: *mut ::std::os::raw::c_int,
3814 ) -> FMOD_RESULT,
3815>;
3816pub type FMOD_DSP_GETBLOCKSIZE_FUNC = ::std::option::Option<
3817 unsafe extern "C" fn(
3818 dsp_state: *mut FMOD_DSP_STATE,
3819 blocksize: *mut ::std::os::raw::c_uint,
3820 ) -> FMOD_RESULT,
3821>;
3822pub type FMOD_DSP_GETSPEAKERMODE_FUNC = ::std::option::Option<
3823 unsafe extern "C" fn(
3824 dsp_state: *mut FMOD_DSP_STATE,
3825 speakermode_mixer: *mut FMOD_SPEAKERMODE,
3826 speakermode_output: *mut FMOD_SPEAKERMODE,
3827 ) -> FMOD_RESULT,
3828>;
3829pub type FMOD_DSP_GETCLOCK_FUNC = ::std::option::Option<
3830 unsafe extern "C" fn(
3831 dsp_state: *mut FMOD_DSP_STATE,
3832 clock: *mut ::std::os::raw::c_ulonglong,
3833 offset: *mut ::std::os::raw::c_uint,
3834 length: *mut ::std::os::raw::c_uint,
3835 ) -> FMOD_RESULT,
3836>;
3837pub type FMOD_DSP_GETLISTENERATTRIBUTES_FUNC = ::std::option::Option<
3838 unsafe extern "C" fn(
3839 dsp_state: *mut FMOD_DSP_STATE,
3840 numlisteners: *mut ::std::os::raw::c_int,
3841 attributes: *mut FMOD_3D_ATTRIBUTES,
3842 ) -> FMOD_RESULT,
3843>;
3844pub type FMOD_DSP_GETUSERDATA_FUNC = ::std::option::Option<
3845 unsafe extern "C" fn(
3846 dsp_state: *mut FMOD_DSP_STATE,
3847 userdata: *mut *mut ::std::os::raw::c_void,
3848 ) -> FMOD_RESULT,
3849>;
3850pub type FMOD_DSP_DFT_FFTREAL_FUNC = ::std::option::Option<
3851 unsafe extern "C" fn(
3852 dsp_state: *mut FMOD_DSP_STATE,
3853 size: ::std::os::raw::c_int,
3854 signal: *const f32,
3855 dft: *mut FMOD_COMPLEX,
3856 window: *const f32,
3857 signalhop: ::std::os::raw::c_int,
3858 ) -> FMOD_RESULT,
3859>;
3860pub type FMOD_DSP_DFT_IFFTREAL_FUNC = ::std::option::Option<
3861 unsafe extern "C" fn(
3862 dsp_state: *mut FMOD_DSP_STATE,
3863 size: ::std::os::raw::c_int,
3864 dft: *const FMOD_COMPLEX,
3865 signal: *mut f32,
3866 window: *const f32,
3867 signalhop: ::std::os::raw::c_int,
3868 ) -> FMOD_RESULT,
3869>;
3870pub type FMOD_DSP_PAN_SUMMONOMATRIX_FUNC = ::std::option::Option<
3871 unsafe extern "C" fn(
3872 dsp_state: *mut FMOD_DSP_STATE,
3873 sourceSpeakerMode: FMOD_SPEAKERMODE,
3874 lowFrequencyGain: f32,
3875 overallGain: f32,
3876 matrix: *mut f32,
3877 ) -> FMOD_RESULT,
3878>;
3879pub type FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC = ::std::option::Option<
3880 unsafe extern "C" fn(
3881 dsp_state: *mut FMOD_DSP_STATE,
3882 sourceSpeakerMode: FMOD_SPEAKERMODE,
3883 pan: f32,
3884 lowFrequencyGain: f32,
3885 overallGain: f32,
3886 matrixHop: ::std::os::raw::c_int,
3887 matrix: *mut f32,
3888 ) -> FMOD_RESULT,
3889>;
3890pub type FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC = ::std::option::Option<
3891 unsafe extern "C" fn(
3892 dsp_state: *mut FMOD_DSP_STATE,
3893 sourceSpeakerMode: FMOD_SPEAKERMODE,
3894 targetSpeakerMode: FMOD_SPEAKERMODE,
3895 direction: f32,
3896 extent: f32,
3897 rotation: f32,
3898 lowFrequencyGain: f32,
3899 overallGain: f32,
3900 matrixHop: ::std::os::raw::c_int,
3901 matrix: *mut f32,
3902 flags: FMOD_DSP_PAN_SURROUND_FLAGS,
3903 ) -> FMOD_RESULT,
3904>;
3905pub type FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
3906 unsafe extern "C" fn(
3907 dsp_state: *mut FMOD_DSP_STATE,
3908 targetSpeakerMode: FMOD_SPEAKERMODE,
3909 direction: f32,
3910 extent: f32,
3911 lowFrequencyGain: f32,
3912 overallGain: f32,
3913 matrixHop: ::std::os::raw::c_int,
3914 matrix: *mut f32,
3915 ) -> FMOD_RESULT,
3916>;
3917pub type FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC = ::std::option::Option<
3918 unsafe extern "C" fn(
3919 dsp_state: *mut FMOD_DSP_STATE,
3920 targetSpeakerMode: FMOD_SPEAKERMODE,
3921 direction: f32,
3922 extent: f32,
3923 rotation: f32,
3924 lowFrequencyGain: f32,
3925 overallGain: f32,
3926 matrixHop: ::std::os::raw::c_int,
3927 matrix: *mut f32,
3928 ) -> FMOD_RESULT,
3929>;
3930pub type FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC = ::std::option::Option<
3931 unsafe extern "C" fn(
3932 dsp_state: *mut FMOD_DSP_STATE,
3933 rolloff: FMOD_DSP_PAN_3D_ROLLOFF_TYPE,
3934 distance: f32,
3935 mindistance: f32,
3936 maxdistance: f32,
3937 gain: *mut f32,
3938 ) -> FMOD_RESULT,
3939>;
3940#[repr(C)]
3941#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
3942pub struct FMOD_DSP_BUFFER_ARRAY {
3943 pub numbuffers: ::std::os::raw::c_int,
3944 pub buffernumchannels: *mut ::std::os::raw::c_int,
3945 pub bufferchannelmask: *mut FMOD_CHANNELMASK,
3946 pub buffers: *mut *mut f32,
3947 pub speakermode: FMOD_SPEAKERMODE,
3948}
3949#[test]
3950fn bindgen_test_layout_FMOD_DSP_BUFFER_ARRAY() {
3951 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_BUFFER_ARRAY> =
3952 ::std::mem::MaybeUninit::uninit();
3953 let ptr = UNINIT.as_ptr();
3954 assert_eq!(
3955 ::std::mem::size_of::<FMOD_DSP_BUFFER_ARRAY>(),
3956 40usize,
3957 concat!("Size of: ", stringify!(FMOD_DSP_BUFFER_ARRAY))
3958 );
3959 assert_eq!(
3960 ::std::mem::align_of::<FMOD_DSP_BUFFER_ARRAY>(),
3961 8usize,
3962 concat!("Alignment of ", stringify!(FMOD_DSP_BUFFER_ARRAY))
3963 );
3964 assert_eq!(
3965 unsafe { ::std::ptr::addr_of!((*ptr).numbuffers) as usize - ptr as usize },
3966 0usize,
3967 concat!(
3968 "Offset of field: ",
3969 stringify!(FMOD_DSP_BUFFER_ARRAY),
3970 "::",
3971 stringify!(numbuffers)
3972 )
3973 );
3974 assert_eq!(
3975 unsafe { ::std::ptr::addr_of!((*ptr).buffernumchannels) as usize - ptr as usize },
3976 8usize,
3977 concat!(
3978 "Offset of field: ",
3979 stringify!(FMOD_DSP_BUFFER_ARRAY),
3980 "::",
3981 stringify!(buffernumchannels)
3982 )
3983 );
3984 assert_eq!(
3985 unsafe { ::std::ptr::addr_of!((*ptr).bufferchannelmask) as usize - ptr as usize },
3986 16usize,
3987 concat!(
3988 "Offset of field: ",
3989 stringify!(FMOD_DSP_BUFFER_ARRAY),
3990 "::",
3991 stringify!(bufferchannelmask)
3992 )
3993 );
3994 assert_eq!(
3995 unsafe { ::std::ptr::addr_of!((*ptr).buffers) as usize - ptr as usize },
3996 24usize,
3997 concat!(
3998 "Offset of field: ",
3999 stringify!(FMOD_DSP_BUFFER_ARRAY),
4000 "::",
4001 stringify!(buffers)
4002 )
4003 );
4004 assert_eq!(
4005 unsafe { ::std::ptr::addr_of!((*ptr).speakermode) as usize - ptr as usize },
4006 32usize,
4007 concat!(
4008 "Offset of field: ",
4009 stringify!(FMOD_DSP_BUFFER_ARRAY),
4010 "::",
4011 stringify!(speakermode)
4012 )
4013 );
4014}
4015impl Default for FMOD_DSP_BUFFER_ARRAY {
4016 fn default() -> Self {
4017 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4018 unsafe {
4019 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4020 s.assume_init()
4021 }
4022 }
4023}
4024#[repr(C)]
4025#[derive(Debug, Default, Copy, Clone, PartialEq)]
4026pub struct FMOD_COMPLEX {
4027 pub real: f32,
4028 pub imag: f32,
4029}
4030#[test]
4031fn bindgen_test_layout_FMOD_COMPLEX() {
4032 const UNINIT: ::std::mem::MaybeUninit<FMOD_COMPLEX> = ::std::mem::MaybeUninit::uninit();
4033 let ptr = UNINIT.as_ptr();
4034 assert_eq!(
4035 ::std::mem::size_of::<FMOD_COMPLEX>(),
4036 8usize,
4037 concat!("Size of: ", stringify!(FMOD_COMPLEX))
4038 );
4039 assert_eq!(
4040 ::std::mem::align_of::<FMOD_COMPLEX>(),
4041 4usize,
4042 concat!("Alignment of ", stringify!(FMOD_COMPLEX))
4043 );
4044 assert_eq!(
4045 unsafe { ::std::ptr::addr_of!((*ptr).real) as usize - ptr as usize },
4046 0usize,
4047 concat!(
4048 "Offset of field: ",
4049 stringify!(FMOD_COMPLEX),
4050 "::",
4051 stringify!(real)
4052 )
4053 );
4054 assert_eq!(
4055 unsafe { ::std::ptr::addr_of!((*ptr).imag) as usize - ptr as usize },
4056 4usize,
4057 concat!(
4058 "Offset of field: ",
4059 stringify!(FMOD_COMPLEX),
4060 "::",
4061 stringify!(imag)
4062 )
4063 );
4064}
4065#[repr(C)]
4066#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4067pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
4068 pub numpoints: ::std::os::raw::c_int,
4069 pub pointparamvalues: *mut f32,
4070 pub pointpositions: *mut f32,
4071}
4072#[test]
4073fn bindgen_test_layout_FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR() {
4074 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR> =
4075 ::std::mem::MaybeUninit::uninit();
4076 let ptr = UNINIT.as_ptr();
4077 assert_eq!(
4078 ::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>(),
4079 24usize,
4080 concat!(
4081 "Size of: ",
4082 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR)
4083 )
4084 );
4085 assert_eq!(
4086 ::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR>(),
4087 8usize,
4088 concat!(
4089 "Alignment of ",
4090 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR)
4091 )
4092 );
4093 assert_eq!(
4094 unsafe { ::std::ptr::addr_of!((*ptr).numpoints) as usize - ptr as usize },
4095 0usize,
4096 concat!(
4097 "Offset of field: ",
4098 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR),
4099 "::",
4100 stringify!(numpoints)
4101 )
4102 );
4103 assert_eq!(
4104 unsafe { ::std::ptr::addr_of!((*ptr).pointparamvalues) as usize - ptr as usize },
4105 8usize,
4106 concat!(
4107 "Offset of field: ",
4108 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR),
4109 "::",
4110 stringify!(pointparamvalues)
4111 )
4112 );
4113 assert_eq!(
4114 unsafe { ::std::ptr::addr_of!((*ptr).pointpositions) as usize - ptr as usize },
4115 16usize,
4116 concat!(
4117 "Offset of field: ",
4118 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR),
4119 "::",
4120 stringify!(pointpositions)
4121 )
4122 );
4123}
4124impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR {
4125 fn default() -> Self {
4126 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4127 unsafe {
4128 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4129 s.assume_init()
4130 }
4131 }
4132}
4133#[repr(C)]
4134#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4135pub struct FMOD_DSP_PARAMETER_FLOAT_MAPPING {
4136 pub type_: FMOD_DSP_PARAMETER_FLOAT_MAPPING_TYPE,
4137 pub piecewiselinearmapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING_PIECEWISE_LINEAR,
4138}
4139#[test]
4140fn bindgen_test_layout_FMOD_DSP_PARAMETER_FLOAT_MAPPING() {
4141 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_FLOAT_MAPPING> =
4142 ::std::mem::MaybeUninit::uninit();
4143 let ptr = UNINIT.as_ptr();
4144 assert_eq!(
4145 ::std::mem::size_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>(),
4146 32usize,
4147 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING))
4148 );
4149 assert_eq!(
4150 ::std::mem::align_of::<FMOD_DSP_PARAMETER_FLOAT_MAPPING>(),
4151 8usize,
4152 concat!(
4153 "Alignment of ",
4154 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING)
4155 )
4156 );
4157 assert_eq!(
4158 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4159 0usize,
4160 concat!(
4161 "Offset of field: ",
4162 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING),
4163 "::",
4164 stringify!(type_)
4165 )
4166 );
4167 assert_eq!(
4168 unsafe { ::std::ptr::addr_of!((*ptr).piecewiselinearmapping) as usize - ptr as usize },
4169 8usize,
4170 concat!(
4171 "Offset of field: ",
4172 stringify!(FMOD_DSP_PARAMETER_FLOAT_MAPPING),
4173 "::",
4174 stringify!(piecewiselinearmapping)
4175 )
4176 );
4177}
4178impl Default for FMOD_DSP_PARAMETER_FLOAT_MAPPING {
4179 fn default() -> Self {
4180 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4181 unsafe {
4182 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4183 s.assume_init()
4184 }
4185 }
4186}
4187#[repr(C)]
4188#[derive(Debug, Copy, Clone, PartialEq)]
4189pub struct FMOD_DSP_PARAMETER_DESC_FLOAT {
4190 pub min: f32,
4191 pub max: f32,
4192 pub defaultval: f32,
4193 pub mapping: FMOD_DSP_PARAMETER_FLOAT_MAPPING,
4194}
4195#[test]
4196fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC_FLOAT() {
4197 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC_FLOAT> =
4198 ::std::mem::MaybeUninit::uninit();
4199 let ptr = UNINIT.as_ptr();
4200 assert_eq!(
4201 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>(),
4202 48usize,
4203 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT))
4204 );
4205 assert_eq!(
4206 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_FLOAT>(),
4207 8usize,
4208 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT))
4209 );
4210 assert_eq!(
4211 unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
4212 0usize,
4213 concat!(
4214 "Offset of field: ",
4215 stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT),
4216 "::",
4217 stringify!(min)
4218 )
4219 );
4220 assert_eq!(
4221 unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
4222 4usize,
4223 concat!(
4224 "Offset of field: ",
4225 stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT),
4226 "::",
4227 stringify!(max)
4228 )
4229 );
4230 assert_eq!(
4231 unsafe { ::std::ptr::addr_of!((*ptr).defaultval) as usize - ptr as usize },
4232 8usize,
4233 concat!(
4234 "Offset of field: ",
4235 stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT),
4236 "::",
4237 stringify!(defaultval)
4238 )
4239 );
4240 assert_eq!(
4241 unsafe { ::std::ptr::addr_of!((*ptr).mapping) as usize - ptr as usize },
4242 16usize,
4243 concat!(
4244 "Offset of field: ",
4245 stringify!(FMOD_DSP_PARAMETER_DESC_FLOAT),
4246 "::",
4247 stringify!(mapping)
4248 )
4249 );
4250}
4251impl Default for FMOD_DSP_PARAMETER_DESC_FLOAT {
4252 fn default() -> Self {
4253 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4254 unsafe {
4255 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4256 s.assume_init()
4257 }
4258 }
4259}
4260#[repr(C)]
4261#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4262pub struct FMOD_DSP_PARAMETER_DESC_INT {
4263 pub min: ::std::os::raw::c_int,
4264 pub max: ::std::os::raw::c_int,
4265 pub defaultval: ::std::os::raw::c_int,
4266 pub goestoinf: FMOD_BOOL,
4267 pub valuenames: *const *const ::std::os::raw::c_char,
4268}
4269#[test]
4270fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC_INT() {
4271 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC_INT> =
4272 ::std::mem::MaybeUninit::uninit();
4273 let ptr = UNINIT.as_ptr();
4274 assert_eq!(
4275 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_INT>(),
4276 24usize,
4277 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_DESC_INT))
4278 );
4279 assert_eq!(
4280 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_INT>(),
4281 8usize,
4282 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_DESC_INT))
4283 );
4284 assert_eq!(
4285 unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
4286 0usize,
4287 concat!(
4288 "Offset of field: ",
4289 stringify!(FMOD_DSP_PARAMETER_DESC_INT),
4290 "::",
4291 stringify!(min)
4292 )
4293 );
4294 assert_eq!(
4295 unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
4296 4usize,
4297 concat!(
4298 "Offset of field: ",
4299 stringify!(FMOD_DSP_PARAMETER_DESC_INT),
4300 "::",
4301 stringify!(max)
4302 )
4303 );
4304 assert_eq!(
4305 unsafe { ::std::ptr::addr_of!((*ptr).defaultval) as usize - ptr as usize },
4306 8usize,
4307 concat!(
4308 "Offset of field: ",
4309 stringify!(FMOD_DSP_PARAMETER_DESC_INT),
4310 "::",
4311 stringify!(defaultval)
4312 )
4313 );
4314 assert_eq!(
4315 unsafe { ::std::ptr::addr_of!((*ptr).goestoinf) as usize - ptr as usize },
4316 12usize,
4317 concat!(
4318 "Offset of field: ",
4319 stringify!(FMOD_DSP_PARAMETER_DESC_INT),
4320 "::",
4321 stringify!(goestoinf)
4322 )
4323 );
4324 assert_eq!(
4325 unsafe { ::std::ptr::addr_of!((*ptr).valuenames) as usize - ptr as usize },
4326 16usize,
4327 concat!(
4328 "Offset of field: ",
4329 stringify!(FMOD_DSP_PARAMETER_DESC_INT),
4330 "::",
4331 stringify!(valuenames)
4332 )
4333 );
4334}
4335impl Default for FMOD_DSP_PARAMETER_DESC_INT {
4336 fn default() -> Self {
4337 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4338 unsafe {
4339 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4340 s.assume_init()
4341 }
4342 }
4343}
4344#[repr(C)]
4345#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4346pub struct FMOD_DSP_PARAMETER_DESC_BOOL {
4347 pub defaultval: FMOD_BOOL,
4348 pub valuenames: *const *const ::std::os::raw::c_char,
4349}
4350#[test]
4351fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC_BOOL() {
4352 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC_BOOL> =
4353 ::std::mem::MaybeUninit::uninit();
4354 let ptr = UNINIT.as_ptr();
4355 assert_eq!(
4356 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_BOOL>(),
4357 16usize,
4358 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_DESC_BOOL))
4359 );
4360 assert_eq!(
4361 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_BOOL>(),
4362 8usize,
4363 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_DESC_BOOL))
4364 );
4365 assert_eq!(
4366 unsafe { ::std::ptr::addr_of!((*ptr).defaultval) as usize - ptr as usize },
4367 0usize,
4368 concat!(
4369 "Offset of field: ",
4370 stringify!(FMOD_DSP_PARAMETER_DESC_BOOL),
4371 "::",
4372 stringify!(defaultval)
4373 )
4374 );
4375 assert_eq!(
4376 unsafe { ::std::ptr::addr_of!((*ptr).valuenames) as usize - ptr as usize },
4377 8usize,
4378 concat!(
4379 "Offset of field: ",
4380 stringify!(FMOD_DSP_PARAMETER_DESC_BOOL),
4381 "::",
4382 stringify!(valuenames)
4383 )
4384 );
4385}
4386impl Default for FMOD_DSP_PARAMETER_DESC_BOOL {
4387 fn default() -> Self {
4388 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4389 unsafe {
4390 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4391 s.assume_init()
4392 }
4393 }
4394}
4395#[repr(C)]
4396#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
4397pub struct FMOD_DSP_PARAMETER_DESC_DATA {
4398 pub datatype: ::std::os::raw::c_int,
4399}
4400#[test]
4401fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC_DATA() {
4402 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC_DATA> =
4403 ::std::mem::MaybeUninit::uninit();
4404 let ptr = UNINIT.as_ptr();
4405 assert_eq!(
4406 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC_DATA>(),
4407 4usize,
4408 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_DESC_DATA))
4409 );
4410 assert_eq!(
4411 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC_DATA>(),
4412 4usize,
4413 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_DESC_DATA))
4414 );
4415 assert_eq!(
4416 unsafe { ::std::ptr::addr_of!((*ptr).datatype) as usize - ptr as usize },
4417 0usize,
4418 concat!(
4419 "Offset of field: ",
4420 stringify!(FMOD_DSP_PARAMETER_DESC_DATA),
4421 "::",
4422 stringify!(datatype)
4423 )
4424 );
4425}
4426#[repr(C)]
4427#[derive(Copy, Clone)]
4428pub struct FMOD_DSP_PARAMETER_DESC {
4429 pub type_: FMOD_DSP_PARAMETER_TYPE,
4430 pub name: [::std::os::raw::c_char; 16usize],
4431 pub label: [::std::os::raw::c_char; 16usize],
4432 pub description: *const ::std::os::raw::c_char,
4433 pub __bindgen_anon_1: FMOD_DSP_PARAMETER_DESC__bindgen_ty_1,
4434}
4435#[repr(C)]
4436#[derive(Copy, Clone)]
4437pub union FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
4438 pub floatdesc: FMOD_DSP_PARAMETER_DESC_FLOAT,
4439 pub intdesc: FMOD_DSP_PARAMETER_DESC_INT,
4440 pub booldesc: FMOD_DSP_PARAMETER_DESC_BOOL,
4441 pub datadesc: FMOD_DSP_PARAMETER_DESC_DATA,
4442}
4443#[test]
4444fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC__bindgen_ty_1() {
4445 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1> =
4446 ::std::mem::MaybeUninit::uninit();
4447 let ptr = UNINIT.as_ptr();
4448 assert_eq!(
4449 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>(),
4450 48usize,
4451 concat!(
4452 "Size of: ",
4453 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1)
4454 )
4455 );
4456 assert_eq!(
4457 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC__bindgen_ty_1>(),
4458 8usize,
4459 concat!(
4460 "Alignment of ",
4461 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1)
4462 )
4463 );
4464 assert_eq!(
4465 unsafe { ::std::ptr::addr_of!((*ptr).floatdesc) as usize - ptr as usize },
4466 0usize,
4467 concat!(
4468 "Offset of field: ",
4469 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1),
4470 "::",
4471 stringify!(floatdesc)
4472 )
4473 );
4474 assert_eq!(
4475 unsafe { ::std::ptr::addr_of!((*ptr).intdesc) as usize - ptr as usize },
4476 0usize,
4477 concat!(
4478 "Offset of field: ",
4479 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1),
4480 "::",
4481 stringify!(intdesc)
4482 )
4483 );
4484 assert_eq!(
4485 unsafe { ::std::ptr::addr_of!((*ptr).booldesc) as usize - ptr as usize },
4486 0usize,
4487 concat!(
4488 "Offset of field: ",
4489 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1),
4490 "::",
4491 stringify!(booldesc)
4492 )
4493 );
4494 assert_eq!(
4495 unsafe { ::std::ptr::addr_of!((*ptr).datadesc) as usize - ptr as usize },
4496 0usize,
4497 concat!(
4498 "Offset of field: ",
4499 stringify!(FMOD_DSP_PARAMETER_DESC__bindgen_ty_1),
4500 "::",
4501 stringify!(datadesc)
4502 )
4503 );
4504}
4505impl Default for FMOD_DSP_PARAMETER_DESC__bindgen_ty_1 {
4506 fn default() -> Self {
4507 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4508 unsafe {
4509 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4510 s.assume_init()
4511 }
4512 }
4513}
4514#[test]
4515fn bindgen_test_layout_FMOD_DSP_PARAMETER_DESC() {
4516 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_DESC> =
4517 ::std::mem::MaybeUninit::uninit();
4518 let ptr = UNINIT.as_ptr();
4519 assert_eq!(
4520 ::std::mem::size_of::<FMOD_DSP_PARAMETER_DESC>(),
4521 96usize,
4522 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_DESC))
4523 );
4524 assert_eq!(
4525 ::std::mem::align_of::<FMOD_DSP_PARAMETER_DESC>(),
4526 8usize,
4527 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_DESC))
4528 );
4529 assert_eq!(
4530 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
4531 0usize,
4532 concat!(
4533 "Offset of field: ",
4534 stringify!(FMOD_DSP_PARAMETER_DESC),
4535 "::",
4536 stringify!(type_)
4537 )
4538 );
4539 assert_eq!(
4540 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
4541 4usize,
4542 concat!(
4543 "Offset of field: ",
4544 stringify!(FMOD_DSP_PARAMETER_DESC),
4545 "::",
4546 stringify!(name)
4547 )
4548 );
4549 assert_eq!(
4550 unsafe { ::std::ptr::addr_of!((*ptr).label) as usize - ptr as usize },
4551 20usize,
4552 concat!(
4553 "Offset of field: ",
4554 stringify!(FMOD_DSP_PARAMETER_DESC),
4555 "::",
4556 stringify!(label)
4557 )
4558 );
4559 assert_eq!(
4560 unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
4561 40usize,
4562 concat!(
4563 "Offset of field: ",
4564 stringify!(FMOD_DSP_PARAMETER_DESC),
4565 "::",
4566 stringify!(description)
4567 )
4568 );
4569}
4570impl Default for FMOD_DSP_PARAMETER_DESC {
4571 fn default() -> Self {
4572 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4573 unsafe {
4574 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4575 s.assume_init()
4576 }
4577 }
4578}
4579#[repr(C)]
4580#[derive(Debug, Default, Copy, Clone, PartialEq)]
4581pub struct FMOD_DSP_PARAMETER_OVERALLGAIN {
4582 pub linear_gain: f32,
4583 pub linear_gain_additive: f32,
4584}
4585#[test]
4586fn bindgen_test_layout_FMOD_DSP_PARAMETER_OVERALLGAIN() {
4587 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_OVERALLGAIN> =
4588 ::std::mem::MaybeUninit::uninit();
4589 let ptr = UNINIT.as_ptr();
4590 assert_eq!(
4591 ::std::mem::size_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>(),
4592 8usize,
4593 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_OVERALLGAIN))
4594 );
4595 assert_eq!(
4596 ::std::mem::align_of::<FMOD_DSP_PARAMETER_OVERALLGAIN>(),
4597 4usize,
4598 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_OVERALLGAIN))
4599 );
4600 assert_eq!(
4601 unsafe { ::std::ptr::addr_of!((*ptr).linear_gain) as usize - ptr as usize },
4602 0usize,
4603 concat!(
4604 "Offset of field: ",
4605 stringify!(FMOD_DSP_PARAMETER_OVERALLGAIN),
4606 "::",
4607 stringify!(linear_gain)
4608 )
4609 );
4610 assert_eq!(
4611 unsafe { ::std::ptr::addr_of!((*ptr).linear_gain_additive) as usize - ptr as usize },
4612 4usize,
4613 concat!(
4614 "Offset of field: ",
4615 stringify!(FMOD_DSP_PARAMETER_OVERALLGAIN),
4616 "::",
4617 stringify!(linear_gain_additive)
4618 )
4619 );
4620}
4621#[repr(C)]
4622#[derive(Debug, Default, Copy, Clone, PartialEq)]
4623pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES {
4624 pub relative: FMOD_3D_ATTRIBUTES,
4625 pub absolute: FMOD_3D_ATTRIBUTES,
4626}
4627#[test]
4628fn bindgen_test_layout_FMOD_DSP_PARAMETER_3DATTRIBUTES() {
4629 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_3DATTRIBUTES> =
4630 ::std::mem::MaybeUninit::uninit();
4631 let ptr = UNINIT.as_ptr();
4632 assert_eq!(
4633 ::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>(),
4634 96usize,
4635 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES))
4636 );
4637 assert_eq!(
4638 ::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES>(),
4639 4usize,
4640 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES))
4641 );
4642 assert_eq!(
4643 unsafe { ::std::ptr::addr_of!((*ptr).relative) as usize - ptr as usize },
4644 0usize,
4645 concat!(
4646 "Offset of field: ",
4647 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES),
4648 "::",
4649 stringify!(relative)
4650 )
4651 );
4652 assert_eq!(
4653 unsafe { ::std::ptr::addr_of!((*ptr).absolute) as usize - ptr as usize },
4654 48usize,
4655 concat!(
4656 "Offset of field: ",
4657 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES),
4658 "::",
4659 stringify!(absolute)
4660 )
4661 );
4662}
4663#[repr(C)]
4664#[derive(Debug, Default, Copy, Clone, PartialEq)]
4665pub struct FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI {
4666 pub numlisteners: ::std::os::raw::c_int,
4667 pub relative: [FMOD_3D_ATTRIBUTES; 8usize],
4668 pub weight: [f32; 8usize],
4669 pub absolute: FMOD_3D_ATTRIBUTES,
4670}
4671#[test]
4672fn bindgen_test_layout_FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI() {
4673 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI> =
4674 ::std::mem::MaybeUninit::uninit();
4675 let ptr = UNINIT.as_ptr();
4676 assert_eq!(
4677 ::std::mem::size_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>(),
4678 468usize,
4679 concat!(
4680 "Size of: ",
4681 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI)
4682 )
4683 );
4684 assert_eq!(
4685 ::std::mem::align_of::<FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI>(),
4686 4usize,
4687 concat!(
4688 "Alignment of ",
4689 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI)
4690 )
4691 );
4692 assert_eq!(
4693 unsafe { ::std::ptr::addr_of!((*ptr).numlisteners) as usize - ptr as usize },
4694 0usize,
4695 concat!(
4696 "Offset of field: ",
4697 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI),
4698 "::",
4699 stringify!(numlisteners)
4700 )
4701 );
4702 assert_eq!(
4703 unsafe { ::std::ptr::addr_of!((*ptr).relative) as usize - ptr as usize },
4704 4usize,
4705 concat!(
4706 "Offset of field: ",
4707 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI),
4708 "::",
4709 stringify!(relative)
4710 )
4711 );
4712 assert_eq!(
4713 unsafe { ::std::ptr::addr_of!((*ptr).weight) as usize - ptr as usize },
4714 388usize,
4715 concat!(
4716 "Offset of field: ",
4717 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI),
4718 "::",
4719 stringify!(weight)
4720 )
4721 );
4722 assert_eq!(
4723 unsafe { ::std::ptr::addr_of!((*ptr).absolute) as usize - ptr as usize },
4724 420usize,
4725 concat!(
4726 "Offset of field: ",
4727 stringify!(FMOD_DSP_PARAMETER_3DATTRIBUTES_MULTI),
4728 "::",
4729 stringify!(absolute)
4730 )
4731 );
4732}
4733#[repr(C)]
4734#[derive(Debug, Default, Copy, Clone, PartialEq)]
4735pub struct FMOD_DSP_PARAMETER_ATTENUATION_RANGE {
4736 pub min: f32,
4737 pub max: f32,
4738}
4739#[test]
4740fn bindgen_test_layout_FMOD_DSP_PARAMETER_ATTENUATION_RANGE() {
4741 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_ATTENUATION_RANGE> =
4742 ::std::mem::MaybeUninit::uninit();
4743 let ptr = UNINIT.as_ptr();
4744 assert_eq!(
4745 ::std::mem::size_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>(),
4746 8usize,
4747 concat!(
4748 "Size of: ",
4749 stringify!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE)
4750 )
4751 );
4752 assert_eq!(
4753 ::std::mem::align_of::<FMOD_DSP_PARAMETER_ATTENUATION_RANGE>(),
4754 4usize,
4755 concat!(
4756 "Alignment of ",
4757 stringify!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE)
4758 )
4759 );
4760 assert_eq!(
4761 unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
4762 0usize,
4763 concat!(
4764 "Offset of field: ",
4765 stringify!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE),
4766 "::",
4767 stringify!(min)
4768 )
4769 );
4770 assert_eq!(
4771 unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
4772 4usize,
4773 concat!(
4774 "Offset of field: ",
4775 stringify!(FMOD_DSP_PARAMETER_ATTENUATION_RANGE),
4776 "::",
4777 stringify!(max)
4778 )
4779 );
4780}
4781#[repr(C)]
4782#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
4783pub struct FMOD_DSP_PARAMETER_SIDECHAIN {
4784 pub sidechainenable: FMOD_BOOL,
4785}
4786#[test]
4787fn bindgen_test_layout_FMOD_DSP_PARAMETER_SIDECHAIN() {
4788 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_SIDECHAIN> =
4789 ::std::mem::MaybeUninit::uninit();
4790 let ptr = UNINIT.as_ptr();
4791 assert_eq!(
4792 ::std::mem::size_of::<FMOD_DSP_PARAMETER_SIDECHAIN>(),
4793 4usize,
4794 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_SIDECHAIN))
4795 );
4796 assert_eq!(
4797 ::std::mem::align_of::<FMOD_DSP_PARAMETER_SIDECHAIN>(),
4798 4usize,
4799 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_SIDECHAIN))
4800 );
4801 assert_eq!(
4802 unsafe { ::std::ptr::addr_of!((*ptr).sidechainenable) as usize - ptr as usize },
4803 0usize,
4804 concat!(
4805 "Offset of field: ",
4806 stringify!(FMOD_DSP_PARAMETER_SIDECHAIN),
4807 "::",
4808 stringify!(sidechainenable)
4809 )
4810 );
4811}
4812#[repr(C)]
4813#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4814pub struct FMOD_DSP_PARAMETER_FFT {
4815 pub length: ::std::os::raw::c_int,
4816 pub numchannels: ::std::os::raw::c_int,
4817 pub spectrum: [*mut f32; 32usize],
4818}
4819#[test]
4820fn bindgen_test_layout_FMOD_DSP_PARAMETER_FFT() {
4821 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_PARAMETER_FFT> =
4822 ::std::mem::MaybeUninit::uninit();
4823 let ptr = UNINIT.as_ptr();
4824 assert_eq!(
4825 ::std::mem::size_of::<FMOD_DSP_PARAMETER_FFT>(),
4826 264usize,
4827 concat!("Size of: ", stringify!(FMOD_DSP_PARAMETER_FFT))
4828 );
4829 assert_eq!(
4830 ::std::mem::align_of::<FMOD_DSP_PARAMETER_FFT>(),
4831 8usize,
4832 concat!("Alignment of ", stringify!(FMOD_DSP_PARAMETER_FFT))
4833 );
4834 assert_eq!(
4835 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
4836 0usize,
4837 concat!(
4838 "Offset of field: ",
4839 stringify!(FMOD_DSP_PARAMETER_FFT),
4840 "::",
4841 stringify!(length)
4842 )
4843 );
4844 assert_eq!(
4845 unsafe { ::std::ptr::addr_of!((*ptr).numchannels) as usize - ptr as usize },
4846 4usize,
4847 concat!(
4848 "Offset of field: ",
4849 stringify!(FMOD_DSP_PARAMETER_FFT),
4850 "::",
4851 stringify!(numchannels)
4852 )
4853 );
4854 assert_eq!(
4855 unsafe { ::std::ptr::addr_of!((*ptr).spectrum) as usize - ptr as usize },
4856 8usize,
4857 concat!(
4858 "Offset of field: ",
4859 stringify!(FMOD_DSP_PARAMETER_FFT),
4860 "::",
4861 stringify!(spectrum)
4862 )
4863 );
4864}
4865impl Default for FMOD_DSP_PARAMETER_FFT {
4866 fn default() -> Self {
4867 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4868 unsafe {
4869 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4870 s.assume_init()
4871 }
4872 }
4873}
4874#[repr(C)]
4875#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
4876pub struct FMOD_DSP_DESCRIPTION {
4877 pub pluginsdkversion: ::std::os::raw::c_uint,
4878 pub name: [::std::os::raw::c_char; 32usize],
4879 pub version: ::std::os::raw::c_uint,
4880 pub numinputbuffers: ::std::os::raw::c_int,
4881 pub numoutputbuffers: ::std::os::raw::c_int,
4882 pub create: FMOD_DSP_CREATE_CALLBACK,
4883 pub release: FMOD_DSP_RELEASE_CALLBACK,
4884 pub reset: FMOD_DSP_RESET_CALLBACK,
4885 pub read: FMOD_DSP_READ_CALLBACK,
4886 pub process: FMOD_DSP_PROCESS_CALLBACK,
4887 pub setposition: FMOD_DSP_SETPOSITION_CALLBACK,
4888 pub numparameters: ::std::os::raw::c_int,
4889 pub paramdesc: *mut *mut FMOD_DSP_PARAMETER_DESC,
4890 pub setparameterfloat: FMOD_DSP_SETPARAM_FLOAT_CALLBACK,
4891 pub setparameterint: FMOD_DSP_SETPARAM_INT_CALLBACK,
4892 pub setparameterbool: FMOD_DSP_SETPARAM_BOOL_CALLBACK,
4893 pub setparameterdata: FMOD_DSP_SETPARAM_DATA_CALLBACK,
4894 pub getparameterfloat: FMOD_DSP_GETPARAM_FLOAT_CALLBACK,
4895 pub getparameterint: FMOD_DSP_GETPARAM_INT_CALLBACK,
4896 pub getparameterbool: FMOD_DSP_GETPARAM_BOOL_CALLBACK,
4897 pub getparameterdata: FMOD_DSP_GETPARAM_DATA_CALLBACK,
4898 pub shouldiprocess: FMOD_DSP_SHOULDIPROCESS_CALLBACK,
4899 pub userdata: *mut ::std::os::raw::c_void,
4900 pub sys_register: FMOD_DSP_SYSTEM_REGISTER_CALLBACK,
4901 pub sys_deregister: FMOD_DSP_SYSTEM_DEREGISTER_CALLBACK,
4902 pub sys_mix: FMOD_DSP_SYSTEM_MIX_CALLBACK,
4903}
4904#[test]
4905fn bindgen_test_layout_FMOD_DSP_DESCRIPTION() {
4906 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_DESCRIPTION> = ::std::mem::MaybeUninit::uninit();
4907 let ptr = UNINIT.as_ptr();
4908 assert_eq!(
4909 ::std::mem::size_of::<FMOD_DSP_DESCRIPTION>(),
4910 216usize,
4911 concat!("Size of: ", stringify!(FMOD_DSP_DESCRIPTION))
4912 );
4913 assert_eq!(
4914 ::std::mem::align_of::<FMOD_DSP_DESCRIPTION>(),
4915 8usize,
4916 concat!("Alignment of ", stringify!(FMOD_DSP_DESCRIPTION))
4917 );
4918 assert_eq!(
4919 unsafe { ::std::ptr::addr_of!((*ptr).pluginsdkversion) as usize - ptr as usize },
4920 0usize,
4921 concat!(
4922 "Offset of field: ",
4923 stringify!(FMOD_DSP_DESCRIPTION),
4924 "::",
4925 stringify!(pluginsdkversion)
4926 )
4927 );
4928 assert_eq!(
4929 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
4930 4usize,
4931 concat!(
4932 "Offset of field: ",
4933 stringify!(FMOD_DSP_DESCRIPTION),
4934 "::",
4935 stringify!(name)
4936 )
4937 );
4938 assert_eq!(
4939 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
4940 36usize,
4941 concat!(
4942 "Offset of field: ",
4943 stringify!(FMOD_DSP_DESCRIPTION),
4944 "::",
4945 stringify!(version)
4946 )
4947 );
4948 assert_eq!(
4949 unsafe { ::std::ptr::addr_of!((*ptr).numinputbuffers) as usize - ptr as usize },
4950 40usize,
4951 concat!(
4952 "Offset of field: ",
4953 stringify!(FMOD_DSP_DESCRIPTION),
4954 "::",
4955 stringify!(numinputbuffers)
4956 )
4957 );
4958 assert_eq!(
4959 unsafe { ::std::ptr::addr_of!((*ptr).numoutputbuffers) as usize - ptr as usize },
4960 44usize,
4961 concat!(
4962 "Offset of field: ",
4963 stringify!(FMOD_DSP_DESCRIPTION),
4964 "::",
4965 stringify!(numoutputbuffers)
4966 )
4967 );
4968 assert_eq!(
4969 unsafe { ::std::ptr::addr_of!((*ptr).create) as usize - ptr as usize },
4970 48usize,
4971 concat!(
4972 "Offset of field: ",
4973 stringify!(FMOD_DSP_DESCRIPTION),
4974 "::",
4975 stringify!(create)
4976 )
4977 );
4978 assert_eq!(
4979 unsafe { ::std::ptr::addr_of!((*ptr).release) as usize - ptr as usize },
4980 56usize,
4981 concat!(
4982 "Offset of field: ",
4983 stringify!(FMOD_DSP_DESCRIPTION),
4984 "::",
4985 stringify!(release)
4986 )
4987 );
4988 assert_eq!(
4989 unsafe { ::std::ptr::addr_of!((*ptr).reset) as usize - ptr as usize },
4990 64usize,
4991 concat!(
4992 "Offset of field: ",
4993 stringify!(FMOD_DSP_DESCRIPTION),
4994 "::",
4995 stringify!(reset)
4996 )
4997 );
4998 assert_eq!(
4999 unsafe { ::std::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
5000 72usize,
5001 concat!(
5002 "Offset of field: ",
5003 stringify!(FMOD_DSP_DESCRIPTION),
5004 "::",
5005 stringify!(read)
5006 )
5007 );
5008 assert_eq!(
5009 unsafe { ::std::ptr::addr_of!((*ptr).process) as usize - ptr as usize },
5010 80usize,
5011 concat!(
5012 "Offset of field: ",
5013 stringify!(FMOD_DSP_DESCRIPTION),
5014 "::",
5015 stringify!(process)
5016 )
5017 );
5018 assert_eq!(
5019 unsafe { ::std::ptr::addr_of!((*ptr).setposition) as usize - ptr as usize },
5020 88usize,
5021 concat!(
5022 "Offset of field: ",
5023 stringify!(FMOD_DSP_DESCRIPTION),
5024 "::",
5025 stringify!(setposition)
5026 )
5027 );
5028 assert_eq!(
5029 unsafe { ::std::ptr::addr_of!((*ptr).numparameters) as usize - ptr as usize },
5030 96usize,
5031 concat!(
5032 "Offset of field: ",
5033 stringify!(FMOD_DSP_DESCRIPTION),
5034 "::",
5035 stringify!(numparameters)
5036 )
5037 );
5038 assert_eq!(
5039 unsafe { ::std::ptr::addr_of!((*ptr).paramdesc) as usize - ptr as usize },
5040 104usize,
5041 concat!(
5042 "Offset of field: ",
5043 stringify!(FMOD_DSP_DESCRIPTION),
5044 "::",
5045 stringify!(paramdesc)
5046 )
5047 );
5048 assert_eq!(
5049 unsafe { ::std::ptr::addr_of!((*ptr).setparameterfloat) as usize - ptr as usize },
5050 112usize,
5051 concat!(
5052 "Offset of field: ",
5053 stringify!(FMOD_DSP_DESCRIPTION),
5054 "::",
5055 stringify!(setparameterfloat)
5056 )
5057 );
5058 assert_eq!(
5059 unsafe { ::std::ptr::addr_of!((*ptr).setparameterint) as usize - ptr as usize },
5060 120usize,
5061 concat!(
5062 "Offset of field: ",
5063 stringify!(FMOD_DSP_DESCRIPTION),
5064 "::",
5065 stringify!(setparameterint)
5066 )
5067 );
5068 assert_eq!(
5069 unsafe { ::std::ptr::addr_of!((*ptr).setparameterbool) as usize - ptr as usize },
5070 128usize,
5071 concat!(
5072 "Offset of field: ",
5073 stringify!(FMOD_DSP_DESCRIPTION),
5074 "::",
5075 stringify!(setparameterbool)
5076 )
5077 );
5078 assert_eq!(
5079 unsafe { ::std::ptr::addr_of!((*ptr).setparameterdata) as usize - ptr as usize },
5080 136usize,
5081 concat!(
5082 "Offset of field: ",
5083 stringify!(FMOD_DSP_DESCRIPTION),
5084 "::",
5085 stringify!(setparameterdata)
5086 )
5087 );
5088 assert_eq!(
5089 unsafe { ::std::ptr::addr_of!((*ptr).getparameterfloat) as usize - ptr as usize },
5090 144usize,
5091 concat!(
5092 "Offset of field: ",
5093 stringify!(FMOD_DSP_DESCRIPTION),
5094 "::",
5095 stringify!(getparameterfloat)
5096 )
5097 );
5098 assert_eq!(
5099 unsafe { ::std::ptr::addr_of!((*ptr).getparameterint) as usize - ptr as usize },
5100 152usize,
5101 concat!(
5102 "Offset of field: ",
5103 stringify!(FMOD_DSP_DESCRIPTION),
5104 "::",
5105 stringify!(getparameterint)
5106 )
5107 );
5108 assert_eq!(
5109 unsafe { ::std::ptr::addr_of!((*ptr).getparameterbool) as usize - ptr as usize },
5110 160usize,
5111 concat!(
5112 "Offset of field: ",
5113 stringify!(FMOD_DSP_DESCRIPTION),
5114 "::",
5115 stringify!(getparameterbool)
5116 )
5117 );
5118 assert_eq!(
5119 unsafe { ::std::ptr::addr_of!((*ptr).getparameterdata) as usize - ptr as usize },
5120 168usize,
5121 concat!(
5122 "Offset of field: ",
5123 stringify!(FMOD_DSP_DESCRIPTION),
5124 "::",
5125 stringify!(getparameterdata)
5126 )
5127 );
5128 assert_eq!(
5129 unsafe { ::std::ptr::addr_of!((*ptr).shouldiprocess) as usize - ptr as usize },
5130 176usize,
5131 concat!(
5132 "Offset of field: ",
5133 stringify!(FMOD_DSP_DESCRIPTION),
5134 "::",
5135 stringify!(shouldiprocess)
5136 )
5137 );
5138 assert_eq!(
5139 unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
5140 184usize,
5141 concat!(
5142 "Offset of field: ",
5143 stringify!(FMOD_DSP_DESCRIPTION),
5144 "::",
5145 stringify!(userdata)
5146 )
5147 );
5148 assert_eq!(
5149 unsafe { ::std::ptr::addr_of!((*ptr).sys_register) as usize - ptr as usize },
5150 192usize,
5151 concat!(
5152 "Offset of field: ",
5153 stringify!(FMOD_DSP_DESCRIPTION),
5154 "::",
5155 stringify!(sys_register)
5156 )
5157 );
5158 assert_eq!(
5159 unsafe { ::std::ptr::addr_of!((*ptr).sys_deregister) as usize - ptr as usize },
5160 200usize,
5161 concat!(
5162 "Offset of field: ",
5163 stringify!(FMOD_DSP_DESCRIPTION),
5164 "::",
5165 stringify!(sys_deregister)
5166 )
5167 );
5168 assert_eq!(
5169 unsafe { ::std::ptr::addr_of!((*ptr).sys_mix) as usize - ptr as usize },
5170 208usize,
5171 concat!(
5172 "Offset of field: ",
5173 stringify!(FMOD_DSP_DESCRIPTION),
5174 "::",
5175 stringify!(sys_mix)
5176 )
5177 );
5178}
5179impl Default for FMOD_DSP_DESCRIPTION {
5180 fn default() -> Self {
5181 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5182 unsafe {
5183 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5184 s.assume_init()
5185 }
5186 }
5187}
5188#[repr(C)]
5189#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
5190pub struct FMOD_DSP_STATE_DFT_FUNCTIONS {
5191 pub fftreal: FMOD_DSP_DFT_FFTREAL_FUNC,
5192 pub inversefftreal: FMOD_DSP_DFT_IFFTREAL_FUNC,
5193}
5194#[test]
5195fn bindgen_test_layout_FMOD_DSP_STATE_DFT_FUNCTIONS() {
5196 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_STATE_DFT_FUNCTIONS> =
5197 ::std::mem::MaybeUninit::uninit();
5198 let ptr = UNINIT.as_ptr();
5199 assert_eq!(
5200 ::std::mem::size_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>(),
5201 16usize,
5202 concat!("Size of: ", stringify!(FMOD_DSP_STATE_DFT_FUNCTIONS))
5203 );
5204 assert_eq!(
5205 ::std::mem::align_of::<FMOD_DSP_STATE_DFT_FUNCTIONS>(),
5206 8usize,
5207 concat!("Alignment of ", stringify!(FMOD_DSP_STATE_DFT_FUNCTIONS))
5208 );
5209 assert_eq!(
5210 unsafe { ::std::ptr::addr_of!((*ptr).fftreal) as usize - ptr as usize },
5211 0usize,
5212 concat!(
5213 "Offset of field: ",
5214 stringify!(FMOD_DSP_STATE_DFT_FUNCTIONS),
5215 "::",
5216 stringify!(fftreal)
5217 )
5218 );
5219 assert_eq!(
5220 unsafe { ::std::ptr::addr_of!((*ptr).inversefftreal) as usize - ptr as usize },
5221 8usize,
5222 concat!(
5223 "Offset of field: ",
5224 stringify!(FMOD_DSP_STATE_DFT_FUNCTIONS),
5225 "::",
5226 stringify!(inversefftreal)
5227 )
5228 );
5229}
5230#[repr(C)]
5231#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
5232pub struct FMOD_DSP_STATE_PAN_FUNCTIONS {
5233 pub summonomatrix: FMOD_DSP_PAN_SUMMONOMATRIX_FUNC,
5234 pub sumstereomatrix: FMOD_DSP_PAN_SUMSTEREOMATRIX_FUNC,
5235 pub sumsurroundmatrix: FMOD_DSP_PAN_SUMSURROUNDMATRIX_FUNC,
5236 pub summonotosurroundmatrix: FMOD_DSP_PAN_SUMMONOTOSURROUNDMATRIX_FUNC,
5237 pub sumstereotosurroundmatrix: FMOD_DSP_PAN_SUMSTEREOTOSURROUNDMATRIX_FUNC,
5238 pub getrolloffgain: FMOD_DSP_PAN_GETROLLOFFGAIN_FUNC,
5239}
5240#[test]
5241fn bindgen_test_layout_FMOD_DSP_STATE_PAN_FUNCTIONS() {
5242 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_STATE_PAN_FUNCTIONS> =
5243 ::std::mem::MaybeUninit::uninit();
5244 let ptr = UNINIT.as_ptr();
5245 assert_eq!(
5246 ::std::mem::size_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>(),
5247 48usize,
5248 concat!("Size of: ", stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS))
5249 );
5250 assert_eq!(
5251 ::std::mem::align_of::<FMOD_DSP_STATE_PAN_FUNCTIONS>(),
5252 8usize,
5253 concat!("Alignment of ", stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS))
5254 );
5255 assert_eq!(
5256 unsafe { ::std::ptr::addr_of!((*ptr).summonomatrix) as usize - ptr as usize },
5257 0usize,
5258 concat!(
5259 "Offset of field: ",
5260 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5261 "::",
5262 stringify!(summonomatrix)
5263 )
5264 );
5265 assert_eq!(
5266 unsafe { ::std::ptr::addr_of!((*ptr).sumstereomatrix) as usize - ptr as usize },
5267 8usize,
5268 concat!(
5269 "Offset of field: ",
5270 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5271 "::",
5272 stringify!(sumstereomatrix)
5273 )
5274 );
5275 assert_eq!(
5276 unsafe { ::std::ptr::addr_of!((*ptr).sumsurroundmatrix) as usize - ptr as usize },
5277 16usize,
5278 concat!(
5279 "Offset of field: ",
5280 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5281 "::",
5282 stringify!(sumsurroundmatrix)
5283 )
5284 );
5285 assert_eq!(
5286 unsafe { ::std::ptr::addr_of!((*ptr).summonotosurroundmatrix) as usize - ptr as usize },
5287 24usize,
5288 concat!(
5289 "Offset of field: ",
5290 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5291 "::",
5292 stringify!(summonotosurroundmatrix)
5293 )
5294 );
5295 assert_eq!(
5296 unsafe { ::std::ptr::addr_of!((*ptr).sumstereotosurroundmatrix) as usize - ptr as usize },
5297 32usize,
5298 concat!(
5299 "Offset of field: ",
5300 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5301 "::",
5302 stringify!(sumstereotosurroundmatrix)
5303 )
5304 );
5305 assert_eq!(
5306 unsafe { ::std::ptr::addr_of!((*ptr).getrolloffgain) as usize - ptr as usize },
5307 40usize,
5308 concat!(
5309 "Offset of field: ",
5310 stringify!(FMOD_DSP_STATE_PAN_FUNCTIONS),
5311 "::",
5312 stringify!(getrolloffgain)
5313 )
5314 );
5315}
5316#[repr(C)]
5317#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5318pub struct FMOD_DSP_STATE_FUNCTIONS {
5319 pub alloc: FMOD_DSP_ALLOC_FUNC,
5320 pub realloc: FMOD_DSP_REALLOC_FUNC,
5321 pub free: FMOD_DSP_FREE_FUNC,
5322 pub getsamplerate: FMOD_DSP_GETSAMPLERATE_FUNC,
5323 pub getblocksize: FMOD_DSP_GETBLOCKSIZE_FUNC,
5324 pub dft: *mut FMOD_DSP_STATE_DFT_FUNCTIONS,
5325 pub pan: *mut FMOD_DSP_STATE_PAN_FUNCTIONS,
5326 pub getspeakermode: FMOD_DSP_GETSPEAKERMODE_FUNC,
5327 pub getclock: FMOD_DSP_GETCLOCK_FUNC,
5328 pub getlistenerattributes: FMOD_DSP_GETLISTENERATTRIBUTES_FUNC,
5329 pub log: FMOD_DSP_LOG_FUNC,
5330 pub getuserdata: FMOD_DSP_GETUSERDATA_FUNC,
5331}
5332#[test]
5333fn bindgen_test_layout_FMOD_DSP_STATE_FUNCTIONS() {
5334 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_STATE_FUNCTIONS> =
5335 ::std::mem::MaybeUninit::uninit();
5336 let ptr = UNINIT.as_ptr();
5337 assert_eq!(
5338 ::std::mem::size_of::<FMOD_DSP_STATE_FUNCTIONS>(),
5339 96usize,
5340 concat!("Size of: ", stringify!(FMOD_DSP_STATE_FUNCTIONS))
5341 );
5342 assert_eq!(
5343 ::std::mem::align_of::<FMOD_DSP_STATE_FUNCTIONS>(),
5344 8usize,
5345 concat!("Alignment of ", stringify!(FMOD_DSP_STATE_FUNCTIONS))
5346 );
5347 assert_eq!(
5348 unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
5349 0usize,
5350 concat!(
5351 "Offset of field: ",
5352 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5353 "::",
5354 stringify!(alloc)
5355 )
5356 );
5357 assert_eq!(
5358 unsafe { ::std::ptr::addr_of!((*ptr).realloc) as usize - ptr as usize },
5359 8usize,
5360 concat!(
5361 "Offset of field: ",
5362 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5363 "::",
5364 stringify!(realloc)
5365 )
5366 );
5367 assert_eq!(
5368 unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
5369 16usize,
5370 concat!(
5371 "Offset of field: ",
5372 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5373 "::",
5374 stringify!(free)
5375 )
5376 );
5377 assert_eq!(
5378 unsafe { ::std::ptr::addr_of!((*ptr).getsamplerate) as usize - ptr as usize },
5379 24usize,
5380 concat!(
5381 "Offset of field: ",
5382 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5383 "::",
5384 stringify!(getsamplerate)
5385 )
5386 );
5387 assert_eq!(
5388 unsafe { ::std::ptr::addr_of!((*ptr).getblocksize) as usize - ptr as usize },
5389 32usize,
5390 concat!(
5391 "Offset of field: ",
5392 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5393 "::",
5394 stringify!(getblocksize)
5395 )
5396 );
5397 assert_eq!(
5398 unsafe { ::std::ptr::addr_of!((*ptr).dft) as usize - ptr as usize },
5399 40usize,
5400 concat!(
5401 "Offset of field: ",
5402 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5403 "::",
5404 stringify!(dft)
5405 )
5406 );
5407 assert_eq!(
5408 unsafe { ::std::ptr::addr_of!((*ptr).pan) as usize - ptr as usize },
5409 48usize,
5410 concat!(
5411 "Offset of field: ",
5412 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5413 "::",
5414 stringify!(pan)
5415 )
5416 );
5417 assert_eq!(
5418 unsafe { ::std::ptr::addr_of!((*ptr).getspeakermode) as usize - ptr as usize },
5419 56usize,
5420 concat!(
5421 "Offset of field: ",
5422 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5423 "::",
5424 stringify!(getspeakermode)
5425 )
5426 );
5427 assert_eq!(
5428 unsafe { ::std::ptr::addr_of!((*ptr).getclock) as usize - ptr as usize },
5429 64usize,
5430 concat!(
5431 "Offset of field: ",
5432 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5433 "::",
5434 stringify!(getclock)
5435 )
5436 );
5437 assert_eq!(
5438 unsafe { ::std::ptr::addr_of!((*ptr).getlistenerattributes) as usize - ptr as usize },
5439 72usize,
5440 concat!(
5441 "Offset of field: ",
5442 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5443 "::",
5444 stringify!(getlistenerattributes)
5445 )
5446 );
5447 assert_eq!(
5448 unsafe { ::std::ptr::addr_of!((*ptr).log) as usize - ptr as usize },
5449 80usize,
5450 concat!(
5451 "Offset of field: ",
5452 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5453 "::",
5454 stringify!(log)
5455 )
5456 );
5457 assert_eq!(
5458 unsafe { ::std::ptr::addr_of!((*ptr).getuserdata) as usize - ptr as usize },
5459 88usize,
5460 concat!(
5461 "Offset of field: ",
5462 stringify!(FMOD_DSP_STATE_FUNCTIONS),
5463 "::",
5464 stringify!(getuserdata)
5465 )
5466 );
5467}
5468impl Default for FMOD_DSP_STATE_FUNCTIONS {
5469 fn default() -> Self {
5470 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5471 unsafe {
5472 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5473 s.assume_init()
5474 }
5475 }
5476}
5477#[repr(C)]
5478#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5479pub struct FMOD_DSP_STATE {
5480 pub instance: *mut ::std::os::raw::c_void,
5481 pub plugindata: *mut ::std::os::raw::c_void,
5482 pub channelmask: FMOD_CHANNELMASK,
5483 pub source_speakermode: FMOD_SPEAKERMODE,
5484 pub sidechaindata: *mut f32,
5485 pub sidechainchannels: ::std::os::raw::c_int,
5486 pub functions: *mut FMOD_DSP_STATE_FUNCTIONS,
5487 pub systemobject: ::std::os::raw::c_int,
5488}
5489#[test]
5490fn bindgen_test_layout_FMOD_DSP_STATE() {
5491 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_STATE> = ::std::mem::MaybeUninit::uninit();
5492 let ptr = UNINIT.as_ptr();
5493 assert_eq!(
5494 ::std::mem::size_of::<FMOD_DSP_STATE>(),
5495 56usize,
5496 concat!("Size of: ", stringify!(FMOD_DSP_STATE))
5497 );
5498 assert_eq!(
5499 ::std::mem::align_of::<FMOD_DSP_STATE>(),
5500 8usize,
5501 concat!("Alignment of ", stringify!(FMOD_DSP_STATE))
5502 );
5503 assert_eq!(
5504 unsafe { ::std::ptr::addr_of!((*ptr).instance) as usize - ptr as usize },
5505 0usize,
5506 concat!(
5507 "Offset of field: ",
5508 stringify!(FMOD_DSP_STATE),
5509 "::",
5510 stringify!(instance)
5511 )
5512 );
5513 assert_eq!(
5514 unsafe { ::std::ptr::addr_of!((*ptr).plugindata) as usize - ptr as usize },
5515 8usize,
5516 concat!(
5517 "Offset of field: ",
5518 stringify!(FMOD_DSP_STATE),
5519 "::",
5520 stringify!(plugindata)
5521 )
5522 );
5523 assert_eq!(
5524 unsafe { ::std::ptr::addr_of!((*ptr).channelmask) as usize - ptr as usize },
5525 16usize,
5526 concat!(
5527 "Offset of field: ",
5528 stringify!(FMOD_DSP_STATE),
5529 "::",
5530 stringify!(channelmask)
5531 )
5532 );
5533 assert_eq!(
5534 unsafe { ::std::ptr::addr_of!((*ptr).source_speakermode) as usize - ptr as usize },
5535 20usize,
5536 concat!(
5537 "Offset of field: ",
5538 stringify!(FMOD_DSP_STATE),
5539 "::",
5540 stringify!(source_speakermode)
5541 )
5542 );
5543 assert_eq!(
5544 unsafe { ::std::ptr::addr_of!((*ptr).sidechaindata) as usize - ptr as usize },
5545 24usize,
5546 concat!(
5547 "Offset of field: ",
5548 stringify!(FMOD_DSP_STATE),
5549 "::",
5550 stringify!(sidechaindata)
5551 )
5552 );
5553 assert_eq!(
5554 unsafe { ::std::ptr::addr_of!((*ptr).sidechainchannels) as usize - ptr as usize },
5555 32usize,
5556 concat!(
5557 "Offset of field: ",
5558 stringify!(FMOD_DSP_STATE),
5559 "::",
5560 stringify!(sidechainchannels)
5561 )
5562 );
5563 assert_eq!(
5564 unsafe { ::std::ptr::addr_of!((*ptr).functions) as usize - ptr as usize },
5565 40usize,
5566 concat!(
5567 "Offset of field: ",
5568 stringify!(FMOD_DSP_STATE),
5569 "::",
5570 stringify!(functions)
5571 )
5572 );
5573 assert_eq!(
5574 unsafe { ::std::ptr::addr_of!((*ptr).systemobject) as usize - ptr as usize },
5575 48usize,
5576 concat!(
5577 "Offset of field: ",
5578 stringify!(FMOD_DSP_STATE),
5579 "::",
5580 stringify!(systemobject)
5581 )
5582 );
5583}
5584impl Default for FMOD_DSP_STATE {
5585 fn default() -> Self {
5586 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5587 unsafe {
5588 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5589 s.assume_init()
5590 }
5591 }
5592}
5593#[repr(C)]
5594#[derive(Debug, Default, Copy, Clone, PartialEq)]
5595pub struct FMOD_DSP_METERING_INFO {
5596 pub numsamples: ::std::os::raw::c_int,
5597 pub peaklevel: [f32; 32usize],
5598 pub rmslevel: [f32; 32usize],
5599 pub numchannels: ::std::os::raw::c_short,
5600}
5601#[test]
5602fn bindgen_test_layout_FMOD_DSP_METERING_INFO() {
5603 const UNINIT: ::std::mem::MaybeUninit<FMOD_DSP_METERING_INFO> =
5604 ::std::mem::MaybeUninit::uninit();
5605 let ptr = UNINIT.as_ptr();
5606 assert_eq!(
5607 ::std::mem::size_of::<FMOD_DSP_METERING_INFO>(),
5608 264usize,
5609 concat!("Size of: ", stringify!(FMOD_DSP_METERING_INFO))
5610 );
5611 assert_eq!(
5612 ::std::mem::align_of::<FMOD_DSP_METERING_INFO>(),
5613 4usize,
5614 concat!("Alignment of ", stringify!(FMOD_DSP_METERING_INFO))
5615 );
5616 assert_eq!(
5617 unsafe { ::std::ptr::addr_of!((*ptr).numsamples) as usize - ptr as usize },
5618 0usize,
5619 concat!(
5620 "Offset of field: ",
5621 stringify!(FMOD_DSP_METERING_INFO),
5622 "::",
5623 stringify!(numsamples)
5624 )
5625 );
5626 assert_eq!(
5627 unsafe { ::std::ptr::addr_of!((*ptr).peaklevel) as usize - ptr as usize },
5628 4usize,
5629 concat!(
5630 "Offset of field: ",
5631 stringify!(FMOD_DSP_METERING_INFO),
5632 "::",
5633 stringify!(peaklevel)
5634 )
5635 );
5636 assert_eq!(
5637 unsafe { ::std::ptr::addr_of!((*ptr).rmslevel) as usize - ptr as usize },
5638 132usize,
5639 concat!(
5640 "Offset of field: ",
5641 stringify!(FMOD_DSP_METERING_INFO),
5642 "::",
5643 stringify!(rmslevel)
5644 )
5645 );
5646 assert_eq!(
5647 unsafe { ::std::ptr::addr_of!((*ptr).numchannels) as usize - ptr as usize },
5648 260usize,
5649 concat!(
5650 "Offset of field: ",
5651 stringify!(FMOD_DSP_METERING_INFO),
5652 "::",
5653 stringify!(numchannels)
5654 )
5655 );
5656}
5657pub type FMOD_OUTPUT_METHOD = ::std::os::raw::c_uint;
5658pub type FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK = ::std::option::Option<
5659 unsafe extern "C" fn(
5660 output_state: *mut FMOD_OUTPUT_STATE,
5661 numdrivers: *mut ::std::os::raw::c_int,
5662 ) -> FMOD_RESULT,
5663>;
5664pub type FMOD_OUTPUT_GETDRIVERINFO_CALLBACK = ::std::option::Option<
5665 unsafe extern "C" fn(
5666 output_state: *mut FMOD_OUTPUT_STATE,
5667 id: ::std::os::raw::c_int,
5668 name: *mut ::std::os::raw::c_char,
5669 namelen: ::std::os::raw::c_int,
5670 guid: *mut FMOD_GUID,
5671 systemrate: *mut ::std::os::raw::c_int,
5672 speakermode: *mut FMOD_SPEAKERMODE,
5673 speakermodechannels: *mut ::std::os::raw::c_int,
5674 ) -> FMOD_RESULT,
5675>;
5676pub type FMOD_OUTPUT_INIT_CALLBACK = ::std::option::Option<
5677 unsafe extern "C" fn(
5678 output_state: *mut FMOD_OUTPUT_STATE,
5679 selecteddriver: ::std::os::raw::c_int,
5680 flags: FMOD_INITFLAGS,
5681 outputrate: *mut ::std::os::raw::c_int,
5682 speakermode: *mut FMOD_SPEAKERMODE,
5683 speakermodechannels: *mut ::std::os::raw::c_int,
5684 outputformat: *mut FMOD_SOUND_FORMAT,
5685 dspbufferlength: ::std::os::raw::c_int,
5686 dspnumbuffers: *mut ::std::os::raw::c_int,
5687 dspnumadditionalbuffers: *mut ::std::os::raw::c_int,
5688 extradriverdata: *mut ::std::os::raw::c_void,
5689 ) -> FMOD_RESULT,
5690>;
5691pub type FMOD_OUTPUT_START_CALLBACK = ::std::option::Option<
5692 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5693>;
5694pub type FMOD_OUTPUT_STOP_CALLBACK = ::std::option::Option<
5695 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5696>;
5697pub type FMOD_OUTPUT_CLOSE_CALLBACK = ::std::option::Option<
5698 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5699>;
5700pub type FMOD_OUTPUT_UPDATE_CALLBACK = ::std::option::Option<
5701 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5702>;
5703pub type FMOD_OUTPUT_GETHANDLE_CALLBACK = ::std::option::Option<
5704 unsafe extern "C" fn(
5705 output_state: *mut FMOD_OUTPUT_STATE,
5706 handle: *mut *mut ::std::os::raw::c_void,
5707 ) -> FMOD_RESULT,
5708>;
5709pub type FMOD_OUTPUT_MIXER_CALLBACK = ::std::option::Option<
5710 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5711>;
5712pub type FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK = ::std::option::Option<
5713 unsafe extern "C" fn(
5714 output_state: *mut FMOD_OUTPUT_STATE,
5715 maxhardwareobjects: *mut ::std::os::raw::c_int,
5716 ) -> FMOD_RESULT,
5717>;
5718pub type FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK = ::std::option::Option<
5719 unsafe extern "C" fn(
5720 output_state: *mut FMOD_OUTPUT_STATE,
5721 object3d: *mut *mut ::std::os::raw::c_void,
5722 ) -> FMOD_RESULT,
5723>;
5724pub type FMOD_OUTPUT_OBJECT3DFREE_CALLBACK = ::std::option::Option<
5725 unsafe extern "C" fn(
5726 output_state: *mut FMOD_OUTPUT_STATE,
5727 object3d: *mut ::std::os::raw::c_void,
5728 ) -> FMOD_RESULT,
5729>;
5730pub type FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK = ::std::option::Option<
5731 unsafe extern "C" fn(
5732 output_state: *mut FMOD_OUTPUT_STATE,
5733 object3d: *mut ::std::os::raw::c_void,
5734 info: *const FMOD_OUTPUT_OBJECT3DINFO,
5735 ) -> FMOD_RESULT,
5736>;
5737pub type FMOD_OUTPUT_OPENPORT_CALLBACK = ::std::option::Option<
5738 unsafe extern "C" fn(
5739 output_state: *mut FMOD_OUTPUT_STATE,
5740 portType: FMOD_PORT_TYPE,
5741 portIndex: FMOD_PORT_INDEX,
5742 portId: *mut ::std::os::raw::c_int,
5743 portRate: *mut ::std::os::raw::c_int,
5744 portChannels: *mut ::std::os::raw::c_int,
5745 portFormat: *mut FMOD_SOUND_FORMAT,
5746 ) -> FMOD_RESULT,
5747>;
5748pub type FMOD_OUTPUT_CLOSEPORT_CALLBACK = ::std::option::Option<
5749 unsafe extern "C" fn(
5750 output_state: *mut FMOD_OUTPUT_STATE,
5751 portId: ::std::os::raw::c_int,
5752 ) -> FMOD_RESULT,
5753>;
5754pub type FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK = ::std::option::Option<
5755 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5756>;
5757pub type FMOD_OUTPUT_READFROMMIXER_FUNC = ::std::option::Option<
5758 unsafe extern "C" fn(
5759 output_state: *mut FMOD_OUTPUT_STATE,
5760 buffer: *mut ::std::os::raw::c_void,
5761 length: ::std::os::raw::c_uint,
5762 ) -> FMOD_RESULT,
5763>;
5764pub type FMOD_OUTPUT_COPYPORT_FUNC = ::std::option::Option<
5765 unsafe extern "C" fn(
5766 output_state: *mut FMOD_OUTPUT_STATE,
5767 portId: ::std::os::raw::c_int,
5768 buffer: *mut ::std::os::raw::c_void,
5769 length: ::std::os::raw::c_uint,
5770 ) -> FMOD_RESULT,
5771>;
5772pub type FMOD_OUTPUT_REQUESTRESET_FUNC = ::std::option::Option<
5773 unsafe extern "C" fn(output_state: *mut FMOD_OUTPUT_STATE) -> FMOD_RESULT,
5774>;
5775pub type FMOD_OUTPUT_ALLOC_FUNC = ::std::option::Option<
5776 unsafe extern "C" fn(
5777 size: ::std::os::raw::c_uint,
5778 align: ::std::os::raw::c_uint,
5779 file: *const ::std::os::raw::c_char,
5780 line: ::std::os::raw::c_int,
5781 ) -> *mut ::std::os::raw::c_void,
5782>;
5783pub type FMOD_OUTPUT_FREE_FUNC = ::std::option::Option<
5784 unsafe extern "C" fn(
5785 ptr: *mut ::std::os::raw::c_void,
5786 file: *const ::std::os::raw::c_char,
5787 line: ::std::os::raw::c_int,
5788 ),
5789>;
5790pub type FMOD_OUTPUT_LOG_FUNC = ::std::option::Option<
5791 unsafe extern "C" fn(
5792 level: FMOD_DEBUG_FLAGS,
5793 file: *const ::std::os::raw::c_char,
5794 line: ::std::os::raw::c_int,
5795 function: *const ::std::os::raw::c_char,
5796 string: *const ::std::os::raw::c_char,
5797 ...
5798 ),
5799>;
5800#[repr(C)]
5801#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
5802pub struct FMOD_OUTPUT_DESCRIPTION {
5803 pub apiversion: ::std::os::raw::c_uint,
5804 pub name: *const ::std::os::raw::c_char,
5805 pub version: ::std::os::raw::c_uint,
5806 pub method: FMOD_OUTPUT_METHOD,
5807 pub getnumdrivers: FMOD_OUTPUT_GETNUMDRIVERS_CALLBACK,
5808 pub getdriverinfo: FMOD_OUTPUT_GETDRIVERINFO_CALLBACK,
5809 pub init: FMOD_OUTPUT_INIT_CALLBACK,
5810 pub start: FMOD_OUTPUT_START_CALLBACK,
5811 pub stop: FMOD_OUTPUT_STOP_CALLBACK,
5812 pub close: FMOD_OUTPUT_CLOSE_CALLBACK,
5813 pub update: FMOD_OUTPUT_UPDATE_CALLBACK,
5814 pub gethandle: FMOD_OUTPUT_GETHANDLE_CALLBACK,
5815 pub mixer: FMOD_OUTPUT_MIXER_CALLBACK,
5816 pub object3dgetinfo: FMOD_OUTPUT_OBJECT3DGETINFO_CALLBACK,
5817 pub object3dalloc: FMOD_OUTPUT_OBJECT3DALLOC_CALLBACK,
5818 pub object3dfree: FMOD_OUTPUT_OBJECT3DFREE_CALLBACK,
5819 pub object3dupdate: FMOD_OUTPUT_OBJECT3DUPDATE_CALLBACK,
5820 pub openport: FMOD_OUTPUT_OPENPORT_CALLBACK,
5821 pub closeport: FMOD_OUTPUT_CLOSEPORT_CALLBACK,
5822 pub devicelistchanged: FMOD_OUTPUT_DEVICELISTCHANGED_CALLBACK,
5823}
5824#[test]
5825fn bindgen_test_layout_FMOD_OUTPUT_DESCRIPTION() {
5826 const UNINIT: ::std::mem::MaybeUninit<FMOD_OUTPUT_DESCRIPTION> =
5827 ::std::mem::MaybeUninit::uninit();
5828 let ptr = UNINIT.as_ptr();
5829 assert_eq!(
5830 ::std::mem::size_of::<FMOD_OUTPUT_DESCRIPTION>(),
5831 152usize,
5832 concat!("Size of: ", stringify!(FMOD_OUTPUT_DESCRIPTION))
5833 );
5834 assert_eq!(
5835 ::std::mem::align_of::<FMOD_OUTPUT_DESCRIPTION>(),
5836 8usize,
5837 concat!("Alignment of ", stringify!(FMOD_OUTPUT_DESCRIPTION))
5838 );
5839 assert_eq!(
5840 unsafe { ::std::ptr::addr_of!((*ptr).apiversion) as usize - ptr as usize },
5841 0usize,
5842 concat!(
5843 "Offset of field: ",
5844 stringify!(FMOD_OUTPUT_DESCRIPTION),
5845 "::",
5846 stringify!(apiversion)
5847 )
5848 );
5849 assert_eq!(
5850 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
5851 8usize,
5852 concat!(
5853 "Offset of field: ",
5854 stringify!(FMOD_OUTPUT_DESCRIPTION),
5855 "::",
5856 stringify!(name)
5857 )
5858 );
5859 assert_eq!(
5860 unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
5861 16usize,
5862 concat!(
5863 "Offset of field: ",
5864 stringify!(FMOD_OUTPUT_DESCRIPTION),
5865 "::",
5866 stringify!(version)
5867 )
5868 );
5869 assert_eq!(
5870 unsafe { ::std::ptr::addr_of!((*ptr).method) as usize - ptr as usize },
5871 20usize,
5872 concat!(
5873 "Offset of field: ",
5874 stringify!(FMOD_OUTPUT_DESCRIPTION),
5875 "::",
5876 stringify!(method)
5877 )
5878 );
5879 assert_eq!(
5880 unsafe { ::std::ptr::addr_of!((*ptr).getnumdrivers) as usize - ptr as usize },
5881 24usize,
5882 concat!(
5883 "Offset of field: ",
5884 stringify!(FMOD_OUTPUT_DESCRIPTION),
5885 "::",
5886 stringify!(getnumdrivers)
5887 )
5888 );
5889 assert_eq!(
5890 unsafe { ::std::ptr::addr_of!((*ptr).getdriverinfo) as usize - ptr as usize },
5891 32usize,
5892 concat!(
5893 "Offset of field: ",
5894 stringify!(FMOD_OUTPUT_DESCRIPTION),
5895 "::",
5896 stringify!(getdriverinfo)
5897 )
5898 );
5899 assert_eq!(
5900 unsafe { ::std::ptr::addr_of!((*ptr).init) as usize - ptr as usize },
5901 40usize,
5902 concat!(
5903 "Offset of field: ",
5904 stringify!(FMOD_OUTPUT_DESCRIPTION),
5905 "::",
5906 stringify!(init)
5907 )
5908 );
5909 assert_eq!(
5910 unsafe { ::std::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
5911 48usize,
5912 concat!(
5913 "Offset of field: ",
5914 stringify!(FMOD_OUTPUT_DESCRIPTION),
5915 "::",
5916 stringify!(start)
5917 )
5918 );
5919 assert_eq!(
5920 unsafe { ::std::ptr::addr_of!((*ptr).stop) as usize - ptr as usize },
5921 56usize,
5922 concat!(
5923 "Offset of field: ",
5924 stringify!(FMOD_OUTPUT_DESCRIPTION),
5925 "::",
5926 stringify!(stop)
5927 )
5928 );
5929 assert_eq!(
5930 unsafe { ::std::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
5931 64usize,
5932 concat!(
5933 "Offset of field: ",
5934 stringify!(FMOD_OUTPUT_DESCRIPTION),
5935 "::",
5936 stringify!(close)
5937 )
5938 );
5939 assert_eq!(
5940 unsafe { ::std::ptr::addr_of!((*ptr).update) as usize - ptr as usize },
5941 72usize,
5942 concat!(
5943 "Offset of field: ",
5944 stringify!(FMOD_OUTPUT_DESCRIPTION),
5945 "::",
5946 stringify!(update)
5947 )
5948 );
5949 assert_eq!(
5950 unsafe { ::std::ptr::addr_of!((*ptr).gethandle) as usize - ptr as usize },
5951 80usize,
5952 concat!(
5953 "Offset of field: ",
5954 stringify!(FMOD_OUTPUT_DESCRIPTION),
5955 "::",
5956 stringify!(gethandle)
5957 )
5958 );
5959 assert_eq!(
5960 unsafe { ::std::ptr::addr_of!((*ptr).mixer) as usize - ptr as usize },
5961 88usize,
5962 concat!(
5963 "Offset of field: ",
5964 stringify!(FMOD_OUTPUT_DESCRIPTION),
5965 "::",
5966 stringify!(mixer)
5967 )
5968 );
5969 assert_eq!(
5970 unsafe { ::std::ptr::addr_of!((*ptr).object3dgetinfo) as usize - ptr as usize },
5971 96usize,
5972 concat!(
5973 "Offset of field: ",
5974 stringify!(FMOD_OUTPUT_DESCRIPTION),
5975 "::",
5976 stringify!(object3dgetinfo)
5977 )
5978 );
5979 assert_eq!(
5980 unsafe { ::std::ptr::addr_of!((*ptr).object3dalloc) as usize - ptr as usize },
5981 104usize,
5982 concat!(
5983 "Offset of field: ",
5984 stringify!(FMOD_OUTPUT_DESCRIPTION),
5985 "::",
5986 stringify!(object3dalloc)
5987 )
5988 );
5989 assert_eq!(
5990 unsafe { ::std::ptr::addr_of!((*ptr).object3dfree) as usize - ptr as usize },
5991 112usize,
5992 concat!(
5993 "Offset of field: ",
5994 stringify!(FMOD_OUTPUT_DESCRIPTION),
5995 "::",
5996 stringify!(object3dfree)
5997 )
5998 );
5999 assert_eq!(
6000 unsafe { ::std::ptr::addr_of!((*ptr).object3dupdate) as usize - ptr as usize },
6001 120usize,
6002 concat!(
6003 "Offset of field: ",
6004 stringify!(FMOD_OUTPUT_DESCRIPTION),
6005 "::",
6006 stringify!(object3dupdate)
6007 )
6008 );
6009 assert_eq!(
6010 unsafe { ::std::ptr::addr_of!((*ptr).openport) as usize - ptr as usize },
6011 128usize,
6012 concat!(
6013 "Offset of field: ",
6014 stringify!(FMOD_OUTPUT_DESCRIPTION),
6015 "::",
6016 stringify!(openport)
6017 )
6018 );
6019 assert_eq!(
6020 unsafe { ::std::ptr::addr_of!((*ptr).closeport) as usize - ptr as usize },
6021 136usize,
6022 concat!(
6023 "Offset of field: ",
6024 stringify!(FMOD_OUTPUT_DESCRIPTION),
6025 "::",
6026 stringify!(closeport)
6027 )
6028 );
6029 assert_eq!(
6030 unsafe { ::std::ptr::addr_of!((*ptr).devicelistchanged) as usize - ptr as usize },
6031 144usize,
6032 concat!(
6033 "Offset of field: ",
6034 stringify!(FMOD_OUTPUT_DESCRIPTION),
6035 "::",
6036 stringify!(devicelistchanged)
6037 )
6038 );
6039}
6040impl Default for FMOD_OUTPUT_DESCRIPTION {
6041 fn default() -> Self {
6042 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6043 unsafe {
6044 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6045 s.assume_init()
6046 }
6047 }
6048}
6049#[repr(C)]
6050#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
6051pub struct FMOD_OUTPUT_STATE {
6052 pub plugindata: *mut ::std::os::raw::c_void,
6053 pub readfrommixer: FMOD_OUTPUT_READFROMMIXER_FUNC,
6054 pub alloc: FMOD_OUTPUT_ALLOC_FUNC,
6055 pub free: FMOD_OUTPUT_FREE_FUNC,
6056 pub log: FMOD_OUTPUT_LOG_FUNC,
6057 pub copyport: FMOD_OUTPUT_COPYPORT_FUNC,
6058 pub requestreset: FMOD_OUTPUT_REQUESTRESET_FUNC,
6059}
6060#[test]
6061fn bindgen_test_layout_FMOD_OUTPUT_STATE() {
6062 const UNINIT: ::std::mem::MaybeUninit<FMOD_OUTPUT_STATE> = ::std::mem::MaybeUninit::uninit();
6063 let ptr = UNINIT.as_ptr();
6064 assert_eq!(
6065 ::std::mem::size_of::<FMOD_OUTPUT_STATE>(),
6066 56usize,
6067 concat!("Size of: ", stringify!(FMOD_OUTPUT_STATE))
6068 );
6069 assert_eq!(
6070 ::std::mem::align_of::<FMOD_OUTPUT_STATE>(),
6071 8usize,
6072 concat!("Alignment of ", stringify!(FMOD_OUTPUT_STATE))
6073 );
6074 assert_eq!(
6075 unsafe { ::std::ptr::addr_of!((*ptr).plugindata) as usize - ptr as usize },
6076 0usize,
6077 concat!(
6078 "Offset of field: ",
6079 stringify!(FMOD_OUTPUT_STATE),
6080 "::",
6081 stringify!(plugindata)
6082 )
6083 );
6084 assert_eq!(
6085 unsafe { ::std::ptr::addr_of!((*ptr).readfrommixer) as usize - ptr as usize },
6086 8usize,
6087 concat!(
6088 "Offset of field: ",
6089 stringify!(FMOD_OUTPUT_STATE),
6090 "::",
6091 stringify!(readfrommixer)
6092 )
6093 );
6094 assert_eq!(
6095 unsafe { ::std::ptr::addr_of!((*ptr).alloc) as usize - ptr as usize },
6096 16usize,
6097 concat!(
6098 "Offset of field: ",
6099 stringify!(FMOD_OUTPUT_STATE),
6100 "::",
6101 stringify!(alloc)
6102 )
6103 );
6104 assert_eq!(
6105 unsafe { ::std::ptr::addr_of!((*ptr).free) as usize - ptr as usize },
6106 24usize,
6107 concat!(
6108 "Offset of field: ",
6109 stringify!(FMOD_OUTPUT_STATE),
6110 "::",
6111 stringify!(free)
6112 )
6113 );
6114 assert_eq!(
6115 unsafe { ::std::ptr::addr_of!((*ptr).log) as usize - ptr as usize },
6116 32usize,
6117 concat!(
6118 "Offset of field: ",
6119 stringify!(FMOD_OUTPUT_STATE),
6120 "::",
6121 stringify!(log)
6122 )
6123 );
6124 assert_eq!(
6125 unsafe { ::std::ptr::addr_of!((*ptr).copyport) as usize - ptr as usize },
6126 40usize,
6127 concat!(
6128 "Offset of field: ",
6129 stringify!(FMOD_OUTPUT_STATE),
6130 "::",
6131 stringify!(copyport)
6132 )
6133 );
6134 assert_eq!(
6135 unsafe { ::std::ptr::addr_of!((*ptr).requestreset) as usize - ptr as usize },
6136 48usize,
6137 concat!(
6138 "Offset of field: ",
6139 stringify!(FMOD_OUTPUT_STATE),
6140 "::",
6141 stringify!(requestreset)
6142 )
6143 );
6144}
6145impl Default for FMOD_OUTPUT_STATE {
6146 fn default() -> Self {
6147 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6148 unsafe {
6149 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6150 s.assume_init()
6151 }
6152 }
6153}
6154#[repr(C)]
6155#[derive(Debug, Copy, Clone, PartialEq)]
6156pub struct FMOD_OUTPUT_OBJECT3DINFO {
6157 pub buffer: *mut f32,
6158 pub bufferlength: ::std::os::raw::c_uint,
6159 pub position: FMOD_VECTOR,
6160 pub gain: f32,
6161 pub spread: f32,
6162 pub priority: f32,
6163}
6164#[test]
6165fn bindgen_test_layout_FMOD_OUTPUT_OBJECT3DINFO() {
6166 const UNINIT: ::std::mem::MaybeUninit<FMOD_OUTPUT_OBJECT3DINFO> =
6167 ::std::mem::MaybeUninit::uninit();
6168 let ptr = UNINIT.as_ptr();
6169 assert_eq!(
6170 ::std::mem::size_of::<FMOD_OUTPUT_OBJECT3DINFO>(),
6171 40usize,
6172 concat!("Size of: ", stringify!(FMOD_OUTPUT_OBJECT3DINFO))
6173 );
6174 assert_eq!(
6175 ::std::mem::align_of::<FMOD_OUTPUT_OBJECT3DINFO>(),
6176 8usize,
6177 concat!("Alignment of ", stringify!(FMOD_OUTPUT_OBJECT3DINFO))
6178 );
6179 assert_eq!(
6180 unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize },
6181 0usize,
6182 concat!(
6183 "Offset of field: ",
6184 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6185 "::",
6186 stringify!(buffer)
6187 )
6188 );
6189 assert_eq!(
6190 unsafe { ::std::ptr::addr_of!((*ptr).bufferlength) as usize - ptr as usize },
6191 8usize,
6192 concat!(
6193 "Offset of field: ",
6194 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6195 "::",
6196 stringify!(bufferlength)
6197 )
6198 );
6199 assert_eq!(
6200 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
6201 12usize,
6202 concat!(
6203 "Offset of field: ",
6204 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6205 "::",
6206 stringify!(position)
6207 )
6208 );
6209 assert_eq!(
6210 unsafe { ::std::ptr::addr_of!((*ptr).gain) as usize - ptr as usize },
6211 24usize,
6212 concat!(
6213 "Offset of field: ",
6214 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6215 "::",
6216 stringify!(gain)
6217 )
6218 );
6219 assert_eq!(
6220 unsafe { ::std::ptr::addr_of!((*ptr).spread) as usize - ptr as usize },
6221 28usize,
6222 concat!(
6223 "Offset of field: ",
6224 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6225 "::",
6226 stringify!(spread)
6227 )
6228 );
6229 assert_eq!(
6230 unsafe { ::std::ptr::addr_of!((*ptr).priority) as usize - ptr as usize },
6231 32usize,
6232 concat!(
6233 "Offset of field: ",
6234 stringify!(FMOD_OUTPUT_OBJECT3DINFO),
6235 "::",
6236 stringify!(priority)
6237 )
6238 );
6239}
6240impl Default for FMOD_OUTPUT_OBJECT3DINFO {
6241 fn default() -> Self {
6242 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6243 unsafe {
6244 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6245 s.assume_init()
6246 }
6247 }
6248}
6249extern "C" {
6250 #[must_use]
6251 pub fn FMOD_Memory_Initialize(
6252 poolmem: *mut ::std::os::raw::c_void,
6253 poollen: ::std::os::raw::c_int,
6254 useralloc: FMOD_MEMORY_ALLOC_CALLBACK,
6255 userrealloc: FMOD_MEMORY_REALLOC_CALLBACK,
6256 userfree: FMOD_MEMORY_FREE_CALLBACK,
6257 memtypeflags: FMOD_MEMORY_TYPE,
6258 ) -> FMOD_RESULT;
6259}
6260extern "C" {
6261 #[must_use]
6262 pub fn FMOD_Memory_GetStats(
6263 currentalloced: *mut ::std::os::raw::c_int,
6264 maxalloced: *mut ::std::os::raw::c_int,
6265 blocking: FMOD_BOOL,
6266 ) -> FMOD_RESULT;
6267}
6268extern "C" {
6269 #[must_use]
6270 pub fn FMOD_Debug_Initialize(
6271 flags: FMOD_DEBUG_FLAGS,
6272 mode: FMOD_DEBUG_MODE,
6273 callback: FMOD_DEBUG_CALLBACK,
6274 filename: *const ::std::os::raw::c_char,
6275 ) -> FMOD_RESULT;
6276}
6277extern "C" {
6278 #[must_use]
6279 pub fn FMOD_File_SetDiskBusy(busy: ::std::os::raw::c_int) -> FMOD_RESULT;
6280}
6281extern "C" {
6282 #[must_use]
6283 pub fn FMOD_File_GetDiskBusy(busy: *mut ::std::os::raw::c_int) -> FMOD_RESULT;
6284}
6285extern "C" {
6286 #[must_use]
6287 pub fn FMOD_Thread_SetAttributes(
6288 type_: FMOD_THREAD_TYPE,
6289 affinity: FMOD_THREAD_AFFINITY,
6290 priority: FMOD_THREAD_PRIORITY,
6291 stacksize: FMOD_THREAD_STACK_SIZE,
6292 ) -> FMOD_RESULT;
6293}
6294extern "C" {
6295 #[must_use]
6296 pub fn FMOD_System_Create(
6297 system: *mut *mut FMOD_SYSTEM,
6298 headerversion: ::std::os::raw::c_uint,
6299 ) -> FMOD_RESULT;
6300}
6301extern "C" {
6302 #[must_use]
6303 pub fn FMOD_System_Release(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6304}
6305extern "C" {
6306 #[must_use]
6307 pub fn FMOD_System_SetOutput(system: *mut FMOD_SYSTEM, output: FMOD_OUTPUTTYPE) -> FMOD_RESULT;
6308}
6309extern "C" {
6310 #[must_use]
6311 pub fn FMOD_System_GetOutput(
6312 system: *mut FMOD_SYSTEM,
6313 output: *mut FMOD_OUTPUTTYPE,
6314 ) -> FMOD_RESULT;
6315}
6316extern "C" {
6317 #[must_use]
6318 pub fn FMOD_System_GetNumDrivers(
6319 system: *mut FMOD_SYSTEM,
6320 numdrivers: *mut ::std::os::raw::c_int,
6321 ) -> FMOD_RESULT;
6322}
6323extern "C" {
6324 #[must_use]
6325 pub fn FMOD_System_GetDriverInfo(
6326 system: *mut FMOD_SYSTEM,
6327 id: ::std::os::raw::c_int,
6328 name: *mut ::std::os::raw::c_char,
6329 namelen: ::std::os::raw::c_int,
6330 guid: *mut FMOD_GUID,
6331 systemrate: *mut ::std::os::raw::c_int,
6332 speakermode: *mut FMOD_SPEAKERMODE,
6333 speakermodechannels: *mut ::std::os::raw::c_int,
6334 ) -> FMOD_RESULT;
6335}
6336extern "C" {
6337 #[must_use]
6338 pub fn FMOD_System_SetDriver(
6339 system: *mut FMOD_SYSTEM,
6340 driver: ::std::os::raw::c_int,
6341 ) -> FMOD_RESULT;
6342}
6343extern "C" {
6344 #[must_use]
6345 pub fn FMOD_System_GetDriver(
6346 system: *mut FMOD_SYSTEM,
6347 driver: *mut ::std::os::raw::c_int,
6348 ) -> FMOD_RESULT;
6349}
6350extern "C" {
6351 #[must_use]
6352 pub fn FMOD_System_SetSoftwareChannels(
6353 system: *mut FMOD_SYSTEM,
6354 numsoftwarechannels: ::std::os::raw::c_int,
6355 ) -> FMOD_RESULT;
6356}
6357extern "C" {
6358 #[must_use]
6359 pub fn FMOD_System_GetSoftwareChannels(
6360 system: *mut FMOD_SYSTEM,
6361 numsoftwarechannels: *mut ::std::os::raw::c_int,
6362 ) -> FMOD_RESULT;
6363}
6364extern "C" {
6365 #[must_use]
6366 pub fn FMOD_System_SetSoftwareFormat(
6367 system: *mut FMOD_SYSTEM,
6368 samplerate: ::std::os::raw::c_int,
6369 speakermode: FMOD_SPEAKERMODE,
6370 numrawspeakers: ::std::os::raw::c_int,
6371 ) -> FMOD_RESULT;
6372}
6373extern "C" {
6374 #[must_use]
6375 pub fn FMOD_System_GetSoftwareFormat(
6376 system: *mut FMOD_SYSTEM,
6377 samplerate: *mut ::std::os::raw::c_int,
6378 speakermode: *mut FMOD_SPEAKERMODE,
6379 numrawspeakers: *mut ::std::os::raw::c_int,
6380 ) -> FMOD_RESULT;
6381}
6382extern "C" {
6383 #[must_use]
6384 pub fn FMOD_System_SetDSPBufferSize(
6385 system: *mut FMOD_SYSTEM,
6386 bufferlength: ::std::os::raw::c_uint,
6387 numbuffers: ::std::os::raw::c_int,
6388 ) -> FMOD_RESULT;
6389}
6390extern "C" {
6391 #[must_use]
6392 pub fn FMOD_System_GetDSPBufferSize(
6393 system: *mut FMOD_SYSTEM,
6394 bufferlength: *mut ::std::os::raw::c_uint,
6395 numbuffers: *mut ::std::os::raw::c_int,
6396 ) -> FMOD_RESULT;
6397}
6398extern "C" {
6399 #[must_use]
6400 pub fn FMOD_System_SetFileSystem(
6401 system: *mut FMOD_SYSTEM,
6402 useropen: FMOD_FILE_OPEN_CALLBACK,
6403 userclose: FMOD_FILE_CLOSE_CALLBACK,
6404 userread: FMOD_FILE_READ_CALLBACK,
6405 userseek: FMOD_FILE_SEEK_CALLBACK,
6406 userasyncread: FMOD_FILE_ASYNCREAD_CALLBACK,
6407 userasynccancel: FMOD_FILE_ASYNCCANCEL_CALLBACK,
6408 blockalign: ::std::os::raw::c_int,
6409 ) -> FMOD_RESULT;
6410}
6411extern "C" {
6412 #[must_use]
6413 pub fn FMOD_System_AttachFileSystem(
6414 system: *mut FMOD_SYSTEM,
6415 useropen: FMOD_FILE_OPEN_CALLBACK,
6416 userclose: FMOD_FILE_CLOSE_CALLBACK,
6417 userread: FMOD_FILE_READ_CALLBACK,
6418 userseek: FMOD_FILE_SEEK_CALLBACK,
6419 ) -> FMOD_RESULT;
6420}
6421extern "C" {
6422 #[must_use]
6423 pub fn FMOD_System_SetAdvancedSettings(
6424 system: *mut FMOD_SYSTEM,
6425 settings: *mut FMOD_ADVANCEDSETTINGS,
6426 ) -> FMOD_RESULT;
6427}
6428extern "C" {
6429 #[must_use]
6430 pub fn FMOD_System_GetAdvancedSettings(
6431 system: *mut FMOD_SYSTEM,
6432 settings: *mut FMOD_ADVANCEDSETTINGS,
6433 ) -> FMOD_RESULT;
6434}
6435extern "C" {
6436 #[must_use]
6437 pub fn FMOD_System_SetCallback(
6438 system: *mut FMOD_SYSTEM,
6439 callback: FMOD_SYSTEM_CALLBACK,
6440 callbackmask: FMOD_SYSTEM_CALLBACK_TYPE,
6441 ) -> FMOD_RESULT;
6442}
6443extern "C" {
6444 #[must_use]
6445 pub fn FMOD_System_SetPluginPath(
6446 system: *mut FMOD_SYSTEM,
6447 path: *const ::std::os::raw::c_char,
6448 ) -> FMOD_RESULT;
6449}
6450extern "C" {
6451 #[must_use]
6452 pub fn FMOD_System_LoadPlugin(
6453 system: *mut FMOD_SYSTEM,
6454 filename: *const ::std::os::raw::c_char,
6455 handle: *mut ::std::os::raw::c_uint,
6456 priority: ::std::os::raw::c_uint,
6457 ) -> FMOD_RESULT;
6458}
6459extern "C" {
6460 #[must_use]
6461 pub fn FMOD_System_UnloadPlugin(
6462 system: *mut FMOD_SYSTEM,
6463 handle: ::std::os::raw::c_uint,
6464 ) -> FMOD_RESULT;
6465}
6466extern "C" {
6467 #[must_use]
6468 pub fn FMOD_System_GetNumNestedPlugins(
6469 system: *mut FMOD_SYSTEM,
6470 handle: ::std::os::raw::c_uint,
6471 count: *mut ::std::os::raw::c_int,
6472 ) -> FMOD_RESULT;
6473}
6474extern "C" {
6475 #[must_use]
6476 pub fn FMOD_System_GetNestedPlugin(
6477 system: *mut FMOD_SYSTEM,
6478 handle: ::std::os::raw::c_uint,
6479 index: ::std::os::raw::c_int,
6480 nestedhandle: *mut ::std::os::raw::c_uint,
6481 ) -> FMOD_RESULT;
6482}
6483extern "C" {
6484 #[must_use]
6485 pub fn FMOD_System_GetNumPlugins(
6486 system: *mut FMOD_SYSTEM,
6487 plugintype: FMOD_PLUGINTYPE,
6488 numplugins: *mut ::std::os::raw::c_int,
6489 ) -> FMOD_RESULT;
6490}
6491extern "C" {
6492 #[must_use]
6493 pub fn FMOD_System_GetPluginHandle(
6494 system: *mut FMOD_SYSTEM,
6495 plugintype: FMOD_PLUGINTYPE,
6496 index: ::std::os::raw::c_int,
6497 handle: *mut ::std::os::raw::c_uint,
6498 ) -> FMOD_RESULT;
6499}
6500extern "C" {
6501 #[must_use]
6502 pub fn FMOD_System_GetPluginInfo(
6503 system: *mut FMOD_SYSTEM,
6504 handle: ::std::os::raw::c_uint,
6505 plugintype: *mut FMOD_PLUGINTYPE,
6506 name: *mut ::std::os::raw::c_char,
6507 namelen: ::std::os::raw::c_int,
6508 version: *mut ::std::os::raw::c_uint,
6509 ) -> FMOD_RESULT;
6510}
6511extern "C" {
6512 #[must_use]
6513 pub fn FMOD_System_SetOutputByPlugin(
6514 system: *mut FMOD_SYSTEM,
6515 handle: ::std::os::raw::c_uint,
6516 ) -> FMOD_RESULT;
6517}
6518extern "C" {
6519 #[must_use]
6520 pub fn FMOD_System_GetOutputByPlugin(
6521 system: *mut FMOD_SYSTEM,
6522 handle: *mut ::std::os::raw::c_uint,
6523 ) -> FMOD_RESULT;
6524}
6525extern "C" {
6526 #[must_use]
6527 pub fn FMOD_System_CreateDSPByPlugin(
6528 system: *mut FMOD_SYSTEM,
6529 handle: ::std::os::raw::c_uint,
6530 dsp: *mut *mut FMOD_DSP,
6531 ) -> FMOD_RESULT;
6532}
6533extern "C" {
6534 #[must_use]
6535 pub fn FMOD_System_GetDSPInfoByPlugin(
6536 system: *mut FMOD_SYSTEM,
6537 handle: ::std::os::raw::c_uint,
6538 description: *mut *const FMOD_DSP_DESCRIPTION,
6539 ) -> FMOD_RESULT;
6540}
6541extern "C" {
6542 #[must_use]
6543 pub fn FMOD_System_RegisterCodec(
6544 system: *mut FMOD_SYSTEM,
6545 description: *mut FMOD_CODEC_DESCRIPTION,
6546 handle: *mut ::std::os::raw::c_uint,
6547 priority: ::std::os::raw::c_uint,
6548 ) -> FMOD_RESULT;
6549}
6550extern "C" {
6551 #[must_use]
6552 pub fn FMOD_System_RegisterDSP(
6553 system: *mut FMOD_SYSTEM,
6554 description: *const FMOD_DSP_DESCRIPTION,
6555 handle: *mut ::std::os::raw::c_uint,
6556 ) -> FMOD_RESULT;
6557}
6558extern "C" {
6559 #[must_use]
6560 pub fn FMOD_System_RegisterOutput(
6561 system: *mut FMOD_SYSTEM,
6562 description: *const FMOD_OUTPUT_DESCRIPTION,
6563 handle: *mut ::std::os::raw::c_uint,
6564 ) -> FMOD_RESULT;
6565}
6566extern "C" {
6567 #[must_use]
6568 pub fn FMOD_System_Init(
6569 system: *mut FMOD_SYSTEM,
6570 maxchannels: ::std::os::raw::c_int,
6571 flags: FMOD_INITFLAGS,
6572 extradriverdata: *mut ::std::os::raw::c_void,
6573 ) -> FMOD_RESULT;
6574}
6575extern "C" {
6576 #[must_use]
6577 pub fn FMOD_System_Close(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6578}
6579extern "C" {
6580 #[must_use]
6581 pub fn FMOD_System_Update(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6582}
6583extern "C" {
6584 #[must_use]
6585 pub fn FMOD_System_SetSpeakerPosition(
6586 system: *mut FMOD_SYSTEM,
6587 speaker: FMOD_SPEAKER,
6588 x: f32,
6589 y: f32,
6590 active: FMOD_BOOL,
6591 ) -> FMOD_RESULT;
6592}
6593extern "C" {
6594 #[must_use]
6595 pub fn FMOD_System_GetSpeakerPosition(
6596 system: *mut FMOD_SYSTEM,
6597 speaker: FMOD_SPEAKER,
6598 x: *mut f32,
6599 y: *mut f32,
6600 active: *mut FMOD_BOOL,
6601 ) -> FMOD_RESULT;
6602}
6603extern "C" {
6604 #[must_use]
6605 pub fn FMOD_System_SetStreamBufferSize(
6606 system: *mut FMOD_SYSTEM,
6607 filebuffersize: ::std::os::raw::c_uint,
6608 filebuffersizetype: FMOD_TIMEUNIT,
6609 ) -> FMOD_RESULT;
6610}
6611extern "C" {
6612 #[must_use]
6613 pub fn FMOD_System_GetStreamBufferSize(
6614 system: *mut FMOD_SYSTEM,
6615 filebuffersize: *mut ::std::os::raw::c_uint,
6616 filebuffersizetype: *mut FMOD_TIMEUNIT,
6617 ) -> FMOD_RESULT;
6618}
6619extern "C" {
6620 #[must_use]
6621 pub fn FMOD_System_Set3DSettings(
6622 system: *mut FMOD_SYSTEM,
6623 dopplerscale: f32,
6624 distancefactor: f32,
6625 rolloffscale: f32,
6626 ) -> FMOD_RESULT;
6627}
6628extern "C" {
6629 #[must_use]
6630 pub fn FMOD_System_Get3DSettings(
6631 system: *mut FMOD_SYSTEM,
6632 dopplerscale: *mut f32,
6633 distancefactor: *mut f32,
6634 rolloffscale: *mut f32,
6635 ) -> FMOD_RESULT;
6636}
6637extern "C" {
6638 #[must_use]
6639 pub fn FMOD_System_Set3DNumListeners(
6640 system: *mut FMOD_SYSTEM,
6641 numlisteners: ::std::os::raw::c_int,
6642 ) -> FMOD_RESULT;
6643}
6644extern "C" {
6645 #[must_use]
6646 pub fn FMOD_System_Get3DNumListeners(
6647 system: *mut FMOD_SYSTEM,
6648 numlisteners: *mut ::std::os::raw::c_int,
6649 ) -> FMOD_RESULT;
6650}
6651extern "C" {
6652 #[must_use]
6653 pub fn FMOD_System_Set3DListenerAttributes(
6654 system: *mut FMOD_SYSTEM,
6655 listener: ::std::os::raw::c_int,
6656 pos: *const FMOD_VECTOR,
6657 vel: *const FMOD_VECTOR,
6658 forward: *const FMOD_VECTOR,
6659 up: *const FMOD_VECTOR,
6660 ) -> FMOD_RESULT;
6661}
6662extern "C" {
6663 #[must_use]
6664 pub fn FMOD_System_Get3DListenerAttributes(
6665 system: *mut FMOD_SYSTEM,
6666 listener: ::std::os::raw::c_int,
6667 pos: *mut FMOD_VECTOR,
6668 vel: *mut FMOD_VECTOR,
6669 forward: *mut FMOD_VECTOR,
6670 up: *mut FMOD_VECTOR,
6671 ) -> FMOD_RESULT;
6672}
6673extern "C" {
6674 #[must_use]
6675 pub fn FMOD_System_Set3DRolloffCallback(
6676 system: *mut FMOD_SYSTEM,
6677 callback: FMOD_3D_ROLLOFF_CALLBACK,
6678 ) -> FMOD_RESULT;
6679}
6680extern "C" {
6681 #[must_use]
6682 pub fn FMOD_System_MixerSuspend(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6683}
6684extern "C" {
6685 #[must_use]
6686 pub fn FMOD_System_MixerResume(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6687}
6688extern "C" {
6689 #[must_use]
6690 pub fn FMOD_System_GetDefaultMixMatrix(
6691 system: *mut FMOD_SYSTEM,
6692 sourcespeakermode: FMOD_SPEAKERMODE,
6693 targetspeakermode: FMOD_SPEAKERMODE,
6694 matrix: *mut f32,
6695 matrixhop: ::std::os::raw::c_int,
6696 ) -> FMOD_RESULT;
6697}
6698extern "C" {
6699 #[must_use]
6700 pub fn FMOD_System_GetSpeakerModeChannels(
6701 system: *mut FMOD_SYSTEM,
6702 mode: FMOD_SPEAKERMODE,
6703 channels: *mut ::std::os::raw::c_int,
6704 ) -> FMOD_RESULT;
6705}
6706extern "C" {
6707 #[must_use]
6708 pub fn FMOD_System_GetVersion(
6709 system: *mut FMOD_SYSTEM,
6710 version: *mut ::std::os::raw::c_uint,
6711 ) -> FMOD_RESULT;
6712}
6713extern "C" {
6714 #[must_use]
6715 pub fn FMOD_System_GetOutputHandle(
6716 system: *mut FMOD_SYSTEM,
6717 handle: *mut *mut ::std::os::raw::c_void,
6718 ) -> FMOD_RESULT;
6719}
6720extern "C" {
6721 #[must_use]
6722 pub fn FMOD_System_GetChannelsPlaying(
6723 system: *mut FMOD_SYSTEM,
6724 channels: *mut ::std::os::raw::c_int,
6725 realchannels: *mut ::std::os::raw::c_int,
6726 ) -> FMOD_RESULT;
6727}
6728extern "C" {
6729 #[must_use]
6730 pub fn FMOD_System_GetCPUUsage(
6731 system: *mut FMOD_SYSTEM,
6732 usage: *mut FMOD_CPU_USAGE,
6733 ) -> FMOD_RESULT;
6734}
6735extern "C" {
6736 #[must_use]
6737 pub fn FMOD_System_GetFileUsage(
6738 system: *mut FMOD_SYSTEM,
6739 sampleBytesRead: *mut ::std::os::raw::c_longlong,
6740 streamBytesRead: *mut ::std::os::raw::c_longlong,
6741 otherBytesRead: *mut ::std::os::raw::c_longlong,
6742 ) -> FMOD_RESULT;
6743}
6744extern "C" {
6745 #[must_use]
6746 pub fn FMOD_System_CreateSound(
6747 system: *mut FMOD_SYSTEM,
6748 name_or_data: *const ::std::os::raw::c_char,
6749 mode: FMOD_MODE,
6750 exinfo: *mut FMOD_CREATESOUNDEXINFO,
6751 sound: *mut *mut FMOD_SOUND,
6752 ) -> FMOD_RESULT;
6753}
6754extern "C" {
6755 #[must_use]
6756 pub fn FMOD_System_CreateStream(
6757 system: *mut FMOD_SYSTEM,
6758 name_or_data: *const ::std::os::raw::c_char,
6759 mode: FMOD_MODE,
6760 exinfo: *mut FMOD_CREATESOUNDEXINFO,
6761 sound: *mut *mut FMOD_SOUND,
6762 ) -> FMOD_RESULT;
6763}
6764extern "C" {
6765 #[must_use]
6766 pub fn FMOD_System_CreateDSP(
6767 system: *mut FMOD_SYSTEM,
6768 description: *const FMOD_DSP_DESCRIPTION,
6769 dsp: *mut *mut FMOD_DSP,
6770 ) -> FMOD_RESULT;
6771}
6772extern "C" {
6773 #[must_use]
6774 pub fn FMOD_System_CreateDSPByType(
6775 system: *mut FMOD_SYSTEM,
6776 type_: FMOD_DSP_TYPE,
6777 dsp: *mut *mut FMOD_DSP,
6778 ) -> FMOD_RESULT;
6779}
6780extern "C" {
6781 #[must_use]
6782 pub fn FMOD_System_CreateChannelGroup(
6783 system: *mut FMOD_SYSTEM,
6784 name: *const ::std::os::raw::c_char,
6785 channelgroup: *mut *mut FMOD_CHANNELGROUP,
6786 ) -> FMOD_RESULT;
6787}
6788extern "C" {
6789 #[must_use]
6790 pub fn FMOD_System_CreateSoundGroup(
6791 system: *mut FMOD_SYSTEM,
6792 name: *const ::std::os::raw::c_char,
6793 soundgroup: *mut *mut FMOD_SOUNDGROUP,
6794 ) -> FMOD_RESULT;
6795}
6796extern "C" {
6797 #[must_use]
6798 pub fn FMOD_System_CreateReverb3D(
6799 system: *mut FMOD_SYSTEM,
6800 reverb: *mut *mut FMOD_REVERB3D,
6801 ) -> FMOD_RESULT;
6802}
6803extern "C" {
6804 #[must_use]
6805 pub fn FMOD_System_PlaySound(
6806 system: *mut FMOD_SYSTEM,
6807 sound: *mut FMOD_SOUND,
6808 channelgroup: *mut FMOD_CHANNELGROUP,
6809 paused: FMOD_BOOL,
6810 channel: *mut *mut FMOD_CHANNEL,
6811 ) -> FMOD_RESULT;
6812}
6813extern "C" {
6814 #[must_use]
6815 pub fn FMOD_System_PlayDSP(
6816 system: *mut FMOD_SYSTEM,
6817 dsp: *mut FMOD_DSP,
6818 channelgroup: *mut FMOD_CHANNELGROUP,
6819 paused: FMOD_BOOL,
6820 channel: *mut *mut FMOD_CHANNEL,
6821 ) -> FMOD_RESULT;
6822}
6823extern "C" {
6824 #[must_use]
6825 pub fn FMOD_System_GetChannel(
6826 system: *mut FMOD_SYSTEM,
6827 channelid: ::std::os::raw::c_int,
6828 channel: *mut *mut FMOD_CHANNEL,
6829 ) -> FMOD_RESULT;
6830}
6831extern "C" {
6832 #[must_use]
6833 pub fn FMOD_System_GetDSPInfoByType(
6834 system: *mut FMOD_SYSTEM,
6835 type_: FMOD_DSP_TYPE,
6836 description: *mut *const FMOD_DSP_DESCRIPTION,
6837 ) -> FMOD_RESULT;
6838}
6839extern "C" {
6840 #[must_use]
6841 pub fn FMOD_System_GetMasterChannelGroup(
6842 system: *mut FMOD_SYSTEM,
6843 channelgroup: *mut *mut FMOD_CHANNELGROUP,
6844 ) -> FMOD_RESULT;
6845}
6846extern "C" {
6847 #[must_use]
6848 pub fn FMOD_System_GetMasterSoundGroup(
6849 system: *mut FMOD_SYSTEM,
6850 soundgroup: *mut *mut FMOD_SOUNDGROUP,
6851 ) -> FMOD_RESULT;
6852}
6853extern "C" {
6854 #[must_use]
6855 pub fn FMOD_System_AttachChannelGroupToPort(
6856 system: *mut FMOD_SYSTEM,
6857 portType: FMOD_PORT_TYPE,
6858 portIndex: FMOD_PORT_INDEX,
6859 channelgroup: *mut FMOD_CHANNELGROUP,
6860 passThru: FMOD_BOOL,
6861 ) -> FMOD_RESULT;
6862}
6863extern "C" {
6864 #[must_use]
6865 pub fn FMOD_System_DetachChannelGroupFromPort(
6866 system: *mut FMOD_SYSTEM,
6867 channelgroup: *mut FMOD_CHANNELGROUP,
6868 ) -> FMOD_RESULT;
6869}
6870extern "C" {
6871 #[must_use]
6872 pub fn FMOD_System_SetReverbProperties(
6873 system: *mut FMOD_SYSTEM,
6874 instance: ::std::os::raw::c_int,
6875 prop: *const FMOD_REVERB_PROPERTIES,
6876 ) -> FMOD_RESULT;
6877}
6878extern "C" {
6879 #[must_use]
6880 pub fn FMOD_System_GetReverbProperties(
6881 system: *mut FMOD_SYSTEM,
6882 instance: ::std::os::raw::c_int,
6883 prop: *mut FMOD_REVERB_PROPERTIES,
6884 ) -> FMOD_RESULT;
6885}
6886extern "C" {
6887 #[must_use]
6888 pub fn FMOD_System_LockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6889}
6890extern "C" {
6891 #[must_use]
6892 pub fn FMOD_System_UnlockDSP(system: *mut FMOD_SYSTEM) -> FMOD_RESULT;
6893}
6894extern "C" {
6895 #[must_use]
6896 pub fn FMOD_System_GetRecordNumDrivers(
6897 system: *mut FMOD_SYSTEM,
6898 numdrivers: *mut ::std::os::raw::c_int,
6899 numconnected: *mut ::std::os::raw::c_int,
6900 ) -> FMOD_RESULT;
6901}
6902extern "C" {
6903 #[must_use]
6904 pub fn FMOD_System_GetRecordDriverInfo(
6905 system: *mut FMOD_SYSTEM,
6906 id: ::std::os::raw::c_int,
6907 name: *mut ::std::os::raw::c_char,
6908 namelen: ::std::os::raw::c_int,
6909 guid: *mut FMOD_GUID,
6910 systemrate: *mut ::std::os::raw::c_int,
6911 speakermode: *mut FMOD_SPEAKERMODE,
6912 speakermodechannels: *mut ::std::os::raw::c_int,
6913 state: *mut FMOD_DRIVER_STATE,
6914 ) -> FMOD_RESULT;
6915}
6916extern "C" {
6917 #[must_use]
6918 pub fn FMOD_System_GetRecordPosition(
6919 system: *mut FMOD_SYSTEM,
6920 id: ::std::os::raw::c_int,
6921 position: *mut ::std::os::raw::c_uint,
6922 ) -> FMOD_RESULT;
6923}
6924extern "C" {
6925 #[must_use]
6926 pub fn FMOD_System_RecordStart(
6927 system: *mut FMOD_SYSTEM,
6928 id: ::std::os::raw::c_int,
6929 sound: *mut FMOD_SOUND,
6930 loop_: FMOD_BOOL,
6931 ) -> FMOD_RESULT;
6932}
6933extern "C" {
6934 #[must_use]
6935 pub fn FMOD_System_RecordStop(
6936 system: *mut FMOD_SYSTEM,
6937 id: ::std::os::raw::c_int,
6938 ) -> FMOD_RESULT;
6939}
6940extern "C" {
6941 #[must_use]
6942 pub fn FMOD_System_IsRecording(
6943 system: *mut FMOD_SYSTEM,
6944 id: ::std::os::raw::c_int,
6945 recording: *mut FMOD_BOOL,
6946 ) -> FMOD_RESULT;
6947}
6948extern "C" {
6949 #[must_use]
6950 pub fn FMOD_System_CreateGeometry(
6951 system: *mut FMOD_SYSTEM,
6952 maxpolygons: ::std::os::raw::c_int,
6953 maxvertices: ::std::os::raw::c_int,
6954 geometry: *mut *mut FMOD_GEOMETRY,
6955 ) -> FMOD_RESULT;
6956}
6957extern "C" {
6958 #[must_use]
6959 pub fn FMOD_System_SetGeometrySettings(
6960 system: *mut FMOD_SYSTEM,
6961 maxworldsize: f32,
6962 ) -> FMOD_RESULT;
6963}
6964extern "C" {
6965 #[must_use]
6966 pub fn FMOD_System_GetGeometrySettings(
6967 system: *mut FMOD_SYSTEM,
6968 maxworldsize: *mut f32,
6969 ) -> FMOD_RESULT;
6970}
6971extern "C" {
6972 #[must_use]
6973 pub fn FMOD_System_LoadGeometry(
6974 system: *mut FMOD_SYSTEM,
6975 data: *const ::std::os::raw::c_void,
6976 datasize: ::std::os::raw::c_int,
6977 geometry: *mut *mut FMOD_GEOMETRY,
6978 ) -> FMOD_RESULT;
6979}
6980extern "C" {
6981 #[must_use]
6982 pub fn FMOD_System_GetGeometryOcclusion(
6983 system: *mut FMOD_SYSTEM,
6984 listener: *const FMOD_VECTOR,
6985 source: *const FMOD_VECTOR,
6986 direct: *mut f32,
6987 reverb: *mut f32,
6988 ) -> FMOD_RESULT;
6989}
6990extern "C" {
6991 #[must_use]
6992 pub fn FMOD_System_SetNetworkProxy(
6993 system: *mut FMOD_SYSTEM,
6994 proxy: *const ::std::os::raw::c_char,
6995 ) -> FMOD_RESULT;
6996}
6997extern "C" {
6998 #[must_use]
6999 pub fn FMOD_System_GetNetworkProxy(
7000 system: *mut FMOD_SYSTEM,
7001 proxy: *mut ::std::os::raw::c_char,
7002 proxylen: ::std::os::raw::c_int,
7003 ) -> FMOD_RESULT;
7004}
7005extern "C" {
7006 #[must_use]
7007 pub fn FMOD_System_SetNetworkTimeout(
7008 system: *mut FMOD_SYSTEM,
7009 timeout: ::std::os::raw::c_int,
7010 ) -> FMOD_RESULT;
7011}
7012extern "C" {
7013 #[must_use]
7014 pub fn FMOD_System_GetNetworkTimeout(
7015 system: *mut FMOD_SYSTEM,
7016 timeout: *mut ::std::os::raw::c_int,
7017 ) -> FMOD_RESULT;
7018}
7019extern "C" {
7020 #[must_use]
7021 pub fn FMOD_System_SetUserData(
7022 system: *mut FMOD_SYSTEM,
7023 userdata: *mut ::std::os::raw::c_void,
7024 ) -> FMOD_RESULT;
7025}
7026extern "C" {
7027 #[must_use]
7028 pub fn FMOD_System_GetUserData(
7029 system: *mut FMOD_SYSTEM,
7030 userdata: *mut *mut ::std::os::raw::c_void,
7031 ) -> FMOD_RESULT;
7032}
7033extern "C" {
7034 #[must_use]
7035 pub fn FMOD_Sound_Release(sound: *mut FMOD_SOUND) -> FMOD_RESULT;
7036}
7037extern "C" {
7038 #[must_use]
7039 pub fn FMOD_Sound_GetSystemObject(
7040 sound: *mut FMOD_SOUND,
7041 system: *mut *mut FMOD_SYSTEM,
7042 ) -> FMOD_RESULT;
7043}
7044extern "C" {
7045 #[must_use]
7046 pub fn FMOD_Sound_Lock(
7047 sound: *mut FMOD_SOUND,
7048 offset: ::std::os::raw::c_uint,
7049 length: ::std::os::raw::c_uint,
7050 ptr1: *mut *mut ::std::os::raw::c_void,
7051 ptr2: *mut *mut ::std::os::raw::c_void,
7052 len1: *mut ::std::os::raw::c_uint,
7053 len2: *mut ::std::os::raw::c_uint,
7054 ) -> FMOD_RESULT;
7055}
7056extern "C" {
7057 #[must_use]
7058 pub fn FMOD_Sound_Unlock(
7059 sound: *mut FMOD_SOUND,
7060 ptr1: *mut ::std::os::raw::c_void,
7061 ptr2: *mut ::std::os::raw::c_void,
7062 len1: ::std::os::raw::c_uint,
7063 len2: ::std::os::raw::c_uint,
7064 ) -> FMOD_RESULT;
7065}
7066extern "C" {
7067 #[must_use]
7068 pub fn FMOD_Sound_SetDefaults(
7069 sound: *mut FMOD_SOUND,
7070 frequency: f32,
7071 priority: ::std::os::raw::c_int,
7072 ) -> FMOD_RESULT;
7073}
7074extern "C" {
7075 #[must_use]
7076 pub fn FMOD_Sound_GetDefaults(
7077 sound: *mut FMOD_SOUND,
7078 frequency: *mut f32,
7079 priority: *mut ::std::os::raw::c_int,
7080 ) -> FMOD_RESULT;
7081}
7082extern "C" {
7083 #[must_use]
7084 pub fn FMOD_Sound_Set3DMinMaxDistance(
7085 sound: *mut FMOD_SOUND,
7086 min: f32,
7087 max: f32,
7088 ) -> FMOD_RESULT;
7089}
7090extern "C" {
7091 #[must_use]
7092 pub fn FMOD_Sound_Get3DMinMaxDistance(
7093 sound: *mut FMOD_SOUND,
7094 min: *mut f32,
7095 max: *mut f32,
7096 ) -> FMOD_RESULT;
7097}
7098extern "C" {
7099 #[must_use]
7100 pub fn FMOD_Sound_Set3DConeSettings(
7101 sound: *mut FMOD_SOUND,
7102 insideconeangle: f32,
7103 outsideconeangle: f32,
7104 outsidevolume: f32,
7105 ) -> FMOD_RESULT;
7106}
7107extern "C" {
7108 #[must_use]
7109 pub fn FMOD_Sound_Get3DConeSettings(
7110 sound: *mut FMOD_SOUND,
7111 insideconeangle: *mut f32,
7112 outsideconeangle: *mut f32,
7113 outsidevolume: *mut f32,
7114 ) -> FMOD_RESULT;
7115}
7116extern "C" {
7117 #[must_use]
7118 pub fn FMOD_Sound_Set3DCustomRolloff(
7119 sound: *mut FMOD_SOUND,
7120 points: *mut FMOD_VECTOR,
7121 numpoints: ::std::os::raw::c_int,
7122 ) -> FMOD_RESULT;
7123}
7124extern "C" {
7125 #[must_use]
7126 pub fn FMOD_Sound_Get3DCustomRolloff(
7127 sound: *mut FMOD_SOUND,
7128 points: *mut *mut FMOD_VECTOR,
7129 numpoints: *mut ::std::os::raw::c_int,
7130 ) -> FMOD_RESULT;
7131}
7132extern "C" {
7133 #[must_use]
7134 pub fn FMOD_Sound_GetSubSound(
7135 sound: *mut FMOD_SOUND,
7136 index: ::std::os::raw::c_int,
7137 subsound: *mut *mut FMOD_SOUND,
7138 ) -> FMOD_RESULT;
7139}
7140extern "C" {
7141 #[must_use]
7142 pub fn FMOD_Sound_GetSubSoundParent(
7143 sound: *mut FMOD_SOUND,
7144 parentsound: *mut *mut FMOD_SOUND,
7145 ) -> FMOD_RESULT;
7146}
7147extern "C" {
7148 #[must_use]
7149 pub fn FMOD_Sound_GetName(
7150 sound: *mut FMOD_SOUND,
7151 name: *mut ::std::os::raw::c_char,
7152 namelen: ::std::os::raw::c_int,
7153 ) -> FMOD_RESULT;
7154}
7155extern "C" {
7156 #[must_use]
7157 pub fn FMOD_Sound_GetLength(
7158 sound: *mut FMOD_SOUND,
7159 length: *mut ::std::os::raw::c_uint,
7160 lengthtype: FMOD_TIMEUNIT,
7161 ) -> FMOD_RESULT;
7162}
7163extern "C" {
7164 #[must_use]
7165 pub fn FMOD_Sound_GetFormat(
7166 sound: *mut FMOD_SOUND,
7167 type_: *mut FMOD_SOUND_TYPE,
7168 format: *mut FMOD_SOUND_FORMAT,
7169 channels: *mut ::std::os::raw::c_int,
7170 bits: *mut ::std::os::raw::c_int,
7171 ) -> FMOD_RESULT;
7172}
7173extern "C" {
7174 #[must_use]
7175 pub fn FMOD_Sound_GetNumSubSounds(
7176 sound: *mut FMOD_SOUND,
7177 numsubsounds: *mut ::std::os::raw::c_int,
7178 ) -> FMOD_RESULT;
7179}
7180extern "C" {
7181 #[must_use]
7182 pub fn FMOD_Sound_GetNumTags(
7183 sound: *mut FMOD_SOUND,
7184 numtags: *mut ::std::os::raw::c_int,
7185 numtagsupdated: *mut ::std::os::raw::c_int,
7186 ) -> FMOD_RESULT;
7187}
7188extern "C" {
7189 #[must_use]
7190 pub fn FMOD_Sound_GetTag(
7191 sound: *mut FMOD_SOUND,
7192 name: *const ::std::os::raw::c_char,
7193 index: ::std::os::raw::c_int,
7194 tag: *mut FMOD_TAG,
7195 ) -> FMOD_RESULT;
7196}
7197extern "C" {
7198 #[must_use]
7199 pub fn FMOD_Sound_GetOpenState(
7200 sound: *mut FMOD_SOUND,
7201 openstate: *mut FMOD_OPENSTATE,
7202 percentbuffered: *mut ::std::os::raw::c_uint,
7203 starving: *mut FMOD_BOOL,
7204 diskbusy: *mut FMOD_BOOL,
7205 ) -> FMOD_RESULT;
7206}
7207extern "C" {
7208 #[must_use]
7209 pub fn FMOD_Sound_ReadData(
7210 sound: *mut FMOD_SOUND,
7211 buffer: *mut ::std::os::raw::c_void,
7212 length: ::std::os::raw::c_uint,
7213 read: *mut ::std::os::raw::c_uint,
7214 ) -> FMOD_RESULT;
7215}
7216extern "C" {
7217 #[must_use]
7218 pub fn FMOD_Sound_SeekData(sound: *mut FMOD_SOUND, pcm: ::std::os::raw::c_uint) -> FMOD_RESULT;
7219}
7220extern "C" {
7221 #[must_use]
7222 pub fn FMOD_Sound_SetSoundGroup(
7223 sound: *mut FMOD_SOUND,
7224 soundgroup: *mut FMOD_SOUNDGROUP,
7225 ) -> FMOD_RESULT;
7226}
7227extern "C" {
7228 #[must_use]
7229 pub fn FMOD_Sound_GetSoundGroup(
7230 sound: *mut FMOD_SOUND,
7231 soundgroup: *mut *mut FMOD_SOUNDGROUP,
7232 ) -> FMOD_RESULT;
7233}
7234extern "C" {
7235 #[must_use]
7236 pub fn FMOD_Sound_GetNumSyncPoints(
7237 sound: *mut FMOD_SOUND,
7238 numsyncpoints: *mut ::std::os::raw::c_int,
7239 ) -> FMOD_RESULT;
7240}
7241extern "C" {
7242 #[must_use]
7243 pub fn FMOD_Sound_GetSyncPoint(
7244 sound: *mut FMOD_SOUND,
7245 index: ::std::os::raw::c_int,
7246 point: *mut *mut FMOD_SYNCPOINT,
7247 ) -> FMOD_RESULT;
7248}
7249extern "C" {
7250 #[must_use]
7251 pub fn FMOD_Sound_GetSyncPointInfo(
7252 sound: *mut FMOD_SOUND,
7253 point: *mut FMOD_SYNCPOINT,
7254 name: *mut ::std::os::raw::c_char,
7255 namelen: ::std::os::raw::c_int,
7256 offset: *mut ::std::os::raw::c_uint,
7257 offsettype: FMOD_TIMEUNIT,
7258 ) -> FMOD_RESULT;
7259}
7260extern "C" {
7261 #[must_use]
7262 pub fn FMOD_Sound_AddSyncPoint(
7263 sound: *mut FMOD_SOUND,
7264 offset: ::std::os::raw::c_uint,
7265 offsettype: FMOD_TIMEUNIT,
7266 name: *const ::std::os::raw::c_char,
7267 point: *mut *mut FMOD_SYNCPOINT,
7268 ) -> FMOD_RESULT;
7269}
7270extern "C" {
7271 #[must_use]
7272 pub fn FMOD_Sound_DeleteSyncPoint(
7273 sound: *mut FMOD_SOUND,
7274 point: *mut FMOD_SYNCPOINT,
7275 ) -> FMOD_RESULT;
7276}
7277extern "C" {
7278 #[must_use]
7279 pub fn FMOD_Sound_SetMode(sound: *mut FMOD_SOUND, mode: FMOD_MODE) -> FMOD_RESULT;
7280}
7281extern "C" {
7282 #[must_use]
7283 pub fn FMOD_Sound_GetMode(sound: *mut FMOD_SOUND, mode: *mut FMOD_MODE) -> FMOD_RESULT;
7284}
7285extern "C" {
7286 #[must_use]
7287 pub fn FMOD_Sound_SetLoopCount(
7288 sound: *mut FMOD_SOUND,
7289 loopcount: ::std::os::raw::c_int,
7290 ) -> FMOD_RESULT;
7291}
7292extern "C" {
7293 #[must_use]
7294 pub fn FMOD_Sound_GetLoopCount(
7295 sound: *mut FMOD_SOUND,
7296 loopcount: *mut ::std::os::raw::c_int,
7297 ) -> FMOD_RESULT;
7298}
7299extern "C" {
7300 #[must_use]
7301 pub fn FMOD_Sound_SetLoopPoints(
7302 sound: *mut FMOD_SOUND,
7303 loopstart: ::std::os::raw::c_uint,
7304 loopstarttype: FMOD_TIMEUNIT,
7305 loopend: ::std::os::raw::c_uint,
7306 loopendtype: FMOD_TIMEUNIT,
7307 ) -> FMOD_RESULT;
7308}
7309extern "C" {
7310 #[must_use]
7311 pub fn FMOD_Sound_GetLoopPoints(
7312 sound: *mut FMOD_SOUND,
7313 loopstart: *mut ::std::os::raw::c_uint,
7314 loopstarttype: FMOD_TIMEUNIT,
7315 loopend: *mut ::std::os::raw::c_uint,
7316 loopendtype: FMOD_TIMEUNIT,
7317 ) -> FMOD_RESULT;
7318}
7319extern "C" {
7320 #[must_use]
7321 pub fn FMOD_Sound_GetMusicNumChannels(
7322 sound: *mut FMOD_SOUND,
7323 numchannels: *mut ::std::os::raw::c_int,
7324 ) -> FMOD_RESULT;
7325}
7326extern "C" {
7327 #[must_use]
7328 pub fn FMOD_Sound_SetMusicChannelVolume(
7329 sound: *mut FMOD_SOUND,
7330 channel: ::std::os::raw::c_int,
7331 volume: f32,
7332 ) -> FMOD_RESULT;
7333}
7334extern "C" {
7335 #[must_use]
7336 pub fn FMOD_Sound_GetMusicChannelVolume(
7337 sound: *mut FMOD_SOUND,
7338 channel: ::std::os::raw::c_int,
7339 volume: *mut f32,
7340 ) -> FMOD_RESULT;
7341}
7342extern "C" {
7343 #[must_use]
7344 pub fn FMOD_Sound_SetMusicSpeed(sound: *mut FMOD_SOUND, speed: f32) -> FMOD_RESULT;
7345}
7346extern "C" {
7347 #[must_use]
7348 pub fn FMOD_Sound_GetMusicSpeed(sound: *mut FMOD_SOUND, speed: *mut f32) -> FMOD_RESULT;
7349}
7350extern "C" {
7351 #[must_use]
7352 pub fn FMOD_Sound_SetUserData(
7353 sound: *mut FMOD_SOUND,
7354 userdata: *mut ::std::os::raw::c_void,
7355 ) -> FMOD_RESULT;
7356}
7357extern "C" {
7358 #[must_use]
7359 pub fn FMOD_Sound_GetUserData(
7360 sound: *mut FMOD_SOUND,
7361 userdata: *mut *mut ::std::os::raw::c_void,
7362 ) -> FMOD_RESULT;
7363}
7364extern "C" {
7365 #[must_use]
7366 pub fn FMOD_Channel_GetSystemObject(
7367 channel: *mut FMOD_CHANNEL,
7368 system: *mut *mut FMOD_SYSTEM,
7369 ) -> FMOD_RESULT;
7370}
7371extern "C" {
7372 #[must_use]
7373 pub fn FMOD_Channel_Stop(channel: *mut FMOD_CHANNEL) -> FMOD_RESULT;
7374}
7375extern "C" {
7376 #[must_use]
7377 pub fn FMOD_Channel_SetPaused(channel: *mut FMOD_CHANNEL, paused: FMOD_BOOL) -> FMOD_RESULT;
7378}
7379extern "C" {
7380 #[must_use]
7381 pub fn FMOD_Channel_GetPaused(
7382 channel: *mut FMOD_CHANNEL,
7383 paused: *mut FMOD_BOOL,
7384 ) -> FMOD_RESULT;
7385}
7386extern "C" {
7387 #[must_use]
7388 pub fn FMOD_Channel_SetVolume(channel: *mut FMOD_CHANNEL, volume: f32) -> FMOD_RESULT;
7389}
7390extern "C" {
7391 #[must_use]
7392 pub fn FMOD_Channel_GetVolume(channel: *mut FMOD_CHANNEL, volume: *mut f32) -> FMOD_RESULT;
7393}
7394extern "C" {
7395 #[must_use]
7396 pub fn FMOD_Channel_SetVolumeRamp(channel: *mut FMOD_CHANNEL, ramp: FMOD_BOOL) -> FMOD_RESULT;
7397}
7398extern "C" {
7399 #[must_use]
7400 pub fn FMOD_Channel_GetVolumeRamp(
7401 channel: *mut FMOD_CHANNEL,
7402 ramp: *mut FMOD_BOOL,
7403 ) -> FMOD_RESULT;
7404}
7405extern "C" {
7406 #[must_use]
7407 pub fn FMOD_Channel_GetAudibility(
7408 channel: *mut FMOD_CHANNEL,
7409 audibility: *mut f32,
7410 ) -> FMOD_RESULT;
7411}
7412extern "C" {
7413 #[must_use]
7414 pub fn FMOD_Channel_SetPitch(channel: *mut FMOD_CHANNEL, pitch: f32) -> FMOD_RESULT;
7415}
7416extern "C" {
7417 #[must_use]
7418 pub fn FMOD_Channel_GetPitch(channel: *mut FMOD_CHANNEL, pitch: *mut f32) -> FMOD_RESULT;
7419}
7420extern "C" {
7421 #[must_use]
7422 pub fn FMOD_Channel_SetMute(channel: *mut FMOD_CHANNEL, mute: FMOD_BOOL) -> FMOD_RESULT;
7423}
7424extern "C" {
7425 #[must_use]
7426 pub fn FMOD_Channel_GetMute(channel: *mut FMOD_CHANNEL, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
7427}
7428extern "C" {
7429 #[must_use]
7430 pub fn FMOD_Channel_SetReverbProperties(
7431 channel: *mut FMOD_CHANNEL,
7432 instance: ::std::os::raw::c_int,
7433 wet: f32,
7434 ) -> FMOD_RESULT;
7435}
7436extern "C" {
7437 #[must_use]
7438 pub fn FMOD_Channel_GetReverbProperties(
7439 channel: *mut FMOD_CHANNEL,
7440 instance: ::std::os::raw::c_int,
7441 wet: *mut f32,
7442 ) -> FMOD_RESULT;
7443}
7444extern "C" {
7445 #[must_use]
7446 pub fn FMOD_Channel_SetLowPassGain(channel: *mut FMOD_CHANNEL, gain: f32) -> FMOD_RESULT;
7447}
7448extern "C" {
7449 #[must_use]
7450 pub fn FMOD_Channel_GetLowPassGain(channel: *mut FMOD_CHANNEL, gain: *mut f32) -> FMOD_RESULT;
7451}
7452extern "C" {
7453 #[must_use]
7454 pub fn FMOD_Channel_SetMode(channel: *mut FMOD_CHANNEL, mode: FMOD_MODE) -> FMOD_RESULT;
7455}
7456extern "C" {
7457 #[must_use]
7458 pub fn FMOD_Channel_GetMode(channel: *mut FMOD_CHANNEL, mode: *mut FMOD_MODE) -> FMOD_RESULT;
7459}
7460extern "C" {
7461 #[must_use]
7462 pub fn FMOD_Channel_SetCallback(
7463 channel: *mut FMOD_CHANNEL,
7464 callback: FMOD_CHANNELCONTROL_CALLBACK,
7465 ) -> FMOD_RESULT;
7466}
7467extern "C" {
7468 #[must_use]
7469 pub fn FMOD_Channel_IsPlaying(
7470 channel: *mut FMOD_CHANNEL,
7471 isplaying: *mut FMOD_BOOL,
7472 ) -> FMOD_RESULT;
7473}
7474extern "C" {
7475 #[must_use]
7476 pub fn FMOD_Channel_SetPan(channel: *mut FMOD_CHANNEL, pan: f32) -> FMOD_RESULT;
7477}
7478extern "C" {
7479 #[must_use]
7480 pub fn FMOD_Channel_SetMixLevelsOutput(
7481 channel: *mut FMOD_CHANNEL,
7482 frontleft: f32,
7483 frontright: f32,
7484 center: f32,
7485 lfe: f32,
7486 surroundleft: f32,
7487 surroundright: f32,
7488 backleft: f32,
7489 backright: f32,
7490 ) -> FMOD_RESULT;
7491}
7492extern "C" {
7493 #[must_use]
7494 pub fn FMOD_Channel_SetMixLevelsInput(
7495 channel: *mut FMOD_CHANNEL,
7496 levels: *mut f32,
7497 numlevels: ::std::os::raw::c_int,
7498 ) -> FMOD_RESULT;
7499}
7500extern "C" {
7501 #[must_use]
7502 pub fn FMOD_Channel_SetMixMatrix(
7503 channel: *mut FMOD_CHANNEL,
7504 matrix: *mut f32,
7505 outchannels: ::std::os::raw::c_int,
7506 inchannels: ::std::os::raw::c_int,
7507 inchannel_hop: ::std::os::raw::c_int,
7508 ) -> FMOD_RESULT;
7509}
7510extern "C" {
7511 #[must_use]
7512 pub fn FMOD_Channel_GetMixMatrix(
7513 channel: *mut FMOD_CHANNEL,
7514 matrix: *mut f32,
7515 outchannels: *mut ::std::os::raw::c_int,
7516 inchannels: *mut ::std::os::raw::c_int,
7517 inchannel_hop: ::std::os::raw::c_int,
7518 ) -> FMOD_RESULT;
7519}
7520extern "C" {
7521 #[must_use]
7522 pub fn FMOD_Channel_GetDSPClock(
7523 channel: *mut FMOD_CHANNEL,
7524 dspclock: *mut ::std::os::raw::c_ulonglong,
7525 parentclock: *mut ::std::os::raw::c_ulonglong,
7526 ) -> FMOD_RESULT;
7527}
7528extern "C" {
7529 #[must_use]
7530 pub fn FMOD_Channel_SetDelay(
7531 channel: *mut FMOD_CHANNEL,
7532 dspclock_start: ::std::os::raw::c_ulonglong,
7533 dspclock_end: ::std::os::raw::c_ulonglong,
7534 stopchannels: FMOD_BOOL,
7535 ) -> FMOD_RESULT;
7536}
7537extern "C" {
7538 #[must_use]
7539 pub fn FMOD_Channel_GetDelay(
7540 channel: *mut FMOD_CHANNEL,
7541 dspclock_start: *mut ::std::os::raw::c_ulonglong,
7542 dspclock_end: *mut ::std::os::raw::c_ulonglong,
7543 stopchannels: *mut FMOD_BOOL,
7544 ) -> FMOD_RESULT;
7545}
7546extern "C" {
7547 #[must_use]
7548 pub fn FMOD_Channel_AddFadePoint(
7549 channel: *mut FMOD_CHANNEL,
7550 dspclock: ::std::os::raw::c_ulonglong,
7551 volume: f32,
7552 ) -> FMOD_RESULT;
7553}
7554extern "C" {
7555 #[must_use]
7556 pub fn FMOD_Channel_SetFadePointRamp(
7557 channel: *mut FMOD_CHANNEL,
7558 dspclock: ::std::os::raw::c_ulonglong,
7559 volume: f32,
7560 ) -> FMOD_RESULT;
7561}
7562extern "C" {
7563 #[must_use]
7564 pub fn FMOD_Channel_RemoveFadePoints(
7565 channel: *mut FMOD_CHANNEL,
7566 dspclock_start: ::std::os::raw::c_ulonglong,
7567 dspclock_end: ::std::os::raw::c_ulonglong,
7568 ) -> FMOD_RESULT;
7569}
7570extern "C" {
7571 #[must_use]
7572 pub fn FMOD_Channel_GetFadePoints(
7573 channel: *mut FMOD_CHANNEL,
7574 numpoints: *mut ::std::os::raw::c_uint,
7575 point_dspclock: *mut ::std::os::raw::c_ulonglong,
7576 point_volume: *mut f32,
7577 ) -> FMOD_RESULT;
7578}
7579extern "C" {
7580 #[must_use]
7581 pub fn FMOD_Channel_GetDSP(
7582 channel: *mut FMOD_CHANNEL,
7583 index: ::std::os::raw::c_int,
7584 dsp: *mut *mut FMOD_DSP,
7585 ) -> FMOD_RESULT;
7586}
7587extern "C" {
7588 #[must_use]
7589 pub fn FMOD_Channel_AddDSP(
7590 channel: *mut FMOD_CHANNEL,
7591 index: ::std::os::raw::c_int,
7592 dsp: *mut FMOD_DSP,
7593 ) -> FMOD_RESULT;
7594}
7595extern "C" {
7596 #[must_use]
7597 pub fn FMOD_Channel_RemoveDSP(channel: *mut FMOD_CHANNEL, dsp: *mut FMOD_DSP) -> FMOD_RESULT;
7598}
7599extern "C" {
7600 #[must_use]
7601 pub fn FMOD_Channel_GetNumDSPs(
7602 channel: *mut FMOD_CHANNEL,
7603 numdsps: *mut ::std::os::raw::c_int,
7604 ) -> FMOD_RESULT;
7605}
7606extern "C" {
7607 #[must_use]
7608 pub fn FMOD_Channel_SetDSPIndex(
7609 channel: *mut FMOD_CHANNEL,
7610 dsp: *mut FMOD_DSP,
7611 index: ::std::os::raw::c_int,
7612 ) -> FMOD_RESULT;
7613}
7614extern "C" {
7615 #[must_use]
7616 pub fn FMOD_Channel_GetDSPIndex(
7617 channel: *mut FMOD_CHANNEL,
7618 dsp: *mut FMOD_DSP,
7619 index: *mut ::std::os::raw::c_int,
7620 ) -> FMOD_RESULT;
7621}
7622extern "C" {
7623 #[must_use]
7624 pub fn FMOD_Channel_Set3DAttributes(
7625 channel: *mut FMOD_CHANNEL,
7626 pos: *const FMOD_VECTOR,
7627 vel: *const FMOD_VECTOR,
7628 ) -> FMOD_RESULT;
7629}
7630extern "C" {
7631 #[must_use]
7632 pub fn FMOD_Channel_Get3DAttributes(
7633 channel: *mut FMOD_CHANNEL,
7634 pos: *mut FMOD_VECTOR,
7635 vel: *mut FMOD_VECTOR,
7636 ) -> FMOD_RESULT;
7637}
7638extern "C" {
7639 #[must_use]
7640 pub fn FMOD_Channel_Set3DMinMaxDistance(
7641 channel: *mut FMOD_CHANNEL,
7642 mindistance: f32,
7643 maxdistance: f32,
7644 ) -> FMOD_RESULT;
7645}
7646extern "C" {
7647 #[must_use]
7648 pub fn FMOD_Channel_Get3DMinMaxDistance(
7649 channel: *mut FMOD_CHANNEL,
7650 mindistance: *mut f32,
7651 maxdistance: *mut f32,
7652 ) -> FMOD_RESULT;
7653}
7654extern "C" {
7655 #[must_use]
7656 pub fn FMOD_Channel_Set3DConeSettings(
7657 channel: *mut FMOD_CHANNEL,
7658 insideconeangle: f32,
7659 outsideconeangle: f32,
7660 outsidevolume: f32,
7661 ) -> FMOD_RESULT;
7662}
7663extern "C" {
7664 #[must_use]
7665 pub fn FMOD_Channel_Get3DConeSettings(
7666 channel: *mut FMOD_CHANNEL,
7667 insideconeangle: *mut f32,
7668 outsideconeangle: *mut f32,
7669 outsidevolume: *mut f32,
7670 ) -> FMOD_RESULT;
7671}
7672extern "C" {
7673 #[must_use]
7674 pub fn FMOD_Channel_Set3DConeOrientation(
7675 channel: *mut FMOD_CHANNEL,
7676 orientation: *mut FMOD_VECTOR,
7677 ) -> FMOD_RESULT;
7678}
7679extern "C" {
7680 #[must_use]
7681 pub fn FMOD_Channel_Get3DConeOrientation(
7682 channel: *mut FMOD_CHANNEL,
7683 orientation: *mut FMOD_VECTOR,
7684 ) -> FMOD_RESULT;
7685}
7686extern "C" {
7687 #[must_use]
7688 pub fn FMOD_Channel_Set3DCustomRolloff(
7689 channel: *mut FMOD_CHANNEL,
7690 points: *mut FMOD_VECTOR,
7691 numpoints: ::std::os::raw::c_int,
7692 ) -> FMOD_RESULT;
7693}
7694extern "C" {
7695 #[must_use]
7696 pub fn FMOD_Channel_Get3DCustomRolloff(
7697 channel: *mut FMOD_CHANNEL,
7698 points: *mut *mut FMOD_VECTOR,
7699 numpoints: *mut ::std::os::raw::c_int,
7700 ) -> FMOD_RESULT;
7701}
7702extern "C" {
7703 #[must_use]
7704 pub fn FMOD_Channel_Set3DOcclusion(
7705 channel: *mut FMOD_CHANNEL,
7706 directocclusion: f32,
7707 reverbocclusion: f32,
7708 ) -> FMOD_RESULT;
7709}
7710extern "C" {
7711 #[must_use]
7712 pub fn FMOD_Channel_Get3DOcclusion(
7713 channel: *mut FMOD_CHANNEL,
7714 directocclusion: *mut f32,
7715 reverbocclusion: *mut f32,
7716 ) -> FMOD_RESULT;
7717}
7718extern "C" {
7719 #[must_use]
7720 pub fn FMOD_Channel_Set3DSpread(channel: *mut FMOD_CHANNEL, angle: f32) -> FMOD_RESULT;
7721}
7722extern "C" {
7723 #[must_use]
7724 pub fn FMOD_Channel_Get3DSpread(channel: *mut FMOD_CHANNEL, angle: *mut f32) -> FMOD_RESULT;
7725}
7726extern "C" {
7727 #[must_use]
7728 pub fn FMOD_Channel_Set3DLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
7729}
7730extern "C" {
7731 #[must_use]
7732 pub fn FMOD_Channel_Get3DLevel(channel: *mut FMOD_CHANNEL, level: *mut f32) -> FMOD_RESULT;
7733}
7734extern "C" {
7735 #[must_use]
7736 pub fn FMOD_Channel_Set3DDopplerLevel(channel: *mut FMOD_CHANNEL, level: f32) -> FMOD_RESULT;
7737}
7738extern "C" {
7739 #[must_use]
7740 pub fn FMOD_Channel_Get3DDopplerLevel(
7741 channel: *mut FMOD_CHANNEL,
7742 level: *mut f32,
7743 ) -> FMOD_RESULT;
7744}
7745extern "C" {
7746 #[must_use]
7747 pub fn FMOD_Channel_Set3DDistanceFilter(
7748 channel: *mut FMOD_CHANNEL,
7749 custom: FMOD_BOOL,
7750 customLevel: f32,
7751 centerFreq: f32,
7752 ) -> FMOD_RESULT;
7753}
7754extern "C" {
7755 #[must_use]
7756 pub fn FMOD_Channel_Get3DDistanceFilter(
7757 channel: *mut FMOD_CHANNEL,
7758 custom: *mut FMOD_BOOL,
7759 customLevel: *mut f32,
7760 centerFreq: *mut f32,
7761 ) -> FMOD_RESULT;
7762}
7763extern "C" {
7764 #[must_use]
7765 pub fn FMOD_Channel_SetUserData(
7766 channel: *mut FMOD_CHANNEL,
7767 userdata: *mut ::std::os::raw::c_void,
7768 ) -> FMOD_RESULT;
7769}
7770extern "C" {
7771 #[must_use]
7772 pub fn FMOD_Channel_GetUserData(
7773 channel: *mut FMOD_CHANNEL,
7774 userdata: *mut *mut ::std::os::raw::c_void,
7775 ) -> FMOD_RESULT;
7776}
7777extern "C" {
7778 #[must_use]
7779 pub fn FMOD_Channel_SetFrequency(channel: *mut FMOD_CHANNEL, frequency: f32) -> FMOD_RESULT;
7780}
7781extern "C" {
7782 #[must_use]
7783 pub fn FMOD_Channel_GetFrequency(
7784 channel: *mut FMOD_CHANNEL,
7785 frequency: *mut f32,
7786 ) -> FMOD_RESULT;
7787}
7788extern "C" {
7789 #[must_use]
7790 pub fn FMOD_Channel_SetPriority(
7791 channel: *mut FMOD_CHANNEL,
7792 priority: ::std::os::raw::c_int,
7793 ) -> FMOD_RESULT;
7794}
7795extern "C" {
7796 #[must_use]
7797 pub fn FMOD_Channel_GetPriority(
7798 channel: *mut FMOD_CHANNEL,
7799 priority: *mut ::std::os::raw::c_int,
7800 ) -> FMOD_RESULT;
7801}
7802extern "C" {
7803 #[must_use]
7804 pub fn FMOD_Channel_SetPosition(
7805 channel: *mut FMOD_CHANNEL,
7806 position: ::std::os::raw::c_uint,
7807 postype: FMOD_TIMEUNIT,
7808 ) -> FMOD_RESULT;
7809}
7810extern "C" {
7811 #[must_use]
7812 pub fn FMOD_Channel_GetPosition(
7813 channel: *mut FMOD_CHANNEL,
7814 position: *mut ::std::os::raw::c_uint,
7815 postype: FMOD_TIMEUNIT,
7816 ) -> FMOD_RESULT;
7817}
7818extern "C" {
7819 #[must_use]
7820 pub fn FMOD_Channel_SetChannelGroup(
7821 channel: *mut FMOD_CHANNEL,
7822 channelgroup: *mut FMOD_CHANNELGROUP,
7823 ) -> FMOD_RESULT;
7824}
7825extern "C" {
7826 #[must_use]
7827 pub fn FMOD_Channel_GetChannelGroup(
7828 channel: *mut FMOD_CHANNEL,
7829 channelgroup: *mut *mut FMOD_CHANNELGROUP,
7830 ) -> FMOD_RESULT;
7831}
7832extern "C" {
7833 #[must_use]
7834 pub fn FMOD_Channel_SetLoopCount(
7835 channel: *mut FMOD_CHANNEL,
7836 loopcount: ::std::os::raw::c_int,
7837 ) -> FMOD_RESULT;
7838}
7839extern "C" {
7840 #[must_use]
7841 pub fn FMOD_Channel_GetLoopCount(
7842 channel: *mut FMOD_CHANNEL,
7843 loopcount: *mut ::std::os::raw::c_int,
7844 ) -> FMOD_RESULT;
7845}
7846extern "C" {
7847 #[must_use]
7848 pub fn FMOD_Channel_SetLoopPoints(
7849 channel: *mut FMOD_CHANNEL,
7850 loopstart: ::std::os::raw::c_uint,
7851 loopstarttype: FMOD_TIMEUNIT,
7852 loopend: ::std::os::raw::c_uint,
7853 loopendtype: FMOD_TIMEUNIT,
7854 ) -> FMOD_RESULT;
7855}
7856extern "C" {
7857 #[must_use]
7858 pub fn FMOD_Channel_GetLoopPoints(
7859 channel: *mut FMOD_CHANNEL,
7860 loopstart: *mut ::std::os::raw::c_uint,
7861 loopstarttype: FMOD_TIMEUNIT,
7862 loopend: *mut ::std::os::raw::c_uint,
7863 loopendtype: FMOD_TIMEUNIT,
7864 ) -> FMOD_RESULT;
7865}
7866extern "C" {
7867 #[must_use]
7868 pub fn FMOD_Channel_IsVirtual(
7869 channel: *mut FMOD_CHANNEL,
7870 isvirtual: *mut FMOD_BOOL,
7871 ) -> FMOD_RESULT;
7872}
7873extern "C" {
7874 #[must_use]
7875 pub fn FMOD_Channel_GetCurrentSound(
7876 channel: *mut FMOD_CHANNEL,
7877 sound: *mut *mut FMOD_SOUND,
7878 ) -> FMOD_RESULT;
7879}
7880extern "C" {
7881 #[must_use]
7882 pub fn FMOD_Channel_GetIndex(
7883 channel: *mut FMOD_CHANNEL,
7884 index: *mut ::std::os::raw::c_int,
7885 ) -> FMOD_RESULT;
7886}
7887extern "C" {
7888 #[must_use]
7889 pub fn FMOD_ChannelGroup_GetSystemObject(
7890 channelgroup: *mut FMOD_CHANNELGROUP,
7891 system: *mut *mut FMOD_SYSTEM,
7892 ) -> FMOD_RESULT;
7893}
7894extern "C" {
7895 #[must_use]
7896 pub fn FMOD_ChannelGroup_Stop(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
7897}
7898extern "C" {
7899 #[must_use]
7900 pub fn FMOD_ChannelGroup_SetPaused(
7901 channelgroup: *mut FMOD_CHANNELGROUP,
7902 paused: FMOD_BOOL,
7903 ) -> FMOD_RESULT;
7904}
7905extern "C" {
7906 #[must_use]
7907 pub fn FMOD_ChannelGroup_GetPaused(
7908 channelgroup: *mut FMOD_CHANNELGROUP,
7909 paused: *mut FMOD_BOOL,
7910 ) -> FMOD_RESULT;
7911}
7912extern "C" {
7913 #[must_use]
7914 pub fn FMOD_ChannelGroup_SetVolume(
7915 channelgroup: *mut FMOD_CHANNELGROUP,
7916 volume: f32,
7917 ) -> FMOD_RESULT;
7918}
7919extern "C" {
7920 #[must_use]
7921 pub fn FMOD_ChannelGroup_GetVolume(
7922 channelgroup: *mut FMOD_CHANNELGROUP,
7923 volume: *mut f32,
7924 ) -> FMOD_RESULT;
7925}
7926extern "C" {
7927 #[must_use]
7928 pub fn FMOD_ChannelGroup_SetVolumeRamp(
7929 channelgroup: *mut FMOD_CHANNELGROUP,
7930 ramp: FMOD_BOOL,
7931 ) -> FMOD_RESULT;
7932}
7933extern "C" {
7934 #[must_use]
7935 pub fn FMOD_ChannelGroup_GetVolumeRamp(
7936 channelgroup: *mut FMOD_CHANNELGROUP,
7937 ramp: *mut FMOD_BOOL,
7938 ) -> FMOD_RESULT;
7939}
7940extern "C" {
7941 #[must_use]
7942 pub fn FMOD_ChannelGroup_GetAudibility(
7943 channelgroup: *mut FMOD_CHANNELGROUP,
7944 audibility: *mut f32,
7945 ) -> FMOD_RESULT;
7946}
7947extern "C" {
7948 #[must_use]
7949 pub fn FMOD_ChannelGroup_SetPitch(
7950 channelgroup: *mut FMOD_CHANNELGROUP,
7951 pitch: f32,
7952 ) -> FMOD_RESULT;
7953}
7954extern "C" {
7955 #[must_use]
7956 pub fn FMOD_ChannelGroup_GetPitch(
7957 channelgroup: *mut FMOD_CHANNELGROUP,
7958 pitch: *mut f32,
7959 ) -> FMOD_RESULT;
7960}
7961extern "C" {
7962 #[must_use]
7963 pub fn FMOD_ChannelGroup_SetMute(
7964 channelgroup: *mut FMOD_CHANNELGROUP,
7965 mute: FMOD_BOOL,
7966 ) -> FMOD_RESULT;
7967}
7968extern "C" {
7969 #[must_use]
7970 pub fn FMOD_ChannelGroup_GetMute(
7971 channelgroup: *mut FMOD_CHANNELGROUP,
7972 mute: *mut FMOD_BOOL,
7973 ) -> FMOD_RESULT;
7974}
7975extern "C" {
7976 #[must_use]
7977 pub fn FMOD_ChannelGroup_SetReverbProperties(
7978 channelgroup: *mut FMOD_CHANNELGROUP,
7979 instance: ::std::os::raw::c_int,
7980 wet: f32,
7981 ) -> FMOD_RESULT;
7982}
7983extern "C" {
7984 #[must_use]
7985 pub fn FMOD_ChannelGroup_GetReverbProperties(
7986 channelgroup: *mut FMOD_CHANNELGROUP,
7987 instance: ::std::os::raw::c_int,
7988 wet: *mut f32,
7989 ) -> FMOD_RESULT;
7990}
7991extern "C" {
7992 #[must_use]
7993 pub fn FMOD_ChannelGroup_SetLowPassGain(
7994 channelgroup: *mut FMOD_CHANNELGROUP,
7995 gain: f32,
7996 ) -> FMOD_RESULT;
7997}
7998extern "C" {
7999 #[must_use]
8000 pub fn FMOD_ChannelGroup_GetLowPassGain(
8001 channelgroup: *mut FMOD_CHANNELGROUP,
8002 gain: *mut f32,
8003 ) -> FMOD_RESULT;
8004}
8005extern "C" {
8006 #[must_use]
8007 pub fn FMOD_ChannelGroup_SetMode(
8008 channelgroup: *mut FMOD_CHANNELGROUP,
8009 mode: FMOD_MODE,
8010 ) -> FMOD_RESULT;
8011}
8012extern "C" {
8013 #[must_use]
8014 pub fn FMOD_ChannelGroup_GetMode(
8015 channelgroup: *mut FMOD_CHANNELGROUP,
8016 mode: *mut FMOD_MODE,
8017 ) -> FMOD_RESULT;
8018}
8019extern "C" {
8020 #[must_use]
8021 pub fn FMOD_ChannelGroup_SetCallback(
8022 channelgroup: *mut FMOD_CHANNELGROUP,
8023 callback: FMOD_CHANNELCONTROL_CALLBACK,
8024 ) -> FMOD_RESULT;
8025}
8026extern "C" {
8027 #[must_use]
8028 pub fn FMOD_ChannelGroup_IsPlaying(
8029 channelgroup: *mut FMOD_CHANNELGROUP,
8030 isplaying: *mut FMOD_BOOL,
8031 ) -> FMOD_RESULT;
8032}
8033extern "C" {
8034 #[must_use]
8035 pub fn FMOD_ChannelGroup_SetPan(channelgroup: *mut FMOD_CHANNELGROUP, pan: f32) -> FMOD_RESULT;
8036}
8037extern "C" {
8038 #[must_use]
8039 pub fn FMOD_ChannelGroup_SetMixLevelsOutput(
8040 channelgroup: *mut FMOD_CHANNELGROUP,
8041 frontleft: f32,
8042 frontright: f32,
8043 center: f32,
8044 lfe: f32,
8045 surroundleft: f32,
8046 surroundright: f32,
8047 backleft: f32,
8048 backright: f32,
8049 ) -> FMOD_RESULT;
8050}
8051extern "C" {
8052 #[must_use]
8053 pub fn FMOD_ChannelGroup_SetMixLevelsInput(
8054 channelgroup: *mut FMOD_CHANNELGROUP,
8055 levels: *mut f32,
8056 numlevels: ::std::os::raw::c_int,
8057 ) -> FMOD_RESULT;
8058}
8059extern "C" {
8060 #[must_use]
8061 pub fn FMOD_ChannelGroup_SetMixMatrix(
8062 channelgroup: *mut FMOD_CHANNELGROUP,
8063 matrix: *mut f32,
8064 outchannels: ::std::os::raw::c_int,
8065 inchannels: ::std::os::raw::c_int,
8066 inchannel_hop: ::std::os::raw::c_int,
8067 ) -> FMOD_RESULT;
8068}
8069extern "C" {
8070 #[must_use]
8071 pub fn FMOD_ChannelGroup_GetMixMatrix(
8072 channelgroup: *mut FMOD_CHANNELGROUP,
8073 matrix: *mut f32,
8074 outchannels: *mut ::std::os::raw::c_int,
8075 inchannels: *mut ::std::os::raw::c_int,
8076 inchannel_hop: ::std::os::raw::c_int,
8077 ) -> FMOD_RESULT;
8078}
8079extern "C" {
8080 #[must_use]
8081 pub fn FMOD_ChannelGroup_GetDSPClock(
8082 channelgroup: *mut FMOD_CHANNELGROUP,
8083 dspclock: *mut ::std::os::raw::c_ulonglong,
8084 parentclock: *mut ::std::os::raw::c_ulonglong,
8085 ) -> FMOD_RESULT;
8086}
8087extern "C" {
8088 #[must_use]
8089 pub fn FMOD_ChannelGroup_SetDelay(
8090 channelgroup: *mut FMOD_CHANNELGROUP,
8091 dspclock_start: ::std::os::raw::c_ulonglong,
8092 dspclock_end: ::std::os::raw::c_ulonglong,
8093 stopchannels: FMOD_BOOL,
8094 ) -> FMOD_RESULT;
8095}
8096extern "C" {
8097 #[must_use]
8098 pub fn FMOD_ChannelGroup_GetDelay(
8099 channelgroup: *mut FMOD_CHANNELGROUP,
8100 dspclock_start: *mut ::std::os::raw::c_ulonglong,
8101 dspclock_end: *mut ::std::os::raw::c_ulonglong,
8102 stopchannels: *mut FMOD_BOOL,
8103 ) -> FMOD_RESULT;
8104}
8105extern "C" {
8106 #[must_use]
8107 pub fn FMOD_ChannelGroup_AddFadePoint(
8108 channelgroup: *mut FMOD_CHANNELGROUP,
8109 dspclock: ::std::os::raw::c_ulonglong,
8110 volume: f32,
8111 ) -> FMOD_RESULT;
8112}
8113extern "C" {
8114 #[must_use]
8115 pub fn FMOD_ChannelGroup_SetFadePointRamp(
8116 channelgroup: *mut FMOD_CHANNELGROUP,
8117 dspclock: ::std::os::raw::c_ulonglong,
8118 volume: f32,
8119 ) -> FMOD_RESULT;
8120}
8121extern "C" {
8122 #[must_use]
8123 pub fn FMOD_ChannelGroup_RemoveFadePoints(
8124 channelgroup: *mut FMOD_CHANNELGROUP,
8125 dspclock_start: ::std::os::raw::c_ulonglong,
8126 dspclock_end: ::std::os::raw::c_ulonglong,
8127 ) -> FMOD_RESULT;
8128}
8129extern "C" {
8130 #[must_use]
8131 pub fn FMOD_ChannelGroup_GetFadePoints(
8132 channelgroup: *mut FMOD_CHANNELGROUP,
8133 numpoints: *mut ::std::os::raw::c_uint,
8134 point_dspclock: *mut ::std::os::raw::c_ulonglong,
8135 point_volume: *mut f32,
8136 ) -> FMOD_RESULT;
8137}
8138extern "C" {
8139 #[must_use]
8140 pub fn FMOD_ChannelGroup_GetDSP(
8141 channelgroup: *mut FMOD_CHANNELGROUP,
8142 index: ::std::os::raw::c_int,
8143 dsp: *mut *mut FMOD_DSP,
8144 ) -> FMOD_RESULT;
8145}
8146extern "C" {
8147 #[must_use]
8148 pub fn FMOD_ChannelGroup_AddDSP(
8149 channelgroup: *mut FMOD_CHANNELGROUP,
8150 index: ::std::os::raw::c_int,
8151 dsp: *mut FMOD_DSP,
8152 ) -> FMOD_RESULT;
8153}
8154extern "C" {
8155 #[must_use]
8156 pub fn FMOD_ChannelGroup_RemoveDSP(
8157 channelgroup: *mut FMOD_CHANNELGROUP,
8158 dsp: *mut FMOD_DSP,
8159 ) -> FMOD_RESULT;
8160}
8161extern "C" {
8162 #[must_use]
8163 pub fn FMOD_ChannelGroup_GetNumDSPs(
8164 channelgroup: *mut FMOD_CHANNELGROUP,
8165 numdsps: *mut ::std::os::raw::c_int,
8166 ) -> FMOD_RESULT;
8167}
8168extern "C" {
8169 #[must_use]
8170 pub fn FMOD_ChannelGroup_SetDSPIndex(
8171 channelgroup: *mut FMOD_CHANNELGROUP,
8172 dsp: *mut FMOD_DSP,
8173 index: ::std::os::raw::c_int,
8174 ) -> FMOD_RESULT;
8175}
8176extern "C" {
8177 #[must_use]
8178 pub fn FMOD_ChannelGroup_GetDSPIndex(
8179 channelgroup: *mut FMOD_CHANNELGROUP,
8180 dsp: *mut FMOD_DSP,
8181 index: *mut ::std::os::raw::c_int,
8182 ) -> FMOD_RESULT;
8183}
8184extern "C" {
8185 #[must_use]
8186 pub fn FMOD_ChannelGroup_Set3DAttributes(
8187 channelgroup: *mut FMOD_CHANNELGROUP,
8188 pos: *const FMOD_VECTOR,
8189 vel: *const FMOD_VECTOR,
8190 ) -> FMOD_RESULT;
8191}
8192extern "C" {
8193 #[must_use]
8194 pub fn FMOD_ChannelGroup_Get3DAttributes(
8195 channelgroup: *mut FMOD_CHANNELGROUP,
8196 pos: *mut FMOD_VECTOR,
8197 vel: *mut FMOD_VECTOR,
8198 ) -> FMOD_RESULT;
8199}
8200extern "C" {
8201 #[must_use]
8202 pub fn FMOD_ChannelGroup_Set3DMinMaxDistance(
8203 channelgroup: *mut FMOD_CHANNELGROUP,
8204 mindistance: f32,
8205 maxdistance: f32,
8206 ) -> FMOD_RESULT;
8207}
8208extern "C" {
8209 #[must_use]
8210 pub fn FMOD_ChannelGroup_Get3DMinMaxDistance(
8211 channelgroup: *mut FMOD_CHANNELGROUP,
8212 mindistance: *mut f32,
8213 maxdistance: *mut f32,
8214 ) -> FMOD_RESULT;
8215}
8216extern "C" {
8217 #[must_use]
8218 pub fn FMOD_ChannelGroup_Set3DConeSettings(
8219 channelgroup: *mut FMOD_CHANNELGROUP,
8220 insideconeangle: f32,
8221 outsideconeangle: f32,
8222 outsidevolume: f32,
8223 ) -> FMOD_RESULT;
8224}
8225extern "C" {
8226 #[must_use]
8227 pub fn FMOD_ChannelGroup_Get3DConeSettings(
8228 channelgroup: *mut FMOD_CHANNELGROUP,
8229 insideconeangle: *mut f32,
8230 outsideconeangle: *mut f32,
8231 outsidevolume: *mut f32,
8232 ) -> FMOD_RESULT;
8233}
8234extern "C" {
8235 #[must_use]
8236 pub fn FMOD_ChannelGroup_Set3DConeOrientation(
8237 channelgroup: *mut FMOD_CHANNELGROUP,
8238 orientation: *mut FMOD_VECTOR,
8239 ) -> FMOD_RESULT;
8240}
8241extern "C" {
8242 #[must_use]
8243 pub fn FMOD_ChannelGroup_Get3DConeOrientation(
8244 channelgroup: *mut FMOD_CHANNELGROUP,
8245 orientation: *mut FMOD_VECTOR,
8246 ) -> FMOD_RESULT;
8247}
8248extern "C" {
8249 #[must_use]
8250 pub fn FMOD_ChannelGroup_Set3DCustomRolloff(
8251 channelgroup: *mut FMOD_CHANNELGROUP,
8252 points: *mut FMOD_VECTOR,
8253 numpoints: ::std::os::raw::c_int,
8254 ) -> FMOD_RESULT;
8255}
8256extern "C" {
8257 #[must_use]
8258 pub fn FMOD_ChannelGroup_Get3DCustomRolloff(
8259 channelgroup: *mut FMOD_CHANNELGROUP,
8260 points: *mut *mut FMOD_VECTOR,
8261 numpoints: *mut ::std::os::raw::c_int,
8262 ) -> FMOD_RESULT;
8263}
8264extern "C" {
8265 #[must_use]
8266 pub fn FMOD_ChannelGroup_Set3DOcclusion(
8267 channelgroup: *mut FMOD_CHANNELGROUP,
8268 directocclusion: f32,
8269 reverbocclusion: f32,
8270 ) -> FMOD_RESULT;
8271}
8272extern "C" {
8273 #[must_use]
8274 pub fn FMOD_ChannelGroup_Get3DOcclusion(
8275 channelgroup: *mut FMOD_CHANNELGROUP,
8276 directocclusion: *mut f32,
8277 reverbocclusion: *mut f32,
8278 ) -> FMOD_RESULT;
8279}
8280extern "C" {
8281 #[must_use]
8282 pub fn FMOD_ChannelGroup_Set3DSpread(
8283 channelgroup: *mut FMOD_CHANNELGROUP,
8284 angle: f32,
8285 ) -> FMOD_RESULT;
8286}
8287extern "C" {
8288 #[must_use]
8289 pub fn FMOD_ChannelGroup_Get3DSpread(
8290 channelgroup: *mut FMOD_CHANNELGROUP,
8291 angle: *mut f32,
8292 ) -> FMOD_RESULT;
8293}
8294extern "C" {
8295 #[must_use]
8296 pub fn FMOD_ChannelGroup_Set3DLevel(
8297 channelgroup: *mut FMOD_CHANNELGROUP,
8298 level: f32,
8299 ) -> FMOD_RESULT;
8300}
8301extern "C" {
8302 #[must_use]
8303 pub fn FMOD_ChannelGroup_Get3DLevel(
8304 channelgroup: *mut FMOD_CHANNELGROUP,
8305 level: *mut f32,
8306 ) -> FMOD_RESULT;
8307}
8308extern "C" {
8309 #[must_use]
8310 pub fn FMOD_ChannelGroup_Set3DDopplerLevel(
8311 channelgroup: *mut FMOD_CHANNELGROUP,
8312 level: f32,
8313 ) -> FMOD_RESULT;
8314}
8315extern "C" {
8316 #[must_use]
8317 pub fn FMOD_ChannelGroup_Get3DDopplerLevel(
8318 channelgroup: *mut FMOD_CHANNELGROUP,
8319 level: *mut f32,
8320 ) -> FMOD_RESULT;
8321}
8322extern "C" {
8323 #[must_use]
8324 pub fn FMOD_ChannelGroup_Set3DDistanceFilter(
8325 channelgroup: *mut FMOD_CHANNELGROUP,
8326 custom: FMOD_BOOL,
8327 customLevel: f32,
8328 centerFreq: f32,
8329 ) -> FMOD_RESULT;
8330}
8331extern "C" {
8332 #[must_use]
8333 pub fn FMOD_ChannelGroup_Get3DDistanceFilter(
8334 channelgroup: *mut FMOD_CHANNELGROUP,
8335 custom: *mut FMOD_BOOL,
8336 customLevel: *mut f32,
8337 centerFreq: *mut f32,
8338 ) -> FMOD_RESULT;
8339}
8340extern "C" {
8341 #[must_use]
8342 pub fn FMOD_ChannelGroup_SetUserData(
8343 channelgroup: *mut FMOD_CHANNELGROUP,
8344 userdata: *mut ::std::os::raw::c_void,
8345 ) -> FMOD_RESULT;
8346}
8347extern "C" {
8348 #[must_use]
8349 pub fn FMOD_ChannelGroup_GetUserData(
8350 channelgroup: *mut FMOD_CHANNELGROUP,
8351 userdata: *mut *mut ::std::os::raw::c_void,
8352 ) -> FMOD_RESULT;
8353}
8354extern "C" {
8355 #[must_use]
8356 pub fn FMOD_ChannelGroup_Release(channelgroup: *mut FMOD_CHANNELGROUP) -> FMOD_RESULT;
8357}
8358extern "C" {
8359 #[must_use]
8360 pub fn FMOD_ChannelGroup_AddGroup(
8361 channelgroup: *mut FMOD_CHANNELGROUP,
8362 group: *mut FMOD_CHANNELGROUP,
8363 propagatedspclock: FMOD_BOOL,
8364 connection: *mut *mut FMOD_DSPCONNECTION,
8365 ) -> FMOD_RESULT;
8366}
8367extern "C" {
8368 #[must_use]
8369 pub fn FMOD_ChannelGroup_GetNumGroups(
8370 channelgroup: *mut FMOD_CHANNELGROUP,
8371 numgroups: *mut ::std::os::raw::c_int,
8372 ) -> FMOD_RESULT;
8373}
8374extern "C" {
8375 #[must_use]
8376 pub fn FMOD_ChannelGroup_GetGroup(
8377 channelgroup: *mut FMOD_CHANNELGROUP,
8378 index: ::std::os::raw::c_int,
8379 group: *mut *mut FMOD_CHANNELGROUP,
8380 ) -> FMOD_RESULT;
8381}
8382extern "C" {
8383 #[must_use]
8384 pub fn FMOD_ChannelGroup_GetParentGroup(
8385 channelgroup: *mut FMOD_CHANNELGROUP,
8386 group: *mut *mut FMOD_CHANNELGROUP,
8387 ) -> FMOD_RESULT;
8388}
8389extern "C" {
8390 #[must_use]
8391 pub fn FMOD_ChannelGroup_GetName(
8392 channelgroup: *mut FMOD_CHANNELGROUP,
8393 name: *mut ::std::os::raw::c_char,
8394 namelen: ::std::os::raw::c_int,
8395 ) -> FMOD_RESULT;
8396}
8397extern "C" {
8398 #[must_use]
8399 pub fn FMOD_ChannelGroup_GetNumChannels(
8400 channelgroup: *mut FMOD_CHANNELGROUP,
8401 numchannels: *mut ::std::os::raw::c_int,
8402 ) -> FMOD_RESULT;
8403}
8404extern "C" {
8405 #[must_use]
8406 pub fn FMOD_ChannelGroup_GetChannel(
8407 channelgroup: *mut FMOD_CHANNELGROUP,
8408 index: ::std::os::raw::c_int,
8409 channel: *mut *mut FMOD_CHANNEL,
8410 ) -> FMOD_RESULT;
8411}
8412extern "C" {
8413 #[must_use]
8414 pub fn FMOD_SoundGroup_Release(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
8415}
8416extern "C" {
8417 #[must_use]
8418 pub fn FMOD_SoundGroup_GetSystemObject(
8419 soundgroup: *mut FMOD_SOUNDGROUP,
8420 system: *mut *mut FMOD_SYSTEM,
8421 ) -> FMOD_RESULT;
8422}
8423extern "C" {
8424 #[must_use]
8425 pub fn FMOD_SoundGroup_SetMaxAudible(
8426 soundgroup: *mut FMOD_SOUNDGROUP,
8427 maxaudible: ::std::os::raw::c_int,
8428 ) -> FMOD_RESULT;
8429}
8430extern "C" {
8431 #[must_use]
8432 pub fn FMOD_SoundGroup_GetMaxAudible(
8433 soundgroup: *mut FMOD_SOUNDGROUP,
8434 maxaudible: *mut ::std::os::raw::c_int,
8435 ) -> FMOD_RESULT;
8436}
8437extern "C" {
8438 #[must_use]
8439 pub fn FMOD_SoundGroup_SetMaxAudibleBehavior(
8440 soundgroup: *mut FMOD_SOUNDGROUP,
8441 behavior: FMOD_SOUNDGROUP_BEHAVIOR,
8442 ) -> FMOD_RESULT;
8443}
8444extern "C" {
8445 #[must_use]
8446 pub fn FMOD_SoundGroup_GetMaxAudibleBehavior(
8447 soundgroup: *mut FMOD_SOUNDGROUP,
8448 behavior: *mut FMOD_SOUNDGROUP_BEHAVIOR,
8449 ) -> FMOD_RESULT;
8450}
8451extern "C" {
8452 #[must_use]
8453 pub fn FMOD_SoundGroup_SetMuteFadeSpeed(
8454 soundgroup: *mut FMOD_SOUNDGROUP,
8455 speed: f32,
8456 ) -> FMOD_RESULT;
8457}
8458extern "C" {
8459 #[must_use]
8460 pub fn FMOD_SoundGroup_GetMuteFadeSpeed(
8461 soundgroup: *mut FMOD_SOUNDGROUP,
8462 speed: *mut f32,
8463 ) -> FMOD_RESULT;
8464}
8465extern "C" {
8466 #[must_use]
8467 pub fn FMOD_SoundGroup_SetVolume(soundgroup: *mut FMOD_SOUNDGROUP, volume: f32) -> FMOD_RESULT;
8468}
8469extern "C" {
8470 #[must_use]
8471 pub fn FMOD_SoundGroup_GetVolume(
8472 soundgroup: *mut FMOD_SOUNDGROUP,
8473 volume: *mut f32,
8474 ) -> FMOD_RESULT;
8475}
8476extern "C" {
8477 #[must_use]
8478 pub fn FMOD_SoundGroup_Stop(soundgroup: *mut FMOD_SOUNDGROUP) -> FMOD_RESULT;
8479}
8480extern "C" {
8481 #[must_use]
8482 pub fn FMOD_SoundGroup_GetName(
8483 soundgroup: *mut FMOD_SOUNDGROUP,
8484 name: *mut ::std::os::raw::c_char,
8485 namelen: ::std::os::raw::c_int,
8486 ) -> FMOD_RESULT;
8487}
8488extern "C" {
8489 #[must_use]
8490 pub fn FMOD_SoundGroup_GetNumSounds(
8491 soundgroup: *mut FMOD_SOUNDGROUP,
8492 numsounds: *mut ::std::os::raw::c_int,
8493 ) -> FMOD_RESULT;
8494}
8495extern "C" {
8496 #[must_use]
8497 pub fn FMOD_SoundGroup_GetSound(
8498 soundgroup: *mut FMOD_SOUNDGROUP,
8499 index: ::std::os::raw::c_int,
8500 sound: *mut *mut FMOD_SOUND,
8501 ) -> FMOD_RESULT;
8502}
8503extern "C" {
8504 #[must_use]
8505 pub fn FMOD_SoundGroup_GetNumPlaying(
8506 soundgroup: *mut FMOD_SOUNDGROUP,
8507 numplaying: *mut ::std::os::raw::c_int,
8508 ) -> FMOD_RESULT;
8509}
8510extern "C" {
8511 #[must_use]
8512 pub fn FMOD_SoundGroup_SetUserData(
8513 soundgroup: *mut FMOD_SOUNDGROUP,
8514 userdata: *mut ::std::os::raw::c_void,
8515 ) -> FMOD_RESULT;
8516}
8517extern "C" {
8518 #[must_use]
8519 pub fn FMOD_SoundGroup_GetUserData(
8520 soundgroup: *mut FMOD_SOUNDGROUP,
8521 userdata: *mut *mut ::std::os::raw::c_void,
8522 ) -> FMOD_RESULT;
8523}
8524extern "C" {
8525 #[must_use]
8526 pub fn FMOD_DSP_Release(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
8527}
8528extern "C" {
8529 #[must_use]
8530 pub fn FMOD_DSP_GetSystemObject(
8531 dsp: *mut FMOD_DSP,
8532 system: *mut *mut FMOD_SYSTEM,
8533 ) -> FMOD_RESULT;
8534}
8535extern "C" {
8536 #[must_use]
8537 pub fn FMOD_DSP_AddInput(
8538 dsp: *mut FMOD_DSP,
8539 input: *mut FMOD_DSP,
8540 connection: *mut *mut FMOD_DSPCONNECTION,
8541 type_: FMOD_DSPCONNECTION_TYPE,
8542 ) -> FMOD_RESULT;
8543}
8544extern "C" {
8545 #[must_use]
8546 pub fn FMOD_DSP_DisconnectFrom(
8547 dsp: *mut FMOD_DSP,
8548 target: *mut FMOD_DSP,
8549 connection: *mut FMOD_DSPCONNECTION,
8550 ) -> FMOD_RESULT;
8551}
8552extern "C" {
8553 #[must_use]
8554 pub fn FMOD_DSP_DisconnectAll(
8555 dsp: *mut FMOD_DSP,
8556 inputs: FMOD_BOOL,
8557 outputs: FMOD_BOOL,
8558 ) -> FMOD_RESULT;
8559}
8560extern "C" {
8561 #[must_use]
8562 pub fn FMOD_DSP_GetNumInputs(
8563 dsp: *mut FMOD_DSP,
8564 numinputs: *mut ::std::os::raw::c_int,
8565 ) -> FMOD_RESULT;
8566}
8567extern "C" {
8568 #[must_use]
8569 pub fn FMOD_DSP_GetNumOutputs(
8570 dsp: *mut FMOD_DSP,
8571 numoutputs: *mut ::std::os::raw::c_int,
8572 ) -> FMOD_RESULT;
8573}
8574extern "C" {
8575 #[must_use]
8576 pub fn FMOD_DSP_GetInput(
8577 dsp: *mut FMOD_DSP,
8578 index: ::std::os::raw::c_int,
8579 input: *mut *mut FMOD_DSP,
8580 inputconnection: *mut *mut FMOD_DSPCONNECTION,
8581 ) -> FMOD_RESULT;
8582}
8583extern "C" {
8584 #[must_use]
8585 pub fn FMOD_DSP_GetOutput(
8586 dsp: *mut FMOD_DSP,
8587 index: ::std::os::raw::c_int,
8588 output: *mut *mut FMOD_DSP,
8589 outputconnection: *mut *mut FMOD_DSPCONNECTION,
8590 ) -> FMOD_RESULT;
8591}
8592extern "C" {
8593 #[must_use]
8594 pub fn FMOD_DSP_SetActive(dsp: *mut FMOD_DSP, active: FMOD_BOOL) -> FMOD_RESULT;
8595}
8596extern "C" {
8597 #[must_use]
8598 pub fn FMOD_DSP_GetActive(dsp: *mut FMOD_DSP, active: *mut FMOD_BOOL) -> FMOD_RESULT;
8599}
8600extern "C" {
8601 #[must_use]
8602 pub fn FMOD_DSP_SetBypass(dsp: *mut FMOD_DSP, bypass: FMOD_BOOL) -> FMOD_RESULT;
8603}
8604extern "C" {
8605 #[must_use]
8606 pub fn FMOD_DSP_GetBypass(dsp: *mut FMOD_DSP, bypass: *mut FMOD_BOOL) -> FMOD_RESULT;
8607}
8608extern "C" {
8609 #[must_use]
8610 pub fn FMOD_DSP_SetWetDryMix(
8611 dsp: *mut FMOD_DSP,
8612 prewet: f32,
8613 postwet: f32,
8614 dry: f32,
8615 ) -> FMOD_RESULT;
8616}
8617extern "C" {
8618 #[must_use]
8619 pub fn FMOD_DSP_GetWetDryMix(
8620 dsp: *mut FMOD_DSP,
8621 prewet: *mut f32,
8622 postwet: *mut f32,
8623 dry: *mut f32,
8624 ) -> FMOD_RESULT;
8625}
8626extern "C" {
8627 #[must_use]
8628 pub fn FMOD_DSP_SetChannelFormat(
8629 dsp: *mut FMOD_DSP,
8630 channelmask: FMOD_CHANNELMASK,
8631 numchannels: ::std::os::raw::c_int,
8632 source_speakermode: FMOD_SPEAKERMODE,
8633 ) -> FMOD_RESULT;
8634}
8635extern "C" {
8636 #[must_use]
8637 pub fn FMOD_DSP_GetChannelFormat(
8638 dsp: *mut FMOD_DSP,
8639 channelmask: *mut FMOD_CHANNELMASK,
8640 numchannels: *mut ::std::os::raw::c_int,
8641 source_speakermode: *mut FMOD_SPEAKERMODE,
8642 ) -> FMOD_RESULT;
8643}
8644extern "C" {
8645 #[must_use]
8646 pub fn FMOD_DSP_GetOutputChannelFormat(
8647 dsp: *mut FMOD_DSP,
8648 inmask: FMOD_CHANNELMASK,
8649 inchannels: ::std::os::raw::c_int,
8650 inspeakermode: FMOD_SPEAKERMODE,
8651 outmask: *mut FMOD_CHANNELMASK,
8652 outchannels: *mut ::std::os::raw::c_int,
8653 outspeakermode: *mut FMOD_SPEAKERMODE,
8654 ) -> FMOD_RESULT;
8655}
8656extern "C" {
8657 #[must_use]
8658 pub fn FMOD_DSP_Reset(dsp: *mut FMOD_DSP) -> FMOD_RESULT;
8659}
8660extern "C" {
8661 #[must_use]
8662 pub fn FMOD_DSP_SetCallback(dsp: *mut FMOD_DSP, callback: FMOD_DSP_CALLBACK) -> FMOD_RESULT;
8663}
8664extern "C" {
8665 #[must_use]
8666 pub fn FMOD_DSP_SetParameterFloat(
8667 dsp: *mut FMOD_DSP,
8668 index: ::std::os::raw::c_int,
8669 value: f32,
8670 ) -> FMOD_RESULT;
8671}
8672extern "C" {
8673 #[must_use]
8674 pub fn FMOD_DSP_SetParameterInt(
8675 dsp: *mut FMOD_DSP,
8676 index: ::std::os::raw::c_int,
8677 value: ::std::os::raw::c_int,
8678 ) -> FMOD_RESULT;
8679}
8680extern "C" {
8681 #[must_use]
8682 pub fn FMOD_DSP_SetParameterBool(
8683 dsp: *mut FMOD_DSP,
8684 index: ::std::os::raw::c_int,
8685 value: FMOD_BOOL,
8686 ) -> FMOD_RESULT;
8687}
8688extern "C" {
8689 #[must_use]
8690 pub fn FMOD_DSP_SetParameterData(
8691 dsp: *mut FMOD_DSP,
8692 index: ::std::os::raw::c_int,
8693 data: *mut ::std::os::raw::c_void,
8694 length: ::std::os::raw::c_uint,
8695 ) -> FMOD_RESULT;
8696}
8697extern "C" {
8698 #[must_use]
8699 pub fn FMOD_DSP_GetParameterFloat(
8700 dsp: *mut FMOD_DSP,
8701 index: ::std::os::raw::c_int,
8702 value: *mut f32,
8703 valuestr: *mut ::std::os::raw::c_char,
8704 valuestrlen: ::std::os::raw::c_int,
8705 ) -> FMOD_RESULT;
8706}
8707extern "C" {
8708 #[must_use]
8709 pub fn FMOD_DSP_GetParameterInt(
8710 dsp: *mut FMOD_DSP,
8711 index: ::std::os::raw::c_int,
8712 value: *mut ::std::os::raw::c_int,
8713 valuestr: *mut ::std::os::raw::c_char,
8714 valuestrlen: ::std::os::raw::c_int,
8715 ) -> FMOD_RESULT;
8716}
8717extern "C" {
8718 #[must_use]
8719 pub fn FMOD_DSP_GetParameterBool(
8720 dsp: *mut FMOD_DSP,
8721 index: ::std::os::raw::c_int,
8722 value: *mut FMOD_BOOL,
8723 valuestr: *mut ::std::os::raw::c_char,
8724 valuestrlen: ::std::os::raw::c_int,
8725 ) -> FMOD_RESULT;
8726}
8727extern "C" {
8728 #[must_use]
8729 pub fn FMOD_DSP_GetParameterData(
8730 dsp: *mut FMOD_DSP,
8731 index: ::std::os::raw::c_int,
8732 data: *mut *mut ::std::os::raw::c_void,
8733 length: *mut ::std::os::raw::c_uint,
8734 valuestr: *mut ::std::os::raw::c_char,
8735 valuestrlen: ::std::os::raw::c_int,
8736 ) -> FMOD_RESULT;
8737}
8738extern "C" {
8739 #[must_use]
8740 pub fn FMOD_DSP_GetNumParameters(
8741 dsp: *mut FMOD_DSP,
8742 numparams: *mut ::std::os::raw::c_int,
8743 ) -> FMOD_RESULT;
8744}
8745extern "C" {
8746 #[must_use]
8747 pub fn FMOD_DSP_GetParameterInfo(
8748 dsp: *mut FMOD_DSP,
8749 index: ::std::os::raw::c_int,
8750 desc: *mut *mut FMOD_DSP_PARAMETER_DESC,
8751 ) -> FMOD_RESULT;
8752}
8753extern "C" {
8754 #[must_use]
8755 pub fn FMOD_DSP_GetDataParameterIndex(
8756 dsp: *mut FMOD_DSP,
8757 datatype: ::std::os::raw::c_int,
8758 index: *mut ::std::os::raw::c_int,
8759 ) -> FMOD_RESULT;
8760}
8761extern "C" {
8762 #[must_use]
8763 pub fn FMOD_DSP_ShowConfigDialog(
8764 dsp: *mut FMOD_DSP,
8765 hwnd: *mut ::std::os::raw::c_void,
8766 show: FMOD_BOOL,
8767 ) -> FMOD_RESULT;
8768}
8769extern "C" {
8770 #[must_use]
8771 pub fn FMOD_DSP_GetInfo(
8772 dsp: *mut FMOD_DSP,
8773 name: *mut ::std::os::raw::c_char,
8774 version: *mut ::std::os::raw::c_uint,
8775 channels: *mut ::std::os::raw::c_int,
8776 configwidth: *mut ::std::os::raw::c_int,
8777 configheight: *mut ::std::os::raw::c_int,
8778 ) -> FMOD_RESULT;
8779}
8780extern "C" {
8781 #[must_use]
8782 pub fn FMOD_DSP_GetType(dsp: *mut FMOD_DSP, type_: *mut FMOD_DSP_TYPE) -> FMOD_RESULT;
8783}
8784extern "C" {
8785 #[must_use]
8786 pub fn FMOD_DSP_GetIdle(dsp: *mut FMOD_DSP, idle: *mut FMOD_BOOL) -> FMOD_RESULT;
8787}
8788extern "C" {
8789 #[must_use]
8790 pub fn FMOD_DSP_SetUserData(
8791 dsp: *mut FMOD_DSP,
8792 userdata: *mut ::std::os::raw::c_void,
8793 ) -> FMOD_RESULT;
8794}
8795extern "C" {
8796 #[must_use]
8797 pub fn FMOD_DSP_GetUserData(
8798 dsp: *mut FMOD_DSP,
8799 userdata: *mut *mut ::std::os::raw::c_void,
8800 ) -> FMOD_RESULT;
8801}
8802extern "C" {
8803 #[must_use]
8804 pub fn FMOD_DSP_SetMeteringEnabled(
8805 dsp: *mut FMOD_DSP,
8806 inputEnabled: FMOD_BOOL,
8807 outputEnabled: FMOD_BOOL,
8808 ) -> FMOD_RESULT;
8809}
8810extern "C" {
8811 #[must_use]
8812 pub fn FMOD_DSP_GetMeteringEnabled(
8813 dsp: *mut FMOD_DSP,
8814 inputEnabled: *mut FMOD_BOOL,
8815 outputEnabled: *mut FMOD_BOOL,
8816 ) -> FMOD_RESULT;
8817}
8818extern "C" {
8819 #[must_use]
8820 pub fn FMOD_DSP_GetMeteringInfo(
8821 dsp: *mut FMOD_DSP,
8822 inputInfo: *mut FMOD_DSP_METERING_INFO,
8823 outputInfo: *mut FMOD_DSP_METERING_INFO,
8824 ) -> FMOD_RESULT;
8825}
8826extern "C" {
8827 #[must_use]
8828 pub fn FMOD_DSP_GetCPUUsage(
8829 dsp: *mut FMOD_DSP,
8830 exclusive: *mut ::std::os::raw::c_uint,
8831 inclusive: *mut ::std::os::raw::c_uint,
8832 ) -> FMOD_RESULT;
8833}
8834extern "C" {
8835 #[must_use]
8836 pub fn FMOD_DSPConnection_GetInput(
8837 dspconnection: *mut FMOD_DSPCONNECTION,
8838 input: *mut *mut FMOD_DSP,
8839 ) -> FMOD_RESULT;
8840}
8841extern "C" {
8842 #[must_use]
8843 pub fn FMOD_DSPConnection_GetOutput(
8844 dspconnection: *mut FMOD_DSPCONNECTION,
8845 output: *mut *mut FMOD_DSP,
8846 ) -> FMOD_RESULT;
8847}
8848extern "C" {
8849 #[must_use]
8850 pub fn FMOD_DSPConnection_SetMix(
8851 dspconnection: *mut FMOD_DSPCONNECTION,
8852 volume: f32,
8853 ) -> FMOD_RESULT;
8854}
8855extern "C" {
8856 #[must_use]
8857 pub fn FMOD_DSPConnection_GetMix(
8858 dspconnection: *mut FMOD_DSPCONNECTION,
8859 volume: *mut f32,
8860 ) -> FMOD_RESULT;
8861}
8862extern "C" {
8863 #[must_use]
8864 pub fn FMOD_DSPConnection_SetMixMatrix(
8865 dspconnection: *mut FMOD_DSPCONNECTION,
8866 matrix: *mut f32,
8867 outchannels: ::std::os::raw::c_int,
8868 inchannels: ::std::os::raw::c_int,
8869 inchannel_hop: ::std::os::raw::c_int,
8870 ) -> FMOD_RESULT;
8871}
8872extern "C" {
8873 #[must_use]
8874 pub fn FMOD_DSPConnection_GetMixMatrix(
8875 dspconnection: *mut FMOD_DSPCONNECTION,
8876 matrix: *mut f32,
8877 outchannels: *mut ::std::os::raw::c_int,
8878 inchannels: *mut ::std::os::raw::c_int,
8879 inchannel_hop: ::std::os::raw::c_int,
8880 ) -> FMOD_RESULT;
8881}
8882extern "C" {
8883 #[must_use]
8884 pub fn FMOD_DSPConnection_GetType(
8885 dspconnection: *mut FMOD_DSPCONNECTION,
8886 type_: *mut FMOD_DSPCONNECTION_TYPE,
8887 ) -> FMOD_RESULT;
8888}
8889extern "C" {
8890 #[must_use]
8891 pub fn FMOD_DSPConnection_SetUserData(
8892 dspconnection: *mut FMOD_DSPCONNECTION,
8893 userdata: *mut ::std::os::raw::c_void,
8894 ) -> FMOD_RESULT;
8895}
8896extern "C" {
8897 #[must_use]
8898 pub fn FMOD_DSPConnection_GetUserData(
8899 dspconnection: *mut FMOD_DSPCONNECTION,
8900 userdata: *mut *mut ::std::os::raw::c_void,
8901 ) -> FMOD_RESULT;
8902}
8903extern "C" {
8904 #[must_use]
8905 pub fn FMOD_Geometry_Release(geometry: *mut FMOD_GEOMETRY) -> FMOD_RESULT;
8906}
8907extern "C" {
8908 #[must_use]
8909 pub fn FMOD_Geometry_AddPolygon(
8910 geometry: *mut FMOD_GEOMETRY,
8911 directocclusion: f32,
8912 reverbocclusion: f32,
8913 doublesided: FMOD_BOOL,
8914 numvertices: ::std::os::raw::c_int,
8915 vertices: *const FMOD_VECTOR,
8916 polygonindex: *mut ::std::os::raw::c_int,
8917 ) -> FMOD_RESULT;
8918}
8919extern "C" {
8920 #[must_use]
8921 pub fn FMOD_Geometry_GetNumPolygons(
8922 geometry: *mut FMOD_GEOMETRY,
8923 numpolygons: *mut ::std::os::raw::c_int,
8924 ) -> FMOD_RESULT;
8925}
8926extern "C" {
8927 #[must_use]
8928 pub fn FMOD_Geometry_GetMaxPolygons(
8929 geometry: *mut FMOD_GEOMETRY,
8930 maxpolygons: *mut ::std::os::raw::c_int,
8931 maxvertices: *mut ::std::os::raw::c_int,
8932 ) -> FMOD_RESULT;
8933}
8934extern "C" {
8935 #[must_use]
8936 pub fn FMOD_Geometry_GetPolygonNumVertices(
8937 geometry: *mut FMOD_GEOMETRY,
8938 index: ::std::os::raw::c_int,
8939 numvertices: *mut ::std::os::raw::c_int,
8940 ) -> FMOD_RESULT;
8941}
8942extern "C" {
8943 #[must_use]
8944 pub fn FMOD_Geometry_SetPolygonVertex(
8945 geometry: *mut FMOD_GEOMETRY,
8946 index: ::std::os::raw::c_int,
8947 vertexindex: ::std::os::raw::c_int,
8948 vertex: *const FMOD_VECTOR,
8949 ) -> FMOD_RESULT;
8950}
8951extern "C" {
8952 #[must_use]
8953 pub fn FMOD_Geometry_GetPolygonVertex(
8954 geometry: *mut FMOD_GEOMETRY,
8955 index: ::std::os::raw::c_int,
8956 vertexindex: ::std::os::raw::c_int,
8957 vertex: *mut FMOD_VECTOR,
8958 ) -> FMOD_RESULT;
8959}
8960extern "C" {
8961 #[must_use]
8962 pub fn FMOD_Geometry_SetPolygonAttributes(
8963 geometry: *mut FMOD_GEOMETRY,
8964 index: ::std::os::raw::c_int,
8965 directocclusion: f32,
8966 reverbocclusion: f32,
8967 doublesided: FMOD_BOOL,
8968 ) -> FMOD_RESULT;
8969}
8970extern "C" {
8971 #[must_use]
8972 pub fn FMOD_Geometry_GetPolygonAttributes(
8973 geometry: *mut FMOD_GEOMETRY,
8974 index: ::std::os::raw::c_int,
8975 directocclusion: *mut f32,
8976 reverbocclusion: *mut f32,
8977 doublesided: *mut FMOD_BOOL,
8978 ) -> FMOD_RESULT;
8979}
8980extern "C" {
8981 #[must_use]
8982 pub fn FMOD_Geometry_SetActive(geometry: *mut FMOD_GEOMETRY, active: FMOD_BOOL) -> FMOD_RESULT;
8983}
8984extern "C" {
8985 #[must_use]
8986 pub fn FMOD_Geometry_GetActive(
8987 geometry: *mut FMOD_GEOMETRY,
8988 active: *mut FMOD_BOOL,
8989 ) -> FMOD_RESULT;
8990}
8991extern "C" {
8992 #[must_use]
8993 pub fn FMOD_Geometry_SetRotation(
8994 geometry: *mut FMOD_GEOMETRY,
8995 forward: *const FMOD_VECTOR,
8996 up: *const FMOD_VECTOR,
8997 ) -> FMOD_RESULT;
8998}
8999extern "C" {
9000 #[must_use]
9001 pub fn FMOD_Geometry_GetRotation(
9002 geometry: *mut FMOD_GEOMETRY,
9003 forward: *mut FMOD_VECTOR,
9004 up: *mut FMOD_VECTOR,
9005 ) -> FMOD_RESULT;
9006}
9007extern "C" {
9008 #[must_use]
9009 pub fn FMOD_Geometry_SetPosition(
9010 geometry: *mut FMOD_GEOMETRY,
9011 position: *const FMOD_VECTOR,
9012 ) -> FMOD_RESULT;
9013}
9014extern "C" {
9015 #[must_use]
9016 pub fn FMOD_Geometry_GetPosition(
9017 geometry: *mut FMOD_GEOMETRY,
9018 position: *mut FMOD_VECTOR,
9019 ) -> FMOD_RESULT;
9020}
9021extern "C" {
9022 #[must_use]
9023 pub fn FMOD_Geometry_SetScale(
9024 geometry: *mut FMOD_GEOMETRY,
9025 scale: *const FMOD_VECTOR,
9026 ) -> FMOD_RESULT;
9027}
9028extern "C" {
9029 #[must_use]
9030 pub fn FMOD_Geometry_GetScale(
9031 geometry: *mut FMOD_GEOMETRY,
9032 scale: *mut FMOD_VECTOR,
9033 ) -> FMOD_RESULT;
9034}
9035extern "C" {
9036 #[must_use]
9037 pub fn FMOD_Geometry_Save(
9038 geometry: *mut FMOD_GEOMETRY,
9039 data: *mut ::std::os::raw::c_void,
9040 datasize: *mut ::std::os::raw::c_int,
9041 ) -> FMOD_RESULT;
9042}
9043extern "C" {
9044 #[must_use]
9045 pub fn FMOD_Geometry_SetUserData(
9046 geometry: *mut FMOD_GEOMETRY,
9047 userdata: *mut ::std::os::raw::c_void,
9048 ) -> FMOD_RESULT;
9049}
9050extern "C" {
9051 #[must_use]
9052 pub fn FMOD_Geometry_GetUserData(
9053 geometry: *mut FMOD_GEOMETRY,
9054 userdata: *mut *mut ::std::os::raw::c_void,
9055 ) -> FMOD_RESULT;
9056}
9057extern "C" {
9058 #[must_use]
9059 pub fn FMOD_Reverb3D_Release(reverb3d: *mut FMOD_REVERB3D) -> FMOD_RESULT;
9060}
9061extern "C" {
9062 #[must_use]
9063 pub fn FMOD_Reverb3D_Set3DAttributes(
9064 reverb3d: *mut FMOD_REVERB3D,
9065 position: *const FMOD_VECTOR,
9066 mindistance: f32,
9067 maxdistance: f32,
9068 ) -> FMOD_RESULT;
9069}
9070extern "C" {
9071 #[must_use]
9072 pub fn FMOD_Reverb3D_Get3DAttributes(
9073 reverb3d: *mut FMOD_REVERB3D,
9074 position: *mut FMOD_VECTOR,
9075 mindistance: *mut f32,
9076 maxdistance: *mut f32,
9077 ) -> FMOD_RESULT;
9078}
9079extern "C" {
9080 #[must_use]
9081 pub fn FMOD_Reverb3D_SetProperties(
9082 reverb3d: *mut FMOD_REVERB3D,
9083 properties: *const FMOD_REVERB_PROPERTIES,
9084 ) -> FMOD_RESULT;
9085}
9086extern "C" {
9087 #[must_use]
9088 pub fn FMOD_Reverb3D_GetProperties(
9089 reverb3d: *mut FMOD_REVERB3D,
9090 properties: *mut FMOD_REVERB_PROPERTIES,
9091 ) -> FMOD_RESULT;
9092}
9093extern "C" {
9094 #[must_use]
9095 pub fn FMOD_Reverb3D_SetActive(reverb3d: *mut FMOD_REVERB3D, active: FMOD_BOOL) -> FMOD_RESULT;
9096}
9097extern "C" {
9098 #[must_use]
9099 pub fn FMOD_Reverb3D_GetActive(
9100 reverb3d: *mut FMOD_REVERB3D,
9101 active: *mut FMOD_BOOL,
9102 ) -> FMOD_RESULT;
9103}
9104extern "C" {
9105 #[must_use]
9106 pub fn FMOD_Reverb3D_SetUserData(
9107 reverb3d: *mut FMOD_REVERB3D,
9108 userdata: *mut ::std::os::raw::c_void,
9109 ) -> FMOD_RESULT;
9110}
9111extern "C" {
9112 #[must_use]
9113 pub fn FMOD_Reverb3D_GetUserData(
9114 reverb3d: *mut FMOD_REVERB3D,
9115 userdata: *mut *mut ::std::os::raw::c_void,
9116 ) -> FMOD_RESULT;
9117}
9118extern "C" {
9119 pub fn FMOD_Channel_CastToControl(channel: *mut FMOD_CHANNEL) -> *mut FMOD_CHANNELCONTROL;
9120}
9121extern "C" {
9122 pub fn FMOD_ChannelGroup_CastToControl(
9123 group: *mut FMOD_CHANNELGROUP,
9124 ) -> *mut FMOD_CHANNELCONTROL;
9125}
9126extern "C" {
9127 #[must_use]
9128 pub fn FMOD_ChannelControl_GetSystemObject(
9129 channelcontrol: *mut FMOD_CHANNELCONTROL,
9130 system: *mut *mut FMOD_SYSTEM,
9131 ) -> FMOD_RESULT;
9132}
9133extern "C" {
9134 #[must_use]
9135 pub fn FMOD_ChannelControl_Stop(channelcontrol: *mut FMOD_CHANNELCONTROL) -> FMOD_RESULT;
9136}
9137extern "C" {
9138 #[must_use]
9139 pub fn FMOD_ChannelControl_SetPaused(
9140 channelcontrol: *mut FMOD_CHANNELCONTROL,
9141 paused: bool,
9142 ) -> FMOD_RESULT;
9143}
9144extern "C" {
9145 #[must_use]
9146 pub fn FMOD_ChannelControl_GetPaused(
9147 channelcontrol: *mut FMOD_CHANNELCONTROL,
9148 paused: *mut bool,
9149 ) -> FMOD_RESULT;
9150}
9151extern "C" {
9152 #[must_use]
9153 pub fn FMOD_ChannelControl_SetVolume(
9154 channelcontrol: *mut FMOD_CHANNELCONTROL,
9155 volume: f32,
9156 ) -> FMOD_RESULT;
9157}
9158extern "C" {
9159 #[must_use]
9160 pub fn FMOD_ChannelControl_GetVolume(
9161 channelcontrol: *mut FMOD_CHANNELCONTROL,
9162 volume: *mut f32,
9163 ) -> FMOD_RESULT;
9164}
9165extern "C" {
9166 #[must_use]
9167 pub fn FMOD_ChannelControl_SetVolumeRamp(
9168 channelcontrol: *mut FMOD_CHANNELCONTROL,
9169 ramp: bool,
9170 ) -> FMOD_RESULT;
9171}
9172extern "C" {
9173 #[must_use]
9174 pub fn FMOD_ChannelControl_GetVolumeRamp(
9175 channelcontrol: *mut FMOD_CHANNELCONTROL,
9176 ramp: *mut bool,
9177 ) -> FMOD_RESULT;
9178}
9179extern "C" {
9180 #[must_use]
9181 pub fn FMOD_ChannelControl_GetAudibility(
9182 channelcontrol: *mut FMOD_CHANNELCONTROL,
9183 audibility: *mut f32,
9184 ) -> FMOD_RESULT;
9185}
9186extern "C" {
9187 #[must_use]
9188 pub fn FMOD_ChannelControl_SetPitch(
9189 channelcontrol: *mut FMOD_CHANNELCONTROL,
9190 pitch: f32,
9191 ) -> FMOD_RESULT;
9192}
9193extern "C" {
9194 #[must_use]
9195 pub fn FMOD_ChannelControl_GetPitch(
9196 channelcontrol: *mut FMOD_CHANNELCONTROL,
9197 pitch: *mut f32,
9198 ) -> FMOD_RESULT;
9199}
9200extern "C" {
9201 #[must_use]
9202 pub fn FMOD_ChannelControl_SetMute(
9203 channelcontrol: *mut FMOD_CHANNELCONTROL,
9204 mute: bool,
9205 ) -> FMOD_RESULT;
9206}
9207extern "C" {
9208 #[must_use]
9209 pub fn FMOD_ChannelControl_GetMute(
9210 channelcontrol: *mut FMOD_CHANNELCONTROL,
9211 mute: *mut bool,
9212 ) -> FMOD_RESULT;
9213}
9214extern "C" {
9215 #[must_use]
9216 pub fn FMOD_ChannelControl_SetReverbProperties(
9217 channelcontrol: *mut FMOD_CHANNELCONTROL,
9218 instance: ::std::os::raw::c_int,
9219 wet: f32,
9220 ) -> FMOD_RESULT;
9221}
9222extern "C" {
9223 #[must_use]
9224 pub fn FMOD_ChannelControl_GetReverbProperties(
9225 channelcontrol: *mut FMOD_CHANNELCONTROL,
9226 instance: ::std::os::raw::c_int,
9227 wet: *mut f32,
9228 ) -> FMOD_RESULT;
9229}
9230extern "C" {
9231 #[must_use]
9232 pub fn FMOD_ChannelControl_SetLowPassGain(
9233 channelcontrol: *mut FMOD_CHANNELCONTROL,
9234 gain: f32,
9235 ) -> FMOD_RESULT;
9236}
9237extern "C" {
9238 #[must_use]
9239 pub fn FMOD_ChannelControl_GetLowPassGain(
9240 channelcontrol: *mut FMOD_CHANNELCONTROL,
9241 gain: *mut f32,
9242 ) -> FMOD_RESULT;
9243}
9244extern "C" {
9245 #[must_use]
9246 pub fn FMOD_ChannelControl_SetMode(
9247 channelcontrol: *mut FMOD_CHANNELCONTROL,
9248 mode: FMOD_MODE,
9249 ) -> FMOD_RESULT;
9250}
9251extern "C" {
9252 #[must_use]
9253 pub fn FMOD_ChannelControl_GetMode(
9254 channelcontrol: *mut FMOD_CHANNELCONTROL,
9255 mode: *mut FMOD_MODE,
9256 ) -> FMOD_RESULT;
9257}
9258extern "C" {
9259 #[must_use]
9260 pub fn FMOD_ChannelControl_SetCallback(
9261 channelcontrol: *mut FMOD_CHANNELCONTROL,
9262 callback: FMOD_CHANNELCONTROL_CALLBACK,
9263 ) -> FMOD_RESULT;
9264}
9265extern "C" {
9266 #[must_use]
9267 pub fn FMOD_ChannelControl_IsPlaying(
9268 channelcontrol: *mut FMOD_CHANNELCONTROL,
9269 isplaying: *mut bool,
9270 ) -> FMOD_RESULT;
9271}
9272extern "C" {
9273 #[must_use]
9274 pub fn FMOD_ChannelControl_SetPan(
9275 channelcontrol: *mut FMOD_CHANNELCONTROL,
9276 pan: f32,
9277 ) -> FMOD_RESULT;
9278}
9279extern "C" {
9280 #[must_use]
9281 pub fn FMOD_ChannelControl_SetMixLevelsOutput(
9282 channelcontrol: *mut FMOD_CHANNELCONTROL,
9283 frontleft: f32,
9284 frontright: f32,
9285 center: f32,
9286 lfe: f32,
9287 surroundleft: f32,
9288 surroundright: f32,
9289 backleft: f32,
9290 backright: f32,
9291 ) -> FMOD_RESULT;
9292}
9293extern "C" {
9294 #[must_use]
9295 pub fn FMOD_ChannelControl_SetMixLevelsInput(
9296 channelcontrol: *mut FMOD_CHANNELCONTROL,
9297 levels: *mut f32,
9298 numlevels: ::std::os::raw::c_int,
9299 ) -> FMOD_RESULT;
9300}
9301extern "C" {
9302 #[must_use]
9303 pub fn FMOD_ChannelControl_SetMixMatrix(
9304 channelcontrol: *mut FMOD_CHANNELCONTROL,
9305 matrix: *mut f32,
9306 outchannels: ::std::os::raw::c_int,
9307 inchannels: ::std::os::raw::c_int,
9308 inchannel_hop: ::std::os::raw::c_int,
9309 ) -> FMOD_RESULT;
9310}
9311extern "C" {
9312 #[must_use]
9313 pub fn FMOD_ChannelControl_GetMixMatrix(
9314 channelcontrol: *mut FMOD_CHANNELCONTROL,
9315 matrix: *mut f32,
9316 outchannels: *mut ::std::os::raw::c_int,
9317 inchannels: *mut ::std::os::raw::c_int,
9318 inchannel_hop: ::std::os::raw::c_int,
9319 ) -> FMOD_RESULT;
9320}
9321extern "C" {
9322 #[must_use]
9323 pub fn FMOD_ChannelControl_GetDSPClock(
9324 channelcontrol: *mut FMOD_CHANNELCONTROL,
9325 dspclock: *mut ::std::os::raw::c_ulonglong,
9326 parentclock: *mut ::std::os::raw::c_ulonglong,
9327 ) -> FMOD_RESULT;
9328}
9329extern "C" {
9330 #[must_use]
9331 pub fn FMOD_ChannelControl_SetDelay(
9332 channelcontrol: *mut FMOD_CHANNELCONTROL,
9333 dspclock_start: ::std::os::raw::c_ulonglong,
9334 dspclock_end: ::std::os::raw::c_ulonglong,
9335 stopchannels: bool,
9336 ) -> FMOD_RESULT;
9337}
9338extern "C" {
9339 #[must_use]
9340 pub fn FMOD_ChannelControl_GetDelay(
9341 channelcontrol: *mut FMOD_CHANNELCONTROL,
9342 dspclock_start: *mut ::std::os::raw::c_ulonglong,
9343 dspclock_end: *mut ::std::os::raw::c_ulonglong,
9344 stopchannels: *mut bool,
9345 ) -> FMOD_RESULT;
9346}
9347extern "C" {
9348 #[must_use]
9349 pub fn FMOD_ChannelControl_AddFadePoint(
9350 channelcontrol: *mut FMOD_CHANNELCONTROL,
9351 dspclock: ::std::os::raw::c_ulonglong,
9352 volume: f32,
9353 ) -> FMOD_RESULT;
9354}
9355extern "C" {
9356 #[must_use]
9357 pub fn FMOD_ChannelControl_SetFadePointRamp(
9358 channelcontrol: *mut FMOD_CHANNELCONTROL,
9359 dspclock: ::std::os::raw::c_ulonglong,
9360 volume: f32,
9361 ) -> FMOD_RESULT;
9362}
9363extern "C" {
9364 #[must_use]
9365 pub fn FMOD_ChannelControl_RemoveFadePoints(
9366 channelcontrol: *mut FMOD_CHANNELCONTROL,
9367 dspclock_start: ::std::os::raw::c_ulonglong,
9368 dspclock_end: ::std::os::raw::c_ulonglong,
9369 ) -> FMOD_RESULT;
9370}
9371extern "C" {
9372 #[must_use]
9373 pub fn FMOD_ChannelControl_GetFadePoints(
9374 channelcontrol: *mut FMOD_CHANNELCONTROL,
9375 numpoints: *mut ::std::os::raw::c_uint,
9376 point_dspclock: *mut ::std::os::raw::c_ulonglong,
9377 point_volume: *mut f32,
9378 ) -> FMOD_RESULT;
9379}
9380extern "C" {
9381 #[must_use]
9382 pub fn FMOD_ChannelControl_GetDSP(
9383 channelcontrol: *mut FMOD_CHANNELCONTROL,
9384 index: ::std::os::raw::c_int,
9385 dsp: *mut *mut FMOD_DSP,
9386 ) -> FMOD_RESULT;
9387}
9388extern "C" {
9389 #[must_use]
9390 pub fn FMOD_ChannelControl_AddDSP(
9391 channelcontrol: *mut FMOD_CHANNELCONTROL,
9392 index: ::std::os::raw::c_int,
9393 dsp: *mut FMOD_DSP,
9394 ) -> FMOD_RESULT;
9395}
9396extern "C" {
9397 #[must_use]
9398 pub fn FMOD_ChannelControl_RemoveDSP(
9399 channelcontrol: *mut FMOD_CHANNELCONTROL,
9400 dsp: *mut FMOD_DSP,
9401 ) -> FMOD_RESULT;
9402}
9403extern "C" {
9404 #[must_use]
9405 pub fn FMOD_ChannelControl_GetNumDSPs(
9406 channelcontrol: *mut FMOD_CHANNELCONTROL,
9407 numdsps: *mut ::std::os::raw::c_int,
9408 ) -> FMOD_RESULT;
9409}
9410extern "C" {
9411 #[must_use]
9412 pub fn FMOD_ChannelControl_SetDSPIndex(
9413 channelcontrol: *mut FMOD_CHANNELCONTROL,
9414 dsp: *mut FMOD_DSP,
9415 index: ::std::os::raw::c_int,
9416 ) -> FMOD_RESULT;
9417}
9418extern "C" {
9419 #[must_use]
9420 pub fn FMOD_ChannelControl_GetDSPIndex(
9421 channelcontrol: *mut FMOD_CHANNELCONTROL,
9422 dsp: *mut FMOD_DSP,
9423 index: *mut ::std::os::raw::c_int,
9424 ) -> FMOD_RESULT;
9425}
9426extern "C" {
9427 #[must_use]
9428 pub fn FMOD_ChannelControl_Set3DAttributes(
9429 channelcontrol: *mut FMOD_CHANNELCONTROL,
9430 pos: *const FMOD_VECTOR,
9431 vel: *const FMOD_VECTOR,
9432 ) -> FMOD_RESULT;
9433}
9434extern "C" {
9435 #[must_use]
9436 pub fn FMOD_ChannelControl_Get3DAttributes(
9437 channelcontrol: *mut FMOD_CHANNELCONTROL,
9438 pos: *mut FMOD_VECTOR,
9439 vel: *mut FMOD_VECTOR,
9440 ) -> FMOD_RESULT;
9441}
9442extern "C" {
9443 #[must_use]
9444 pub fn FMOD_ChannelControl_Set3DMinMaxDistance(
9445 channelcontrol: *mut FMOD_CHANNELCONTROL,
9446 mindistance: f32,
9447 maxdistance: f32,
9448 ) -> FMOD_RESULT;
9449}
9450extern "C" {
9451 #[must_use]
9452 pub fn FMOD_ChannelControl_Get3DMinMaxDistance(
9453 channelcontrol: *mut FMOD_CHANNELCONTROL,
9454 mindistance: *mut f32,
9455 maxdistance: *mut f32,
9456 ) -> FMOD_RESULT;
9457}
9458extern "C" {
9459 #[must_use]
9460 pub fn FMOD_ChannelControl_Set3DConeSettings(
9461 channelcontrol: *mut FMOD_CHANNELCONTROL,
9462 insideconeangle: f32,
9463 outsideconeangle: f32,
9464 outsidevolume: f32,
9465 ) -> FMOD_RESULT;
9466}
9467extern "C" {
9468 #[must_use]
9469 pub fn FMOD_ChannelControl_Get3DConeSettings(
9470 channelcontrol: *mut FMOD_CHANNELCONTROL,
9471 insideconeangle: *mut f32,
9472 outsideconeangle: *mut f32,
9473 outsidevolume: *mut f32,
9474 ) -> FMOD_RESULT;
9475}
9476extern "C" {
9477 #[must_use]
9478 pub fn FMOD_ChannelControl_Set3DConeOrientation(
9479 channelcontrol: *mut FMOD_CHANNELCONTROL,
9480 orientation: *mut FMOD_VECTOR,
9481 ) -> FMOD_RESULT;
9482}
9483extern "C" {
9484 #[must_use]
9485 pub fn FMOD_ChannelControl_Get3DConeOrientation(
9486 channelcontrol: *mut FMOD_CHANNELCONTROL,
9487 orientation: *mut FMOD_VECTOR,
9488 ) -> FMOD_RESULT;
9489}
9490extern "C" {
9491 #[must_use]
9492 pub fn FMOD_ChannelControl_Set3DCustomRolloff(
9493 channelcontrol: *mut FMOD_CHANNELCONTROL,
9494 points: *mut FMOD_VECTOR,
9495 numpoints: ::std::os::raw::c_int,
9496 ) -> FMOD_RESULT;
9497}
9498extern "C" {
9499 #[must_use]
9500 pub fn FMOD_ChannelControl_Get3DCustomRolloff(
9501 channelcontrol: *mut FMOD_CHANNELCONTROL,
9502 points: *mut *mut FMOD_VECTOR,
9503 numpoints: *mut ::std::os::raw::c_int,
9504 ) -> FMOD_RESULT;
9505}
9506extern "C" {
9507 #[must_use]
9508 pub fn FMOD_ChannelControl_Set3DOcclusion(
9509 channelcontrol: *mut FMOD_CHANNELCONTROL,
9510 directocclusion: f32,
9511 reverbocclusion: f32,
9512 ) -> FMOD_RESULT;
9513}
9514extern "C" {
9515 #[must_use]
9516 pub fn FMOD_ChannelControl_Get3DOcclusion(
9517 channelcontrol: *mut FMOD_CHANNELCONTROL,
9518 directocclusion: *mut f32,
9519 reverbocclusion: *mut f32,
9520 ) -> FMOD_RESULT;
9521}
9522extern "C" {
9523 #[must_use]
9524 pub fn FMOD_ChannelControl_Set3DSpread(
9525 channelcontrol: *mut FMOD_CHANNELCONTROL,
9526 angle: f32,
9527 ) -> FMOD_RESULT;
9528}
9529extern "C" {
9530 #[must_use]
9531 pub fn FMOD_ChannelControl_Get3DSpread(
9532 channelcontrol: *mut FMOD_CHANNELCONTROL,
9533 angle: *mut f32,
9534 ) -> FMOD_RESULT;
9535}
9536extern "C" {
9537 #[must_use]
9538 pub fn FMOD_ChannelControl_Set3DLevel(
9539 channelcontrol: *mut FMOD_CHANNELCONTROL,
9540 level: f32,
9541 ) -> FMOD_RESULT;
9542}
9543extern "C" {
9544 #[must_use]
9545 pub fn FMOD_ChannelControl_Get3DLevel(
9546 channelcontrol: *mut FMOD_CHANNELCONTROL,
9547 level: *mut f32,
9548 ) -> FMOD_RESULT;
9549}
9550extern "C" {
9551 #[must_use]
9552 pub fn FMOD_ChannelControl_Set3DDopplerLevel(
9553 channelcontrol: *mut FMOD_CHANNELCONTROL,
9554 level: f32,
9555 ) -> FMOD_RESULT;
9556}
9557extern "C" {
9558 #[must_use]
9559 pub fn FMOD_ChannelControl_Get3DDopplerLevel(
9560 channelcontrol: *mut FMOD_CHANNELCONTROL,
9561 level: *mut f32,
9562 ) -> FMOD_RESULT;
9563}
9564extern "C" {
9565 #[must_use]
9566 pub fn FMOD_ChannelControl_Set3DDistanceFilter(
9567 channelcontrol: *mut FMOD_CHANNELCONTROL,
9568 custom: bool,
9569 customLevel: f32,
9570 centerFreq: f32,
9571 ) -> FMOD_RESULT;
9572}
9573extern "C" {
9574 #[must_use]
9575 pub fn FMOD_ChannelControl_Get3DDistanceFilter(
9576 channelcontrol: *mut FMOD_CHANNELCONTROL,
9577 custom: *mut bool,
9578 customLevel: *mut f32,
9579 centerFreq: *mut f32,
9580 ) -> FMOD_RESULT;
9581}
9582extern "C" {
9583 #[must_use]
9584 pub fn FMOD_ChannelControl_SetUserData(
9585 channelcontrol: *mut FMOD_CHANNELCONTROL,
9586 userdata: *mut ::std::os::raw::c_void,
9587 ) -> FMOD_RESULT;
9588}
9589extern "C" {
9590 #[must_use]
9591 pub fn FMOD_ChannelControl_GetUserData(
9592 channelcontrol: *mut FMOD_CHANNELCONTROL,
9593 userdata: *mut *mut ::std::os::raw::c_void,
9594 ) -> FMOD_RESULT;
9595}
9596#[repr(C)]
9597#[derive(Debug, Copy, Clone)]
9598pub struct FMOD_STUDIO_SYSTEM {
9599 _unused: [u8; 0],
9600}
9601#[repr(C)]
9602#[derive(Debug, Copy, Clone)]
9603pub struct FMOD_STUDIO_EVENTDESCRIPTION {
9604 _unused: [u8; 0],
9605}
9606#[repr(C)]
9607#[derive(Debug, Copy, Clone)]
9608pub struct FMOD_STUDIO_EVENTINSTANCE {
9609 _unused: [u8; 0],
9610}
9611#[repr(C)]
9612#[derive(Debug, Copy, Clone)]
9613pub struct FMOD_STUDIO_BUS {
9614 _unused: [u8; 0],
9615}
9616#[repr(C)]
9617#[derive(Debug, Copy, Clone)]
9618pub struct FMOD_STUDIO_VCA {
9619 _unused: [u8; 0],
9620}
9621#[repr(C)]
9622#[derive(Debug, Copy, Clone)]
9623pub struct FMOD_STUDIO_BANK {
9624 _unused: [u8; 0],
9625}
9626#[repr(C)]
9627#[derive(Debug, Copy, Clone)]
9628pub struct FMOD_STUDIO_COMMANDREPLAY {
9629 _unused: [u8; 0],
9630}
9631pub type FMOD_STUDIO_INITFLAGS = ::std::os::raw::c_uint;
9632pub type FMOD_STUDIO_PARAMETER_FLAGS = ::std::os::raw::c_uint;
9633pub type FMOD_STUDIO_SYSTEM_CALLBACK_TYPE = ::std::os::raw::c_uint;
9634pub type FMOD_STUDIO_EVENT_CALLBACK_TYPE = ::std::os::raw::c_uint;
9635pub type FMOD_STUDIO_LOAD_BANK_FLAGS = ::std::os::raw::c_uint;
9636pub type FMOD_STUDIO_COMMANDCAPTURE_FLAGS = ::std::os::raw::c_uint;
9637pub type FMOD_STUDIO_COMMANDREPLAY_FLAGS = ::std::os::raw::c_uint;
9638pub const FMOD_STUDIO_LOADING_STATE_UNLOADING: FMOD_STUDIO_LOADING_STATE = 0;
9639pub const FMOD_STUDIO_LOADING_STATE_UNLOADED: FMOD_STUDIO_LOADING_STATE = 1;
9640pub const FMOD_STUDIO_LOADING_STATE_LOADING: FMOD_STUDIO_LOADING_STATE = 2;
9641pub const FMOD_STUDIO_LOADING_STATE_LOADED: FMOD_STUDIO_LOADING_STATE = 3;
9642pub const FMOD_STUDIO_LOADING_STATE_ERROR: FMOD_STUDIO_LOADING_STATE = 4;
9643pub const FMOD_STUDIO_LOADING_STATE_FORCEINT: FMOD_STUDIO_LOADING_STATE = 65536;
9644pub type FMOD_STUDIO_LOADING_STATE = ::std::os::raw::c_uint;
9645pub const FMOD_STUDIO_LOAD_MEMORY: FMOD_STUDIO_LOAD_MEMORY_MODE = 0;
9646pub const FMOD_STUDIO_LOAD_MEMORY_POINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 1;
9647pub const FMOD_STUDIO_LOAD_MEMORY_FORCEINT: FMOD_STUDIO_LOAD_MEMORY_MODE = 65536;
9648pub type FMOD_STUDIO_LOAD_MEMORY_MODE = ::std::os::raw::c_uint;
9649pub const FMOD_STUDIO_PARAMETER_GAME_CONTROLLED: FMOD_STUDIO_PARAMETER_TYPE = 0;
9650pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE: FMOD_STUDIO_PARAMETER_TYPE = 1;
9651pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_CONE_ANGLE: FMOD_STUDIO_PARAMETER_TYPE = 2;
9652pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_EVENT_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 3;
9653pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DIRECTION: FMOD_STUDIO_PARAMETER_TYPE = 4;
9654pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_ELEVATION: FMOD_STUDIO_PARAMETER_TYPE = 5;
9655pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_LISTENER_ORIENTATION: FMOD_STUDIO_PARAMETER_TYPE = 6;
9656pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED: FMOD_STUDIO_PARAMETER_TYPE = 7;
9657pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_SPEED_ABSOLUTE: FMOD_STUDIO_PARAMETER_TYPE = 8;
9658pub const FMOD_STUDIO_PARAMETER_AUTOMATIC_DISTANCE_NORMALIZED: FMOD_STUDIO_PARAMETER_TYPE = 9;
9659pub const FMOD_STUDIO_PARAMETER_MAX: FMOD_STUDIO_PARAMETER_TYPE = 10;
9660pub const FMOD_STUDIO_PARAMETER_FORCEINT: FMOD_STUDIO_PARAMETER_TYPE = 65536;
9661pub type FMOD_STUDIO_PARAMETER_TYPE = ::std::os::raw::c_uint;
9662pub const FMOD_STUDIO_USER_PROPERTY_TYPE_INTEGER: FMOD_STUDIO_USER_PROPERTY_TYPE = 0;
9663pub const FMOD_STUDIO_USER_PROPERTY_TYPE_BOOLEAN: FMOD_STUDIO_USER_PROPERTY_TYPE = 1;
9664pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FLOAT: FMOD_STUDIO_USER_PROPERTY_TYPE = 2;
9665pub const FMOD_STUDIO_USER_PROPERTY_TYPE_STRING: FMOD_STUDIO_USER_PROPERTY_TYPE = 3;
9666pub const FMOD_STUDIO_USER_PROPERTY_TYPE_FORCEINT: FMOD_STUDIO_USER_PROPERTY_TYPE = 65536;
9667pub type FMOD_STUDIO_USER_PROPERTY_TYPE = ::std::os::raw::c_uint;
9668pub const FMOD_STUDIO_EVENT_PROPERTY_CHANNELPRIORITY: FMOD_STUDIO_EVENT_PROPERTY = 0;
9669pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_DELAY: FMOD_STUDIO_EVENT_PROPERTY = 1;
9670pub const FMOD_STUDIO_EVENT_PROPERTY_SCHEDULE_LOOKAHEAD: FMOD_STUDIO_EVENT_PROPERTY = 2;
9671pub const FMOD_STUDIO_EVENT_PROPERTY_MINIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 3;
9672pub const FMOD_STUDIO_EVENT_PROPERTY_MAXIMUM_DISTANCE: FMOD_STUDIO_EVENT_PROPERTY = 4;
9673pub const FMOD_STUDIO_EVENT_PROPERTY_COOLDOWN: FMOD_STUDIO_EVENT_PROPERTY = 5;
9674pub const FMOD_STUDIO_EVENT_PROPERTY_MAX: FMOD_STUDIO_EVENT_PROPERTY = 6;
9675pub const FMOD_STUDIO_EVENT_PROPERTY_FORCEINT: FMOD_STUDIO_EVENT_PROPERTY = 65536;
9676pub type FMOD_STUDIO_EVENT_PROPERTY = ::std::os::raw::c_uint;
9677pub const FMOD_STUDIO_PLAYBACK_PLAYING: FMOD_STUDIO_PLAYBACK_STATE = 0;
9678pub const FMOD_STUDIO_PLAYBACK_SUSTAINING: FMOD_STUDIO_PLAYBACK_STATE = 1;
9679pub const FMOD_STUDIO_PLAYBACK_STOPPED: FMOD_STUDIO_PLAYBACK_STATE = 2;
9680pub const FMOD_STUDIO_PLAYBACK_STARTING: FMOD_STUDIO_PLAYBACK_STATE = 3;
9681pub const FMOD_STUDIO_PLAYBACK_STOPPING: FMOD_STUDIO_PLAYBACK_STATE = 4;
9682pub const FMOD_STUDIO_PLAYBACK_FORCEINT: FMOD_STUDIO_PLAYBACK_STATE = 65536;
9683pub type FMOD_STUDIO_PLAYBACK_STATE = ::std::os::raw::c_uint;
9684pub const FMOD_STUDIO_STOP_ALLOWFADEOUT: FMOD_STUDIO_STOP_MODE = 0;
9685pub const FMOD_STUDIO_STOP_IMMEDIATE: FMOD_STUDIO_STOP_MODE = 1;
9686pub const FMOD_STUDIO_STOP_FORCEINT: FMOD_STUDIO_STOP_MODE = 65536;
9687pub type FMOD_STUDIO_STOP_MODE = ::std::os::raw::c_uint;
9688pub const FMOD_STUDIO_INSTANCETYPE_NONE: FMOD_STUDIO_INSTANCETYPE = 0;
9689pub const FMOD_STUDIO_INSTANCETYPE_SYSTEM: FMOD_STUDIO_INSTANCETYPE = 1;
9690pub const FMOD_STUDIO_INSTANCETYPE_EVENTDESCRIPTION: FMOD_STUDIO_INSTANCETYPE = 2;
9691pub const FMOD_STUDIO_INSTANCETYPE_EVENTINSTANCE: FMOD_STUDIO_INSTANCETYPE = 3;
9692pub const FMOD_STUDIO_INSTANCETYPE_PARAMETERINSTANCE: FMOD_STUDIO_INSTANCETYPE = 4;
9693pub const FMOD_STUDIO_INSTANCETYPE_BUS: FMOD_STUDIO_INSTANCETYPE = 5;
9694pub const FMOD_STUDIO_INSTANCETYPE_VCA: FMOD_STUDIO_INSTANCETYPE = 6;
9695pub const FMOD_STUDIO_INSTANCETYPE_BANK: FMOD_STUDIO_INSTANCETYPE = 7;
9696pub const FMOD_STUDIO_INSTANCETYPE_COMMANDREPLAY: FMOD_STUDIO_INSTANCETYPE = 8;
9697pub const FMOD_STUDIO_INSTANCETYPE_FORCEINT: FMOD_STUDIO_INSTANCETYPE = 65536;
9698pub type FMOD_STUDIO_INSTANCETYPE = ::std::os::raw::c_uint;
9699#[repr(C)]
9700#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
9701pub struct FMOD_STUDIO_BANK_INFO {
9702 pub size: ::std::os::raw::c_int,
9703 pub userdata: *mut ::std::os::raw::c_void,
9704 pub userdatalength: ::std::os::raw::c_int,
9705 pub opencallback: FMOD_FILE_OPEN_CALLBACK,
9706 pub closecallback: FMOD_FILE_CLOSE_CALLBACK,
9707 pub readcallback: FMOD_FILE_READ_CALLBACK,
9708 pub seekcallback: FMOD_FILE_SEEK_CALLBACK,
9709}
9710#[test]
9711fn bindgen_test_layout_FMOD_STUDIO_BANK_INFO() {
9712 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_BANK_INFO> =
9713 ::std::mem::MaybeUninit::uninit();
9714 let ptr = UNINIT.as_ptr();
9715 assert_eq!(
9716 ::std::mem::size_of::<FMOD_STUDIO_BANK_INFO>(),
9717 56usize,
9718 concat!("Size of: ", stringify!(FMOD_STUDIO_BANK_INFO))
9719 );
9720 assert_eq!(
9721 ::std::mem::align_of::<FMOD_STUDIO_BANK_INFO>(),
9722 8usize,
9723 concat!("Alignment of ", stringify!(FMOD_STUDIO_BANK_INFO))
9724 );
9725 assert_eq!(
9726 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
9727 0usize,
9728 concat!(
9729 "Offset of field: ",
9730 stringify!(FMOD_STUDIO_BANK_INFO),
9731 "::",
9732 stringify!(size)
9733 )
9734 );
9735 assert_eq!(
9736 unsafe { ::std::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
9737 8usize,
9738 concat!(
9739 "Offset of field: ",
9740 stringify!(FMOD_STUDIO_BANK_INFO),
9741 "::",
9742 stringify!(userdata)
9743 )
9744 );
9745 assert_eq!(
9746 unsafe { ::std::ptr::addr_of!((*ptr).userdatalength) as usize - ptr as usize },
9747 16usize,
9748 concat!(
9749 "Offset of field: ",
9750 stringify!(FMOD_STUDIO_BANK_INFO),
9751 "::",
9752 stringify!(userdatalength)
9753 )
9754 );
9755 assert_eq!(
9756 unsafe { ::std::ptr::addr_of!((*ptr).opencallback) as usize - ptr as usize },
9757 24usize,
9758 concat!(
9759 "Offset of field: ",
9760 stringify!(FMOD_STUDIO_BANK_INFO),
9761 "::",
9762 stringify!(opencallback)
9763 )
9764 );
9765 assert_eq!(
9766 unsafe { ::std::ptr::addr_of!((*ptr).closecallback) as usize - ptr as usize },
9767 32usize,
9768 concat!(
9769 "Offset of field: ",
9770 stringify!(FMOD_STUDIO_BANK_INFO),
9771 "::",
9772 stringify!(closecallback)
9773 )
9774 );
9775 assert_eq!(
9776 unsafe { ::std::ptr::addr_of!((*ptr).readcallback) as usize - ptr as usize },
9777 40usize,
9778 concat!(
9779 "Offset of field: ",
9780 stringify!(FMOD_STUDIO_BANK_INFO),
9781 "::",
9782 stringify!(readcallback)
9783 )
9784 );
9785 assert_eq!(
9786 unsafe { ::std::ptr::addr_of!((*ptr).seekcallback) as usize - ptr as usize },
9787 48usize,
9788 concat!(
9789 "Offset of field: ",
9790 stringify!(FMOD_STUDIO_BANK_INFO),
9791 "::",
9792 stringify!(seekcallback)
9793 )
9794 );
9795}
9796impl Default for FMOD_STUDIO_BANK_INFO {
9797 fn default() -> Self {
9798 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9799 unsafe {
9800 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9801 s.assume_init()
9802 }
9803 }
9804}
9805#[repr(C)]
9806#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
9807pub struct FMOD_STUDIO_PARAMETER_ID {
9808 pub data1: ::std::os::raw::c_uint,
9809 pub data2: ::std::os::raw::c_uint,
9810}
9811#[test]
9812fn bindgen_test_layout_FMOD_STUDIO_PARAMETER_ID() {
9813 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_PARAMETER_ID> =
9814 ::std::mem::MaybeUninit::uninit();
9815 let ptr = UNINIT.as_ptr();
9816 assert_eq!(
9817 ::std::mem::size_of::<FMOD_STUDIO_PARAMETER_ID>(),
9818 8usize,
9819 concat!("Size of: ", stringify!(FMOD_STUDIO_PARAMETER_ID))
9820 );
9821 assert_eq!(
9822 ::std::mem::align_of::<FMOD_STUDIO_PARAMETER_ID>(),
9823 4usize,
9824 concat!("Alignment of ", stringify!(FMOD_STUDIO_PARAMETER_ID))
9825 );
9826 assert_eq!(
9827 unsafe { ::std::ptr::addr_of!((*ptr).data1) as usize - ptr as usize },
9828 0usize,
9829 concat!(
9830 "Offset of field: ",
9831 stringify!(FMOD_STUDIO_PARAMETER_ID),
9832 "::",
9833 stringify!(data1)
9834 )
9835 );
9836 assert_eq!(
9837 unsafe { ::std::ptr::addr_of!((*ptr).data2) as usize - ptr as usize },
9838 4usize,
9839 concat!(
9840 "Offset of field: ",
9841 stringify!(FMOD_STUDIO_PARAMETER_ID),
9842 "::",
9843 stringify!(data2)
9844 )
9845 );
9846}
9847#[repr(C)]
9848#[derive(Debug, Copy, Clone, PartialEq)]
9849pub struct FMOD_STUDIO_PARAMETER_DESCRIPTION {
9850 pub name: *const ::std::os::raw::c_char,
9851 pub id: FMOD_STUDIO_PARAMETER_ID,
9852 pub minimum: f32,
9853 pub maximum: f32,
9854 pub defaultvalue: f32,
9855 pub type_: FMOD_STUDIO_PARAMETER_TYPE,
9856 pub flags: FMOD_STUDIO_PARAMETER_FLAGS,
9857 pub guid: FMOD_GUID,
9858}
9859#[test]
9860fn bindgen_test_layout_FMOD_STUDIO_PARAMETER_DESCRIPTION() {
9861 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_PARAMETER_DESCRIPTION> =
9862 ::std::mem::MaybeUninit::uninit();
9863 let ptr = UNINIT.as_ptr();
9864 assert_eq!(
9865 ::std::mem::size_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>(),
9866 56usize,
9867 concat!("Size of: ", stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION))
9868 );
9869 assert_eq!(
9870 ::std::mem::align_of::<FMOD_STUDIO_PARAMETER_DESCRIPTION>(),
9871 8usize,
9872 concat!(
9873 "Alignment of ",
9874 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION)
9875 )
9876 );
9877 assert_eq!(
9878 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
9879 0usize,
9880 concat!(
9881 "Offset of field: ",
9882 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9883 "::",
9884 stringify!(name)
9885 )
9886 );
9887 assert_eq!(
9888 unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
9889 8usize,
9890 concat!(
9891 "Offset of field: ",
9892 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9893 "::",
9894 stringify!(id)
9895 )
9896 );
9897 assert_eq!(
9898 unsafe { ::std::ptr::addr_of!((*ptr).minimum) as usize - ptr as usize },
9899 16usize,
9900 concat!(
9901 "Offset of field: ",
9902 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9903 "::",
9904 stringify!(minimum)
9905 )
9906 );
9907 assert_eq!(
9908 unsafe { ::std::ptr::addr_of!((*ptr).maximum) as usize - ptr as usize },
9909 20usize,
9910 concat!(
9911 "Offset of field: ",
9912 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9913 "::",
9914 stringify!(maximum)
9915 )
9916 );
9917 assert_eq!(
9918 unsafe { ::std::ptr::addr_of!((*ptr).defaultvalue) as usize - ptr as usize },
9919 24usize,
9920 concat!(
9921 "Offset of field: ",
9922 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9923 "::",
9924 stringify!(defaultvalue)
9925 )
9926 );
9927 assert_eq!(
9928 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
9929 28usize,
9930 concat!(
9931 "Offset of field: ",
9932 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9933 "::",
9934 stringify!(type_)
9935 )
9936 );
9937 assert_eq!(
9938 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
9939 32usize,
9940 concat!(
9941 "Offset of field: ",
9942 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9943 "::",
9944 stringify!(flags)
9945 )
9946 );
9947 assert_eq!(
9948 unsafe { ::std::ptr::addr_of!((*ptr).guid) as usize - ptr as usize },
9949 36usize,
9950 concat!(
9951 "Offset of field: ",
9952 stringify!(FMOD_STUDIO_PARAMETER_DESCRIPTION),
9953 "::",
9954 stringify!(guid)
9955 )
9956 );
9957}
9958impl Default for FMOD_STUDIO_PARAMETER_DESCRIPTION {
9959 fn default() -> Self {
9960 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9961 unsafe {
9962 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9963 s.assume_init()
9964 }
9965 }
9966}
9967#[repr(C)]
9968#[derive(Copy, Clone)]
9969pub struct FMOD_STUDIO_USER_PROPERTY {
9970 pub name: *const ::std::os::raw::c_char,
9971 pub type_: FMOD_STUDIO_USER_PROPERTY_TYPE,
9972 pub __bindgen_anon_1: FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1,
9973}
9974#[repr(C)]
9975#[derive(Copy, Clone)]
9976pub union FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
9977 pub intvalue: ::std::os::raw::c_int,
9978 pub boolvalue: FMOD_BOOL,
9979 pub floatvalue: f32,
9980 pub stringvalue: *const ::std::os::raw::c_char,
9981}
9982#[test]
9983fn bindgen_test_layout_FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1() {
9984 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1> =
9985 ::std::mem::MaybeUninit::uninit();
9986 let ptr = UNINIT.as_ptr();
9987 assert_eq!(
9988 ::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>(),
9989 8usize,
9990 concat!(
9991 "Size of: ",
9992 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1)
9993 )
9994 );
9995 assert_eq!(
9996 ::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1>(),
9997 8usize,
9998 concat!(
9999 "Alignment of ",
10000 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1)
10001 )
10002 );
10003 assert_eq!(
10004 unsafe { ::std::ptr::addr_of!((*ptr).intvalue) as usize - ptr as usize },
10005 0usize,
10006 concat!(
10007 "Offset of field: ",
10008 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1),
10009 "::",
10010 stringify!(intvalue)
10011 )
10012 );
10013 assert_eq!(
10014 unsafe { ::std::ptr::addr_of!((*ptr).boolvalue) as usize - ptr as usize },
10015 0usize,
10016 concat!(
10017 "Offset of field: ",
10018 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1),
10019 "::",
10020 stringify!(boolvalue)
10021 )
10022 );
10023 assert_eq!(
10024 unsafe { ::std::ptr::addr_of!((*ptr).floatvalue) as usize - ptr as usize },
10025 0usize,
10026 concat!(
10027 "Offset of field: ",
10028 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1),
10029 "::",
10030 stringify!(floatvalue)
10031 )
10032 );
10033 assert_eq!(
10034 unsafe { ::std::ptr::addr_of!((*ptr).stringvalue) as usize - ptr as usize },
10035 0usize,
10036 concat!(
10037 "Offset of field: ",
10038 stringify!(FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1),
10039 "::",
10040 stringify!(stringvalue)
10041 )
10042 );
10043}
10044impl Default for FMOD_STUDIO_USER_PROPERTY__bindgen_ty_1 {
10045 fn default() -> Self {
10046 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10047 unsafe {
10048 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10049 s.assume_init()
10050 }
10051 }
10052}
10053#[test]
10054fn bindgen_test_layout_FMOD_STUDIO_USER_PROPERTY() {
10055 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_USER_PROPERTY> =
10056 ::std::mem::MaybeUninit::uninit();
10057 let ptr = UNINIT.as_ptr();
10058 assert_eq!(
10059 ::std::mem::size_of::<FMOD_STUDIO_USER_PROPERTY>(),
10060 24usize,
10061 concat!("Size of: ", stringify!(FMOD_STUDIO_USER_PROPERTY))
10062 );
10063 assert_eq!(
10064 ::std::mem::align_of::<FMOD_STUDIO_USER_PROPERTY>(),
10065 8usize,
10066 concat!("Alignment of ", stringify!(FMOD_STUDIO_USER_PROPERTY))
10067 );
10068 assert_eq!(
10069 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
10070 0usize,
10071 concat!(
10072 "Offset of field: ",
10073 stringify!(FMOD_STUDIO_USER_PROPERTY),
10074 "::",
10075 stringify!(name)
10076 )
10077 );
10078 assert_eq!(
10079 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
10080 8usize,
10081 concat!(
10082 "Offset of field: ",
10083 stringify!(FMOD_STUDIO_USER_PROPERTY),
10084 "::",
10085 stringify!(type_)
10086 )
10087 );
10088}
10089impl Default for FMOD_STUDIO_USER_PROPERTY {
10090 fn default() -> Self {
10091 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10092 unsafe {
10093 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10094 s.assume_init()
10095 }
10096 }
10097}
10098#[repr(C)]
10099#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10100pub struct FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
10101 pub name: *const ::std::os::raw::c_char,
10102 pub sound: *mut FMOD_SOUND,
10103 pub subsoundIndex: ::std::os::raw::c_int,
10104}
10105#[test]
10106fn bindgen_test_layout_FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES() {
10107 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES> =
10108 ::std::mem::MaybeUninit::uninit();
10109 let ptr = UNINIT.as_ptr();
10110 assert_eq!(
10111 ::std::mem::size_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>(),
10112 24usize,
10113 concat!(
10114 "Size of: ",
10115 stringify!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES)
10116 )
10117 );
10118 assert_eq!(
10119 ::std::mem::align_of::<FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES>(),
10120 8usize,
10121 concat!(
10122 "Alignment of ",
10123 stringify!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES)
10124 )
10125 );
10126 assert_eq!(
10127 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
10128 0usize,
10129 concat!(
10130 "Offset of field: ",
10131 stringify!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES),
10132 "::",
10133 stringify!(name)
10134 )
10135 );
10136 assert_eq!(
10137 unsafe { ::std::ptr::addr_of!((*ptr).sound) as usize - ptr as usize },
10138 8usize,
10139 concat!(
10140 "Offset of field: ",
10141 stringify!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES),
10142 "::",
10143 stringify!(sound)
10144 )
10145 );
10146 assert_eq!(
10147 unsafe { ::std::ptr::addr_of!((*ptr).subsoundIndex) as usize - ptr as usize },
10148 16usize,
10149 concat!(
10150 "Offset of field: ",
10151 stringify!(FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES),
10152 "::",
10153 stringify!(subsoundIndex)
10154 )
10155 );
10156}
10157impl Default for FMOD_STUDIO_PROGRAMMER_SOUND_PROPERTIES {
10158 fn default() -> Self {
10159 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10160 unsafe {
10161 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10162 s.assume_init()
10163 }
10164 }
10165}
10166#[repr(C)]
10167#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10168pub struct FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
10169 pub name: *const ::std::os::raw::c_char,
10170 pub dsp: *mut FMOD_DSP,
10171}
10172#[test]
10173fn bindgen_test_layout_FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES() {
10174 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES> =
10175 ::std::mem::MaybeUninit::uninit();
10176 let ptr = UNINIT.as_ptr();
10177 assert_eq!(
10178 ::std::mem::size_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>(),
10179 16usize,
10180 concat!(
10181 "Size of: ",
10182 stringify!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES)
10183 )
10184 );
10185 assert_eq!(
10186 ::std::mem::align_of::<FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES>(),
10187 8usize,
10188 concat!(
10189 "Alignment of ",
10190 stringify!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES)
10191 )
10192 );
10193 assert_eq!(
10194 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
10195 0usize,
10196 concat!(
10197 "Offset of field: ",
10198 stringify!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES),
10199 "::",
10200 stringify!(name)
10201 )
10202 );
10203 assert_eq!(
10204 unsafe { ::std::ptr::addr_of!((*ptr).dsp) as usize - ptr as usize },
10205 8usize,
10206 concat!(
10207 "Offset of field: ",
10208 stringify!(FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES),
10209 "::",
10210 stringify!(dsp)
10211 )
10212 );
10213}
10214impl Default for FMOD_STUDIO_PLUGIN_INSTANCE_PROPERTIES {
10215 fn default() -> Self {
10216 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10217 unsafe {
10218 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10219 s.assume_init()
10220 }
10221 }
10222}
10223#[repr(C)]
10224#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10225pub struct FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
10226 pub name: *const ::std::os::raw::c_char,
10227 pub position: ::std::os::raw::c_int,
10228}
10229#[test]
10230fn bindgen_test_layout_FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES() {
10231 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES> =
10232 ::std::mem::MaybeUninit::uninit();
10233 let ptr = UNINIT.as_ptr();
10234 assert_eq!(
10235 ::std::mem::size_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>(),
10236 16usize,
10237 concat!(
10238 "Size of: ",
10239 stringify!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES)
10240 )
10241 );
10242 assert_eq!(
10243 ::std::mem::align_of::<FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES>(),
10244 8usize,
10245 concat!(
10246 "Alignment of ",
10247 stringify!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES)
10248 )
10249 );
10250 assert_eq!(
10251 unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
10252 0usize,
10253 concat!(
10254 "Offset of field: ",
10255 stringify!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES),
10256 "::",
10257 stringify!(name)
10258 )
10259 );
10260 assert_eq!(
10261 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
10262 8usize,
10263 concat!(
10264 "Offset of field: ",
10265 stringify!(FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES),
10266 "::",
10267 stringify!(position)
10268 )
10269 );
10270}
10271impl Default for FMOD_STUDIO_TIMELINE_MARKER_PROPERTIES {
10272 fn default() -> Self {
10273 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10274 unsafe {
10275 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10276 s.assume_init()
10277 }
10278 }
10279}
10280#[repr(C)]
10281#[derive(Debug, Default, Copy, Clone, PartialEq)]
10282pub struct FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES {
10283 pub bar: ::std::os::raw::c_int,
10284 pub beat: ::std::os::raw::c_int,
10285 pub position: ::std::os::raw::c_int,
10286 pub tempo: f32,
10287 pub timesignatureupper: ::std::os::raw::c_int,
10288 pub timesignaturelower: ::std::os::raw::c_int,
10289}
10290#[test]
10291fn bindgen_test_layout_FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES() {
10292 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES> =
10293 ::std::mem::MaybeUninit::uninit();
10294 let ptr = UNINIT.as_ptr();
10295 assert_eq!(
10296 ::std::mem::size_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>(),
10297 24usize,
10298 concat!(
10299 "Size of: ",
10300 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES)
10301 )
10302 );
10303 assert_eq!(
10304 ::std::mem::align_of::<FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES>(),
10305 4usize,
10306 concat!(
10307 "Alignment of ",
10308 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES)
10309 )
10310 );
10311 assert_eq!(
10312 unsafe { ::std::ptr::addr_of!((*ptr).bar) as usize - ptr as usize },
10313 0usize,
10314 concat!(
10315 "Offset of field: ",
10316 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10317 "::",
10318 stringify!(bar)
10319 )
10320 );
10321 assert_eq!(
10322 unsafe { ::std::ptr::addr_of!((*ptr).beat) as usize - ptr as usize },
10323 4usize,
10324 concat!(
10325 "Offset of field: ",
10326 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10327 "::",
10328 stringify!(beat)
10329 )
10330 );
10331 assert_eq!(
10332 unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
10333 8usize,
10334 concat!(
10335 "Offset of field: ",
10336 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10337 "::",
10338 stringify!(position)
10339 )
10340 );
10341 assert_eq!(
10342 unsafe { ::std::ptr::addr_of!((*ptr).tempo) as usize - ptr as usize },
10343 12usize,
10344 concat!(
10345 "Offset of field: ",
10346 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10347 "::",
10348 stringify!(tempo)
10349 )
10350 );
10351 assert_eq!(
10352 unsafe { ::std::ptr::addr_of!((*ptr).timesignatureupper) as usize - ptr as usize },
10353 16usize,
10354 concat!(
10355 "Offset of field: ",
10356 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10357 "::",
10358 stringify!(timesignatureupper)
10359 )
10360 );
10361 assert_eq!(
10362 unsafe { ::std::ptr::addr_of!((*ptr).timesignaturelower) as usize - ptr as usize },
10363 20usize,
10364 concat!(
10365 "Offset of field: ",
10366 stringify!(FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES),
10367 "::",
10368 stringify!(timesignaturelower)
10369 )
10370 );
10371}
10372#[repr(C)]
10373#[derive(Debug, Default, Copy, Clone, PartialEq)]
10374pub struct FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES {
10375 pub eventid: FMOD_GUID,
10376 pub properties: FMOD_STUDIO_TIMELINE_BEAT_PROPERTIES,
10377}
10378#[test]
10379fn bindgen_test_layout_FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES() {
10380 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES> =
10381 ::std::mem::MaybeUninit::uninit();
10382 let ptr = UNINIT.as_ptr();
10383 assert_eq!(
10384 ::std::mem::size_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>(),
10385 40usize,
10386 concat!(
10387 "Size of: ",
10388 stringify!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES)
10389 )
10390 );
10391 assert_eq!(
10392 ::std::mem::align_of::<FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES>(),
10393 4usize,
10394 concat!(
10395 "Alignment of ",
10396 stringify!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES)
10397 )
10398 );
10399 assert_eq!(
10400 unsafe { ::std::ptr::addr_of!((*ptr).eventid) as usize - ptr as usize },
10401 0usize,
10402 concat!(
10403 "Offset of field: ",
10404 stringify!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES),
10405 "::",
10406 stringify!(eventid)
10407 )
10408 );
10409 assert_eq!(
10410 unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
10411 16usize,
10412 concat!(
10413 "Offset of field: ",
10414 stringify!(FMOD_STUDIO_TIMELINE_NESTED_BEAT_PROPERTIES),
10415 "::",
10416 stringify!(properties)
10417 )
10418 );
10419}
10420#[repr(C)]
10421#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10422pub struct FMOD_STUDIO_ADVANCEDSETTINGS {
10423 pub cbsize: ::std::os::raw::c_int,
10424 pub commandqueuesize: ::std::os::raw::c_uint,
10425 pub handleinitialsize: ::std::os::raw::c_uint,
10426 pub studioupdateperiod: ::std::os::raw::c_int,
10427 pub idlesampledatapoolsize: ::std::os::raw::c_int,
10428 pub streamingscheduledelay: ::std::os::raw::c_uint,
10429 pub encryptionkey: *const ::std::os::raw::c_char,
10430}
10431#[test]
10432fn bindgen_test_layout_FMOD_STUDIO_ADVANCEDSETTINGS() {
10433 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_ADVANCEDSETTINGS> =
10434 ::std::mem::MaybeUninit::uninit();
10435 let ptr = UNINIT.as_ptr();
10436 assert_eq!(
10437 ::std::mem::size_of::<FMOD_STUDIO_ADVANCEDSETTINGS>(),
10438 32usize,
10439 concat!("Size of: ", stringify!(FMOD_STUDIO_ADVANCEDSETTINGS))
10440 );
10441 assert_eq!(
10442 ::std::mem::align_of::<FMOD_STUDIO_ADVANCEDSETTINGS>(),
10443 8usize,
10444 concat!("Alignment of ", stringify!(FMOD_STUDIO_ADVANCEDSETTINGS))
10445 );
10446 assert_eq!(
10447 unsafe { ::std::ptr::addr_of!((*ptr).cbsize) as usize - ptr as usize },
10448 0usize,
10449 concat!(
10450 "Offset of field: ",
10451 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10452 "::",
10453 stringify!(cbsize)
10454 )
10455 );
10456 assert_eq!(
10457 unsafe { ::std::ptr::addr_of!((*ptr).commandqueuesize) as usize - ptr as usize },
10458 4usize,
10459 concat!(
10460 "Offset of field: ",
10461 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10462 "::",
10463 stringify!(commandqueuesize)
10464 )
10465 );
10466 assert_eq!(
10467 unsafe { ::std::ptr::addr_of!((*ptr).handleinitialsize) as usize - ptr as usize },
10468 8usize,
10469 concat!(
10470 "Offset of field: ",
10471 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10472 "::",
10473 stringify!(handleinitialsize)
10474 )
10475 );
10476 assert_eq!(
10477 unsafe { ::std::ptr::addr_of!((*ptr).studioupdateperiod) as usize - ptr as usize },
10478 12usize,
10479 concat!(
10480 "Offset of field: ",
10481 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10482 "::",
10483 stringify!(studioupdateperiod)
10484 )
10485 );
10486 assert_eq!(
10487 unsafe { ::std::ptr::addr_of!((*ptr).idlesampledatapoolsize) as usize - ptr as usize },
10488 16usize,
10489 concat!(
10490 "Offset of field: ",
10491 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10492 "::",
10493 stringify!(idlesampledatapoolsize)
10494 )
10495 );
10496 assert_eq!(
10497 unsafe { ::std::ptr::addr_of!((*ptr).streamingscheduledelay) as usize - ptr as usize },
10498 20usize,
10499 concat!(
10500 "Offset of field: ",
10501 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10502 "::",
10503 stringify!(streamingscheduledelay)
10504 )
10505 );
10506 assert_eq!(
10507 unsafe { ::std::ptr::addr_of!((*ptr).encryptionkey) as usize - ptr as usize },
10508 24usize,
10509 concat!(
10510 "Offset of field: ",
10511 stringify!(FMOD_STUDIO_ADVANCEDSETTINGS),
10512 "::",
10513 stringify!(encryptionkey)
10514 )
10515 );
10516}
10517impl Default for FMOD_STUDIO_ADVANCEDSETTINGS {
10518 fn default() -> Self {
10519 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10520 unsafe {
10521 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10522 s.assume_init()
10523 }
10524 }
10525}
10526#[repr(C)]
10527#[derive(Debug, Default, Copy, Clone, PartialEq)]
10528pub struct FMOD_STUDIO_CPU_USAGE {
10529 pub update: f32,
10530}
10531#[test]
10532fn bindgen_test_layout_FMOD_STUDIO_CPU_USAGE() {
10533 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_CPU_USAGE> =
10534 ::std::mem::MaybeUninit::uninit();
10535 let ptr = UNINIT.as_ptr();
10536 assert_eq!(
10537 ::std::mem::size_of::<FMOD_STUDIO_CPU_USAGE>(),
10538 4usize,
10539 concat!("Size of: ", stringify!(FMOD_STUDIO_CPU_USAGE))
10540 );
10541 assert_eq!(
10542 ::std::mem::align_of::<FMOD_STUDIO_CPU_USAGE>(),
10543 4usize,
10544 concat!("Alignment of ", stringify!(FMOD_STUDIO_CPU_USAGE))
10545 );
10546 assert_eq!(
10547 unsafe { ::std::ptr::addr_of!((*ptr).update) as usize - ptr as usize },
10548 0usize,
10549 concat!(
10550 "Offset of field: ",
10551 stringify!(FMOD_STUDIO_CPU_USAGE),
10552 "::",
10553 stringify!(update)
10554 )
10555 );
10556}
10557#[repr(C)]
10558#[derive(Debug, Default, Copy, Clone, PartialEq)]
10559pub struct FMOD_STUDIO_BUFFER_INFO {
10560 pub currentusage: ::std::os::raw::c_int,
10561 pub peakusage: ::std::os::raw::c_int,
10562 pub capacity: ::std::os::raw::c_int,
10563 pub stallcount: ::std::os::raw::c_int,
10564 pub stalltime: f32,
10565}
10566#[test]
10567fn bindgen_test_layout_FMOD_STUDIO_BUFFER_INFO() {
10568 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_BUFFER_INFO> =
10569 ::std::mem::MaybeUninit::uninit();
10570 let ptr = UNINIT.as_ptr();
10571 assert_eq!(
10572 ::std::mem::size_of::<FMOD_STUDIO_BUFFER_INFO>(),
10573 20usize,
10574 concat!("Size of: ", stringify!(FMOD_STUDIO_BUFFER_INFO))
10575 );
10576 assert_eq!(
10577 ::std::mem::align_of::<FMOD_STUDIO_BUFFER_INFO>(),
10578 4usize,
10579 concat!("Alignment of ", stringify!(FMOD_STUDIO_BUFFER_INFO))
10580 );
10581 assert_eq!(
10582 unsafe { ::std::ptr::addr_of!((*ptr).currentusage) as usize - ptr as usize },
10583 0usize,
10584 concat!(
10585 "Offset of field: ",
10586 stringify!(FMOD_STUDIO_BUFFER_INFO),
10587 "::",
10588 stringify!(currentusage)
10589 )
10590 );
10591 assert_eq!(
10592 unsafe { ::std::ptr::addr_of!((*ptr).peakusage) as usize - ptr as usize },
10593 4usize,
10594 concat!(
10595 "Offset of field: ",
10596 stringify!(FMOD_STUDIO_BUFFER_INFO),
10597 "::",
10598 stringify!(peakusage)
10599 )
10600 );
10601 assert_eq!(
10602 unsafe { ::std::ptr::addr_of!((*ptr).capacity) as usize - ptr as usize },
10603 8usize,
10604 concat!(
10605 "Offset of field: ",
10606 stringify!(FMOD_STUDIO_BUFFER_INFO),
10607 "::",
10608 stringify!(capacity)
10609 )
10610 );
10611 assert_eq!(
10612 unsafe { ::std::ptr::addr_of!((*ptr).stallcount) as usize - ptr as usize },
10613 12usize,
10614 concat!(
10615 "Offset of field: ",
10616 stringify!(FMOD_STUDIO_BUFFER_INFO),
10617 "::",
10618 stringify!(stallcount)
10619 )
10620 );
10621 assert_eq!(
10622 unsafe { ::std::ptr::addr_of!((*ptr).stalltime) as usize - ptr as usize },
10623 16usize,
10624 concat!(
10625 "Offset of field: ",
10626 stringify!(FMOD_STUDIO_BUFFER_INFO),
10627 "::",
10628 stringify!(stalltime)
10629 )
10630 );
10631}
10632#[repr(C)]
10633#[derive(Debug, Default, Copy, Clone, PartialEq)]
10634pub struct FMOD_STUDIO_BUFFER_USAGE {
10635 pub studiocommandqueue: FMOD_STUDIO_BUFFER_INFO,
10636 pub studiohandle: FMOD_STUDIO_BUFFER_INFO,
10637}
10638#[test]
10639fn bindgen_test_layout_FMOD_STUDIO_BUFFER_USAGE() {
10640 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_BUFFER_USAGE> =
10641 ::std::mem::MaybeUninit::uninit();
10642 let ptr = UNINIT.as_ptr();
10643 assert_eq!(
10644 ::std::mem::size_of::<FMOD_STUDIO_BUFFER_USAGE>(),
10645 40usize,
10646 concat!("Size of: ", stringify!(FMOD_STUDIO_BUFFER_USAGE))
10647 );
10648 assert_eq!(
10649 ::std::mem::align_of::<FMOD_STUDIO_BUFFER_USAGE>(),
10650 4usize,
10651 concat!("Alignment of ", stringify!(FMOD_STUDIO_BUFFER_USAGE))
10652 );
10653 assert_eq!(
10654 unsafe { ::std::ptr::addr_of!((*ptr).studiocommandqueue) as usize - ptr as usize },
10655 0usize,
10656 concat!(
10657 "Offset of field: ",
10658 stringify!(FMOD_STUDIO_BUFFER_USAGE),
10659 "::",
10660 stringify!(studiocommandqueue)
10661 )
10662 );
10663 assert_eq!(
10664 unsafe { ::std::ptr::addr_of!((*ptr).studiohandle) as usize - ptr as usize },
10665 20usize,
10666 concat!(
10667 "Offset of field: ",
10668 stringify!(FMOD_STUDIO_BUFFER_USAGE),
10669 "::",
10670 stringify!(studiohandle)
10671 )
10672 );
10673}
10674#[repr(C)]
10675#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
10676pub struct FMOD_STUDIO_SOUND_INFO {
10677 pub name_or_data: *const ::std::os::raw::c_char,
10678 pub mode: FMOD_MODE,
10679 pub exinfo: FMOD_CREATESOUNDEXINFO,
10680 pub subsoundindex: ::std::os::raw::c_int,
10681}
10682#[test]
10683fn bindgen_test_layout_FMOD_STUDIO_SOUND_INFO() {
10684 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_SOUND_INFO> =
10685 ::std::mem::MaybeUninit::uninit();
10686 let ptr = UNINIT.as_ptr();
10687 assert_eq!(
10688 ::std::mem::size_of::<FMOD_STUDIO_SOUND_INFO>(),
10689 248usize,
10690 concat!("Size of: ", stringify!(FMOD_STUDIO_SOUND_INFO))
10691 );
10692 assert_eq!(
10693 ::std::mem::align_of::<FMOD_STUDIO_SOUND_INFO>(),
10694 8usize,
10695 concat!("Alignment of ", stringify!(FMOD_STUDIO_SOUND_INFO))
10696 );
10697 assert_eq!(
10698 unsafe { ::std::ptr::addr_of!((*ptr).name_or_data) as usize - ptr as usize },
10699 0usize,
10700 concat!(
10701 "Offset of field: ",
10702 stringify!(FMOD_STUDIO_SOUND_INFO),
10703 "::",
10704 stringify!(name_or_data)
10705 )
10706 );
10707 assert_eq!(
10708 unsafe { ::std::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
10709 8usize,
10710 concat!(
10711 "Offset of field: ",
10712 stringify!(FMOD_STUDIO_SOUND_INFO),
10713 "::",
10714 stringify!(mode)
10715 )
10716 );
10717 assert_eq!(
10718 unsafe { ::std::ptr::addr_of!((*ptr).exinfo) as usize - ptr as usize },
10719 16usize,
10720 concat!(
10721 "Offset of field: ",
10722 stringify!(FMOD_STUDIO_SOUND_INFO),
10723 "::",
10724 stringify!(exinfo)
10725 )
10726 );
10727 assert_eq!(
10728 unsafe { ::std::ptr::addr_of!((*ptr).subsoundindex) as usize - ptr as usize },
10729 240usize,
10730 concat!(
10731 "Offset of field: ",
10732 stringify!(FMOD_STUDIO_SOUND_INFO),
10733 "::",
10734 stringify!(subsoundindex)
10735 )
10736 );
10737}
10738impl Default for FMOD_STUDIO_SOUND_INFO {
10739 fn default() -> Self {
10740 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10741 unsafe {
10742 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10743 s.assume_init()
10744 }
10745 }
10746}
10747#[repr(C)]
10748#[derive(Debug, Copy, Clone, PartialEq)]
10749pub struct FMOD_STUDIO_COMMAND_INFO {
10750 pub commandname: *const ::std::os::raw::c_char,
10751 pub parentcommandindex: ::std::os::raw::c_int,
10752 pub framenumber: ::std::os::raw::c_int,
10753 pub frametime: f32,
10754 pub instancetype: FMOD_STUDIO_INSTANCETYPE,
10755 pub outputtype: FMOD_STUDIO_INSTANCETYPE,
10756 pub instancehandle: ::std::os::raw::c_uint,
10757 pub outputhandle: ::std::os::raw::c_uint,
10758}
10759#[test]
10760fn bindgen_test_layout_FMOD_STUDIO_COMMAND_INFO() {
10761 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_COMMAND_INFO> =
10762 ::std::mem::MaybeUninit::uninit();
10763 let ptr = UNINIT.as_ptr();
10764 assert_eq!(
10765 ::std::mem::size_of::<FMOD_STUDIO_COMMAND_INFO>(),
10766 40usize,
10767 concat!("Size of: ", stringify!(FMOD_STUDIO_COMMAND_INFO))
10768 );
10769 assert_eq!(
10770 ::std::mem::align_of::<FMOD_STUDIO_COMMAND_INFO>(),
10771 8usize,
10772 concat!("Alignment of ", stringify!(FMOD_STUDIO_COMMAND_INFO))
10773 );
10774 assert_eq!(
10775 unsafe { ::std::ptr::addr_of!((*ptr).commandname) as usize - ptr as usize },
10776 0usize,
10777 concat!(
10778 "Offset of field: ",
10779 stringify!(FMOD_STUDIO_COMMAND_INFO),
10780 "::",
10781 stringify!(commandname)
10782 )
10783 );
10784 assert_eq!(
10785 unsafe { ::std::ptr::addr_of!((*ptr).parentcommandindex) as usize - ptr as usize },
10786 8usize,
10787 concat!(
10788 "Offset of field: ",
10789 stringify!(FMOD_STUDIO_COMMAND_INFO),
10790 "::",
10791 stringify!(parentcommandindex)
10792 )
10793 );
10794 assert_eq!(
10795 unsafe { ::std::ptr::addr_of!((*ptr).framenumber) as usize - ptr as usize },
10796 12usize,
10797 concat!(
10798 "Offset of field: ",
10799 stringify!(FMOD_STUDIO_COMMAND_INFO),
10800 "::",
10801 stringify!(framenumber)
10802 )
10803 );
10804 assert_eq!(
10805 unsafe { ::std::ptr::addr_of!((*ptr).frametime) as usize - ptr as usize },
10806 16usize,
10807 concat!(
10808 "Offset of field: ",
10809 stringify!(FMOD_STUDIO_COMMAND_INFO),
10810 "::",
10811 stringify!(frametime)
10812 )
10813 );
10814 assert_eq!(
10815 unsafe { ::std::ptr::addr_of!((*ptr).instancetype) as usize - ptr as usize },
10816 20usize,
10817 concat!(
10818 "Offset of field: ",
10819 stringify!(FMOD_STUDIO_COMMAND_INFO),
10820 "::",
10821 stringify!(instancetype)
10822 )
10823 );
10824 assert_eq!(
10825 unsafe { ::std::ptr::addr_of!((*ptr).outputtype) as usize - ptr as usize },
10826 24usize,
10827 concat!(
10828 "Offset of field: ",
10829 stringify!(FMOD_STUDIO_COMMAND_INFO),
10830 "::",
10831 stringify!(outputtype)
10832 )
10833 );
10834 assert_eq!(
10835 unsafe { ::std::ptr::addr_of!((*ptr).instancehandle) as usize - ptr as usize },
10836 28usize,
10837 concat!(
10838 "Offset of field: ",
10839 stringify!(FMOD_STUDIO_COMMAND_INFO),
10840 "::",
10841 stringify!(instancehandle)
10842 )
10843 );
10844 assert_eq!(
10845 unsafe { ::std::ptr::addr_of!((*ptr).outputhandle) as usize - ptr as usize },
10846 32usize,
10847 concat!(
10848 "Offset of field: ",
10849 stringify!(FMOD_STUDIO_COMMAND_INFO),
10850 "::",
10851 stringify!(outputhandle)
10852 )
10853 );
10854}
10855impl Default for FMOD_STUDIO_COMMAND_INFO {
10856 fn default() -> Self {
10857 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10858 unsafe {
10859 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10860 s.assume_init()
10861 }
10862 }
10863}
10864#[repr(C)]
10865#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
10866pub struct FMOD_STUDIO_MEMORY_USAGE {
10867 pub exclusive: ::std::os::raw::c_int,
10868 pub inclusive: ::std::os::raw::c_int,
10869 pub sampledata: ::std::os::raw::c_int,
10870}
10871#[test]
10872fn bindgen_test_layout_FMOD_STUDIO_MEMORY_USAGE() {
10873 const UNINIT: ::std::mem::MaybeUninit<FMOD_STUDIO_MEMORY_USAGE> =
10874 ::std::mem::MaybeUninit::uninit();
10875 let ptr = UNINIT.as_ptr();
10876 assert_eq!(
10877 ::std::mem::size_of::<FMOD_STUDIO_MEMORY_USAGE>(),
10878 12usize,
10879 concat!("Size of: ", stringify!(FMOD_STUDIO_MEMORY_USAGE))
10880 );
10881 assert_eq!(
10882 ::std::mem::align_of::<FMOD_STUDIO_MEMORY_USAGE>(),
10883 4usize,
10884 concat!("Alignment of ", stringify!(FMOD_STUDIO_MEMORY_USAGE))
10885 );
10886 assert_eq!(
10887 unsafe { ::std::ptr::addr_of!((*ptr).exclusive) as usize - ptr as usize },
10888 0usize,
10889 concat!(
10890 "Offset of field: ",
10891 stringify!(FMOD_STUDIO_MEMORY_USAGE),
10892 "::",
10893 stringify!(exclusive)
10894 )
10895 );
10896 assert_eq!(
10897 unsafe { ::std::ptr::addr_of!((*ptr).inclusive) as usize - ptr as usize },
10898 4usize,
10899 concat!(
10900 "Offset of field: ",
10901 stringify!(FMOD_STUDIO_MEMORY_USAGE),
10902 "::",
10903 stringify!(inclusive)
10904 )
10905 );
10906 assert_eq!(
10907 unsafe { ::std::ptr::addr_of!((*ptr).sampledata) as usize - ptr as usize },
10908 8usize,
10909 concat!(
10910 "Offset of field: ",
10911 stringify!(FMOD_STUDIO_MEMORY_USAGE),
10912 "::",
10913 stringify!(sampledata)
10914 )
10915 );
10916}
10917pub type FMOD_STUDIO_SYSTEM_CALLBACK = ::std::option::Option<
10918 unsafe extern "C" fn(
10919 system: *mut FMOD_STUDIO_SYSTEM,
10920 type_: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
10921 commanddata: *mut ::std::os::raw::c_void,
10922 userdata: *mut ::std::os::raw::c_void,
10923 ) -> FMOD_RESULT,
10924>;
10925pub type FMOD_STUDIO_EVENT_CALLBACK = ::std::option::Option<
10926 unsafe extern "C" fn(
10927 type_: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
10928 event: *mut FMOD_STUDIO_EVENTINSTANCE,
10929 parameters: *mut ::std::os::raw::c_void,
10930 ) -> FMOD_RESULT,
10931>;
10932pub type FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK = ::std::option::Option<
10933 unsafe extern "C" fn(
10934 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
10935 commandindex: ::std::os::raw::c_int,
10936 currenttime: f32,
10937 userdata: *mut ::std::os::raw::c_void,
10938 ) -> FMOD_RESULT,
10939>;
10940pub type FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK = ::std::option::Option<
10941 unsafe extern "C" fn(
10942 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
10943 commandindex: ::std::os::raw::c_int,
10944 bankguid: *const FMOD_GUID,
10945 bankfilename: *const ::std::os::raw::c_char,
10946 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
10947 bank: *mut *mut FMOD_STUDIO_BANK,
10948 userdata: *mut ::std::os::raw::c_void,
10949 ) -> FMOD_RESULT,
10950>;
10951pub type FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK = ::std::option::Option<
10952 unsafe extern "C" fn(
10953 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
10954 commandindex: ::std::os::raw::c_int,
10955 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
10956 instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
10957 userdata: *mut ::std::os::raw::c_void,
10958 ) -> FMOD_RESULT,
10959>;
10960extern "C" {
10961 #[must_use]
10962 pub fn FMOD_Studio_ParseID(
10963 idstring: *const ::std::os::raw::c_char,
10964 id: *mut FMOD_GUID,
10965 ) -> FMOD_RESULT;
10966}
10967extern "C" {
10968 #[must_use]
10969 pub fn FMOD_Studio_System_Create(
10970 system: *mut *mut FMOD_STUDIO_SYSTEM,
10971 headerversion: ::std::os::raw::c_uint,
10972 ) -> FMOD_RESULT;
10973}
10974extern "C" {
10975 pub fn FMOD_Studio_System_IsValid(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_BOOL;
10976}
10977extern "C" {
10978 #[must_use]
10979 pub fn FMOD_Studio_System_SetAdvancedSettings(
10980 system: *mut FMOD_STUDIO_SYSTEM,
10981 settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
10982 ) -> FMOD_RESULT;
10983}
10984extern "C" {
10985 #[must_use]
10986 pub fn FMOD_Studio_System_GetAdvancedSettings(
10987 system: *mut FMOD_STUDIO_SYSTEM,
10988 settings: *mut FMOD_STUDIO_ADVANCEDSETTINGS,
10989 ) -> FMOD_RESULT;
10990}
10991extern "C" {
10992 #[must_use]
10993 pub fn FMOD_Studio_System_Initialize(
10994 system: *mut FMOD_STUDIO_SYSTEM,
10995 maxchannels: ::std::os::raw::c_int,
10996 studioflags: FMOD_STUDIO_INITFLAGS,
10997 flags: FMOD_INITFLAGS,
10998 extradriverdata: *mut ::std::os::raw::c_void,
10999 ) -> FMOD_RESULT;
11000}
11001extern "C" {
11002 #[must_use]
11003 pub fn FMOD_Studio_System_Release(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11004}
11005extern "C" {
11006 #[must_use]
11007 pub fn FMOD_Studio_System_Update(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11008}
11009extern "C" {
11010 #[must_use]
11011 pub fn FMOD_Studio_System_GetCoreSystem(
11012 system: *mut FMOD_STUDIO_SYSTEM,
11013 coresystem: *mut *mut FMOD_SYSTEM,
11014 ) -> FMOD_RESULT;
11015}
11016extern "C" {
11017 #[must_use]
11018 pub fn FMOD_Studio_System_GetEvent(
11019 system: *mut FMOD_STUDIO_SYSTEM,
11020 pathOrID: *const ::std::os::raw::c_char,
11021 event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
11022 ) -> FMOD_RESULT;
11023}
11024extern "C" {
11025 #[must_use]
11026 pub fn FMOD_Studio_System_GetBus(
11027 system: *mut FMOD_STUDIO_SYSTEM,
11028 pathOrID: *const ::std::os::raw::c_char,
11029 bus: *mut *mut FMOD_STUDIO_BUS,
11030 ) -> FMOD_RESULT;
11031}
11032extern "C" {
11033 #[must_use]
11034 pub fn FMOD_Studio_System_GetVCA(
11035 system: *mut FMOD_STUDIO_SYSTEM,
11036 pathOrID: *const ::std::os::raw::c_char,
11037 vca: *mut *mut FMOD_STUDIO_VCA,
11038 ) -> FMOD_RESULT;
11039}
11040extern "C" {
11041 #[must_use]
11042 pub fn FMOD_Studio_System_GetBank(
11043 system: *mut FMOD_STUDIO_SYSTEM,
11044 pathOrID: *const ::std::os::raw::c_char,
11045 bank: *mut *mut FMOD_STUDIO_BANK,
11046 ) -> FMOD_RESULT;
11047}
11048extern "C" {
11049 #[must_use]
11050 pub fn FMOD_Studio_System_GetEventByID(
11051 system: *mut FMOD_STUDIO_SYSTEM,
11052 id: *const FMOD_GUID,
11053 event: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
11054 ) -> FMOD_RESULT;
11055}
11056extern "C" {
11057 #[must_use]
11058 pub fn FMOD_Studio_System_GetBusByID(
11059 system: *mut FMOD_STUDIO_SYSTEM,
11060 id: *const FMOD_GUID,
11061 bus: *mut *mut FMOD_STUDIO_BUS,
11062 ) -> FMOD_RESULT;
11063}
11064extern "C" {
11065 #[must_use]
11066 pub fn FMOD_Studio_System_GetVCAByID(
11067 system: *mut FMOD_STUDIO_SYSTEM,
11068 id: *const FMOD_GUID,
11069 vca: *mut *mut FMOD_STUDIO_VCA,
11070 ) -> FMOD_RESULT;
11071}
11072extern "C" {
11073 #[must_use]
11074 pub fn FMOD_Studio_System_GetBankByID(
11075 system: *mut FMOD_STUDIO_SYSTEM,
11076 id: *const FMOD_GUID,
11077 bank: *mut *mut FMOD_STUDIO_BANK,
11078 ) -> FMOD_RESULT;
11079}
11080extern "C" {
11081 #[must_use]
11082 pub fn FMOD_Studio_System_GetSoundInfo(
11083 system: *mut FMOD_STUDIO_SYSTEM,
11084 key: *const ::std::os::raw::c_char,
11085 info: *mut FMOD_STUDIO_SOUND_INFO,
11086 ) -> FMOD_RESULT;
11087}
11088extern "C" {
11089 #[must_use]
11090 pub fn FMOD_Studio_System_GetParameterDescriptionByName(
11091 system: *mut FMOD_STUDIO_SYSTEM,
11092 name: *const ::std::os::raw::c_char,
11093 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11094 ) -> FMOD_RESULT;
11095}
11096extern "C" {
11097 #[must_use]
11098 pub fn FMOD_Studio_System_GetParameterDescriptionByID(
11099 system: *mut FMOD_STUDIO_SYSTEM,
11100 id: FMOD_STUDIO_PARAMETER_ID,
11101 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11102 ) -> FMOD_RESULT;
11103}
11104extern "C" {
11105 #[must_use]
11106 pub fn FMOD_Studio_System_GetParameterLabelByName(
11107 system: *mut FMOD_STUDIO_SYSTEM,
11108 name: *const ::std::os::raw::c_char,
11109 labelindex: ::std::os::raw::c_int,
11110 label: *mut ::std::os::raw::c_char,
11111 size: ::std::os::raw::c_int,
11112 retrieved: *mut ::std::os::raw::c_int,
11113 ) -> FMOD_RESULT;
11114}
11115extern "C" {
11116 #[must_use]
11117 pub fn FMOD_Studio_System_GetParameterLabelByID(
11118 system: *mut FMOD_STUDIO_SYSTEM,
11119 id: FMOD_STUDIO_PARAMETER_ID,
11120 labelindex: ::std::os::raw::c_int,
11121 label: *mut ::std::os::raw::c_char,
11122 size: ::std::os::raw::c_int,
11123 retrieved: *mut ::std::os::raw::c_int,
11124 ) -> FMOD_RESULT;
11125}
11126extern "C" {
11127 #[must_use]
11128 pub fn FMOD_Studio_System_GetParameterByID(
11129 system: *mut FMOD_STUDIO_SYSTEM,
11130 id: FMOD_STUDIO_PARAMETER_ID,
11131 value: *mut f32,
11132 finalvalue: *mut f32,
11133 ) -> FMOD_RESULT;
11134}
11135extern "C" {
11136 #[must_use]
11137 pub fn FMOD_Studio_System_SetParameterByID(
11138 system: *mut FMOD_STUDIO_SYSTEM,
11139 id: FMOD_STUDIO_PARAMETER_ID,
11140 value: f32,
11141 ignoreseekspeed: FMOD_BOOL,
11142 ) -> FMOD_RESULT;
11143}
11144extern "C" {
11145 #[must_use]
11146 pub fn FMOD_Studio_System_SetParameterByIDWithLabel(
11147 system: *mut FMOD_STUDIO_SYSTEM,
11148 id: FMOD_STUDIO_PARAMETER_ID,
11149 label: *const ::std::os::raw::c_char,
11150 ignoreseekspeed: FMOD_BOOL,
11151 ) -> FMOD_RESULT;
11152}
11153extern "C" {
11154 #[must_use]
11155 pub fn FMOD_Studio_System_SetParametersByIDs(
11156 system: *mut FMOD_STUDIO_SYSTEM,
11157 ids: *const FMOD_STUDIO_PARAMETER_ID,
11158 values: *mut f32,
11159 count: ::std::os::raw::c_int,
11160 ignoreseekspeed: FMOD_BOOL,
11161 ) -> FMOD_RESULT;
11162}
11163extern "C" {
11164 #[must_use]
11165 pub fn FMOD_Studio_System_GetParameterByName(
11166 system: *mut FMOD_STUDIO_SYSTEM,
11167 name: *const ::std::os::raw::c_char,
11168 value: *mut f32,
11169 finalvalue: *mut f32,
11170 ) -> FMOD_RESULT;
11171}
11172extern "C" {
11173 #[must_use]
11174 pub fn FMOD_Studio_System_SetParameterByName(
11175 system: *mut FMOD_STUDIO_SYSTEM,
11176 name: *const ::std::os::raw::c_char,
11177 value: f32,
11178 ignoreseekspeed: FMOD_BOOL,
11179 ) -> FMOD_RESULT;
11180}
11181extern "C" {
11182 #[must_use]
11183 pub fn FMOD_Studio_System_SetParameterByNameWithLabel(
11184 system: *mut FMOD_STUDIO_SYSTEM,
11185 name: *const ::std::os::raw::c_char,
11186 label: *const ::std::os::raw::c_char,
11187 ignoreseekspeed: FMOD_BOOL,
11188 ) -> FMOD_RESULT;
11189}
11190extern "C" {
11191 #[must_use]
11192 pub fn FMOD_Studio_System_LookupID(
11193 system: *mut FMOD_STUDIO_SYSTEM,
11194 path: *const ::std::os::raw::c_char,
11195 id: *mut FMOD_GUID,
11196 ) -> FMOD_RESULT;
11197}
11198extern "C" {
11199 #[must_use]
11200 pub fn FMOD_Studio_System_LookupPath(
11201 system: *mut FMOD_STUDIO_SYSTEM,
11202 id: *const FMOD_GUID,
11203 path: *mut ::std::os::raw::c_char,
11204 size: ::std::os::raw::c_int,
11205 retrieved: *mut ::std::os::raw::c_int,
11206 ) -> FMOD_RESULT;
11207}
11208extern "C" {
11209 #[must_use]
11210 pub fn FMOD_Studio_System_GetNumListeners(
11211 system: *mut FMOD_STUDIO_SYSTEM,
11212 numlisteners: *mut ::std::os::raw::c_int,
11213 ) -> FMOD_RESULT;
11214}
11215extern "C" {
11216 #[must_use]
11217 pub fn FMOD_Studio_System_SetNumListeners(
11218 system: *mut FMOD_STUDIO_SYSTEM,
11219 numlisteners: ::std::os::raw::c_int,
11220 ) -> FMOD_RESULT;
11221}
11222extern "C" {
11223 #[must_use]
11224 pub fn FMOD_Studio_System_GetListenerAttributes(
11225 system: *mut FMOD_STUDIO_SYSTEM,
11226 index: ::std::os::raw::c_int,
11227 attributes: *mut FMOD_3D_ATTRIBUTES,
11228 attenuationposition: *mut FMOD_VECTOR,
11229 ) -> FMOD_RESULT;
11230}
11231extern "C" {
11232 #[must_use]
11233 pub fn FMOD_Studio_System_SetListenerAttributes(
11234 system: *mut FMOD_STUDIO_SYSTEM,
11235 index: ::std::os::raw::c_int,
11236 attributes: *const FMOD_3D_ATTRIBUTES,
11237 attenuationposition: *const FMOD_VECTOR,
11238 ) -> FMOD_RESULT;
11239}
11240extern "C" {
11241 #[must_use]
11242 pub fn FMOD_Studio_System_GetListenerWeight(
11243 system: *mut FMOD_STUDIO_SYSTEM,
11244 index: ::std::os::raw::c_int,
11245 weight: *mut f32,
11246 ) -> FMOD_RESULT;
11247}
11248extern "C" {
11249 #[must_use]
11250 pub fn FMOD_Studio_System_SetListenerWeight(
11251 system: *mut FMOD_STUDIO_SYSTEM,
11252 index: ::std::os::raw::c_int,
11253 weight: f32,
11254 ) -> FMOD_RESULT;
11255}
11256extern "C" {
11257 #[must_use]
11258 pub fn FMOD_Studio_System_LoadBankFile(
11259 system: *mut FMOD_STUDIO_SYSTEM,
11260 filename: *const ::std::os::raw::c_char,
11261 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
11262 bank: *mut *mut FMOD_STUDIO_BANK,
11263 ) -> FMOD_RESULT;
11264}
11265extern "C" {
11266 #[must_use]
11267 pub fn FMOD_Studio_System_LoadBankMemory(
11268 system: *mut FMOD_STUDIO_SYSTEM,
11269 buffer: *const ::std::os::raw::c_char,
11270 length: ::std::os::raw::c_int,
11271 mode: FMOD_STUDIO_LOAD_MEMORY_MODE,
11272 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
11273 bank: *mut *mut FMOD_STUDIO_BANK,
11274 ) -> FMOD_RESULT;
11275}
11276extern "C" {
11277 #[must_use]
11278 pub fn FMOD_Studio_System_LoadBankCustom(
11279 system: *mut FMOD_STUDIO_SYSTEM,
11280 info: *const FMOD_STUDIO_BANK_INFO,
11281 flags: FMOD_STUDIO_LOAD_BANK_FLAGS,
11282 bank: *mut *mut FMOD_STUDIO_BANK,
11283 ) -> FMOD_RESULT;
11284}
11285extern "C" {
11286 #[must_use]
11287 pub fn FMOD_Studio_System_RegisterPlugin(
11288 system: *mut FMOD_STUDIO_SYSTEM,
11289 description: *const FMOD_DSP_DESCRIPTION,
11290 ) -> FMOD_RESULT;
11291}
11292extern "C" {
11293 #[must_use]
11294 pub fn FMOD_Studio_System_UnregisterPlugin(
11295 system: *mut FMOD_STUDIO_SYSTEM,
11296 name: *const ::std::os::raw::c_char,
11297 ) -> FMOD_RESULT;
11298}
11299extern "C" {
11300 #[must_use]
11301 pub fn FMOD_Studio_System_UnloadAll(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11302}
11303extern "C" {
11304 #[must_use]
11305 pub fn FMOD_Studio_System_FlushCommands(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11306}
11307extern "C" {
11308 #[must_use]
11309 pub fn FMOD_Studio_System_FlushSampleLoading(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11310}
11311extern "C" {
11312 #[must_use]
11313 pub fn FMOD_Studio_System_StartCommandCapture(
11314 system: *mut FMOD_STUDIO_SYSTEM,
11315 filename: *const ::std::os::raw::c_char,
11316 flags: FMOD_STUDIO_COMMANDCAPTURE_FLAGS,
11317 ) -> FMOD_RESULT;
11318}
11319extern "C" {
11320 #[must_use]
11321 pub fn FMOD_Studio_System_StopCommandCapture(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11322}
11323extern "C" {
11324 #[must_use]
11325 pub fn FMOD_Studio_System_LoadCommandReplay(
11326 system: *mut FMOD_STUDIO_SYSTEM,
11327 filename: *const ::std::os::raw::c_char,
11328 flags: FMOD_STUDIO_COMMANDREPLAY_FLAGS,
11329 replay: *mut *mut FMOD_STUDIO_COMMANDREPLAY,
11330 ) -> FMOD_RESULT;
11331}
11332extern "C" {
11333 #[must_use]
11334 pub fn FMOD_Studio_System_GetBankCount(
11335 system: *mut FMOD_STUDIO_SYSTEM,
11336 count: *mut ::std::os::raw::c_int,
11337 ) -> FMOD_RESULT;
11338}
11339extern "C" {
11340 #[must_use]
11341 pub fn FMOD_Studio_System_GetBankList(
11342 system: *mut FMOD_STUDIO_SYSTEM,
11343 array: *mut *mut FMOD_STUDIO_BANK,
11344 capacity: ::std::os::raw::c_int,
11345 count: *mut ::std::os::raw::c_int,
11346 ) -> FMOD_RESULT;
11347}
11348extern "C" {
11349 #[must_use]
11350 pub fn FMOD_Studio_System_GetParameterDescriptionCount(
11351 system: *mut FMOD_STUDIO_SYSTEM,
11352 count: *mut ::std::os::raw::c_int,
11353 ) -> FMOD_RESULT;
11354}
11355extern "C" {
11356 #[must_use]
11357 pub fn FMOD_Studio_System_GetParameterDescriptionList(
11358 system: *mut FMOD_STUDIO_SYSTEM,
11359 array: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11360 capacity: ::std::os::raw::c_int,
11361 count: *mut ::std::os::raw::c_int,
11362 ) -> FMOD_RESULT;
11363}
11364extern "C" {
11365 #[must_use]
11366 pub fn FMOD_Studio_System_GetCPUUsage(
11367 system: *mut FMOD_STUDIO_SYSTEM,
11368 usage: *mut FMOD_STUDIO_CPU_USAGE,
11369 usage_core: *mut FMOD_CPU_USAGE,
11370 ) -> FMOD_RESULT;
11371}
11372extern "C" {
11373 #[must_use]
11374 pub fn FMOD_Studio_System_GetBufferUsage(
11375 system: *mut FMOD_STUDIO_SYSTEM,
11376 usage: *mut FMOD_STUDIO_BUFFER_USAGE,
11377 ) -> FMOD_RESULT;
11378}
11379extern "C" {
11380 #[must_use]
11381 pub fn FMOD_Studio_System_ResetBufferUsage(system: *mut FMOD_STUDIO_SYSTEM) -> FMOD_RESULT;
11382}
11383extern "C" {
11384 #[must_use]
11385 pub fn FMOD_Studio_System_SetCallback(
11386 system: *mut FMOD_STUDIO_SYSTEM,
11387 callback: FMOD_STUDIO_SYSTEM_CALLBACK,
11388 callbackmask: FMOD_STUDIO_SYSTEM_CALLBACK_TYPE,
11389 ) -> FMOD_RESULT;
11390}
11391extern "C" {
11392 #[must_use]
11393 pub fn FMOD_Studio_System_SetUserData(
11394 system: *mut FMOD_STUDIO_SYSTEM,
11395 userdata: *mut ::std::os::raw::c_void,
11396 ) -> FMOD_RESULT;
11397}
11398extern "C" {
11399 #[must_use]
11400 pub fn FMOD_Studio_System_GetUserData(
11401 system: *mut FMOD_STUDIO_SYSTEM,
11402 userdata: *mut *mut ::std::os::raw::c_void,
11403 ) -> FMOD_RESULT;
11404}
11405extern "C" {
11406 #[must_use]
11407 pub fn FMOD_Studio_System_GetMemoryUsage(
11408 system: *mut FMOD_STUDIO_SYSTEM,
11409 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
11410 ) -> FMOD_RESULT;
11411}
11412extern "C" {
11413 pub fn FMOD_Studio_EventDescription_IsValid(
11414 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11415 ) -> FMOD_BOOL;
11416}
11417extern "C" {
11418 #[must_use]
11419 pub fn FMOD_Studio_EventDescription_GetID(
11420 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11421 id: *mut FMOD_GUID,
11422 ) -> FMOD_RESULT;
11423}
11424extern "C" {
11425 #[must_use]
11426 pub fn FMOD_Studio_EventDescription_GetPath(
11427 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11428 path: *mut ::std::os::raw::c_char,
11429 size: ::std::os::raw::c_int,
11430 retrieved: *mut ::std::os::raw::c_int,
11431 ) -> FMOD_RESULT;
11432}
11433extern "C" {
11434 #[must_use]
11435 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionCount(
11436 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11437 count: *mut ::std::os::raw::c_int,
11438 ) -> FMOD_RESULT;
11439}
11440extern "C" {
11441 #[must_use]
11442 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByIndex(
11443 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11444 index: ::std::os::raw::c_int,
11445 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11446 ) -> FMOD_RESULT;
11447}
11448extern "C" {
11449 #[must_use]
11450 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByName(
11451 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11452 name: *const ::std::os::raw::c_char,
11453 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11454 ) -> FMOD_RESULT;
11455}
11456extern "C" {
11457 #[must_use]
11458 pub fn FMOD_Studio_EventDescription_GetParameterDescriptionByID(
11459 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11460 id: FMOD_STUDIO_PARAMETER_ID,
11461 parameter: *mut FMOD_STUDIO_PARAMETER_DESCRIPTION,
11462 ) -> FMOD_RESULT;
11463}
11464extern "C" {
11465 #[must_use]
11466 pub fn FMOD_Studio_EventDescription_GetParameterLabelByIndex(
11467 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11468 index: ::std::os::raw::c_int,
11469 labelindex: ::std::os::raw::c_int,
11470 label: *mut ::std::os::raw::c_char,
11471 size: ::std::os::raw::c_int,
11472 retrieved: *mut ::std::os::raw::c_int,
11473 ) -> FMOD_RESULT;
11474}
11475extern "C" {
11476 #[must_use]
11477 pub fn FMOD_Studio_EventDescription_GetParameterLabelByName(
11478 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11479 name: *const ::std::os::raw::c_char,
11480 labelindex: ::std::os::raw::c_int,
11481 label: *mut ::std::os::raw::c_char,
11482 size: ::std::os::raw::c_int,
11483 retrieved: *mut ::std::os::raw::c_int,
11484 ) -> FMOD_RESULT;
11485}
11486extern "C" {
11487 #[must_use]
11488 pub fn FMOD_Studio_EventDescription_GetParameterLabelByID(
11489 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11490 id: FMOD_STUDIO_PARAMETER_ID,
11491 labelindex: ::std::os::raw::c_int,
11492 label: *mut ::std::os::raw::c_char,
11493 size: ::std::os::raw::c_int,
11494 retrieved: *mut ::std::os::raw::c_int,
11495 ) -> FMOD_RESULT;
11496}
11497extern "C" {
11498 #[must_use]
11499 pub fn FMOD_Studio_EventDescription_GetUserPropertyCount(
11500 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11501 count: *mut ::std::os::raw::c_int,
11502 ) -> FMOD_RESULT;
11503}
11504extern "C" {
11505 #[must_use]
11506 pub fn FMOD_Studio_EventDescription_GetUserPropertyByIndex(
11507 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11508 index: ::std::os::raw::c_int,
11509 property: *mut FMOD_STUDIO_USER_PROPERTY,
11510 ) -> FMOD_RESULT;
11511}
11512extern "C" {
11513 #[must_use]
11514 pub fn FMOD_Studio_EventDescription_GetUserProperty(
11515 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11516 name: *const ::std::os::raw::c_char,
11517 property: *mut FMOD_STUDIO_USER_PROPERTY,
11518 ) -> FMOD_RESULT;
11519}
11520extern "C" {
11521 #[must_use]
11522 pub fn FMOD_Studio_EventDescription_GetLength(
11523 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11524 length: *mut ::std::os::raw::c_int,
11525 ) -> FMOD_RESULT;
11526}
11527extern "C" {
11528 #[must_use]
11529 pub fn FMOD_Studio_EventDescription_GetMinMaxDistance(
11530 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11531 min: *mut f32,
11532 max: *mut f32,
11533 ) -> FMOD_RESULT;
11534}
11535extern "C" {
11536 #[must_use]
11537 pub fn FMOD_Studio_EventDescription_GetSoundSize(
11538 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11539 size: *mut f32,
11540 ) -> FMOD_RESULT;
11541}
11542extern "C" {
11543 #[must_use]
11544 pub fn FMOD_Studio_EventDescription_IsSnapshot(
11545 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11546 snapshot: *mut FMOD_BOOL,
11547 ) -> FMOD_RESULT;
11548}
11549extern "C" {
11550 #[must_use]
11551 pub fn FMOD_Studio_EventDescription_IsOneshot(
11552 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11553 oneshot: *mut FMOD_BOOL,
11554 ) -> FMOD_RESULT;
11555}
11556extern "C" {
11557 #[must_use]
11558 pub fn FMOD_Studio_EventDescription_IsStream(
11559 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11560 isStream: *mut FMOD_BOOL,
11561 ) -> FMOD_RESULT;
11562}
11563extern "C" {
11564 #[must_use]
11565 pub fn FMOD_Studio_EventDescription_Is3D(
11566 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11567 is3D: *mut FMOD_BOOL,
11568 ) -> FMOD_RESULT;
11569}
11570extern "C" {
11571 #[must_use]
11572 pub fn FMOD_Studio_EventDescription_IsDopplerEnabled(
11573 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11574 doppler: *mut FMOD_BOOL,
11575 ) -> FMOD_RESULT;
11576}
11577extern "C" {
11578 #[must_use]
11579 pub fn FMOD_Studio_EventDescription_HasSustainPoint(
11580 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11581 sustainPoint: *mut FMOD_BOOL,
11582 ) -> FMOD_RESULT;
11583}
11584extern "C" {
11585 #[must_use]
11586 pub fn FMOD_Studio_EventDescription_CreateInstance(
11587 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11588 instance: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
11589 ) -> FMOD_RESULT;
11590}
11591extern "C" {
11592 #[must_use]
11593 pub fn FMOD_Studio_EventDescription_GetInstanceCount(
11594 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11595 count: *mut ::std::os::raw::c_int,
11596 ) -> FMOD_RESULT;
11597}
11598extern "C" {
11599 #[must_use]
11600 pub fn FMOD_Studio_EventDescription_GetInstanceList(
11601 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11602 array: *mut *mut FMOD_STUDIO_EVENTINSTANCE,
11603 capacity: ::std::os::raw::c_int,
11604 count: *mut ::std::os::raw::c_int,
11605 ) -> FMOD_RESULT;
11606}
11607extern "C" {
11608 #[must_use]
11609 pub fn FMOD_Studio_EventDescription_LoadSampleData(
11610 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11611 ) -> FMOD_RESULT;
11612}
11613extern "C" {
11614 #[must_use]
11615 pub fn FMOD_Studio_EventDescription_UnloadSampleData(
11616 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11617 ) -> FMOD_RESULT;
11618}
11619extern "C" {
11620 #[must_use]
11621 pub fn FMOD_Studio_EventDescription_GetSampleLoadingState(
11622 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11623 state: *mut FMOD_STUDIO_LOADING_STATE,
11624 ) -> FMOD_RESULT;
11625}
11626extern "C" {
11627 #[must_use]
11628 pub fn FMOD_Studio_EventDescription_ReleaseAllInstances(
11629 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11630 ) -> FMOD_RESULT;
11631}
11632extern "C" {
11633 #[must_use]
11634 pub fn FMOD_Studio_EventDescription_SetCallback(
11635 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11636 callback: FMOD_STUDIO_EVENT_CALLBACK,
11637 callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
11638 ) -> FMOD_RESULT;
11639}
11640extern "C" {
11641 #[must_use]
11642 pub fn FMOD_Studio_EventDescription_GetUserData(
11643 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11644 userdata: *mut *mut ::std::os::raw::c_void,
11645 ) -> FMOD_RESULT;
11646}
11647extern "C" {
11648 #[must_use]
11649 pub fn FMOD_Studio_EventDescription_SetUserData(
11650 eventdescription: *mut FMOD_STUDIO_EVENTDESCRIPTION,
11651 userdata: *mut ::std::os::raw::c_void,
11652 ) -> FMOD_RESULT;
11653}
11654extern "C" {
11655 pub fn FMOD_Studio_EventInstance_IsValid(
11656 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11657 ) -> FMOD_BOOL;
11658}
11659extern "C" {
11660 #[must_use]
11661 pub fn FMOD_Studio_EventInstance_GetDescription(
11662 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11663 description: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
11664 ) -> FMOD_RESULT;
11665}
11666extern "C" {
11667 #[must_use]
11668 pub fn FMOD_Studio_EventInstance_GetVolume(
11669 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11670 volume: *mut f32,
11671 finalvolume: *mut f32,
11672 ) -> FMOD_RESULT;
11673}
11674extern "C" {
11675 #[must_use]
11676 pub fn FMOD_Studio_EventInstance_SetVolume(
11677 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11678 volume: f32,
11679 ) -> FMOD_RESULT;
11680}
11681extern "C" {
11682 #[must_use]
11683 pub fn FMOD_Studio_EventInstance_GetPitch(
11684 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11685 pitch: *mut f32,
11686 finalpitch: *mut f32,
11687 ) -> FMOD_RESULT;
11688}
11689extern "C" {
11690 #[must_use]
11691 pub fn FMOD_Studio_EventInstance_SetPitch(
11692 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11693 pitch: f32,
11694 ) -> FMOD_RESULT;
11695}
11696extern "C" {
11697 #[must_use]
11698 pub fn FMOD_Studio_EventInstance_Get3DAttributes(
11699 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11700 attributes: *mut FMOD_3D_ATTRIBUTES,
11701 ) -> FMOD_RESULT;
11702}
11703extern "C" {
11704 #[must_use]
11705 pub fn FMOD_Studio_EventInstance_Set3DAttributes(
11706 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11707 attributes: *mut FMOD_3D_ATTRIBUTES,
11708 ) -> FMOD_RESULT;
11709}
11710extern "C" {
11711 #[must_use]
11712 pub fn FMOD_Studio_EventInstance_GetListenerMask(
11713 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11714 mask: *mut ::std::os::raw::c_uint,
11715 ) -> FMOD_RESULT;
11716}
11717extern "C" {
11718 #[must_use]
11719 pub fn FMOD_Studio_EventInstance_SetListenerMask(
11720 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11721 mask: ::std::os::raw::c_uint,
11722 ) -> FMOD_RESULT;
11723}
11724extern "C" {
11725 #[must_use]
11726 pub fn FMOD_Studio_EventInstance_GetProperty(
11727 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11728 index: FMOD_STUDIO_EVENT_PROPERTY,
11729 value: *mut f32,
11730 ) -> FMOD_RESULT;
11731}
11732extern "C" {
11733 #[must_use]
11734 pub fn FMOD_Studio_EventInstance_SetProperty(
11735 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11736 index: FMOD_STUDIO_EVENT_PROPERTY,
11737 value: f32,
11738 ) -> FMOD_RESULT;
11739}
11740extern "C" {
11741 #[must_use]
11742 pub fn FMOD_Studio_EventInstance_GetReverbLevel(
11743 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11744 index: ::std::os::raw::c_int,
11745 level: *mut f32,
11746 ) -> FMOD_RESULT;
11747}
11748extern "C" {
11749 #[must_use]
11750 pub fn FMOD_Studio_EventInstance_SetReverbLevel(
11751 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11752 index: ::std::os::raw::c_int,
11753 level: f32,
11754 ) -> FMOD_RESULT;
11755}
11756extern "C" {
11757 #[must_use]
11758 pub fn FMOD_Studio_EventInstance_GetPaused(
11759 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11760 paused: *mut FMOD_BOOL,
11761 ) -> FMOD_RESULT;
11762}
11763extern "C" {
11764 #[must_use]
11765 pub fn FMOD_Studio_EventInstance_SetPaused(
11766 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11767 paused: FMOD_BOOL,
11768 ) -> FMOD_RESULT;
11769}
11770extern "C" {
11771 #[must_use]
11772 pub fn FMOD_Studio_EventInstance_Start(
11773 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11774 ) -> FMOD_RESULT;
11775}
11776extern "C" {
11777 #[must_use]
11778 pub fn FMOD_Studio_EventInstance_Stop(
11779 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11780 mode: FMOD_STUDIO_STOP_MODE,
11781 ) -> FMOD_RESULT;
11782}
11783extern "C" {
11784 #[must_use]
11785 pub fn FMOD_Studio_EventInstance_GetTimelinePosition(
11786 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11787 position: *mut ::std::os::raw::c_int,
11788 ) -> FMOD_RESULT;
11789}
11790extern "C" {
11791 #[must_use]
11792 pub fn FMOD_Studio_EventInstance_SetTimelinePosition(
11793 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11794 position: ::std::os::raw::c_int,
11795 ) -> FMOD_RESULT;
11796}
11797extern "C" {
11798 #[must_use]
11799 pub fn FMOD_Studio_EventInstance_GetPlaybackState(
11800 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11801 state: *mut FMOD_STUDIO_PLAYBACK_STATE,
11802 ) -> FMOD_RESULT;
11803}
11804extern "C" {
11805 #[must_use]
11806 pub fn FMOD_Studio_EventInstance_GetChannelGroup(
11807 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11808 group: *mut *mut FMOD_CHANNELGROUP,
11809 ) -> FMOD_RESULT;
11810}
11811extern "C" {
11812 #[must_use]
11813 pub fn FMOD_Studio_EventInstance_GetMinMaxDistance(
11814 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11815 min: *mut f32,
11816 max: *mut f32,
11817 ) -> FMOD_RESULT;
11818}
11819extern "C" {
11820 #[must_use]
11821 pub fn FMOD_Studio_EventInstance_Release(
11822 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11823 ) -> FMOD_RESULT;
11824}
11825extern "C" {
11826 #[must_use]
11827 pub fn FMOD_Studio_EventInstance_IsVirtual(
11828 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11829 virtualstate: *mut FMOD_BOOL,
11830 ) -> FMOD_RESULT;
11831}
11832extern "C" {
11833 #[must_use]
11834 pub fn FMOD_Studio_EventInstance_GetParameterByName(
11835 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11836 name: *const ::std::os::raw::c_char,
11837 value: *mut f32,
11838 finalvalue: *mut f32,
11839 ) -> FMOD_RESULT;
11840}
11841extern "C" {
11842 #[must_use]
11843 pub fn FMOD_Studio_EventInstance_SetParameterByName(
11844 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11845 name: *const ::std::os::raw::c_char,
11846 value: f32,
11847 ignoreseekspeed: FMOD_BOOL,
11848 ) -> FMOD_RESULT;
11849}
11850extern "C" {
11851 #[must_use]
11852 pub fn FMOD_Studio_EventInstance_SetParameterByNameWithLabel(
11853 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11854 name: *const ::std::os::raw::c_char,
11855 label: *const ::std::os::raw::c_char,
11856 ignoreseekspeed: FMOD_BOOL,
11857 ) -> FMOD_RESULT;
11858}
11859extern "C" {
11860 #[must_use]
11861 pub fn FMOD_Studio_EventInstance_GetParameterByID(
11862 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11863 id: FMOD_STUDIO_PARAMETER_ID,
11864 value: *mut f32,
11865 finalvalue: *mut f32,
11866 ) -> FMOD_RESULT;
11867}
11868extern "C" {
11869 #[must_use]
11870 pub fn FMOD_Studio_EventInstance_SetParameterByID(
11871 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11872 id: FMOD_STUDIO_PARAMETER_ID,
11873 value: f32,
11874 ignoreseekspeed: FMOD_BOOL,
11875 ) -> FMOD_RESULT;
11876}
11877extern "C" {
11878 #[must_use]
11879 pub fn FMOD_Studio_EventInstance_SetParameterByIDWithLabel(
11880 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11881 id: FMOD_STUDIO_PARAMETER_ID,
11882 label: *const ::std::os::raw::c_char,
11883 ignoreseekspeed: FMOD_BOOL,
11884 ) -> FMOD_RESULT;
11885}
11886extern "C" {
11887 #[must_use]
11888 pub fn FMOD_Studio_EventInstance_SetParametersByIDs(
11889 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11890 ids: *const FMOD_STUDIO_PARAMETER_ID,
11891 values: *mut f32,
11892 count: ::std::os::raw::c_int,
11893 ignoreseekspeed: FMOD_BOOL,
11894 ) -> FMOD_RESULT;
11895}
11896extern "C" {
11897 #[must_use]
11898 pub fn FMOD_Studio_EventInstance_KeyOff(
11899 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11900 ) -> FMOD_RESULT;
11901}
11902extern "C" {
11903 #[must_use]
11904 pub fn FMOD_Studio_EventInstance_SetCallback(
11905 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11906 callback: FMOD_STUDIO_EVENT_CALLBACK,
11907 callbackmask: FMOD_STUDIO_EVENT_CALLBACK_TYPE,
11908 ) -> FMOD_RESULT;
11909}
11910extern "C" {
11911 #[must_use]
11912 pub fn FMOD_Studio_EventInstance_GetUserData(
11913 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11914 userdata: *mut *mut ::std::os::raw::c_void,
11915 ) -> FMOD_RESULT;
11916}
11917extern "C" {
11918 #[must_use]
11919 pub fn FMOD_Studio_EventInstance_SetUserData(
11920 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11921 userdata: *mut ::std::os::raw::c_void,
11922 ) -> FMOD_RESULT;
11923}
11924extern "C" {
11925 #[must_use]
11926 pub fn FMOD_Studio_EventInstance_GetCPUUsage(
11927 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11928 exclusive: *mut ::std::os::raw::c_uint,
11929 inclusive: *mut ::std::os::raw::c_uint,
11930 ) -> FMOD_RESULT;
11931}
11932extern "C" {
11933 #[must_use]
11934 pub fn FMOD_Studio_EventInstance_GetMemoryUsage(
11935 eventinstance: *mut FMOD_STUDIO_EVENTINSTANCE,
11936 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
11937 ) -> FMOD_RESULT;
11938}
11939extern "C" {
11940 pub fn FMOD_Studio_Bus_IsValid(bus: *mut FMOD_STUDIO_BUS) -> FMOD_BOOL;
11941}
11942extern "C" {
11943 #[must_use]
11944 pub fn FMOD_Studio_Bus_GetID(bus: *mut FMOD_STUDIO_BUS, id: *mut FMOD_GUID) -> FMOD_RESULT;
11945}
11946extern "C" {
11947 #[must_use]
11948 pub fn FMOD_Studio_Bus_GetPath(
11949 bus: *mut FMOD_STUDIO_BUS,
11950 path: *mut ::std::os::raw::c_char,
11951 size: ::std::os::raw::c_int,
11952 retrieved: *mut ::std::os::raw::c_int,
11953 ) -> FMOD_RESULT;
11954}
11955extern "C" {
11956 #[must_use]
11957 pub fn FMOD_Studio_Bus_GetVolume(
11958 bus: *mut FMOD_STUDIO_BUS,
11959 volume: *mut f32,
11960 finalvolume: *mut f32,
11961 ) -> FMOD_RESULT;
11962}
11963extern "C" {
11964 #[must_use]
11965 pub fn FMOD_Studio_Bus_SetVolume(bus: *mut FMOD_STUDIO_BUS, volume: f32) -> FMOD_RESULT;
11966}
11967extern "C" {
11968 #[must_use]
11969 pub fn FMOD_Studio_Bus_GetPaused(
11970 bus: *mut FMOD_STUDIO_BUS,
11971 paused: *mut FMOD_BOOL,
11972 ) -> FMOD_RESULT;
11973}
11974extern "C" {
11975 #[must_use]
11976 pub fn FMOD_Studio_Bus_SetPaused(bus: *mut FMOD_STUDIO_BUS, paused: FMOD_BOOL) -> FMOD_RESULT;
11977}
11978extern "C" {
11979 #[must_use]
11980 pub fn FMOD_Studio_Bus_GetMute(bus: *mut FMOD_STUDIO_BUS, mute: *mut FMOD_BOOL) -> FMOD_RESULT;
11981}
11982extern "C" {
11983 #[must_use]
11984 pub fn FMOD_Studio_Bus_SetMute(bus: *mut FMOD_STUDIO_BUS, mute: FMOD_BOOL) -> FMOD_RESULT;
11985}
11986extern "C" {
11987 #[must_use]
11988 pub fn FMOD_Studio_Bus_StopAllEvents(
11989 bus: *mut FMOD_STUDIO_BUS,
11990 mode: FMOD_STUDIO_STOP_MODE,
11991 ) -> FMOD_RESULT;
11992}
11993extern "C" {
11994 #[must_use]
11995 pub fn FMOD_Studio_Bus_GetPortIndex(
11996 bus: *mut FMOD_STUDIO_BUS,
11997 index: *mut FMOD_PORT_INDEX,
11998 ) -> FMOD_RESULT;
11999}
12000extern "C" {
12001 #[must_use]
12002 pub fn FMOD_Studio_Bus_SetPortIndex(
12003 bus: *mut FMOD_STUDIO_BUS,
12004 index: FMOD_PORT_INDEX,
12005 ) -> FMOD_RESULT;
12006}
12007extern "C" {
12008 #[must_use]
12009 pub fn FMOD_Studio_Bus_LockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
12010}
12011extern "C" {
12012 #[must_use]
12013 pub fn FMOD_Studio_Bus_UnlockChannelGroup(bus: *mut FMOD_STUDIO_BUS) -> FMOD_RESULT;
12014}
12015extern "C" {
12016 #[must_use]
12017 pub fn FMOD_Studio_Bus_GetChannelGroup(
12018 bus: *mut FMOD_STUDIO_BUS,
12019 group: *mut *mut FMOD_CHANNELGROUP,
12020 ) -> FMOD_RESULT;
12021}
12022extern "C" {
12023 #[must_use]
12024 pub fn FMOD_Studio_Bus_GetCPUUsage(
12025 bus: *mut FMOD_STUDIO_BUS,
12026 exclusive: *mut ::std::os::raw::c_uint,
12027 inclusive: *mut ::std::os::raw::c_uint,
12028 ) -> FMOD_RESULT;
12029}
12030extern "C" {
12031 #[must_use]
12032 pub fn FMOD_Studio_Bus_GetMemoryUsage(
12033 bus: *mut FMOD_STUDIO_BUS,
12034 memoryusage: *mut FMOD_STUDIO_MEMORY_USAGE,
12035 ) -> FMOD_RESULT;
12036}
12037extern "C" {
12038 pub fn FMOD_Studio_VCA_IsValid(vca: *mut FMOD_STUDIO_VCA) -> FMOD_BOOL;
12039}
12040extern "C" {
12041 #[must_use]
12042 pub fn FMOD_Studio_VCA_GetID(vca: *mut FMOD_STUDIO_VCA, id: *mut FMOD_GUID) -> FMOD_RESULT;
12043}
12044extern "C" {
12045 #[must_use]
12046 pub fn FMOD_Studio_VCA_GetPath(
12047 vca: *mut FMOD_STUDIO_VCA,
12048 path: *mut ::std::os::raw::c_char,
12049 size: ::std::os::raw::c_int,
12050 retrieved: *mut ::std::os::raw::c_int,
12051 ) -> FMOD_RESULT;
12052}
12053extern "C" {
12054 #[must_use]
12055 pub fn FMOD_Studio_VCA_GetVolume(
12056 vca: *mut FMOD_STUDIO_VCA,
12057 volume: *mut f32,
12058 finalvolume: *mut f32,
12059 ) -> FMOD_RESULT;
12060}
12061extern "C" {
12062 #[must_use]
12063 pub fn FMOD_Studio_VCA_SetVolume(vca: *mut FMOD_STUDIO_VCA, volume: f32) -> FMOD_RESULT;
12064}
12065extern "C" {
12066 pub fn FMOD_Studio_Bank_IsValid(bank: *mut FMOD_STUDIO_BANK) -> FMOD_BOOL;
12067}
12068extern "C" {
12069 #[must_use]
12070 pub fn FMOD_Studio_Bank_GetID(bank: *mut FMOD_STUDIO_BANK, id: *mut FMOD_GUID) -> FMOD_RESULT;
12071}
12072extern "C" {
12073 #[must_use]
12074 pub fn FMOD_Studio_Bank_GetPath(
12075 bank: *mut FMOD_STUDIO_BANK,
12076 path: *mut ::std::os::raw::c_char,
12077 size: ::std::os::raw::c_int,
12078 retrieved: *mut ::std::os::raw::c_int,
12079 ) -> FMOD_RESULT;
12080}
12081extern "C" {
12082 #[must_use]
12083 pub fn FMOD_Studio_Bank_Unload(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
12084}
12085extern "C" {
12086 #[must_use]
12087 pub fn FMOD_Studio_Bank_LoadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
12088}
12089extern "C" {
12090 #[must_use]
12091 pub fn FMOD_Studio_Bank_UnloadSampleData(bank: *mut FMOD_STUDIO_BANK) -> FMOD_RESULT;
12092}
12093extern "C" {
12094 #[must_use]
12095 pub fn FMOD_Studio_Bank_GetLoadingState(
12096 bank: *mut FMOD_STUDIO_BANK,
12097 state: *mut FMOD_STUDIO_LOADING_STATE,
12098 ) -> FMOD_RESULT;
12099}
12100extern "C" {
12101 #[must_use]
12102 pub fn FMOD_Studio_Bank_GetSampleLoadingState(
12103 bank: *mut FMOD_STUDIO_BANK,
12104 state: *mut FMOD_STUDIO_LOADING_STATE,
12105 ) -> FMOD_RESULT;
12106}
12107extern "C" {
12108 #[must_use]
12109 pub fn FMOD_Studio_Bank_GetStringCount(
12110 bank: *mut FMOD_STUDIO_BANK,
12111 count: *mut ::std::os::raw::c_int,
12112 ) -> FMOD_RESULT;
12113}
12114extern "C" {
12115 #[must_use]
12116 pub fn FMOD_Studio_Bank_GetStringInfo(
12117 bank: *mut FMOD_STUDIO_BANK,
12118 index: ::std::os::raw::c_int,
12119 id: *mut FMOD_GUID,
12120 path: *mut ::std::os::raw::c_char,
12121 size: ::std::os::raw::c_int,
12122 retrieved: *mut ::std::os::raw::c_int,
12123 ) -> FMOD_RESULT;
12124}
12125extern "C" {
12126 #[must_use]
12127 pub fn FMOD_Studio_Bank_GetEventCount(
12128 bank: *mut FMOD_STUDIO_BANK,
12129 count: *mut ::std::os::raw::c_int,
12130 ) -> FMOD_RESULT;
12131}
12132extern "C" {
12133 #[must_use]
12134 pub fn FMOD_Studio_Bank_GetEventList(
12135 bank: *mut FMOD_STUDIO_BANK,
12136 array: *mut *mut FMOD_STUDIO_EVENTDESCRIPTION,
12137 capacity: ::std::os::raw::c_int,
12138 count: *mut ::std::os::raw::c_int,
12139 ) -> FMOD_RESULT;
12140}
12141extern "C" {
12142 #[must_use]
12143 pub fn FMOD_Studio_Bank_GetBusCount(
12144 bank: *mut FMOD_STUDIO_BANK,
12145 count: *mut ::std::os::raw::c_int,
12146 ) -> FMOD_RESULT;
12147}
12148extern "C" {
12149 #[must_use]
12150 pub fn FMOD_Studio_Bank_GetBusList(
12151 bank: *mut FMOD_STUDIO_BANK,
12152 array: *mut *mut FMOD_STUDIO_BUS,
12153 capacity: ::std::os::raw::c_int,
12154 count: *mut ::std::os::raw::c_int,
12155 ) -> FMOD_RESULT;
12156}
12157extern "C" {
12158 #[must_use]
12159 pub fn FMOD_Studio_Bank_GetVCACount(
12160 bank: *mut FMOD_STUDIO_BANK,
12161 count: *mut ::std::os::raw::c_int,
12162 ) -> FMOD_RESULT;
12163}
12164extern "C" {
12165 #[must_use]
12166 pub fn FMOD_Studio_Bank_GetVCAList(
12167 bank: *mut FMOD_STUDIO_BANK,
12168 array: *mut *mut FMOD_STUDIO_VCA,
12169 capacity: ::std::os::raw::c_int,
12170 count: *mut ::std::os::raw::c_int,
12171 ) -> FMOD_RESULT;
12172}
12173extern "C" {
12174 #[must_use]
12175 pub fn FMOD_Studio_Bank_GetUserData(
12176 bank: *mut FMOD_STUDIO_BANK,
12177 userdata: *mut *mut ::std::os::raw::c_void,
12178 ) -> FMOD_RESULT;
12179}
12180extern "C" {
12181 #[must_use]
12182 pub fn FMOD_Studio_Bank_SetUserData(
12183 bank: *mut FMOD_STUDIO_BANK,
12184 userdata: *mut ::std::os::raw::c_void,
12185 ) -> FMOD_RESULT;
12186}
12187extern "C" {
12188 pub fn FMOD_Studio_CommandReplay_IsValid(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_BOOL;
12189}
12190extern "C" {
12191 #[must_use]
12192 pub fn FMOD_Studio_CommandReplay_GetSystem(
12193 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12194 system: *mut *mut FMOD_STUDIO_SYSTEM,
12195 ) -> FMOD_RESULT;
12196}
12197extern "C" {
12198 #[must_use]
12199 pub fn FMOD_Studio_CommandReplay_GetLength(
12200 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12201 length: *mut f32,
12202 ) -> FMOD_RESULT;
12203}
12204extern "C" {
12205 #[must_use]
12206 pub fn FMOD_Studio_CommandReplay_GetCommandCount(
12207 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12208 count: *mut ::std::os::raw::c_int,
12209 ) -> FMOD_RESULT;
12210}
12211extern "C" {
12212 #[must_use]
12213 pub fn FMOD_Studio_CommandReplay_GetCommandInfo(
12214 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12215 commandindex: ::std::os::raw::c_int,
12216 info: *mut FMOD_STUDIO_COMMAND_INFO,
12217 ) -> FMOD_RESULT;
12218}
12219extern "C" {
12220 #[must_use]
12221 pub fn FMOD_Studio_CommandReplay_GetCommandString(
12222 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12223 commandindex: ::std::os::raw::c_int,
12224 buffer: *mut ::std::os::raw::c_char,
12225 length: ::std::os::raw::c_int,
12226 ) -> FMOD_RESULT;
12227}
12228extern "C" {
12229 #[must_use]
12230 pub fn FMOD_Studio_CommandReplay_GetCommandAtTime(
12231 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12232 time: f32,
12233 commandindex: *mut ::std::os::raw::c_int,
12234 ) -> FMOD_RESULT;
12235}
12236extern "C" {
12237 #[must_use]
12238 pub fn FMOD_Studio_CommandReplay_SetBankPath(
12239 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12240 bankPath: *const ::std::os::raw::c_char,
12241 ) -> FMOD_RESULT;
12242}
12243extern "C" {
12244 #[must_use]
12245 pub fn FMOD_Studio_CommandReplay_Start(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
12246}
12247extern "C" {
12248 #[must_use]
12249 pub fn FMOD_Studio_CommandReplay_Stop(replay: *mut FMOD_STUDIO_COMMANDREPLAY) -> FMOD_RESULT;
12250}
12251extern "C" {
12252 #[must_use]
12253 pub fn FMOD_Studio_CommandReplay_SeekToTime(
12254 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12255 time: f32,
12256 ) -> FMOD_RESULT;
12257}
12258extern "C" {
12259 #[must_use]
12260 pub fn FMOD_Studio_CommandReplay_SeekToCommand(
12261 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12262 commandindex: ::std::os::raw::c_int,
12263 ) -> FMOD_RESULT;
12264}
12265extern "C" {
12266 #[must_use]
12267 pub fn FMOD_Studio_CommandReplay_GetPaused(
12268 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12269 paused: *mut FMOD_BOOL,
12270 ) -> FMOD_RESULT;
12271}
12272extern "C" {
12273 #[must_use]
12274 pub fn FMOD_Studio_CommandReplay_SetPaused(
12275 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12276 paused: FMOD_BOOL,
12277 ) -> FMOD_RESULT;
12278}
12279extern "C" {
12280 #[must_use]
12281 pub fn FMOD_Studio_CommandReplay_GetPlaybackState(
12282 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12283 state: *mut FMOD_STUDIO_PLAYBACK_STATE,
12284 ) -> FMOD_RESULT;
12285}
12286extern "C" {
12287 #[must_use]
12288 pub fn FMOD_Studio_CommandReplay_GetCurrentCommand(
12289 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12290 commandindex: *mut ::std::os::raw::c_int,
12291 currenttime: *mut f32,
12292 ) -> FMOD_RESULT;
12293}
12294extern "C" {
12295 #[must_use]
12296 pub fn FMOD_Studio_CommandReplay_Release(replay: *mut FMOD_STUDIO_COMMANDREPLAY)
12297 -> FMOD_RESULT;
12298}
12299extern "C" {
12300 #[must_use]
12301 pub fn FMOD_Studio_CommandReplay_SetFrameCallback(
12302 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12303 callback: FMOD_STUDIO_COMMANDREPLAY_FRAME_CALLBACK,
12304 ) -> FMOD_RESULT;
12305}
12306extern "C" {
12307 #[must_use]
12308 pub fn FMOD_Studio_CommandReplay_SetLoadBankCallback(
12309 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12310 callback: FMOD_STUDIO_COMMANDREPLAY_LOAD_BANK_CALLBACK,
12311 ) -> FMOD_RESULT;
12312}
12313extern "C" {
12314 #[must_use]
12315 pub fn FMOD_Studio_CommandReplay_SetCreateInstanceCallback(
12316 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12317 callback: FMOD_STUDIO_COMMANDREPLAY_CREATE_INSTANCE_CALLBACK,
12318 ) -> FMOD_RESULT;
12319}
12320extern "C" {
12321 #[must_use]
12322 pub fn FMOD_Studio_CommandReplay_GetUserData(
12323 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12324 userdata: *mut *mut ::std::os::raw::c_void,
12325 ) -> FMOD_RESULT;
12326}
12327extern "C" {
12328 #[must_use]
12329 pub fn FMOD_Studio_CommandReplay_SetUserData(
12330 replay: *mut FMOD_STUDIO_COMMANDREPLAY,
12331 userdata: *mut ::std::os::raw::c_void,
12332 ) -> FMOD_RESULT;
12333}