/* automatically generated by rust-bindgen */

#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
    #[inline]
    pub fn new() -> Self {
        __IncompleteArrayField(::std::marker::PhantomData, [])
    }
    #[inline]
    pub unsafe fn as_ptr(&self) -> *const T {
        ::std::mem::transmute(self)
    }
    #[inline]
    pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
        ::std::mem::transmute(self)
    }
    #[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")
    }
}
impl<T> ::std::clone::Clone for __IncompleteArrayField<T> {
    #[inline]
    fn clone(&self) -> Self {
        Self::new()
    }
}

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" {
    #[doc = " Returns the API level of the device we\'re actually running on, or -1 on failure."]
    #[doc = " The returned values correspond to the named constants in `<android/api-level.h>`,"]
    #[doc = " and is equivalent to the Java `Build.VERSION.SDK_INT` API."]
    #[doc = ""]
    #[doc = " See also android_get_application_target_sdk_version()."]
    pub fn android_get_device_api_level() -> ::std::os::raw::c_int;
}
pub type wchar_t = ::std::os::raw::c_int;
#[repr(C)]
#[repr(align(16))]
#[derive(Debug, Copy, Clone)]
pub struct max_align_t {
    pub __clang_max_align_nonce1: ::std::os::raw::c_longlong,
    pub __bindgen_padding_0: u64,
    pub __clang_max_align_nonce2: u128,
}
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_long;
pub type __uint64_t = ::std::os::raw::c_ulong;
pub type __intptr_t = ::std::os::raw::c_long;
pub type __uintptr_t = ::std::os::raw::c_ulong;
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 = i64;
pub type uint_fast16_t = u64;
pub type int_fast32_t = i64;
pub type uint_fast32_t = u64;
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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ),
    >,
    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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ),
    >,
    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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ) -> 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: *mut __va_list_tag,
        ),
    >,
    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_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
    pub gp_offset: ::std::os::raw::c_uint,
    pub fp_offset: ::std::os::raw::c_uint,
    pub overflow_arg_area: *mut ::std::os::raw::c_void,
    pub reg_save_area: *mut ::std::os::raw::c_void,
}
