1#![allow(non_camel_case_types)]
4#![allow(non_snake_case)]
5pub type sl_int32_t = i32;
6pub type sl_uint32_t = u32;
7
8#[repr(C)]
9#[derive(Default)]
10pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
11impl<T> __IncompleteArrayField<T> {
12 #[inline]
13 pub const fn new() -> Self {
14 __IncompleteArrayField(::std::marker::PhantomData, [])
15 }
16 #[inline]
17 pub unsafe fn as_ptr(&self) -> *const T {
18 ::std::mem::transmute(self)
19 }
20 #[inline]
21 pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
22 ::std::mem::transmute(self)
23 }
24 #[inline]
25 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
26 ::std::slice::from_raw_parts(self.as_ptr(), len)
27 }
28 #[inline]
29 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
30 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
31 }
32}
33impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
34 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
35 fmt.write_str("__IncompleteArrayField")
36 }
37}
38impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
39 #[inline]
40 fn clone(&self) -> Self {
41 Self::new()
42 }
43}
44pub const KHRONOS_TITLE: &'static [u8; 13usize] = b"KhronosTitle\0";
45pub const KHRONOS_ALBUM: &'static [u8; 13usize] = b"KhronosAlbum\0";
46pub const KHRONOS_TRACK_NUMBER: &'static [u8; 19usize] = b"KhronosTrackNumber\0";
47pub const KHRONOS_ARTIST: &'static [u8; 14usize] = b"KhronosArtist\0";
48pub const KHRONOS_GENRE: &'static [u8; 13usize] = b"KhronosGenre\0";
49pub const KHRONOS_YEAR: &'static [u8; 12usize] = b"KhronosYear\0";
50pub const KHRONOS_COMMENT: &'static [u8; 15usize] = b"KhronosComment\0";
51pub const KHRONOS_ARTIST_URL: &'static [u8; 17usize] = b"KhronosArtistURL\0";
52pub const KHRONOS_CONTENT_URL: &'static [u8; 18usize] = b"KhronosContentURL\0";
53pub const KHRONOS_RATING: &'static [u8; 14usize] = b"KhronosRating\0";
54pub const KHRONOS_ALBUM_ART: &'static [u8; 16usize] = b"KhronosAlbumArt\0";
55pub const KHRONOS_COPYRIGHT: &'static [u8; 17usize] = b"KhronosCopyright\0";
56pub const SL_BOOLEAN_FALSE: u32 = 0;
57pub const SL_BOOLEAN_TRUE: u32 = 1;
58pub const SL_OBJECTID_ENGINE: u32 = 4097;
59pub const SL_OBJECTID_LEDDEVICE: u32 = 4098;
60pub const SL_OBJECTID_VIBRADEVICE: u32 = 4099;
61pub const SL_OBJECTID_AUDIOPLAYER: u32 = 4100;
62pub const SL_OBJECTID_AUDIORECORDER: u32 = 4101;
63pub const SL_OBJECTID_MIDIPLAYER: u32 = 4102;
64pub const SL_OBJECTID_LISTENER: u32 = 4103;
65pub const SL_OBJECTID_3DGROUP: u32 = 4104;
66pub const SL_OBJECTID_OUTPUTMIX: u32 = 4105;
67pub const SL_OBJECTID_METADATAEXTRACTOR: u32 = 4106;
68pub const SL_PROFILES_PHONE: u32 = 1;
69pub const SL_PROFILES_MUSIC: u32 = 2;
70pub const SL_PROFILES_GAME: u32 = 4;
71pub const SL_VOICETYPE_2D_AUDIO: u32 = 1;
72pub const SL_VOICETYPE_MIDI: u32 = 2;
73pub const SL_VOICETYPE_3D_AUDIO: u32 = 4;
74pub const SL_VOICETYPE_3D_MIDIOUTPUT: u32 = 8;
75pub const SL_PRIORITY_LOWEST: u32 = 4294967295;
76pub const SL_PRIORITY_VERYLOW: u32 = 3758096384;
77pub const SL_PRIORITY_LOW: u32 = 3221225472;
78pub const SL_PRIORITY_BELOWNORMAL: u32 = 2684354560;
79pub const SL_PRIORITY_NORMAL: u32 = 2147483647;
80pub const SL_PRIORITY_ABOVENORMAL: u32 = 1610612736;
81pub const SL_PRIORITY_HIGH: u32 = 1073741824;
82pub const SL_PRIORITY_VERYHIGH: u32 = 536870912;
83pub const SL_PRIORITY_HIGHEST: u32 = 0;
84pub const SL_PCM_REPRESENTATION_SIGNED_INT: u32 = 1;
85pub const SL_PCM_REPRESENTATION_UNSIGNED_INT: u32 = 2;
86pub const SL_PCM_REPRESENTATION_FLOAT: u32 = 3;
87pub const SL_PCMSAMPLEFORMAT_FIXED_8: u32 = 8;
88pub const SL_PCMSAMPLEFORMAT_FIXED_16: u32 = 16;
89pub const SL_PCMSAMPLEFORMAT_FIXED_20: u32 = 20;
90pub const SL_PCMSAMPLEFORMAT_FIXED_24: u32 = 24;
91pub const SL_PCMSAMPLEFORMAT_FIXED_28: u32 = 28;
92pub const SL_PCMSAMPLEFORMAT_FIXED_32: u32 = 32;
93pub const SL_PCMSAMPLEFORMAT_FIXED_64: u32 = 64;
94pub const SL_SAMPLINGRATE_8: u32 = 8000000;
95pub const SL_SAMPLINGRATE_11_025: u32 = 11025000;
96pub const SL_SAMPLINGRATE_12: u32 = 12000000;
97pub const SL_SAMPLINGRATE_16: u32 = 16000000;
98pub const SL_SAMPLINGRATE_22_05: u32 = 22050000;
99pub const SL_SAMPLINGRATE_24: u32 = 24000000;
100pub const SL_SAMPLINGRATE_32: u32 = 32000000;
101pub const SL_SAMPLINGRATE_44_1: u32 = 44100000;
102pub const SL_SAMPLINGRATE_48: u32 = 48000000;
103pub const SL_SAMPLINGRATE_64: u32 = 64000000;
104pub const SL_SAMPLINGRATE_88_2: u32 = 88200000;
105pub const SL_SAMPLINGRATE_96: u32 = 96000000;
106pub const SL_SAMPLINGRATE_192: u32 = 192000000;
107pub const SL_SPEAKER_FRONT_LEFT: u32 = 1;
108pub const SL_SPEAKER_FRONT_RIGHT: u32 = 2;
109pub const SL_SPEAKER_FRONT_CENTER: u32 = 4;
110pub const SL_SPEAKER_LOW_FREQUENCY: u32 = 8;
111pub const SL_SPEAKER_BACK_LEFT: u32 = 16;
112pub const SL_SPEAKER_BACK_RIGHT: u32 = 32;
113pub const SL_SPEAKER_FRONT_LEFT_OF_CENTER: u32 = 64;
114pub const SL_SPEAKER_FRONT_RIGHT_OF_CENTER: u32 = 128;
115pub const SL_SPEAKER_BACK_CENTER: u32 = 256;
116pub const SL_SPEAKER_SIDE_LEFT: u32 = 512;
117pub const SL_SPEAKER_SIDE_RIGHT: u32 = 1024;
118pub const SL_SPEAKER_TOP_CENTER: u32 = 2048;
119pub const SL_SPEAKER_TOP_FRONT_LEFT: u32 = 4096;
120pub const SL_SPEAKER_TOP_FRONT_CENTER: u32 = 8192;
121pub const SL_SPEAKER_TOP_FRONT_RIGHT: u32 = 16384;
122pub const SL_SPEAKER_TOP_BACK_LEFT: u32 = 32768;
123pub const SL_SPEAKER_TOP_BACK_CENTER: u32 = 65536;
124pub const SL_SPEAKER_TOP_BACK_RIGHT: u32 = 131072;
125pub const SL_RESULT_SUCCESS: u32 = 0;
126pub const SL_RESULT_PRECONDITIONS_VIOLATED: u32 = 1;
127pub const SL_RESULT_PARAMETER_INVALID: u32 = 2;
128pub const SL_RESULT_MEMORY_FAILURE: u32 = 3;
129pub const SL_RESULT_RESOURCE_ERROR: u32 = 4;
130pub const SL_RESULT_RESOURCE_LOST: u32 = 5;
131pub const SL_RESULT_IO_ERROR: u32 = 6;
132pub const SL_RESULT_BUFFER_INSUFFICIENT: u32 = 7;
133pub const SL_RESULT_CONTENT_CORRUPTED: u32 = 8;
134pub const SL_RESULT_CONTENT_UNSUPPORTED: u32 = 9;
135pub const SL_RESULT_CONTENT_NOT_FOUND: u32 = 10;
136pub const SL_RESULT_PERMISSION_DENIED: u32 = 11;
137pub const SL_RESULT_FEATURE_UNSUPPORTED: u32 = 12;
138pub const SL_RESULT_INTERNAL_ERROR: u32 = 13;
139pub const SL_RESULT_UNKNOWN_ERROR: u32 = 14;
140pub const SL_RESULT_OPERATION_ABORTED: u32 = 15;
141pub const SL_RESULT_CONTROL_LOST: u32 = 16;
142pub const SL_RESULT_READONLY: u32 = 17;
143pub const SL_RESULT_ENGINEOPTION_UNSUPPORTED: u32 = 18;
144pub const SL_RESULT_SOURCE_SINK_INCOMPATIBLE: u32 = 19;
145pub const SL_OBJECT_STATE_UNREALIZED: u32 = 1;
146pub const SL_OBJECT_STATE_REALIZED: u32 = 2;
147pub const SL_OBJECT_STATE_SUSPENDED: u32 = 3;
148pub const SL_OBJECT_EVENT_RUNTIME_ERROR: u32 = 1;
149pub const SL_OBJECT_EVENT_ASYNC_TERMINATION: u32 = 2;
150pub const SL_OBJECT_EVENT_RESOURCES_LOST: u32 = 3;
151pub const SL_OBJECT_EVENT_RESOURCES_AVAILABLE: u32 = 4;
152pub const SL_OBJECT_EVENT_ITF_CONTROL_TAKEN: u32 = 5;
153pub const SL_OBJECT_EVENT_ITF_CONTROL_RETURNED: u32 = 6;
154pub const SL_OBJECT_EVENT_ITF_PARAMETERS_CHANGED: u32 = 7;
155pub const SL_DATALOCATOR_NULL: u32 = 0;
156pub const SL_DATALOCATOR_URI: u32 = 1;
157pub const SL_DATALOCATOR_ADDRESS: u32 = 2;
158pub const SL_DATALOCATOR_IODEVICE: u32 = 3;
159pub const SL_DATALOCATOR_OUTPUTMIX: u32 = 4;
160pub const SL_DATALOCATOR_RESERVED5: u32 = 5;
161pub const SL_DATALOCATOR_BUFFERQUEUE: u32 = 6;
162pub const SL_DATALOCATOR_MIDIBUFFERQUEUE: u32 = 7;
163pub const SL_DATALOCATOR_MEDIAOBJECT: u32 = 8;
164pub const SL_DATALOCATOR_CONTENTPIPE: u32 = 9;
165pub const SL_IODEVICE_AUDIOINPUT: u32 = 1;
166pub const SL_IODEVICE_LEDARRAY: u32 = 2;
167pub const SL_IODEVICE_VIBRA: u32 = 3;
168pub const SL_IODEVICE_RESERVED4: u32 = 4;
169pub const SL_IODEVICE_RESERVED5: u32 = 5;
170pub const SL_IODEVICE_AUDIOOUTPUT: u32 = 6;
171pub const SL_DATAFORMAT_MIME: u32 = 1;
172pub const SL_DATAFORMAT_PCM: u32 = 2;
173pub const SL_DATAFORMAT_RESERVED3: u32 = 3;
174pub const SL_DATAFORMAT_PCM_EX: u32 = 4;
175pub const SL_BYTEORDER_BIGENDIAN: u32 = 1;
176pub const SL_BYTEORDER_LITTLEENDIAN: u32 = 2;
177pub const SL_BYTEORDER_NATIVE: u32 = 2;
178pub const SL_CONTAINERTYPE_UNSPECIFIED: u32 = 1;
179pub const SL_CONTAINERTYPE_RAW: u32 = 2;
180pub const SL_CONTAINERTYPE_ASF: u32 = 3;
181pub const SL_CONTAINERTYPE_AVI: u32 = 4;
182pub const SL_CONTAINERTYPE_BMP: u32 = 5;
183pub const SL_CONTAINERTYPE_JPG: u32 = 6;
184pub const SL_CONTAINERTYPE_JPG2000: u32 = 7;
185pub const SL_CONTAINERTYPE_M4A: u32 = 8;
186pub const SL_CONTAINERTYPE_MP3: u32 = 9;
187pub const SL_CONTAINERTYPE_MP4: u32 = 10;
188pub const SL_CONTAINERTYPE_MPEG_ES: u32 = 11;
189pub const SL_CONTAINERTYPE_MPEG_PS: u32 = 12;
190pub const SL_CONTAINERTYPE_MPEG_TS: u32 = 13;
191pub const SL_CONTAINERTYPE_QT: u32 = 14;
192pub const SL_CONTAINERTYPE_WAV: u32 = 15;
193pub const SL_CONTAINERTYPE_XMF_0: u32 = 16;
194pub const SL_CONTAINERTYPE_XMF_1: u32 = 17;
195pub const SL_CONTAINERTYPE_XMF_2: u32 = 18;
196pub const SL_CONTAINERTYPE_XMF_3: u32 = 19;
197pub const SL_CONTAINERTYPE_XMF_GENERIC: u32 = 20;
198pub const SL_CONTAINERTYPE_AMR: u32 = 21;
199pub const SL_CONTAINERTYPE_AAC: u32 = 22;
200pub const SL_CONTAINERTYPE_3GPP: u32 = 23;
201pub const SL_CONTAINERTYPE_3GA: u32 = 24;
202pub const SL_CONTAINERTYPE_RM: u32 = 25;
203pub const SL_CONTAINERTYPE_DMF: u32 = 26;
204pub const SL_CONTAINERTYPE_SMF: u32 = 27;
205pub const SL_CONTAINERTYPE_MOBILE_DLS: u32 = 28;
206pub const SL_CONTAINERTYPE_OGG: u32 = 29;
207pub const SL_DEFAULTDEVICEID_AUDIOINPUT: u32 = 4294967295;
208pub const SL_DEFAULTDEVICEID_AUDIOOUTPUT: u32 = 4294967294;
209pub const SL_DEFAULTDEVICEID_LED: u32 = 4294967293;
210pub const SL_DEFAULTDEVICEID_VIBRA: u32 = 4294967292;
211pub const SL_DEFAULTDEVICEID_RESERVED1: u32 = 4294967291;
212pub const SL_DEVLOCATION_HANDSET: u32 = 1;
213pub const SL_DEVLOCATION_HEADSET: u32 = 2;
214pub const SL_DEVLOCATION_CARKIT: u32 = 3;
215pub const SL_DEVLOCATION_DOCK: u32 = 4;
216pub const SL_DEVLOCATION_REMOTE: u32 = 5;
217pub const SL_DEVLOCATION_RESLTE: u32 = 5;
218pub const SL_DEVSCOPE_UNKNOWN: u32 = 1;
219pub const SL_DEVSCOPE_ENVIRONMENT: u32 = 2;
220pub const SL_DEVSCOPE_USER: u32 = 3;
221pub const SL_CHARACTERENCODING_UNKNOWN: u32 = 0;
222pub const SL_CHARACTERENCODING_BINARY: u32 = 1;
223pub const SL_CHARACTERENCODING_ASCII: u32 = 2;
224pub const SL_CHARACTERENCODING_BIG5: u32 = 3;
225pub const SL_CHARACTERENCODING_CODEPAGE1252: u32 = 4;
226pub const SL_CHARACTERENCODING_GB2312: u32 = 5;
227pub const SL_CHARACTERENCODING_HZGB2312: u32 = 6;
228pub const SL_CHARACTERENCODING_GB12345: u32 = 7;
229pub const SL_CHARACTERENCODING_GB18030: u32 = 8;
230pub const SL_CHARACTERENCODING_GBK: u32 = 9;
231pub const SL_CHARACTERENCODING_IMAPUTF7: u32 = 10;
232pub const SL_CHARACTERENCODING_ISO2022JP: u32 = 11;
233pub const SL_CHARACTERENCODING_ISO2022JP1: u32 = 11;
234pub const SL_CHARACTERENCODING_ISO88591: u32 = 12;
235pub const SL_CHARACTERENCODING_ISO885910: u32 = 13;
236pub const SL_CHARACTERENCODING_ISO885913: u32 = 14;
237pub const SL_CHARACTERENCODING_ISO885914: u32 = 15;
238pub const SL_CHARACTERENCODING_ISO885915: u32 = 16;
239pub const SL_CHARACTERENCODING_ISO88592: u32 = 17;
240pub const SL_CHARACTERENCODING_ISO88593: u32 = 18;
241pub const SL_CHARACTERENCODING_ISO88594: u32 = 19;
242pub const SL_CHARACTERENCODING_ISO88595: u32 = 20;
243pub const SL_CHARACTERENCODING_ISO88596: u32 = 21;
244pub const SL_CHARACTERENCODING_ISO88597: u32 = 22;
245pub const SL_CHARACTERENCODING_ISO88598: u32 = 23;
246pub const SL_CHARACTERENCODING_ISO88599: u32 = 24;
247pub const SL_CHARACTERENCODING_ISOEUCJP: u32 = 25;
248pub const SL_CHARACTERENCODING_SHIFTJIS: u32 = 26;
249pub const SL_CHARACTERENCODING_SMS7BIT: u32 = 27;
250pub const SL_CHARACTERENCODING_UTF7: u32 = 28;
251pub const SL_CHARACTERENCODING_UTF8: u32 = 29;
252pub const SL_CHARACTERENCODING_JAVACONFORMANTUTF8: u32 = 30;
253pub const SL_CHARACTERENCODING_UTF16BE: u32 = 31;
254pub const SL_CHARACTERENCODING_UTF16LE: u32 = 32;
255pub const SL_METADATATRAVERSALMODE_ALL: u32 = 1;
256pub const SL_METADATATRAVERSALMODE_NODE: u32 = 2;
257pub const SL_NODETYPE_UNSPECIFIED: u32 = 1;
258pub const SL_NODETYPE_AUDIO: u32 = 2;
259pub const SL_NODETYPE_VIDEO: u32 = 3;
260pub const SL_NODETYPE_IMAGE: u32 = 4;
261pub const SL_NODE_PARENT: u32 = 4294967295;
262pub const SL_PLAYSTATE_STOPPED: u32 = 1;
263pub const SL_PLAYSTATE_PAUSED: u32 = 2;
264pub const SL_PLAYSTATE_PLAYING: u32 = 3;
265pub const SL_PLAYEVENT_HEADATEND: u32 = 1;
266pub const SL_PLAYEVENT_HEADATMARKER: u32 = 2;
267pub const SL_PLAYEVENT_HEADATNEWPOS: u32 = 4;
268pub const SL_PLAYEVENT_HEADMOVING: u32 = 8;
269pub const SL_PLAYEVENT_HEADSTALLED: u32 = 16;
270pub const SL_PLAYEVENT_DURATIONUPDATED: u32 = 32;
271pub const SL_TIME_UNKNOWN: u32 = 4294967295;
272pub const SL_PREFETCHEVENT_STATUSCHANGE: u32 = 1;
273pub const SL_PREFETCHEVENT_FILLLEVELCHANGE: u32 = 2;
274pub const SL_PREFETCHEVENT_ERROR: u32 = 3;
275pub const SL_PREFETCHEVENT_ERROR_UNRECOVERABLE: u32 = 4;
276pub const SL_PREFETCHSTATUS_UNDERFLOW: u32 = 1;
277pub const SL_PREFETCHSTATUS_SUFFICIENTDATA: u32 = 2;
278pub const SL_PREFETCHSTATUS_OVERFLOW: u32 = 3;
279pub const SL_RATEPROP_RESERVED1: u32 = 1;
280pub const SL_RATEPROP_RESERVED2: u32 = 2;
281pub const SL_RATEPROP_SILENTAUDIO: u32 = 256;
282pub const SL_RATEPROP_STAGGEREDAUDIO: u32 = 512;
283pub const SL_RATEPROP_NOPITCHCORAUDIO: u32 = 1024;
284pub const SL_RATEPROP_PITCHCORAUDIO: u32 = 2048;
285pub const SL_SEEKMODE_FAST: u32 = 1;
286pub const SL_SEEKMODE_ACCURATE: u32 = 2;
287pub const SL_RECORDSTATE_STOPPED: u32 = 1;
288pub const SL_RECORDSTATE_PAUSED: u32 = 2;
289pub const SL_RECORDSTATE_RECORDING: u32 = 3;
290pub const SL_RECORDEVENT_HEADATLIMIT: u32 = 1;
291pub const SL_RECORDEVENT_HEADATMARKER: u32 = 2;
292pub const SL_RECORDEVENT_HEADATNEWPOS: u32 = 4;
293pub const SL_RECORDEVENT_HEADMOVING: u32 = 8;
294pub const SL_RECORDEVENT_HEADSTALLED: u32 = 16;
295pub const SL_RECORDEVENT_BUFFER_INSUFFICIENT: u32 = 32;
296pub const SL_RECORDEVENT_BUFFER_FULL: u32 = 32;
297pub const SL_RECORDEVENT_BUFFERQUEUE_STARVED: u32 = 64;
298pub const SL_EQUALIZER_UNDEFINED: u32 = 65535;
299pub const SL_BUFFERQUEUEEVENT_PROCESSED: u32 = 1;
300pub const SL_BUFFERQUEUEEVENT_UNREALIZED: u32 = 2;
301pub const SL_BUFFERQUEUEEVENT_CLEARED: u32 = 4;
302pub const SL_BUFFERQUEUEEVENT_STOPPED: u32 = 8;
303pub const SL_BUFFERQUEUEEVENT_ERROR: u32 = 16;
304pub const SL_BUFFERQUEUEEVENT_CONTENT_END: u32 = 32;
305pub const SL_REVERBPRESET_NONE: u32 = 0;
306pub const SL_REVERBPRESET_SMALLROOM: u32 = 1;
307pub const SL_REVERBPRESET_MEDIUMROOM: u32 = 2;
308pub const SL_REVERBPRESET_LARGEROOM: u32 = 3;
309pub const SL_REVERBPRESET_MEDIUMHALL: u32 = 4;
310pub const SL_REVERBPRESET_LARGEHALL: u32 = 5;
311pub const SL_REVERBPRESET_PLATE: u32 = 6;
312pub const SL_3DHINT_OFF: u32 = 0;
313pub const SL_3DHINT_QUALITY_LOWEST: u32 = 1;
314pub const SL_3DHINT_QUALITY_LOW: u32 = 16384;
315pub const SL_3DHINT_QUALITY_MEDIUM: u32 = 32768;
316pub const SL_3DHINT_QUALITY_HIGH: u32 = 49152;
317pub const SL_3DHINT_QUALITY_HIGHEST: u32 = 65535;
318pub const SL_ROLLOFFMODEL_EXPONENTIAL: u32 = 0;
319pub const SL_ROLLOFFMODEL_LINEAR: u32 = 1;
320pub const SL_DYNAMIC_ITF_EVENT_RUNTIME_ERROR: u32 = 1;
321pub const SL_DYNAMIC_ITF_EVENT_ASYNC_TERMINATION: u32 = 2;
322pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST: u32 = 3;
323pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST_PERMANENTLY: u32 = 4;
324pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_AVAILABLE: u32 = 5;
325pub const SL_MIDIMESSAGETYPE_NOTE_ON_OFF: u32 = 1;
326pub const SL_MIDIMESSAGETYPE_POLY_PRESSURE: u32 = 2;
327pub const SL_MIDIMESSAGETYPE_CONTROL_CHANGE: u32 = 3;
328pub const SL_MIDIMESSAGETYPE_PROGRAM_CHANGE: u32 = 4;
329pub const SL_MIDIMESSAGETYPE_CHANNEL_PRESSURE: u32 = 5;
330pub const SL_MIDIMESSAGETYPE_PITCH_BEND: u32 = 6;
331pub const SL_MIDIMESSAGETYPE_SYSTEM_MESSAGE: u32 = 7;
332pub const SL_AUDIOSTREAMFORMAT_UNDEFINED: u32 = 0;
333pub const SL_RATECONTROLMODE_CONSTANTBITRATE: u32 = 1;
334pub const SL_RATECONTROLMODE_VARIABLEBITRATE: u32 = 2;
335pub const SL_AUDIOCODEC_PCM: u32 = 1;
336pub const SL_AUDIOCODEC_MP3: u32 = 2;
337pub const SL_AUDIOCODEC_AMR: u32 = 3;
338pub const SL_AUDIOCODEC_AMRWB: u32 = 4;
339pub const SL_AUDIOCODEC_AMRWBPLUS: u32 = 5;
340pub const SL_AUDIOCODEC_AAC: u32 = 6;
341pub const SL_AUDIOCODEC_WMA: u32 = 7;
342pub const SL_AUDIOCODEC_REAL: u32 = 8;
343pub const SL_AUDIOCODEC_VORBIS: u32 = 9;
344pub const SL_AUDIOPROFILE_PCM: u32 = 1;
345pub const SL_AUDIOPROFILE_MPEG1_L3: u32 = 1;
346pub const SL_AUDIOPROFILE_MPEG2_L3: u32 = 2;
347pub const SL_AUDIOPROFILE_MPEG25_L3: u32 = 3;
348pub const SL_AUDIOCHANMODE_MP3_MONO: u32 = 1;
349pub const SL_AUDIOCHANMODE_MP3_STEREO: u32 = 2;
350pub const SL_AUDIOCHANMODE_MP3_JOINTSTEREO: u32 = 3;
351pub const SL_AUDIOCHANMODE_MP3_DUAL: u32 = 4;
352pub const SL_AUDIOPROFILE_AMR: u32 = 1;
353pub const SL_AUDIOSTREAMFORMAT_CONFORMANCE: u32 = 1;
354pub const SL_AUDIOSTREAMFORMAT_IF1: u32 = 2;
355pub const SL_AUDIOSTREAMFORMAT_IF2: u32 = 3;
356pub const SL_AUDIOSTREAMFORMAT_FSF: u32 = 4;
357pub const SL_AUDIOSTREAMFORMAT_RTPPAYLOAD: u32 = 5;
358pub const SL_AUDIOSTREAMFORMAT_ITU: u32 = 6;
359pub const SL_AUDIOPROFILE_AMRWB: u32 = 1;
360pub const SL_AUDIOPROFILE_AMRWBPLUS: u32 = 1;
361pub const SL_AUDIOPROFILE_AAC_AAC: u32 = 1;
362pub const SL_AUDIOMODE_AAC_MAIN: u32 = 1;
363pub const SL_AUDIOMODE_AAC_LC: u32 = 2;
364pub const SL_AUDIOMODE_AAC_SSR: u32 = 3;
365pub const SL_AUDIOMODE_AAC_LTP: u32 = 4;
366pub const SL_AUDIOMODE_AAC_HE: u32 = 5;
367pub const SL_AUDIOMODE_AAC_SCALABLE: u32 = 6;
368pub const SL_AUDIOMODE_AAC_ERLC: u32 = 7;
369pub const SL_AUDIOMODE_AAC_LD: u32 = 8;
370pub const SL_AUDIOMODE_AAC_HE_PS: u32 = 9;
371pub const SL_AUDIOMODE_AAC_HE_MPS: u32 = 10;
372pub const SL_AUDIOSTREAMFORMAT_MP2ADTS: u32 = 1;
373pub const SL_AUDIOSTREAMFORMAT_MP4ADTS: u32 = 2;
374pub const SL_AUDIOSTREAMFORMAT_MP4LOAS: u32 = 3;
375pub const SL_AUDIOSTREAMFORMAT_MP4LATM: u32 = 4;
376pub const SL_AUDIOSTREAMFORMAT_ADIF: u32 = 5;
377pub const SL_AUDIOSTREAMFORMAT_MP4FF: u32 = 6;
378pub const SL_AUDIOSTREAMFORMAT_RAW: u32 = 7;
379pub const SL_AUDIOPROFILE_WMA7: u32 = 1;
380pub const SL_AUDIOPROFILE_WMA8: u32 = 2;
381pub const SL_AUDIOPROFILE_WMA9: u32 = 3;
382pub const SL_AUDIOPROFILE_WMA10: u32 = 4;
383pub const SL_AUDIOMODE_WMA_LEVEL1: u32 = 1;
384pub const SL_AUDIOMODE_WMA_LEVEL2: u32 = 2;
385pub const SL_AUDIOMODE_WMA_LEVEL3: u32 = 3;
386pub const SL_AUDIOMODE_WMA_LEVEL4: u32 = 4;
387pub const SL_AUDIOMODE_WMAPRO_LEVELM0: u32 = 5;
388pub const SL_AUDIOMODE_WMAPRO_LEVELM1: u32 = 6;
389pub const SL_AUDIOMODE_WMAPRO_LEVELM2: u32 = 7;
390pub const SL_AUDIOMODE_WMAPRO_LEVELM3: u32 = 8;
391pub const SL_AUDIOPROFILE_REALAUDIO: u32 = 1;
392pub const SL_AUDIOMODE_REALAUDIO_G2: u32 = 1;
393pub const SL_AUDIOMODE_REALAUDIO_8: u32 = 2;
394pub const SL_AUDIOMODE_REALAUDIO_10: u32 = 3;
395pub const SL_AUDIOMODE_REALAUDIO_SURROUND: u32 = 4;
396pub const SL_ENGINEOPTION_THREADSAFE: u32 = 1;
397pub const SL_ENGINEOPTION_LOSSOFCONTROL: u32 = 2;
398pub const SL_ENGINEOPTION_MAJORVERSION: u32 = 3;
399pub const SL_ENGINEOPTION_MINORVERSION: u32 = 4;
400pub const SL_ENGINEOPTION_STEPVERSION: u32 = 5;
401pub const SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT: u32 = 1;
402pub const SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT: u32 = 2;
403pub const SL_ANDROID_PCM_REPRESENTATION_FLOAT: u32 = 3;
404pub const SL_ANDROID_DATAFORMAT_PCM_EX: u32 = 4;
405pub const SL_ANDROID_SPEAKER_NON_POSITIONAL: u32 = 2147483648;
406pub const SL_ANDROID_SPEAKER_USE_DEFAULT: u32 = 0;
407pub const SL_ANDROID_ITEMKEY_NONE: u32 = 0;
408pub const SL_ANDROID_ITEMKEY_EOS: u32 = 1;
409pub const SL_ANDROID_ITEMKEY_DISCONTINUITY: u32 = 2;
410pub const SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT: u32 = 3;
411pub const SL_ANDROID_ITEMKEY_FORMAT_CHANGE: u32 = 4;
412pub const SL_ANDROIDBUFFERQUEUEEVENT_NONE: u32 = 0;
413pub const SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED: u32 = 1;
414pub const SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: u32 = 2147485629;
415pub const SL_DATALOCATOR_ANDROIDBUFFERQUEUE: u32 = 2147485630;
416pub type sl_char_t = ::std::os::raw::c_char;
417pub type sl_uint8_t = ::std::os::raw::c_uchar;
418pub type sl_int8_t = ::std::os::raw::c_schar;
419pub type sl_uint16_t = ::std::os::raw::c_ushort;
420pub type sl_int16_t = ::std::os::raw::c_short;
421pub type sl_float32_t = f32;
422pub type sl_float64_t = f64;
423pub type SLchar = sl_char_t;
424pub type SLint8 = sl_int8_t;
425pub type SLuint8 = sl_uint8_t;
426pub type SLint16 = sl_int16_t;
427pub type SLuint16 = sl_uint16_t;
428pub type SLint32 = sl_int32_t;
429pub type SLuint32 = sl_uint32_t;
430pub type SLfloat32 = sl_float32_t;
431pub type Slfloat64 = sl_float64_t;
432pub type SLboolean = SLuint32;
433pub type SLmillibel = SLint16;
434pub type SLmillisecond = SLuint32;
435pub type SLmilliHertz = SLuint32;
436pub type SLmillimeter = SLint32;
437pub type SLmillidegree = SLint32;
438pub type SLpermille = SLint16;
439pub type SLmicrosecond = SLuint32;
440pub type SLresult = SLuint32;
441#[doc = " Interface ID defined as a UUID"]
442#[repr(C)]
443pub struct SLInterfaceID_ {
444 pub time_low: SLuint32,
445 pub time_mid: SLuint16,
446 pub time_hi_and_version: SLuint16,
447 pub clock_seq: SLuint16,
448 pub node: [SLuint8; 6usize],
449}
450pub type SLInterfaceID = *const SLInterfaceID_;
451pub type SLObjectItf = *const *const SLObjectItf_;
452extern "C" {
453 pub static SL_IID_NULL: SLInterfaceID;
454}
455#[doc = " URI-based data locator definition where locatorType must be SL_DATALOCATOR_URI"]
456#[repr(C)]
457pub struct SLDataLocator_URI_ {
458 pub locatorType: SLuint32,
459 pub pURI: *const SLchar,
460}
461pub type SLDataLocator_URI = SLDataLocator_URI_;
462#[doc = " Address-based data locator definition where locatorType must be SL_DATALOCATOR_ADDRESS"]
463#[repr(C)]
464pub struct SLDataLocator_Address_ {
465 pub locatorType: SLuint32,
466 pub pAddress: *mut ::std::os::raw::c_void,
467 pub length: SLuint32,
468}
469pub type SLDataLocator_Address = SLDataLocator_Address_;
470#[doc = " IODevice-based data locator definition where locatorType must be SL_DATALOCATOR_IODEVICE"]
471#[repr(C)]
472pub struct SLDataLocator_IODevice_ {
473 pub locatorType: SLuint32,
474 pub deviceType: SLuint32,
475 pub deviceID: SLuint32,
476 pub device: SLObjectItf,
477}
478pub type SLDataLocator_IODevice = SLDataLocator_IODevice_;
479#[doc = " OutputMix-based data locator definition where locatorType must be SL_DATALOCATOR_OUTPUTMIX"]
480#[repr(C)]
481pub struct SLDataLocator_OutputMix_ {
482 pub locatorType: SLuint32,
483 pub outputMix: SLObjectItf,
484}
485pub type SLDataLocator_OutputMix = SLDataLocator_OutputMix_;
486#[doc = " BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_BUFFERQUEUE"]
487#[repr(C)]
488pub struct SLDataLocator_BufferQueue_ {
489 pub locatorType: SLuint32,
490 pub numBuffers: SLuint32,
491}
492pub type SLDataLocator_BufferQueue = SLDataLocator_BufferQueue_;
493#[doc = " ContentPipe-based data locator definition where locatorType must be SL_DATALOCATOR_CONTENTPIPE"]
494#[repr(C)]
495pub struct SLDataLocator_ContentPipe_ {
496 pub locatorType: SLuint32,
497 pub pContentPipe: *mut ::std::os::raw::c_void,
498 pub pURI: *const SLchar,
499}
500pub type SLDataLocator_ContentPipe = SLDataLocator_ContentPipe_;
501#[doc = " MidiBufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_MIDIBUFFERQUEUE"]
502#[repr(C)]
503pub struct SLDataLocator_MIDIBufferQueue_ {
504 pub locatorType: SLuint32,
505 pub tpqn: SLuint32,
506 pub numBuffers: SLuint32,
507}
508pub type SLDataLocator_MIDIBufferQueue = SLDataLocator_MIDIBufferQueue_;
509#[doc = " MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME"]
510#[repr(C)]
511pub struct SLDataFormat_MIME_ {
512 pub formatType: SLuint32,
513 pub pMimeType: *const SLchar,
514 pub containerType: SLuint32,
515}
516pub type SLDataFormat_MIME = SLDataFormat_MIME_;
517#[doc = " PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM"]
518#[repr(C)]
519pub struct SLDataFormat_PCM_ {
520 pub formatType: SLuint32,
521 pub numChannels: SLuint32,
522 pub samplesPerSec: SLuint32,
523 pub bitsPerSample: SLuint32,
524 pub containerSize: SLuint32,
525 pub channelMask: SLuint32,
526 pub endianness: SLuint32,
527}
528pub type SLDataFormat_PCM = SLDataFormat_PCM_;
529#[doc = " PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM_EX"]
530#[repr(C)]
531pub struct SLDataFormat_PCM_EX_ {
532 pub formatType: SLuint32,
533 pub numChannels: SLuint32,
534 pub sampleRate: SLuint32,
535 pub bitsPerSample: SLuint32,
536 pub containerSize: SLuint32,
537 pub channelMask: SLuint32,
538 pub endianness: SLuint32,
539 pub representation: SLuint32,
540}
541pub type SLDataFormat_PCM_EX = SLDataFormat_PCM_EX_;
542#[doc = " MediaObject-type-based data format definition where formatType must be SL_DATAFORMAT_MEDIAOBJECT"]
543#[repr(C)]
544pub struct SLDataLocator_MediaObject_ {
545 pub locatorType: SLuint32,
546 pub mediaObject: SLObjectItf,
547}
548pub type SLDataLocator_MediaObject = SLDataLocator_MediaObject_;
549#[doc = " NULL-type-based data format definition where formatType must be SL_DATAFORMAT_NULL"]
550#[repr(C)]
551pub struct SLDataLocator_Null_ {
552 pub locatorType: SLuint32,
553}
554pub type SLDataLocator_Null = SLDataLocator_Null_;
555#[repr(C)]
556#[derive(Debug, Copy, Clone)]
557pub struct SLDataSource_ {
558 pub pLocator: *mut ::std::os::raw::c_void,
559 pub pFormat: *mut ::std::os::raw::c_void,
560}
561pub type SLDataSource = SLDataSource_;
562#[repr(C)]
563#[derive(Debug, Copy, Clone)]
564pub struct SLDataSink_ {
565 pub pLocator: *mut ::std::os::raw::c_void,
566 pub pFormat: *mut ::std::os::raw::c_void,
567}
568pub type SLDataSink = SLDataSink_;
569extern "C" {
570 pub static SL_IID_OBJECT: SLInterfaceID;
571}
572#[doc = " Object callback"]
573pub type slObjectCallback = ::std::option::Option<
574 unsafe extern "C" fn(
575 caller: SLObjectItf,
576 pContext: *const ::std::os::raw::c_void,
577 event: SLuint32,
578 result: SLresult,
579 param: SLuint32,
580 pInterface: *mut ::std::os::raw::c_void,
581 ),
582>;
583#[repr(C)]
584#[derive(Debug, Copy, Clone)]
585pub struct SLObjectItf_ {
586 pub Realize: ::std::option::Option<
587 unsafe extern "C" fn(self_: SLObjectItf, async_: SLboolean) -> SLresult,
588 >,
589 pub Resume: ::std::option::Option<
590 unsafe extern "C" fn(self_: SLObjectItf, async_: SLboolean) -> SLresult,
591 >,
592 pub GetState: ::std::option::Option<
593 unsafe extern "C" fn(self_: SLObjectItf, pState: *mut SLuint32) -> SLresult,
594 >,
595 pub GetInterface: ::std::option::Option<
596 unsafe extern "C" fn(
597 self_: SLObjectItf,
598 iid: SLInterfaceID,
599 pInterface: *mut ::std::os::raw::c_void,
600 ) -> SLresult,
601 >,
602 pub RegisterCallback: ::std::option::Option<
603 unsafe extern "C" fn(
604 self_: SLObjectItf,
605 callback: slObjectCallback,
606 pContext: *mut ::std::os::raw::c_void,
607 ) -> SLresult,
608 >,
609 pub AbortAsyncOperation: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
610 pub Destroy: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
611 pub SetPriority: ::std::option::Option<
612 unsafe extern "C" fn(self_: SLObjectItf, priority: SLuint32) -> SLresult,
613 >,
614 pub GetPriority: ::std::option::Option<
615 unsafe extern "C" fn(self_: SLObjectItf, pPriority: *mut SLuint32) -> SLresult,
616 >,
617 pub SetLossOfControlInterfaces: ::std::option::Option<
618 unsafe extern "C" fn(
619 self_: SLObjectItf,
620 numInterfaces: SLuint16,
621 pInterfaceIDs: *const SLInterfaceID,
622 enabled: SLboolean,
623 ) -> SLresult,
624 >,
625}
626#[repr(C)]
627pub struct SLAudioInputDescriptor_ {
628 pub pDeviceName: *mut SLchar,
629 pub deviceNameLength: SLint16,
630 pub deviceConnection: SLint16,
631 pub deviceScope: SLint16,
632 pub deviceLocation: SLint16,
633 pub isForTelephony: SLboolean,
634 pub minSampleRate: SLmilliHertz,
635 pub maxSampleRate: SLmilliHertz,
636 pub isFreqRangeContinuous: SLboolean,
637 pub pSamplingRatesSupported: *mut SLmilliHertz,
638 pub numOfSamplingRatesSupported: SLint16,
639 pub maxChannels: SLint16,
640}
641pub type SLAudioInputDescriptor = SLAudioInputDescriptor_;
642#[repr(C)]
643pub struct SLAudioOutputDescriptor_ {
644 pub pDeviceName: *mut SLchar,
645 pub deviceNameLength: SLint16,
646 pub deviceConnection: SLint16,
647 pub deviceScope: SLint16,
648 pub deviceLocation: SLint16,
649 pub isForTelephony: SLboolean,
650 pub minSampleRate: SLmilliHertz,
651 pub maxSampleRate: SLmilliHertz,
652 pub isFreqRangeContinuous: SLboolean,
653 pub pSamplingRatesSupported: *mut SLmilliHertz,
654 pub numOfSamplingRatesSupported: SLint16,
655 pub maxChannels: SLint16,
656}
657pub type SLAudioOutputDescriptor = SLAudioOutputDescriptor_;
658extern "C" {
659 pub static SL_IID_AUDIOIODEVICECAPABILITIES: SLInterfaceID;
660}
661pub type SLAudioIODeviceCapabilitiesItf = *const *const SLAudioIODeviceCapabilitiesItf_;
662pub type slAvailableAudioInputsChangedCallback = ::std::option::Option<
663 unsafe extern "C" fn(
664 caller: SLAudioIODeviceCapabilitiesItf,
665 pContext: *mut ::std::os::raw::c_void,
666 deviceID: SLuint32,
667 numInputs: SLuint32,
668 isNew: SLboolean,
669 ),
670>;
671pub type slAvailableAudioOutputsChangedCallback = ::std::option::Option<
672 unsafe extern "C" fn(
673 caller: SLAudioIODeviceCapabilitiesItf,
674 pContext: *mut ::std::os::raw::c_void,
675 deviceID: SLuint32,
676 numOutputs: SLuint32,
677 isNew: SLboolean,
678 ),
679>;
680pub type slDefaultDeviceIDMapChangedCallback = ::std::option::Option<
681 unsafe extern "C" fn(
682 caller: SLAudioIODeviceCapabilitiesItf,
683 pContext: *mut ::std::os::raw::c_void,
684 isOutput: SLboolean,
685 numDevices: SLuint32,
686 ),
687>;
688#[repr(C)]
689#[derive(Debug, Copy, Clone)]
690pub struct SLAudioIODeviceCapabilitiesItf_ {
691 pub GetAvailableAudioInputs: ::std::option::Option<
692 unsafe extern "C" fn(
693 self_: SLAudioIODeviceCapabilitiesItf,
694 pNumInputs: *mut SLuint32,
695 pInputDeviceIDs: *mut SLuint32,
696 ) -> SLresult,
697 >,
698 pub QueryAudioInputCapabilities: ::std::option::Option<
699 unsafe extern "C" fn(
700 self_: SLAudioIODeviceCapabilitiesItf,
701 deviceId: SLuint32,
702 pDescriptor: *mut SLAudioInputDescriptor,
703 ) -> SLresult,
704 >,
705 pub RegisterAvailableAudioInputsChangedCallback: ::std::option::Option<
706 unsafe extern "C" fn(
707 self_: SLAudioIODeviceCapabilitiesItf,
708 callback: slAvailableAudioInputsChangedCallback,
709 pContext: *mut ::std::os::raw::c_void,
710 ) -> SLresult,
711 >,
712 pub GetAvailableAudioOutputs: ::std::option::Option<
713 unsafe extern "C" fn(
714 self_: SLAudioIODeviceCapabilitiesItf,
715 pNumOutputs: *mut SLuint32,
716 pOutputDeviceIDs: *mut SLuint32,
717 ) -> SLresult,
718 >,
719 pub QueryAudioOutputCapabilities: ::std::option::Option<
720 unsafe extern "C" fn(
721 self_: SLAudioIODeviceCapabilitiesItf,
722 deviceId: SLuint32,
723 pDescriptor: *mut SLAudioOutputDescriptor,
724 ) -> SLresult,
725 >,
726 pub RegisterAvailableAudioOutputsChangedCallback: ::std::option::Option<
727 unsafe extern "C" fn(
728 self_: SLAudioIODeviceCapabilitiesItf,
729 callback: slAvailableAudioOutputsChangedCallback,
730 pContext: *mut ::std::os::raw::c_void,
731 ) -> SLresult,
732 >,
733 pub RegisterDefaultDeviceIDMapChangedCallback: ::std::option::Option<
734 unsafe extern "C" fn(
735 self_: SLAudioIODeviceCapabilitiesItf,
736 callback: slDefaultDeviceIDMapChangedCallback,
737 pContext: *mut ::std::os::raw::c_void,
738 ) -> SLresult,
739 >,
740 pub GetAssociatedAudioInputs: ::std::option::Option<
741 unsafe extern "C" fn(
742 self_: SLAudioIODeviceCapabilitiesItf,
743 deviceId: SLuint32,
744 pNumAudioInputs: *mut SLuint32,
745 pAudioInputDeviceIDs: *mut SLuint32,
746 ) -> SLresult,
747 >,
748 pub GetAssociatedAudioOutputs: ::std::option::Option<
749 unsafe extern "C" fn(
750 self_: SLAudioIODeviceCapabilitiesItf,
751 deviceId: SLuint32,
752 pNumAudioOutputs: *mut SLuint32,
753 pAudioOutputDeviceIDs: *mut SLuint32,
754 ) -> SLresult,
755 >,
756 pub GetDefaultAudioDevices: ::std::option::Option<
757 unsafe extern "C" fn(
758 self_: SLAudioIODeviceCapabilitiesItf,
759 defaultDeviceID: SLuint32,
760 pNumAudioDevices: *mut SLuint32,
761 pAudioDeviceIDs: *mut SLuint32,
762 ) -> SLresult,
763 >,
764 pub QuerySampleFormatsSupported: ::std::option::Option<
765 unsafe extern "C" fn(
766 self_: SLAudioIODeviceCapabilitiesItf,
767 deviceId: SLuint32,
768 samplingRate: SLmilliHertz,
769 pSampleFormats: *mut SLint32,
770 pNumOfSampleFormats: *mut SLuint32,
771 ) -> SLresult,
772 >,
773}
774#[repr(C)]
775pub struct SLLEDDescriptor_ {
776 pub ledCount: SLuint8,
777 pub primaryLED: SLuint8,
778 pub colorMask: SLuint32,
779}
780pub type SLLEDDescriptor = SLLEDDescriptor_;
781#[repr(C)]
782pub struct SLHSL_ {
783 pub hue: SLmillidegree,
784 pub saturation: SLpermille,
785 pub lightness: SLpermille,
786}
787pub type SLHSL = SLHSL_;
788extern "C" {
789 pub static SL_IID_LED: SLInterfaceID;
790}
791pub type SLLEDArrayItf = *const *const SLLEDArrayItf_;
792#[repr(C)]
793#[derive(Debug, Copy, Clone)]
794pub struct SLLEDArrayItf_ {
795 pub ActivateLEDArray: ::std::option::Option<
796 unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: SLuint32) -> SLresult,
797 >,
798 pub IsLEDArrayActivated: ::std::option::Option<
799 unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: *mut SLuint32) -> SLresult,
800 >,
801 pub SetColor: ::std::option::Option<
802 unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *const SLHSL) -> SLresult,
803 >,
804 pub GetColor: ::std::option::Option<
805 unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *mut SLHSL) -> SLresult,
806 >,
807}
808#[repr(C)]
809pub struct SLVibraDescriptor_ {
810 pub supportsFrequency: SLboolean,
811 pub supportsIntensity: SLboolean,
812 pub minFrequency: SLmilliHertz,
813 pub maxFrequency: SLmilliHertz,
814}
815pub type SLVibraDescriptor = SLVibraDescriptor_;
816extern "C" {
817 pub static SL_IID_VIBRA: SLInterfaceID;
818}
819pub type SLVibraItf = *const *const SLVibraItf_;
820#[repr(C)]
821#[derive(Debug, Copy, Clone)]
822pub struct SLVibraItf_ {
823 pub Vibrate: ::std::option::Option<
824 unsafe extern "C" fn(self_: SLVibraItf, vibrate: SLboolean) -> SLresult,
825 >,
826 pub IsVibrating: ::std::option::Option<
827 unsafe extern "C" fn(self_: SLVibraItf, pVibrating: *mut SLboolean) -> SLresult,
828 >,
829 pub SetFrequency: ::std::option::Option<
830 unsafe extern "C" fn(self_: SLVibraItf, frequency: SLmilliHertz) -> SLresult,
831 >,
832 pub GetFrequency: ::std::option::Option<
833 unsafe extern "C" fn(self_: SLVibraItf, pFrequency: *mut SLmilliHertz) -> SLresult,
834 >,
835 pub SetIntensity: ::std::option::Option<
836 unsafe extern "C" fn(self_: SLVibraItf, intensity: SLpermille) -> SLresult,
837 >,
838 pub GetIntensity: ::std::option::Option<
839 unsafe extern "C" fn(self_: SLVibraItf, pIntensity: *mut SLpermille) -> SLresult,
840 >,
841}
842#[repr(C)]
843pub struct SLMetadataInfo_ {
844 pub size: SLuint32,
845 pub encoding: SLuint32,
846 pub langCountry: [SLchar; 16usize],
847 pub data: [SLuint8; 1usize],
848}
849pub type SLMetadataInfo = SLMetadataInfo_;
850extern "C" {
851 pub static SL_IID_METADATAEXTRACTION: SLInterfaceID;
852}
853pub type SLMetadataExtractionItf = *const *const SLMetadataExtractionItf_;
854#[repr(C)]
855#[derive(Debug, Copy, Clone)]
856pub struct SLMetadataExtractionItf_ {
857 pub GetItemCount: ::std::option::Option<
858 unsafe extern "C" fn(self_: SLMetadataExtractionItf, pItemCount: *mut SLuint32) -> SLresult,
859 >,
860 pub GetKeySize: ::std::option::Option<
861 unsafe extern "C" fn(
862 self_: SLMetadataExtractionItf,
863 index: SLuint32,
864 pKeySize: *mut SLuint32,
865 ) -> SLresult,
866 >,
867 pub GetKey: ::std::option::Option<
868 unsafe extern "C" fn(
869 self_: SLMetadataExtractionItf,
870 index: SLuint32,
871 keySize: SLuint32,
872 pKey: *mut SLMetadataInfo,
873 ) -> SLresult,
874 >,
875 pub GetValueSize: ::std::option::Option<
876 unsafe extern "C" fn(
877 self_: SLMetadataExtractionItf,
878 index: SLuint32,
879 pValueSize: *mut SLuint32,
880 ) -> SLresult,
881 >,
882 pub GetValue: ::std::option::Option<
883 unsafe extern "C" fn(
884 self_: SLMetadataExtractionItf,
885 index: SLuint32,
886 valueSize: SLuint32,
887 pValue: *mut SLMetadataInfo,
888 ) -> SLresult,
889 >,
890 pub AddKeyFilter: ::std::option::Option<
891 unsafe extern "C" fn(
892 self_: SLMetadataExtractionItf,
893 keySize: SLuint32,
894 pKey: *const ::std::os::raw::c_void,
895 keyEncoding: SLuint32,
896 pValueLangCountry: *const SLchar,
897 valueEncoding: SLuint32,
898 filterMask: SLuint8,
899 ) -> SLresult,
900 >,
901 pub ClearKeyFilter:
902 ::std::option::Option<unsafe extern "C" fn(self_: SLMetadataExtractionItf) -> SLresult>,
903}
904extern "C" {
905 pub static SL_IID_METADATAMESSAGE: SLInterfaceID;
906}
907pub type SLMetadataMessageItf = *const *const SLMetadataMessageItf_;
908pub type slMetadataCallback = ::std::option::Option<
909 unsafe extern "C" fn(
910 caller: SLMetadataMessageItf,
911 pContext: *mut ::std::os::raw::c_void,
912 index: SLuint32,
913 ),
914>;
915#[repr(C)]
916#[derive(Debug, Copy, Clone)]
917pub struct SLMetadataMessageItf_ {
918 pub RegisterMetadataCallback: ::std::option::Option<
919 unsafe extern "C" fn(
920 self_: SLMetadataMessageItf,
921 callback: slMetadataCallback,
922 pContext: *mut ::std::os::raw::c_void,
923 ) -> SLresult,
924 >,
925}
926extern "C" {
927 pub static SL_IID_METADATATRAVERSAL: SLInterfaceID;
928}
929pub type SLMetadataTraversalItf = *const *const SLMetadataTraversalItf_;
930#[repr(C)]
931#[derive(Debug, Copy, Clone)]
932pub struct SLMetadataTraversalItf_ {
933 pub SetMode: ::std::option::Option<
934 unsafe extern "C" fn(self_: SLMetadataTraversalItf, mode: SLuint32) -> SLresult,
935 >,
936 pub GetChildCount: ::std::option::Option<
937 unsafe extern "C" fn(self_: SLMetadataTraversalItf, pCount: *mut SLuint32) -> SLresult,
938 >,
939 pub GetChildMIMETypeSize: ::std::option::Option<
940 unsafe extern "C" fn(
941 self_: SLMetadataTraversalItf,
942 index: SLuint32,
943 pSize: *mut SLuint32,
944 ) -> SLresult,
945 >,
946 pub GetChildInfo: ::std::option::Option<
947 unsafe extern "C" fn(
948 self_: SLMetadataTraversalItf,
949 index: SLuint32,
950 pNodeID: *mut SLint32,
951 pType: *mut SLuint32,
952 size: SLuint32,
953 pMimeType: *mut SLchar,
954 ) -> SLresult,
955 >,
956 pub SetActiveNode: ::std::option::Option<
957 unsafe extern "C" fn(self_: SLMetadataTraversalItf, index: SLuint32) -> SLresult,
958 >,
959}
960extern "C" {
961 pub static SL_IID_DYNAMICSOURCE: SLInterfaceID;
962}
963pub type SLDynamicSourceItf = *const *const SLDynamicSourceItf_;
964#[repr(C)]
965#[derive(Debug, Copy, Clone)]
966pub struct SLDynamicSourceItf_ {
967 pub SetSource: ::std::option::Option<
968 unsafe extern "C" fn(
969 self_: SLDynamicSourceItf,
970 pDataSource: *const SLDataSource,
971 ) -> SLresult,
972 >,
973}
974extern "C" {
975 pub static SL_IID_DYNAMICSOURCESINKCHANGE: SLInterfaceID;
976}
977pub type SLDynamicSourceSinkChangeItf = *const *const SLDynamicSourceSinkChangeItf_;
978pub type slSourceChangeCallback = ::std::option::Option<
979 unsafe extern "C" fn(
980 caller: SLDynamicSourceSinkChangeItf,
981 pContext: *mut ::std::os::raw::c_void,
982 resultCode: SLuint32,
983 pExistingDataSource: *const SLDataSource,
984 pNewDataSource: *const SLDataSource,
985 ),
986>;
987pub type slSinkChangeCallback = ::std::option::Option<
988 unsafe extern "C" fn(
989 caller: SLDynamicSourceSinkChangeItf,
990 pContext: *mut ::std::os::raw::c_void,
991 resultCode: SLuint32,
992 pExistingDataSink: *const SLDataSource,
993 pNewDataSink: *const SLDataSource,
994 ),
995>;
996#[repr(C)]
997#[derive(Debug, Copy, Clone)]
998pub struct SLDynamicSourceSinkChangeItf_ {
999 pub ChangeSource: ::std::option::Option<
1000 unsafe extern "C" fn(
1001 self_: SLDynamicSourceSinkChangeItf,
1002 pExistingDataSource: *const SLDataSource,
1003 pNewDataSource: *const SLDataSource,
1004 async_: SLboolean,
1005 ) -> SLresult,
1006 >,
1007 pub ChangeSink: ::std::option::Option<
1008 unsafe extern "C" fn(
1009 self_: SLDynamicSourceSinkChangeItf,
1010 pExistingDataSink: *const SLDataSink,
1011 pNewDataSink: *const SLDataSink,
1012 async_: SLboolean,
1013 ) -> SLresult,
1014 >,
1015 pub RegisterSourceChangeCallback: ::std::option::Option<
1016 unsafe extern "C" fn(
1017 self_: SLDynamicSourceSinkChangeItf,
1018 callback: slSourceChangeCallback,
1019 pContext: *mut ::std::os::raw::c_void,
1020 ) -> SLresult,
1021 >,
1022 pub RegisterSinkChangeCallback: ::std::option::Option<
1023 unsafe extern "C" fn(
1024 self_: SLDynamicSourceSinkChangeItf,
1025 callback: slSinkChangeCallback,
1026 pContext: *mut ::std::os::raw::c_void,
1027 ) -> SLresult,
1028 >,
1029}
1030extern "C" {
1031 pub static SL_IID_OUTPUTMIX: SLInterfaceID;
1032}
1033pub type SLOutputMixItf = *const *const SLOutputMixItf_;
1034pub type slMixDeviceChangeCallback = ::std::option::Option<
1035 unsafe extern "C" fn(caller: SLOutputMixItf, pContext: *mut ::std::os::raw::c_void),
1036>;
1037#[repr(C)]
1038#[derive(Debug, Copy, Clone)]
1039pub struct SLOutputMixItf_ {
1040 pub GetDestinationOutputDeviceIDs: ::std::option::Option<
1041 unsafe extern "C" fn(
1042 self_: SLOutputMixItf,
1043 pNumDevices: *mut SLint32,
1044 pDeviceIDs: *mut SLuint32,
1045 ) -> SLresult,
1046 >,
1047 pub RegisterDeviceChangeCallback: ::std::option::Option<
1048 unsafe extern "C" fn(
1049 self_: SLOutputMixItf,
1050 callback: slMixDeviceChangeCallback,
1051 pContext: *mut ::std::os::raw::c_void,
1052 ) -> SLresult,
1053 >,
1054 pub ReRoute: ::std::option::Option<
1055 unsafe extern "C" fn(
1056 self_: SLOutputMixItf,
1057 numOutputDevices: SLint32,
1058 pOutputDeviceIDs: *mut SLuint32,
1059 ) -> SLresult,
1060 >,
1061}
1062extern "C" {
1063 pub static SL_IID_PLAY: SLInterfaceID;
1064}
1065pub type SLPlayItf = *const *const SLPlayItf_;
1066pub type slPlayCallback = ::std::option::Option<
1067 unsafe extern "C" fn(caller: SLPlayItf, pContext: *mut ::std::os::raw::c_void, event: SLuint32),
1068>;
1069#[doc = " Playback interface methods"]
1070#[repr(C)]
1071#[derive(Debug, Copy, Clone)]
1072pub struct SLPlayItf_ {
1073 pub SetPlayState:
1074 ::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf, state: SLuint32) -> SLresult>,
1075 pub GetPlayState: ::std::option::Option<
1076 unsafe extern "C" fn(self_: SLPlayItf, pState: *mut SLuint32) -> SLresult,
1077 >,
1078 pub GetDuration: ::std::option::Option<
1079 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
1080 >,
1081 pub GetPosition: ::std::option::Option<
1082 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
1083 >,
1084 pub RegisterCallback: ::std::option::Option<
1085 unsafe extern "C" fn(
1086 self_: SLPlayItf,
1087 callback: slPlayCallback,
1088 pContext: *mut ::std::os::raw::c_void,
1089 ) -> SLresult,
1090 >,
1091 pub SetCallbackEventsMask: ::std::option::Option<
1092 unsafe extern "C" fn(self_: SLPlayItf, eventFlags: SLuint32) -> SLresult,
1093 >,
1094 pub GetCallbackEventsMask: ::std::option::Option<
1095 unsafe extern "C" fn(self_: SLPlayItf, pEventFlags: *mut SLuint32) -> SLresult,
1096 >,
1097 pub SetMarkerPosition: ::std::option::Option<
1098 unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
1099 >,
1100 pub ClearMarkerPosition:
1101 ::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf) -> SLresult>,
1102 pub GetMarkerPosition: ::std::option::Option<
1103 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
1104 >,
1105 pub SetPositionUpdatePeriod: ::std::option::Option<
1106 unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
1107 >,
1108 pub GetPositionUpdatePeriod: ::std::option::Option<
1109 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
1110 >,
1111}
1112extern "C" {
1113 pub static SL_IID_PREFETCHSTATUS: SLInterfaceID;
1114}
1115pub type SLPrefetchStatusItf = *const *const SLPrefetchStatusItf_;
1116pub type slPrefetchCallback = ::std::option::Option<
1117 unsafe extern "C" fn(
1118 caller: SLPrefetchStatusItf,
1119 pContext: *mut ::std::os::raw::c_void,
1120 event: SLuint32,
1121 ),
1122>;
1123#[doc = " Prefetch status interface methods"]
1124#[repr(C)]
1125#[derive(Debug, Copy, Clone)]
1126pub struct SLPrefetchStatusItf_ {
1127 pub GetPrefetchStatus: ::std::option::Option<
1128 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pStatus: *mut SLuint32) -> SLresult,
1129 >,
1130 pub GetFillLevel: ::std::option::Option<
1131 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pLevel: *mut SLpermille) -> SLresult,
1132 >,
1133 pub RegisterCallback: ::std::option::Option<
1134 unsafe extern "C" fn(
1135 self_: SLPrefetchStatusItf,
1136 callback: slPrefetchCallback,
1137 pContext: *mut ::std::os::raw::c_void,
1138 ) -> SLresult,
1139 >,
1140 pub SetCallbackEventsMask: ::std::option::Option<
1141 unsafe extern "C" fn(self_: SLPrefetchStatusItf, eventFlags: SLuint32) -> SLresult,
1142 >,
1143 pub GetCallbackEventsMask: ::std::option::Option<
1144 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pEventFlags: *mut SLuint32) -> SLresult,
1145 >,
1146 pub SetFillUpdatePeriod: ::std::option::Option<
1147 unsafe extern "C" fn(self_: SLPrefetchStatusItf, period: SLpermille) -> SLresult,
1148 >,
1149 pub GetFillUpdatePeriod: ::std::option::Option<
1150 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pPeriod: *mut SLpermille) -> SLresult,
1151 >,
1152 pub GetError: ::std::option::Option<
1153 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pResult: *mut SLresult) -> SLresult,
1154 >,
1155}
1156extern "C" {
1157 pub static SL_IID_PLAYBACKRATE: SLInterfaceID;
1158}
1159pub type SLPlaybackRateItf = *const *const SLPlaybackRateItf_;
1160#[repr(C)]
1161#[derive(Debug, Copy, Clone)]
1162pub struct SLPlaybackRateItf_ {
1163 pub SetRate: ::std::option::Option<
1164 unsafe extern "C" fn(self_: SLPlaybackRateItf, rate: SLpermille) -> SLresult,
1165 >,
1166 pub GetRate: ::std::option::Option<
1167 unsafe extern "C" fn(self_: SLPlaybackRateItf, pRate: *mut SLpermille) -> SLresult,
1168 >,
1169 pub SetPropertyConstraints: ::std::option::Option<
1170 unsafe extern "C" fn(self_: SLPlaybackRateItf, constraints: SLuint32) -> SLresult,
1171 >,
1172 pub GetProperties: ::std::option::Option<
1173 unsafe extern "C" fn(self_: SLPlaybackRateItf, pProperties: *mut SLuint32) -> SLresult,
1174 >,
1175 pub GetCapabilitiesOfRate: ::std::option::Option<
1176 unsafe extern "C" fn(
1177 self_: SLPlaybackRateItf,
1178 rate: SLpermille,
1179 pCapabilities: *mut SLuint32,
1180 ) -> SLresult,
1181 >,
1182 pub GetRateRange: ::std::option::Option<
1183 unsafe extern "C" fn(
1184 self_: SLPlaybackRateItf,
1185 index: SLuint8,
1186 pMinRate: *mut SLpermille,
1187 pMaxRate: *mut SLpermille,
1188 pStepSize: *mut SLpermille,
1189 pCapabilities: *mut SLuint32,
1190 ) -> SLresult,
1191 >,
1192}
1193extern "C" {
1194 pub static SL_IID_SEEK: SLInterfaceID;
1195}
1196pub type SLSeekItf = *const *const SLSeekItf_;
1197#[repr(C)]
1198#[derive(Debug, Copy, Clone)]
1199pub struct SLSeekItf_ {
1200 pub SetPosition: ::std::option::Option<
1201 unsafe extern "C" fn(self_: SLSeekItf, pos: SLmillisecond, seekMode: SLuint32) -> SLresult,
1202 >,
1203 pub SetLoop: ::std::option::Option<
1204 unsafe extern "C" fn(
1205 self_: SLSeekItf,
1206 loopEnable: SLboolean,
1207 startPos: SLmillisecond,
1208 endPos: SLmillisecond,
1209 ) -> SLresult,
1210 >,
1211 pub GetLoop: ::std::option::Option<
1212 unsafe extern "C" fn(
1213 self_: SLSeekItf,
1214 pLoopEnabled: *mut SLboolean,
1215 pStartPos: *mut SLmillisecond,
1216 pEndPos: *mut SLmillisecond,
1217 ) -> SLresult,
1218 >,
1219}
1220extern "C" {
1221 pub static SL_IID_RECORD: SLInterfaceID;
1222}
1223pub type SLRecordItf = *const *const SLRecordItf_;
1224pub type slRecordCallback = ::std::option::Option<
1225 unsafe extern "C" fn(
1226 caller: SLRecordItf,
1227 pContext: *mut ::std::os::raw::c_void,
1228 event: SLuint32,
1229 ),
1230>;
1231#[doc = " Recording interface methods"]
1232#[repr(C)]
1233#[derive(Debug, Copy, Clone)]
1234pub struct SLRecordItf_ {
1235 pub SetRecordState: ::std::option::Option<
1236 unsafe extern "C" fn(self_: SLRecordItf, state: SLuint32) -> SLresult,
1237 >,
1238 pub GetRecordState: ::std::option::Option<
1239 unsafe extern "C" fn(self_: SLRecordItf, pState: *mut SLuint32) -> SLresult,
1240 >,
1241 pub SetDurationLimit: ::std::option::Option<
1242 unsafe extern "C" fn(self_: SLRecordItf, msec: SLmillisecond) -> SLresult,
1243 >,
1244 pub GetPosition: ::std::option::Option<
1245 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
1246 >,
1247 pub RegisterCallback: ::std::option::Option<
1248 unsafe extern "C" fn(
1249 self_: SLRecordItf,
1250 callback: slRecordCallback,
1251 pContext: *mut ::std::os::raw::c_void,
1252 ) -> SLresult,
1253 >,
1254 pub SetCallbackEventsMask: ::std::option::Option<
1255 unsafe extern "C" fn(self_: SLRecordItf, eventFlags: SLuint32) -> SLresult,
1256 >,
1257 pub GetCallbackEventsMask: ::std::option::Option<
1258 unsafe extern "C" fn(self_: SLRecordItf, pEventFlags: *mut SLuint32) -> SLresult,
1259 >,
1260 pub SetMarkerPosition: ::std::option::Option<
1261 unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
1262 >,
1263 pub ClearMarkerPosition:
1264 ::std::option::Option<unsafe extern "C" fn(self_: SLRecordItf) -> SLresult>,
1265 pub GetMarkerPosition: ::std::option::Option<
1266 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
1267 >,
1268 pub SetPositionUpdatePeriod: ::std::option::Option<
1269 unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
1270 >,
1271 pub GetPositionUpdatePeriod: ::std::option::Option<
1272 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
1273 >,
1274}
1275extern "C" {
1276 pub static SL_IID_EQUALIZER: SLInterfaceID;
1277}
1278pub type SLEqualizerItf = *const *const SLEqualizerItf_;
1279#[repr(C)]
1280#[derive(Debug, Copy, Clone)]
1281pub struct SLEqualizerItf_ {
1282 pub SetEnabled: ::std::option::Option<
1283 unsafe extern "C" fn(self_: SLEqualizerItf, enabled: SLboolean) -> SLresult,
1284 >,
1285 pub IsEnabled: ::std::option::Option<
1286 unsafe extern "C" fn(self_: SLEqualizerItf, pEnabled: *mut SLboolean) -> SLresult,
1287 >,
1288 pub GetNumberOfBands: ::std::option::Option<
1289 unsafe extern "C" fn(self_: SLEqualizerItf, pAmount: *mut SLuint16) -> SLresult,
1290 >,
1291 pub GetBandLevelRange: ::std::option::Option<
1292 unsafe extern "C" fn(
1293 self_: SLEqualizerItf,
1294 pMin: *mut SLmillibel,
1295 pMax: *mut SLmillibel,
1296 ) -> SLresult,
1297 >,
1298 pub SetBandLevel: ::std::option::Option<
1299 unsafe extern "C" fn(self_: SLEqualizerItf, band: SLuint16, level: SLmillibel) -> SLresult,
1300 >,
1301 pub GetBandLevel: ::std::option::Option<
1302 unsafe extern "C" fn(
1303 self_: SLEqualizerItf,
1304 band: SLuint16,
1305 pLevel: *mut SLmillibel,
1306 ) -> SLresult,
1307 >,
1308 pub GetCenterFreq: ::std::option::Option<
1309 unsafe extern "C" fn(
1310 self_: SLEqualizerItf,
1311 band: SLuint16,
1312 pCenter: *mut SLmilliHertz,
1313 ) -> SLresult,
1314 >,
1315 pub GetBandFreqRange: ::std::option::Option<
1316 unsafe extern "C" fn(
1317 self_: SLEqualizerItf,
1318 band: SLuint16,
1319 pMin: *mut SLmilliHertz,
1320 pMax: *mut SLmilliHertz,
1321 ) -> SLresult,
1322 >,
1323 pub GetBand: ::std::option::Option<
1324 unsafe extern "C" fn(
1325 self_: SLEqualizerItf,
1326 frequency: SLmilliHertz,
1327 pBand: *mut SLuint16,
1328 ) -> SLresult,
1329 >,
1330 pub GetCurrentPreset: ::std::option::Option<
1331 unsafe extern "C" fn(self_: SLEqualizerItf, pPreset: *mut SLuint16) -> SLresult,
1332 >,
1333 pub UsePreset: ::std::option::Option<
1334 unsafe extern "C" fn(self_: SLEqualizerItf, index: SLuint16) -> SLresult,
1335 >,
1336 pub GetNumberOfPresets: ::std::option::Option<
1337 unsafe extern "C" fn(self_: SLEqualizerItf, pNumPresets: *mut SLuint16) -> SLresult,
1338 >,
1339 pub GetPresetName: ::std::option::Option<
1340 unsafe extern "C" fn(
1341 self_: SLEqualizerItf,
1342 index: SLuint16,
1343 pSize: *mut SLuint16,
1344 pName: *mut SLchar,
1345 ) -> SLresult,
1346 >,
1347}
1348extern "C" {
1349 pub static SL_IID_VOLUME: SLInterfaceID;
1350}
1351pub type SLVolumeItf = *const *const SLVolumeItf_;
1352#[repr(C)]
1353#[derive(Debug, Copy, Clone)]
1354pub struct SLVolumeItf_ {
1355 pub SetVolumeLevel: ::std::option::Option<
1356 unsafe extern "C" fn(self_: SLVolumeItf, level: SLmillibel) -> SLresult,
1357 >,
1358 pub GetVolumeLevel: ::std::option::Option<
1359 unsafe extern "C" fn(self_: SLVolumeItf, pLevel: *mut SLmillibel) -> SLresult,
1360 >,
1361 pub GetMaxVolumeLevel: ::std::option::Option<
1362 unsafe extern "C" fn(self_: SLVolumeItf, pMaxLevel: *mut SLmillibel) -> SLresult,
1363 >,
1364 pub SetMute: ::std::option::Option<
1365 unsafe extern "C" fn(self_: SLVolumeItf, mute: SLboolean) -> SLresult,
1366 >,
1367 pub GetMute: ::std::option::Option<
1368 unsafe extern "C" fn(self_: SLVolumeItf, pMute: *mut SLboolean) -> SLresult,
1369 >,
1370 pub EnableStereoPosition: ::std::option::Option<
1371 unsafe extern "C" fn(self_: SLVolumeItf, enable: SLboolean) -> SLresult,
1372 >,
1373 pub IsEnabledStereoPosition: ::std::option::Option<
1374 unsafe extern "C" fn(self_: SLVolumeItf, pEnable: *mut SLboolean) -> SLresult,
1375 >,
1376 pub SetStereoPosition: ::std::option::Option<
1377 unsafe extern "C" fn(self_: SLVolumeItf, stereoPosition: SLpermille) -> SLresult,
1378 >,
1379 pub GetStereoPosition: ::std::option::Option<
1380 unsafe extern "C" fn(self_: SLVolumeItf, pStereoPosition: *mut SLpermille) -> SLresult,
1381 >,
1382}
1383extern "C" {
1384 pub static SL_IID_DEVICEVOLUME: SLInterfaceID;
1385}
1386pub type SLDeviceVolumeItf = *const *const SLDeviceVolumeItf_;
1387#[repr(C)]
1388#[derive(Debug, Copy, Clone)]
1389pub struct SLDeviceVolumeItf_ {
1390 pub GetVolumeScale: ::std::option::Option<
1391 unsafe extern "C" fn(
1392 self_: SLDeviceVolumeItf,
1393 deviceID: SLuint32,
1394 pMinValue: *mut SLint32,
1395 pMaxValue: *mut SLint32,
1396 pIsMillibelScale: *mut SLboolean,
1397 ) -> SLresult,
1398 >,
1399 pub SetVolume: ::std::option::Option<
1400 unsafe extern "C" fn(
1401 self_: SLDeviceVolumeItf,
1402 deviceID: SLuint32,
1403 volume: SLint32,
1404 ) -> SLresult,
1405 >,
1406 pub GetVolume: ::std::option::Option<
1407 unsafe extern "C" fn(
1408 self_: SLDeviceVolumeItf,
1409 deviceID: SLuint32,
1410 pVolume: *mut SLint32,
1411 ) -> SLresult,
1412 >,
1413}
1414extern "C" {
1415 pub static SL_IID_BUFFERQUEUE: SLInterfaceID;
1416}
1417pub type SLBufferQueueItf = *const *const SLBufferQueueItf_;
1418pub type slBufferQueueCallback = ::std::option::Option<
1419 unsafe extern "C" fn(
1420 caller: SLBufferQueueItf,
1421 eventFlags: SLuint32,
1422 pBuffer: *const ::std::os::raw::c_void,
1423 bufferSize: SLuint32,
1424 dataUsed: SLuint32,
1425 pContext: *mut ::std::os::raw::c_void,
1426 ),
1427>;
1428#[doc = " Buffer queue state"]
1429#[repr(C)]
1430pub struct SLBufferQueueState_ {
1431 pub count: SLuint32,
1432 pub index: SLuint32,
1433}
1434pub type SLBufferQueueState = SLBufferQueueState_;
1435#[repr(C)]
1436#[derive(Debug, Copy, Clone)]
1437pub struct SLBufferQueueItf_ {
1438 pub Enqueue: ::std::option::Option<
1439 unsafe extern "C" fn(
1440 self_: SLBufferQueueItf,
1441 pBuffer: *const ::std::os::raw::c_void,
1442 size: SLuint32,
1443 isLastBuffer: SLboolean,
1444 ) -> SLresult,
1445 >,
1446 pub Clear: ::std::option::Option<unsafe extern "C" fn(self_: SLBufferQueueItf) -> SLresult>,
1447 pub GetState: ::std::option::Option<
1448 unsafe extern "C" fn(self_: SLBufferQueueItf, pState: *mut SLBufferQueueState) -> SLresult,
1449 >,
1450 pub RegisterCallback: ::std::option::Option<
1451 unsafe extern "C" fn(
1452 self_: SLBufferQueueItf,
1453 callback: slBufferQueueCallback,
1454 pContext: *mut ::std::os::raw::c_void,
1455 ) -> SLresult,
1456 >,
1457 pub SetCallbackEventsMask: ::std::option::Option<
1458 unsafe extern "C" fn(self_: SLBufferQueueItf, eventFlags: SLuint32) -> SLresult,
1459 >,
1460 pub GetCallbackEventsMask: ::std::option::Option<
1461 unsafe extern "C" fn(self_: SLBufferQueueItf, pEventFlags: *mut SLuint32) -> SLresult,
1462 >,
1463}
1464extern "C" {
1465 pub static SL_IID_CONFIGEXTENSION: SLInterfaceID;
1466}
1467pub type SLConfigExtensionsItf = *const *const SLConfigExtensionsItf_;
1468#[repr(C)]
1469#[derive(Debug, Copy, Clone)]
1470pub struct SLConfigExtensionsItf_ {
1471 pub SetConfiguration: ::std::option::Option<
1472 unsafe extern "C" fn(
1473 self_: SLConfigExtensionsItf,
1474 pConfigKey: *const SLchar,
1475 valueSize: SLuint32,
1476 pConfigValue: *const ::std::os::raw::c_void,
1477 ) -> SLresult,
1478 >,
1479 pub GetConfiguration: ::std::option::Option<
1480 unsafe extern "C" fn(
1481 self_: SLConfigExtensionsItf,
1482 pConfigKey: *const SLchar,
1483 pValueSize: *mut SLuint32,
1484 pConfigValue: *mut ::std::os::raw::c_void,
1485 ) -> SLresult,
1486 >,
1487}
1488extern "C" {
1489 pub static SL_IID_PRESETREVERB: SLInterfaceID;
1490}
1491pub type SLPresetReverbItf = *const *const SLPresetReverbItf_;
1492#[repr(C)]
1493#[derive(Debug, Copy, Clone)]
1494pub struct SLPresetReverbItf_ {
1495 pub SetPreset: ::std::option::Option<
1496 unsafe extern "C" fn(self_: SLPresetReverbItf, preset: SLuint16) -> SLresult,
1497 >,
1498 pub GetPreset: ::std::option::Option<
1499 unsafe extern "C" fn(self_: SLPresetReverbItf, pPreset: *mut SLuint16) -> SLresult,
1500 >,
1501}
1502#[repr(C)]
1503pub struct SLEnvironmentalReverbSettings_ {
1504 pub roomLevel: SLmillibel,
1505 pub roomHFLevel: SLmillibel,
1506 pub decayTime: SLmillisecond,
1507 pub decayHFRatio: SLpermille,
1508 pub reflectionsLevel: SLmillibel,
1509 pub reflectionsDelay: SLmillisecond,
1510 pub reverbLevel: SLmillibel,
1511 pub reverbDelay: SLmillisecond,
1512 pub diffusion: SLpermille,
1513 pub density: SLpermille,
1514}
1515pub type SLEnvironmentalReverbSettings = SLEnvironmentalReverbSettings_;
1516extern "C" {
1517 pub static SL_IID_ENVIRONMENTALREVERB: SLInterfaceID;
1518}
1519pub type SLEnvironmentalReverbItf = *const *const SLEnvironmentalReverbItf_;
1520#[repr(C)]
1521#[derive(Debug, Copy, Clone)]
1522pub struct SLEnvironmentalReverbItf_ {
1523 pub SetRoomLevel: ::std::option::Option<
1524 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, room: SLmillibel) -> SLresult,
1525 >,
1526 pub GetRoomLevel: ::std::option::Option<
1527 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoom: *mut SLmillibel) -> SLresult,
1528 >,
1529 pub SetRoomHFLevel: ::std::option::Option<
1530 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, roomHF: SLmillibel) -> SLresult,
1531 >,
1532 pub GetRoomHFLevel: ::std::option::Option<
1533 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoomHF: *mut SLmillibel) -> SLresult,
1534 >,
1535 pub SetDecayTime: ::std::option::Option<
1536 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayTime: SLmillisecond) -> SLresult,
1537 >,
1538 pub GetDecayTime: ::std::option::Option<
1539 unsafe extern "C" fn(
1540 self_: SLEnvironmentalReverbItf,
1541 pDecayTime: *mut SLmillisecond,
1542 ) -> SLresult,
1543 >,
1544 pub SetDecayHFRatio: ::std::option::Option<
1545 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayHFRatio: SLpermille) -> SLresult,
1546 >,
1547 pub GetDecayHFRatio: ::std::option::Option<
1548 unsafe extern "C" fn(
1549 self_: SLEnvironmentalReverbItf,
1550 pDecayHFRatio: *mut SLpermille,
1551 ) -> SLresult,
1552 >,
1553 pub SetReflectionsLevel: ::std::option::Option<
1554 unsafe extern "C" fn(
1555 self_: SLEnvironmentalReverbItf,
1556 reflectionsLevel: SLmillibel,
1557 ) -> SLresult,
1558 >,
1559 pub GetReflectionsLevel: ::std::option::Option<
1560 unsafe extern "C" fn(
1561 self_: SLEnvironmentalReverbItf,
1562 pReflectionsLevel: *mut SLmillibel,
1563 ) -> SLresult,
1564 >,
1565 pub SetReflectionsDelay: ::std::option::Option<
1566 unsafe extern "C" fn(
1567 self_: SLEnvironmentalReverbItf,
1568 reflectionsDelay: SLmillisecond,
1569 ) -> SLresult,
1570 >,
1571 pub GetReflectionsDelay: ::std::option::Option<
1572 unsafe extern "C" fn(
1573 self_: SLEnvironmentalReverbItf,
1574 pReflectionsDelay: *mut SLmillisecond,
1575 ) -> SLresult,
1576 >,
1577 pub SetReverbLevel: ::std::option::Option<
1578 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reverbLevel: SLmillibel) -> SLresult,
1579 >,
1580 pub GetReverbLevel: ::std::option::Option<
1581 unsafe extern "C" fn(
1582 self_: SLEnvironmentalReverbItf,
1583 pReverbLevel: *mut SLmillibel,
1584 ) -> SLresult,
1585 >,
1586 pub SetReverbDelay: ::std::option::Option<
1587 unsafe extern "C" fn(
1588 self_: SLEnvironmentalReverbItf,
1589 reverbDelay: SLmillisecond,
1590 ) -> SLresult,
1591 >,
1592 pub GetReverbDelay: ::std::option::Option<
1593 unsafe extern "C" fn(
1594 self_: SLEnvironmentalReverbItf,
1595 pReverbDelay: *mut SLmillisecond,
1596 ) -> SLresult,
1597 >,
1598 pub SetDiffusion: ::std::option::Option<
1599 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, diffusion: SLpermille) -> SLresult,
1600 >,
1601 pub GetDiffusion: ::std::option::Option<
1602 unsafe extern "C" fn(
1603 self_: SLEnvironmentalReverbItf,
1604 pDiffusion: *mut SLpermille,
1605 ) -> SLresult,
1606 >,
1607 pub SetDensity: ::std::option::Option<
1608 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, density: SLpermille) -> SLresult,
1609 >,
1610 pub GetDensity: ::std::option::Option<
1611 unsafe extern "C" fn(
1612 self_: SLEnvironmentalReverbItf,
1613 pDensity: *mut SLpermille,
1614 ) -> SLresult,
1615 >,
1616 pub SetEnvironmentalReverbProperties: ::std::option::Option<
1617 unsafe extern "C" fn(
1618 self_: SLEnvironmentalReverbItf,
1619 pProperties: *const SLEnvironmentalReverbSettings,
1620 ) -> SLresult,
1621 >,
1622 pub GetEnvironmentalReverbProperties: ::std::option::Option<
1623 unsafe extern "C" fn(
1624 self_: SLEnvironmentalReverbItf,
1625 pProperties: *mut SLEnvironmentalReverbSettings,
1626 ) -> SLresult,
1627 >,
1628}
1629extern "C" {
1630 pub static SL_IID_EFFECTSEND: SLInterfaceID;
1631}
1632pub type SLEffectSendItf = *const *const SLEffectSendItf_;
1633#[repr(C)]
1634#[derive(Debug, Copy, Clone)]
1635pub struct SLEffectSendItf_ {
1636 pub EnableEffectSend: ::std::option::Option<
1637 unsafe extern "C" fn(
1638 self_: SLEffectSendItf,
1639 pAuxEffect: *const ::std::os::raw::c_void,
1640 enable: SLboolean,
1641 initialLevel: SLmillibel,
1642 ) -> SLresult,
1643 >,
1644 pub IsEnabled: ::std::option::Option<
1645 unsafe extern "C" fn(
1646 self_: SLEffectSendItf,
1647 pAuxEffect: *const ::std::os::raw::c_void,
1648 pEnable: *mut SLboolean,
1649 ) -> SLresult,
1650 >,
1651 pub SetDirectLevel: ::std::option::Option<
1652 unsafe extern "C" fn(self_: SLEffectSendItf, directLevel: SLmillibel) -> SLresult,
1653 >,
1654 pub GetDirectLevel: ::std::option::Option<
1655 unsafe extern "C" fn(self_: SLEffectSendItf, pDirectLevel: *mut SLmillibel) -> SLresult,
1656 >,
1657 pub SetSendLevel: ::std::option::Option<
1658 unsafe extern "C" fn(
1659 self_: SLEffectSendItf,
1660 pAuxEffect: *const ::std::os::raw::c_void,
1661 sendLevel: SLmillibel,
1662 ) -> SLresult,
1663 >,
1664 pub GetSendLevel: ::std::option::Option<
1665 unsafe extern "C" fn(
1666 self_: SLEffectSendItf,
1667 pAuxEffect: *const ::std::os::raw::c_void,
1668 pSendLevel: *mut SLmillibel,
1669 ) -> SLresult,
1670 >,
1671}
1672extern "C" {
1673 pub static SL_IID_3DGROUPING: SLInterfaceID;
1674}
1675pub type SL3DGroupingItf = *const *const SL3DGroupingItf_;
1676#[repr(C)]
1677#[derive(Debug, Copy, Clone)]
1678pub struct SL3DGroupingItf_ {
1679 pub Set3DGroup: ::std::option::Option<
1680 unsafe extern "C" fn(self_: SL3DGroupingItf, group: SLObjectItf) -> SLresult,
1681 >,
1682 pub Get3DGroup: ::std::option::Option<
1683 unsafe extern "C" fn(self_: SL3DGroupingItf, pGroup: *mut SLObjectItf) -> SLresult,
1684 >,
1685}
1686extern "C" {
1687 pub static SL_IID_3DHINT: SLInterfaceID;
1688}
1689pub type SL3DHintItf = *const *const SL3DHintItf_;
1690#[repr(C)]
1691#[derive(Debug, Copy, Clone)]
1692pub struct SL3DHintItf_ {
1693 pub SetRenderHint: ::std::option::Option<
1694 unsafe extern "C" fn(self_: SL3DHintItf, qualityHint: SLuint16) -> SLresult,
1695 >,
1696 pub GetRenderHint: ::std::option::Option<
1697 unsafe extern "C" fn(self_: SL3DHintItf, pQualityHint: *mut SLuint16) -> SLresult,
1698 >,
1699}
1700extern "C" {
1701 pub static SL_IID_3DCOMMIT: SLInterfaceID;
1702}
1703pub type SL3DCommitItf = *const *const SL3DCommitItf_;
1704#[repr(C)]
1705#[derive(Debug, Copy, Clone)]
1706pub struct SL3DCommitItf_ {
1707 pub Commit: ::std::option::Option<unsafe extern "C" fn(self_: SL3DCommitItf) -> SLresult>,
1708 pub SetDeferred: ::std::option::Option<
1709 unsafe extern "C" fn(self_: SL3DCommitItf, deferred: SLboolean) -> SLresult,
1710 >,
1711}
1712#[repr(C)]
1713pub struct SLVec3D_ {
1714 pub x: SLint32,
1715 pub y: SLint32,
1716 pub z: SLint32,
1717}
1718pub type SLVec3D = SLVec3D_;
1719extern "C" {
1720 pub static SL_IID_3DLOCATION: SLInterfaceID;
1721}
1722pub type SL3DLocationItf = *const *const SL3DLocationItf_;
1723#[repr(C)]
1724#[derive(Debug, Copy, Clone)]
1725pub struct SL3DLocationItf_ {
1726 pub SetLocationCartesian: ::std::option::Option<
1727 unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *const SLVec3D) -> SLresult,
1728 >,
1729 pub SetLocationSpherical: ::std::option::Option<
1730 unsafe extern "C" fn(
1731 self_: SL3DLocationItf,
1732 azimuth: SLmillidegree,
1733 elevation: SLmillidegree,
1734 distance: SLmillimeter,
1735 ) -> SLresult,
1736 >,
1737 pub Move: ::std::option::Option<
1738 unsafe extern "C" fn(self_: SL3DLocationItf, pMovement: *const SLVec3D) -> SLresult,
1739 >,
1740 pub GetLocationCartesian: ::std::option::Option<
1741 unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *mut SLVec3D) -> SLresult,
1742 >,
1743 pub SetOrientationVectors: ::std::option::Option<
1744 unsafe extern "C" fn(
1745 self_: SL3DLocationItf,
1746 pFront: *const SLVec3D,
1747 pAbove: *const SLVec3D,
1748 ) -> SLresult,
1749 >,
1750 pub SetOrientationAngles: ::std::option::Option<
1751 unsafe extern "C" fn(
1752 self_: SL3DLocationItf,
1753 heading: SLmillidegree,
1754 pitch: SLmillidegree,
1755 roll: SLmillidegree,
1756 ) -> SLresult,
1757 >,
1758 pub Rotate: ::std::option::Option<
1759 unsafe extern "C" fn(
1760 self_: SL3DLocationItf,
1761 theta: SLmillidegree,
1762 pAxis: *const SLVec3D,
1763 ) -> SLresult,
1764 >,
1765 pub GetOrientationVectors: ::std::option::Option<
1766 unsafe extern "C" fn(
1767 self_: SL3DLocationItf,
1768 pFront: *mut SLVec3D,
1769 pUp: *mut SLVec3D,
1770 ) -> SLresult,
1771 >,
1772}
1773extern "C" {
1774 pub static SL_IID_3DDOPPLER: SLInterfaceID;
1775}
1776pub type SL3DDopplerItf = *const *const SL3DDopplerItf_;
1777#[repr(C)]
1778#[derive(Debug, Copy, Clone)]
1779pub struct SL3DDopplerItf_ {
1780 pub SetVelocityCartesian: ::std::option::Option<
1781 unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *const SLVec3D) -> SLresult,
1782 >,
1783 pub SetVelocitySpherical: ::std::option::Option<
1784 unsafe extern "C" fn(
1785 self_: SL3DDopplerItf,
1786 azimuth: SLmillidegree,
1787 elevation: SLmillidegree,
1788 speed: SLmillimeter,
1789 ) -> SLresult,
1790 >,
1791 pub GetVelocityCartesian: ::std::option::Option<
1792 unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *mut SLVec3D) -> SLresult,
1793 >,
1794 pub SetDopplerFactor: ::std::option::Option<
1795 unsafe extern "C" fn(self_: SL3DDopplerItf, dopplerFactor: SLpermille) -> SLresult,
1796 >,
1797 pub GetDopplerFactor: ::std::option::Option<
1798 unsafe extern "C" fn(self_: SL3DDopplerItf, pDopplerFactor: *mut SLpermille) -> SLresult,
1799 >,
1800}
1801extern "C" {
1802 pub static SL_IID_3DSOURCE: SLInterfaceID;
1803}
1804pub type SL3DSourceItf = *const *const SL3DSourceItf_;
1805#[repr(C)]
1806#[derive(Debug, Copy, Clone)]
1807pub struct SL3DSourceItf_ {
1808 pub SetHeadRelative: ::std::option::Option<
1809 unsafe extern "C" fn(self_: SL3DSourceItf, headRelative: SLboolean) -> SLresult,
1810 >,
1811 pub GetHeadRelative: ::std::option::Option<
1812 unsafe extern "C" fn(self_: SL3DSourceItf, pHeadRelative: *mut SLboolean) -> SLresult,
1813 >,
1814 pub SetRolloffDistances: ::std::option::Option<
1815 unsafe extern "C" fn(
1816 self_: SL3DSourceItf,
1817 minDistance: SLmillimeter,
1818 maxDistance: SLmillimeter,
1819 ) -> SLresult,
1820 >,
1821 pub GetRolloffDistances: ::std::option::Option<
1822 unsafe extern "C" fn(
1823 self_: SL3DSourceItf,
1824 pMinDistance: *mut SLmillimeter,
1825 pMaxDistance: *mut SLmillimeter,
1826 ) -> SLresult,
1827 >,
1828 pub SetRolloffMaxDistanceMute: ::std::option::Option<
1829 unsafe extern "C" fn(self_: SL3DSourceItf, mute: SLboolean) -> SLresult,
1830 >,
1831 pub GetRolloffMaxDistanceMute: ::std::option::Option<
1832 unsafe extern "C" fn(self_: SL3DSourceItf, pMute: *mut SLboolean) -> SLresult,
1833 >,
1834 pub SetRolloffFactor: ::std::option::Option<
1835 unsafe extern "C" fn(self_: SL3DSourceItf, rolloffFactor: SLpermille) -> SLresult,
1836 >,
1837 pub GetRolloffFactor: ::std::option::Option<
1838 unsafe extern "C" fn(self_: SL3DSourceItf, pRolloffFactor: *mut SLpermille) -> SLresult,
1839 >,
1840 pub SetRoomRolloffFactor: ::std::option::Option<
1841 unsafe extern "C" fn(self_: SL3DSourceItf, roomRolloffFactor: SLpermille) -> SLresult,
1842 >,
1843 pub GetRoomRolloffFactor: ::std::option::Option<
1844 unsafe extern "C" fn(self_: SL3DSourceItf, pRoomRolloffFactor: *mut SLpermille) -> SLresult,
1845 >,
1846 pub SetRolloffModel: ::std::option::Option<
1847 unsafe extern "C" fn(self_: SL3DSourceItf, model: SLuint8) -> SLresult,
1848 >,
1849 pub GetRolloffModel: ::std::option::Option<
1850 unsafe extern "C" fn(self_: SL3DSourceItf, pModel: *mut SLuint8) -> SLresult,
1851 >,
1852 pub SetCone: ::std::option::Option<
1853 unsafe extern "C" fn(
1854 self_: SL3DSourceItf,
1855 innerAngle: SLmillidegree,
1856 outerAngle: SLmillidegree,
1857 outerLevel: SLmillibel,
1858 ) -> SLresult,
1859 >,
1860 pub GetCone: ::std::option::Option<
1861 unsafe extern "C" fn(
1862 self_: SL3DSourceItf,
1863 pInnerAngle: *mut SLmillidegree,
1864 pOuterAngle: *mut SLmillidegree,
1865 pOuterLevel: *mut SLmillibel,
1866 ) -> SLresult,
1867 >,
1868}
1869extern "C" {
1870 pub static SL_IID_3DMACROSCOPIC: SLInterfaceID;
1871}
1872pub type SL3DMacroscopicItf = *const *const SL3DMacroscopicItf_;
1873#[repr(C)]
1874#[derive(Debug, Copy, Clone)]
1875pub struct SL3DMacroscopicItf_ {
1876 pub SetSize: ::std::option::Option<
1877 unsafe extern "C" fn(
1878 self_: SL3DMacroscopicItf,
1879 width: SLmillimeter,
1880 height: SLmillimeter,
1881 depth: SLmillimeter,
1882 ) -> SLresult,
1883 >,
1884 pub GetSize: ::std::option::Option<
1885 unsafe extern "C" fn(
1886 self_: SL3DMacroscopicItf,
1887 pWidth: *mut SLmillimeter,
1888 pHeight: *mut SLmillimeter,
1889 pDepth: *mut SLmillimeter,
1890 ) -> SLresult,
1891 >,
1892 pub SetOrientationAngles: ::std::option::Option<
1893 unsafe extern "C" fn(
1894 self_: SL3DMacroscopicItf,
1895 heading: SLmillidegree,
1896 pitch: SLmillidegree,
1897 roll: SLmillidegree,
1898 ) -> SLresult,
1899 >,
1900 pub SetOrientationVectors: ::std::option::Option<
1901 unsafe extern "C" fn(
1902 self_: SL3DMacroscopicItf,
1903 pFront: *const SLVec3D,
1904 pAbove: *const SLVec3D,
1905 ) -> SLresult,
1906 >,
1907 pub Rotate: ::std::option::Option<
1908 unsafe extern "C" fn(
1909 self_: SL3DMacroscopicItf,
1910 theta: SLmillidegree,
1911 pAxis: *const SLVec3D,
1912 ) -> SLresult,
1913 >,
1914 pub GetOrientationVectors: ::std::option::Option<
1915 unsafe extern "C" fn(
1916 self_: SL3DMacroscopicItf,
1917 pFront: *mut SLVec3D,
1918 pUp: *mut SLVec3D,
1919 ) -> SLresult,
1920 >,
1921}
1922extern "C" {
1923 pub static SL_IID_MUTESOLO: SLInterfaceID;
1924}
1925pub type SLMuteSoloItf = *const *const SLMuteSoloItf_;
1926#[repr(C)]
1927#[derive(Debug, Copy, Clone)]
1928pub struct SLMuteSoloItf_ {
1929 pub SetChannelMute: ::std::option::Option<
1930 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, mute: SLboolean) -> SLresult,
1931 >,
1932 pub GetChannelMute: ::std::option::Option<
1933 unsafe extern "C" fn(
1934 self_: SLMuteSoloItf,
1935 chan: SLuint8,
1936 pMute: *mut SLboolean,
1937 ) -> SLresult,
1938 >,
1939 pub SetChannelSolo: ::std::option::Option<
1940 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, solo: SLboolean) -> SLresult,
1941 >,
1942 pub GetChannelSolo: ::std::option::Option<
1943 unsafe extern "C" fn(
1944 self_: SLMuteSoloItf,
1945 chan: SLuint8,
1946 pSolo: *mut SLboolean,
1947 ) -> SLresult,
1948 >,
1949 pub GetNumChannels: ::std::option::Option<
1950 unsafe extern "C" fn(self_: SLMuteSoloItf, pNumChannels: *mut SLuint8) -> SLresult,
1951 >,
1952}
1953extern "C" {
1954 pub static SL_IID_DYNAMICINTERFACEMANAGEMENT: SLInterfaceID;
1955}
1956pub type SLDynamicInterfaceManagementItf = *const *const SLDynamicInterfaceManagementItf_;
1957pub type slDynamicInterfaceManagementCallback = ::std::option::Option<
1958 unsafe extern "C" fn(
1959 caller: SLDynamicInterfaceManagementItf,
1960 pContext: *mut ::std::os::raw::c_void,
1961 event: SLuint32,
1962 result: SLresult,
1963 iid: SLInterfaceID,
1964 ),
1965>;
1966#[repr(C)]
1967#[derive(Debug, Copy, Clone)]
1968pub struct SLDynamicInterfaceManagementItf_ {
1969 pub AddInterface: ::std::option::Option<
1970 unsafe extern "C" fn(
1971 self_: SLDynamicInterfaceManagementItf,
1972 iid: SLInterfaceID,
1973 async_: SLboolean,
1974 ) -> SLresult,
1975 >,
1976 pub RemoveInterface: ::std::option::Option<
1977 unsafe extern "C" fn(
1978 self_: SLDynamicInterfaceManagementItf,
1979 iid: SLInterfaceID,
1980 ) -> SLresult,
1981 >,
1982 pub ResumeInterface: ::std::option::Option<
1983 unsafe extern "C" fn(
1984 self_: SLDynamicInterfaceManagementItf,
1985 iid: SLInterfaceID,
1986 async_: SLboolean,
1987 ) -> SLresult,
1988 >,
1989 pub RegisterCallback: ::std::option::Option<
1990 unsafe extern "C" fn(
1991 self_: SLDynamicInterfaceManagementItf,
1992 callback: slDynamicInterfaceManagementCallback,
1993 pContext: *mut ::std::os::raw::c_void,
1994 ) -> SLresult,
1995 >,
1996}
1997extern "C" {
1998 pub static SL_IID_MIDIMESSAGE: SLInterfaceID;
1999}
2000pub type SLMIDIMessageItf = *const *const SLMIDIMessageItf_;
2001pub type slMetaEventCallback = ::std::option::Option<
2002 unsafe extern "C" fn(
2003 caller: SLMIDIMessageItf,
2004 pContext: *mut ::std::os::raw::c_void,
2005 type_: SLuint8,
2006 length: SLuint32,
2007 pData: *const SLuint8,
2008 tick: SLuint32,
2009 track: SLuint16,
2010 ),
2011>;
2012pub type slMIDIMessageCallback = ::std::option::Option<
2013 unsafe extern "C" fn(
2014 caller: SLMIDIMessageItf,
2015 pContext: *mut ::std::os::raw::c_void,
2016 statusByte: SLuint8,
2017 length: SLuint32,
2018 pData: *const SLuint8,
2019 tick: SLuint32,
2020 track: SLuint16,
2021 ),
2022>;
2023#[repr(C)]
2024#[derive(Debug, Copy, Clone)]
2025pub struct SLMIDIMessageItf_ {
2026 pub SendMessage: ::std::option::Option<
2027 unsafe extern "C" fn(
2028 self_: SLMIDIMessageItf,
2029 pData: *const SLuint8,
2030 length: SLuint32,
2031 ) -> SLresult,
2032 >,
2033 pub RegisterMetaEventCallback: ::std::option::Option<
2034 unsafe extern "C" fn(
2035 self_: SLMIDIMessageItf,
2036 callback: slMetaEventCallback,
2037 pContext: *mut ::std::os::raw::c_void,
2038 ) -> SLresult,
2039 >,
2040 pub RegisterMIDIMessageCallback: ::std::option::Option<
2041 unsafe extern "C" fn(
2042 self_: SLMIDIMessageItf,
2043 callback: slMIDIMessageCallback,
2044 pContext: *mut ::std::os::raw::c_void,
2045 ) -> SLresult,
2046 >,
2047 pub AddMIDIMessageCallbackFilter: ::std::option::Option<
2048 unsafe extern "C" fn(self_: SLMIDIMessageItf, messageType: SLuint32) -> SLresult,
2049 >,
2050 pub ClearMIDIMessageCallbackFilter:
2051 ::std::option::Option<unsafe extern "C" fn(self_: SLMIDIMessageItf) -> SLresult>,
2052}
2053extern "C" {
2054 pub static SL_IID_MIDIMUTESOLO: SLInterfaceID;
2055}
2056pub type SLMIDIMuteSoloItf = *const *const SLMIDIMuteSoloItf_;
2057#[repr(C)]
2058#[derive(Debug, Copy, Clone)]
2059pub struct SLMIDIMuteSoloItf_ {
2060 pub SetChannelMute: ::std::option::Option<
2061 unsafe extern "C" fn(
2062 self_: SLMIDIMuteSoloItf,
2063 channel: SLuint8,
2064 mute: SLboolean,
2065 ) -> SLresult,
2066 >,
2067 pub GetChannelMute: ::std::option::Option<
2068 unsafe extern "C" fn(
2069 self_: SLMIDIMuteSoloItf,
2070 channel: SLuint8,
2071 pMute: *mut SLboolean,
2072 ) -> SLresult,
2073 >,
2074 pub SetChannelSolo: ::std::option::Option<
2075 unsafe extern "C" fn(
2076 self_: SLMIDIMuteSoloItf,
2077 channel: SLuint8,
2078 solo: SLboolean,
2079 ) -> SLresult,
2080 >,
2081 pub GetChannelSolo: ::std::option::Option<
2082 unsafe extern "C" fn(
2083 self_: SLMIDIMuteSoloItf,
2084 channel: SLuint8,
2085 pSolo: *mut SLboolean,
2086 ) -> SLresult,
2087 >,
2088 pub GetTrackCount: ::std::option::Option<
2089 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, pCount: *mut SLuint16) -> SLresult,
2090 >,
2091 pub SetTrackMute: ::std::option::Option<
2092 unsafe extern "C" fn(
2093 self_: SLMIDIMuteSoloItf,
2094 track: SLuint16,
2095 mute: SLboolean,
2096 ) -> SLresult,
2097 >,
2098 pub GetTrackMute: ::std::option::Option<
2099 unsafe extern "C" fn(
2100 self_: SLMIDIMuteSoloItf,
2101 track: SLuint16,
2102 pMute: *mut SLboolean,
2103 ) -> SLresult,
2104 >,
2105 pub SetTrackSolo: ::std::option::Option<
2106 unsafe extern "C" fn(
2107 self_: SLMIDIMuteSoloItf,
2108 track: SLuint16,
2109 solo: SLboolean,
2110 ) -> SLresult,
2111 >,
2112 pub GetTrackSolo: ::std::option::Option<
2113 unsafe extern "C" fn(
2114 self_: SLMIDIMuteSoloItf,
2115 track: SLuint16,
2116 pSolo: *mut SLboolean,
2117 ) -> SLresult,
2118 >,
2119}
2120extern "C" {
2121 pub static SL_IID_MIDITEMPO: SLInterfaceID;
2122}
2123pub type SLMIDITempoItf = *const *const SLMIDITempoItf_;
2124#[repr(C)]
2125#[derive(Debug, Copy, Clone)]
2126pub struct SLMIDITempoItf_ {
2127 pub SetTicksPerQuarterNote: ::std::option::Option<
2128 unsafe extern "C" fn(self_: SLMIDITempoItf, tpqn: SLuint32) -> SLresult,
2129 >,
2130 pub GetTicksPerQuarterNote: ::std::option::Option<
2131 unsafe extern "C" fn(self_: SLMIDITempoItf, pTpqn: *mut SLuint32) -> SLresult,
2132 >,
2133 pub SetMicrosecondsPerQuarterNote: ::std::option::Option<
2134 unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: SLmicrosecond) -> SLresult,
2135 >,
2136 pub GetMicrosecondsPerQuarterNote: ::std::option::Option<
2137 unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: *mut SLmicrosecond) -> SLresult,
2138 >,
2139}
2140extern "C" {
2141 pub static SL_IID_MIDITIME: SLInterfaceID;
2142}
2143pub type SLMIDITimeItf = *const *const SLMIDITimeItf_;
2144#[repr(C)]
2145#[derive(Debug, Copy, Clone)]
2146pub struct SLMIDITimeItf_ {
2147 pub GetDuration: ::std::option::Option<
2148 unsafe extern "C" fn(self_: SLMIDITimeItf, pDuration: *mut SLuint32) -> SLresult,
2149 >,
2150 pub SetPosition: ::std::option::Option<
2151 unsafe extern "C" fn(self_: SLMIDITimeItf, position: SLuint32) -> SLresult,
2152 >,
2153 pub GetPosition: ::std::option::Option<
2154 unsafe extern "C" fn(self_: SLMIDITimeItf, pPosition: *mut SLuint32) -> SLresult,
2155 >,
2156 pub SetLoopPoints: ::std::option::Option<
2157 unsafe extern "C" fn(
2158 self_: SLMIDITimeItf,
2159 startTick: SLuint32,
2160 numTicks: SLuint32,
2161 ) -> SLresult,
2162 >,
2163 pub GetLoopPoints: ::std::option::Option<
2164 unsafe extern "C" fn(
2165 self_: SLMIDITimeItf,
2166 pStartTick: *mut SLuint32,
2167 pNumTicks: *mut SLuint32,
2168 ) -> SLresult,
2169 >,
2170}
2171#[repr(C)]
2172pub struct SLAudioCodecDescriptor_ {
2173 pub maxChannels: SLuint32,
2174 pub minBitsPerSample: SLuint32,
2175 pub maxBitsPerSample: SLuint32,
2176 pub minSampleRate: SLmilliHertz,
2177 pub maxSampleRate: SLmilliHertz,
2178 pub isFreqRangeContinuous: SLboolean,
2179 pub pSampleRatesSupported: *mut SLmilliHertz,
2180 pub numSampleRatesSupported: SLuint32,
2181 pub minBitRate: SLuint32,
2182 pub maxBitRate: SLuint32,
2183 pub isBitrateRangeContinuous: SLboolean,
2184 pub pBitratesSupported: *mut SLuint32,
2185 pub numBitratesSupported: SLuint32,
2186 pub profileSetting: SLuint32,
2187 pub modeSetting: SLuint32,
2188 pub streamFormat: SLuint32,
2189}
2190pub type SLAudioCodecDescriptor = SLAudioCodecDescriptor_;
2191extern "C" {
2192 pub static SL_IID_AUDIODECODERCAPABILITIES: SLInterfaceID;
2193}
2194pub type SLAudioDecoderCapabilitiesItf = *const *const SLAudioDecoderCapabilitiesItf_;
2195#[repr(C)]
2196#[derive(Debug, Copy, Clone)]
2197pub struct SLAudioDecoderCapabilitiesItf_ {
2198 pub GetAudioDecoders: ::std::option::Option<
2199 unsafe extern "C" fn(
2200 self_: SLAudioDecoderCapabilitiesItf,
2201 pNumDecoders: *mut SLuint32,
2202 pDecoderIds: *mut SLuint32,
2203 ) -> SLresult,
2204 >,
2205 pub GetAudioDecoderCapabilities: ::std::option::Option<
2206 unsafe extern "C" fn(
2207 self_: SLAudioDecoderCapabilitiesItf,
2208 decoderId: SLuint32,
2209 pIndex: *mut SLuint32,
2210 pDescriptor: *mut SLAudioCodecDescriptor,
2211 ) -> SLresult,
2212 >,
2213}
2214#[repr(C)]
2215pub struct SLAudioEncoderSettings_ {
2216 pub encoderId: SLuint32,
2217 pub channelsIn: SLuint32,
2218 pub channelsOut: SLuint32,
2219 pub sampleRate: SLmilliHertz,
2220 pub bitRate: SLuint32,
2221 pub bitsPerSample: SLuint32,
2222 pub rateControl: SLuint32,
2223 pub profileSetting: SLuint32,
2224 pub levelSetting: SLuint32,
2225 pub channelMode: SLuint32,
2226 pub streamFormat: SLuint32,
2227 pub encodeOptions: SLuint32,
2228 pub blockAlignment: SLuint32,
2229}
2230pub type SLAudioEncoderSettings = SLAudioEncoderSettings_;
2231extern "C" {
2232 pub static SL_IID_AUDIOENCODERCAPABILITIES: SLInterfaceID;
2233}
2234pub type SLAudioEncoderCapabilitiesItf = *const *const SLAudioEncoderCapabilitiesItf_;
2235#[repr(C)]
2236#[derive(Debug, Copy, Clone)]
2237pub struct SLAudioEncoderCapabilitiesItf_ {
2238 pub GetAudioEncoders: ::std::option::Option<
2239 unsafe extern "C" fn(
2240 self_: SLAudioEncoderCapabilitiesItf,
2241 pNumEncoders: *mut SLuint32,
2242 pEncoderIds: *mut SLuint32,
2243 ) -> SLresult,
2244 >,
2245 pub GetAudioEncoderCapabilities: ::std::option::Option<
2246 unsafe extern "C" fn(
2247 self_: SLAudioEncoderCapabilitiesItf,
2248 encoderId: SLuint32,
2249 pIndex: *mut SLuint32,
2250 pDescriptor: *mut SLAudioCodecDescriptor,
2251 ) -> SLresult,
2252 >,
2253}
2254extern "C" {
2255 pub static SL_IID_AUDIOENCODER: SLInterfaceID;
2256}
2257pub type SLAudioEncoderItf = *const *const SLAudioEncoderItf_;
2258#[repr(C)]
2259#[derive(Debug, Copy, Clone)]
2260pub struct SLAudioEncoderItf_ {
2261 pub SetEncoderSettings: ::std::option::Option<
2262 unsafe extern "C" fn(
2263 self_: SLAudioEncoderItf,
2264 pSettings: *mut SLAudioEncoderSettings,
2265 ) -> SLresult,
2266 >,
2267 pub GetEncoderSettings: ::std::option::Option<
2268 unsafe extern "C" fn(
2269 self_: SLAudioEncoderItf,
2270 pSettings: *mut SLAudioEncoderSettings,
2271 ) -> SLresult,
2272 >,
2273}
2274extern "C" {
2275 pub static SL_IID_BASSBOOST: SLInterfaceID;
2276}
2277pub type SLBassBoostItf = *const *const SLBassBoostItf_;
2278#[repr(C)]
2279#[derive(Debug, Copy, Clone)]
2280pub struct SLBassBoostItf_ {
2281 pub SetEnabled: ::std::option::Option<
2282 unsafe extern "C" fn(self_: SLBassBoostItf, enabled: SLboolean) -> SLresult,
2283 >,
2284 pub IsEnabled: ::std::option::Option<
2285 unsafe extern "C" fn(self_: SLBassBoostItf, pEnabled: *mut SLboolean) -> SLresult,
2286 >,
2287 pub SetStrength: ::std::option::Option<
2288 unsafe extern "C" fn(self_: SLBassBoostItf, strength: SLpermille) -> SLresult,
2289 >,
2290 pub GetRoundedStrength: ::std::option::Option<
2291 unsafe extern "C" fn(self_: SLBassBoostItf, pStrength: *mut SLpermille) -> SLresult,
2292 >,
2293 pub IsStrengthSupported: ::std::option::Option<
2294 unsafe extern "C" fn(self_: SLBassBoostItf, pSupported: *mut SLboolean) -> SLresult,
2295 >,
2296}
2297extern "C" {
2298 pub static SL_IID_PITCH: SLInterfaceID;
2299}
2300pub type SLPitchItf = *const *const SLPitchItf_;
2301#[repr(C)]
2302#[derive(Debug, Copy, Clone)]
2303pub struct SLPitchItf_ {
2304 pub SetPitch: ::std::option::Option<
2305 unsafe extern "C" fn(self_: SLPitchItf, pitch: SLpermille) -> SLresult,
2306 >,
2307 pub GetPitch: ::std::option::Option<
2308 unsafe extern "C" fn(self_: SLPitchItf, pPitch: *mut SLpermille) -> SLresult,
2309 >,
2310 pub GetPitchCapabilities: ::std::option::Option<
2311 unsafe extern "C" fn(
2312 self_: SLPitchItf,
2313 pMinPitch: *mut SLpermille,
2314 pMaxPitch: *mut SLpermille,
2315 ) -> SLresult,
2316 >,
2317}
2318extern "C" {
2319 pub static SL_IID_RATEPITCH: SLInterfaceID;
2320}
2321pub type SLRatePitchItf = *const *const SLRatePitchItf_;
2322#[repr(C)]
2323#[derive(Debug, Copy, Clone)]
2324pub struct SLRatePitchItf_ {
2325 pub SetRate: ::std::option::Option<
2326 unsafe extern "C" fn(self_: SLRatePitchItf, rate: SLpermille) -> SLresult,
2327 >,
2328 pub GetRate: ::std::option::Option<
2329 unsafe extern "C" fn(self_: SLRatePitchItf, pRate: *mut SLpermille) -> SLresult,
2330 >,
2331 pub GetRatePitchCapabilities: ::std::option::Option<
2332 unsafe extern "C" fn(
2333 self_: SLRatePitchItf,
2334 pMinRate: *mut SLpermille,
2335 pMaxRate: *mut SLpermille,
2336 ) -> SLresult,
2337 >,
2338}
2339extern "C" {
2340 pub static SL_IID_VIRTUALIZER: SLInterfaceID;
2341}
2342pub type SLVirtualizerItf = *const *const SLVirtualizerItf_;
2343#[repr(C)]
2344#[derive(Debug, Copy, Clone)]
2345pub struct SLVirtualizerItf_ {
2346 pub SetEnabled: ::std::option::Option<
2347 unsafe extern "C" fn(self_: SLVirtualizerItf, enabled: SLboolean) -> SLresult,
2348 >,
2349 pub IsEnabled: ::std::option::Option<
2350 unsafe extern "C" fn(self_: SLVirtualizerItf, pEnabled: *mut SLboolean) -> SLresult,
2351 >,
2352 pub SetStrength: ::std::option::Option<
2353 unsafe extern "C" fn(self_: SLVirtualizerItf, strength: SLpermille) -> SLresult,
2354 >,
2355 pub GetRoundedStrength: ::std::option::Option<
2356 unsafe extern "C" fn(self_: SLVirtualizerItf, pStrength: *mut SLpermille) -> SLresult,
2357 >,
2358 pub IsStrengthSupported: ::std::option::Option<
2359 unsafe extern "C" fn(self_: SLVirtualizerItf, pSupported: *mut SLboolean) -> SLresult,
2360 >,
2361}
2362extern "C" {
2363 pub static SL_IID_VISUALIZATION: SLInterfaceID;
2364}
2365pub type SLVisualizationItf = *const *const SLVisualizationItf_;
2366pub type slVisualizationCallback = ::std::option::Option<
2367 unsafe extern "C" fn(
2368 pContext: *mut ::std::os::raw::c_void,
2369 waveform: *const SLuint8,
2370 fft: *const SLuint8,
2371 samplerate: SLmilliHertz,
2372 ),
2373>;
2374#[repr(C)]
2375#[derive(Debug, Copy, Clone)]
2376pub struct SLVisualizationItf_ {
2377 pub RegisterVisualizationCallback: ::std::option::Option<
2378 unsafe extern "C" fn(
2379 self_: SLVisualizationItf,
2380 callback: slVisualizationCallback,
2381 pContext: *mut ::std::os::raw::c_void,
2382 rate: SLmilliHertz,
2383 ) -> SLresult,
2384 >,
2385 pub GetMaxRate: ::std::option::Option<
2386 unsafe extern "C" fn(self_: SLVisualizationItf, pRate: *mut SLmilliHertz) -> SLresult,
2387 >,
2388}
2389extern "C" {
2390 pub static SL_IID_ENGINE: SLInterfaceID;
2391}
2392pub type SLEngineItf = *const *const SLEngineItf_;
2393#[repr(C)]
2394#[derive(Debug, Copy, Clone)]
2395pub struct SLEngineItf_ {
2396 pub CreateLEDDevice: ::std::option::Option<
2397 unsafe extern "C" fn(
2398 self_: SLEngineItf,
2399 pDevice: *mut SLObjectItf,
2400 deviceID: SLuint32,
2401 numInterfaces: SLuint32,
2402 pInterfaceIds: *const SLInterfaceID,
2403 pInterfaceRequired: *const SLboolean,
2404 ) -> SLresult,
2405 >,
2406 pub CreateVibraDevice: ::std::option::Option<
2407 unsafe extern "C" fn(
2408 self_: SLEngineItf,
2409 pDevice: *mut SLObjectItf,
2410 deviceID: SLuint32,
2411 numInterfaces: SLuint32,
2412 pInterfaceIds: *const SLInterfaceID,
2413 pInterfaceRequired: *const SLboolean,
2414 ) -> SLresult,
2415 >,
2416 pub CreateAudioPlayer: ::std::option::Option<
2417 unsafe extern "C" fn(
2418 self_: SLEngineItf,
2419 pPlayer: *mut SLObjectItf,
2420 pAudioSrc: *const SLDataSource,
2421 pAudioSnk: *const SLDataSink,
2422 numInterfaces: SLuint32,
2423 pInterfaceIds: *const SLInterfaceID,
2424 pInterfaceRequired: *const SLboolean,
2425 ) -> SLresult,
2426 >,
2427 pub CreateAudioRecorder: ::std::option::Option<
2428 unsafe extern "C" fn(
2429 self_: SLEngineItf,
2430 pRecorder: *mut SLObjectItf,
2431 pAudioSrc: *const SLDataSource,
2432 pAudioSnk: *const SLDataSink,
2433 numInterfaces: SLuint32,
2434 pInterfaceIds: *const SLInterfaceID,
2435 pInterfaceRequired: *const SLboolean,
2436 ) -> SLresult,
2437 >,
2438 pub CreateMidiPlayer: ::std::option::Option<
2439 unsafe extern "C" fn(
2440 self_: SLEngineItf,
2441 pPlayer: *mut SLObjectItf,
2442 pMIDISrc: *const SLDataSource,
2443 pBankSrc: *const SLDataSource,
2444 pAudioOutput: *const SLDataSink,
2445 pVibra: *const SLDataSink,
2446 pLEDArray: *const SLDataSink,
2447 numInterfaces: SLuint32,
2448 pInterfaceIds: *const SLInterfaceID,
2449 pInterfaceRequired: *const SLboolean,
2450 ) -> SLresult,
2451 >,
2452 pub CreateListener: ::std::option::Option<
2453 unsafe extern "C" fn(
2454 self_: SLEngineItf,
2455 pListener: *mut SLObjectItf,
2456 numInterfaces: SLuint32,
2457 pInterfaceIds: *const SLInterfaceID,
2458 pInterfaceRequired: *const SLboolean,
2459 ) -> SLresult,
2460 >,
2461 pub Create3DGroup: ::std::option::Option<
2462 unsafe extern "C" fn(
2463 self_: SLEngineItf,
2464 pGroup: *mut SLObjectItf,
2465 numInterfaces: SLuint32,
2466 pInterfaceIds: *const SLInterfaceID,
2467 pInterfaceRequired: *const SLboolean,
2468 ) -> SLresult,
2469 >,
2470 pub CreateOutputMix: ::std::option::Option<
2471 unsafe extern "C" fn(
2472 self_: SLEngineItf,
2473 pMix: *mut SLObjectItf,
2474 numInterfaces: SLuint32,
2475 pInterfaceIds: *const SLInterfaceID,
2476 pInterfaceRequired: *const SLboolean,
2477 ) -> SLresult,
2478 >,
2479 pub CreateMetadataExtractor: ::std::option::Option<
2480 unsafe extern "C" fn(
2481 self_: SLEngineItf,
2482 pMetadataExtractor: *mut SLObjectItf,
2483 pDataSource: *const SLDataSource,
2484 numInterfaces: SLuint32,
2485 pInterfaceIds: *const SLInterfaceID,
2486 pInterfaceRequired: *const SLboolean,
2487 ) -> SLresult,
2488 >,
2489 pub CreateExtensionObject: ::std::option::Option<
2490 unsafe extern "C" fn(
2491 self_: SLEngineItf,
2492 pObject: *mut SLObjectItf,
2493 pParameters: *mut ::std::os::raw::c_void,
2494 objectID: SLuint32,
2495 numInterfaces: SLuint32,
2496 pInterfaceIds: *const SLInterfaceID,
2497 pInterfaceRequired: *const SLboolean,
2498 ) -> SLresult,
2499 >,
2500 pub QueryNumSupportedInterfaces: ::std::option::Option<
2501 unsafe extern "C" fn(
2502 self_: SLEngineItf,
2503 objectID: SLuint32,
2504 pNumSupportedInterfaces: *mut SLuint32,
2505 ) -> SLresult,
2506 >,
2507 pub QuerySupportedInterfaces: ::std::option::Option<
2508 unsafe extern "C" fn(
2509 self_: SLEngineItf,
2510 objectID: SLuint32,
2511 index: SLuint32,
2512 pInterfaceId: *mut SLInterfaceID,
2513 ) -> SLresult,
2514 >,
2515 pub QueryNumSupportedExtensions: ::std::option::Option<
2516 unsafe extern "C" fn(self_: SLEngineItf, pNumExtensions: *mut SLuint32) -> SLresult,
2517 >,
2518 pub QuerySupportedExtension: ::std::option::Option<
2519 unsafe extern "C" fn(
2520 self_: SLEngineItf,
2521 index: SLuint32,
2522 pExtensionName: *mut SLchar,
2523 pNameLength: *mut SLuint16,
2524 ) -> SLresult,
2525 >,
2526 pub IsExtensionSupported: ::std::option::Option<
2527 unsafe extern "C" fn(
2528 self_: SLEngineItf,
2529 pExtensionName: *const SLchar,
2530 pSupported: *mut SLboolean,
2531 ) -> SLresult,
2532 >,
2533}
2534extern "C" {
2535 pub static SL_IID_ENGINECAPABILITIES: SLInterfaceID;
2536}
2537pub type SLEngineCapabilitiesItf = *const *const SLEngineCapabilitiesItf_;
2538#[repr(C)]
2539#[derive(Debug, Copy, Clone)]
2540pub struct SLEngineCapabilitiesItf_ {
2541 pub QuerySupportedProfiles: ::std::option::Option<
2542 unsafe extern "C" fn(
2543 self_: SLEngineCapabilitiesItf,
2544 pProfilesSupported: *mut SLuint16,
2545 ) -> SLresult,
2546 >,
2547 pub QueryAvailableVoices: ::std::option::Option<
2548 unsafe extern "C" fn(
2549 self_: SLEngineCapabilitiesItf,
2550 voiceType: SLuint16,
2551 pNumMaxVoices: *mut SLuint16,
2552 pIsAbsoluteMax: *mut SLboolean,
2553 pNumFreeVoices: *mut SLuint16,
2554 ) -> SLresult,
2555 >,
2556 pub QueryNumberOfMIDISynthesizers: ::std::option::Option<
2557 unsafe extern "C" fn(
2558 self_: SLEngineCapabilitiesItf,
2559 pNumMIDIsynthesizers: *mut SLuint16,
2560 ) -> SLresult,
2561 >,
2562 pub QueryAPIVersion: ::std::option::Option<
2563 unsafe extern "C" fn(
2564 self_: SLEngineCapabilitiesItf,
2565 pMajor: *mut SLuint16,
2566 pMinor: *mut SLuint16,
2567 pStep: *mut SLuint16,
2568 ) -> SLresult,
2569 >,
2570 pub QueryLEDCapabilities: ::std::option::Option<
2571 unsafe extern "C" fn(
2572 self_: SLEngineCapabilitiesItf,
2573 pIndex: *mut SLuint32,
2574 pLEDDeviceID: *mut SLuint32,
2575 pDescriptor: *mut SLLEDDescriptor,
2576 ) -> SLresult,
2577 >,
2578 pub QueryVibraCapabilities: ::std::option::Option<
2579 unsafe extern "C" fn(
2580 self_: SLEngineCapabilitiesItf,
2581 pIndex: *mut SLuint32,
2582 pVibraDeviceID: *mut SLuint32,
2583 pDescriptor: *mut SLVibraDescriptor,
2584 ) -> SLresult,
2585 >,
2586 pub IsThreadSafe: ::std::option::Option<
2587 unsafe extern "C" fn(
2588 self_: SLEngineCapabilitiesItf,
2589 pIsThreadSafe: *mut SLboolean,
2590 ) -> SLresult,
2591 >,
2592}
2593extern "C" {
2594 pub static SL_IID_THREADSYNC: SLInterfaceID;
2595}
2596pub type SLThreadSyncItf = *const *const SLThreadSyncItf_;
2597#[repr(C)]
2598#[derive(Debug, Copy, Clone)]
2599pub struct SLThreadSyncItf_ {
2600 pub EnterCriticalSection:
2601 ::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
2602 pub ExitCriticalSection:
2603 ::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
2604}
2605#[repr(C)]
2606pub struct SLEngineOption_ {
2607 pub feature: SLuint32,
2608 pub data: SLuint32,
2609}
2610pub type SLEngineOption = SLEngineOption_;
2611extern "C" {
2612 pub fn slCreateEngine(
2613 pEngine: *mut SLObjectItf,
2614 numOptions: SLuint32,
2615 pEngineOptions: *const SLEngineOption,
2616 numInterfaces: SLuint32,
2617 pInterfaceIds: *const SLInterfaceID,
2618 pInterfaceRequired: *const SLboolean,
2619 ) -> SLresult;
2620}
2621extern "C" {
2622 pub fn slQueryNumSupportedEngineInterfaces(pNumSupportedInterfaces: *mut SLuint32) -> SLresult;
2623}
2624extern "C" {
2625 pub fn slQuerySupportedEngineInterfaces(
2626 index: SLuint32,
2627 pInterfaceId: *mut SLInterfaceID,
2628 ) -> SLresult;
2629}
2630#[repr(C)]
2631pub struct SLAndroidDataFormat_PCM_EX_ {
2632 pub formatType: SLuint32,
2633 pub numChannels: SLuint32,
2634 pub sampleRate: SLuint32,
2635 pub bitsPerSample: SLuint32,
2636 pub containerSize: SLuint32,
2637 pub channelMask: SLuint32,
2638 pub endianness: SLuint32,
2639 pub representation: SLuint32,
2640}
2641pub type SLAndroidDataFormat_PCM_EX = SLAndroidDataFormat_PCM_EX_;
2642extern "C" {
2643 pub static SL_IID_ANDROIDEFFECT: SLInterfaceID;
2644}
2645pub type SLAndroidEffectItf = *const *const SLAndroidEffectItf_;
2646#[doc = " Android Effect interface methods"]
2647#[repr(C)]
2648#[derive(Debug, Copy, Clone)]
2649pub struct SLAndroidEffectItf_ {
2650 pub CreateEffect: ::std::option::Option<
2651 unsafe extern "C" fn(
2652 self_: SLAndroidEffectItf,
2653 effectImplementationId: SLInterfaceID,
2654 ) -> SLresult,
2655 >,
2656 pub ReleaseEffect: ::std::option::Option<
2657 unsafe extern "C" fn(
2658 self_: SLAndroidEffectItf,
2659 effectImplementationId: SLInterfaceID,
2660 ) -> SLresult,
2661 >,
2662 pub SetEnabled: ::std::option::Option<
2663 unsafe extern "C" fn(
2664 self_: SLAndroidEffectItf,
2665 effectImplementationId: SLInterfaceID,
2666 enabled: SLboolean,
2667 ) -> SLresult,
2668 >,
2669 pub IsEnabled: ::std::option::Option<
2670 unsafe extern "C" fn(
2671 self_: SLAndroidEffectItf,
2672 effectImplementationId: SLInterfaceID,
2673 pEnabled: *mut SLboolean,
2674 ) -> SLresult,
2675 >,
2676 pub SendCommand: ::std::option::Option<
2677 unsafe extern "C" fn(
2678 self_: SLAndroidEffectItf,
2679 effectImplementationId: SLInterfaceID,
2680 command: SLuint32,
2681 commandSize: SLuint32,
2682 pCommandData: *mut ::std::os::raw::c_void,
2683 replySize: *mut SLuint32,
2684 pReplyData: *mut ::std::os::raw::c_void,
2685 ) -> SLresult,
2686 >,
2687}
2688extern "C" {
2689 pub static SL_IID_ANDROIDEFFECTSEND: SLInterfaceID;
2690}
2691pub type SLAndroidEffectSendItf = *const *const SLAndroidEffectSendItf_;
2692#[doc = " Android Effect Send interface methods"]
2693#[repr(C)]
2694#[derive(Debug, Copy, Clone)]
2695pub struct SLAndroidEffectSendItf_ {
2696 pub EnableEffectSend: ::std::option::Option<
2697 unsafe extern "C" fn(
2698 self_: SLAndroidEffectSendItf,
2699 effectImplementationId: SLInterfaceID,
2700 enable: SLboolean,
2701 initialLevel: SLmillibel,
2702 ) -> SLresult,
2703 >,
2704 pub IsEnabled: ::std::option::Option<
2705 unsafe extern "C" fn(
2706 self_: SLAndroidEffectSendItf,
2707 effectImplementationId: SLInterfaceID,
2708 pEnable: *mut SLboolean,
2709 ) -> SLresult,
2710 >,
2711 pub SetDirectLevel: ::std::option::Option<
2712 unsafe extern "C" fn(self_: SLAndroidEffectSendItf, directLevel: SLmillibel) -> SLresult,
2713 >,
2714 pub GetDirectLevel: ::std::option::Option<
2715 unsafe extern "C" fn(
2716 self_: SLAndroidEffectSendItf,
2717 pDirectLevel: *mut SLmillibel,
2718 ) -> SLresult,
2719 >,
2720 pub SetSendLevel: ::std::option::Option<
2721 unsafe extern "C" fn(
2722 self_: SLAndroidEffectSendItf,
2723 effectImplementationId: SLInterfaceID,
2724 sendLevel: SLmillibel,
2725 ) -> SLresult,
2726 >,
2727 pub GetSendLevel: ::std::option::Option<
2728 unsafe extern "C" fn(
2729 self_: SLAndroidEffectSendItf,
2730 effectImplementationId: SLInterfaceID,
2731 pSendLevel: *mut SLmillibel,
2732 ) -> SLresult,
2733 >,
2734}
2735extern "C" {
2736 pub static SL_IID_ANDROIDEFFECTCAPABILITIES: SLInterfaceID;
2737}
2738pub type SLAndroidEffectCapabilitiesItf = *const *const SLAndroidEffectCapabilitiesItf_;
2739#[doc = " Android Effect Capabilities interface methods"]
2740#[repr(C)]
2741#[derive(Debug, Copy, Clone)]
2742pub struct SLAndroidEffectCapabilitiesItf_ {
2743 pub QueryNumEffects: ::std::option::Option<
2744 unsafe extern "C" fn(
2745 self_: SLAndroidEffectCapabilitiesItf,
2746 pNumSupportedEffects: *mut SLuint32,
2747 ) -> SLresult,
2748 >,
2749 pub QueryEffect: ::std::option::Option<
2750 unsafe extern "C" fn(
2751 self_: SLAndroidEffectCapabilitiesItf,
2752 index: SLuint32,
2753 pEffectType: *mut SLInterfaceID,
2754 pEffectImplementation: *mut SLInterfaceID,
2755 pName: *mut SLchar,
2756 pNameSize: *mut SLuint16,
2757 ) -> SLresult,
2758 >,
2759}
2760extern "C" {
2761 pub static SL_IID_ANDROIDCONFIGURATION: SLInterfaceID;
2762}
2763#[doc = " Android Configuration interface methods"]
2764#[repr(C)]
2765#[derive(Debug, Copy, Clone)]
2766pub struct SLAndroidConfigurationItf_ {
2767 _unused: [u8; 0],
2768}
2769pub type SLAndroidConfigurationItf = *const *const SLAndroidConfigurationItf_;
2770extern "C" {
2771 pub static SL_IID_ANDROIDSIMPLEBUFFERQUEUE: SLInterfaceID;
2772}
2773pub type SLAndroidSimpleBufferQueueItf = *const *const SLAndroidSimpleBufferQueueItf_;
2774pub type slAndroidSimpleBufferQueueCallback = ::std::option::Option<
2775 unsafe extern "C" fn(
2776 caller: SLAndroidSimpleBufferQueueItf,
2777 pContext: *mut ::std::os::raw::c_void,
2778 ),
2779>;
2780#[doc = " Android simple buffer queue state"]
2781#[repr(C)]
2782pub struct SLAndroidSimpleBufferQueueState_ {
2783 pub count: SLuint32,
2784 pub index: SLuint32,
2785}
2786pub type SLAndroidSimpleBufferQueueState = SLAndroidSimpleBufferQueueState_;
2787#[repr(C)]
2788#[derive(Debug, Copy, Clone)]
2789pub struct SLAndroidSimpleBufferQueueItf_ {
2790 pub Enqueue: ::std::option::Option<
2791 unsafe extern "C" fn(
2792 self_: SLAndroidSimpleBufferQueueItf,
2793 pBuffer: *const ::std::os::raw::c_void,
2794 size: SLuint32,
2795 ) -> SLresult,
2796 >,
2797 pub Clear: ::std::option::Option<
2798 unsafe extern "C" fn(self_: SLAndroidSimpleBufferQueueItf) -> SLresult,
2799 >,
2800 pub GetState: ::std::option::Option<
2801 unsafe extern "C" fn(
2802 self_: SLAndroidSimpleBufferQueueItf,
2803 pState: *mut SLAndroidSimpleBufferQueueState,
2804 ) -> SLresult,
2805 >,
2806 pub RegisterCallback: ::std::option::Option<
2807 unsafe extern "C" fn(
2808 self_: SLAndroidSimpleBufferQueueItf,
2809 callback: slAndroidSimpleBufferQueueCallback,
2810 pContext: *mut ::std::os::raw::c_void,
2811 ) -> SLresult,
2812 >,
2813}
2814extern "C" {
2815 pub static SL_IID_ANDROIDBUFFERQUEUESOURCE: SLInterfaceID;
2816}
2817pub type SLAndroidBufferQueueItf = *const *const SLAndroidBufferQueueItf_;
2818#[repr(C)]
2819pub struct SLAndroidBufferItem_ {
2820 pub itemKey: SLuint32,
2821 pub itemSize: SLuint32,
2822 pub itemData: __IncompleteArrayField<SLuint8>,
2823}
2824pub type SLAndroidBufferItem = SLAndroidBufferItem_;
2825pub type slAndroidBufferQueueCallback = ::std::option::Option<
2826 unsafe extern "C" fn(
2827 caller: SLAndroidBufferQueueItf,
2828 pCallbackContext: *mut ::std::os::raw::c_void,
2829 pBufferContext: *mut ::std::os::raw::c_void,
2830 pBufferData: *mut ::std::os::raw::c_void,
2831 dataSize: SLuint32,
2832 dataUsed: SLuint32,
2833 pItems: *const SLAndroidBufferItem,
2834 itemsLength: SLuint32,
2835 ) -> SLresult,
2836>;
2837#[repr(C)]
2838pub struct SLAndroidBufferQueueState_ {
2839 pub count: SLuint32,
2840 pub index: SLuint32,
2841}
2842pub type SLAndroidBufferQueueState = SLAndroidBufferQueueState_;
2843#[repr(C)]
2844#[derive(Debug, Copy, Clone)]
2845pub struct SLAndroidBufferQueueItf_ {
2846 pub RegisterCallback: ::std::option::Option<
2847 unsafe extern "C" fn(
2848 self_: SLAndroidBufferQueueItf,
2849 callback: slAndroidBufferQueueCallback,
2850 pCallbackContext: *mut ::std::os::raw::c_void,
2851 ) -> SLresult,
2852 >,
2853 pub Clear:
2854 ::std::option::Option<unsafe extern "C" fn(self_: SLAndroidBufferQueueItf) -> SLresult>,
2855 pub Enqueue: ::std::option::Option<
2856 unsafe extern "C" fn(
2857 self_: SLAndroidBufferQueueItf,
2858 pBufferContext: *mut ::std::os::raw::c_void,
2859 pData: *mut ::std::os::raw::c_void,
2860 dataLength: SLuint32,
2861 pItems: *const SLAndroidBufferItem,
2862 itemsLength: SLuint32,
2863 ) -> SLresult,
2864 >,
2865 pub GetState: ::std::option::Option<
2866 unsafe extern "C" fn(
2867 self_: SLAndroidBufferQueueItf,
2868 pState: *mut SLAndroidBufferQueueState,
2869 ) -> SLresult,
2870 >,
2871 pub SetCallbackEventsMask: ::std::option::Option<
2872 unsafe extern "C" fn(self_: SLAndroidBufferQueueItf, eventFlags: SLuint32) -> SLresult,
2873 >,
2874 pub GetCallbackEventsMask: ::std::option::Option<
2875 unsafe extern "C" fn(
2876 self_: SLAndroidBufferQueueItf,
2877 pEventFlags: *mut SLuint32,
2878 ) -> SLresult,
2879 >,
2880}
2881#[doc = " BufferQueue-based data locator definition where locatorType must"]
2882#[doc = " be SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE"]
2883#[repr(C)]
2884pub struct SLDataLocator_AndroidSimpleBufferQueue {
2885 pub locatorType: SLuint32,
2886 pub numBuffers: SLuint32,
2887}
2888#[doc = " Android Buffer Queue-based data locator definition,"]
2889#[doc = " locatorType must be SL_DATALOCATOR_ANDROIDBUFFERQUEUE"]
2890#[repr(C)]
2891pub struct SLDataLocator_AndroidBufferQueue_ {
2892 pub locatorType: SLuint32,
2893 pub numBuffers: SLuint32,
2894}
2895pub type SLDataLocator_AndroidBufferQueue = SLDataLocator_AndroidBufferQueue_;
2896extern "C" {
2897 pub static SL_IID_ANDROIDACOUSTICECHOCANCELLATION: SLInterfaceID;
2898}
2899pub type SLAndroidAcousticEchoCancellationItf = *const *const SLAndroidAcousticEchoCancellationItf_;
2900#[repr(C)]
2901#[derive(Debug, Copy, Clone)]
2902pub struct SLAndroidAcousticEchoCancellationItf_ {
2903 pub SetEnabled: ::std::option::Option<
2904 unsafe extern "C" fn(
2905 self_: SLAndroidAcousticEchoCancellationItf,
2906 enabled: SLboolean,
2907 ) -> SLresult,
2908 >,
2909 pub IsEnabled: ::std::option::Option<
2910 unsafe extern "C" fn(
2911 self_: SLAndroidAcousticEchoCancellationItf,
2912 pEnabled: *mut SLboolean,
2913 ) -> SLresult,
2914 >,
2915}
2916extern "C" {
2917 pub static SL_IID_ANDROIDAUTOMATICGAINCONTROL: SLInterfaceID;
2918}
2919pub type SLAndroidAutomaticGainControlItf = *const *const SLAndroidAutomaticGainControlItf_;
2920#[repr(C)]
2921#[derive(Debug, Copy, Clone)]
2922pub struct SLAndroidAutomaticGainControlItf_ {
2923 pub SetEnabled: ::std::option::Option<
2924 unsafe extern "C" fn(
2925 self_: SLAndroidAutomaticGainControlItf,
2926 enabled: SLboolean,
2927 ) -> SLresult,
2928 >,
2929 pub IsEnabled: ::std::option::Option<
2930 unsafe extern "C" fn(
2931 self_: SLAndroidAutomaticGainControlItf,
2932 pEnabled: *mut SLboolean,
2933 ) -> SLresult,
2934 >,
2935}
2936extern "C" {
2937 pub static SL_IID_ANDROIDNOISESUPPRESSION: SLInterfaceID;
2938}
2939pub type SLAndroidNoiseSuppressionItf = *const *const SLAndroidNoiseSuppressionItf_;
2940#[repr(C)]
2941#[derive(Debug, Copy, Clone)]
2942pub struct SLAndroidNoiseSuppressionItf_ {
2943 pub SetEnabled: ::std::option::Option<
2944 unsafe extern "C" fn(self_: SLAndroidNoiseSuppressionItf, enabled: SLboolean) -> SLresult,
2945 >,
2946 pub IsEnabled: ::std::option::Option<
2947 unsafe extern "C" fn(
2948 self_: SLAndroidNoiseSuppressionItf,
2949 pEnabled: *mut SLboolean,
2950 ) -> SLresult,
2951 >,
2952}