1#[repr(C)]
4#[derive(Default)]
5pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>);
6impl<T> __IncompleteArrayField<T> {
7 #[inline]
8 pub fn new() -> Self {
9 __IncompleteArrayField(::std::marker::PhantomData)
10 }
11 #[inline]
12 pub unsafe fn as_ptr(&self) -> *const T {
13 ::std::mem::transmute(self)
14 }
15 #[inline]
16 pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
17 ::std::mem::transmute(self)
18 }
19 #[inline]
20 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21 ::std::slice::from_raw_parts(self.as_ptr(), len)
22 }
23 #[inline]
24 pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
25 ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
26 }
27}
28impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
29 fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
30 fmt.write_str("__IncompleteArrayField")
31 }
32}
33impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
34 #[inline]
35 fn clone(&self) -> Self {
36 Self::new()
37 }
38}
39impl<T> ::std::marker::Copy for __IncompleteArrayField<T> {}
40pub const KHRONOS_TITLE: &'static [u8; 13usize] = b"KhronosTitle\0";
41pub const KHRONOS_ALBUM: &'static [u8; 13usize] = b"KhronosAlbum\0";
42pub const KHRONOS_TRACK_NUMBER: &'static [u8; 19usize] = b"KhronosTrackNumber\0";
43pub const KHRONOS_ARTIST: &'static [u8; 14usize] = b"KhronosArtist\0";
44pub const KHRONOS_GENRE: &'static [u8; 13usize] = b"KhronosGenre\0";
45pub const KHRONOS_YEAR: &'static [u8; 12usize] = b"KhronosYear\0";
46pub const KHRONOS_COMMENT: &'static [u8; 15usize] = b"KhronosComment\0";
47pub const KHRONOS_ARTIST_URL: &'static [u8; 17usize] = b"KhronosArtistURL\0";
48pub const KHRONOS_CONTENT_URL: &'static [u8; 18usize] = b"KhronosContentURL\0";
49pub const KHRONOS_RATING: &'static [u8; 14usize] = b"KhronosRating\0";
50pub const KHRONOS_ALBUM_ART: &'static [u8; 16usize] = b"KhronosAlbumArt\0";
51pub const KHRONOS_COPYRIGHT: &'static [u8; 17usize] = b"KhronosCopyright\0";
52pub const SL_NODE_PARENT: u32 = 4294967295;
53pub const ANDROID_KEY_PCMFORMAT_NUMCHANNELS: &'static [u8; 28usize] =
54 b"AndroidPcmFormatNumChannels\0";
55pub const ANDROID_KEY_PCMFORMAT_SAMPLERATE: &'static [u8; 27usize] =
56 b"AndroidPcmFormatSampleRate\0";
57pub const ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE: &'static [u8; 30usize] =
58 b"AndroidPcmFormatBitsPerSample\0";
59pub const ANDROID_KEY_PCMFORMAT_CONTAINERSIZE: &'static [u8; 30usize] =
60 b"AndroidPcmFormatContainerSize\0";
61pub const ANDROID_KEY_PCMFORMAT_CHANNELMASK: &'static [u8; 28usize] =
62 b"AndroidPcmFormatChannelMask\0";
63pub const ANDROID_KEY_PCMFORMAT_ENDIANNESS: &'static [u8; 27usize] =
64 b"AndroidPcmFormatEndianness\0";
65pub const __GNUC_VA_LIST: u32 = 1;
66pub const _STDINT_H: u32 = 1;
67pub const _FEATURES_H: u32 = 1;
68pub const _DEFAULT_SOURCE: u32 = 1;
69pub const __USE_ISOC11: u32 = 1;
70pub const __USE_ISOC99: u32 = 1;
71pub const __USE_ISOC95: u32 = 1;
72pub const __USE_POSIX_IMPLICITLY: u32 = 1;
73pub const _POSIX_SOURCE: u32 = 1;
74pub const _POSIX_C_SOURCE: u32 = 200809;
75pub const __USE_POSIX: u32 = 1;
76pub const __USE_POSIX2: u32 = 1;
77pub const __USE_POSIX199309: u32 = 1;
78pub const __USE_POSIX199506: u32 = 1;
79pub const __USE_XOPEN2K: u32 = 1;
80pub const __USE_XOPEN2K8: u32 = 1;
81pub const _ATFILE_SOURCE: u32 = 1;
82pub const __USE_MISC: u32 = 1;
83pub const __USE_ATFILE: u32 = 1;
84pub const __USE_FORTIFY_LEVEL: u32 = 0;
85pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
86pub const _STDC_PREDEF_H: u32 = 1;
87pub const __STDC_IEC_559__: u32 = 1;
88pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
89pub const __STDC_ISO_10646__: u32 = 201706;
90pub const __GNU_LIBRARY__: u32 = 6;
91pub const __GLIBC__: u32 = 2;
92pub const __GLIBC_MINOR__: u32 = 28;
93pub const _SYS_CDEFS_H: u32 = 1;
94pub const __glibc_c99_flexarr_available: u32 = 1;
95pub const __WORDSIZE: u32 = 32;
96pub const __WORDSIZE32_SIZE_ULONG: u32 = 0;
97pub const __WORDSIZE32_PTRDIFF_LONG: u32 = 0;
98pub const __WORDSIZE_TIME64_COMPAT32: u32 = 0;
99pub const __HAVE_GENERIC_SELECTION: u32 = 1;
100pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
101pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
102pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
103pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
104pub const _BITS_TYPES_H: u32 = 1;
105pub const _BITS_TYPESIZES_H: u32 = 1;
106pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 0;
107pub const __FD_SETSIZE: u32 = 1024;
108pub const _BITS_WCHAR_H: u32 = 1;
109pub const _BITS_STDINT_INTN_H: u32 = 1;
110pub const _BITS_STDINT_UINTN_H: u32 = 1;
111pub const INT8_MIN: i32 = -128;
112pub const INT16_MIN: i32 = -32768;
113pub const INT32_MIN: i32 = -2147483648;
114pub const INT8_MAX: u32 = 127;
115pub const INT16_MAX: u32 = 32767;
116pub const INT32_MAX: u32 = 2147483647;
117pub const UINT8_MAX: u32 = 255;
118pub const UINT16_MAX: u32 = 65535;
119pub const UINT32_MAX: u32 = 4294967295;
120pub const INT_LEAST8_MIN: i32 = -128;
121pub const INT_LEAST16_MIN: i32 = -32768;
122pub const INT_LEAST32_MIN: i32 = -2147483648;
123pub const INT_LEAST8_MAX: u32 = 127;
124pub const INT_LEAST16_MAX: u32 = 32767;
125pub const INT_LEAST32_MAX: u32 = 2147483647;
126pub const UINT_LEAST8_MAX: u32 = 255;
127pub const UINT_LEAST16_MAX: u32 = 65535;
128pub const UINT_LEAST32_MAX: u32 = 4294967295;
129pub const INT_FAST8_MIN: i32 = -128;
130pub const INT_FAST16_MIN: i32 = -2147483648;
131pub const INT_FAST32_MIN: i32 = -2147483648;
132pub const INT_FAST8_MAX: u32 = 127;
133pub const INT_FAST16_MAX: u32 = 2147483647;
134pub const INT_FAST32_MAX: u32 = 2147483647;
135pub const UINT_FAST8_MAX: u32 = 255;
136pub const UINT_FAST16_MAX: u32 = 4294967295;
137pub const UINT_FAST32_MAX: u32 = 4294967295;
138pub const INTPTR_MIN: i32 = -2147483648;
139pub const INTPTR_MAX: u32 = 2147483647;
140pub const UINTPTR_MAX: u32 = 4294967295;
141pub const PTRDIFF_MIN: i32 = -2147483648;
142pub const PTRDIFF_MAX: u32 = 2147483647;
143pub const SIG_ATOMIC_MIN: i32 = -2147483648;
144pub const SIG_ATOMIC_MAX: u32 = 2147483647;
145pub const SIZE_MAX: u32 = 4294967295;
146pub const WINT_MIN: u32 = 0;
147pub const WINT_MAX: u32 = 4294967295;
148pub const JNI_FALSE: u32 = 0;
149pub const JNI_TRUE: u32 = 1;
150pub const JNI_VERSION_1_1: u32 = 65537;
151pub const JNI_VERSION_1_2: u32 = 65538;
152pub const JNI_VERSION_1_4: u32 = 65540;
153pub const JNI_VERSION_1_6: u32 = 65542;
154pub const JNI_OK: u32 = 0;
155pub const JNI_ERR: i32 = -1;
156pub const JNI_EDETACHED: i32 = -2;
157pub const JNI_EVERSION: i32 = -3;
158pub const JNI_COMMIT: u32 = 1;
159pub const JNI_ABORT: u32 = 2;
160pub const SL_ANDROID_JAVA_PROXY_ROUTING: u32 = 1;
161pub type sl_uint8_t = ::std::os::raw::c_uchar;
162pub type sl_int8_t = ::std::os::raw::c_schar;
163pub type sl_uint16_t = ::std::os::raw::c_ushort;
164pub type sl_int16_t = ::std::os::raw::c_short;
165pub type sl_uint32_t = ::std::os::raw::c_uint;
166pub type sl_int32_t = ::std::os::raw::c_int;
167pub type sl_int64_t = ::std::os::raw::c_longlong;
168pub type sl_uint64_t = ::std::os::raw::c_ulonglong;
169pub type SLint8 = sl_int8_t;
170pub type SLuint8 = sl_uint8_t;
171pub type SLint16 = sl_int16_t;
172pub type SLuint16 = sl_uint16_t;
173pub type SLint32 = sl_int32_t;
174pub type SLuint32 = sl_uint32_t;
175pub type SLboolean = SLuint32;
176pub type SLchar = SLuint8;
177pub type SLmillibel = SLint16;
178pub type SLmillisecond = SLuint32;
179pub type SLmilliHertz = SLuint32;
180pub type SLmillimeter = SLint32;
181pub type SLmillidegree = SLint32;
182pub type SLpermille = SLint16;
183pub type SLmicrosecond = SLuint32;
184pub type SLresult = SLuint32;
185#[repr(C)]
187#[derive(Debug, Copy, Clone)]
188pub struct SLInterfaceID_ {
189 pub time_low: SLuint32,
190 pub time_mid: SLuint16,
191 pub time_hi_and_version: SLuint16,
192 pub clock_seq: SLuint16,
193 pub node: [SLuint8; 6usize],
194}
195pub type SLInterfaceID = *const SLInterfaceID_;
196pub type SLObjectItf = *const *const SLObjectItf_;
197extern "C" {
198 pub static mut SL_IID_NULL: SLInterfaceID;
199}
200#[repr(C)]
202#[derive(Debug, Copy, Clone)]
203pub struct SLDataLocator_URI_ {
204 pub locatorType: SLuint32,
205 pub URI: *mut SLchar,
206}
207pub type SLDataLocator_URI = SLDataLocator_URI_;
208#[repr(C)]
210#[derive(Debug, Copy, Clone)]
211pub struct SLDataLocator_Address_ {
212 pub locatorType: SLuint32,
213 pub pAddress: *mut ::std::os::raw::c_void,
214 pub length: SLuint32,
215}
216pub type SLDataLocator_Address = SLDataLocator_Address_;
217#[repr(C)]
219#[derive(Debug, Copy, Clone)]
220pub struct SLDataLocator_IODevice_ {
221 pub locatorType: SLuint32,
222 pub deviceType: SLuint32,
223 pub deviceID: SLuint32,
224 pub device: SLObjectItf,
225}
226pub type SLDataLocator_IODevice = SLDataLocator_IODevice_;
227#[repr(C)]
229#[derive(Debug, Copy, Clone)]
230pub struct SLDataLocator_OutputMix {
231 pub locatorType: SLuint32,
232 pub outputMix: SLObjectItf,
233}
234#[repr(C)]
236#[derive(Debug, Copy, Clone)]
237pub struct SLDataLocator_BufferQueue {
238 pub locatorType: SLuint32,
239 pub numBuffers: SLuint32,
240}
241#[repr(C)]
243#[derive(Debug, Copy, Clone)]
244pub struct SLDataLocator_MIDIBufferQueue {
245 pub locatorType: SLuint32,
246 pub tpqn: SLuint32,
247 pub numBuffers: SLuint32,
248}
249#[repr(C)]
251#[derive(Debug, Copy, Clone)]
252pub struct SLDataFormat_MIME_ {
253 pub formatType: SLuint32,
254 pub mimeType: *mut SLchar,
255 pub containerType: SLuint32,
256}
257pub type SLDataFormat_MIME = SLDataFormat_MIME_;
258#[repr(C)]
260#[derive(Debug, Copy, Clone)]
261pub struct SLDataFormat_PCM_ {
262 pub formatType: SLuint32,
263 pub numChannels: SLuint32,
264 pub samplesPerSec: SLuint32,
265 pub bitsPerSample: SLuint32,
266 pub containerSize: SLuint32,
267 pub channelMask: SLuint32,
268 pub endianness: SLuint32,
269}
270pub type SLDataFormat_PCM = SLDataFormat_PCM_;
271#[repr(C)]
272#[derive(Debug, Copy, Clone)]
273pub struct SLDataSource_ {
274 pub pLocator: *mut ::std::os::raw::c_void,
275 pub pFormat: *mut ::std::os::raw::c_void,
276}
277pub type SLDataSource = SLDataSource_;
278#[repr(C)]
279#[derive(Debug, Copy, Clone)]
280pub struct SLDataSink_ {
281 pub pLocator: *mut ::std::os::raw::c_void,
282 pub pFormat: *mut ::std::os::raw::c_void,
283}
284pub type SLDataSink = SLDataSink_;
285extern "C" {
286 pub static mut SL_IID_OBJECT: SLInterfaceID;
287}
288pub type slObjectCallback = ::std::option::Option<
290 unsafe extern "C" fn(
291 caller: SLObjectItf,
292 pContext: *const ::std::os::raw::c_void,
293 event: SLuint32,
294 result: SLresult,
295 param: SLuint32,
296 pInterface: *mut ::std::os::raw::c_void,
297 ),
298>;
299#[repr(C)]
300#[derive(Debug, Copy, Clone)]
301pub struct SLObjectItf_ {
302 pub Realize: ::std::option::Option<
303 unsafe extern "C" fn(self_: SLObjectItf, async: SLboolean) -> SLresult,
304 >,
305 pub Resume: ::std::option::Option<
306 unsafe extern "C" fn(self_: SLObjectItf, async: SLboolean) -> SLresult,
307 >,
308 pub GetState: ::std::option::Option<
309 unsafe extern "C" fn(self_: SLObjectItf, pState: *mut SLuint32) -> SLresult,
310 >,
311 pub GetInterface: ::std::option::Option<
312 unsafe extern "C" fn(
313 self_: SLObjectItf,
314 iid: SLInterfaceID,
315 pInterface: *mut ::std::os::raw::c_void,
316 ) -> SLresult,
317 >,
318 pub RegisterCallback: ::std::option::Option<
319 unsafe extern "C" fn(
320 self_: SLObjectItf,
321 callback: slObjectCallback,
322 pContext: *mut ::std::os::raw::c_void,
323 ) -> SLresult,
324 >,
325 pub AbortAsyncOperation: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
326 pub Destroy: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
327 pub SetPriority: ::std::option::Option<
328 unsafe extern "C" fn(self_: SLObjectItf, priority: SLint32, preemptable: SLboolean)
329 -> SLresult,
330 >,
331 pub GetPriority: ::std::option::Option<
332 unsafe extern "C" fn(
333 self_: SLObjectItf,
334 pPriority: *mut SLint32,
335 pPreemptable: *mut SLboolean,
336 ) -> SLresult,
337 >,
338 pub SetLossOfControlInterfaces: ::std::option::Option<
339 unsafe extern "C" fn(
340 self_: SLObjectItf,
341 numInterfaces: SLint16,
342 pInterfaceIDs: *mut SLInterfaceID,
343 enabled: SLboolean,
344 ) -> SLresult,
345 >,
346}
347#[repr(C)]
348#[derive(Debug, Copy, Clone)]
349pub struct SLAudioInputDescriptor_ {
350 pub deviceName: *mut SLchar,
351 pub deviceConnection: SLint16,
352 pub deviceScope: SLint16,
353 pub deviceLocation: SLint16,
354 pub isForTelephony: SLboolean,
355 pub minSampleRate: SLmilliHertz,
356 pub maxSampleRate: SLmilliHertz,
357 pub isFreqRangeContinuous: SLboolean,
358 pub samplingRatesSupported: *mut SLmilliHertz,
359 pub numOfSamplingRatesSupported: SLint16,
360 pub maxChannels: SLint16,
361}
362pub type SLAudioInputDescriptor = SLAudioInputDescriptor_;
363#[repr(C)]
364#[derive(Debug, Copy, Clone)]
365pub struct SLAudioOutputDescriptor_ {
366 pub pDeviceName: *mut SLchar,
367 pub deviceConnection: SLint16,
368 pub deviceScope: SLint16,
369 pub deviceLocation: SLint16,
370 pub isForTelephony: SLboolean,
371 pub minSampleRate: SLmilliHertz,
372 pub maxSampleRate: SLmilliHertz,
373 pub isFreqRangeContinuous: SLboolean,
374 pub samplingRatesSupported: *mut SLmilliHertz,
375 pub numOfSamplingRatesSupported: SLint16,
376 pub maxChannels: SLint16,
377}
378pub type SLAudioOutputDescriptor = SLAudioOutputDescriptor_;
379extern "C" {
380 pub static mut SL_IID_AUDIOIODEVICECAPABILITIES: SLInterfaceID;
381}
382pub type SLAudioIODeviceCapabilitiesItf = *const *const SLAudioIODeviceCapabilitiesItf_;
383pub type slAvailableAudioInputsChangedCallback = ::std::option::Option<
384 unsafe extern "C" fn(
385 caller: SLAudioIODeviceCapabilitiesItf,
386 pContext: *mut ::std::os::raw::c_void,
387 deviceID: SLuint32,
388 numInputs: SLint32,
389 isNew: SLboolean,
390 ),
391>;
392pub type slAvailableAudioOutputsChangedCallback = ::std::option::Option<
393 unsafe extern "C" fn(
394 caller: SLAudioIODeviceCapabilitiesItf,
395 pContext: *mut ::std::os::raw::c_void,
396 deviceID: SLuint32,
397 numOutputs: SLint32,
398 isNew: SLboolean,
399 ),
400>;
401pub type slDefaultDeviceIDMapChangedCallback = ::std::option::Option<
402 unsafe extern "C" fn(
403 caller: SLAudioIODeviceCapabilitiesItf,
404 pContext: *mut ::std::os::raw::c_void,
405 isOutput: SLboolean,
406 numDevices: SLint32,
407 ),
408>;
409#[repr(C)]
410#[derive(Debug, Copy, Clone)]
411pub struct SLAudioIODeviceCapabilitiesItf_ {
412 pub GetAvailableAudioInputs: ::std::option::Option<
413 unsafe extern "C" fn(
414 self_: SLAudioIODeviceCapabilitiesItf,
415 pNumInputs: *mut SLint32,
416 pInputDeviceIDs: *mut SLuint32,
417 ) -> SLresult,
418 >,
419 pub QueryAudioInputCapabilities: ::std::option::Option<
420 unsafe extern "C" fn(
421 self_: SLAudioIODeviceCapabilitiesItf,
422 deviceId: SLuint32,
423 pDescriptor: *mut SLAudioInputDescriptor,
424 ) -> SLresult,
425 >,
426 pub RegisterAvailableAudioInputsChangedCallback: ::std::option::Option<
427 unsafe extern "C" fn(
428 self_: SLAudioIODeviceCapabilitiesItf,
429 callback: slAvailableAudioInputsChangedCallback,
430 pContext: *mut ::std::os::raw::c_void,
431 ) -> SLresult,
432 >,
433 pub GetAvailableAudioOutputs: ::std::option::Option<
434 unsafe extern "C" fn(
435 self_: SLAudioIODeviceCapabilitiesItf,
436 pNumOutputs: *mut SLint32,
437 pOutputDeviceIDs: *mut SLuint32,
438 ) -> SLresult,
439 >,
440 pub QueryAudioOutputCapabilities: ::std::option::Option<
441 unsafe extern "C" fn(
442 self_: SLAudioIODeviceCapabilitiesItf,
443 deviceId: SLuint32,
444 pDescriptor: *mut SLAudioOutputDescriptor,
445 ) -> SLresult,
446 >,
447 pub RegisterAvailableAudioOutputsChangedCallback: ::std::option::Option<
448 unsafe extern "C" fn(
449 self_: SLAudioIODeviceCapabilitiesItf,
450 callback: slAvailableAudioOutputsChangedCallback,
451 pContext: *mut ::std::os::raw::c_void,
452 ) -> SLresult,
453 >,
454 pub RegisterDefaultDeviceIDMapChangedCallback: ::std::option::Option<
455 unsafe extern "C" fn(
456 self_: SLAudioIODeviceCapabilitiesItf,
457 callback: slDefaultDeviceIDMapChangedCallback,
458 pContext: *mut ::std::os::raw::c_void,
459 ) -> SLresult,
460 >,
461 pub GetAssociatedAudioInputs: ::std::option::Option<
462 unsafe extern "C" fn(
463 self_: SLAudioIODeviceCapabilitiesItf,
464 deviceId: SLuint32,
465 pNumAudioInputs: *mut SLint32,
466 pAudioInputDeviceIDs: *mut SLuint32,
467 ) -> SLresult,
468 >,
469 pub GetAssociatedAudioOutputs: ::std::option::Option<
470 unsafe extern "C" fn(
471 self_: SLAudioIODeviceCapabilitiesItf,
472 deviceId: SLuint32,
473 pNumAudioOutputs: *mut SLint32,
474 pAudioOutputDeviceIDs: *mut SLuint32,
475 ) -> SLresult,
476 >,
477 pub GetDefaultAudioDevices: ::std::option::Option<
478 unsafe extern "C" fn(
479 self_: SLAudioIODeviceCapabilitiesItf,
480 defaultDeviceID: SLuint32,
481 pNumAudioDevices: *mut SLint32,
482 pAudioDeviceIDs: *mut SLuint32,
483 ) -> SLresult,
484 >,
485 pub QuerySampleFormatsSupported: ::std::option::Option<
486 unsafe extern "C" fn(
487 self_: SLAudioIODeviceCapabilitiesItf,
488 deviceId: SLuint32,
489 samplingRate: SLmilliHertz,
490 pSampleFormats: *mut SLint32,
491 pNumOfSampleFormats: *mut SLint32,
492 ) -> SLresult,
493 >,
494}
495#[repr(C)]
496#[derive(Debug, Copy, Clone)]
497pub struct SLLEDDescriptor_ {
498 pub ledCount: SLuint8,
499 pub primaryLED: SLuint8,
500 pub colorMask: SLuint32,
501}
502pub type SLLEDDescriptor = SLLEDDescriptor_;
503#[repr(C)]
504#[derive(Debug, Copy, Clone)]
505pub struct SLHSL_ {
506 pub hue: SLmillidegree,
507 pub saturation: SLpermille,
508 pub lightness: SLpermille,
509}
510pub type SLHSL = SLHSL_;
511extern "C" {
512 pub static mut SL_IID_LED: SLInterfaceID;
513}
514pub type SLLEDArrayItf = *const *const SLLEDArrayItf_;
515#[repr(C)]
516#[derive(Debug, Copy, Clone)]
517pub struct SLLEDArrayItf_ {
518 pub ActivateLEDArray: ::std::option::Option<
519 unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: SLuint32) -> SLresult,
520 >,
521 pub IsLEDArrayActivated: ::std::option::Option<
522 unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: *mut SLuint32) -> SLresult,
523 >,
524 pub SetColor: ::std::option::Option<
525 unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *const SLHSL) -> SLresult,
526 >,
527 pub GetColor: ::std::option::Option<
528 unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *mut SLHSL) -> SLresult,
529 >,
530}
531#[repr(C)]
532#[derive(Debug, Copy, Clone)]
533pub struct SLVibraDescriptor_ {
534 pub supportsFrequency: SLboolean,
535 pub supportsIntensity: SLboolean,
536 pub minFrequency: SLmilliHertz,
537 pub maxFrequency: SLmilliHertz,
538}
539pub type SLVibraDescriptor = SLVibraDescriptor_;
540extern "C" {
541 pub static mut SL_IID_VIBRA: SLInterfaceID;
542}
543pub type SLVibraItf = *const *const SLVibraItf_;
544#[repr(C)]
545#[derive(Debug, Copy, Clone)]
546pub struct SLVibraItf_ {
547 pub Vibrate: ::std::option::Option<
548 unsafe extern "C" fn(self_: SLVibraItf, vibrate: SLboolean) -> SLresult,
549 >,
550 pub IsVibrating: ::std::option::Option<
551 unsafe extern "C" fn(self_: SLVibraItf, pVibrating: *mut SLboolean) -> SLresult,
552 >,
553 pub SetFrequency: ::std::option::Option<
554 unsafe extern "C" fn(self_: SLVibraItf, frequency: SLmilliHertz) -> SLresult,
555 >,
556 pub GetFrequency: ::std::option::Option<
557 unsafe extern "C" fn(self_: SLVibraItf, pFrequency: *mut SLmilliHertz) -> SLresult,
558 >,
559 pub SetIntensity: ::std::option::Option<
560 unsafe extern "C" fn(self_: SLVibraItf, intensity: SLpermille) -> SLresult,
561 >,
562 pub GetIntensity: ::std::option::Option<
563 unsafe extern "C" fn(self_: SLVibraItf, pIntensity: *mut SLpermille) -> SLresult,
564 >,
565}
566#[repr(C)]
567#[derive(Debug, Copy, Clone)]
568pub struct SLMetadataInfo_ {
569 pub size: SLuint32,
570 pub encoding: SLuint32,
571 pub langCountry: [SLchar; 16usize],
572 pub data: [SLuint8; 1usize],
573}
574pub type SLMetadataInfo = SLMetadataInfo_;
575extern "C" {
576 pub static mut SL_IID_METADATAEXTRACTION: SLInterfaceID;
577}
578pub type SLMetadataExtractionItf = *const *const SLMetadataExtractionItf_;
579#[repr(C)]
580#[derive(Debug, Copy, Clone)]
581pub struct SLMetadataExtractionItf_ {
582 pub GetItemCount: ::std::option::Option<
583 unsafe extern "C" fn(self_: SLMetadataExtractionItf, pItemCount: *mut SLuint32) -> SLresult,
584 >,
585 pub GetKeySize: ::std::option::Option<
586 unsafe extern "C" fn(
587 self_: SLMetadataExtractionItf,
588 index: SLuint32,
589 pKeySize: *mut SLuint32,
590 ) -> SLresult,
591 >,
592 pub GetKey: ::std::option::Option<
593 unsafe extern "C" fn(
594 self_: SLMetadataExtractionItf,
595 index: SLuint32,
596 keySize: SLuint32,
597 pKey: *mut SLMetadataInfo,
598 ) -> SLresult,
599 >,
600 pub GetValueSize: ::std::option::Option<
601 unsafe extern "C" fn(
602 self_: SLMetadataExtractionItf,
603 index: SLuint32,
604 pValueSize: *mut SLuint32,
605 ) -> SLresult,
606 >,
607 pub GetValue: ::std::option::Option<
608 unsafe extern "C" fn(
609 self_: SLMetadataExtractionItf,
610 index: SLuint32,
611 valueSize: SLuint32,
612 pValue: *mut SLMetadataInfo,
613 ) -> SLresult,
614 >,
615 pub AddKeyFilter: ::std::option::Option<
616 unsafe extern "C" fn(
617 self_: SLMetadataExtractionItf,
618 keySize: SLuint32,
619 pKey: *const ::std::os::raw::c_void,
620 keyEncoding: SLuint32,
621 pValueLangCountry: *const SLchar,
622 valueEncoding: SLuint32,
623 filterMask: SLuint8,
624 ) -> SLresult,
625 >,
626 pub ClearKeyFilter:
627 ::std::option::Option<unsafe extern "C" fn(self_: SLMetadataExtractionItf) -> SLresult>,
628}
629extern "C" {
630 pub static mut SL_IID_METADATATRAVERSAL: SLInterfaceID;
631}
632pub type SLMetadataTraversalItf = *const *const SLMetadataTraversalItf_;
633#[repr(C)]
634#[derive(Debug, Copy, Clone)]
635pub struct SLMetadataTraversalItf_ {
636 pub SetMode: ::std::option::Option<
637 unsafe extern "C" fn(self_: SLMetadataTraversalItf, mode: SLuint32) -> SLresult,
638 >,
639 pub GetChildCount: ::std::option::Option<
640 unsafe extern "C" fn(self_: SLMetadataTraversalItf, pCount: *mut SLuint32) -> SLresult,
641 >,
642 pub GetChildMIMETypeSize: ::std::option::Option<
643 unsafe extern "C" fn(self_: SLMetadataTraversalItf, index: SLuint32, pSize: *mut SLuint32)
644 -> SLresult,
645 >,
646 pub GetChildInfo: ::std::option::Option<
647 unsafe extern "C" fn(
648 self_: SLMetadataTraversalItf,
649 index: SLuint32,
650 pNodeID: *mut SLint32,
651 pType: *mut SLuint32,
652 size: SLuint32,
653 pMimeType: *mut SLchar,
654 ) -> SLresult,
655 >,
656 pub SetActiveNode: ::std::option::Option<
657 unsafe extern "C" fn(self_: SLMetadataTraversalItf, index: SLuint32) -> SLresult,
658 >,
659}
660extern "C" {
661 pub static mut SL_IID_DYNAMICSOURCE: SLInterfaceID;
662}
663pub type SLDynamicSourceItf = *const *const SLDynamicSourceItf_;
664#[repr(C)]
665#[derive(Debug, Copy, Clone)]
666pub struct SLDynamicSourceItf_ {
667 pub SetSource: ::std::option::Option<
668 unsafe extern "C" fn(self_: SLDynamicSourceItf, pDataSource: *mut SLDataSource) -> SLresult,
669 >,
670}
671extern "C" {
672 pub static mut SL_IID_OUTPUTMIX: SLInterfaceID;
673}
674pub type SLOutputMixItf = *const *const SLOutputMixItf_;
675pub type slMixDeviceChangeCallback = ::std::option::Option<
676 unsafe extern "C" fn(caller: SLOutputMixItf, pContext: *mut ::std::os::raw::c_void),
677>;
678#[repr(C)]
679#[derive(Debug, Copy, Clone)]
680pub struct SLOutputMixItf_ {
681 pub GetDestinationOutputDeviceIDs: ::std::option::Option<
682 unsafe extern "C" fn(
683 self_: SLOutputMixItf,
684 pNumDevices: *mut SLint32,
685 pDeviceIDs: *mut SLuint32,
686 ) -> SLresult,
687 >,
688 pub RegisterDeviceChangeCallback: ::std::option::Option<
689 unsafe extern "C" fn(
690 self_: SLOutputMixItf,
691 callback: slMixDeviceChangeCallback,
692 pContext: *mut ::std::os::raw::c_void,
693 ) -> SLresult,
694 >,
695 pub ReRoute: ::std::option::Option<
696 unsafe extern "C" fn(
697 self_: SLOutputMixItf,
698 numOutputDevices: SLint32,
699 pOutputDeviceIDs: *mut SLuint32,
700 ) -> SLresult,
701 >,
702}
703extern "C" {
704 pub static mut SL_IID_PLAY: SLInterfaceID;
705}
706pub type SLPlayItf = *const *const SLPlayItf_;
707pub type slPlayCallback = ::std::option::Option<
708 unsafe extern "C" fn(caller: SLPlayItf, pContext: *mut ::std::os::raw::c_void, event: SLuint32),
709>;
710#[repr(C)]
712#[derive(Debug, Copy, Clone)]
713pub struct SLPlayItf_ {
714 pub SetPlayState:
715 ::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf, state: SLuint32) -> SLresult>,
716 pub GetPlayState: ::std::option::Option<
717 unsafe extern "C" fn(self_: SLPlayItf, pState: *mut SLuint32) -> SLresult,
718 >,
719 pub GetDuration: ::std::option::Option<
720 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
721 >,
722 pub GetPosition: ::std::option::Option<
723 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
724 >,
725 pub RegisterCallback: ::std::option::Option<
726 unsafe extern "C" fn(
727 self_: SLPlayItf,
728 callback: slPlayCallback,
729 pContext: *mut ::std::os::raw::c_void,
730 ) -> SLresult,
731 >,
732 pub SetCallbackEventsMask: ::std::option::Option<
733 unsafe extern "C" fn(self_: SLPlayItf, eventFlags: SLuint32) -> SLresult,
734 >,
735 pub GetCallbackEventsMask: ::std::option::Option<
736 unsafe extern "C" fn(self_: SLPlayItf, pEventFlags: *mut SLuint32) -> SLresult,
737 >,
738 pub SetMarkerPosition: ::std::option::Option<
739 unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
740 >,
741 pub ClearMarkerPosition:
742 ::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf) -> SLresult>,
743 pub GetMarkerPosition: ::std::option::Option<
744 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
745 >,
746 pub SetPositionUpdatePeriod: ::std::option::Option<
747 unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
748 >,
749 pub GetPositionUpdatePeriod: ::std::option::Option<
750 unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
751 >,
752}
753extern "C" {
754 pub static mut SL_IID_PREFETCHSTATUS: SLInterfaceID;
755}
756pub type SLPrefetchStatusItf = *const *const SLPrefetchStatusItf_;
757pub type slPrefetchCallback = ::std::option::Option<
758 unsafe extern "C" fn(
759 caller: SLPrefetchStatusItf,
760 pContext: *mut ::std::os::raw::c_void,
761 event: SLuint32,
762 ),
763>;
764#[repr(C)]
766#[derive(Debug, Copy, Clone)]
767pub struct SLPrefetchStatusItf_ {
768 pub GetPrefetchStatus: ::std::option::Option<
769 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pStatus: *mut SLuint32) -> SLresult,
770 >,
771 pub GetFillLevel: ::std::option::Option<
772 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pLevel: *mut SLpermille) -> SLresult,
773 >,
774 pub RegisterCallback: ::std::option::Option<
775 unsafe extern "C" fn(
776 self_: SLPrefetchStatusItf,
777 callback: slPrefetchCallback,
778 pContext: *mut ::std::os::raw::c_void,
779 ) -> SLresult,
780 >,
781 pub SetCallbackEventsMask: ::std::option::Option<
782 unsafe extern "C" fn(self_: SLPrefetchStatusItf, eventFlags: SLuint32) -> SLresult,
783 >,
784 pub GetCallbackEventsMask: ::std::option::Option<
785 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pEventFlags: *mut SLuint32) -> SLresult,
786 >,
787 pub SetFillUpdatePeriod: ::std::option::Option<
788 unsafe extern "C" fn(self_: SLPrefetchStatusItf, period: SLpermille) -> SLresult,
789 >,
790 pub GetFillUpdatePeriod: ::std::option::Option<
791 unsafe extern "C" fn(self_: SLPrefetchStatusItf, pPeriod: *mut SLpermille) -> SLresult,
792 >,
793}
794extern "C" {
795 pub static mut SL_IID_PLAYBACKRATE: SLInterfaceID;
796}
797pub type SLPlaybackRateItf = *const *const SLPlaybackRateItf_;
798#[repr(C)]
799#[derive(Debug, Copy, Clone)]
800pub struct SLPlaybackRateItf_ {
801 pub SetRate: ::std::option::Option<
802 unsafe extern "C" fn(self_: SLPlaybackRateItf, rate: SLpermille) -> SLresult,
803 >,
804 pub GetRate: ::std::option::Option<
805 unsafe extern "C" fn(self_: SLPlaybackRateItf, pRate: *mut SLpermille) -> SLresult,
806 >,
807 pub SetPropertyConstraints: ::std::option::Option<
808 unsafe extern "C" fn(self_: SLPlaybackRateItf, constraints: SLuint32) -> SLresult,
809 >,
810 pub GetProperties: ::std::option::Option<
811 unsafe extern "C" fn(self_: SLPlaybackRateItf, pProperties: *mut SLuint32) -> SLresult,
812 >,
813 pub GetCapabilitiesOfRate: ::std::option::Option<
814 unsafe extern "C" fn(
815 self_: SLPlaybackRateItf,
816 rate: SLpermille,
817 pCapabilities: *mut SLuint32,
818 ) -> SLresult,
819 >,
820 pub GetRateRange: ::std::option::Option<
821 unsafe extern "C" fn(
822 self_: SLPlaybackRateItf,
823 index: SLuint8,
824 pMinRate: *mut SLpermille,
825 pMaxRate: *mut SLpermille,
826 pStepSize: *mut SLpermille,
827 pCapabilities: *mut SLuint32,
828 ) -> SLresult,
829 >,
830}
831extern "C" {
832 pub static mut SL_IID_SEEK: SLInterfaceID;
833}
834pub type SLSeekItf = *const *const SLSeekItf_;
835#[repr(C)]
836#[derive(Debug, Copy, Clone)]
837pub struct SLSeekItf_ {
838 pub SetPosition: ::std::option::Option<
839 unsafe extern "C" fn(self_: SLSeekItf, pos: SLmillisecond, seekMode: SLuint32) -> SLresult,
840 >,
841 pub SetLoop: ::std::option::Option<
842 unsafe extern "C" fn(
843 self_: SLSeekItf,
844 loopEnable: SLboolean,
845 startPos: SLmillisecond,
846 endPos: SLmillisecond,
847 ) -> SLresult,
848 >,
849 pub GetLoop: ::std::option::Option<
850 unsafe extern "C" fn(
851 self_: SLSeekItf,
852 pLoopEnabled: *mut SLboolean,
853 pStartPos: *mut SLmillisecond,
854 pEndPos: *mut SLmillisecond,
855 ) -> SLresult,
856 >,
857}
858extern "C" {
859 pub static mut SL_IID_RECORD: SLInterfaceID;
860}
861pub type SLRecordItf = *const *const SLRecordItf_;
862pub type slRecordCallback = ::std::option::Option<
863 unsafe extern "C" fn(
864 caller: SLRecordItf,
865 pContext: *mut ::std::os::raw::c_void,
866 event: SLuint32,
867 ),
868>;
869#[repr(C)]
871#[derive(Debug, Copy, Clone)]
872pub struct SLRecordItf_ {
873 pub SetRecordState: ::std::option::Option<
874 unsafe extern "C" fn(self_: SLRecordItf, state: SLuint32) -> SLresult,
875 >,
876 pub GetRecordState: ::std::option::Option<
877 unsafe extern "C" fn(self_: SLRecordItf, pState: *mut SLuint32) -> SLresult,
878 >,
879 pub SetDurationLimit: ::std::option::Option<
880 unsafe extern "C" fn(self_: SLRecordItf, msec: SLmillisecond) -> SLresult,
881 >,
882 pub GetPosition: ::std::option::Option<
883 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
884 >,
885 pub RegisterCallback: ::std::option::Option<
886 unsafe extern "C" fn(
887 self_: SLRecordItf,
888 callback: slRecordCallback,
889 pContext: *mut ::std::os::raw::c_void,
890 ) -> SLresult,
891 >,
892 pub SetCallbackEventsMask: ::std::option::Option<
893 unsafe extern "C" fn(self_: SLRecordItf, eventFlags: SLuint32) -> SLresult,
894 >,
895 pub GetCallbackEventsMask: ::std::option::Option<
896 unsafe extern "C" fn(self_: SLRecordItf, pEventFlags: *mut SLuint32) -> SLresult,
897 >,
898 pub SetMarkerPosition: ::std::option::Option<
899 unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
900 >,
901 pub ClearMarkerPosition:
902 ::std::option::Option<unsafe extern "C" fn(self_: SLRecordItf) -> SLresult>,
903 pub GetMarkerPosition: ::std::option::Option<
904 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
905 >,
906 pub SetPositionUpdatePeriod: ::std::option::Option<
907 unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
908 >,
909 pub GetPositionUpdatePeriod: ::std::option::Option<
910 unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
911 >,
912}
913extern "C" {
914 pub static mut SL_IID_EQUALIZER: SLInterfaceID;
915}
916pub type SLEqualizerItf = *const *const SLEqualizerItf_;
917#[repr(C)]
918#[derive(Debug, Copy, Clone)]
919pub struct SLEqualizerItf_ {
920 pub SetEnabled: ::std::option::Option<
921 unsafe extern "C" fn(self_: SLEqualizerItf, enabled: SLboolean) -> SLresult,
922 >,
923 pub IsEnabled: ::std::option::Option<
924 unsafe extern "C" fn(self_: SLEqualizerItf, pEnabled: *mut SLboolean) -> SLresult,
925 >,
926 pub GetNumberOfBands: ::std::option::Option<
927 unsafe extern "C" fn(self_: SLEqualizerItf, pAmount: *mut SLuint16) -> SLresult,
928 >,
929 pub GetBandLevelRange: ::std::option::Option<
930 unsafe extern "C" fn(self_: SLEqualizerItf, pMin: *mut SLmillibel, pMax: *mut SLmillibel)
931 -> SLresult,
932 >,
933 pub SetBandLevel: ::std::option::Option<
934 unsafe extern "C" fn(self_: SLEqualizerItf, band: SLuint16, level: SLmillibel) -> SLresult,
935 >,
936 pub GetBandLevel: ::std::option::Option<
937 unsafe extern "C" fn(self_: SLEqualizerItf, band: SLuint16, pLevel: *mut SLmillibel)
938 -> SLresult,
939 >,
940 pub GetCenterFreq: ::std::option::Option<
941 unsafe extern "C" fn(self_: SLEqualizerItf, band: SLuint16, pCenter: *mut SLmilliHertz)
942 -> SLresult,
943 >,
944 pub GetBandFreqRange: ::std::option::Option<
945 unsafe extern "C" fn(
946 self_: SLEqualizerItf,
947 band: SLuint16,
948 pMin: *mut SLmilliHertz,
949 pMax: *mut SLmilliHertz,
950 ) -> SLresult,
951 >,
952 pub GetBand: ::std::option::Option<
953 unsafe extern "C" fn(self_: SLEqualizerItf, frequency: SLmilliHertz, pBand: *mut SLuint16)
954 -> SLresult,
955 >,
956 pub GetCurrentPreset: ::std::option::Option<
957 unsafe extern "C" fn(self_: SLEqualizerItf, pPreset: *mut SLuint16) -> SLresult,
958 >,
959 pub UsePreset: ::std::option::Option<
960 unsafe extern "C" fn(self_: SLEqualizerItf, index: SLuint16) -> SLresult,
961 >,
962 pub GetNumberOfPresets: ::std::option::Option<
963 unsafe extern "C" fn(self_: SLEqualizerItf, pNumPresets: *mut SLuint16) -> SLresult,
964 >,
965 pub GetPresetName: ::std::option::Option<
966 unsafe extern "C" fn(self_: SLEqualizerItf, index: SLuint16, ppName: *mut *const SLchar)
967 -> SLresult,
968 >,
969}
970extern "C" {
971 pub static mut SL_IID_VOLUME: SLInterfaceID;
972}
973pub type SLVolumeItf = *const *const SLVolumeItf_;
974#[repr(C)]
975#[derive(Debug, Copy, Clone)]
976pub struct SLVolumeItf_ {
977 pub SetVolumeLevel: ::std::option::Option<
978 unsafe extern "C" fn(self_: SLVolumeItf, level: SLmillibel) -> SLresult,
979 >,
980 pub GetVolumeLevel: ::std::option::Option<
981 unsafe extern "C" fn(self_: SLVolumeItf, pLevel: *mut SLmillibel) -> SLresult,
982 >,
983 pub GetMaxVolumeLevel: ::std::option::Option<
984 unsafe extern "C" fn(self_: SLVolumeItf, pMaxLevel: *mut SLmillibel) -> SLresult,
985 >,
986 pub SetMute: ::std::option::Option<
987 unsafe extern "C" fn(self_: SLVolumeItf, mute: SLboolean) -> SLresult,
988 >,
989 pub GetMute: ::std::option::Option<
990 unsafe extern "C" fn(self_: SLVolumeItf, pMute: *mut SLboolean) -> SLresult,
991 >,
992 pub EnableStereoPosition: ::std::option::Option<
993 unsafe extern "C" fn(self_: SLVolumeItf, enable: SLboolean) -> SLresult,
994 >,
995 pub IsEnabledStereoPosition: ::std::option::Option<
996 unsafe extern "C" fn(self_: SLVolumeItf, pEnable: *mut SLboolean) -> SLresult,
997 >,
998 pub SetStereoPosition: ::std::option::Option<
999 unsafe extern "C" fn(self_: SLVolumeItf, stereoPosition: SLpermille) -> SLresult,
1000 >,
1001 pub GetStereoPosition: ::std::option::Option<
1002 unsafe extern "C" fn(self_: SLVolumeItf, pStereoPosition: *mut SLpermille) -> SLresult,
1003 >,
1004}
1005extern "C" {
1006 pub static mut SL_IID_DEVICEVOLUME: SLInterfaceID;
1007}
1008pub type SLDeviceVolumeItf = *const *const SLDeviceVolumeItf_;
1009#[repr(C)]
1010#[derive(Debug, Copy, Clone)]
1011pub struct SLDeviceVolumeItf_ {
1012 pub GetVolumeScale: ::std::option::Option<
1013 unsafe extern "C" fn(
1014 self_: SLDeviceVolumeItf,
1015 deviceID: SLuint32,
1016 pMinValue: *mut SLint32,
1017 pMaxValue: *mut SLint32,
1018 pIsMillibelScale: *mut SLboolean,
1019 ) -> SLresult,
1020 >,
1021 pub SetVolume: ::std::option::Option<
1022 unsafe extern "C" fn(self_: SLDeviceVolumeItf, deviceID: SLuint32, volume: SLint32)
1023 -> SLresult,
1024 >,
1025 pub GetVolume: ::std::option::Option<
1026 unsafe extern "C" fn(self_: SLDeviceVolumeItf, deviceID: SLuint32, pVolume: *mut SLint32)
1027 -> SLresult,
1028 >,
1029}
1030extern "C" {
1031 pub static mut SL_IID_BUFFERQUEUE: SLInterfaceID;
1032}
1033pub type SLBufferQueueItf = *const *const SLBufferQueueItf_;
1034pub type slBufferQueueCallback = ::std::option::Option<
1035 unsafe extern "C" fn(caller: SLBufferQueueItf, pContext: *mut ::std::os::raw::c_void),
1036>;
1037#[repr(C)]
1039#[derive(Debug, Copy, Clone)]
1040pub struct SLBufferQueueState_ {
1041 pub count: SLuint32,
1042 pub playIndex: SLuint32,
1043}
1044pub type SLBufferQueueState = SLBufferQueueState_;
1045#[repr(C)]
1046#[derive(Debug, Copy, Clone)]
1047pub struct SLBufferQueueItf_ {
1048 pub Enqueue: ::std::option::Option<
1049 unsafe extern "C" fn(
1050 self_: SLBufferQueueItf,
1051 pBuffer: *const ::std::os::raw::c_void,
1052 size: SLuint32,
1053 ) -> SLresult,
1054 >,
1055 pub Clear: ::std::option::Option<unsafe extern "C" fn(self_: SLBufferQueueItf) -> SLresult>,
1056 pub GetState: ::std::option::Option<
1057 unsafe extern "C" fn(self_: SLBufferQueueItf, pState: *mut SLBufferQueueState) -> SLresult,
1058 >,
1059 pub RegisterCallback: ::std::option::Option<
1060 unsafe extern "C" fn(
1061 self_: SLBufferQueueItf,
1062 callback: slBufferQueueCallback,
1063 pContext: *mut ::std::os::raw::c_void,
1064 ) -> SLresult,
1065 >,
1066}
1067extern "C" {
1068 pub static mut SL_IID_PRESETREVERB: SLInterfaceID;
1069}
1070pub type SLPresetReverbItf = *const *const SLPresetReverbItf_;
1071#[repr(C)]
1072#[derive(Debug, Copy, Clone)]
1073pub struct SLPresetReverbItf_ {
1074 pub SetPreset: ::std::option::Option<
1075 unsafe extern "C" fn(self_: SLPresetReverbItf, preset: SLuint16) -> SLresult,
1076 >,
1077 pub GetPreset: ::std::option::Option<
1078 unsafe extern "C" fn(self_: SLPresetReverbItf, pPreset: *mut SLuint16) -> SLresult,
1079 >,
1080}
1081#[repr(C)]
1082#[derive(Debug, Copy, Clone)]
1083pub struct SLEnvironmentalReverbSettings_ {
1084 pub roomLevel: SLmillibel,
1085 pub roomHFLevel: SLmillibel,
1086 pub decayTime: SLmillisecond,
1087 pub decayHFRatio: SLpermille,
1088 pub reflectionsLevel: SLmillibel,
1089 pub reflectionsDelay: SLmillisecond,
1090 pub reverbLevel: SLmillibel,
1091 pub reverbDelay: SLmillisecond,
1092 pub diffusion: SLpermille,
1093 pub density: SLpermille,
1094}
1095pub type SLEnvironmentalReverbSettings = SLEnvironmentalReverbSettings_;
1096extern "C" {
1097 pub static mut SL_IID_ENVIRONMENTALREVERB: SLInterfaceID;
1098}
1099pub type SLEnvironmentalReverbItf = *const *const SLEnvironmentalReverbItf_;
1100#[repr(C)]
1101#[derive(Debug, Copy, Clone)]
1102pub struct SLEnvironmentalReverbItf_ {
1103 pub SetRoomLevel: ::std::option::Option<
1104 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, room: SLmillibel) -> SLresult,
1105 >,
1106 pub GetRoomLevel: ::std::option::Option<
1107 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoom: *mut SLmillibel) -> SLresult,
1108 >,
1109 pub SetRoomHFLevel: ::std::option::Option<
1110 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, roomHF: SLmillibel) -> SLresult,
1111 >,
1112 pub GetRoomHFLevel: ::std::option::Option<
1113 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoomHF: *mut SLmillibel) -> SLresult,
1114 >,
1115 pub SetDecayTime: ::std::option::Option<
1116 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayTime: SLmillisecond) -> SLresult,
1117 >,
1118 pub GetDecayTime: ::std::option::Option<
1119 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pDecayTime: *mut SLmillisecond)
1120 -> SLresult,
1121 >,
1122 pub SetDecayHFRatio: ::std::option::Option<
1123 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayHFRatio: SLpermille) -> SLresult,
1124 >,
1125 pub GetDecayHFRatio: ::std::option::Option<
1126 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pDecayHFRatio: *mut SLpermille)
1127 -> SLresult,
1128 >,
1129 pub SetReflectionsLevel: ::std::option::Option<
1130 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reflectionsLevel: SLmillibel)
1131 -> SLresult,
1132 >,
1133 pub GetReflectionsLevel: ::std::option::Option<
1134 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pReflectionsLevel: *mut SLmillibel)
1135 -> SLresult,
1136 >,
1137 pub SetReflectionsDelay: ::std::option::Option<
1138 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reflectionsDelay: SLmillisecond)
1139 -> SLresult,
1140 >,
1141 pub GetReflectionsDelay: ::std::option::Option<
1142 unsafe extern "C" fn(
1143 self_: SLEnvironmentalReverbItf,
1144 pReflectionsDelay: *mut SLmillisecond,
1145 ) -> SLresult,
1146 >,
1147 pub SetReverbLevel: ::std::option::Option<
1148 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reverbLevel: SLmillibel) -> SLresult,
1149 >,
1150 pub GetReverbLevel: ::std::option::Option<
1151 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pReverbLevel: *mut SLmillibel)
1152 -> SLresult,
1153 >,
1154 pub SetReverbDelay: ::std::option::Option<
1155 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reverbDelay: SLmillisecond)
1156 -> SLresult,
1157 >,
1158 pub GetReverbDelay: ::std::option::Option<
1159 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pReverbDelay: *mut SLmillisecond)
1160 -> SLresult,
1161 >,
1162 pub SetDiffusion: ::std::option::Option<
1163 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, diffusion: SLpermille) -> SLresult,
1164 >,
1165 pub GetDiffusion: ::std::option::Option<
1166 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pDiffusion: *mut SLpermille)
1167 -> SLresult,
1168 >,
1169 pub SetDensity: ::std::option::Option<
1170 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, density: SLpermille) -> SLresult,
1171 >,
1172 pub GetDensity: ::std::option::Option<
1173 unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pDensity: *mut SLpermille)
1174 -> SLresult,
1175 >,
1176 pub SetEnvironmentalReverbProperties: ::std::option::Option<
1177 unsafe extern "C" fn(
1178 self_: SLEnvironmentalReverbItf,
1179 pProperties: *const SLEnvironmentalReverbSettings,
1180 ) -> SLresult,
1181 >,
1182 pub GetEnvironmentalReverbProperties: ::std::option::Option<
1183 unsafe extern "C" fn(
1184 self_: SLEnvironmentalReverbItf,
1185 pProperties: *mut SLEnvironmentalReverbSettings,
1186 ) -> SLresult,
1187 >,
1188}
1189extern "C" {
1190 pub static mut SL_IID_EFFECTSEND: SLInterfaceID;
1191}
1192pub type SLEffectSendItf = *const *const SLEffectSendItf_;
1193#[repr(C)]
1194#[derive(Debug, Copy, Clone)]
1195pub struct SLEffectSendItf_ {
1196 pub EnableEffectSend: ::std::option::Option<
1197 unsafe extern "C" fn(
1198 self_: SLEffectSendItf,
1199 pAuxEffect: *const ::std::os::raw::c_void,
1200 enable: SLboolean,
1201 initialLevel: SLmillibel,
1202 ) -> SLresult,
1203 >,
1204 pub IsEnabled: ::std::option::Option<
1205 unsafe extern "C" fn(
1206 self_: SLEffectSendItf,
1207 pAuxEffect: *const ::std::os::raw::c_void,
1208 pEnable: *mut SLboolean,
1209 ) -> SLresult,
1210 >,
1211 pub SetDirectLevel: ::std::option::Option<
1212 unsafe extern "C" fn(self_: SLEffectSendItf, directLevel: SLmillibel) -> SLresult,
1213 >,
1214 pub GetDirectLevel: ::std::option::Option<
1215 unsafe extern "C" fn(self_: SLEffectSendItf, pDirectLevel: *mut SLmillibel) -> SLresult,
1216 >,
1217 pub SetSendLevel: ::std::option::Option<
1218 unsafe extern "C" fn(
1219 self_: SLEffectSendItf,
1220 pAuxEffect: *const ::std::os::raw::c_void,
1221 sendLevel: SLmillibel,
1222 ) -> SLresult,
1223 >,
1224 pub GetSendLevel: ::std::option::Option<
1225 unsafe extern "C" fn(
1226 self_: SLEffectSendItf,
1227 pAuxEffect: *const ::std::os::raw::c_void,
1228 pSendLevel: *mut SLmillibel,
1229 ) -> SLresult,
1230 >,
1231}
1232extern "C" {
1233 pub static mut SL_IID_3DGROUPING: SLInterfaceID;
1234}
1235pub type SL3DGroupingItf = *const *const SL3DGroupingItf_;
1236#[repr(C)]
1237#[derive(Debug, Copy, Clone)]
1238pub struct SL3DGroupingItf_ {
1239 pub Set3DGroup: ::std::option::Option<
1240 unsafe extern "C" fn(self_: SL3DGroupingItf, group: SLObjectItf) -> SLresult,
1241 >,
1242 pub Get3DGroup: ::std::option::Option<
1243 unsafe extern "C" fn(self_: SL3DGroupingItf, pGroup: *mut SLObjectItf) -> SLresult,
1244 >,
1245}
1246extern "C" {
1247 pub static mut SL_IID_3DCOMMIT: SLInterfaceID;
1248}
1249pub type SL3DCommitItf = *const *const SL3DCommitItf_;
1250#[repr(C)]
1251#[derive(Debug, Copy, Clone)]
1252pub struct SL3DCommitItf_ {
1253 pub Commit: ::std::option::Option<unsafe extern "C" fn(self_: SL3DCommitItf) -> SLresult>,
1254 pub SetDeferred: ::std::option::Option<
1255 unsafe extern "C" fn(self_: SL3DCommitItf, deferred: SLboolean) -> SLresult,
1256 >,
1257}
1258#[repr(C)]
1259#[derive(Debug, Copy, Clone)]
1260pub struct SLVec3D_ {
1261 pub x: SLint32,
1262 pub y: SLint32,
1263 pub z: SLint32,
1264}
1265pub type SLVec3D = SLVec3D_;
1266extern "C" {
1267 pub static mut SL_IID_3DLOCATION: SLInterfaceID;
1268}
1269pub type SL3DLocationItf = *const *const SL3DLocationItf_;
1270#[repr(C)]
1271#[derive(Debug, Copy, Clone)]
1272pub struct SL3DLocationItf_ {
1273 pub SetLocationCartesian: ::std::option::Option<
1274 unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *const SLVec3D) -> SLresult,
1275 >,
1276 pub SetLocationSpherical: ::std::option::Option<
1277 unsafe extern "C" fn(
1278 self_: SL3DLocationItf,
1279 azimuth: SLmillidegree,
1280 elevation: SLmillidegree,
1281 distance: SLmillimeter,
1282 ) -> SLresult,
1283 >,
1284 pub Move: ::std::option::Option<
1285 unsafe extern "C" fn(self_: SL3DLocationItf, pMovement: *const SLVec3D) -> SLresult,
1286 >,
1287 pub GetLocationCartesian: ::std::option::Option<
1288 unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *mut SLVec3D) -> SLresult,
1289 >,
1290 pub SetOrientationVectors: ::std::option::Option<
1291 unsafe extern "C" fn(
1292 self_: SL3DLocationItf,
1293 pFront: *const SLVec3D,
1294 pAbove: *const SLVec3D,
1295 ) -> SLresult,
1296 >,
1297 pub SetOrientationAngles: ::std::option::Option<
1298 unsafe extern "C" fn(
1299 self_: SL3DLocationItf,
1300 heading: SLmillidegree,
1301 pitch: SLmillidegree,
1302 roll: SLmillidegree,
1303 ) -> SLresult,
1304 >,
1305 pub Rotate: ::std::option::Option<
1306 unsafe extern "C" fn(self_: SL3DLocationItf, theta: SLmillidegree, pAxis: *const SLVec3D)
1307 -> SLresult,
1308 >,
1309 pub GetOrientationVectors: ::std::option::Option<
1310 unsafe extern "C" fn(self_: SL3DLocationItf, pFront: *mut SLVec3D, pUp: *mut SLVec3D)
1311 -> SLresult,
1312 >,
1313}
1314extern "C" {
1315 pub static mut SL_IID_3DDOPPLER: SLInterfaceID;
1316}
1317pub type SL3DDopplerItf = *const *const SL3DDopplerItf_;
1318#[repr(C)]
1319#[derive(Debug, Copy, Clone)]
1320pub struct SL3DDopplerItf_ {
1321 pub SetVelocityCartesian: ::std::option::Option<
1322 unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *const SLVec3D) -> SLresult,
1323 >,
1324 pub SetVelocitySpherical: ::std::option::Option<
1325 unsafe extern "C" fn(
1326 self_: SL3DDopplerItf,
1327 azimuth: SLmillidegree,
1328 elevation: SLmillidegree,
1329 speed: SLmillimeter,
1330 ) -> SLresult,
1331 >,
1332 pub GetVelocityCartesian: ::std::option::Option<
1333 unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *mut SLVec3D) -> SLresult,
1334 >,
1335 pub SetDopplerFactor: ::std::option::Option<
1336 unsafe extern "C" fn(self_: SL3DDopplerItf, dopplerFactor: SLpermille) -> SLresult,
1337 >,
1338 pub GetDopplerFactor: ::std::option::Option<
1339 unsafe extern "C" fn(self_: SL3DDopplerItf, pDopplerFactor: *mut SLpermille) -> SLresult,
1340 >,
1341}
1342extern "C" {
1343 pub static mut SL_IID_3DSOURCE: SLInterfaceID;
1344}
1345pub type SL3DSourceItf = *const *const SL3DSourceItf_;
1346#[repr(C)]
1347#[derive(Debug, Copy, Clone)]
1348pub struct SL3DSourceItf_ {
1349 pub SetHeadRelative: ::std::option::Option<
1350 unsafe extern "C" fn(self_: SL3DSourceItf, headRelative: SLboolean) -> SLresult,
1351 >,
1352 pub GetHeadRelative: ::std::option::Option<
1353 unsafe extern "C" fn(self_: SL3DSourceItf, pHeadRelative: *mut SLboolean) -> SLresult,
1354 >,
1355 pub SetRolloffDistances: ::std::option::Option<
1356 unsafe extern "C" fn(
1357 self_: SL3DSourceItf,
1358 minDistance: SLmillimeter,
1359 maxDistance: SLmillimeter,
1360 ) -> SLresult,
1361 >,
1362 pub GetRolloffDistances: ::std::option::Option<
1363 unsafe extern "C" fn(
1364 self_: SL3DSourceItf,
1365 pMinDistance: *mut SLmillimeter,
1366 pMaxDistance: *mut SLmillimeter,
1367 ) -> SLresult,
1368 >,
1369 pub SetRolloffMaxDistanceMute: ::std::option::Option<
1370 unsafe extern "C" fn(self_: SL3DSourceItf, mute: SLboolean) -> SLresult,
1371 >,
1372 pub GetRolloffMaxDistanceMute: ::std::option::Option<
1373 unsafe extern "C" fn(self_: SL3DSourceItf, pMute: *mut SLboolean) -> SLresult,
1374 >,
1375 pub SetRolloffFactor: ::std::option::Option<
1376 unsafe extern "C" fn(self_: SL3DSourceItf, rolloffFactor: SLpermille) -> SLresult,
1377 >,
1378 pub GetRolloffFactor: ::std::option::Option<
1379 unsafe extern "C" fn(self_: SL3DSourceItf, pRolloffFactor: *mut SLpermille) -> SLresult,
1380 >,
1381 pub SetRoomRolloffFactor: ::std::option::Option<
1382 unsafe extern "C" fn(self_: SL3DSourceItf, roomRolloffFactor: SLpermille) -> SLresult,
1383 >,
1384 pub GetRoomRolloffFactor: ::std::option::Option<
1385 unsafe extern "C" fn(self_: SL3DSourceItf, pRoomRolloffFactor: *mut SLpermille) -> SLresult,
1386 >,
1387 pub SetRolloffModel: ::std::option::Option<
1388 unsafe extern "C" fn(self_: SL3DSourceItf, model: SLuint8) -> SLresult,
1389 >,
1390 pub GetRolloffModel: ::std::option::Option<
1391 unsafe extern "C" fn(self_: SL3DSourceItf, pModel: *mut SLuint8) -> SLresult,
1392 >,
1393 pub SetCone: ::std::option::Option<
1394 unsafe extern "C" fn(
1395 self_: SL3DSourceItf,
1396 innerAngle: SLmillidegree,
1397 outerAngle: SLmillidegree,
1398 outerLevel: SLmillibel,
1399 ) -> SLresult,
1400 >,
1401 pub GetCone: ::std::option::Option<
1402 unsafe extern "C" fn(
1403 self_: SL3DSourceItf,
1404 pInnerAngle: *mut SLmillidegree,
1405 pOuterAngle: *mut SLmillidegree,
1406 pOuterLevel: *mut SLmillibel,
1407 ) -> SLresult,
1408 >,
1409}
1410extern "C" {
1411 pub static mut SL_IID_3DMACROSCOPIC: SLInterfaceID;
1412}
1413pub type SL3DMacroscopicItf = *const *const SL3DMacroscopicItf_;
1414#[repr(C)]
1415#[derive(Debug, Copy, Clone)]
1416pub struct SL3DMacroscopicItf_ {
1417 pub SetSize: ::std::option::Option<
1418 unsafe extern "C" fn(
1419 self_: SL3DMacroscopicItf,
1420 width: SLmillimeter,
1421 height: SLmillimeter,
1422 depth: SLmillimeter,
1423 ) -> SLresult,
1424 >,
1425 pub GetSize: ::std::option::Option<
1426 unsafe extern "C" fn(
1427 self_: SL3DMacroscopicItf,
1428 pWidth: *mut SLmillimeter,
1429 pHeight: *mut SLmillimeter,
1430 pDepth: *mut SLmillimeter,
1431 ) -> SLresult,
1432 >,
1433 pub SetOrientationAngles: ::std::option::Option<
1434 unsafe extern "C" fn(
1435 self_: SL3DMacroscopicItf,
1436 heading: SLmillidegree,
1437 pitch: SLmillidegree,
1438 roll: SLmillidegree,
1439 ) -> SLresult,
1440 >,
1441 pub SetOrientationVectors: ::std::option::Option<
1442 unsafe extern "C" fn(
1443 self_: SL3DMacroscopicItf,
1444 pFront: *const SLVec3D,
1445 pAbove: *const SLVec3D,
1446 ) -> SLresult,
1447 >,
1448 pub Rotate: ::std::option::Option<
1449 unsafe extern "C" fn(
1450 self_: SL3DMacroscopicItf,
1451 theta: SLmillidegree,
1452 pAxis: *const SLVec3D,
1453 ) -> SLresult,
1454 >,
1455 pub GetOrientationVectors: ::std::option::Option<
1456 unsafe extern "C" fn(self_: SL3DMacroscopicItf, pFront: *mut SLVec3D, pUp: *mut SLVec3D)
1457 -> SLresult,
1458 >,
1459}
1460extern "C" {
1461 pub static mut SL_IID_MUTESOLO: SLInterfaceID;
1462}
1463pub type SLMuteSoloItf = *const *const SLMuteSoloItf_;
1464#[repr(C)]
1465#[derive(Debug, Copy, Clone)]
1466pub struct SLMuteSoloItf_ {
1467 pub SetChannelMute: ::std::option::Option<
1468 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, mute: SLboolean) -> SLresult,
1469 >,
1470 pub GetChannelMute: ::std::option::Option<
1471 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, pMute: *mut SLboolean)
1472 -> SLresult,
1473 >,
1474 pub SetChannelSolo: ::std::option::Option<
1475 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, solo: SLboolean) -> SLresult,
1476 >,
1477 pub GetChannelSolo: ::std::option::Option<
1478 unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, pSolo: *mut SLboolean)
1479 -> SLresult,
1480 >,
1481 pub GetNumChannels: ::std::option::Option<
1482 unsafe extern "C" fn(self_: SLMuteSoloItf, pNumChannels: *mut SLuint8) -> SLresult,
1483 >,
1484}
1485extern "C" {
1486 pub static mut SL_IID_DYNAMICINTERFACEMANAGEMENT: SLInterfaceID;
1487}
1488pub type SLDynamicInterfaceManagementItf = *const *const SLDynamicInterfaceManagementItf_;
1489pub type slDynamicInterfaceManagementCallback = ::std::option::Option<
1490 unsafe extern "C" fn(
1491 caller: SLDynamicInterfaceManagementItf,
1492 pContext: *mut ::std::os::raw::c_void,
1493 event: SLuint32,
1494 result: SLresult,
1495 iid: SLInterfaceID,
1496 ),
1497>;
1498#[repr(C)]
1499#[derive(Debug, Copy, Clone)]
1500pub struct SLDynamicInterfaceManagementItf_ {
1501 pub AddInterface: ::std::option::Option<
1502 unsafe extern "C" fn(
1503 self_: SLDynamicInterfaceManagementItf,
1504 iid: SLInterfaceID,
1505 async: SLboolean,
1506 ) -> SLresult,
1507 >,
1508 pub RemoveInterface: ::std::option::Option<
1509 unsafe extern "C" fn(self_: SLDynamicInterfaceManagementItf, iid: SLInterfaceID)
1510 -> SLresult,
1511 >,
1512 pub ResumeInterface: ::std::option::Option<
1513 unsafe extern "C" fn(
1514 self_: SLDynamicInterfaceManagementItf,
1515 iid: SLInterfaceID,
1516 async: SLboolean,
1517 ) -> SLresult,
1518 >,
1519 pub RegisterCallback: ::std::option::Option<
1520 unsafe extern "C" fn(
1521 self_: SLDynamicInterfaceManagementItf,
1522 callback: slDynamicInterfaceManagementCallback,
1523 pContext: *mut ::std::os::raw::c_void,
1524 ) -> SLresult,
1525 >,
1526}
1527extern "C" {
1528 pub static mut SL_IID_MIDIMESSAGE: SLInterfaceID;
1529}
1530pub type SLMIDIMessageItf = *const *const SLMIDIMessageItf_;
1531pub type slMetaEventCallback = ::std::option::Option<
1532 unsafe extern "C" fn(
1533 caller: SLMIDIMessageItf,
1534 pContext: *mut ::std::os::raw::c_void,
1535 type_: SLuint8,
1536 length: SLuint32,
1537 pData: *const SLuint8,
1538 tick: SLuint32,
1539 track: SLuint16,
1540 ),
1541>;
1542pub type slMIDIMessageCallback = ::std::option::Option<
1543 unsafe extern "C" fn(
1544 caller: SLMIDIMessageItf,
1545 pContext: *mut ::std::os::raw::c_void,
1546 statusByte: SLuint8,
1547 length: SLuint32,
1548 pData: *const SLuint8,
1549 tick: SLuint32,
1550 track: SLuint16,
1551 ),
1552>;
1553#[repr(C)]
1554#[derive(Debug, Copy, Clone)]
1555pub struct SLMIDIMessageItf_ {
1556 pub SendMessage: ::std::option::Option<
1557 unsafe extern "C" fn(self_: SLMIDIMessageItf, data: *const SLuint8, length: SLuint32)
1558 -> SLresult,
1559 >,
1560 pub RegisterMetaEventCallback: ::std::option::Option<
1561 unsafe extern "C" fn(
1562 self_: SLMIDIMessageItf,
1563 callback: slMetaEventCallback,
1564 pContext: *mut ::std::os::raw::c_void,
1565 ) -> SLresult,
1566 >,
1567 pub RegisterMIDIMessageCallback: ::std::option::Option<
1568 unsafe extern "C" fn(
1569 self_: SLMIDIMessageItf,
1570 callback: slMIDIMessageCallback,
1571 pContext: *mut ::std::os::raw::c_void,
1572 ) -> SLresult,
1573 >,
1574 pub AddMIDIMessageCallbackFilter: ::std::option::Option<
1575 unsafe extern "C" fn(self_: SLMIDIMessageItf, messageType: SLuint32) -> SLresult,
1576 >,
1577 pub ClearMIDIMessageCallbackFilter:
1578 ::std::option::Option<unsafe extern "C" fn(self_: SLMIDIMessageItf) -> SLresult>,
1579}
1580extern "C" {
1581 pub static mut SL_IID_MIDIMUTESOLO: SLInterfaceID;
1582}
1583pub type SLMIDIMuteSoloItf = *const *const SLMIDIMuteSoloItf_;
1584#[repr(C)]
1585#[derive(Debug, Copy, Clone)]
1586pub struct SLMIDIMuteSoloItf_ {
1587 pub SetChannelMute: ::std::option::Option<
1588 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, channel: SLuint8, mute: SLboolean)
1589 -> SLresult,
1590 >,
1591 pub GetChannelMute: ::std::option::Option<
1592 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, channel: SLuint8, pMute: *mut SLboolean)
1593 -> SLresult,
1594 >,
1595 pub SetChannelSolo: ::std::option::Option<
1596 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, channel: SLuint8, solo: SLboolean)
1597 -> SLresult,
1598 >,
1599 pub GetChannelSolo: ::std::option::Option<
1600 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, channel: SLuint8, pSolo: *mut SLboolean)
1601 -> SLresult,
1602 >,
1603 pub GetTrackCount: ::std::option::Option<
1604 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, pCount: *mut SLuint16) -> SLresult,
1605 >,
1606 pub SetTrackMute: ::std::option::Option<
1607 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, track: SLuint16, mute: SLboolean)
1608 -> SLresult,
1609 >,
1610 pub GetTrackMute: ::std::option::Option<
1611 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, track: SLuint16, pMute: *mut SLboolean)
1612 -> SLresult,
1613 >,
1614 pub SetTrackSolo: ::std::option::Option<
1615 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, track: SLuint16, solo: SLboolean)
1616 -> SLresult,
1617 >,
1618 pub GetTrackSolo: ::std::option::Option<
1619 unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, track: SLuint16, pSolo: *mut SLboolean)
1620 -> SLresult,
1621 >,
1622}
1623extern "C" {
1624 pub static mut SL_IID_MIDITEMPO: SLInterfaceID;
1625}
1626pub type SLMIDITempoItf = *const *const SLMIDITempoItf_;
1627#[repr(C)]
1628#[derive(Debug, Copy, Clone)]
1629pub struct SLMIDITempoItf_ {
1630 pub SetTicksPerQuarterNote: ::std::option::Option<
1631 unsafe extern "C" fn(self_: SLMIDITempoItf, tpqn: SLuint32) -> SLresult,
1632 >,
1633 pub GetTicksPerQuarterNote: ::std::option::Option<
1634 unsafe extern "C" fn(self_: SLMIDITempoItf, pTpqn: *mut SLuint32) -> SLresult,
1635 >,
1636 pub SetMicrosecondsPerQuarterNote: ::std::option::Option<
1637 unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: SLmicrosecond) -> SLresult,
1638 >,
1639 pub GetMicrosecondsPerQuarterNote: ::std::option::Option<
1640 unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: *mut SLmicrosecond) -> SLresult,
1641 >,
1642}
1643extern "C" {
1644 pub static mut SL_IID_MIDITIME: SLInterfaceID;
1645}
1646pub type SLMIDITimeItf = *const *const SLMIDITimeItf_;
1647#[repr(C)]
1648#[derive(Debug, Copy, Clone)]
1649pub struct SLMIDITimeItf_ {
1650 pub GetDuration: ::std::option::Option<
1651 unsafe extern "C" fn(self_: SLMIDITimeItf, pDuration: *mut SLuint32) -> SLresult,
1652 >,
1653 pub SetPosition: ::std::option::Option<
1654 unsafe extern "C" fn(self_: SLMIDITimeItf, position: SLuint32) -> SLresult,
1655 >,
1656 pub GetPosition: ::std::option::Option<
1657 unsafe extern "C" fn(self_: SLMIDITimeItf, pPosition: *mut SLuint32) -> SLresult,
1658 >,
1659 pub SetLoopPoints: ::std::option::Option<
1660 unsafe extern "C" fn(self_: SLMIDITimeItf, startTick: SLuint32, numTicks: SLuint32)
1661 -> SLresult,
1662 >,
1663 pub GetLoopPoints: ::std::option::Option<
1664 unsafe extern "C" fn(
1665 self_: SLMIDITimeItf,
1666 pStartTick: *mut SLuint32,
1667 pNumTicks: *mut SLuint32,
1668 ) -> SLresult,
1669 >,
1670}
1671#[repr(C)]
1672#[derive(Debug, Copy, Clone)]
1673pub struct SLAudioCodecDescriptor_ {
1674 pub maxChannels: SLuint32,
1675 pub minBitsPerSample: SLuint32,
1676 pub maxBitsPerSample: SLuint32,
1677 pub minSampleRate: SLmilliHertz,
1678 pub maxSampleRate: SLmilliHertz,
1679 pub isFreqRangeContinuous: SLboolean,
1680 pub pSampleRatesSupported: *mut SLmilliHertz,
1681 pub numSampleRatesSupported: SLuint32,
1682 pub minBitRate: SLuint32,
1683 pub maxBitRate: SLuint32,
1684 pub isBitrateRangeContinuous: SLboolean,
1685 pub pBitratesSupported: *mut SLuint32,
1686 pub numBitratesSupported: SLuint32,
1687 pub profileSetting: SLuint32,
1688 pub modeSetting: SLuint32,
1689}
1690pub type SLAudioCodecDescriptor = SLAudioCodecDescriptor_;
1691#[repr(C)]
1692#[derive(Debug, Copy, Clone)]
1693pub struct SLAudioCodecProfileMode_ {
1694 pub profileSetting: SLuint32,
1695 pub modeSetting: SLuint32,
1696}
1697pub type SLAudioCodecProfileMode = SLAudioCodecProfileMode_;
1698extern "C" {
1699 pub static mut SL_IID_AUDIODECODERCAPABILITIES: SLInterfaceID;
1700}
1701pub type SLAudioDecoderCapabilitiesItf = *const *const SLAudioDecoderCapabilitiesItf_;
1702#[repr(C)]
1703#[derive(Debug, Copy, Clone)]
1704pub struct SLAudioDecoderCapabilitiesItf_ {
1705 pub GetAudioDecoders: ::std::option::Option<
1706 unsafe extern "C" fn(
1707 self_: SLAudioDecoderCapabilitiesItf,
1708 pNumDecoders: *mut SLuint32,
1709 pDecoderIds: *mut SLuint32,
1710 ) -> SLresult,
1711 >,
1712 pub GetAudioDecoderCapabilities: ::std::option::Option<
1713 unsafe extern "C" fn(
1714 self_: SLAudioDecoderCapabilitiesItf,
1715 decoderId: SLuint32,
1716 pIndex: *mut SLuint32,
1717 pDescriptor: *mut SLAudioCodecDescriptor,
1718 ) -> SLresult,
1719 >,
1720}
1721#[repr(C)]
1722#[derive(Debug, Copy, Clone)]
1723pub struct SLAudioEncoderSettings_ {
1724 pub encoderId: SLuint32,
1725 pub channelsIn: SLuint32,
1726 pub channelsOut: SLuint32,
1727 pub sampleRate: SLmilliHertz,
1728 pub bitRate: SLuint32,
1729 pub bitsPerSample: SLuint32,
1730 pub rateControl: SLuint32,
1731 pub profileSetting: SLuint32,
1732 pub levelSetting: SLuint32,
1733 pub channelMode: SLuint32,
1734 pub streamFormat: SLuint32,
1735 pub encodeOptions: SLuint32,
1736 pub blockAlignment: SLuint32,
1737}
1738pub type SLAudioEncoderSettings = SLAudioEncoderSettings_;
1739extern "C" {
1740 pub static mut SL_IID_AUDIOENCODERCAPABILITIES: SLInterfaceID;
1741}
1742pub type SLAudioEncoderCapabilitiesItf = *const *const SLAudioEncoderCapabilitiesItf_;
1743#[repr(C)]
1744#[derive(Debug, Copy, Clone)]
1745pub struct SLAudioEncoderCapabilitiesItf_ {
1746 pub GetAudioEncoders: ::std::option::Option<
1747 unsafe extern "C" fn(
1748 self_: SLAudioEncoderCapabilitiesItf,
1749 pNumEncoders: *mut SLuint32,
1750 pEncoderIds: *mut SLuint32,
1751 ) -> SLresult,
1752 >,
1753 pub GetAudioEncoderCapabilities: ::std::option::Option<
1754 unsafe extern "C" fn(
1755 self_: SLAudioEncoderCapabilitiesItf,
1756 encoderId: SLuint32,
1757 pIndex: *mut SLuint32,
1758 pDescriptor: *mut SLAudioCodecDescriptor,
1759 ) -> SLresult,
1760 >,
1761}
1762extern "C" {
1763 pub static mut SL_IID_AUDIOENCODER: SLInterfaceID;
1764}
1765pub type SLAudioEncoderItf = *const *const SLAudioEncoderItf_;
1766#[repr(C)]
1767#[derive(Debug, Copy, Clone)]
1768pub struct SLAudioEncoderItf_ {
1769 pub SetEncoderSettings: ::std::option::Option<
1770 unsafe extern "C" fn(self_: SLAudioEncoderItf, pSettings: *mut SLAudioEncoderSettings)
1771 -> SLresult,
1772 >,
1773 pub GetEncoderSettings: ::std::option::Option<
1774 unsafe extern "C" fn(self_: SLAudioEncoderItf, pSettings: *mut SLAudioEncoderSettings)
1775 -> SLresult,
1776 >,
1777}
1778extern "C" {
1779 pub static mut SL_IID_BASSBOOST: SLInterfaceID;
1780}
1781pub type SLBassBoostItf = *const *const SLBassBoostItf_;
1782#[repr(C)]
1783#[derive(Debug, Copy, Clone)]
1784pub struct SLBassBoostItf_ {
1785 pub SetEnabled: ::std::option::Option<
1786 unsafe extern "C" fn(self_: SLBassBoostItf, enabled: SLboolean) -> SLresult,
1787 >,
1788 pub IsEnabled: ::std::option::Option<
1789 unsafe extern "C" fn(self_: SLBassBoostItf, pEnabled: *mut SLboolean) -> SLresult,
1790 >,
1791 pub SetStrength: ::std::option::Option<
1792 unsafe extern "C" fn(self_: SLBassBoostItf, strength: SLpermille) -> SLresult,
1793 >,
1794 pub GetRoundedStrength: ::std::option::Option<
1795 unsafe extern "C" fn(self_: SLBassBoostItf, pStrength: *mut SLpermille) -> SLresult,
1796 >,
1797 pub IsStrengthSupported: ::std::option::Option<
1798 unsafe extern "C" fn(self_: SLBassBoostItf, pSupported: *mut SLboolean) -> SLresult,
1799 >,
1800}
1801extern "C" {
1802 pub static mut SL_IID_PITCH: SLInterfaceID;
1803}
1804pub type SLPitchItf = *const *const SLPitchItf_;
1805#[repr(C)]
1806#[derive(Debug, Copy, Clone)]
1807pub struct SLPitchItf_ {
1808 pub SetPitch: ::std::option::Option<
1809 unsafe extern "C" fn(self_: SLPitchItf, pitch: SLpermille) -> SLresult,
1810 >,
1811 pub GetPitch: ::std::option::Option<
1812 unsafe extern "C" fn(self_: SLPitchItf, pPitch: *mut SLpermille) -> SLresult,
1813 >,
1814 pub GetPitchCapabilities: ::std::option::Option<
1815 unsafe extern "C" fn(
1816 self_: SLPitchItf,
1817 pMinPitch: *mut SLpermille,
1818 pMaxPitch: *mut SLpermille,
1819 ) -> SLresult,
1820 >,
1821}
1822extern "C" {
1823 pub static mut SL_IID_RATEPITCH: SLInterfaceID;
1824}
1825pub type SLRatePitchItf = *const *const SLRatePitchItf_;
1826#[repr(C)]
1827#[derive(Debug, Copy, Clone)]
1828pub struct SLRatePitchItf_ {
1829 pub SetRate: ::std::option::Option<
1830 unsafe extern "C" fn(self_: SLRatePitchItf, rate: SLpermille) -> SLresult,
1831 >,
1832 pub GetRate: ::std::option::Option<
1833 unsafe extern "C" fn(self_: SLRatePitchItf, pRate: *mut SLpermille) -> SLresult,
1834 >,
1835 pub GetRatePitchCapabilities: ::std::option::Option<
1836 unsafe extern "C" fn(
1837 self_: SLRatePitchItf,
1838 pMinRate: *mut SLpermille,
1839 pMaxRate: *mut SLpermille,
1840 ) -> SLresult,
1841 >,
1842}
1843extern "C" {
1844 pub static mut SL_IID_VIRTUALIZER: SLInterfaceID;
1845}
1846pub type SLVirtualizerItf = *const *const SLVirtualizerItf_;
1847#[repr(C)]
1848#[derive(Debug, Copy, Clone)]
1849pub struct SLVirtualizerItf_ {
1850 pub SetEnabled: ::std::option::Option<
1851 unsafe extern "C" fn(self_: SLVirtualizerItf, enabled: SLboolean) -> SLresult,
1852 >,
1853 pub IsEnabled: ::std::option::Option<
1854 unsafe extern "C" fn(self_: SLVirtualizerItf, pEnabled: *mut SLboolean) -> SLresult,
1855 >,
1856 pub SetStrength: ::std::option::Option<
1857 unsafe extern "C" fn(self_: SLVirtualizerItf, strength: SLpermille) -> SLresult,
1858 >,
1859 pub GetRoundedStrength: ::std::option::Option<
1860 unsafe extern "C" fn(self_: SLVirtualizerItf, pStrength: *mut SLpermille) -> SLresult,
1861 >,
1862 pub IsStrengthSupported: ::std::option::Option<
1863 unsafe extern "C" fn(self_: SLVirtualizerItf, pSupported: *mut SLboolean) -> SLresult,
1864 >,
1865}
1866extern "C" {
1867 pub static mut SL_IID_VISUALIZATION: SLInterfaceID;
1868}
1869pub type SLVisualizationItf = *const *const SLVisualizationItf_;
1870pub type slVisualizationCallback = ::std::option::Option<
1871 unsafe extern "C" fn(
1872 pContext: *mut ::std::os::raw::c_void,
1873 waveform: *const SLuint8,
1874 fft: *const SLuint8,
1875 samplerate: SLmilliHertz,
1876 ),
1877>;
1878#[repr(C)]
1879#[derive(Debug, Copy, Clone)]
1880pub struct SLVisualizationItf_ {
1881 pub RegisterVisualizationCallback: ::std::option::Option<
1882 unsafe extern "C" fn(
1883 self_: SLVisualizationItf,
1884 callback: slVisualizationCallback,
1885 pContext: *mut ::std::os::raw::c_void,
1886 rate: SLmilliHertz,
1887 ) -> SLresult,
1888 >,
1889 pub GetMaxRate: ::std::option::Option<
1890 unsafe extern "C" fn(self_: SLVisualizationItf, pRate: *mut SLmilliHertz) -> SLresult,
1891 >,
1892}
1893extern "C" {
1894 pub static mut SL_IID_ENGINE: SLInterfaceID;
1895}
1896pub type SLEngineItf = *const *const SLEngineItf_;
1897#[repr(C)]
1898#[derive(Debug, Copy, Clone)]
1899pub struct SLEngineItf_ {
1900 pub CreateLEDDevice: ::std::option::Option<
1901 unsafe extern "C" fn(
1902 self_: SLEngineItf,
1903 pDevice: *mut SLObjectItf,
1904 deviceID: SLuint32,
1905 numInterfaces: SLuint32,
1906 pInterfaceIds: *const SLInterfaceID,
1907 pInterfaceRequired: *const SLboolean,
1908 ) -> SLresult,
1909 >,
1910 pub CreateVibraDevice: ::std::option::Option<
1911 unsafe extern "C" fn(
1912 self_: SLEngineItf,
1913 pDevice: *mut SLObjectItf,
1914 deviceID: SLuint32,
1915 numInterfaces: SLuint32,
1916 pInterfaceIds: *const SLInterfaceID,
1917 pInterfaceRequired: *const SLboolean,
1918 ) -> SLresult,
1919 >,
1920 pub CreateAudioPlayer: ::std::option::Option<
1921 unsafe extern "C" fn(
1922 self_: SLEngineItf,
1923 pPlayer: *mut SLObjectItf,
1924 pAudioSrc: *mut SLDataSource,
1925 pAudioSnk: *mut SLDataSink,
1926 numInterfaces: SLuint32,
1927 pInterfaceIds: *const SLInterfaceID,
1928 pInterfaceRequired: *const SLboolean,
1929 ) -> SLresult,
1930 >,
1931 pub CreateAudioRecorder: ::std::option::Option<
1932 unsafe extern "C" fn(
1933 self_: SLEngineItf,
1934 pRecorder: *mut SLObjectItf,
1935 pAudioSrc: *mut SLDataSource,
1936 pAudioSnk: *mut SLDataSink,
1937 numInterfaces: SLuint32,
1938 pInterfaceIds: *const SLInterfaceID,
1939 pInterfaceRequired: *const SLboolean,
1940 ) -> SLresult,
1941 >,
1942 pub CreateMidiPlayer: ::std::option::Option<
1943 unsafe extern "C" fn(
1944 self_: SLEngineItf,
1945 pPlayer: *mut SLObjectItf,
1946 pMIDISrc: *mut SLDataSource,
1947 pBankSrc: *mut SLDataSource,
1948 pAudioOutput: *mut SLDataSink,
1949 pVibra: *mut SLDataSink,
1950 pLEDArray: *mut SLDataSink,
1951 numInterfaces: SLuint32,
1952 pInterfaceIds: *const SLInterfaceID,
1953 pInterfaceRequired: *const SLboolean,
1954 ) -> SLresult,
1955 >,
1956 pub CreateListener: ::std::option::Option<
1957 unsafe extern "C" fn(
1958 self_: SLEngineItf,
1959 pListener: *mut SLObjectItf,
1960 numInterfaces: SLuint32,
1961 pInterfaceIds: *const SLInterfaceID,
1962 pInterfaceRequired: *const SLboolean,
1963 ) -> SLresult,
1964 >,
1965 pub Create3DGroup: ::std::option::Option<
1966 unsafe extern "C" fn(
1967 self_: SLEngineItf,
1968 pGroup: *mut SLObjectItf,
1969 numInterfaces: SLuint32,
1970 pInterfaceIds: *const SLInterfaceID,
1971 pInterfaceRequired: *const SLboolean,
1972 ) -> SLresult,
1973 >,
1974 pub CreateOutputMix: ::std::option::Option<
1975 unsafe extern "C" fn(
1976 self_: SLEngineItf,
1977 pMix: *mut SLObjectItf,
1978 numInterfaces: SLuint32,
1979 pInterfaceIds: *const SLInterfaceID,
1980 pInterfaceRequired: *const SLboolean,
1981 ) -> SLresult,
1982 >,
1983 pub CreateMetadataExtractor: ::std::option::Option<
1984 unsafe extern "C" fn(
1985 self_: SLEngineItf,
1986 pMetadataExtractor: *mut SLObjectItf,
1987 pDataSource: *mut SLDataSource,
1988 numInterfaces: SLuint32,
1989 pInterfaceIds: *const SLInterfaceID,
1990 pInterfaceRequired: *const SLboolean,
1991 ) -> SLresult,
1992 >,
1993 pub CreateExtensionObject: ::std::option::Option<
1994 unsafe extern "C" fn(
1995 self_: SLEngineItf,
1996 pObject: *mut SLObjectItf,
1997 pParameters: *mut ::std::os::raw::c_void,
1998 objectID: SLuint32,
1999 numInterfaces: SLuint32,
2000 pInterfaceIds: *const SLInterfaceID,
2001 pInterfaceRequired: *const SLboolean,
2002 ) -> SLresult,
2003 >,
2004 pub QueryNumSupportedInterfaces: ::std::option::Option<
2005 unsafe extern "C" fn(
2006 self_: SLEngineItf,
2007 objectID: SLuint32,
2008 pNumSupportedInterfaces: *mut SLuint32,
2009 ) -> SLresult,
2010 >,
2011 pub QuerySupportedInterfaces: ::std::option::Option<
2012 unsafe extern "C" fn(
2013 self_: SLEngineItf,
2014 objectID: SLuint32,
2015 index: SLuint32,
2016 pInterfaceId: *mut SLInterfaceID,
2017 ) -> SLresult,
2018 >,
2019 pub QueryNumSupportedExtensions: ::std::option::Option<
2020 unsafe extern "C" fn(self_: SLEngineItf, pNumExtensions: *mut SLuint32) -> SLresult,
2021 >,
2022 pub QuerySupportedExtension: ::std::option::Option<
2023 unsafe extern "C" fn(
2024 self_: SLEngineItf,
2025 index: SLuint32,
2026 pExtensionName: *mut SLchar,
2027 pNameLength: *mut SLint16,
2028 ) -> SLresult,
2029 >,
2030 pub IsExtensionSupported: ::std::option::Option<
2031 unsafe extern "C" fn(
2032 self_: SLEngineItf,
2033 pExtensionName: *const SLchar,
2034 pSupported: *mut SLboolean,
2035 ) -> SLresult,
2036 >,
2037}
2038extern "C" {
2039 pub static mut SL_IID_ENGINECAPABILITIES: SLInterfaceID;
2040}
2041pub type SLEngineCapabilitiesItf = *const *const SLEngineCapabilitiesItf_;
2042#[repr(C)]
2043#[derive(Debug, Copy, Clone)]
2044pub struct SLEngineCapabilitiesItf_ {
2045 pub QuerySupportedProfiles: ::std::option::Option<
2046 unsafe extern "C" fn(self_: SLEngineCapabilitiesItf, pProfilesSupported: *mut SLuint16)
2047 -> SLresult,
2048 >,
2049 pub QueryAvailableVoices: ::std::option::Option<
2050 unsafe extern "C" fn(
2051 self_: SLEngineCapabilitiesItf,
2052 voiceType: SLuint16,
2053 pNumMaxVoices: *mut SLint16,
2054 pIsAbsoluteMax: *mut SLboolean,
2055 pNumFreeVoices: *mut SLint16,
2056 ) -> SLresult,
2057 >,
2058 pub QueryNumberOfMIDISynthesizers: ::std::option::Option<
2059 unsafe extern "C" fn(self_: SLEngineCapabilitiesItf, pNumMIDIsynthesizers: *mut SLint16)
2060 -> SLresult,
2061 >,
2062 pub QueryAPIVersion: ::std::option::Option<
2063 unsafe extern "C" fn(
2064 self_: SLEngineCapabilitiesItf,
2065 pMajor: *mut SLint16,
2066 pMinor: *mut SLint16,
2067 pStep: *mut SLint16,
2068 ) -> SLresult,
2069 >,
2070 pub QueryLEDCapabilities: ::std::option::Option<
2071 unsafe extern "C" fn(
2072 self_: SLEngineCapabilitiesItf,
2073 pIndex: *mut SLuint32,
2074 pLEDDeviceID: *mut SLuint32,
2075 pDescriptor: *mut SLLEDDescriptor,
2076 ) -> SLresult,
2077 >,
2078 pub QueryVibraCapabilities: ::std::option::Option<
2079 unsafe extern "C" fn(
2080 self_: SLEngineCapabilitiesItf,
2081 pIndex: *mut SLuint32,
2082 pVibraDeviceID: *mut SLuint32,
2083 pDescriptor: *mut SLVibraDescriptor,
2084 ) -> SLresult,
2085 >,
2086 pub IsThreadSafe: ::std::option::Option<
2087 unsafe extern "C" fn(self_: SLEngineCapabilitiesItf, pIsThreadSafe: *mut SLboolean)
2088 -> SLresult,
2089 >,
2090}
2091extern "C" {
2092 pub static mut SL_IID_THREADSYNC: SLInterfaceID;
2093}
2094pub type SLThreadSyncItf = *const *const SLThreadSyncItf_;
2095#[repr(C)]
2096#[derive(Debug, Copy, Clone)]
2097pub struct SLThreadSyncItf_ {
2098 pub EnterCriticalSection:
2099 ::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
2100 pub ExitCriticalSection:
2101 ::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
2102}
2103#[repr(C)]
2104#[derive(Debug, Copy, Clone)]
2105pub struct SLEngineOption_ {
2106 pub feature: SLuint32,
2107 pub data: SLuint32,
2108}
2109pub type SLEngineOption = SLEngineOption_;
2110extern "C" {
2111 pub fn slCreateEngine(
2112 pEngine: *mut SLObjectItf,
2113 numOptions: SLuint32,
2114 pEngineOptions: *const SLEngineOption,
2115 numInterfaces: SLuint32,
2116 pInterfaceIds: *const SLInterfaceID,
2117 pInterfaceRequired: *const SLboolean,
2118 ) -> SLresult;
2119}
2120extern "C" {
2121 pub fn slQueryNumSupportedEngineInterfaces(pNumSupportedInterfaces: *mut SLuint32) -> SLresult;
2122}
2123extern "C" {
2124 pub fn slQuerySupportedEngineInterfaces(
2125 index: SLuint32,
2126 pInterfaceId: *mut SLInterfaceID,
2127 ) -> SLresult;
2128}
2129pub type va_list = __builtin_va_list;
2130pub type __gnuc_va_list = __builtin_va_list;
2131pub type __u_char = ::std::os::raw::c_uchar;
2132pub type __u_short = ::std::os::raw::c_ushort;
2133pub type __u_int = ::std::os::raw::c_uint;
2134pub type __u_long = ::std::os::raw::c_ulong;
2135pub type __int8_t = ::std::os::raw::c_schar;
2136pub type __uint8_t = ::std::os::raw::c_uchar;
2137pub type __int16_t = ::std::os::raw::c_short;
2138pub type __uint16_t = ::std::os::raw::c_ushort;
2139pub type __int32_t = ::std::os::raw::c_int;
2140pub type __uint32_t = ::std::os::raw::c_uint;
2141pub type __int64_t = ::std::os::raw::c_longlong;
2142pub type __uint64_t = ::std::os::raw::c_ulonglong;
2143pub type __int_least8_t = __int8_t;
2144pub type __uint_least8_t = __uint8_t;
2145pub type __int_least16_t = __int16_t;
2146pub type __uint_least16_t = __uint16_t;
2147pub type __int_least32_t = __int32_t;
2148pub type __uint_least32_t = __uint32_t;
2149pub type __int_least64_t = __int64_t;
2150pub type __uint_least64_t = __uint64_t;
2151pub type __quad_t = ::std::os::raw::c_longlong;
2152pub type __u_quad_t = ::std::os::raw::c_ulonglong;
2153pub type __intmax_t = ::std::os::raw::c_longlong;
2154pub type __uintmax_t = ::std::os::raw::c_ulonglong;
2155pub type __dev_t = __u_quad_t;
2156pub type __uid_t = ::std::os::raw::c_uint;
2157pub type __gid_t = ::std::os::raw::c_uint;
2158pub type __ino_t = ::std::os::raw::c_ulong;
2159pub type __ino64_t = __u_quad_t;
2160pub type __mode_t = ::std::os::raw::c_uint;
2161pub type __nlink_t = ::std::os::raw::c_uint;
2162pub type __off_t = ::std::os::raw::c_long;
2163pub type __off64_t = __quad_t;
2164pub type __pid_t = ::std::os::raw::c_int;
2165#[repr(C)]
2166#[derive(Debug, Copy, Clone)]
2167pub struct __fsid_t {
2168 pub __val: [::std::os::raw::c_int; 2usize],
2169}
2170pub type __clock_t = ::std::os::raw::c_long;
2171pub type __rlim_t = ::std::os::raw::c_ulong;
2172pub type __rlim64_t = __u_quad_t;
2173pub type __id_t = ::std::os::raw::c_uint;
2174pub type __time_t = ::std::os::raw::c_long;
2175pub type __useconds_t = ::std::os::raw::c_uint;
2176pub type __suseconds_t = ::std::os::raw::c_long;
2177pub type __daddr_t = ::std::os::raw::c_int;
2178pub type __key_t = ::std::os::raw::c_int;
2179pub type __clockid_t = ::std::os::raw::c_int;
2180pub type __timer_t = *mut ::std::os::raw::c_void;
2181pub type __blksize_t = ::std::os::raw::c_long;
2182pub type __blkcnt_t = ::std::os::raw::c_long;
2183pub type __blkcnt64_t = __quad_t;
2184pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
2185pub type __fsblkcnt64_t = __u_quad_t;
2186pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
2187pub type __fsfilcnt64_t = __u_quad_t;
2188pub type __fsword_t = ::std::os::raw::c_int;
2189pub type __ssize_t = ::std::os::raw::c_int;
2190pub type __syscall_slong_t = ::std::os::raw::c_long;
2191pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
2192pub type __loff_t = __off64_t;
2193pub type __caddr_t = *mut ::std::os::raw::c_char;
2194pub type __intptr_t = ::std::os::raw::c_int;
2195pub type __socklen_t = ::std::os::raw::c_uint;
2196pub type __sig_atomic_t = ::std::os::raw::c_int;
2197pub type int_least8_t = __int_least8_t;
2198pub type int_least16_t = __int_least16_t;
2199pub type int_least32_t = __int_least32_t;
2200pub type int_least64_t = __int_least64_t;
2201pub type uint_least8_t = __uint_least8_t;
2202pub type uint_least16_t = __uint_least16_t;
2203pub type uint_least32_t = __uint_least32_t;
2204pub type uint_least64_t = __uint_least64_t;
2205pub type int_fast8_t = ::std::os::raw::c_schar;
2206pub type int_fast16_t = ::std::os::raw::c_int;
2207pub type int_fast32_t = ::std::os::raw::c_int;
2208pub type int_fast64_t = ::std::os::raw::c_longlong;
2209pub type uint_fast8_t = ::std::os::raw::c_uchar;
2210pub type uint_fast16_t = ::std::os::raw::c_uint;
2211pub type uint_fast32_t = ::std::os::raw::c_uint;
2212pub type uint_fast64_t = ::std::os::raw::c_ulonglong;
2213pub type intmax_t = __intmax_t;
2214pub type uintmax_t = __uintmax_t;
2215pub type jboolean = u8;
2216pub type jbyte = i8;
2217pub type jchar = u16;
2218pub type jshort = i16;
2219pub type jint = i32;
2220pub type jlong = i64;
2221pub type jfloat = f32;
2222pub type jdouble = f64;
2223pub type jsize = jint;
2224pub type jobject = *mut ::std::os::raw::c_void;
2225pub type jclass = jobject;
2226pub type jstring = jobject;
2227pub type jarray = jobject;
2228pub type jobjectArray = jarray;
2229pub type jbooleanArray = jarray;
2230pub type jbyteArray = jarray;
2231pub type jcharArray = jarray;
2232pub type jshortArray = jarray;
2233pub type jintArray = jarray;
2234pub type jlongArray = jarray;
2235pub type jfloatArray = jarray;
2236pub type jdoubleArray = jarray;
2237pub type jthrowable = jobject;
2238pub type jweak = jobject;
2239#[repr(C)]
2240#[derive(Debug, Copy, Clone)]
2241pub struct _jfieldID {
2242 _unused: [u8; 0],
2243}
2244pub type jfieldID = *mut _jfieldID;
2245#[repr(C)]
2246#[derive(Debug, Copy, Clone)]
2247pub struct _jmethodID {
2248 _unused: [u8; 0],
2249}
2250pub type jmethodID = *mut _jmethodID;
2251#[repr(C)]
2252#[derive(Copy, Clone)]
2253pub union jvalue {
2254 pub z: jboolean,
2255 pub b: jbyte,
2256 pub c: jchar,
2257 pub s: jshort,
2258 pub i: jint,
2259 pub j: jlong,
2260 pub f: jfloat,
2261 pub d: jdouble,
2262 pub l: jobject,
2263 _bindgen_union_align: u64,
2264}
2265pub const jobjectRefType_JNIInvalidRefType: jobjectRefType = 0;
2266pub const jobjectRefType_JNILocalRefType: jobjectRefType = 1;
2267pub const jobjectRefType_JNIGlobalRefType: jobjectRefType = 2;
2268pub const jobjectRefType_JNIWeakGlobalRefType: jobjectRefType = 3;
2269pub type jobjectRefType = u32;
2270#[repr(C)]
2271#[derive(Debug, Copy, Clone)]
2272pub struct JNINativeMethod {
2273 pub name: *const ::std::os::raw::c_char,
2274 pub signature: *const ::std::os::raw::c_char,
2275 pub fnPtr: *mut ::std::os::raw::c_void,
2276}
2277pub type C_JNIEnv = *const JNINativeInterface;
2278pub type JNIEnv = *const JNINativeInterface;
2279pub type JavaVM = *const JNIInvokeInterface;
2280#[repr(C)]
2281#[derive(Debug, Copy, Clone)]
2282pub struct JNINativeInterface {
2283 pub reserved0: *mut ::std::os::raw::c_void,
2284 pub reserved1: *mut ::std::os::raw::c_void,
2285 pub reserved2: *mut ::std::os::raw::c_void,
2286 pub reserved3: *mut ::std::os::raw::c_void,
2287 pub GetVersion: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jint>,
2288 pub DefineClass: ::std::option::Option<
2289 unsafe extern "C" fn(
2290 arg1: *mut JNIEnv,
2291 arg2: *const ::std::os::raw::c_char,
2292 arg3: jobject,
2293 arg4: *const jbyte,
2294 arg5: jsize,
2295 ) -> jclass,
2296 >,
2297 pub FindClass: ::std::option::Option<
2298 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char) -> jclass,
2299 >,
2300 pub FromReflectedMethod:
2301 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jmethodID>,
2302 pub FromReflectedField:
2303 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jfieldID>,
2304 pub ToReflectedMethod: ::std::option::Option<
2305 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: jboolean)
2306 -> jobject,
2307 >,
2308 pub GetSuperclass:
2309 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jclass>,
2310 pub IsAssignableFrom: ::std::option::Option<
2311 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jclass) -> jboolean,
2312 >,
2313 pub ToReflectedField: ::std::option::Option<
2314 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jboolean)
2315 -> jobject,
2316 >,
2317 pub Throw:
2318 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jthrowable) -> jint>,
2319 pub ThrowNew: ::std::option::Option<
2320 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: *const ::std::os::raw::c_char)
2321 -> jint,
2322 >,
2323 pub ExceptionOccurred:
2324 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jthrowable>,
2325 pub ExceptionDescribe: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv)>,
2326 pub ExceptionClear: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv)>,
2327 pub FatalError: ::std::option::Option<
2328 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char),
2329 >,
2330 pub PushLocalFrame:
2331 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jint) -> jint>,
2332 pub PopLocalFrame:
2333 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
2334 pub NewGlobalRef:
2335 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
2336 pub DeleteGlobalRef:
2337 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject)>,
2338 pub DeleteLocalRef:
2339 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject)>,
2340 pub IsSameObject: ::std::option::Option<
2341 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jobject) -> jboolean,
2342 >,
2343 pub NewLocalRef:
2344 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
2345 pub EnsureLocalCapacity:
2346 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jint) -> jint>,
2347 pub AllocObject:
2348 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jobject>,
2349 pub NewObject: ::std::option::Option<
2350 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jobject,
2351 >,
2352 pub NewObjectV: ::std::option::Option<
2353 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2354 -> jobject,
2355 >,
2356 pub NewObjectA: ::std::option::Option<
2357 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2358 -> jobject,
2359 >,
2360 pub GetObjectClass:
2361 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jclass>,
2362 pub IsInstanceOf: ::std::option::Option<
2363 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass) -> jboolean,
2364 >,
2365 pub GetMethodID: ::std::option::Option<
2366 unsafe extern "C" fn(
2367 arg1: *mut JNIEnv,
2368 arg2: jclass,
2369 arg3: *const ::std::os::raw::c_char,
2370 arg4: *const ::std::os::raw::c_char,
2371 ) -> jmethodID,
2372 >,
2373 pub CallObjectMethod: ::std::option::Option<
2374 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jobject,
2375 >,
2376 pub CallObjectMethodV: ::std::option::Option<
2377 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2378 -> jobject,
2379 >,
2380 pub CallObjectMethodA: ::std::option::Option<
2381 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2382 -> jobject,
2383 >,
2384 pub CallBooleanMethod: ::std::option::Option<
2385 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jboolean,
2386 >,
2387 pub CallBooleanMethodV: ::std::option::Option<
2388 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2389 -> jboolean,
2390 >,
2391 pub CallBooleanMethodA: ::std::option::Option<
2392 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2393 -> jboolean,
2394 >,
2395 pub CallByteMethod: ::std::option::Option<
2396 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jbyte,
2397 >,
2398 pub CallByteMethodV: ::std::option::Option<
2399 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2400 -> jbyte,
2401 >,
2402 pub CallByteMethodA: ::std::option::Option<
2403 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2404 -> jbyte,
2405 >,
2406 pub CallCharMethod: ::std::option::Option<
2407 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jchar,
2408 >,
2409 pub CallCharMethodV: ::std::option::Option<
2410 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2411 -> jchar,
2412 >,
2413 pub CallCharMethodA: ::std::option::Option<
2414 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2415 -> jchar,
2416 >,
2417 pub CallShortMethod: ::std::option::Option<
2418 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jshort,
2419 >,
2420 pub CallShortMethodV: ::std::option::Option<
2421 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2422 -> jshort,
2423 >,
2424 pub CallShortMethodA: ::std::option::Option<
2425 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2426 -> jshort,
2427 >,
2428 pub CallIntMethod: ::std::option::Option<
2429 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jint,
2430 >,
2431 pub CallIntMethodV: ::std::option::Option<
2432 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2433 -> jint,
2434 >,
2435 pub CallIntMethodA: ::std::option::Option<
2436 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2437 -> jint,
2438 >,
2439 pub CallLongMethod: ::std::option::Option<
2440 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jlong,
2441 >,
2442 pub CallLongMethodV: ::std::option::Option<
2443 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2444 -> jlong,
2445 >,
2446 pub CallLongMethodA: ::std::option::Option<
2447 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2448 -> jlong,
2449 >,
2450 pub CallFloatMethod: ::std::option::Option<
2451 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jfloat,
2452 >,
2453 pub CallFloatMethodV: ::std::option::Option<
2454 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2455 -> jfloat,
2456 >,
2457 pub CallFloatMethodA: ::std::option::Option<
2458 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2459 -> jfloat,
2460 >,
2461 pub CallDoubleMethod: ::std::option::Option<
2462 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jdouble,
2463 >,
2464 pub CallDoubleMethodV: ::std::option::Option<
2465 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list)
2466 -> jdouble,
2467 >,
2468 pub CallDoubleMethodA: ::std::option::Option<
2469 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue)
2470 -> jdouble,
2471 >,
2472 pub CallVoidMethod: ::std::option::Option<
2473 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...),
2474 >,
2475 pub CallVoidMethodV: ::std::option::Option<
2476 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list),
2477 >,
2478 pub CallVoidMethodA: ::std::option::Option<
2479 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: *mut jvalue),
2480 >,
2481 pub CallNonvirtualObjectMethod: ::std::option::Option<
2482 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2483 -> jobject,
2484 >,
2485 pub CallNonvirtualObjectMethodV: ::std::option::Option<
2486 unsafe extern "C" fn(
2487 arg1: *mut JNIEnv,
2488 arg2: jobject,
2489 arg3: jclass,
2490 arg4: jmethodID,
2491 arg5: va_list,
2492 ) -> jobject,
2493 >,
2494 pub CallNonvirtualObjectMethodA: ::std::option::Option<
2495 unsafe extern "C" fn(
2496 arg1: *mut JNIEnv,
2497 arg2: jobject,
2498 arg3: jclass,
2499 arg4: jmethodID,
2500 arg5: *mut jvalue,
2501 ) -> jobject,
2502 >,
2503 pub CallNonvirtualBooleanMethod: ::std::option::Option<
2504 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2505 -> jboolean,
2506 >,
2507 pub CallNonvirtualBooleanMethodV: ::std::option::Option<
2508 unsafe extern "C" fn(
2509 arg1: *mut JNIEnv,
2510 arg2: jobject,
2511 arg3: jclass,
2512 arg4: jmethodID,
2513 arg5: va_list,
2514 ) -> jboolean,
2515 >,
2516 pub CallNonvirtualBooleanMethodA: ::std::option::Option<
2517 unsafe extern "C" fn(
2518 arg1: *mut JNIEnv,
2519 arg2: jobject,
2520 arg3: jclass,
2521 arg4: jmethodID,
2522 arg5: *mut jvalue,
2523 ) -> jboolean,
2524 >,
2525 pub CallNonvirtualByteMethod: ::std::option::Option<
2526 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2527 -> jbyte,
2528 >,
2529 pub CallNonvirtualByteMethodV: ::std::option::Option<
2530 unsafe extern "C" fn(
2531 arg1: *mut JNIEnv,
2532 arg2: jobject,
2533 arg3: jclass,
2534 arg4: jmethodID,
2535 arg5: va_list,
2536 ) -> jbyte,
2537 >,
2538 pub CallNonvirtualByteMethodA: ::std::option::Option<
2539 unsafe extern "C" fn(
2540 arg1: *mut JNIEnv,
2541 arg2: jobject,
2542 arg3: jclass,
2543 arg4: jmethodID,
2544 arg5: *mut jvalue,
2545 ) -> jbyte,
2546 >,
2547 pub CallNonvirtualCharMethod: ::std::option::Option<
2548 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2549 -> jchar,
2550 >,
2551 pub CallNonvirtualCharMethodV: ::std::option::Option<
2552 unsafe extern "C" fn(
2553 arg1: *mut JNIEnv,
2554 arg2: jobject,
2555 arg3: jclass,
2556 arg4: jmethodID,
2557 arg5: va_list,
2558 ) -> jchar,
2559 >,
2560 pub CallNonvirtualCharMethodA: ::std::option::Option<
2561 unsafe extern "C" fn(
2562 arg1: *mut JNIEnv,
2563 arg2: jobject,
2564 arg3: jclass,
2565 arg4: jmethodID,
2566 arg5: *mut jvalue,
2567 ) -> jchar,
2568 >,
2569 pub CallNonvirtualShortMethod: ::std::option::Option<
2570 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2571 -> jshort,
2572 >,
2573 pub CallNonvirtualShortMethodV: ::std::option::Option<
2574 unsafe extern "C" fn(
2575 arg1: *mut JNIEnv,
2576 arg2: jobject,
2577 arg3: jclass,
2578 arg4: jmethodID,
2579 arg5: va_list,
2580 ) -> jshort,
2581 >,
2582 pub CallNonvirtualShortMethodA: ::std::option::Option<
2583 unsafe extern "C" fn(
2584 arg1: *mut JNIEnv,
2585 arg2: jobject,
2586 arg3: jclass,
2587 arg4: jmethodID,
2588 arg5: *mut jvalue,
2589 ) -> jshort,
2590 >,
2591 pub CallNonvirtualIntMethod: ::std::option::Option<
2592 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2593 -> jint,
2594 >,
2595 pub CallNonvirtualIntMethodV: ::std::option::Option<
2596 unsafe extern "C" fn(
2597 arg1: *mut JNIEnv,
2598 arg2: jobject,
2599 arg3: jclass,
2600 arg4: jmethodID,
2601 arg5: va_list,
2602 ) -> jint,
2603 >,
2604 pub CallNonvirtualIntMethodA: ::std::option::Option<
2605 unsafe extern "C" fn(
2606 arg1: *mut JNIEnv,
2607 arg2: jobject,
2608 arg3: jclass,
2609 arg4: jmethodID,
2610 arg5: *mut jvalue,
2611 ) -> jint,
2612 >,
2613 pub CallNonvirtualLongMethod: ::std::option::Option<
2614 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2615 -> jlong,
2616 >,
2617 pub CallNonvirtualLongMethodV: ::std::option::Option<
2618 unsafe extern "C" fn(
2619 arg1: *mut JNIEnv,
2620 arg2: jobject,
2621 arg3: jclass,
2622 arg4: jmethodID,
2623 arg5: va_list,
2624 ) -> jlong,
2625 >,
2626 pub CallNonvirtualLongMethodA: ::std::option::Option<
2627 unsafe extern "C" fn(
2628 arg1: *mut JNIEnv,
2629 arg2: jobject,
2630 arg3: jclass,
2631 arg4: jmethodID,
2632 arg5: *mut jvalue,
2633 ) -> jlong,
2634 >,
2635 pub CallNonvirtualFloatMethod: ::std::option::Option<
2636 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2637 -> jfloat,
2638 >,
2639 pub CallNonvirtualFloatMethodV: ::std::option::Option<
2640 unsafe extern "C" fn(
2641 arg1: *mut JNIEnv,
2642 arg2: jobject,
2643 arg3: jclass,
2644 arg4: jmethodID,
2645 arg5: va_list,
2646 ) -> jfloat,
2647 >,
2648 pub CallNonvirtualFloatMethodA: ::std::option::Option<
2649 unsafe extern "C" fn(
2650 arg1: *mut JNIEnv,
2651 arg2: jobject,
2652 arg3: jclass,
2653 arg4: jmethodID,
2654 arg5: *mut jvalue,
2655 ) -> jfloat,
2656 >,
2657 pub CallNonvirtualDoubleMethod: ::std::option::Option<
2658 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...)
2659 -> jdouble,
2660 >,
2661 pub CallNonvirtualDoubleMethodV: ::std::option::Option<
2662 unsafe extern "C" fn(
2663 arg1: *mut JNIEnv,
2664 arg2: jobject,
2665 arg3: jclass,
2666 arg4: jmethodID,
2667 arg5: va_list,
2668 ) -> jdouble,
2669 >,
2670 pub CallNonvirtualDoubleMethodA: ::std::option::Option<
2671 unsafe extern "C" fn(
2672 arg1: *mut JNIEnv,
2673 arg2: jobject,
2674 arg3: jclass,
2675 arg4: jmethodID,
2676 arg5: *mut jvalue,
2677 ) -> jdouble,
2678 >,
2679 pub CallNonvirtualVoidMethod: ::std::option::Option<
2680 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...),
2681 >,
2682 pub CallNonvirtualVoidMethodV: ::std::option::Option<
2683 unsafe extern "C" fn(
2684 arg1: *mut JNIEnv,
2685 arg2: jobject,
2686 arg3: jclass,
2687 arg4: jmethodID,
2688 arg5: va_list,
2689 ),
2690 >,
2691 pub CallNonvirtualVoidMethodA: ::std::option::Option<
2692 unsafe extern "C" fn(
2693 arg1: *mut JNIEnv,
2694 arg2: jobject,
2695 arg3: jclass,
2696 arg4: jmethodID,
2697 arg5: *mut jvalue,
2698 ),
2699 >,
2700 pub GetFieldID: ::std::option::Option<
2701 unsafe extern "C" fn(
2702 arg1: *mut JNIEnv,
2703 arg2: jclass,
2704 arg3: *const ::std::os::raw::c_char,
2705 arg4: *const ::std::os::raw::c_char,
2706 ) -> jfieldID,
2707 >,
2708 pub GetObjectField: ::std::option::Option<
2709 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jobject,
2710 >,
2711 pub GetBooleanField: ::std::option::Option<
2712 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jboolean,
2713 >,
2714 pub GetByteField: ::std::option::Option<
2715 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jbyte,
2716 >,
2717 pub GetCharField: ::std::option::Option<
2718 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jchar,
2719 >,
2720 pub GetShortField: ::std::option::Option<
2721 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jshort,
2722 >,
2723 pub GetIntField: ::std::option::Option<
2724 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jint,
2725 >,
2726 pub GetLongField: ::std::option::Option<
2727 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jlong,
2728 >,
2729 pub GetFloatField: ::std::option::Option<
2730 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jfloat,
2731 >,
2732 pub GetDoubleField: ::std::option::Option<
2733 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jdouble,
2734 >,
2735 pub SetObjectField: ::std::option::Option<
2736 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jobject),
2737 >,
2738 pub SetBooleanField: ::std::option::Option<
2739 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jboolean),
2740 >,
2741 pub SetByteField: ::std::option::Option<
2742 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jbyte),
2743 >,
2744 pub SetCharField: ::std::option::Option<
2745 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jchar),
2746 >,
2747 pub SetShortField: ::std::option::Option<
2748 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jshort),
2749 >,
2750 pub SetIntField: ::std::option::Option<
2751 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jint),
2752 >,
2753 pub SetLongField: ::std::option::Option<
2754 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jlong),
2755 >,
2756 pub SetFloatField: ::std::option::Option<
2757 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jfloat),
2758 >,
2759 pub SetDoubleField: ::std::option::Option<
2760 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jdouble),
2761 >,
2762 pub GetStaticMethodID: ::std::option::Option<
2763 unsafe extern "C" fn(
2764 arg1: *mut JNIEnv,
2765 arg2: jclass,
2766 arg3: *const ::std::os::raw::c_char,
2767 arg4: *const ::std::os::raw::c_char,
2768 ) -> jmethodID,
2769 >,
2770 pub CallStaticObjectMethod: ::std::option::Option<
2771 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jobject,
2772 >,
2773 pub CallStaticObjectMethodV: ::std::option::Option<
2774 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2775 -> jobject,
2776 >,
2777 pub CallStaticObjectMethodA: ::std::option::Option<
2778 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2779 -> jobject,
2780 >,
2781 pub CallStaticBooleanMethod: ::std::option::Option<
2782 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jboolean,
2783 >,
2784 pub CallStaticBooleanMethodV: ::std::option::Option<
2785 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2786 -> jboolean,
2787 >,
2788 pub CallStaticBooleanMethodA: ::std::option::Option<
2789 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2790 -> jboolean,
2791 >,
2792 pub CallStaticByteMethod: ::std::option::Option<
2793 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jbyte,
2794 >,
2795 pub CallStaticByteMethodV: ::std::option::Option<
2796 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2797 -> jbyte,
2798 >,
2799 pub CallStaticByteMethodA: ::std::option::Option<
2800 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2801 -> jbyte,
2802 >,
2803 pub CallStaticCharMethod: ::std::option::Option<
2804 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jchar,
2805 >,
2806 pub CallStaticCharMethodV: ::std::option::Option<
2807 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2808 -> jchar,
2809 >,
2810 pub CallStaticCharMethodA: ::std::option::Option<
2811 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2812 -> jchar,
2813 >,
2814 pub CallStaticShortMethod: ::std::option::Option<
2815 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jshort,
2816 >,
2817 pub CallStaticShortMethodV: ::std::option::Option<
2818 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2819 -> jshort,
2820 >,
2821 pub CallStaticShortMethodA: ::std::option::Option<
2822 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2823 -> jshort,
2824 >,
2825 pub CallStaticIntMethod: ::std::option::Option<
2826 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jint,
2827 >,
2828 pub CallStaticIntMethodV: ::std::option::Option<
2829 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2830 -> jint,
2831 >,
2832 pub CallStaticIntMethodA: ::std::option::Option<
2833 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2834 -> jint,
2835 >,
2836 pub CallStaticLongMethod: ::std::option::Option<
2837 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jlong,
2838 >,
2839 pub CallStaticLongMethodV: ::std::option::Option<
2840 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2841 -> jlong,
2842 >,
2843 pub CallStaticLongMethodA: ::std::option::Option<
2844 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2845 -> jlong,
2846 >,
2847 pub CallStaticFloatMethod: ::std::option::Option<
2848 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jfloat,
2849 >,
2850 pub CallStaticFloatMethodV: ::std::option::Option<
2851 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2852 -> jfloat,
2853 >,
2854 pub CallStaticFloatMethodA: ::std::option::Option<
2855 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2856 -> jfloat,
2857 >,
2858 pub CallStaticDoubleMethod: ::std::option::Option<
2859 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jdouble,
2860 >,
2861 pub CallStaticDoubleMethodV: ::std::option::Option<
2862 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list)
2863 -> jdouble,
2864 >,
2865 pub CallStaticDoubleMethodA: ::std::option::Option<
2866 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue)
2867 -> jdouble,
2868 >,
2869 pub CallStaticVoidMethod: ::std::option::Option<
2870 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...),
2871 >,
2872 pub CallStaticVoidMethodV: ::std::option::Option<
2873 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list),
2874 >,
2875 pub CallStaticVoidMethodA: ::std::option::Option<
2876 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *mut jvalue),
2877 >,
2878 pub GetStaticFieldID: ::std::option::Option<
2879 unsafe extern "C" fn(
2880 arg1: *mut JNIEnv,
2881 arg2: jclass,
2882 arg3: *const ::std::os::raw::c_char,
2883 arg4: *const ::std::os::raw::c_char,
2884 ) -> jfieldID,
2885 >,
2886 pub GetStaticObjectField: ::std::option::Option<
2887 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jobject,
2888 >,
2889 pub GetStaticBooleanField: ::std::option::Option<
2890 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jboolean,
2891 >,
2892 pub GetStaticByteField: ::std::option::Option<
2893 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jbyte,
2894 >,
2895 pub GetStaticCharField: ::std::option::Option<
2896 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jchar,
2897 >,
2898 pub GetStaticShortField: ::std::option::Option<
2899 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jshort,
2900 >,
2901 pub GetStaticIntField: ::std::option::Option<
2902 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jint,
2903 >,
2904 pub GetStaticLongField: ::std::option::Option<
2905 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jlong,
2906 >,
2907 pub GetStaticFloatField: ::std::option::Option<
2908 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jfloat,
2909 >,
2910 pub GetStaticDoubleField: ::std::option::Option<
2911 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jdouble,
2912 >,
2913 pub SetStaticObjectField: ::std::option::Option<
2914 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jobject),
2915 >,
2916 pub SetStaticBooleanField: ::std::option::Option<
2917 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jboolean),
2918 >,
2919 pub SetStaticByteField: ::std::option::Option<
2920 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jbyte),
2921 >,
2922 pub SetStaticCharField: ::std::option::Option<
2923 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jchar),
2924 >,
2925 pub SetStaticShortField: ::std::option::Option<
2926 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jshort),
2927 >,
2928 pub SetStaticIntField: ::std::option::Option<
2929 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jint),
2930 >,
2931 pub SetStaticLongField: ::std::option::Option<
2932 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jlong),
2933 >,
2934 pub SetStaticFloatField: ::std::option::Option<
2935 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jfloat),
2936 >,
2937 pub SetStaticDoubleField: ::std::option::Option<
2938 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jdouble),
2939 >,
2940 pub NewString: ::std::option::Option<
2941 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const jchar, arg3: jsize) -> jstring,
2942 >,
2943 pub GetStringLength:
2944 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring) -> jsize>,
2945 pub GetStringChars: ::std::option::Option<
2946 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *mut jboolean) -> *const jchar,
2947 >,
2948 pub ReleaseStringChars: ::std::option::Option<
2949 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const jchar),
2950 >,
2951 pub NewStringUTF: ::std::option::Option<
2952 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char) -> jstring,
2953 >,
2954 pub GetStringUTFLength:
2955 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring) -> jsize>,
2956 pub GetStringUTFChars: ::std::option::Option<
2957 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *mut jboolean)
2958 -> *const ::std::os::raw::c_char,
2959 >,
2960 pub ReleaseStringUTFChars: ::std::option::Option<
2961 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const ::std::os::raw::c_char),
2962 >,
2963 pub GetArrayLength:
2964 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jarray) -> jsize>,
2965 pub NewObjectArray: ::std::option::Option<
2966 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize, arg3: jclass, arg4: jobject)
2967 -> jobjectArray,
2968 >,
2969 pub GetObjectArrayElement: ::std::option::Option<
2970 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobjectArray, arg3: jsize) -> jobject,
2971 >,
2972 pub SetObjectArrayElement: ::std::option::Option<
2973 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobjectArray, arg3: jsize, arg4: jobject),
2974 >,
2975 pub NewBooleanArray: ::std::option::Option<
2976 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jbooleanArray,
2977 >,
2978 pub NewByteArray:
2979 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jbyteArray>,
2980 pub NewCharArray:
2981 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jcharArray>,
2982 pub NewShortArray:
2983 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jshortArray>,
2984 pub NewIntArray:
2985 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jintArray>,
2986 pub NewLongArray:
2987 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jlongArray>,
2988 pub NewFloatArray:
2989 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jfloatArray>,
2990 pub NewDoubleArray:
2991 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jdoubleArray>,
2992 pub GetBooleanArrayElements: ::std::option::Option<
2993 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jbooleanArray, arg3: *mut jboolean)
2994 -> *mut jboolean,
2995 >,
2996 pub GetByteArrayElements: ::std::option::Option<
2997 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jbyteArray, arg3: *mut jboolean)
2998 -> *mut jbyte,
2999 >,
3000 pub GetCharArrayElements: ::std::option::Option<
3001 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jcharArray, arg3: *mut jboolean)
3002 -> *mut jchar,
3003 >,
3004 pub GetShortArrayElements: ::std::option::Option<
3005 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jshortArray, arg3: *mut jboolean)
3006 -> *mut jshort,
3007 >,
3008 pub GetIntArrayElements: ::std::option::Option<
3009 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jintArray, arg3: *mut jboolean) -> *mut jint,
3010 >,
3011 pub GetLongArrayElements: ::std::option::Option<
3012 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jlongArray, arg3: *mut jboolean)
3013 -> *mut jlong,
3014 >,
3015 pub GetFloatArrayElements: ::std::option::Option<
3016 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jfloatArray, arg3: *mut jboolean)
3017 -> *mut jfloat,
3018 >,
3019 pub GetDoubleArrayElements: ::std::option::Option<
3020 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jdoubleArray, arg3: *mut jboolean)
3021 -> *mut jdouble,
3022 >,
3023 pub ReleaseBooleanArrayElements: ::std::option::Option<
3024 unsafe extern "C" fn(
3025 arg1: *mut JNIEnv,
3026 arg2: jbooleanArray,
3027 arg3: *mut jboolean,
3028 arg4: jint,
3029 ),
3030 >,
3031 pub ReleaseByteArrayElements: ::std::option::Option<
3032 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jbyteArray, arg3: *mut jbyte, arg4: jint),
3033 >,
3034 pub ReleaseCharArrayElements: ::std::option::Option<
3035 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jcharArray, arg3: *mut jchar, arg4: jint),
3036 >,
3037 pub ReleaseShortArrayElements: ::std::option::Option<
3038 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jshortArray, arg3: *mut jshort, arg4: jint),
3039 >,
3040 pub ReleaseIntArrayElements: ::std::option::Option<
3041 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jintArray, arg3: *mut jint, arg4: jint),
3042 >,
3043 pub ReleaseLongArrayElements: ::std::option::Option<
3044 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jlongArray, arg3: *mut jlong, arg4: jint),
3045 >,
3046 pub ReleaseFloatArrayElements: ::std::option::Option<
3047 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jfloatArray, arg3: *mut jfloat, arg4: jint),
3048 >,
3049 pub ReleaseDoubleArrayElements: ::std::option::Option<
3050 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jdoubleArray, arg3: *mut jdouble, arg4: jint),
3051 >,
3052 pub GetBooleanArrayRegion: ::std::option::Option<
3053 unsafe extern "C" fn(
3054 arg1: *mut JNIEnv,
3055 arg2: jbooleanArray,
3056 arg3: jsize,
3057 arg4: jsize,
3058 arg5: *mut jboolean,
3059 ),
3060 >,
3061 pub GetByteArrayRegion: ::std::option::Option<
3062 unsafe extern "C" fn(
3063 arg1: *mut JNIEnv,
3064 arg2: jbyteArray,
3065 arg3: jsize,
3066 arg4: jsize,
3067 arg5: *mut jbyte,
3068 ),
3069 >,
3070 pub GetCharArrayRegion: ::std::option::Option<
3071 unsafe extern "C" fn(
3072 arg1: *mut JNIEnv,
3073 arg2: jcharArray,
3074 arg3: jsize,
3075 arg4: jsize,
3076 arg5: *mut jchar,
3077 ),
3078 >,
3079 pub GetShortArrayRegion: ::std::option::Option<
3080 unsafe extern "C" fn(
3081 arg1: *mut JNIEnv,
3082 arg2: jshortArray,
3083 arg3: jsize,
3084 arg4: jsize,
3085 arg5: *mut jshort,
3086 ),
3087 >,
3088 pub GetIntArrayRegion: ::std::option::Option<
3089 unsafe extern "C" fn(
3090 arg1: *mut JNIEnv,
3091 arg2: jintArray,
3092 arg3: jsize,
3093 arg4: jsize,
3094 arg5: *mut jint,
3095 ),
3096 >,
3097 pub GetLongArrayRegion: ::std::option::Option<
3098 unsafe extern "C" fn(
3099 arg1: *mut JNIEnv,
3100 arg2: jlongArray,
3101 arg3: jsize,
3102 arg4: jsize,
3103 arg5: *mut jlong,
3104 ),
3105 >,
3106 pub GetFloatArrayRegion: ::std::option::Option<
3107 unsafe extern "C" fn(
3108 arg1: *mut JNIEnv,
3109 arg2: jfloatArray,
3110 arg3: jsize,
3111 arg4: jsize,
3112 arg5: *mut jfloat,
3113 ),
3114 >,
3115 pub GetDoubleArrayRegion: ::std::option::Option<
3116 unsafe extern "C" fn(
3117 arg1: *mut JNIEnv,
3118 arg2: jdoubleArray,
3119 arg3: jsize,
3120 arg4: jsize,
3121 arg5: *mut jdouble,
3122 ),
3123 >,
3124 pub SetBooleanArrayRegion: ::std::option::Option<
3125 unsafe extern "C" fn(
3126 arg1: *mut JNIEnv,
3127 arg2: jbooleanArray,
3128 arg3: jsize,
3129 arg4: jsize,
3130 arg5: *const jboolean,
3131 ),
3132 >,
3133 pub SetByteArrayRegion: ::std::option::Option<
3134 unsafe extern "C" fn(
3135 arg1: *mut JNIEnv,
3136 arg2: jbyteArray,
3137 arg3: jsize,
3138 arg4: jsize,
3139 arg5: *const jbyte,
3140 ),
3141 >,
3142 pub SetCharArrayRegion: ::std::option::Option<
3143 unsafe extern "C" fn(
3144 arg1: *mut JNIEnv,
3145 arg2: jcharArray,
3146 arg3: jsize,
3147 arg4: jsize,
3148 arg5: *const jchar,
3149 ),
3150 >,
3151 pub SetShortArrayRegion: ::std::option::Option<
3152 unsafe extern "C" fn(
3153 arg1: *mut JNIEnv,
3154 arg2: jshortArray,
3155 arg3: jsize,
3156 arg4: jsize,
3157 arg5: *const jshort,
3158 ),
3159 >,
3160 pub SetIntArrayRegion: ::std::option::Option<
3161 unsafe extern "C" fn(
3162 arg1: *mut JNIEnv,
3163 arg2: jintArray,
3164 arg3: jsize,
3165 arg4: jsize,
3166 arg5: *const jint,
3167 ),
3168 >,
3169 pub SetLongArrayRegion: ::std::option::Option<
3170 unsafe extern "C" fn(
3171 arg1: *mut JNIEnv,
3172 arg2: jlongArray,
3173 arg3: jsize,
3174 arg4: jsize,
3175 arg5: *const jlong,
3176 ),
3177 >,
3178 pub SetFloatArrayRegion: ::std::option::Option<
3179 unsafe extern "C" fn(
3180 arg1: *mut JNIEnv,
3181 arg2: jfloatArray,
3182 arg3: jsize,
3183 arg4: jsize,
3184 arg5: *const jfloat,
3185 ),
3186 >,
3187 pub SetDoubleArrayRegion: ::std::option::Option<
3188 unsafe extern "C" fn(
3189 arg1: *mut JNIEnv,
3190 arg2: jdoubleArray,
3191 arg3: jsize,
3192 arg4: jsize,
3193 arg5: *const jdouble,
3194 ),
3195 >,
3196 pub RegisterNatives: ::std::option::Option<
3197 unsafe extern "C" fn(
3198 arg1: *mut JNIEnv,
3199 arg2: jclass,
3200 arg3: *const JNINativeMethod,
3201 arg4: jint,
3202 ) -> jint,
3203 >,
3204 pub UnregisterNatives:
3205 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jint>,
3206 pub MonitorEnter:
3207 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jint>,
3208 pub MonitorExit:
3209 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jint>,
3210 pub GetJavaVM: ::std::option::Option<
3211 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *mut *mut JavaVM) -> jint,
3212 >,
3213 pub GetStringRegion: ::std::option::Option<
3214 unsafe extern "C" fn(
3215 arg1: *mut JNIEnv,
3216 arg2: jstring,
3217 arg3: jsize,
3218 arg4: jsize,
3219 arg5: *mut jchar,
3220 ),
3221 >,
3222 pub GetStringUTFRegion: ::std::option::Option<
3223 unsafe extern "C" fn(
3224 arg1: *mut JNIEnv,
3225 arg2: jstring,
3226 arg3: jsize,
3227 arg4: jsize,
3228 arg5: *mut ::std::os::raw::c_char,
3229 ),
3230 >,
3231 pub GetPrimitiveArrayCritical: ::std::option::Option<
3232 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jarray, arg3: *mut jboolean)
3233 -> *mut ::std::os::raw::c_void,
3234 >,
3235 pub ReleasePrimitiveArrayCritical: ::std::option::Option<
3236 unsafe extern "C" fn(
3237 arg1: *mut JNIEnv,
3238 arg2: jarray,
3239 arg3: *mut ::std::os::raw::c_void,
3240 arg4: jint,
3241 ),
3242 >,
3243 pub GetStringCritical: ::std::option::Option<
3244 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *mut jboolean) -> *const jchar,
3245 >,
3246 pub ReleaseStringCritical: ::std::option::Option<
3247 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const jchar),
3248 >,
3249 pub NewWeakGlobalRef:
3250 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jweak>,
3251 pub DeleteWeakGlobalRef:
3252 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jweak)>,
3253 pub ExceptionCheck: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jboolean>,
3254 pub NewDirectByteBuffer: ::std::option::Option<
3255 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *mut ::std::os::raw::c_void, arg3: jlong)
3256 -> jobject,
3257 >,
3258 pub GetDirectBufferAddress: ::std::option::Option<
3259 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> *mut ::std::os::raw::c_void,
3260 >,
3261 pub GetDirectBufferCapacity:
3262 ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jlong>,
3263 pub GetObjectRefType: ::std::option::Option<
3264 unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobjectRefType,
3265 >,
3266}
3267#[repr(C)]
3268#[derive(Debug, Copy, Clone)]
3269pub struct _JNIEnv {
3270 pub functions: *const JNINativeInterface,
3271}
3272#[repr(C)]
3273#[derive(Debug, Copy, Clone)]
3274pub struct JNIInvokeInterface {
3275 pub reserved0: *mut ::std::os::raw::c_void,
3276 pub reserved1: *mut ::std::os::raw::c_void,
3277 pub reserved2: *mut ::std::os::raw::c_void,
3278 pub DestroyJavaVM: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JavaVM) -> jint>,
3279 pub AttachCurrentThread: ::std::option::Option<
3280 unsafe extern "C" fn(
3281 arg1: *mut JavaVM,
3282 arg2: *mut *mut JNIEnv,
3283 arg3: *mut ::std::os::raw::c_void,
3284 ) -> jint,
3285 >,
3286 pub DetachCurrentThread: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JavaVM) -> jint>,
3287 pub GetEnv: ::std::option::Option<
3288 unsafe extern "C" fn(arg1: *mut JavaVM, arg2: *mut *mut ::std::os::raw::c_void, arg3: jint)
3289 -> jint,
3290 >,
3291 pub AttachCurrentThreadAsDaemon: ::std::option::Option<
3292 unsafe extern "C" fn(
3293 arg1: *mut JavaVM,
3294 arg2: *mut *mut JNIEnv,
3295 arg3: *mut ::std::os::raw::c_void,
3296 ) -> jint,
3297 >,
3298}
3299#[repr(C)]
3300#[derive(Debug, Copy, Clone)]
3301pub struct _JavaVM {
3302 pub functions: *const JNIInvokeInterface,
3303}
3304#[repr(C)]
3305#[derive(Debug, Copy, Clone)]
3306pub struct JavaVMAttachArgs {
3307 pub version: jint,
3308 pub name: *const ::std::os::raw::c_char,
3309 pub group: jobject,
3310}
3311#[repr(C)]
3312#[derive(Debug, Copy, Clone)]
3313pub struct JavaVMOption {
3314 pub optionString: *const ::std::os::raw::c_char,
3315 pub extraInfo: *mut ::std::os::raw::c_void,
3316}
3317#[repr(C)]
3318#[derive(Debug, Copy, Clone)]
3319pub struct JavaVMInitArgs {
3320 pub version: jint,
3321 pub nOptions: jint,
3322 pub options: *mut JavaVMOption,
3323 pub ignoreUnrecognized: jboolean,
3324}
3325extern "C" {
3326 pub fn JNI_GetDefaultJavaVMInitArgs(arg1: *mut ::std::os::raw::c_void) -> jint;
3327}
3328extern "C" {
3329 pub fn JNI_CreateJavaVM(
3330 arg1: *mut *mut JavaVM,
3331 arg2: *mut *mut JNIEnv,
3332 arg3: *mut ::std::os::raw::c_void,
3333 ) -> jint;
3334}
3335extern "C" {
3336 pub fn JNI_GetCreatedJavaVMs(arg1: *mut *mut JavaVM, arg2: jsize, arg3: *mut jsize) -> jint;
3337}
3338extern "C" {
3339 pub fn JNI_OnLoad(vm: *mut JavaVM, reserved: *mut ::std::os::raw::c_void) -> jint;
3340}
3341extern "C" {
3342 pub fn JNI_OnUnload(vm: *mut JavaVM, reserved: *mut ::std::os::raw::c_void);
3343}
3344pub type SLAint64 = sl_int64_t;
3345pub type SLAuint64 = sl_uint64_t;
3346#[repr(C)]
3347#[derive(Debug, Copy, Clone)]
3348pub struct SLAndroidDataFormat_PCM_EX_ {
3349 pub formatType: SLuint32,
3350 pub numChannels: SLuint32,
3351 pub sampleRate: SLuint32,
3352 pub bitsPerSample: SLuint32,
3353 pub containerSize: SLuint32,
3354 pub channelMask: SLuint32,
3355 pub endianness: SLuint32,
3356 pub representation: SLuint32,
3357}
3358pub type SLAndroidDataFormat_PCM_EX = SLAndroidDataFormat_PCM_EX_;
3359extern "C" {
3360 pub static mut SL_IID_ANDROIDEFFECT: SLInterfaceID;
3361}
3362pub type SLAndroidEffectItf = *const *const SLAndroidEffectItf_;
3363#[repr(C)]
3365#[derive(Debug, Copy, Clone)]
3366pub struct SLAndroidEffectItf_ {
3367 pub CreateEffect: ::std::option::Option<
3368 unsafe extern "C" fn(self_: SLAndroidEffectItf, effectImplementationId: SLInterfaceID)
3369 -> SLresult,
3370 >,
3371 pub ReleaseEffect: ::std::option::Option<
3372 unsafe extern "C" fn(self_: SLAndroidEffectItf, effectImplementationId: SLInterfaceID)
3373 -> SLresult,
3374 >,
3375 pub SetEnabled: ::std::option::Option<
3376 unsafe extern "C" fn(
3377 self_: SLAndroidEffectItf,
3378 effectImplementationId: SLInterfaceID,
3379 enabled: SLboolean,
3380 ) -> SLresult,
3381 >,
3382 pub IsEnabled: ::std::option::Option<
3383 unsafe extern "C" fn(
3384 self_: SLAndroidEffectItf,
3385 effectImplementationId: SLInterfaceID,
3386 pEnabled: *mut SLboolean,
3387 ) -> SLresult,
3388 >,
3389 pub SendCommand: ::std::option::Option<
3390 unsafe extern "C" fn(
3391 self_: SLAndroidEffectItf,
3392 effectImplementationId: SLInterfaceID,
3393 command: SLuint32,
3394 commandSize: SLuint32,
3395 pCommandData: *mut ::std::os::raw::c_void,
3396 replySize: *mut SLuint32,
3397 pReplyData: *mut ::std::os::raw::c_void,
3398 ) -> SLresult,
3399 >,
3400}
3401extern "C" {
3402 pub static mut SL_IID_ANDROIDEFFECTSEND: SLInterfaceID;
3403}
3404pub type SLAndroidEffectSendItf = *const *const SLAndroidEffectSendItf_;
3405#[repr(C)]
3407#[derive(Debug, Copy, Clone)]
3408pub struct SLAndroidEffectSendItf_ {
3409 pub EnableEffectSend: ::std::option::Option<
3410 unsafe extern "C" fn(
3411 self_: SLAndroidEffectSendItf,
3412 effectImplementationId: SLInterfaceID,
3413 enable: SLboolean,
3414 initialLevel: SLmillibel,
3415 ) -> SLresult,
3416 >,
3417 pub IsEnabled: ::std::option::Option<
3418 unsafe extern "C" fn(
3419 self_: SLAndroidEffectSendItf,
3420 effectImplementationId: SLInterfaceID,
3421 pEnable: *mut SLboolean,
3422 ) -> SLresult,
3423 >,
3424 pub SetDirectLevel: ::std::option::Option<
3425 unsafe extern "C" fn(self_: SLAndroidEffectSendItf, directLevel: SLmillibel) -> SLresult,
3426 >,
3427 pub GetDirectLevel: ::std::option::Option<
3428 unsafe extern "C" fn(self_: SLAndroidEffectSendItf, pDirectLevel: *mut SLmillibel)
3429 -> SLresult,
3430 >,
3431 pub SetSendLevel: ::std::option::Option<
3432 unsafe extern "C" fn(
3433 self_: SLAndroidEffectSendItf,
3434 effectImplementationId: SLInterfaceID,
3435 sendLevel: SLmillibel,
3436 ) -> SLresult,
3437 >,
3438 pub GetSendLevel: ::std::option::Option<
3439 unsafe extern "C" fn(
3440 self_: SLAndroidEffectSendItf,
3441 effectImplementationId: SLInterfaceID,
3442 pSendLevel: *mut SLmillibel,
3443 ) -> SLresult,
3444 >,
3445}
3446extern "C" {
3447 pub static mut SL_IID_ANDROIDEFFECTCAPABILITIES: SLInterfaceID;
3448}
3449pub type SLAndroidEffectCapabilitiesItf = *const *const SLAndroidEffectCapabilitiesItf_;
3450#[repr(C)]
3452#[derive(Debug, Copy, Clone)]
3453pub struct SLAndroidEffectCapabilitiesItf_ {
3454 pub QueryNumEffects: ::std::option::Option<
3455 unsafe extern "C" fn(
3456 self_: SLAndroidEffectCapabilitiesItf,
3457 pNumSupportedEffects: *mut SLuint32,
3458 ) -> SLresult,
3459 >,
3460 pub QueryEffect: ::std::option::Option<
3461 unsafe extern "C" fn(
3462 self_: SLAndroidEffectCapabilitiesItf,
3463 index: SLuint32,
3464 pEffectType: *mut SLInterfaceID,
3465 pEffectImplementation: *mut SLInterfaceID,
3466 pName: *mut SLchar,
3467 pNameSize: *mut SLuint16,
3468 ) -> SLresult,
3469 >,
3470}
3471extern "C" {
3472 pub static mut SL_IID_ANDROIDCONFIGURATION: SLInterfaceID;
3473}
3474pub type SLAndroidConfigurationItf = *const *const SLAndroidConfigurationItf_;
3475#[repr(C)]
3477#[derive(Debug, Copy, Clone)]
3478pub struct SLAndroidConfigurationItf_ {
3479 pub SetConfiguration: ::std::option::Option<
3480 unsafe extern "C" fn(
3481 self_: SLAndroidConfigurationItf,
3482 configKey: *const SLchar,
3483 pConfigValue: *const ::std::os::raw::c_void,
3484 valueSize: SLuint32,
3485 ) -> SLresult,
3486 >,
3487 pub GetConfiguration: ::std::option::Option<
3488 unsafe extern "C" fn(
3489 self_: SLAndroidConfigurationItf,
3490 configKey: *const SLchar,
3491 pValueSize: *mut SLuint32,
3492 pConfigValue: *mut ::std::os::raw::c_void,
3493 ) -> SLresult,
3494 >,
3495 pub AcquireJavaProxy: ::std::option::Option<
3496 unsafe extern "C" fn(
3497 self_: SLAndroidConfigurationItf,
3498 proxyType: SLuint32,
3499 pProxyObj: *mut jobject,
3500 ) -> SLresult,
3501 >,
3502 pub ReleaseJavaProxy: ::std::option::Option<
3503 unsafe extern "C" fn(self_: SLAndroidConfigurationItf, proxyType: SLuint32) -> SLresult,
3504 >,
3505}
3506extern "C" {
3507 pub static mut SL_IID_ANDROIDSIMPLEBUFFERQUEUE: SLInterfaceID;
3508}
3509pub type SLAndroidSimpleBufferQueueItf = *const *const SLAndroidSimpleBufferQueueItf_;
3510pub type slAndroidSimpleBufferQueueCallback = ::std::option::Option<
3511 unsafe extern "C" fn(
3512 caller: SLAndroidSimpleBufferQueueItf,
3513 pContext: *mut ::std::os::raw::c_void,
3514 ),
3515>;
3516#[repr(C)]
3518#[derive(Debug, Copy, Clone)]
3519pub struct SLAndroidSimpleBufferQueueState_ {
3520 pub count: SLuint32,
3521 pub index: SLuint32,
3522}
3523pub type SLAndroidSimpleBufferQueueState = SLAndroidSimpleBufferQueueState_;
3524#[repr(C)]
3525#[derive(Debug, Copy, Clone)]
3526pub struct SLAndroidSimpleBufferQueueItf_ {
3527 pub Enqueue: ::std::option::Option<
3528 unsafe extern "C" fn(
3529 self_: SLAndroidSimpleBufferQueueItf,
3530 pBuffer: *const ::std::os::raw::c_void,
3531 size: SLuint32,
3532 ) -> SLresult,
3533 >,
3534 pub Clear: ::std::option::Option<
3535 unsafe extern "C" fn(self_: SLAndroidSimpleBufferQueueItf) -> SLresult,
3536 >,
3537 pub GetState: ::std::option::Option<
3538 unsafe extern "C" fn(
3539 self_: SLAndroidSimpleBufferQueueItf,
3540 pState: *mut SLAndroidSimpleBufferQueueState,
3541 ) -> SLresult,
3542 >,
3543 pub RegisterCallback: ::std::option::Option<
3544 unsafe extern "C" fn(
3545 self_: SLAndroidSimpleBufferQueueItf,
3546 callback: slAndroidSimpleBufferQueueCallback,
3547 pContext: *mut ::std::os::raw::c_void,
3548 ) -> SLresult,
3549 >,
3550}
3551extern "C" {
3552 pub static mut SL_IID_ANDROIDBUFFERQUEUESOURCE: SLInterfaceID;
3553}
3554pub type SLAndroidBufferQueueItf = *const *const SLAndroidBufferQueueItf_;
3555#[repr(C)]
3556#[derive(Debug)]
3557pub struct SLAndroidBufferItem_ {
3558 pub itemKey: SLuint32,
3559 pub itemSize: SLuint32,
3560 pub itemData: __IncompleteArrayField<SLuint8>,
3561}
3562pub type SLAndroidBufferItem = SLAndroidBufferItem_;
3563pub type slAndroidBufferQueueCallback = ::std::option::Option<
3564 unsafe extern "C" fn(
3565 caller: SLAndroidBufferQueueItf,
3566 pCallbackContext: *mut ::std::os::raw::c_void,
3567 pBufferContext: *mut ::std::os::raw::c_void,
3568 pBufferData: *mut ::std::os::raw::c_void,
3569 dataSize: SLuint32,
3570 dataUsed: SLuint32,
3571 pItems: *const SLAndroidBufferItem,
3572 itemsLength: SLuint32,
3573 ) -> SLresult,
3574>;
3575#[repr(C)]
3576#[derive(Debug, Copy, Clone)]
3577pub struct SLAndroidBufferQueueState_ {
3578 pub count: SLuint32,
3579 pub index: SLuint32,
3580}
3581pub type SLAndroidBufferQueueState = SLAndroidBufferQueueState_;
3582#[repr(C)]
3583#[derive(Debug, Copy, Clone)]
3584pub struct SLAndroidBufferQueueItf_ {
3585 pub RegisterCallback: ::std::option::Option<
3586 unsafe extern "C" fn(
3587 self_: SLAndroidBufferQueueItf,
3588 callback: slAndroidBufferQueueCallback,
3589 pCallbackContext: *mut ::std::os::raw::c_void,
3590 ) -> SLresult,
3591 >,
3592 pub Clear:
3593 ::std::option::Option<unsafe extern "C" fn(self_: SLAndroidBufferQueueItf) -> SLresult>,
3594 pub Enqueue: ::std::option::Option<
3595 unsafe extern "C" fn(
3596 self_: SLAndroidBufferQueueItf,
3597 pBufferContext: *mut ::std::os::raw::c_void,
3598 pData: *mut ::std::os::raw::c_void,
3599 dataLength: SLuint32,
3600 pItems: *const SLAndroidBufferItem,
3601 itemsLength: SLuint32,
3602 ) -> SLresult,
3603 >,
3604 pub GetState: ::std::option::Option<
3605 unsafe extern "C" fn(
3606 self_: SLAndroidBufferQueueItf,
3607 pState: *mut SLAndroidBufferQueueState,
3608 ) -> SLresult,
3609 >,
3610 pub SetCallbackEventsMask: ::std::option::Option<
3611 unsafe extern "C" fn(self_: SLAndroidBufferQueueItf, eventFlags: SLuint32) -> SLresult,
3612 >,
3613 pub GetCallbackEventsMask: ::std::option::Option<
3614 unsafe extern "C" fn(self_: SLAndroidBufferQueueItf, pEventFlags: *mut SLuint32)
3615 -> SLresult,
3616 >,
3617}
3618#[repr(C)]
3620#[derive(Debug, Copy, Clone)]
3621pub struct SLDataLocator_AndroidFD_ {
3622 pub locatorType: SLuint32,
3623 pub fd: SLint32,
3624 pub offset: SLAint64,
3625 pub length: SLAint64,
3626}
3627pub type SLDataLocator_AndroidFD = SLDataLocator_AndroidFD_;
3628#[repr(C)]
3630#[derive(Debug, Copy, Clone)]
3631pub struct SLDataLocator_AndroidSimpleBufferQueue {
3632 pub locatorType: SLuint32,
3633 pub numBuffers: SLuint32,
3634}
3635#[repr(C)]
3638#[derive(Debug, Copy, Clone)]
3639pub struct SLDataLocator_AndroidBufferQueue_ {
3640 pub locatorType: SLuint32,
3641 pub numBuffers: SLuint32,
3642}
3643pub type SLDataLocator_AndroidBufferQueue = SLDataLocator_AndroidBufferQueue_;
3644extern "C" {
3645 pub static mut SL_IID_ANDROIDACOUSTICECHOCANCELLATION: SLInterfaceID;
3646}
3647pub type SLAndroidAcousticEchoCancellationItf = *const *const SLAndroidAcousticEchoCancellationItf_;
3648#[repr(C)]
3649#[derive(Debug, Copy, Clone)]
3650pub struct SLAndroidAcousticEchoCancellationItf_ {
3651 pub SetEnabled: ::std::option::Option<
3652 unsafe extern "C" fn(self_: SLAndroidAcousticEchoCancellationItf, enabled: SLboolean)
3653 -> SLresult,
3654 >,
3655 pub IsEnabled: ::std::option::Option<
3656 unsafe extern "C" fn(self_: SLAndroidAcousticEchoCancellationItf, pEnabled: *mut SLboolean)
3657 -> SLresult,
3658 >,
3659}
3660extern "C" {
3661 pub static mut SL_IID_ANDROIDAUTOMATICGAINCONTROL: SLInterfaceID;
3662}
3663pub type SLAndroidAutomaticGainControlItf = *const *const SLAndroidAutomaticGainControlItf_;
3664#[repr(C)]
3665#[derive(Debug, Copy, Clone)]
3666pub struct SLAndroidAutomaticGainControlItf_ {
3667 pub SetEnabled: ::std::option::Option<
3668 unsafe extern "C" fn(self_: SLAndroidAutomaticGainControlItf, enabled: SLboolean)
3669 -> SLresult,
3670 >,
3671 pub IsEnabled: ::std::option::Option<
3672 unsafe extern "C" fn(self_: SLAndroidAutomaticGainControlItf, pEnabled: *mut SLboolean)
3673 -> SLresult,
3674 >,
3675}
3676extern "C" {
3677 pub static mut SL_IID_ANDROIDNOISESUPPRESSION: SLInterfaceID;
3678}
3679pub type SLAndroidNoiseSuppressionItf = *const *const SLAndroidNoiseSuppressionItf_;
3680#[repr(C)]
3681#[derive(Debug, Copy, Clone)]
3682pub struct SLAndroidNoiseSuppressionItf_ {
3683 pub SetEnabled: ::std::option::Option<
3684 unsafe extern "C" fn(self_: SLAndroidNoiseSuppressionItf, enabled: SLboolean) -> SLresult,
3685 >,
3686 pub IsEnabled: ::std::option::Option<
3687 unsafe extern "C" fn(self_: SLAndroidNoiseSuppressionItf, pEnabled: *mut SLboolean)
3688 -> SLresult,
3689 >,
3690}
3691pub type __builtin_va_list = __va_list;
3692#[repr(C)]
3693#[derive(Debug, Copy, Clone)]
3694pub struct __va_list {
3695 pub __ap: *mut ::std::os::raw::c_void,
3696}