#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
pub type sl_int32_t = i32;
pub type sl_uint32_t = u32;
#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub 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 const KHRONOS_TITLE: &'static [u8; 13usize] = b"KhronosTitle\0";
pub const KHRONOS_ALBUM: &'static [u8; 13usize] = b"KhronosAlbum\0";
pub const KHRONOS_TRACK_NUMBER: &'static [u8; 19usize] = b"KhronosTrackNumber\0";
pub const KHRONOS_ARTIST: &'static [u8; 14usize] = b"KhronosArtist\0";
pub const KHRONOS_GENRE: &'static [u8; 13usize] = b"KhronosGenre\0";
pub const KHRONOS_YEAR: &'static [u8; 12usize] = b"KhronosYear\0";
pub const KHRONOS_COMMENT: &'static [u8; 15usize] = b"KhronosComment\0";
pub const KHRONOS_ARTIST_URL: &'static [u8; 17usize] = b"KhronosArtistURL\0";
pub const KHRONOS_CONTENT_URL: &'static [u8; 18usize] = b"KhronosContentURL\0";
pub const KHRONOS_RATING: &'static [u8; 14usize] = b"KhronosRating\0";
pub const KHRONOS_ALBUM_ART: &'static [u8; 16usize] = b"KhronosAlbumArt\0";
pub const KHRONOS_COPYRIGHT: &'static [u8; 17usize] = b"KhronosCopyright\0";
pub const SL_BOOLEAN_FALSE: u32 = 0;
pub const SL_BOOLEAN_TRUE: u32 = 1;
pub const SL_OBJECTID_ENGINE: u32 = 4097;
pub const SL_OBJECTID_LEDDEVICE: u32 = 4098;
pub const SL_OBJECTID_VIBRADEVICE: u32 = 4099;
pub const SL_OBJECTID_AUDIOPLAYER: u32 = 4100;
pub const SL_OBJECTID_AUDIORECORDER: u32 = 4101;
pub const SL_OBJECTID_MIDIPLAYER: u32 = 4102;
pub const SL_OBJECTID_LISTENER: u32 = 4103;
pub const SL_OBJECTID_3DGROUP: u32 = 4104;
pub const SL_OBJECTID_OUTPUTMIX: u32 = 4105;
pub const SL_OBJECTID_METADATAEXTRACTOR: u32 = 4106;
pub const SL_PROFILES_PHONE: u32 = 1;
pub const SL_PROFILES_MUSIC: u32 = 2;
pub const SL_PROFILES_GAME: u32 = 4;
pub const SL_VOICETYPE_2D_AUDIO: u32 = 1;
pub const SL_VOICETYPE_MIDI: u32 = 2;
pub const SL_VOICETYPE_3D_AUDIO: u32 = 4;
pub const SL_VOICETYPE_3D_MIDIOUTPUT: u32 = 8;
pub const SL_PRIORITY_LOWEST: u32 = 4294967295;
pub const SL_PRIORITY_VERYLOW: u32 = 3758096384;
pub const SL_PRIORITY_LOW: u32 = 3221225472;
pub const SL_PRIORITY_BELOWNORMAL: u32 = 2684354560;
pub const SL_PRIORITY_NORMAL: u32 = 2147483647;
pub const SL_PRIORITY_ABOVENORMAL: u32 = 1610612736;
pub const SL_PRIORITY_HIGH: u32 = 1073741824;
pub const SL_PRIORITY_VERYHIGH: u32 = 536870912;
pub const SL_PRIORITY_HIGHEST: u32 = 0;
pub const SL_PCM_REPRESENTATION_SIGNED_INT: u32 = 1;
pub const SL_PCM_REPRESENTATION_UNSIGNED_INT: u32 = 2;
pub const SL_PCM_REPRESENTATION_FLOAT: u32 = 3;
pub const SL_PCMSAMPLEFORMAT_FIXED_8: u32 = 8;
pub const SL_PCMSAMPLEFORMAT_FIXED_16: u32 = 16;
pub const SL_PCMSAMPLEFORMAT_FIXED_20: u32 = 20;
pub const SL_PCMSAMPLEFORMAT_FIXED_24: u32 = 24;
pub const SL_PCMSAMPLEFORMAT_FIXED_28: u32 = 28;
pub const SL_PCMSAMPLEFORMAT_FIXED_32: u32 = 32;
pub const SL_PCMSAMPLEFORMAT_FIXED_64: u32 = 64;
pub const SL_SAMPLINGRATE_8: u32 = 8000000;
pub const SL_SAMPLINGRATE_11_025: u32 = 11025000;
pub const SL_SAMPLINGRATE_12: u32 = 12000000;
pub const SL_SAMPLINGRATE_16: u32 = 16000000;
pub const SL_SAMPLINGRATE_22_05: u32 = 22050000;
pub const SL_SAMPLINGRATE_24: u32 = 24000000;
pub const SL_SAMPLINGRATE_32: u32 = 32000000;
pub const SL_SAMPLINGRATE_44_1: u32 = 44100000;
pub const SL_SAMPLINGRATE_48: u32 = 48000000;
pub const SL_SAMPLINGRATE_64: u32 = 64000000;
pub const SL_SAMPLINGRATE_88_2: u32 = 88200000;
pub const SL_SAMPLINGRATE_96: u32 = 96000000;
pub const SL_SAMPLINGRATE_192: u32 = 192000000;
pub const SL_SPEAKER_FRONT_LEFT: u32 = 1;
pub const SL_SPEAKER_FRONT_RIGHT: u32 = 2;
pub const SL_SPEAKER_FRONT_CENTER: u32 = 4;
pub const SL_SPEAKER_LOW_FREQUENCY: u32 = 8;
pub const SL_SPEAKER_BACK_LEFT: u32 = 16;
pub const SL_SPEAKER_BACK_RIGHT: u32 = 32;
pub const SL_SPEAKER_FRONT_LEFT_OF_CENTER: u32 = 64;
pub const SL_SPEAKER_FRONT_RIGHT_OF_CENTER: u32 = 128;
pub const SL_SPEAKER_BACK_CENTER: u32 = 256;
pub const SL_SPEAKER_SIDE_LEFT: u32 = 512;
pub const SL_SPEAKER_SIDE_RIGHT: u32 = 1024;
pub const SL_SPEAKER_TOP_CENTER: u32 = 2048;
pub const SL_SPEAKER_TOP_FRONT_LEFT: u32 = 4096;
pub const SL_SPEAKER_TOP_FRONT_CENTER: u32 = 8192;
pub const SL_SPEAKER_TOP_FRONT_RIGHT: u32 = 16384;
pub const SL_SPEAKER_TOP_BACK_LEFT: u32 = 32768;
pub const SL_SPEAKER_TOP_BACK_CENTER: u32 = 65536;
pub const SL_SPEAKER_TOP_BACK_RIGHT: u32 = 131072;
pub const SL_RESULT_SUCCESS: u32 = 0;
pub const SL_RESULT_PRECONDITIONS_VIOLATED: u32 = 1;
pub const SL_RESULT_PARAMETER_INVALID: u32 = 2;
pub const SL_RESULT_MEMORY_FAILURE: u32 = 3;
pub const SL_RESULT_RESOURCE_ERROR: u32 = 4;
pub const SL_RESULT_RESOURCE_LOST: u32 = 5;
pub const SL_RESULT_IO_ERROR: u32 = 6;
pub const SL_RESULT_BUFFER_INSUFFICIENT: u32 = 7;
pub const SL_RESULT_CONTENT_CORRUPTED: u32 = 8;
pub const SL_RESULT_CONTENT_UNSUPPORTED: u32 = 9;
pub const SL_RESULT_CONTENT_NOT_FOUND: u32 = 10;
pub const SL_RESULT_PERMISSION_DENIED: u32 = 11;
pub const SL_RESULT_FEATURE_UNSUPPORTED: u32 = 12;
pub const SL_RESULT_INTERNAL_ERROR: u32 = 13;
pub const SL_RESULT_UNKNOWN_ERROR: u32 = 14;
pub const SL_RESULT_OPERATION_ABORTED: u32 = 15;
pub const SL_RESULT_CONTROL_LOST: u32 = 16;
pub const SL_RESULT_READONLY: u32 = 17;
pub const SL_RESULT_ENGINEOPTION_UNSUPPORTED: u32 = 18;
pub const SL_RESULT_SOURCE_SINK_INCOMPATIBLE: u32 = 19;
pub const SL_OBJECT_STATE_UNREALIZED: u32 = 1;
pub const SL_OBJECT_STATE_REALIZED: u32 = 2;
pub const SL_OBJECT_STATE_SUSPENDED: u32 = 3;
pub const SL_OBJECT_EVENT_RUNTIME_ERROR: u32 = 1;
pub const SL_OBJECT_EVENT_ASYNC_TERMINATION: u32 = 2;
pub const SL_OBJECT_EVENT_RESOURCES_LOST: u32 = 3;
pub const SL_OBJECT_EVENT_RESOURCES_AVAILABLE: u32 = 4;
pub const SL_OBJECT_EVENT_ITF_CONTROL_TAKEN: u32 = 5;
pub const SL_OBJECT_EVENT_ITF_CONTROL_RETURNED: u32 = 6;
pub const SL_OBJECT_EVENT_ITF_PARAMETERS_CHANGED: u32 = 7;
pub const SL_DATALOCATOR_NULL: u32 = 0;
pub const SL_DATALOCATOR_URI: u32 = 1;
pub const SL_DATALOCATOR_ADDRESS: u32 = 2;
pub const SL_DATALOCATOR_IODEVICE: u32 = 3;
pub const SL_DATALOCATOR_OUTPUTMIX: u32 = 4;
pub const SL_DATALOCATOR_RESERVED5: u32 = 5;
pub const SL_DATALOCATOR_BUFFERQUEUE: u32 = 6;
pub const SL_DATALOCATOR_MIDIBUFFERQUEUE: u32 = 7;
pub const SL_DATALOCATOR_MEDIAOBJECT: u32 = 8;
pub const SL_DATALOCATOR_CONTENTPIPE: u32 = 9;
pub const SL_IODEVICE_AUDIOINPUT: u32 = 1;
pub const SL_IODEVICE_LEDARRAY: u32 = 2;
pub const SL_IODEVICE_VIBRA: u32 = 3;
pub const SL_IODEVICE_RESERVED4: u32 = 4;
pub const SL_IODEVICE_RESERVED5: u32 = 5;
pub const SL_IODEVICE_AUDIOOUTPUT: u32 = 6;
pub const SL_DATAFORMAT_MIME: u32 = 1;
pub const SL_DATAFORMAT_PCM: u32 = 2;
pub const SL_DATAFORMAT_RESERVED3: u32 = 3;
pub const SL_DATAFORMAT_PCM_EX: u32 = 4;
pub const SL_BYTEORDER_BIGENDIAN: u32 = 1;
pub const SL_BYTEORDER_LITTLEENDIAN: u32 = 2;
pub const SL_BYTEORDER_NATIVE: u32 = 2;
pub const SL_CONTAINERTYPE_UNSPECIFIED: u32 = 1;
pub const SL_CONTAINERTYPE_RAW: u32 = 2;
pub const SL_CONTAINERTYPE_ASF: u32 = 3;
pub const SL_CONTAINERTYPE_AVI: u32 = 4;
pub const SL_CONTAINERTYPE_BMP: u32 = 5;
pub const SL_CONTAINERTYPE_JPG: u32 = 6;
pub const SL_CONTAINERTYPE_JPG2000: u32 = 7;
pub const SL_CONTAINERTYPE_M4A: u32 = 8;
pub const SL_CONTAINERTYPE_MP3: u32 = 9;
pub const SL_CONTAINERTYPE_MP4: u32 = 10;
pub const SL_CONTAINERTYPE_MPEG_ES: u32 = 11;
pub const SL_CONTAINERTYPE_MPEG_PS: u32 = 12;
pub const SL_CONTAINERTYPE_MPEG_TS: u32 = 13;
pub const SL_CONTAINERTYPE_QT: u32 = 14;
pub const SL_CONTAINERTYPE_WAV: u32 = 15;
pub const SL_CONTAINERTYPE_XMF_0: u32 = 16;
pub const SL_CONTAINERTYPE_XMF_1: u32 = 17;
pub const SL_CONTAINERTYPE_XMF_2: u32 = 18;
pub const SL_CONTAINERTYPE_XMF_3: u32 = 19;
pub const SL_CONTAINERTYPE_XMF_GENERIC: u32 = 20;
pub const SL_CONTAINERTYPE_AMR: u32 = 21;
pub const SL_CONTAINERTYPE_AAC: u32 = 22;
pub const SL_CONTAINERTYPE_3GPP: u32 = 23;
pub const SL_CONTAINERTYPE_3GA: u32 = 24;
pub const SL_CONTAINERTYPE_RM: u32 = 25;
pub const SL_CONTAINERTYPE_DMF: u32 = 26;
pub const SL_CONTAINERTYPE_SMF: u32 = 27;
pub const SL_CONTAINERTYPE_MOBILE_DLS: u32 = 28;
pub const SL_CONTAINERTYPE_OGG: u32 = 29;
pub const SL_DEFAULTDEVICEID_AUDIOINPUT: u32 = 4294967295;
pub const SL_DEFAULTDEVICEID_AUDIOOUTPUT: u32 = 4294967294;
pub const SL_DEFAULTDEVICEID_LED: u32 = 4294967293;
pub const SL_DEFAULTDEVICEID_VIBRA: u32 = 4294967292;
pub const SL_DEFAULTDEVICEID_RESERVED1: u32 = 4294967291;
pub const SL_DEVLOCATION_HANDSET: u32 = 1;
pub const SL_DEVLOCATION_HEADSET: u32 = 2;
pub const SL_DEVLOCATION_CARKIT: u32 = 3;
pub const SL_DEVLOCATION_DOCK: u32 = 4;
pub const SL_DEVLOCATION_REMOTE: u32 = 5;
pub const SL_DEVLOCATION_RESLTE: u32 = 5;
pub const SL_DEVSCOPE_UNKNOWN: u32 = 1;
pub const SL_DEVSCOPE_ENVIRONMENT: u32 = 2;
pub const SL_DEVSCOPE_USER: u32 = 3;
pub const SL_CHARACTERENCODING_UNKNOWN: u32 = 0;
pub const SL_CHARACTERENCODING_BINARY: u32 = 1;
pub const SL_CHARACTERENCODING_ASCII: u32 = 2;
pub const SL_CHARACTERENCODING_BIG5: u32 = 3;
pub const SL_CHARACTERENCODING_CODEPAGE1252: u32 = 4;
pub const SL_CHARACTERENCODING_GB2312: u32 = 5;
pub const SL_CHARACTERENCODING_HZGB2312: u32 = 6;
pub const SL_CHARACTERENCODING_GB12345: u32 = 7;
pub const SL_CHARACTERENCODING_GB18030: u32 = 8;
pub const SL_CHARACTERENCODING_GBK: u32 = 9;
pub const SL_CHARACTERENCODING_IMAPUTF7: u32 = 10;
pub const SL_CHARACTERENCODING_ISO2022JP: u32 = 11;
pub const SL_CHARACTERENCODING_ISO2022JP1: u32 = 11;
pub const SL_CHARACTERENCODING_ISO88591: u32 = 12;
pub const SL_CHARACTERENCODING_ISO885910: u32 = 13;
pub const SL_CHARACTERENCODING_ISO885913: u32 = 14;
pub const SL_CHARACTERENCODING_ISO885914: u32 = 15;
pub const SL_CHARACTERENCODING_ISO885915: u32 = 16;
pub const SL_CHARACTERENCODING_ISO88592: u32 = 17;
pub const SL_CHARACTERENCODING_ISO88593: u32 = 18;
pub const SL_CHARACTERENCODING_ISO88594: u32 = 19;
pub const SL_CHARACTERENCODING_ISO88595: u32 = 20;
pub const SL_CHARACTERENCODING_ISO88596: u32 = 21;
pub const SL_CHARACTERENCODING_ISO88597: u32 = 22;
pub const SL_CHARACTERENCODING_ISO88598: u32 = 23;
pub const SL_CHARACTERENCODING_ISO88599: u32 = 24;
pub const SL_CHARACTERENCODING_ISOEUCJP: u32 = 25;
pub const SL_CHARACTERENCODING_SHIFTJIS: u32 = 26;
pub const SL_CHARACTERENCODING_SMS7BIT: u32 = 27;
pub const SL_CHARACTERENCODING_UTF7: u32 = 28;
pub const SL_CHARACTERENCODING_UTF8: u32 = 29;
pub const SL_CHARACTERENCODING_JAVACONFORMANTUTF8: u32 = 30;
pub const SL_CHARACTERENCODING_UTF16BE: u32 = 31;
pub const SL_CHARACTERENCODING_UTF16LE: u32 = 32;
pub const SL_METADATATRAVERSALMODE_ALL: u32 = 1;
pub const SL_METADATATRAVERSALMODE_NODE: u32 = 2;
pub const SL_NODETYPE_UNSPECIFIED: u32 = 1;
pub const SL_NODETYPE_AUDIO: u32 = 2;
pub const SL_NODETYPE_VIDEO: u32 = 3;
pub const SL_NODETYPE_IMAGE: u32 = 4;
pub const SL_NODE_PARENT: u32 = 4294967295;
pub const SL_PLAYSTATE_STOPPED: u32 = 1;
pub const SL_PLAYSTATE_PAUSED: u32 = 2;
pub const SL_PLAYSTATE_PLAYING: u32 = 3;
pub const SL_PLAYEVENT_HEADATEND: u32 = 1;
pub const SL_PLAYEVENT_HEADATMARKER: u32 = 2;
pub const SL_PLAYEVENT_HEADATNEWPOS: u32 = 4;
pub const SL_PLAYEVENT_HEADMOVING: u32 = 8;
pub const SL_PLAYEVENT_HEADSTALLED: u32 = 16;
pub const SL_PLAYEVENT_DURATIONUPDATED: u32 = 32;
pub const SL_TIME_UNKNOWN: u32 = 4294967295;
pub const SL_PREFETCHEVENT_STATUSCHANGE: u32 = 1;
pub const SL_PREFETCHEVENT_FILLLEVELCHANGE: u32 = 2;
pub const SL_PREFETCHEVENT_ERROR: u32 = 3;
pub const SL_PREFETCHEVENT_ERROR_UNRECOVERABLE: u32 = 4;
pub const SL_PREFETCHSTATUS_UNDERFLOW: u32 = 1;
pub const SL_PREFETCHSTATUS_SUFFICIENTDATA: u32 = 2;
pub const SL_PREFETCHSTATUS_OVERFLOW: u32 = 3;
pub const SL_RATEPROP_RESERVED1: u32 = 1;
pub const SL_RATEPROP_RESERVED2: u32 = 2;
pub const SL_RATEPROP_SILENTAUDIO: u32 = 256;
pub const SL_RATEPROP_STAGGEREDAUDIO: u32 = 512;
pub const SL_RATEPROP_NOPITCHCORAUDIO: u32 = 1024;
pub const SL_RATEPROP_PITCHCORAUDIO: u32 = 2048;
pub const SL_SEEKMODE_FAST: u32 = 1;
pub const SL_SEEKMODE_ACCURATE: u32 = 2;
pub const SL_RECORDSTATE_STOPPED: u32 = 1;
pub const SL_RECORDSTATE_PAUSED: u32 = 2;
pub const SL_RECORDSTATE_RECORDING: u32 = 3;
pub const SL_RECORDEVENT_HEADATLIMIT: u32 = 1;
pub const SL_RECORDEVENT_HEADATMARKER: u32 = 2;
pub const SL_RECORDEVENT_HEADATNEWPOS: u32 = 4;
pub const SL_RECORDEVENT_HEADMOVING: u32 = 8;
pub const SL_RECORDEVENT_HEADSTALLED: u32 = 16;
pub const SL_RECORDEVENT_BUFFER_INSUFFICIENT: u32 = 32;
pub const SL_RECORDEVENT_BUFFER_FULL: u32 = 32;
pub const SL_RECORDEVENT_BUFFERQUEUE_STARVED: u32 = 64;
pub const SL_EQUALIZER_UNDEFINED: u32 = 65535;
pub const SL_BUFFERQUEUEEVENT_PROCESSED: u32 = 1;
pub const SL_BUFFERQUEUEEVENT_UNREALIZED: u32 = 2;
pub const SL_BUFFERQUEUEEVENT_CLEARED: u32 = 4;
pub const SL_BUFFERQUEUEEVENT_STOPPED: u32 = 8;
pub const SL_BUFFERQUEUEEVENT_ERROR: u32 = 16;
pub const SL_BUFFERQUEUEEVENT_CONTENT_END: u32 = 32;
pub const SL_REVERBPRESET_NONE: u32 = 0;
pub const SL_REVERBPRESET_SMALLROOM: u32 = 1;
pub const SL_REVERBPRESET_MEDIUMROOM: u32 = 2;
pub const SL_REVERBPRESET_LARGEROOM: u32 = 3;
pub const SL_REVERBPRESET_MEDIUMHALL: u32 = 4;
pub const SL_REVERBPRESET_LARGEHALL: u32 = 5;
pub const SL_REVERBPRESET_PLATE: u32 = 6;
pub const SL_3DHINT_OFF: u32 = 0;
pub const SL_3DHINT_QUALITY_LOWEST: u32 = 1;
pub const SL_3DHINT_QUALITY_LOW: u32 = 16384;
pub const SL_3DHINT_QUALITY_MEDIUM: u32 = 32768;
pub const SL_3DHINT_QUALITY_HIGH: u32 = 49152;
pub const SL_3DHINT_QUALITY_HIGHEST: u32 = 65535;
pub const SL_ROLLOFFMODEL_EXPONENTIAL: u32 = 0;
pub const SL_ROLLOFFMODEL_LINEAR: u32 = 1;
pub const SL_DYNAMIC_ITF_EVENT_RUNTIME_ERROR: u32 = 1;
pub const SL_DYNAMIC_ITF_EVENT_ASYNC_TERMINATION: u32 = 2;
pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST: u32 = 3;
pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST_PERMANENTLY: u32 = 4;
pub const SL_DYNAMIC_ITF_EVENT_RESOURCES_AVAILABLE: u32 = 5;
pub const SL_MIDIMESSAGETYPE_NOTE_ON_OFF: u32 = 1;
pub const SL_MIDIMESSAGETYPE_POLY_PRESSURE: u32 = 2;
pub const SL_MIDIMESSAGETYPE_CONTROL_CHANGE: u32 = 3;
pub const SL_MIDIMESSAGETYPE_PROGRAM_CHANGE: u32 = 4;
pub const SL_MIDIMESSAGETYPE_CHANNEL_PRESSURE: u32 = 5;
pub const SL_MIDIMESSAGETYPE_PITCH_BEND: u32 = 6;
pub const SL_MIDIMESSAGETYPE_SYSTEM_MESSAGE: u32 = 7;
pub const SL_AUDIOSTREAMFORMAT_UNDEFINED: u32 = 0;
pub const SL_RATECONTROLMODE_CONSTANTBITRATE: u32 = 1;
pub const SL_RATECONTROLMODE_VARIABLEBITRATE: u32 = 2;
pub const SL_AUDIOCODEC_PCM: u32 = 1;
pub const SL_AUDIOCODEC_MP3: u32 = 2;
pub const SL_AUDIOCODEC_AMR: u32 = 3;
pub const SL_AUDIOCODEC_AMRWB: u32 = 4;
pub const SL_AUDIOCODEC_AMRWBPLUS: u32 = 5;
pub const SL_AUDIOCODEC_AAC: u32 = 6;
pub const SL_AUDIOCODEC_WMA: u32 = 7;
pub const SL_AUDIOCODEC_REAL: u32 = 8;
pub const SL_AUDIOCODEC_VORBIS: u32 = 9;
pub const SL_AUDIOPROFILE_PCM: u32 = 1;
pub const SL_AUDIOPROFILE_MPEG1_L3: u32 = 1;
pub const SL_AUDIOPROFILE_MPEG2_L3: u32 = 2;
pub const SL_AUDIOPROFILE_MPEG25_L3: u32 = 3;
pub const SL_AUDIOCHANMODE_MP3_MONO: u32 = 1;
pub const SL_AUDIOCHANMODE_MP3_STEREO: u32 = 2;
pub const SL_AUDIOCHANMODE_MP3_JOINTSTEREO: u32 = 3;
pub const SL_AUDIOCHANMODE_MP3_DUAL: u32 = 4;
pub const SL_AUDIOPROFILE_AMR: u32 = 1;
pub const SL_AUDIOSTREAMFORMAT_CONFORMANCE: u32 = 1;
pub const SL_AUDIOSTREAMFORMAT_IF1: u32 = 2;
pub const SL_AUDIOSTREAMFORMAT_IF2: u32 = 3;
pub const SL_AUDIOSTREAMFORMAT_FSF: u32 = 4;
pub const SL_AUDIOSTREAMFORMAT_RTPPAYLOAD: u32 = 5;
pub const SL_AUDIOSTREAMFORMAT_ITU: u32 = 6;
pub const SL_AUDIOPROFILE_AMRWB: u32 = 1;
pub const SL_AUDIOPROFILE_AMRWBPLUS: u32 = 1;
pub const SL_AUDIOPROFILE_AAC_AAC: u32 = 1;
pub const SL_AUDIOMODE_AAC_MAIN: u32 = 1;
pub const SL_AUDIOMODE_AAC_LC: u32 = 2;
pub const SL_AUDIOMODE_AAC_SSR: u32 = 3;
pub const SL_AUDIOMODE_AAC_LTP: u32 = 4;
pub const SL_AUDIOMODE_AAC_HE: u32 = 5;
pub const SL_AUDIOMODE_AAC_SCALABLE: u32 = 6;
pub const SL_AUDIOMODE_AAC_ERLC: u32 = 7;
pub const SL_AUDIOMODE_AAC_LD: u32 = 8;
pub const SL_AUDIOMODE_AAC_HE_PS: u32 = 9;
pub const SL_AUDIOMODE_AAC_HE_MPS: u32 = 10;
pub const SL_AUDIOSTREAMFORMAT_MP2ADTS: u32 = 1;
pub const SL_AUDIOSTREAMFORMAT_MP4ADTS: u32 = 2;
pub const SL_AUDIOSTREAMFORMAT_MP4LOAS: u32 = 3;
pub const SL_AUDIOSTREAMFORMAT_MP4LATM: u32 = 4;
pub const SL_AUDIOSTREAMFORMAT_ADIF: u32 = 5;
pub const SL_AUDIOSTREAMFORMAT_MP4FF: u32 = 6;
pub const SL_AUDIOSTREAMFORMAT_RAW: u32 = 7;
pub const SL_AUDIOPROFILE_WMA7: u32 = 1;
pub const SL_AUDIOPROFILE_WMA8: u32 = 2;
pub const SL_AUDIOPROFILE_WMA9: u32 = 3;
pub const SL_AUDIOPROFILE_WMA10: u32 = 4;
pub const SL_AUDIOMODE_WMA_LEVEL1: u32 = 1;
pub const SL_AUDIOMODE_WMA_LEVEL2: u32 = 2;
pub const SL_AUDIOMODE_WMA_LEVEL3: u32 = 3;
pub const SL_AUDIOMODE_WMA_LEVEL4: u32 = 4;
pub const SL_AUDIOMODE_WMAPRO_LEVELM0: u32 = 5;
pub const SL_AUDIOMODE_WMAPRO_LEVELM1: u32 = 6;
pub const SL_AUDIOMODE_WMAPRO_LEVELM2: u32 = 7;
pub const SL_AUDIOMODE_WMAPRO_LEVELM3: u32 = 8;
pub const SL_AUDIOPROFILE_REALAUDIO: u32 = 1;
pub const SL_AUDIOMODE_REALAUDIO_G2: u32 = 1;
pub const SL_AUDIOMODE_REALAUDIO_8: u32 = 2;
pub const SL_AUDIOMODE_REALAUDIO_10: u32 = 3;
pub const SL_AUDIOMODE_REALAUDIO_SURROUND: u32 = 4;
pub const SL_ENGINEOPTION_THREADSAFE: u32 = 1;
pub const SL_ENGINEOPTION_LOSSOFCONTROL: u32 = 2;
pub const SL_ENGINEOPTION_MAJORVERSION: u32 = 3;
pub const SL_ENGINEOPTION_MINORVERSION: u32 = 4;
pub const SL_ENGINEOPTION_STEPVERSION: u32 = 5;
pub const SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT: u32 = 1;
pub const SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT: u32 = 2;
pub const SL_ANDROID_PCM_REPRESENTATION_FLOAT: u32 = 3;
pub const SL_ANDROID_DATAFORMAT_PCM_EX: u32 = 4;
pub const SL_ANDROID_SPEAKER_NON_POSITIONAL: u32 = 2147483648;
pub const SL_ANDROID_SPEAKER_USE_DEFAULT: u32 = 0;
pub const SL_ANDROID_ITEMKEY_NONE: u32 = 0;
pub const SL_ANDROID_ITEMKEY_EOS: u32 = 1;
pub const SL_ANDROID_ITEMKEY_DISCONTINUITY: u32 = 2;
pub const SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT: u32 = 3;
pub const SL_ANDROID_ITEMKEY_FORMAT_CHANGE: u32 = 4;
pub const SL_ANDROIDBUFFERQUEUEEVENT_NONE: u32 = 0;
pub const SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED: u32 = 1;
pub const SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: u32 = 2147485629;
pub const SL_DATALOCATOR_ANDROIDBUFFERQUEUE: u32 = 2147485630;
pub type sl_char_t = ::std::os::raw::c_char;
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_float32_t = f32;
pub type sl_float64_t = f64;
pub type SLchar = sl_char_t;
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 SLfloat32 = sl_float32_t;
pub type Slfloat64 = sl_float64_t;
pub type SLboolean = SLuint32;
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)]
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)]
pub struct SLDataLocator_URI_ {
pub locatorType: SLuint32,
pub pURI: *const SLchar,
}
pub type SLDataLocator_URI = SLDataLocator_URI_;
#[doc = " Address-based data locator definition where locatorType must be SL_DATALOCATOR_ADDRESS"]
#[repr(C)]
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)]
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)]
pub struct SLDataLocator_OutputMix_ {
pub locatorType: SLuint32,
pub outputMix: SLObjectItf,
}
pub type SLDataLocator_OutputMix = SLDataLocator_OutputMix_;
#[doc = " BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_BUFFERQUEUE"]
#[repr(C)]
pub struct SLDataLocator_BufferQueue_ {
pub locatorType: SLuint32,
pub numBuffers: SLuint32,
}
pub type SLDataLocator_BufferQueue = SLDataLocator_BufferQueue_;
#[doc = " ContentPipe-based data locator definition where locatorType must be SL_DATALOCATOR_CONTENTPIPE"]
#[repr(C)]
pub struct SLDataLocator_ContentPipe_ {
pub locatorType: SLuint32,
pub pContentPipe: *mut ::std::os::raw::c_void,
pub pURI: *const SLchar,
}
pub type SLDataLocator_ContentPipe = SLDataLocator_ContentPipe_;
#[doc = " MidiBufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_MIDIBUFFERQUEUE"]
#[repr(C)]
pub struct SLDataLocator_MIDIBufferQueue_ {
pub locatorType: SLuint32,
pub tpqn: SLuint32,
pub numBuffers: SLuint32,
}
pub type SLDataLocator_MIDIBufferQueue = SLDataLocator_MIDIBufferQueue_;
#[doc = " MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME"]
#[repr(C)]
pub struct SLDataFormat_MIME_ {
pub formatType: SLuint32,
pub pMimeType: *const 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)]
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_;
#[doc = " PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM_EX"]
#[repr(C)]
pub struct SLDataFormat_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 SLDataFormat_PCM_EX = SLDataFormat_PCM_EX_;
#[doc = " MediaObject-type-based data format definition where formatType must be SL_DATAFORMAT_MEDIAOBJECT"]
#[repr(C)]
pub struct SLDataLocator_MediaObject_ {
pub locatorType: SLuint32,
pub mediaObject: SLObjectItf,
}
pub type SLDataLocator_MediaObject = SLDataLocator_MediaObject_;
#[doc = " NULL-type-based data format definition where formatType must be SL_DATAFORMAT_NULL"]
#[repr(C)]
pub struct SLDataLocator_Null_ {
pub locatorType: SLuint32,
}
pub type SLDataLocator_Null = SLDataLocator_Null_;
#[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: SLuint32) -> SLresult,
>,
pub GetPriority: ::std::option::Option<
unsafe extern "C" fn(self_: SLObjectItf, pPriority: *mut SLuint32) -> SLresult,
>,
pub SetLossOfControlInterfaces: ::std::option::Option<
unsafe extern "C" fn(
self_: SLObjectItf,
numInterfaces: SLuint16,
pInterfaceIDs: *const SLInterfaceID,
enabled: SLboolean,
) -> SLresult,
>,
}
#[repr(C)]
pub struct SLAudioInputDescriptor_ {
pub pDeviceName: *mut SLchar,
pub deviceNameLength: SLint16,
pub deviceConnection: SLint16,
pub deviceScope: SLint16,
pub deviceLocation: SLint16,
pub isForTelephony: SLboolean,
pub minSampleRate: SLmilliHertz,
pub maxSampleRate: SLmilliHertz,
pub isFreqRangeContinuous: SLboolean,
pub pSamplingRatesSupported: *mut SLmilliHertz,
pub numOfSamplingRatesSupported: SLint16,
pub maxChannels: SLint16,
}
pub type SLAudioInputDescriptor = SLAudioInputDescriptor_;
#[repr(C)]
pub struct SLAudioOutputDescriptor_ {
pub pDeviceName: *mut SLchar,
pub deviceNameLength: SLint16,
pub deviceConnection: SLint16,
pub deviceScope: SLint16,
pub deviceLocation: SLint16,
pub isForTelephony: SLboolean,
pub minSampleRate: SLmilliHertz,
pub maxSampleRate: SLmilliHertz,
pub isFreqRangeContinuous: SLboolean,
pub pSamplingRatesSupported: *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: SLuint32,
isNew: SLboolean,
),
>;
pub type slAvailableAudioOutputsChangedCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAudioIODeviceCapabilitiesItf,
pContext: *mut ::std::os::raw::c_void,
deviceID: SLuint32,
numOutputs: SLuint32,
isNew: SLboolean,
),
>;
pub type slDefaultDeviceIDMapChangedCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLAudioIODeviceCapabilitiesItf,
pContext: *mut ::std::os::raw::c_void,
isOutput: SLboolean,
numDevices: SLuint32,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAudioIODeviceCapabilitiesItf_ {
pub GetAvailableAudioInputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
pNumInputs: *mut SLuint32,
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 SLuint32,
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 SLuint32,
pAudioInputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub GetAssociatedAudioOutputs: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
pNumAudioOutputs: *mut SLuint32,
pAudioOutputDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub GetDefaultAudioDevices: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
defaultDeviceID: SLuint32,
pNumAudioDevices: *mut SLuint32,
pAudioDeviceIDs: *mut SLuint32,
) -> SLresult,
>,
pub QuerySampleFormatsSupported: ::std::option::Option<
unsafe extern "C" fn(
self_: SLAudioIODeviceCapabilitiesItf,
deviceId: SLuint32,
samplingRate: SLmilliHertz,
pSampleFormats: *mut SLint32,
pNumOfSampleFormats: *mut SLuint32,
) -> SLresult,
>,
}
#[repr(C)]
pub struct SLLEDDescriptor_ {
pub ledCount: SLuint8,
pub primaryLED: SLuint8,
pub colorMask: SLuint32,
}
pub type SLLEDDescriptor = SLLEDDescriptor_;
#[repr(C)]
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)]
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)]
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_METADATAMESSAGE: SLInterfaceID;
}
pub type SLMetadataMessageItf = *const *const SLMetadataMessageItf_;
pub type slMetadataCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLMetadataMessageItf,
pContext: *mut ::std::os::raw::c_void,
index: SLuint32,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLMetadataMessageItf_ {
pub RegisterMetadataCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLMetadataMessageItf,
callback: slMetadataCallback,
pContext: *mut ::std::os::raw::c_void,
) -> 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: *const SLDataSource,
) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_DYNAMICSOURCESINKCHANGE: SLInterfaceID;
}
pub type SLDynamicSourceSinkChangeItf = *const *const SLDynamicSourceSinkChangeItf_;
pub type slSourceChangeCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLDynamicSourceSinkChangeItf,
pContext: *mut ::std::os::raw::c_void,
resultCode: SLuint32,
pExistingDataSource: *const SLDataSource,
pNewDataSource: *const SLDataSource,
),
>;
pub type slSinkChangeCallback = ::std::option::Option<
unsafe extern "C" fn(
caller: SLDynamicSourceSinkChangeItf,
pContext: *mut ::std::os::raw::c_void,
resultCode: SLuint32,
pExistingDataSink: *const SLDataSource,
pNewDataSink: *const SLDataSource,
),
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLDynamicSourceSinkChangeItf_ {
pub ChangeSource: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicSourceSinkChangeItf,
pExistingDataSource: *const SLDataSource,
pNewDataSource: *const SLDataSource,
async_: SLboolean,
) -> SLresult,
>,
pub ChangeSink: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicSourceSinkChangeItf,
pExistingDataSink: *const SLDataSink,
pNewDataSink: *const SLDataSink,
async_: SLboolean,
) -> SLresult,
>,
pub RegisterSourceChangeCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicSourceSinkChangeItf,
callback: slSourceChangeCallback,
pContext: *mut ::std::os::raw::c_void,
) -> SLresult,
>,
pub RegisterSinkChangeCallback: ::std::option::Option<
unsafe extern "C" fn(
self_: SLDynamicSourceSinkChangeItf,
callback: slSinkChangeCallback,
pContext: *mut ::std::os::raw::c_void,
) -> 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,
>,
pub GetError: ::std::option::Option<
unsafe extern "C" fn(self_: SLPrefetchStatusItf, pResult: *mut SLresult) -> 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,
pSize: *mut SLuint16,
pName: *mut 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,
eventFlags: SLuint32,
pBuffer: *const ::std::os::raw::c_void,
bufferSize: SLuint32,
dataUsed: SLuint32,
pContext: *mut ::std::os::raw::c_void,
),
>;
#[doc = " Buffer queue state"]
#[repr(C)]
pub struct SLBufferQueueState_ {
pub count: SLuint32,
pub index: 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,
isLastBuffer: SLboolean,
) -> 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,
>,
pub SetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLBufferQueueItf, eventFlags: SLuint32) -> SLresult,
>,
pub GetCallbackEventsMask: ::std::option::Option<
unsafe extern "C" fn(self_: SLBufferQueueItf, pEventFlags: *mut SLuint32) -> SLresult,
>,
}
extern "C" {
pub static SL_IID_CONFIGEXTENSION: SLInterfaceID;
}
pub type SLConfigExtensionsItf = *const *const SLConfigExtensionsItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLConfigExtensionsItf_ {
pub SetConfiguration: ::std::option::Option<
unsafe extern "C" fn(
self_: SLConfigExtensionsItf,
pConfigKey: *const SLchar,
valueSize: SLuint32,
pConfigValue: *const ::std::os::raw::c_void,
) -> SLresult,
>,
pub GetConfiguration: ::std::option::Option<
unsafe extern "C" fn(
self_: SLConfigExtensionsItf,
pConfigKey: *const SLchar,
pValueSize: *mut SLuint32,
pConfigValue: *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)]
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_3DHINT: SLInterfaceID;
}
pub type SL3DHintItf = *const *const SL3DHintItf_;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SL3DHintItf_ {
pub SetRenderHint: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DHintItf, qualityHint: SLuint16) -> SLresult,
>,
pub GetRenderHint: ::std::option::Option<
unsafe extern "C" fn(self_: SL3DHintItf, pQualityHint: *mut SLuint16) -> 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)]
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,
pData: *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)]
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 streamFormat: SLuint32,
}
pub type SLAudioCodecDescriptor = SLAudioCodecDescriptor_;
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)]
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: *const SLDataSource,
pAudioSnk: *const 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: *const SLDataSource,
pAudioSnk: *const 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: *const SLDataSource,
pBankSrc: *const SLDataSource,
pAudioOutput: *const SLDataSink,
pVibra: *const SLDataSink,
pLEDArray: *const 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: *const 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 SLuint16,
) -> 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 SLuint16,
pIsAbsoluteMax: *mut SLboolean,
pNumFreeVoices: *mut SLuint16,
) -> SLresult,
>,
pub QueryNumberOfMIDISynthesizers: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pNumMIDIsynthesizers: *mut SLuint16,
) -> SLresult,
>,
pub QueryAPIVersion: ::std::option::Option<
unsafe extern "C" fn(
self_: SLEngineCapabilitiesItf,
pMajor: *mut SLuint16,
pMinor: *mut SLuint16,
pStep: *mut SLuint16,
) -> 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)]
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;
}
#[repr(C)]
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;
}
#[doc = " Android Configuration interface methods"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SLAndroidConfigurationItf_ {
_unused: [u8; 0],
}
pub type SLAndroidConfigurationItf = *const *const SLAndroidConfigurationItf_;
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)]
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)]
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)]
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 = " BufferQueue-based data locator definition where locatorType must"]
#[doc = " be SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE"]
#[repr(C)]
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)]
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,
>,
}