#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
pub const KHRONOS_TITLE: &'static [u8; 13usize] = b"KhronosTitle\0";
pub const KHRONOS_ALBUM: &'static [u8; 13usize] = b"KhronosAlbum\0";
pub const KHRONOS_TRACK_NUMBER: &'static [u8; 19usize] = b"KhronosTrackNumber\0";
pub const KHRONOS_ARTIST: &'static [u8; 14usize] = b"KhronosArtist\0";
pub const KHRONOS_GENRE: &'static [u8; 13usize] = b"KhronosGenre\0";
pub const KHRONOS_YEAR: &'static [u8; 12usize] = b"KhronosYear\0";
pub const KHRONOS_COMMENT: &'static [u8; 15usize] = b"KhronosComment\0";
pub const KHRONOS_ARTIST_URL: &'static [u8; 17usize] = b"KhronosArtistURL\0";
pub const KHRONOS_CONTENT_URL: &'static [u8; 18usize] = b"KhronosContentURL\0";
pub const KHRONOS_RATING: &'static [u8; 14usize] = b"KhronosRating\0";
pub const KHRONOS_ALBUM_ART: &'static [u8; 16usize] = b"KhronosAlbumArt\0";
pub const KHRONOS_COPYRIGHT: &'static [u8; 17usize] = b"KhronosCopyright\0";
pub const SL_NODE_PARENT: u32 = 4294967295;
pub const ANDROID_KEY_PCMFORMAT_NUMCHANNELS: &'static [u8; 28usize] =
b"AndroidPcmFormatNumChannels\0";
pub const ANDROID_KEY_PCMFORMAT_SAMPLERATE: &'static [u8; 27usize] =
b"AndroidPcmFormatSampleRate\0";
pub const ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE: &'static [u8; 30usize] =
b"AndroidPcmFormatBitsPerSample\0";
pub const ANDROID_KEY_PCMFORMAT_CONTAINERSIZE: &'static [u8; 30usize] =
b"AndroidPcmFormatContainerSize\0";
pub const ANDROID_KEY_PCMFORMAT_CHANNELMASK: &'static [u8; 28usize] =
b"AndroidPcmFormatChannelMask\0";
pub const ANDROID_KEY_PCMFORMAT_ENDIANNESS: &'static [u8; 27usize] =
b"AndroidPcmFormatEndianness\0";
pub const __GNUC_VA_LIST: u32 = 1;
pub const __BIONIC__: u32 = 1;
pub const __WORDSIZE: u32 = 32;
pub const __bos_level: u32 = 0;
pub const __ANDROID_API_FUTURE__: u32 = 10000;
pub const __ANDROID_API__: u32 = 10000;
pub const __ANDROID_API_G__: u32 = 9;
pub const __ANDROID_API_I__: u32 = 14;
pub const __ANDROID_API_J__: u32 = 16;
pub const __ANDROID_API_J_MR1__: u32 = 17;
pub const __ANDROID_API_J_MR2__: u32 = 18;
pub const __ANDROID_API_K__: u32 = 19;
pub const __ANDROID_API_L__: u32 = 21;
pub const __ANDROID_API_L_MR1__: u32 = 22;
pub const __ANDROID_API_M__: u32 = 23;
pub const __ANDROID_API_N__: u32 = 24;
pub const __ANDROID_API_N_MR1__: u32 = 25;
pub const __ANDROID_API_O__: u32 = 26;
pub const __ANDROID_API_O_MR1__: u32 = 27;
pub const __ANDROID_API_P__: u32 = 28;
pub const __ANDROID_API_Q__: u32 = 29;
pub const __ANDROID_API_R__: u32 = 30;
pub const __NDK_MAJOR__: u32 = 21;
pub const __NDK_MINOR__: u32 = 1;
pub const __NDK_BETA__: u32 = 2;
pub const __NDK_BUILD__: u32 = 6273396;
pub const __NDK_CANARY__: u32 = 0;
pub const WCHAR_MIN: u8 = 0u8;
pub const INT8_MIN: i32 = -128;
pub const INT8_MAX: u32 = 127;
pub const INT_LEAST8_MIN: i32 = -128;
pub const INT_LEAST8_MAX: u32 = 127;
pub const INT_FAST8_MIN: i32 = -128;
pub const INT_FAST8_MAX: u32 = 127;
pub const UINT8_MAX: u32 = 255;
pub const UINT_LEAST8_MAX: u32 = 255;
pub const UINT_FAST8_MAX: u32 = 255;
pub const INT16_MIN: i32 = -32768;
pub const INT16_MAX: u32 = 32767;
pub const INT_LEAST16_MIN: i32 = -32768;
pub const INT_LEAST16_MAX: u32 = 32767;
pub const UINT16_MAX: u32 = 65535;
pub const UINT_LEAST16_MAX: u32 = 65535;
pub const INT32_MIN: i32 = -2147483648;
pub const INT32_MAX: u32 = 2147483647;
pub const INT_LEAST32_MIN: i32 = -2147483648;
pub const INT_LEAST32_MAX: u32 = 2147483647;
pub const INT_FAST32_MIN: i32 = -2147483648;
pub const INT_FAST32_MAX: u32 = 2147483647;
pub const UINT32_MAX: u32 = 4294967295;
pub const UINT_LEAST32_MAX: u32 = 4294967295;
pub const UINT_FAST32_MAX: u32 = 4294967295;
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
pub const WINT_MAX: u32 = 4294967295;
pub const WINT_MIN: u32 = 0;
pub const INTPTR_MIN: i32 = -2147483648;
pub const INTPTR_MAX: u32 = 2147483647;
pub const UINTPTR_MAX: u32 = 4294967295;
pub const PTRDIFF_MIN: i32 = -2147483648;
pub const PTRDIFF_MAX: u32 = 2147483647;
pub const SIZE_MAX: u32 = 4294967295;
pub const JNI_FALSE: u32 = 0;
pub const JNI_TRUE: u32 = 1;
pub const JNI_VERSION_1_1: u32 = 65537;
pub const JNI_VERSION_1_2: u32 = 65538;
pub const JNI_VERSION_1_4: u32 = 65540;
pub const JNI_VERSION_1_6: u32 = 65542;
pub const JNI_OK: u32 = 0;
pub const JNI_ERR: i32 = -1;
pub const JNI_EDETACHED: i32 = -2;
pub const JNI_EVERSION: i32 = -3;
pub const JNI_ENOMEM: i32 = -4;
pub const JNI_EEXIST: i32 = -5;
pub const JNI_EINVAL: i32 = -6;
pub const JNI_COMMIT: u32 = 1;
pub const JNI_ABORT: u32 = 2;
pub const SL_ANDROID_JAVA_PROXY_ROUTING: u32 = 1;
pub type sl_uint8_t = ::std::os::raw::c_uchar;
pub type sl_int8_t = ::std::os::raw::c_schar;
pub type sl_uint16_t = ::std::os::raw::c_ushort;
pub type sl_int16_t = ::std::os::raw::c_short;
pub type sl_uint32_t = ::std::os::raw::c_uint;
pub type sl_int32_t = ::std::os::raw::c_int;
pub type sl_int64_t = ::std::os::raw::c_longlong;
pub type sl_uint64_t = ::std::os::raw::c_ulonglong;
pub type SLint8 = sl_int8_t;
pub type SLuint8 = sl_uint8_t;
pub type SLint16 = sl_int16_t;
pub type SLuint16 = sl_uint16_t;
pub type SLint32 = sl_int32_t;
pub type SLuint32 = sl_uint32_t;
pub type SLboolean = SLuint32;
pub type SLchar = SLuint8;
pub type SLmillibel = SLint16;
pub type SLmillisecond = SLuint32;
pub type SLmilliHertz = SLuint32;
pub type SLmillimeter = SLint32;
pub type SLmillidegree = SLint32;
pub type SLpermille = SLint16;
pub type SLmicrosecond = SLuint32;
pub type SLresult = SLuint32;
#[doc = " Interface ID defined as a UUID"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLInterfaceID_ {
pub time_low: SLuint32,
pub time_mid: SLuint16,
pub time_hi_and_version: SLuint16,
pub clock_seq: SLuint16,
pub node: [SLuint8; 6usize],
}
pub type SLInterfaceID = *const SLInterfaceID_;
pub type SLObjectItf = *const *const SLObjectItf_;
extern "C" {
pub static SL_IID_NULL: SLInterfaceID;
}
#[doc = " URI-based data locator definition where locatorType must be SL_DATALOCATOR_URI"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_URI_ {
pub locatorType: SLuint32,
pub URI: *mut SLchar,
}
pub type SLDataLocator_URI = SLDataLocator_URI_;
#[doc = " Address-based data locator definition where locatorType must be SL_DATALOCATOR_ADDRESS"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_Address_ {
pub locatorType: SLuint32,
pub pAddress: *mut ::std::os::raw::c_void,
pub length: SLuint32,
}
pub type SLDataLocator_Address = SLDataLocator_Address_;
#[doc = " IODevice-based data locator definition where locatorType must be SL_DATALOCATOR_IODEVICE"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_IODevice_ {
pub locatorType: SLuint32,
pub deviceType: SLuint32,
pub deviceID: SLuint32,
pub device: SLObjectItf,
}
pub type SLDataLocator_IODevice = SLDataLocator_IODevice_;
#[doc = " OutputMix-based data locator definition where locatorType must be SL_DATALOCATOR_OUTPUTMIX"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_OutputMix {
pub locatorType: SLuint32,
pub outputMix: SLObjectItf,
}
#[doc = " BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_BUFFERQUEUE"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_BufferQueue {
pub locatorType: SLuint32,
pub numBuffers: SLuint32,
}
#[doc = " MidiBufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_MIDIBUFFERQUEUE"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_MIDIBufferQueue {
pub locatorType: SLuint32,
pub tpqn: SLuint32,
pub numBuffers: SLuint32,
}
#[doc = " MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataFormat_MIME_ {
pub formatType: SLuint32,
pub mimeType: *mut SLchar,
pub containerType: SLuint32,
}
pub type SLDataFormat_MIME = SLDataFormat_MIME_;
#[doc = " PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataFormat_PCM_ {
pub formatType: SLuint32,
pub numChannels: SLuint32,
pub samplesPerSec: SLuint32,
pub bitsPerSample: SLuint32,
pub containerSize: SLuint32,
pub channelMask: SLuint32,
pub endianness: SLuint32,
}
pub type SLDataFormat_PCM = SLDataFormat_PCM_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataSource_ {
pub pLocator: *mut ::std::os::raw::c_void,
pub pFormat: *mut ::std::os::raw::c_void,
}
pub type SLDataSource = SLDataSource_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataSink_ {
pub pLocator: *mut ::std::os::raw::c_void,
pub pFormat: *mut ::std::os::raw::c_void,
}
pub type SLDataSink = SLDataSink_;
extern "C" {
pub static SL_IID_OBJECT: SLInterfaceID;
}
#[doc = " Object callback"]
pub type slObjectCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLObjectItf,
pContext: *const ::std::os::raw::c_void,
event: SLuint32,
result: SLresult,
param: SLuint32,
pInterface: *mut ::std::os::raw::c_void,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLObjectItf_ {
pub Realize: ::std::option::Option<
unsafe extern "C" fn(self_: SLObjectItf, async_: SLboolean) -> SLresult,
>,
pub Resume: ::std::option::Option<
unsafe extern "C" fn(self_: SLObjectItf, async_: SLboolean) -> SLresult,
>,
pub GetState: ::std::option::Option<
unsafe extern "C" fn(self_: SLObjectItf, pState: *mut SLuint32) -> SLresult,
>,
pub GetInterface: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
iid: SLInterfaceID,
pInterface: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
callback: slObjectCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub AbortAsyncOperation: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
pub Destroy: ::std::option::Option<unsafe extern "C" fn(self_: SLObjectItf)>,
pub SetPriority: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
priority: SLint32,
preemptable: SLboolean,
) -> SLresult,
>,
pub GetPriority: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
pPriority: *mut SLint32,
pPreemptable: *mut SLboolean,
) -> SLresult,
>,
pub SetLossOfControlInterfaces: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
numInterfaces: SLint16,
pInterfaceIDs: *mut SLInterfaceID,
enabled: SLboolean,
) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioInputDescriptor_ {
pub deviceName: *mut SLchar,
pub deviceConnection: SLint16,
pub deviceScope: SLint16,
pub deviceLocation: SLint16,
pub isForTelephony: SLboolean,
pub minSampleRate: SLmilliHertz,
pub maxSampleRate: SLmilliHertz,
pub isFreqRangeContinuous: SLboolean,
pub samplingRatesSupported: *mut SLmilliHertz,
pub numOfSamplingRatesSupported: SLint16,
pub maxChannels: SLint16,
}
pub type SLAudioInputDescriptor = SLAudioInputDescriptor_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioOutputDescriptor_ {
pub pDeviceName: *mut SLchar,
pub deviceConnection: SLint16,
pub deviceScope: SLint16,
pub deviceLocation: SLint16,
pub isForTelephony: SLboolean,
pub minSampleRate: SLmilliHertz,
pub maxSampleRate: SLmilliHertz,
pub isFreqRangeContinuous: SLboolean,
pub samplingRatesSupported: *mut SLmilliHertz,
pub numOfSamplingRatesSupported: SLint16,
pub maxChannels: SLint16,
}
pub type SLAudioOutputDescriptor = SLAudioOutputDescriptor_;
extern "C" {
pub static SL_IID_AUDIOIODEVICECAPABILITIES: SLInterfaceID;
}
pub type SLAudioIODeviceCapabilitiesItf = *const *const SLAudioIODeviceCapabilitiesItf_;
pub type slAvailableAudioInputsChangedCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAudioIODeviceCapabilitiesItf,
pContext: *mut ::std::os::raw::c_void,
deviceID: SLuint32,
numInputs: SLint32,
isNew: SLboolean,
),
>;
pub type slAvailableAudioOutputsChangedCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAudioIODeviceCapabilitiesItf,
pContext: *mut ::std::os::raw::c_void,
deviceID: SLuint32,
numOutputs: SLint32,
isNew: SLboolean,
),
>;
pub type slDefaultDeviceIDMapChangedCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAudioIODeviceCapabilitiesItf,
pContext: *mut ::std::os::raw::c_void,
isOutput: SLboolean,
numDevices: SLint32,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioIODeviceCapabilitiesItf_ {
pub GetAvailableAudioInputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
pNumInputs: *mut SLint32,
pInputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub QueryAudioInputCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
pDescriptor: *mut SLAudioInputDescriptor,
) -> SLresult,
>,
pub RegisterAvailableAudioInputsChangedCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
callback: slAvailableAudioInputsChangedCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub GetAvailableAudioOutputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
pNumOutputs: *mut SLint32,
pOutputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub QueryAudioOutputCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
pDescriptor: *mut SLAudioOutputDescriptor,
) -> SLresult,
>,
pub RegisterAvailableAudioOutputsChangedCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
callback: slAvailableAudioOutputsChangedCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub RegisterDefaultDeviceIDMapChangedCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
callback: slDefaultDeviceIDMapChangedCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub GetAssociatedAudioInputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
pNumAudioInputs: *mut SLint32,
pAudioInputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub GetAssociatedAudioOutputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
pNumAudioOutputs: *mut SLint32,
pAudioOutputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub GetDefaultAudioDevices: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
defaultDeviceID: SLuint32,
pNumAudioDevices: *mut SLint32,
pAudioDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub QuerySampleFormatsSupported: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
samplingRate: SLmilliHertz,
pSampleFormats: *mut SLint32,
pNumOfSampleFormats: *mut SLint32,
) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLLEDDescriptor_ {
pub ledCount: SLuint8,
pub primaryLED: SLuint8,
pub colorMask: SLuint32,
}
pub type SLLEDDescriptor = SLLEDDescriptor_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLHSL_ {
pub hue: SLmillidegree,
pub saturation: SLpermille,
pub lightness: SLpermille,
}
pub type SLHSL = SLHSL_;
extern "C" {
pub static SL_IID_LED: SLInterfaceID;
}
pub type SLLEDArrayItf = *const *const SLLEDArrayItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLLEDArrayItf_ {
pub ActivateLEDArray: ::std::option::Option<
unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: SLuint32) -> SLresult,
>,
pub IsLEDArrayActivated: ::std::option::Option<
unsafe extern "C" fn(self_: SLLEDArrayItf, lightMask: *mut SLuint32) -> SLresult,
>,
pub SetColor: ::std::option::Option<
unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *const SLHSL) -> SLresult,
>,
pub GetColor: ::std::option::Option<
unsafe extern "C" fn(self_: SLLEDArrayItf, index: SLuint8, color: *mut SLHSL) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVibraDescriptor_ {
pub supportsFrequency: SLboolean,
pub supportsIntensity: SLboolean,
pub minFrequency: SLmilliHertz,
pub maxFrequency: SLmilliHertz,
}
pub type SLVibraDescriptor = SLVibraDescriptor_;
extern "C" {
pub static SL_IID_VIBRA: SLInterfaceID;
}
pub type SLVibraItf = *const *const SLVibraItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVibraItf_ {
pub Vibrate: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, vibrate: SLboolean) -> SLresult,
>,
pub IsVibrating: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, pVibrating: *mut SLboolean) -> SLresult,
>,
pub SetFrequency: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, frequency: SLmilliHertz) -> SLresult,
>,
pub GetFrequency: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, pFrequency: *mut SLmilliHertz) -> SLresult,
>,
pub SetIntensity: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, intensity: SLpermille) -> SLresult,
>,
pub GetIntensity: ::std::option::Option<
unsafe extern "C" fn(self_: SLVibraItf, pIntensity: *mut SLpermille) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMetadataInfo_ {
pub size: SLuint32,
pub encoding: SLuint32,
pub langCountry: [SLchar; 16usize],
pub data: [SLuint8; 1usize],
}
pub type SLMetadataInfo = SLMetadataInfo_;
extern "C" {
pub static SL_IID_METADATAEXTRACTION: SLInterfaceID;
}
pub type SLMetadataExtractionItf = *const *const SLMetadataExtractionItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMetadataExtractionItf_ {
pub GetItemCount: ::std::option::Option<
unsafe extern "C" fn(self_: SLMetadataExtractionItf, pItemCount: *mut SLuint32) -> SLresult,
>,
pub GetKeySize: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataExtractionItf,
index: SLuint32,
pKeySize: *mut SLuint32,
) -> SLresult,
>,
pub GetKey: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataExtractionItf,
index: SLuint32,
keySize: SLuint32,
pKey: *mut SLMetadataInfo,
) -> SLresult,
>,
pub GetValueSize: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataExtractionItf,
index: SLuint32,
pValueSize: *mut SLuint32,
) -> SLresult,
>,
pub GetValue: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataExtractionItf,
index: SLuint32,
valueSize: SLuint32,
pValue: *mut SLMetadataInfo,
) -> SLresult,
>,
pub AddKeyFilter: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataExtractionItf,
keySize: SLuint32,
pKey: *const ::std::os::raw::c_void,
keyEncoding: SLuint32,
pValueLangCountry: *const SLchar,
valueEncoding: SLuint32,
filterMask: SLuint8,
) -> SLresult,
>,
pub ClearKeyFilter:
::std::option::Option<unsafe extern "C" fn(self_: SLMetadataExtractionItf) -> SLresult>,
}
extern "C" {
pub static SL_IID_METADATATRAVERSAL: SLInterfaceID;
}
pub type SLMetadataTraversalItf = *const *const SLMetadataTraversalItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMetadataTraversalItf_ {
pub SetMode: ::std::option::Option<
unsafe extern "C" fn(self_: SLMetadataTraversalItf, mode: SLuint32) -> SLresult,
>,
pub GetChildCount: ::std::option::Option<
unsafe extern "C" fn(self_: SLMetadataTraversalItf, pCount: *mut SLuint32) -> SLresult,
>,
pub GetChildMIMETypeSize: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataTraversalItf,
index: SLuint32,
pSize: *mut SLuint32,
) -> SLresult,
>,
pub GetChildInfo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataTraversalItf,
index: SLuint32,
pNodeID: *mut SLint32,
pType: *mut SLuint32,
size: SLuint32,
pMimeType: *mut SLchar,
) -> SLresult,
>,
pub SetActiveNode: ::std::option::Option<
unsafe extern "C" fn(self_: SLMetadataTraversalItf, index: SLuint32) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_DYNAMICSOURCE: SLInterfaceID;
}
pub type SLDynamicSourceItf = *const *const SLDynamicSourceItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDynamicSourceItf_ {
pub SetSource: ::std::option::Option<
unsafe extern "C" fn(self_: SLDynamicSourceItf, pDataSource: *mut SLDataSource) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_OUTPUTMIX: SLInterfaceID;
}
pub type SLOutputMixItf = *const *const SLOutputMixItf_;
pub type slMixDeviceChangeCallback = ::std::option::Option<
unsafe extern "C" fn(caller: SLOutputMixItf, pContext: *mut ::std::os::raw::c_void),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLOutputMixItf_ {
pub GetDestinationOutputDeviceIDs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLOutputMixItf,
pNumDevices: *mut SLint32,
pDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub RegisterDeviceChangeCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLOutputMixItf,
callback: slMixDeviceChangeCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub ReRoute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLOutputMixItf,
numOutputDevices: SLint32,
pOutputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_PLAY: SLInterfaceID;
}
pub type SLPlayItf = *const *const SLPlayItf_;
pub type slPlayCallback = ::std::option::Option<
unsafe extern "C" fn(caller: SLPlayItf, pContext: *mut ::std::os::raw::c_void, event: SLuint32),
>;
#[doc = " Playback interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLPlayItf_ {
pub SetPlayState:
::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf, state: SLuint32) -> SLresult>,
pub GetPlayState: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pState: *mut SLuint32) -> SLresult,
>,
pub GetDuration: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
pub GetPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLPlayItf,
callback: slPlayCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub SetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, eventFlags: SLuint32) -> SLresult,
>,
pub GetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pEventFlags: *mut SLuint32) -> SLresult,
>,
pub SetMarkerPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
>,
pub ClearMarkerPosition:
::std::option::Option<unsafe extern "C" fn(self_: SLPlayItf) -> SLresult>,
pub GetMarkerPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
pub SetPositionUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, mSec: SLmillisecond) -> SLresult,
>,
pub GetPositionUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlayItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_PREFETCHSTATUS: SLInterfaceID;
}
pub type SLPrefetchStatusItf = *const *const SLPrefetchStatusItf_;
pub type slPrefetchCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLPrefetchStatusItf,
pContext: *mut ::std::os::raw::c_void,
event: SLuint32,
),
>;
#[doc = " Prefetch status interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLPrefetchStatusItf_ {
pub GetPrefetchStatus: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, pStatus: *mut SLuint32) -> SLresult,
>,
pub GetFillLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, pLevel: *mut SLpermille) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLPrefetchStatusItf,
callback: slPrefetchCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub SetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, eventFlags: SLuint32) -> SLresult,
>,
pub GetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, pEventFlags: *mut SLuint32) -> SLresult,
>,
pub SetFillUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, period: SLpermille) -> SLresult,
>,
pub GetFillUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, pPeriod: *mut SLpermille) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_PLAYBACKRATE: SLInterfaceID;
}
pub type SLPlaybackRateItf = *const *const SLPlaybackRateItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLPlaybackRateItf_ {
pub SetRate: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlaybackRateItf, rate: SLpermille) -> SLresult,
>,
pub GetRate: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlaybackRateItf, pRate: *mut SLpermille) -> SLresult,
>,
pub SetPropertyConstraints: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlaybackRateItf, constraints: SLuint32) -> SLresult,
>,
pub GetProperties: ::std::option::Option<
unsafe extern "C" fn(self_: SLPlaybackRateItf, pProperties: *mut SLuint32) -> SLresult,
>,
pub GetCapabilitiesOfRate: ::std::option::Option<
unsafe extern "C" fn(
self_: SLPlaybackRateItf,
rate: SLpermille,
pCapabilities: *mut SLuint32,
) -> SLresult,
>,
pub GetRateRange: ::std::option::Option<
unsafe extern "C" fn(
self_: SLPlaybackRateItf,
index: SLuint8,
pMinRate: *mut SLpermille,
pMaxRate: *mut SLpermille,
pStepSize: *mut SLpermille,
pCapabilities: *mut SLuint32,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_SEEK: SLInterfaceID;
}
pub type SLSeekItf = *const *const SLSeekItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLSeekItf_ {
pub SetPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLSeekItf, pos: SLmillisecond, seekMode: SLuint32) -> SLresult,
>,
pub SetLoop: ::std::option::Option<
unsafe extern "C" fn(
self_: SLSeekItf,
loopEnable: SLboolean,
startPos: SLmillisecond,
endPos: SLmillisecond,
) -> SLresult,
>,
pub GetLoop: ::std::option::Option<
unsafe extern "C" fn(
self_: SLSeekItf,
pLoopEnabled: *mut SLboolean,
pStartPos: *mut SLmillisecond,
pEndPos: *mut SLmillisecond,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_RECORD: SLInterfaceID;
}
pub type SLRecordItf = *const *const SLRecordItf_;
pub type slRecordCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLRecordItf,
pContext: *mut ::std::os::raw::c_void,
event: SLuint32,
),
>;
#[doc = " Recording interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLRecordItf_ {
pub SetRecordState: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, state: SLuint32) -> SLresult,
>,
pub GetRecordState: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, pState: *mut SLuint32) -> SLresult,
>,
pub SetDurationLimit: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, msec: SLmillisecond) -> SLresult,
>,
pub GetPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLRecordItf,
callback: slRecordCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub SetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, eventFlags: SLuint32) -> SLresult,
>,
pub GetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, pEventFlags: *mut SLuint32) -> SLresult,
>,
pub SetMarkerPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
>,
pub ClearMarkerPosition:
::std::option::Option<unsafe extern "C" fn(self_: SLRecordItf) -> SLresult>,
pub GetMarkerPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
pub SetPositionUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, mSec: SLmillisecond) -> SLresult,
>,
pub GetPositionUpdatePeriod: ::std::option::Option<
unsafe extern "C" fn(self_: SLRecordItf, pMsec: *mut SLmillisecond) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_EQUALIZER: SLInterfaceID;
}
pub type SLEqualizerItf = *const *const SLEqualizerItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEqualizerItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, enabled: SLboolean) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, pEnabled: *mut SLboolean) -> SLresult,
>,
pub GetNumberOfBands: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, pAmount: *mut SLuint16) -> SLresult,
>,
pub GetBandLevelRange: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
pMin: *mut SLmillibel,
pMax: *mut SLmillibel,
) -> SLresult,
>,
pub SetBandLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, band: SLuint16, level: SLmillibel) -> SLresult,
>,
pub GetBandLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
band: SLuint16,
pLevel: *mut SLmillibel,
) -> SLresult,
>,
pub GetCenterFreq: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
band: SLuint16,
pCenter: *mut SLmilliHertz,
) -> SLresult,
>,
pub GetBandFreqRange: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
band: SLuint16,
pMin: *mut SLmilliHertz,
pMax: *mut SLmilliHertz,
) -> SLresult,
>,
pub GetBand: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
frequency: SLmilliHertz,
pBand: *mut SLuint16,
) -> SLresult,
>,
pub GetCurrentPreset: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, pPreset: *mut SLuint16) -> SLresult,
>,
pub UsePreset: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, index: SLuint16) -> SLresult,
>,
pub GetNumberOfPresets: ::std::option::Option<
unsafe extern "C" fn(self_: SLEqualizerItf, pNumPresets: *mut SLuint16) -> SLresult,
>,
pub GetPresetName: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEqualizerItf,
index: SLuint16,
ppName: *mut *const SLchar,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_VOLUME: SLInterfaceID;
}
pub type SLVolumeItf = *const *const SLVolumeItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVolumeItf_ {
pub SetVolumeLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, level: SLmillibel) -> SLresult,
>,
pub GetVolumeLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, pLevel: *mut SLmillibel) -> SLresult,
>,
pub GetMaxVolumeLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, pMaxLevel: *mut SLmillibel) -> SLresult,
>,
pub SetMute: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, mute: SLboolean) -> SLresult,
>,
pub GetMute: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, pMute: *mut SLboolean) -> SLresult,
>,
pub EnableStereoPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, enable: SLboolean) -> SLresult,
>,
pub IsEnabledStereoPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, pEnable: *mut SLboolean) -> SLresult,
>,
pub SetStereoPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, stereoPosition: SLpermille) -> SLresult,
>,
pub GetStereoPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLVolumeItf, pStereoPosition: *mut SLpermille) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_DEVICEVOLUME: SLInterfaceID;
}
pub type SLDeviceVolumeItf = *const *const SLDeviceVolumeItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDeviceVolumeItf_ {
pub GetVolumeScale: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDeviceVolumeItf,
deviceID: SLuint32,
pMinValue: *mut SLint32,
pMaxValue: *mut SLint32,
pIsMillibelScale: *mut SLboolean,
) -> SLresult,
>,
pub SetVolume: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDeviceVolumeItf,
deviceID: SLuint32,
volume: SLint32,
) -> SLresult,
>,
pub GetVolume: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDeviceVolumeItf,
deviceID: SLuint32,
pVolume: *mut SLint32,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_BUFFERQUEUE: SLInterfaceID;
}
pub type SLBufferQueueItf = *const *const SLBufferQueueItf_;
pub type slBufferQueueCallback = ::std::option::Option<
unsafe extern "C" fn(caller: SLBufferQueueItf, pContext: *mut ::std::os::raw::c_void),
>;
#[doc = " Buffer queue state"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLBufferQueueState_ {
pub count: SLuint32,
pub playIndex: SLuint32,
}
pub type SLBufferQueueState = SLBufferQueueState_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLBufferQueueItf_ {
pub Enqueue: ::std::option::Option<
unsafe extern "C" fn(
self_: SLBufferQueueItf,
pBuffer: *const ::std::os::raw::c_void,
size: SLuint32,
) -> SLresult,
>,
pub Clear: ::std::option::Option<unsafe extern "C" fn(self_: SLBufferQueueItf) -> SLresult>,
pub GetState: ::std::option::Option<
unsafe extern "C" fn(self_: SLBufferQueueItf, pState: *mut SLBufferQueueState) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLBufferQueueItf,
callback: slBufferQueueCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_PRESETREVERB: SLInterfaceID;
}
pub type SLPresetReverbItf = *const *const SLPresetReverbItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLPresetReverbItf_ {
pub SetPreset: ::std::option::Option<
unsafe extern "C" fn(self_: SLPresetReverbItf, preset: SLuint16) -> SLresult,
>,
pub GetPreset: ::std::option::Option<
unsafe extern "C" fn(self_: SLPresetReverbItf, pPreset: *mut SLuint16) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEnvironmentalReverbSettings_ {
pub roomLevel: SLmillibel,
pub roomHFLevel: SLmillibel,
pub decayTime: SLmillisecond,
pub decayHFRatio: SLpermille,
pub reflectionsLevel: SLmillibel,
pub reflectionsDelay: SLmillisecond,
pub reverbLevel: SLmillibel,
pub reverbDelay: SLmillisecond,
pub diffusion: SLpermille,
pub density: SLpermille,
}
pub type SLEnvironmentalReverbSettings = SLEnvironmentalReverbSettings_;
extern "C" {
pub static SL_IID_ENVIRONMENTALREVERB: SLInterfaceID;
}
pub type SLEnvironmentalReverbItf = *const *const SLEnvironmentalReverbItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEnvironmentalReverbItf_ {
pub SetRoomLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, room: SLmillibel) -> SLresult,
>,
pub GetRoomLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoom: *mut SLmillibel) -> SLresult,
>,
pub SetRoomHFLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, roomHF: SLmillibel) -> SLresult,
>,
pub GetRoomHFLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, pRoomHF: *mut SLmillibel) -> SLresult,
>,
pub SetDecayTime: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayTime: SLmillisecond) -> SLresult,
>,
pub GetDecayTime: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pDecayTime: *mut SLmillisecond,
) -> SLresult,
>,
pub SetDecayHFRatio: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, decayHFRatio: SLpermille) -> SLresult,
>,
pub GetDecayHFRatio: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pDecayHFRatio: *mut SLpermille,
) -> SLresult,
>,
pub SetReflectionsLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
reflectionsLevel: SLmillibel,
) -> SLresult,
>,
pub GetReflectionsLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pReflectionsLevel: *mut SLmillibel,
) -> SLresult,
>,
pub SetReflectionsDelay: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
reflectionsDelay: SLmillisecond,
) -> SLresult,
>,
pub GetReflectionsDelay: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pReflectionsDelay: *mut SLmillisecond,
) -> SLresult,
>,
pub SetReverbLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, reverbLevel: SLmillibel) -> SLresult,
>,
pub GetReverbLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pReverbLevel: *mut SLmillibel,
) -> SLresult,
>,
pub SetReverbDelay: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
reverbDelay: SLmillisecond,
) -> SLresult,
>,
pub GetReverbDelay: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pReverbDelay: *mut SLmillisecond,
) -> SLresult,
>,
pub SetDiffusion: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, diffusion: SLpermille) -> SLresult,
>,
pub GetDiffusion: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pDiffusion: *mut SLpermille,
) -> SLresult,
>,
pub SetDensity: ::std::option::Option<
unsafe extern "C" fn(self_: SLEnvironmentalReverbItf, density: SLpermille) -> SLresult,
>,
pub GetDensity: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pDensity: *mut SLpermille,
) -> SLresult,
>,
pub SetEnvironmentalReverbProperties: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pProperties: *const SLEnvironmentalReverbSettings,
) -> SLresult,
>,
pub GetEnvironmentalReverbProperties: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEnvironmentalReverbItf,
pProperties: *mut SLEnvironmentalReverbSettings,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_EFFECTSEND: SLInterfaceID;
}
pub type SLEffectSendItf = *const *const SLEffectSendItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEffectSendItf_ {
pub EnableEffectSend: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEffectSendItf,
pAuxEffect: *const ::std::os::raw::c_void,
enable: SLboolean,
initialLevel: SLmillibel,
) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEffectSendItf,
pAuxEffect: *const ::std::os::raw::c_void,
pEnable: *mut SLboolean,
) -> SLresult,
>,
pub SetDirectLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEffectSendItf, directLevel: SLmillibel) -> SLresult,
>,
pub GetDirectLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLEffectSendItf, pDirectLevel: *mut SLmillibel) -> SLresult,
>,
pub SetSendLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEffectSendItf,
pAuxEffect: *const ::std::os::raw::c_void,
sendLevel: SLmillibel,
) -> SLresult,
>,
pub GetSendLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEffectSendItf,
pAuxEffect: *const ::std::os::raw::c_void,
pSendLevel: *mut SLmillibel,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_3DGROUPING: SLInterfaceID;
}
pub type SL3DGroupingItf = *const *const SL3DGroupingItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DGroupingItf_ {
pub Set3DGroup: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DGroupingItf, group: SLObjectItf) -> SLresult,
>,
pub Get3DGroup: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DGroupingItf, pGroup: *mut SLObjectItf) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_3DCOMMIT: SLInterfaceID;
}
pub type SL3DCommitItf = *const *const SL3DCommitItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DCommitItf_ {
pub Commit: ::std::option::Option<unsafe extern "C" fn(self_: SL3DCommitItf) -> SLresult>,
pub SetDeferred: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DCommitItf, deferred: SLboolean) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVec3D_ {
pub x: SLint32,
pub y: SLint32,
pub z: SLint32,
}
pub type SLVec3D = SLVec3D_;
extern "C" {
pub static SL_IID_3DLOCATION: SLInterfaceID;
}
pub type SL3DLocationItf = *const *const SL3DLocationItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DLocationItf_ {
pub SetLocationCartesian: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *const SLVec3D) -> SLresult,
>,
pub SetLocationSpherical: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DLocationItf,
azimuth: SLmillidegree,
elevation: SLmillidegree,
distance: SLmillimeter,
) -> SLresult,
>,
pub Move: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DLocationItf, pMovement: *const SLVec3D) -> SLresult,
>,
pub GetLocationCartesian: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DLocationItf, pLocation: *mut SLVec3D) -> SLresult,
>,
pub SetOrientationVectors: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DLocationItf,
pFront: *const SLVec3D,
pAbove: *const SLVec3D,
) -> SLresult,
>,
pub SetOrientationAngles: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DLocationItf,
heading: SLmillidegree,
pitch: SLmillidegree,
roll: SLmillidegree,
) -> SLresult,
>,
pub Rotate: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DLocationItf,
theta: SLmillidegree,
pAxis: *const SLVec3D,
) -> SLresult,
>,
pub GetOrientationVectors: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DLocationItf,
pFront: *mut SLVec3D,
pUp: *mut SLVec3D,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_3DDOPPLER: SLInterfaceID;
}
pub type SL3DDopplerItf = *const *const SL3DDopplerItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DDopplerItf_ {
pub SetVelocityCartesian: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *const SLVec3D) -> SLresult,
>,
pub SetVelocitySpherical: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DDopplerItf,
azimuth: SLmillidegree,
elevation: SLmillidegree,
speed: SLmillimeter,
) -> SLresult,
>,
pub GetVelocityCartesian: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DDopplerItf, pVelocity: *mut SLVec3D) -> SLresult,
>,
pub SetDopplerFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DDopplerItf, dopplerFactor: SLpermille) -> SLresult,
>,
pub GetDopplerFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DDopplerItf, pDopplerFactor: *mut SLpermille) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_3DSOURCE: SLInterfaceID;
}
pub type SL3DSourceItf = *const *const SL3DSourceItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DSourceItf_ {
pub SetHeadRelative: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, headRelative: SLboolean) -> SLresult,
>,
pub GetHeadRelative: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, pHeadRelative: *mut SLboolean) -> SLresult,
>,
pub SetRolloffDistances: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DSourceItf,
minDistance: SLmillimeter,
maxDistance: SLmillimeter,
) -> SLresult,
>,
pub GetRolloffDistances: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DSourceItf,
pMinDistance: *mut SLmillimeter,
pMaxDistance: *mut SLmillimeter,
) -> SLresult,
>,
pub SetRolloffMaxDistanceMute: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, mute: SLboolean) -> SLresult,
>,
pub GetRolloffMaxDistanceMute: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, pMute: *mut SLboolean) -> SLresult,
>,
pub SetRolloffFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, rolloffFactor: SLpermille) -> SLresult,
>,
pub GetRolloffFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, pRolloffFactor: *mut SLpermille) -> SLresult,
>,
pub SetRoomRolloffFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, roomRolloffFactor: SLpermille) -> SLresult,
>,
pub GetRoomRolloffFactor: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, pRoomRolloffFactor: *mut SLpermille) -> SLresult,
>,
pub SetRolloffModel: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, model: SLuint8) -> SLresult,
>,
pub GetRolloffModel: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DSourceItf, pModel: *mut SLuint8) -> SLresult,
>,
pub SetCone: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DSourceItf,
innerAngle: SLmillidegree,
outerAngle: SLmillidegree,
outerLevel: SLmillibel,
) -> SLresult,
>,
pub GetCone: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DSourceItf,
pInnerAngle: *mut SLmillidegree,
pOuterAngle: *mut SLmillidegree,
pOuterLevel: *mut SLmillibel,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_3DMACROSCOPIC: SLInterfaceID;
}
pub type SL3DMacroscopicItf = *const *const SL3DMacroscopicItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DMacroscopicItf_ {
pub SetSize: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
width: SLmillimeter,
height: SLmillimeter,
depth: SLmillimeter,
) -> SLresult,
>,
pub GetSize: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
pWidth: *mut SLmillimeter,
pHeight: *mut SLmillimeter,
pDepth: *mut SLmillimeter,
) -> SLresult,
>,
pub SetOrientationAngles: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
heading: SLmillidegree,
pitch: SLmillidegree,
roll: SLmillidegree,
) -> SLresult,
>,
pub SetOrientationVectors: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
pFront: *const SLVec3D,
pAbove: *const SLVec3D,
) -> SLresult,
>,
pub Rotate: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
theta: SLmillidegree,
pAxis: *const SLVec3D,
) -> SLresult,
>,
pub GetOrientationVectors: ::std::option::Option<
unsafe extern "C" fn(
self_: SL3DMacroscopicItf,
pFront: *mut SLVec3D,
pUp: *mut SLVec3D,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_MUTESOLO: SLInterfaceID;
}
pub type SLMuteSoloItf = *const *const SLMuteSoloItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMuteSoloItf_ {
pub SetChannelMute: ::std::option::Option<
unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, mute: SLboolean) -> SLresult,
>,
pub GetChannelMute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMuteSoloItf,
chan: SLuint8,
pMute: *mut SLboolean,
) -> SLresult,
>,
pub SetChannelSolo: ::std::option::Option<
unsafe extern "C" fn(self_: SLMuteSoloItf, chan: SLuint8, solo: SLboolean) -> SLresult,
>,
pub GetChannelSolo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMuteSoloItf,
chan: SLuint8,
pSolo: *mut SLboolean,
) -> SLresult,
>,
pub GetNumChannels: ::std::option::Option<
unsafe extern "C" fn(self_: SLMuteSoloItf, pNumChannels: *mut SLuint8) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_DYNAMICINTERFACEMANAGEMENT: SLInterfaceID;
}
pub type SLDynamicInterfaceManagementItf = *const *const SLDynamicInterfaceManagementItf_;
pub type slDynamicInterfaceManagementCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLDynamicInterfaceManagementItf,
pContext: *mut ::std::os::raw::c_void,
event: SLuint32,
result: SLresult,
iid: SLInterfaceID,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDynamicInterfaceManagementItf_ {
pub AddInterface: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicInterfaceManagementItf,
iid: SLInterfaceID,
async_: SLboolean,
) -> SLresult,
>,
pub RemoveInterface: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicInterfaceManagementItf,
iid: SLInterfaceID,
) -> SLresult,
>,
pub ResumeInterface: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicInterfaceManagementItf,
iid: SLInterfaceID,
async_: SLboolean,
) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicInterfaceManagementItf,
callback: slDynamicInterfaceManagementCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_MIDIMESSAGE: SLInterfaceID;
}
pub type SLMIDIMessageItf = *const *const SLMIDIMessageItf_;
pub type slMetaEventCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLMIDIMessageItf,
pContext: *mut ::std::os::raw::c_void,
type_: SLuint8,
length: SLuint32,
pData: *const SLuint8,
tick: SLuint32,
track: SLuint16,
),
>;
pub type slMIDIMessageCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLMIDIMessageItf,
pContext: *mut ::std::os::raw::c_void,
statusByte: SLuint8,
length: SLuint32,
pData: *const SLuint8,
tick: SLuint32,
track: SLuint16,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMIDIMessageItf_ {
pub SendMessage: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMessageItf,
data: *const SLuint8,
length: SLuint32,
) -> SLresult,
>,
pub RegisterMetaEventCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMessageItf,
callback: slMetaEventCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub RegisterMIDIMessageCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMessageItf,
callback: slMIDIMessageCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub AddMIDIMessageCallbackFilter: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDIMessageItf, messageType: SLuint32) -> SLresult,
>,
pub ClearMIDIMessageCallbackFilter:
::std::option::Option<unsafe extern "C" fn(self_: SLMIDIMessageItf) -> SLresult>,
}
extern "C" {
pub static SL_IID_MIDIMUTESOLO: SLInterfaceID;
}
pub type SLMIDIMuteSoloItf = *const *const SLMIDIMuteSoloItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMIDIMuteSoloItf_ {
pub SetChannelMute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
channel: SLuint8,
mute: SLboolean,
) -> SLresult,
>,
pub GetChannelMute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
channel: SLuint8,
pMute: *mut SLboolean,
) -> SLresult,
>,
pub SetChannelSolo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
channel: SLuint8,
solo: SLboolean,
) -> SLresult,
>,
pub GetChannelSolo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
channel: SLuint8,
pSolo: *mut SLboolean,
) -> SLresult,
>,
pub GetTrackCount: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDIMuteSoloItf, pCount: *mut SLuint16) -> SLresult,
>,
pub SetTrackMute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
track: SLuint16,
mute: SLboolean,
) -> SLresult,
>,
pub GetTrackMute: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
track: SLuint16,
pMute: *mut SLboolean,
) -> SLresult,
>,
pub SetTrackSolo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
track: SLuint16,
solo: SLboolean,
) -> SLresult,
>,
pub GetTrackSolo: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDIMuteSoloItf,
track: SLuint16,
pSolo: *mut SLboolean,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_MIDITEMPO: SLInterfaceID;
}
pub type SLMIDITempoItf = *const *const SLMIDITempoItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMIDITempoItf_ {
pub SetTicksPerQuarterNote: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITempoItf, tpqn: SLuint32) -> SLresult,
>,
pub GetTicksPerQuarterNote: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITempoItf, pTpqn: *mut SLuint32) -> SLresult,
>,
pub SetMicrosecondsPerQuarterNote: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: SLmicrosecond) -> SLresult,
>,
pub GetMicrosecondsPerQuarterNote: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITempoItf, uspqn: *mut SLmicrosecond) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_MIDITIME: SLInterfaceID;
}
pub type SLMIDITimeItf = *const *const SLMIDITimeItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMIDITimeItf_ {
pub GetDuration: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITimeItf, pDuration: *mut SLuint32) -> SLresult,
>,
pub SetPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITimeItf, position: SLuint32) -> SLresult,
>,
pub GetPosition: ::std::option::Option<
unsafe extern "C" fn(self_: SLMIDITimeItf, pPosition: *mut SLuint32) -> SLresult,
>,
pub SetLoopPoints: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDITimeItf,
startTick: SLuint32,
numTicks: SLuint32,
) -> SLresult,
>,
pub GetLoopPoints: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMIDITimeItf,
pStartTick: *mut SLuint32,
pNumTicks: *mut SLuint32,
) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioCodecDescriptor_ {
pub maxChannels: SLuint32,
pub minBitsPerSample: SLuint32,
pub maxBitsPerSample: SLuint32,
pub minSampleRate: SLmilliHertz,
pub maxSampleRate: SLmilliHertz,
pub isFreqRangeContinuous: SLboolean,
pub pSampleRatesSupported: *mut SLmilliHertz,
pub numSampleRatesSupported: SLuint32,
pub minBitRate: SLuint32,
pub maxBitRate: SLuint32,
pub isBitrateRangeContinuous: SLboolean,
pub pBitratesSupported: *mut SLuint32,
pub numBitratesSupported: SLuint32,
pub profileSetting: SLuint32,
pub modeSetting: SLuint32,
}
pub type SLAudioCodecDescriptor = SLAudioCodecDescriptor_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioCodecProfileMode_ {
pub profileSetting: SLuint32,
pub modeSetting: SLuint32,
}
pub type SLAudioCodecProfileMode = SLAudioCodecProfileMode_;
extern "C" {
pub static SL_IID_AUDIODECODERCAPABILITIES: SLInterfaceID;
}
pub type SLAudioDecoderCapabilitiesItf = *const *const SLAudioDecoderCapabilitiesItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioDecoderCapabilitiesItf_ {
pub GetAudioDecoders: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioDecoderCapabilitiesItf,
pNumDecoders: *mut SLuint32,
pDecoderIds: *mut SLuint32,
) -> SLresult,
>,
pub GetAudioDecoderCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioDecoderCapabilitiesItf,
decoderId: SLuint32,
pIndex: *mut SLuint32,
pDescriptor: *mut SLAudioCodecDescriptor,
) -> SLresult,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioEncoderSettings_ {
pub encoderId: SLuint32,
pub channelsIn: SLuint32,
pub channelsOut: SLuint32,
pub sampleRate: SLmilliHertz,
pub bitRate: SLuint32,
pub bitsPerSample: SLuint32,
pub rateControl: SLuint32,
pub profileSetting: SLuint32,
pub levelSetting: SLuint32,
pub channelMode: SLuint32,
pub streamFormat: SLuint32,
pub encodeOptions: SLuint32,
pub blockAlignment: SLuint32,
}
pub type SLAudioEncoderSettings = SLAudioEncoderSettings_;
extern "C" {
pub static SL_IID_AUDIOENCODERCAPABILITIES: SLInterfaceID;
}
pub type SLAudioEncoderCapabilitiesItf = *const *const SLAudioEncoderCapabilitiesItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioEncoderCapabilitiesItf_ {
pub GetAudioEncoders: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioEncoderCapabilitiesItf,
pNumEncoders: *mut SLuint32,
pEncoderIds: *mut SLuint32,
) -> SLresult,
>,
pub GetAudioEncoderCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioEncoderCapabilitiesItf,
encoderId: SLuint32,
pIndex: *mut SLuint32,
pDescriptor: *mut SLAudioCodecDescriptor,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_AUDIOENCODER: SLInterfaceID;
}
pub type SLAudioEncoderItf = *const *const SLAudioEncoderItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioEncoderItf_ {
pub SetEncoderSettings: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioEncoderItf,
pSettings: *mut SLAudioEncoderSettings,
) -> SLresult,
>,
pub GetEncoderSettings: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioEncoderItf,
pSettings: *mut SLAudioEncoderSettings,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_BASSBOOST: SLInterfaceID;
}
pub type SLBassBoostItf = *const *const SLBassBoostItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLBassBoostItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLBassBoostItf, enabled: SLboolean) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLBassBoostItf, pEnabled: *mut SLboolean) -> SLresult,
>,
pub SetStrength: ::std::option::Option<
unsafe extern "C" fn(self_: SLBassBoostItf, strength: SLpermille) -> SLresult,
>,
pub GetRoundedStrength: ::std::option::Option<
unsafe extern "C" fn(self_: SLBassBoostItf, pStrength: *mut SLpermille) -> SLresult,
>,
pub IsStrengthSupported: ::std::option::Option<
unsafe extern "C" fn(self_: SLBassBoostItf, pSupported: *mut SLboolean) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_PITCH: SLInterfaceID;
}
pub type SLPitchItf = *const *const SLPitchItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLPitchItf_ {
pub SetPitch: ::std::option::Option<
unsafe extern "C" fn(self_: SLPitchItf, pitch: SLpermille) -> SLresult,
>,
pub GetPitch: ::std::option::Option<
unsafe extern "C" fn(self_: SLPitchItf, pPitch: *mut SLpermille) -> SLresult,
>,
pub GetPitchCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLPitchItf,
pMinPitch: *mut SLpermille,
pMaxPitch: *mut SLpermille,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_RATEPITCH: SLInterfaceID;
}
pub type SLRatePitchItf = *const *const SLRatePitchItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLRatePitchItf_ {
pub SetRate: ::std::option::Option<
unsafe extern "C" fn(self_: SLRatePitchItf, rate: SLpermille) -> SLresult,
>,
pub GetRate: ::std::option::Option<
unsafe extern "C" fn(self_: SLRatePitchItf, pRate: *mut SLpermille) -> SLresult,
>,
pub GetRatePitchCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLRatePitchItf,
pMinRate: *mut SLpermille,
pMaxRate: *mut SLpermille,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_VIRTUALIZER: SLInterfaceID;
}
pub type SLVirtualizerItf = *const *const SLVirtualizerItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVirtualizerItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLVirtualizerItf, enabled: SLboolean) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLVirtualizerItf, pEnabled: *mut SLboolean) -> SLresult,
>,
pub SetStrength: ::std::option::Option<
unsafe extern "C" fn(self_: SLVirtualizerItf, strength: SLpermille) -> SLresult,
>,
pub GetRoundedStrength: ::std::option::Option<
unsafe extern "C" fn(self_: SLVirtualizerItf, pStrength: *mut SLpermille) -> SLresult,
>,
pub IsStrengthSupported: ::std::option::Option<
unsafe extern "C" fn(self_: SLVirtualizerItf, pSupported: *mut SLboolean) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_VISUALIZATION: SLInterfaceID;
}
pub type SLVisualizationItf = *const *const SLVisualizationItf_;
pub type slVisualizationCallback = ::std::option::Option<
unsafe extern "C" fn(
pContext: *mut ::std::os::raw::c_void,
waveform: *const SLuint8,
fft: *const SLuint8,
samplerate: SLmilliHertz,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLVisualizationItf_ {
pub RegisterVisualizationCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLVisualizationItf,
callback: slVisualizationCallback,
pContext: *mut ::std::os::raw::c_void,
rate: SLmilliHertz,
) -> SLresult,
>,
pub GetMaxRate: ::std::option::Option<
unsafe extern "C" fn(self_: SLVisualizationItf, pRate: *mut SLmilliHertz) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ENGINE: SLInterfaceID;
}
pub type SLEngineItf = *const *const SLEngineItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEngineItf_ {
pub CreateLEDDevice: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pDevice: *mut SLObjectItf,
deviceID: SLuint32,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateVibraDevice: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pDevice: *mut SLObjectItf,
deviceID: SLuint32,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateAudioPlayer: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pPlayer: *mut SLObjectItf,
pAudioSrc: *mut SLDataSource,
pAudioSnk: *mut SLDataSink,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateAudioRecorder: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pRecorder: *mut SLObjectItf,
pAudioSrc: *mut SLDataSource,
pAudioSnk: *mut SLDataSink,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateMidiPlayer: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pPlayer: *mut SLObjectItf,
pMIDISrc: *mut SLDataSource,
pBankSrc: *mut SLDataSource,
pAudioOutput: *mut SLDataSink,
pVibra: *mut SLDataSink,
pLEDArray: *mut SLDataSink,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateListener: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pListener: *mut SLObjectItf,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub Create3DGroup: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pGroup: *mut SLObjectItf,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateOutputMix: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pMix: *mut SLObjectItf,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateMetadataExtractor: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pMetadataExtractor: *mut SLObjectItf,
pDataSource: *mut SLDataSource,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub CreateExtensionObject: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pObject: *mut SLObjectItf,
pParameters: *mut ::std::os::raw::c_void,
objectID: SLuint32,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult,
>,
pub QueryNumSupportedInterfaces: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
objectID: SLuint32,
pNumSupportedInterfaces: *mut SLuint32,
) -> SLresult,
>,
pub QuerySupportedInterfaces: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
objectID: SLuint32,
index: SLuint32,
pInterfaceId: *mut SLInterfaceID,
) -> SLresult,
>,
pub QueryNumSupportedExtensions: ::std::option::Option<
unsafe extern "C" fn(self_: SLEngineItf, pNumExtensions: *mut SLuint32) -> SLresult,
>,
pub QuerySupportedExtension: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
index: SLuint32,
pExtensionName: *mut SLchar,
pNameLength: *mut SLint16,
) -> SLresult,
>,
pub IsExtensionSupported: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineItf,
pExtensionName: *const SLchar,
pSupported: *mut SLboolean,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ENGINECAPABILITIES: SLInterfaceID;
}
pub type SLEngineCapabilitiesItf = *const *const SLEngineCapabilitiesItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEngineCapabilitiesItf_ {
pub QuerySupportedProfiles: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pProfilesSupported: *mut SLuint16,
) -> SLresult,
>,
pub QueryAvailableVoices: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
voiceType: SLuint16,
pNumMaxVoices: *mut SLint16,
pIsAbsoluteMax: *mut SLboolean,
pNumFreeVoices: *mut SLint16,
) -> SLresult,
>,
pub QueryNumberOfMIDISynthesizers: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pNumMIDIsynthesizers: *mut SLint16,
) -> SLresult,
>,
pub QueryAPIVersion: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pMajor: *mut SLint16,
pMinor: *mut SLint16,
pStep: *mut SLint16,
) -> SLresult,
>,
pub QueryLEDCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pIndex: *mut SLuint32,
pLEDDeviceID: *mut SLuint32,
pDescriptor: *mut SLLEDDescriptor,
) -> SLresult,
>,
pub QueryVibraCapabilities: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pIndex: *mut SLuint32,
pVibraDeviceID: *mut SLuint32,
pDescriptor: *mut SLVibraDescriptor,
) -> SLresult,
>,
pub IsThreadSafe: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pIsThreadSafe: *mut SLboolean,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_THREADSYNC: SLInterfaceID;
}
pub type SLThreadSyncItf = *const *const SLThreadSyncItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLThreadSyncItf_ {
pub EnterCriticalSection:
::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
pub ExitCriticalSection:
::std::option::Option<unsafe extern "C" fn(self_: SLThreadSyncItf) -> SLresult>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLEngineOption_ {
pub feature: SLuint32,
pub data: SLuint32,
}
pub type SLEngineOption = SLEngineOption_;
extern "C" {
pub fn slCreateEngine(
pEngine: *mut SLObjectItf,
numOptions: SLuint32,
pEngineOptions: *const SLEngineOption,
numInterfaces: SLuint32,
pInterfaceIds: *const SLInterfaceID,
pInterfaceRequired: *const SLboolean,
) -> SLresult;
}
extern "C" {
pub fn slQueryNumSupportedEngineInterfaces(pNumSupportedInterfaces: *mut SLuint32) -> SLresult;
}
extern "C" {
pub fn slQuerySupportedEngineInterfaces(
index: SLuint32,
pInterfaceId: *mut SLInterfaceID,
) -> SLresult;
}
pub type va_list = __builtin_va_list;
pub type __gnuc_va_list = __builtin_va_list;
extern "C" {
pub fn android_get_application_target_sdk_version() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn android_get_device_api_level() -> ::std::os::raw::c_int;
}
pub type size_t = ::std::os::raw::c_uint;
pub type wchar_t = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
pub __clang_max_align_nonce2: f64,
}
pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __int64_t = ::std::os::raw::c_longlong;
pub type __uint64_t = ::std::os::raw::c_ulonglong;
pub type __intptr_t = ::std::os::raw::c_int;
pub type __uintptr_t = ::std::os::raw::c_uint;
pub type int_least8_t = i8;
pub type uint_least8_t = u8;
pub type int_least16_t = i16;
pub type uint_least16_t = u16;
pub type int_least32_t = i32;
pub type uint_least32_t = u32;
pub type int_least64_t = i64;
pub type uint_least64_t = u64;
pub type int_fast8_t = i8;
pub type uint_fast8_t = u8;
pub type int_fast64_t = i64;
pub type uint_fast64_t = u64;
pub type int_fast16_t = i32;
pub type uint_fast16_t = u32;
pub type int_fast32_t = i32;
pub type uint_fast32_t = u32;
pub type uintmax_t = u64;
pub type intmax_t = i64;
pub type jboolean = u8;
pub type jbyte = i8;
pub type jchar = u16;
pub type jshort = i16;
pub type jint = i32;
pub type jlong = i64;
pub type jfloat = f32;
pub type jdouble = f64;
pub type jsize = jint;
pub type jobject = *mut ::std::os::raw::c_void;
pub type jclass = jobject;
pub type jstring = jobject;
pub type jarray = jobject;
pub type jobjectArray = jarray;
pub type jbooleanArray = jarray;
pub type jbyteArray = jarray;
pub type jcharArray = jarray;
pub type jshortArray = jarray;
pub type jintArray = jarray;
pub type jlongArray = jarray;
pub type jfloatArray = jarray;
pub type jdoubleArray = jarray;
pub type jthrowable = jobject;
pub type jweak = jobject;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jfieldID {
_unused: [u8; 0],
}
pub type jfieldID = *mut _jfieldID;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _jmethodID {
_unused: [u8; 0],
}
pub type jmethodID = *mut _jmethodID;
#[repr(C)]
#[derive(Copy, Clone)]
pub union jvalue {
pub z: jboolean,
pub b: jbyte,
pub c: jchar,
pub s: jshort,
pub i: jint,
pub j: jlong,
pub f: jfloat,
pub d: jdouble,
pub l: jobject,
_bindgen_union_align: u64,
}
pub const jobjectRefType_JNIInvalidRefType: jobjectRefType = 0;
pub const jobjectRefType_JNILocalRefType: jobjectRefType = 1;
pub const jobjectRefType_JNIGlobalRefType: jobjectRefType = 2;
pub const jobjectRefType_JNIWeakGlobalRefType: jobjectRefType = 3;
pub type jobjectRefType = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JNINativeMethod {
pub name: *const ::std::os::raw::c_char,
pub signature: *const ::std::os::raw::c_char,
pub fnPtr: *mut ::std::os::raw::c_void,
}
pub type C_JNIEnv = *const JNINativeInterface;
pub type JNIEnv = *const JNINativeInterface;
pub type JavaVM = *const JNIInvokeInterface;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JNINativeInterface {
pub reserved0: *mut ::std::os::raw::c_void,
pub reserved1: *mut ::std::os::raw::c_void,
pub reserved2: *mut ::std::os::raw::c_void,
pub reserved3: *mut ::std::os::raw::c_void,
pub GetVersion: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jint>,
pub DefineClass: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: *const ::std::os::raw::c_char,
arg3: jobject,
arg4: *const jbyte,
arg5: jsize,
) -> jclass,
>,
pub FindClass: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char) -> jclass,
>,
pub FromReflectedMethod:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jmethodID>,
pub FromReflectedField:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jfieldID>,
pub ToReflectedMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: jboolean,
) -> jobject,
>,
pub GetSuperclass:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jclass>,
pub IsAssignableFrom: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jclass) -> jboolean,
>,
pub ToReflectedField: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jfieldID,
arg4: jboolean,
) -> jobject,
>,
pub Throw:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jthrowable) -> jint>,
pub ThrowNew: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const ::std::os::raw::c_char,
) -> jint,
>,
pub ExceptionOccurred:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jthrowable>,
pub ExceptionDescribe: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv)>,
pub ExceptionClear: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv)>,
pub FatalError: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char),
>,
pub PushLocalFrame:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jint) -> jint>,
pub PopLocalFrame:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
pub NewGlobalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
pub DeleteGlobalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject)>,
pub DeleteLocalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject)>,
pub IsSameObject: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jobject) -> jboolean,
>,
pub NewLocalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobject>,
pub EnsureLocalCapacity:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jint) -> jint>,
pub AllocObject:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jobject>,
pub NewObject: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jobject,
>,
pub NewObjectV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jobject,
>,
pub NewObjectA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jobject,
>,
pub GetObjectClass:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jclass>,
pub IsInstanceOf: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass) -> jboolean,
>,
pub GetMethodID: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const ::std::os::raw::c_char,
arg4: *const ::std::os::raw::c_char,
) -> jmethodID,
>,
pub CallObjectMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jobject,
>,
pub CallObjectMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jobject,
>,
pub CallObjectMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jobject,
>,
pub CallBooleanMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jboolean,
>,
pub CallBooleanMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jboolean,
>,
pub CallBooleanMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jboolean,
>,
pub CallByteMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jbyte,
>,
pub CallByteMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jbyte,
>,
pub CallByteMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jbyte,
>,
pub CallCharMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jchar,
>,
pub CallCharMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jchar,
>,
pub CallCharMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jchar,
>,
pub CallShortMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jshort,
>,
pub CallShortMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jshort,
>,
pub CallShortMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jshort,
>,
pub CallIntMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jint,
>,
pub CallIntMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jint,
>,
pub CallIntMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jint,
>,
pub CallLongMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jlong,
>,
pub CallLongMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jlong,
>,
pub CallLongMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jlong,
>,
pub CallFloatMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jfloat,
>,
pub CallFloatMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jfloat,
>,
pub CallFloatMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jfloat,
>,
pub CallDoubleMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...) -> jdouble,
>,
pub CallDoubleMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: va_list,
) -> jdouble,
>,
pub CallDoubleMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
) -> jdouble,
>,
pub CallVoidMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, ...),
>,
pub CallVoidMethodV: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jmethodID, arg4: va_list),
>,
pub CallVoidMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jmethodID,
arg4: *const jvalue,
),
>,
pub CallNonvirtualObjectMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jobject,
>,
pub CallNonvirtualObjectMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jobject,
>,
pub CallNonvirtualObjectMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jobject,
>,
pub CallNonvirtualBooleanMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jboolean,
>,
pub CallNonvirtualBooleanMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jboolean,
>,
pub CallNonvirtualBooleanMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jboolean,
>,
pub CallNonvirtualByteMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jbyte,
>,
pub CallNonvirtualByteMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jbyte,
>,
pub CallNonvirtualByteMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jbyte,
>,
pub CallNonvirtualCharMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jchar,
>,
pub CallNonvirtualCharMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jchar,
>,
pub CallNonvirtualCharMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jchar,
>,
pub CallNonvirtualShortMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jshort,
>,
pub CallNonvirtualShortMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jshort,
>,
pub CallNonvirtualShortMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jshort,
>,
pub CallNonvirtualIntMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jint,
>,
pub CallNonvirtualIntMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jint,
>,
pub CallNonvirtualIntMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jint,
>,
pub CallNonvirtualLongMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jlong,
>,
pub CallNonvirtualLongMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jlong,
>,
pub CallNonvirtualLongMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jlong,
>,
pub CallNonvirtualFloatMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jfloat,
>,
pub CallNonvirtualFloatMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jfloat,
>,
pub CallNonvirtualFloatMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jfloat,
>,
pub CallNonvirtualDoubleMethod: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
...
) -> jdouble,
>,
pub CallNonvirtualDoubleMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
) -> jdouble,
>,
pub CallNonvirtualDoubleMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
) -> jdouble,
>,
pub CallNonvirtualVoidMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jclass, arg4: jmethodID, ...),
>,
pub CallNonvirtualVoidMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: va_list,
),
>,
pub CallNonvirtualVoidMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jobject,
arg3: jclass,
arg4: jmethodID,
arg5: *const jvalue,
),
>,
pub GetFieldID: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const ::std::os::raw::c_char,
arg4: *const ::std::os::raw::c_char,
) -> jfieldID,
>,
pub GetObjectField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jobject,
>,
pub GetBooleanField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jboolean,
>,
pub GetByteField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jbyte,
>,
pub GetCharField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jchar,
>,
pub GetShortField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jshort,
>,
pub GetIntField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jint,
>,
pub GetLongField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jlong,
>,
pub GetFloatField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jfloat,
>,
pub GetDoubleField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID) -> jdouble,
>,
pub SetObjectField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jobject),
>,
pub SetBooleanField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jboolean),
>,
pub SetByteField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jbyte),
>,
pub SetCharField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jchar),
>,
pub SetShortField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jshort),
>,
pub SetIntField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jint),
>,
pub SetLongField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jlong),
>,
pub SetFloatField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jfloat),
>,
pub SetDoubleField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject, arg3: jfieldID, arg4: jdouble),
>,
pub GetStaticMethodID: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const ::std::os::raw::c_char,
arg4: *const ::std::os::raw::c_char,
) -> jmethodID,
>,
pub CallStaticObjectMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jobject,
>,
pub CallStaticObjectMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jobject,
>,
pub CallStaticObjectMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jobject,
>,
pub CallStaticBooleanMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jboolean,
>,
pub CallStaticBooleanMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jboolean,
>,
pub CallStaticBooleanMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jboolean,
>,
pub CallStaticByteMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jbyte,
>,
pub CallStaticByteMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jbyte,
>,
pub CallStaticByteMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jbyte,
>,
pub CallStaticCharMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jchar,
>,
pub CallStaticCharMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jchar,
>,
pub CallStaticCharMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jchar,
>,
pub CallStaticShortMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jshort,
>,
pub CallStaticShortMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jshort,
>,
pub CallStaticShortMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jshort,
>,
pub CallStaticIntMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jint,
>,
pub CallStaticIntMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jint,
>,
pub CallStaticIntMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jint,
>,
pub CallStaticLongMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jlong,
>,
pub CallStaticLongMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jlong,
>,
pub CallStaticLongMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jlong,
>,
pub CallStaticFloatMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jfloat,
>,
pub CallStaticFloatMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jfloat,
>,
pub CallStaticFloatMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jfloat,
>,
pub CallStaticDoubleMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...) -> jdouble,
>,
pub CallStaticDoubleMethodV: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: va_list,
) -> jdouble,
>,
pub CallStaticDoubleMethodA: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: jmethodID,
arg4: *const jvalue,
) -> jdouble,
>,
pub CallStaticVoidMethod: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, ...),
>,
pub CallStaticVoidMethodV: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: va_list),
>,
pub CallStaticVoidMethodA: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jmethodID, arg4: *const jvalue),
>,
pub GetStaticFieldID: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const ::std::os::raw::c_char,
arg4: *const ::std::os::raw::c_char,
) -> jfieldID,
>,
pub GetStaticObjectField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jobject,
>,
pub GetStaticBooleanField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jboolean,
>,
pub GetStaticByteField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jbyte,
>,
pub GetStaticCharField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jchar,
>,
pub GetStaticShortField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jshort,
>,
pub GetStaticIntField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jint,
>,
pub GetStaticLongField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jlong,
>,
pub GetStaticFloatField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jfloat,
>,
pub GetStaticDoubleField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID) -> jdouble,
>,
pub SetStaticObjectField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jobject),
>,
pub SetStaticBooleanField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jboolean),
>,
pub SetStaticByteField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jbyte),
>,
pub SetStaticCharField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jchar),
>,
pub SetStaticShortField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jshort),
>,
pub SetStaticIntField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jint),
>,
pub SetStaticLongField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jlong),
>,
pub SetStaticFloatField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jfloat),
>,
pub SetStaticDoubleField: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass, arg3: jfieldID, arg4: jdouble),
>,
pub NewString: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const jchar, arg3: jsize) -> jstring,
>,
pub GetStringLength:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring) -> jsize>,
pub GetStringChars: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *mut jboolean) -> *const jchar,
>,
pub ReleaseStringChars: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const jchar),
>,
pub NewStringUTF: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *const ::std::os::raw::c_char) -> jstring,
>,
pub GetStringUTFLength:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring) -> jsize>,
pub GetStringUTFChars: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jstring,
arg3: *mut jboolean,
) -> *const ::std::os::raw::c_char,
>,
pub ReleaseStringUTFChars: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const ::std::os::raw::c_char),
>,
pub GetArrayLength:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jarray) -> jsize>,
pub NewObjectArray: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jsize,
arg3: jclass,
arg4: jobject,
) -> jobjectArray,
>,
pub GetObjectArrayElement: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobjectArray, arg3: jsize) -> jobject,
>,
pub SetObjectArrayElement: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobjectArray, arg3: jsize, arg4: jobject),
>,
pub NewBooleanArray: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jbooleanArray,
>,
pub NewByteArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jbyteArray>,
pub NewCharArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jcharArray>,
pub NewShortArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jshortArray>,
pub NewIntArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jintArray>,
pub NewLongArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jlongArray>,
pub NewFloatArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jfloatArray>,
pub NewDoubleArray:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jsize) -> jdoubleArray>,
pub GetBooleanArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbooleanArray,
arg3: *mut jboolean,
) -> *mut jboolean,
>,
pub GetByteArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbyteArray,
arg3: *mut jboolean,
) -> *mut jbyte,
>,
pub GetCharArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jcharArray,
arg3: *mut jboolean,
) -> *mut jchar,
>,
pub GetShortArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jshortArray,
arg3: *mut jboolean,
) -> *mut jshort,
>,
pub GetIntArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jintArray, arg3: *mut jboolean) -> *mut jint,
>,
pub GetLongArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jlongArray,
arg3: *mut jboolean,
) -> *mut jlong,
>,
pub GetFloatArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jfloatArray,
arg3: *mut jboolean,
) -> *mut jfloat,
>,
pub GetDoubleArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jdoubleArray,
arg3: *mut jboolean,
) -> *mut jdouble,
>,
pub ReleaseBooleanArrayElements: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbooleanArray,
arg3: *mut jboolean,
arg4: jint,
),
>,
pub ReleaseByteArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jbyteArray, arg3: *mut jbyte, arg4: jint),
>,
pub ReleaseCharArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jcharArray, arg3: *mut jchar, arg4: jint),
>,
pub ReleaseShortArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jshortArray, arg3: *mut jshort, arg4: jint),
>,
pub ReleaseIntArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jintArray, arg3: *mut jint, arg4: jint),
>,
pub ReleaseLongArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jlongArray, arg3: *mut jlong, arg4: jint),
>,
pub ReleaseFloatArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jfloatArray, arg3: *mut jfloat, arg4: jint),
>,
pub ReleaseDoubleArrayElements: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jdoubleArray, arg3: *mut jdouble, arg4: jint),
>,
pub GetBooleanArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbooleanArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jboolean,
),
>,
pub GetByteArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbyteArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jbyte,
),
>,
pub GetCharArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jcharArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jchar,
),
>,
pub GetShortArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jshortArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jshort,
),
>,
pub GetIntArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jintArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jint,
),
>,
pub GetLongArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jlongArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jlong,
),
>,
pub GetFloatArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jfloatArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jfloat,
),
>,
pub GetDoubleArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jdoubleArray,
arg3: jsize,
arg4: jsize,
arg5: *mut jdouble,
),
>,
pub SetBooleanArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbooleanArray,
arg3: jsize,
arg4: jsize,
arg5: *const jboolean,
),
>,
pub SetByteArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jbyteArray,
arg3: jsize,
arg4: jsize,
arg5: *const jbyte,
),
>,
pub SetCharArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jcharArray,
arg3: jsize,
arg4: jsize,
arg5: *const jchar,
),
>,
pub SetShortArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jshortArray,
arg3: jsize,
arg4: jsize,
arg5: *const jshort,
),
>,
pub SetIntArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jintArray,
arg3: jsize,
arg4: jsize,
arg5: *const jint,
),
>,
pub SetLongArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jlongArray,
arg3: jsize,
arg4: jsize,
arg5: *const jlong,
),
>,
pub SetFloatArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jfloatArray,
arg3: jsize,
arg4: jsize,
arg5: *const jfloat,
),
>,
pub SetDoubleArrayRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jdoubleArray,
arg3: jsize,
arg4: jsize,
arg5: *const jdouble,
),
>,
pub RegisterNatives: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jclass,
arg3: *const JNINativeMethod,
arg4: jint,
) -> jint,
>,
pub UnregisterNatives:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jclass) -> jint>,
pub MonitorEnter:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jint>,
pub MonitorExit:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jint>,
pub GetJavaVM: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: *mut *mut JavaVM) -> jint,
>,
pub GetStringRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jstring,
arg3: jsize,
arg4: jsize,
arg5: *mut jchar,
),
>,
pub GetStringUTFRegion: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jstring,
arg3: jsize,
arg4: jsize,
arg5: *mut ::std::os::raw::c_char,
),
>,
pub GetPrimitiveArrayCritical: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jarray,
arg3: *mut jboolean,
) -> *mut ::std::os::raw::c_void,
>,
pub ReleasePrimitiveArrayCritical: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: jarray,
arg3: *mut ::std::os::raw::c_void,
arg4: jint,
),
>,
pub GetStringCritical: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *mut jboolean) -> *const jchar,
>,
pub ReleaseStringCritical: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jstring, arg3: *const jchar),
>,
pub NewWeakGlobalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jweak>,
pub DeleteWeakGlobalRef:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jweak)>,
pub ExceptionCheck: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv) -> jboolean>,
pub NewDirectByteBuffer: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JNIEnv,
arg2: *mut ::std::os::raw::c_void,
arg3: jlong,
) -> jobject,
>,
pub GetDirectBufferAddress: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> *mut ::std::os::raw::c_void,
>,
pub GetDirectBufferCapacity:
::std::option::Option<unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jlong>,
pub GetObjectRefType: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut JNIEnv, arg2: jobject) -> jobjectRefType,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _JNIEnv {
pub functions: *const JNINativeInterface,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JNIInvokeInterface {
pub reserved0: *mut ::std::os::raw::c_void,
pub reserved1: *mut ::std::os::raw::c_void,
pub reserved2: *mut ::std::os::raw::c_void,
pub DestroyJavaVM: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JavaVM) -> jint>,
pub AttachCurrentThread: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JavaVM,
arg2: *mut *mut JNIEnv,
arg3: *mut ::std::os::raw::c_void,
) -> jint,
>,
pub DetachCurrentThread: ::std::option::Option<unsafe extern "C" fn(arg1: *mut JavaVM) -> jint>,
pub GetEnv: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JavaVM,
arg2: *mut *mut ::std::os::raw::c_void,
arg3: jint,
) -> jint,
>,
pub AttachCurrentThreadAsDaemon: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut JavaVM,
arg2: *mut *mut JNIEnv,
arg3: *mut ::std::os::raw::c_void,
) -> jint,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _JavaVM {
pub functions: *const JNIInvokeInterface,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JavaVMAttachArgs {
pub version: jint,
pub name: *const ::std::os::raw::c_char,
pub group: jobject,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JavaVMOption {
pub optionString: *const ::std::os::raw::c_char,
pub extraInfo: *mut ::std::os::raw::c_void,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct JavaVMInitArgs {
pub version: jint,
pub nOptions: jint,
pub options: *mut JavaVMOption,
pub ignoreUnrecognized: jboolean,
}
extern "C" {
pub fn JNI_GetDefaultJavaVMInitArgs(arg1: *mut ::std::os::raw::c_void) -> jint;
}
extern "C" {
pub fn JNI_CreateJavaVM(
arg1: *mut *mut JavaVM,
arg2: *mut *mut JNIEnv,
arg3: *mut ::std::os::raw::c_void,
) -> jint;
}
extern "C" {
pub fn JNI_GetCreatedJavaVMs(arg1: *mut *mut JavaVM, arg2: jsize, arg3: *mut jsize) -> jint;
}
extern "C" {
pub fn JNI_OnLoad(vm: *mut JavaVM, reserved: *mut ::std::os::raw::c_void) -> jint;
}
extern "C" {
pub fn JNI_OnUnload(vm: *mut JavaVM, reserved: *mut ::std::os::raw::c_void);
}
pub type SLAint64 = sl_int64_t;
pub type SLAuint64 = sl_uint64_t;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidDataFormat_PCM_EX_ {
pub formatType: SLuint32,
pub numChannels: SLuint32,
pub sampleRate: SLuint32,
pub bitsPerSample: SLuint32,
pub containerSize: SLuint32,
pub channelMask: SLuint32,
pub endianness: SLuint32,
pub representation: SLuint32,
}
pub type SLAndroidDataFormat_PCM_EX = SLAndroidDataFormat_PCM_EX_;
extern "C" {
pub static SL_IID_ANDROIDEFFECT: SLInterfaceID;
}
pub type SLAndroidEffectItf = *const *const SLAndroidEffectItf_;
#[doc = " Android Effect interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidEffectItf_ {
pub CreateEffect: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectItf,
effectImplementationId: SLInterfaceID,
) -> SLresult,
>,
pub ReleaseEffect: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectItf,
effectImplementationId: SLInterfaceID,
) -> SLresult,
>,
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectItf,
effectImplementationId: SLInterfaceID,
enabled: SLboolean,
) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectItf,
effectImplementationId: SLInterfaceID,
pEnabled: *mut SLboolean,
) -> SLresult,
>,
pub SendCommand: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectItf,
effectImplementationId: SLInterfaceID,
command: SLuint32,
commandSize: SLuint32,
pCommandData: *mut ::std::os::raw::c_void,
replySize: *mut SLuint32,
pReplyData: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDEFFECTSEND: SLInterfaceID;
}
pub type SLAndroidEffectSendItf = *const *const SLAndroidEffectSendItf_;
#[doc = " Android Effect Send interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidEffectSendItf_ {
pub EnableEffectSend: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectSendItf,
effectImplementationId: SLInterfaceID,
enable: SLboolean,
initialLevel: SLmillibel,
) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectSendItf,
effectImplementationId: SLInterfaceID,
pEnable: *mut SLboolean,
) -> SLresult,
>,
pub SetDirectLevel: ::std::option::Option<
unsafe extern "C" fn(self_: SLAndroidEffectSendItf, directLevel: SLmillibel) -> SLresult,
>,
pub GetDirectLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectSendItf,
pDirectLevel: *mut SLmillibel,
) -> SLresult,
>,
pub SetSendLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectSendItf,
effectImplementationId: SLInterfaceID,
sendLevel: SLmillibel,
) -> SLresult,
>,
pub GetSendLevel: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectSendItf,
effectImplementationId: SLInterfaceID,
pSendLevel: *mut SLmillibel,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDEFFECTCAPABILITIES: SLInterfaceID;
}
pub type SLAndroidEffectCapabilitiesItf = *const *const SLAndroidEffectCapabilitiesItf_;
#[doc = " Android Effect Capabilities interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidEffectCapabilitiesItf_ {
pub QueryNumEffects: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectCapabilitiesItf,
pNumSupportedEffects: *mut SLuint32,
) -> SLresult,
>,
pub QueryEffect: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidEffectCapabilitiesItf,
index: SLuint32,
pEffectType: *mut SLInterfaceID,
pEffectImplementation: *mut SLInterfaceID,
pName: *mut SLchar,
pNameSize: *mut SLuint16,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDCONFIGURATION: SLInterfaceID;
}
pub type SLAndroidConfigurationItf = *const *const SLAndroidConfigurationItf_;
#[doc = " Android Configuration interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidConfigurationItf_ {
pub SetConfiguration: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidConfigurationItf,
configKey: *const SLchar,
pConfigValue: *const ::std::os::raw::c_void,
valueSize: SLuint32,
) -> SLresult,
>,
pub GetConfiguration: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidConfigurationItf,
configKey: *const SLchar,
pValueSize: *mut SLuint32,
pConfigValue: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub AcquireJavaProxy: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidConfigurationItf,
proxyType: SLuint32,
pProxyObj: *mut jobject,
) -> SLresult,
>,
pub ReleaseJavaProxy: ::std::option::Option<
unsafe extern "C" fn(self_: SLAndroidConfigurationItf, proxyType: SLuint32) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDSIMPLEBUFFERQUEUE: SLInterfaceID;
}
pub type SLAndroidSimpleBufferQueueItf = *const *const SLAndroidSimpleBufferQueueItf_;
pub type slAndroidSimpleBufferQueueCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAndroidSimpleBufferQueueItf,
pContext: *mut ::std::os::raw::c_void,
),
>;
#[doc = " Android simple buffer queue state"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidSimpleBufferQueueState_ {
pub count: SLuint32,
pub index: SLuint32,
}
pub type SLAndroidSimpleBufferQueueState = SLAndroidSimpleBufferQueueState_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidSimpleBufferQueueItf_ {
pub Enqueue: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidSimpleBufferQueueItf,
pBuffer: *const ::std::os::raw::c_void,
size: SLuint32,
) -> SLresult,
>,
pub Clear: ::std::option::Option<
unsafe extern "C" fn(self_: SLAndroidSimpleBufferQueueItf) -> SLresult,
>,
pub GetState: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidSimpleBufferQueueItf,
pState: *mut SLAndroidSimpleBufferQueueState,
) -> SLresult,
>,
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidSimpleBufferQueueItf,
callback: slAndroidSimpleBufferQueueCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDBUFFERQUEUESOURCE: SLInterfaceID;
}
pub type SLAndroidBufferQueueItf = *const *const SLAndroidBufferQueueItf_;
#[repr(C)]
#[derive(Debug)]
pub struct SLAndroidBufferItem_ {
pub itemKey: SLuint32,
pub itemSize: SLuint32,
pub itemData: __IncompleteArrayField<SLuint8>,
}
pub type SLAndroidBufferItem = SLAndroidBufferItem_;
pub type slAndroidBufferQueueCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAndroidBufferQueueItf,
pCallbackContext: *mut ::std::os::raw::c_void,
pBufferContext: *mut ::std::os::raw::c_void,
pBufferData: *mut ::std::os::raw::c_void,
dataSize: SLuint32,
dataUsed: SLuint32,
pItems: *const SLAndroidBufferItem,
itemsLength: SLuint32,
) -> SLresult,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidBufferQueueState_ {
pub count: SLuint32,
pub index: SLuint32,
}
pub type SLAndroidBufferQueueState = SLAndroidBufferQueueState_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidBufferQueueItf_ {
pub RegisterCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidBufferQueueItf,
callback: slAndroidBufferQueueCallback,
pCallbackContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub Clear:
::std::option::Option<unsafe extern "C" fn(self_: SLAndroidBufferQueueItf) -> SLresult>,
pub Enqueue: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidBufferQueueItf,
pBufferContext: *mut ::std::os::raw::c_void,
pData: *mut ::std::os::raw::c_void,
dataLength: SLuint32,
pItems: *const SLAndroidBufferItem,
itemsLength: SLuint32,
) -> SLresult,
>,
pub GetState: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidBufferQueueItf,
pState: *mut SLAndroidBufferQueueState,
) -> SLresult,
>,
pub SetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLAndroidBufferQueueItf, eventFlags: SLuint32) -> SLresult,
>,
pub GetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidBufferQueueItf,
pEventFlags: *mut SLuint32,
) -> SLresult,
>,
}
#[doc = " File Descriptor-based data locator definition, locatorType must be SL_DATALOCATOR_ANDROIDFD"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_AndroidFD_ {
pub locatorType: SLuint32,
pub fd: SLint32,
pub offset: SLAint64,
pub length: SLAint64,
}
pub type SLDataLocator_AndroidFD = SLDataLocator_AndroidFD_;
#[doc = " BufferQueue-based data locator definition where locatorType must"]
#[doc = " be SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_AndroidSimpleBufferQueue {
pub locatorType: SLuint32,
pub numBuffers: SLuint32,
}
#[doc = " Android Buffer Queue-based data locator definition,"]
#[doc = " locatorType must be SL_DATALOCATOR_ANDROIDBUFFERQUEUE"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDataLocator_AndroidBufferQueue_ {
pub locatorType: SLuint32,
pub numBuffers: SLuint32,
}
pub type SLDataLocator_AndroidBufferQueue = SLDataLocator_AndroidBufferQueue_;
extern "C" {
pub static SL_IID_ANDROIDACOUSTICECHOCANCELLATION: SLInterfaceID;
}
pub type SLAndroidAcousticEchoCancellationItf = *const *const SLAndroidAcousticEchoCancellationItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidAcousticEchoCancellationItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidAcousticEchoCancellationItf,
enabled: SLboolean,
) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidAcousticEchoCancellationItf,
pEnabled: *mut SLboolean,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDAUTOMATICGAINCONTROL: SLInterfaceID;
}
pub type SLAndroidAutomaticGainControlItf = *const *const SLAndroidAutomaticGainControlItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidAutomaticGainControlItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidAutomaticGainControlItf,
enabled: SLboolean,
) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidAutomaticGainControlItf,
pEnabled: *mut SLboolean,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_ANDROIDNOISESUPPRESSION: SLInterfaceID;
}
pub type SLAndroidNoiseSuppressionItf = *const *const SLAndroidNoiseSuppressionItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidNoiseSuppressionItf_ {
pub SetEnabled: ::std::option::Option<
unsafe extern "C" fn(self_: SLAndroidNoiseSuppressionItf, enabled: SLboolean) -> SLresult,
>,
pub IsEnabled: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAndroidNoiseSuppressionItf,
pEnabled: *mut SLboolean,
) -> SLresult,
>,
}
pub type __builtin_va_list = __va_list;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list {
pub __ap: *mut ::std::os::raw::c_void,
}