Merge "Update OpenSLES_Android.h and OpenSLES_AndroidConfiguration.h for N API" into ndk-r12-release
diff --git a/ndk/platforms/android-24/include/SLES/OpenSLES.h b/ndk/platforms/android-24/include/SLES/OpenSLES.h
new file mode 100644
index 0000000..8686997
--- /dev/null
+++ b/ndk/platforms/android-24/include/SLES/OpenSLES.h
@@ -0,0 +1,2774 @@
+/*
+ * Copyright (c) 2007-2009 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and /or associated documentation files (the "Materials "), to
+ * deal in the Materials without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Materials, and to permit persons to whom the Materials are
+ * furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE
+ * MATERIALS.
+ *
+ * OpenSLES.h - OpenSL ES version 1.0.1
+ *
+ */
+
+/****************************************************************************/
+/* NOTE: This file is a standard OpenSL ES header file and should not be */
+/* modified in any way. */
+/****************************************************************************/
+
+#ifndef OPENSL_ES_H_
+#define OPENSL_ES_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OpenSLES_Platform.h"
+
+
+/*****************************************************************************/
+/* Common types, structures, and defines */
+/*****************************************************************************/
+
+#ifndef _KHRONOS_KEYS_
+#define _KHRONOS_KEYS_
+
+#define KHRONOS_TITLE "KhronosTitle"
+#define KHRONOS_ALBUM "KhronosAlbum"
+#define KHRONOS_TRACK_NUMBER "KhronosTrackNumber"
+#define KHRONOS_ARTIST "KhronosArtist"
+#define KHRONOS_GENRE "KhronosGenre"
+#define KHRONOS_YEAR "KhronosYear"
+#define KHRONOS_COMMENT "KhronosComment"
+#define KHRONOS_ARTIST_URL "KhronosArtistURL"
+#define KHRONOS_CONTENT_URL "KhronosContentURL"
+#define KHRONOS_RATING "KhronosRating"
+#define KHRONOS_ALBUM_ART "KhronosAlbumArt"
+#define KHRONOS_COPYRIGHT "KhronosCopyright"
+
+#endif
+
+
+/* remap common types to SL types for clarity */
+typedef sl_int8_t SLint8; /* 8 bit signed integer */
+typedef sl_uint8_t SLuint8; /* 8 bit unsigned integer */
+typedef sl_int16_t SLint16; /* 16 bit signed integer */
+typedef sl_uint16_t SLuint16; /* 16 bit unsigned integer */
+typedef sl_int32_t SLint32; /* 32 bit signed integer */
+typedef sl_uint32_t SLuint32; /* 32 bit unsigned integer */
+
+typedef SLuint32 SLboolean;
+#define SL_BOOLEAN_FALSE ((SLboolean) 0x00000000)
+#define SL_BOOLEAN_TRUE ((SLboolean) 0x00000001)
+
+typedef SLuint8 SLchar; /* UTF-8 is to be used */
+typedef SLint16 SLmillibel;
+typedef SLuint32 SLmillisecond;
+typedef SLuint32 SLmilliHertz;
+typedef SLint32 SLmillimeter;
+typedef SLint32 SLmillidegree;
+typedef SLint16 SLpermille;
+typedef SLuint32 SLmicrosecond;
+typedef SLuint32 SLresult;
+
+#define SL_MILLIBEL_MAX ((SLmillibel) 0x7FFF)
+#define SL_MILLIBEL_MIN ((SLmillibel) (-SL_MILLIBEL_MAX-1))
+
+#define SL_MILLIHERTZ_MAX ((SLmilliHertz) 0xFFFFFFFF)
+#define SL_MILLIMETER_MAX ((SLmillimeter) 0x7FFFFFFF)
+
+/** Interface ID defined as a UUID */
+typedef const struct SLInterfaceID_ {
+ SLuint32 time_low;
+ SLuint16 time_mid;
+ SLuint16 time_hi_and_version;
+ SLuint16 clock_seq;
+ SLuint8 node[6];
+} * SLInterfaceID;
+
+/* Forward declaration for the object interface */
+struct SLObjectItf_;
+
+typedef const struct SLObjectItf_ * const * SLObjectItf;
+
+/* Objects ID's */
+
+#define SL_OBJECTID_ENGINE ((SLuint32) 0x00001001)
+#define SL_OBJECTID_LEDDEVICE ((SLuint32) 0x00001002)
+#define SL_OBJECTID_VIBRADEVICE ((SLuint32) 0x00001003)
+#define SL_OBJECTID_AUDIOPLAYER ((SLuint32) 0x00001004)
+#define SL_OBJECTID_AUDIORECORDER ((SLuint32) 0x00001005)
+#define SL_OBJECTID_MIDIPLAYER ((SLuint32) 0x00001006)
+#define SL_OBJECTID_LISTENER ((SLuint32) 0x00001007)
+#define SL_OBJECTID_3DGROUP ((SLuint32) 0x00001008)
+#define SL_OBJECTID_OUTPUTMIX ((SLuint32) 0x00001009)
+#define SL_OBJECTID_METADATAEXTRACTOR ((SLuint32) 0x0000100A)
+
+
+/* SL Profiles */
+
+#define SL_PROFILES_PHONE ((SLuint16) 0x0001)
+#define SL_PROFILES_MUSIC ((SLuint16) 0x0002)
+#define SL_PROFILES_GAME ((SLuint16) 0x0004)
+
+/* Types of voices supported by the system */
+
+#define SL_VOICETYPE_2D_AUDIO ((SLuint16) 0x0001)
+#define SL_VOICETYPE_MIDI ((SLuint16) 0x0002)
+#define SL_VOICETYPE_3D_AUDIO ((SLuint16) 0x0004)
+#define SL_VOICETYPE_3D_MIDIOUTPUT ((SLuint16) 0x0008)
+
+/* Convenient macros representing various different priority levels, for use with the SetPriority method */
+
+#define SL_PRIORITY_LOWEST ((SLint32) (-0x7FFFFFFF-1))
+#define SL_PRIORITY_VERYLOW ((SLint32) -0x60000000)
+#define SL_PRIORITY_LOW ((SLint32) -0x40000000)
+#define SL_PRIORITY_BELOWNORMAL ((SLint32) -0x20000000)
+#define SL_PRIORITY_NORMAL ((SLint32) 0x00000000)
+#define SL_PRIORITY_ABOVENORMAL ((SLint32) 0x20000000)
+#define SL_PRIORITY_HIGH ((SLint32) 0x40000000)
+#define SL_PRIORITY_VERYHIGH ((SLint32) 0x60000000)
+#define SL_PRIORITY_HIGHEST ((SLint32) 0x7FFFFFFF)
+
+
+/** These macros list the various sample formats that are possible on audio input and output devices. */
+
+#define SL_PCMSAMPLEFORMAT_FIXED_8 ((SLuint16) 0x0008)
+#define SL_PCMSAMPLEFORMAT_FIXED_16 ((SLuint16) 0x0010)
+#define SL_PCMSAMPLEFORMAT_FIXED_20 ((SLuint16) 0x0014)
+#define SL_PCMSAMPLEFORMAT_FIXED_24 ((SLuint16) 0x0018)
+#define SL_PCMSAMPLEFORMAT_FIXED_28 ((SLuint16) 0x001C)
+#define SL_PCMSAMPLEFORMAT_FIXED_32 ((SLuint16) 0x0020)
+
+
+/** These macros specify the commonly used sampling rates (in milliHertz) supported by most audio I/O devices. */
+
+#define SL_SAMPLINGRATE_8 ((SLuint32) 8000000)
+#define SL_SAMPLINGRATE_11_025 ((SLuint32) 11025000)
+#define SL_SAMPLINGRATE_12 ((SLuint32) 12000000)
+#define SL_SAMPLINGRATE_16 ((SLuint32) 16000000)
+#define SL_SAMPLINGRATE_22_05 ((SLuint32) 22050000)
+#define SL_SAMPLINGRATE_24 ((SLuint32) 24000000)
+#define SL_SAMPLINGRATE_32 ((SLuint32) 32000000)
+#define SL_SAMPLINGRATE_44_1 ((SLuint32) 44100000)
+#define SL_SAMPLINGRATE_48 ((SLuint32) 48000000)
+#define SL_SAMPLINGRATE_64 ((SLuint32) 64000000)
+#define SL_SAMPLINGRATE_88_2 ((SLuint32) 88200000)
+#define SL_SAMPLINGRATE_96 ((SLuint32) 96000000)
+#define SL_SAMPLINGRATE_192 ((SLuint32) 192000000)
+
+#define SL_SPEAKER_FRONT_LEFT ((SLuint32) 0x00000001)
+#define SL_SPEAKER_FRONT_RIGHT ((SLuint32) 0x00000002)
+#define SL_SPEAKER_FRONT_CENTER ((SLuint32) 0x00000004)
+#define SL_SPEAKER_LOW_FREQUENCY ((SLuint32) 0x00000008)
+#define SL_SPEAKER_BACK_LEFT ((SLuint32) 0x00000010)
+#define SL_SPEAKER_BACK_RIGHT ((SLuint32) 0x00000020)
+#define SL_SPEAKER_FRONT_LEFT_OF_CENTER ((SLuint32) 0x00000040)
+#define SL_SPEAKER_FRONT_RIGHT_OF_CENTER ((SLuint32) 0x00000080)
+#define SL_SPEAKER_BACK_CENTER ((SLuint32) 0x00000100)
+#define SL_SPEAKER_SIDE_LEFT ((SLuint32) 0x00000200)
+#define SL_SPEAKER_SIDE_RIGHT ((SLuint32) 0x00000400)
+#define SL_SPEAKER_TOP_CENTER ((SLuint32) 0x00000800)
+#define SL_SPEAKER_TOP_FRONT_LEFT ((SLuint32) 0x00001000)
+#define SL_SPEAKER_TOP_FRONT_CENTER ((SLuint32) 0x00002000)
+#define SL_SPEAKER_TOP_FRONT_RIGHT ((SLuint32) 0x00004000)
+#define SL_SPEAKER_TOP_BACK_LEFT ((SLuint32) 0x00008000)
+#define SL_SPEAKER_TOP_BACK_CENTER ((SLuint32) 0x00010000)
+#define SL_SPEAKER_TOP_BACK_RIGHT ((SLuint32) 0x00020000)
+
+
+/*****************************************************************************/
+/* Errors */
+/* */
+/*****************************************************************************/
+
+#define SL_RESULT_SUCCESS ((SLuint32) 0x00000000)
+#define SL_RESULT_PRECONDITIONS_VIOLATED ((SLuint32) 0x00000001)
+#define SL_RESULT_PARAMETER_INVALID ((SLuint32) 0x00000002)
+#define SL_RESULT_MEMORY_FAILURE ((SLuint32) 0x00000003)
+#define SL_RESULT_RESOURCE_ERROR ((SLuint32) 0x00000004)
+#define SL_RESULT_RESOURCE_LOST ((SLuint32) 0x00000005)
+#define SL_RESULT_IO_ERROR ((SLuint32) 0x00000006)
+#define SL_RESULT_BUFFER_INSUFFICIENT ((SLuint32) 0x00000007)
+#define SL_RESULT_CONTENT_CORRUPTED ((SLuint32) 0x00000008)
+#define SL_RESULT_CONTENT_UNSUPPORTED ((SLuint32) 0x00000009)
+#define SL_RESULT_CONTENT_NOT_FOUND ((SLuint32) 0x0000000A)
+#define SL_RESULT_PERMISSION_DENIED ((SLuint32) 0x0000000B)
+#define SL_RESULT_FEATURE_UNSUPPORTED ((SLuint32) 0x0000000C)
+#define SL_RESULT_INTERNAL_ERROR ((SLuint32) 0x0000000D)
+#define SL_RESULT_UNKNOWN_ERROR ((SLuint32) 0x0000000E)
+#define SL_RESULT_OPERATION_ABORTED ((SLuint32) 0x0000000F)
+#define SL_RESULT_CONTROL_LOST ((SLuint32) 0x00000010)
+
+
+/* Object state definitions */
+
+#define SL_OBJECT_STATE_UNREALIZED ((SLuint32) 0x00000001)
+#define SL_OBJECT_STATE_REALIZED ((SLuint32) 0x00000002)
+#define SL_OBJECT_STATE_SUSPENDED ((SLuint32) 0x00000003)
+
+/* Object event definitions */
+
+#define SL_OBJECT_EVENT_RUNTIME_ERROR ((SLuint32) 0x00000001)
+#define SL_OBJECT_EVENT_ASYNC_TERMINATION ((SLuint32) 0x00000002)
+#define SL_OBJECT_EVENT_RESOURCES_LOST ((SLuint32) 0x00000003)
+#define SL_OBJECT_EVENT_RESOURCES_AVAILABLE ((SLuint32) 0x00000004)
+#define SL_OBJECT_EVENT_ITF_CONTROL_TAKEN ((SLuint32) 0x00000005)
+#define SL_OBJECT_EVENT_ITF_CONTROL_RETURNED ((SLuint32) 0x00000006)
+#define SL_OBJECT_EVENT_ITF_PARAMETERS_CHANGED ((SLuint32) 0x00000007)
+
+
+/*****************************************************************************/
+/* Interface definitions */
+/*****************************************************************************/
+
+/** NULL Interface */
+
+extern SL_API const SLInterfaceID SL_IID_NULL;
+
+/*---------------------------------------------------------------------------*/
+/* Data Source and Data Sink Structures */
+/*---------------------------------------------------------------------------*/
+
+/** Data locator macros */
+#define SL_DATALOCATOR_URI ((SLuint32) 0x00000001)
+#define SL_DATALOCATOR_ADDRESS ((SLuint32) 0x00000002)
+#define SL_DATALOCATOR_IODEVICE ((SLuint32) 0x00000003)
+#define SL_DATALOCATOR_OUTPUTMIX ((SLuint32) 0x00000004)
+#define SL_DATALOCATOR_RESERVED5 ((SLuint32) 0x00000005)
+#define SL_DATALOCATOR_BUFFERQUEUE ((SLuint32) 0x00000006)
+#define SL_DATALOCATOR_MIDIBUFFERQUEUE ((SLuint32) 0x00000007)
+#define SL_DATALOCATOR_RESERVED8 ((SLuint32) 0x00000008)
+
+
+
+/** URI-based data locator definition where locatorType must be SL_DATALOCATOR_URI*/
+typedef struct SLDataLocator_URI_ {
+ SLuint32 locatorType;
+ SLchar * URI;
+} SLDataLocator_URI;
+
+/** Address-based data locator definition where locatorType must be SL_DATALOCATOR_ADDRESS*/
+typedef struct SLDataLocator_Address_ {
+ SLuint32 locatorType;
+ void *pAddress;
+ SLuint32 length;
+} SLDataLocator_Address;
+
+/** IODevice-types */
+#define SL_IODEVICE_AUDIOINPUT ((SLuint32) 0x00000001)
+#define SL_IODEVICE_LEDARRAY ((SLuint32) 0x00000002)
+#define SL_IODEVICE_VIBRA ((SLuint32) 0x00000003)
+#define SL_IODEVICE_RESERVED4 ((SLuint32) 0x00000004)
+#define SL_IODEVICE_RESERVED5 ((SLuint32) 0x00000005)
+
+/** IODevice-based data locator definition where locatorType must be SL_DATALOCATOR_IODEVICE*/
+typedef struct SLDataLocator_IODevice_ {
+ SLuint32 locatorType;
+ SLuint32 deviceType;
+ SLuint32 deviceID;
+ SLObjectItf device;
+} SLDataLocator_IODevice;
+
+/** OutputMix-based data locator definition where locatorType must be SL_DATALOCATOR_OUTPUTMIX*/
+typedef struct SLDataLocator_OutputMix {
+ SLuint32 locatorType;
+ SLObjectItf outputMix;
+} SLDataLocator_OutputMix;
+
+
+/** BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_BUFFERQUEUE*/
+typedef struct SLDataLocator_BufferQueue {
+ SLuint32 locatorType;
+ SLuint32 numBuffers;
+} SLDataLocator_BufferQueue;
+
+/** MidiBufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_MIDIBUFFERQUEUE*/
+typedef struct SLDataLocator_MIDIBufferQueue {
+ SLuint32 locatorType;
+ SLuint32 tpqn;
+ SLuint32 numBuffers;
+} SLDataLocator_MIDIBufferQueue;
+
+/** Data format defines */
+#define SL_DATAFORMAT_MIME ((SLuint32) 0x00000001)
+#define SL_DATAFORMAT_PCM ((SLuint32) 0x00000002)
+#define SL_DATAFORMAT_RESERVED3 ((SLuint32) 0x00000003)
+
+
+/** MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME*/
+typedef struct SLDataFormat_MIME_ {
+ SLuint32 formatType;
+ SLchar * mimeType;
+ SLuint32 containerType;
+} SLDataFormat_MIME;
+
+/* Byte order of a block of 16- or 32-bit data */
+#define SL_BYTEORDER_BIGENDIAN ((SLuint32) 0x00000001)
+#define SL_BYTEORDER_LITTLEENDIAN ((SLuint32) 0x00000002)
+
+/* Container type */
+#define SL_CONTAINERTYPE_UNSPECIFIED ((SLuint32) 0x00000001)
+#define SL_CONTAINERTYPE_RAW ((SLuint32) 0x00000002)
+#define SL_CONTAINERTYPE_ASF ((SLuint32) 0x00000003)
+#define SL_CONTAINERTYPE_AVI ((SLuint32) 0x00000004)
+#define SL_CONTAINERTYPE_BMP ((SLuint32) 0x00000005)
+#define SL_CONTAINERTYPE_JPG ((SLuint32) 0x00000006)
+#define SL_CONTAINERTYPE_JPG2000 ((SLuint32) 0x00000007)
+#define SL_CONTAINERTYPE_M4A ((SLuint32) 0x00000008)
+#define SL_CONTAINERTYPE_MP3 ((SLuint32) 0x00000009)
+#define SL_CONTAINERTYPE_MP4 ((SLuint32) 0x0000000A)
+#define SL_CONTAINERTYPE_MPEG_ES ((SLuint32) 0x0000000B)
+#define SL_CONTAINERTYPE_MPEG_PS ((SLuint32) 0x0000000C)
+#define SL_CONTAINERTYPE_MPEG_TS ((SLuint32) 0x0000000D)
+#define SL_CONTAINERTYPE_QT ((SLuint32) 0x0000000E)
+#define SL_CONTAINERTYPE_WAV ((SLuint32) 0x0000000F)
+#define SL_CONTAINERTYPE_XMF_0 ((SLuint32) 0x00000010)
+#define SL_CONTAINERTYPE_XMF_1 ((SLuint32) 0x00000011)
+#define SL_CONTAINERTYPE_XMF_2 ((SLuint32) 0x00000012)
+#define SL_CONTAINERTYPE_XMF_3 ((SLuint32) 0x00000013)
+#define SL_CONTAINERTYPE_XMF_GENERIC ((SLuint32) 0x00000014)
+#define SL_CONTAINERTYPE_AMR ((SLuint32) 0x00000015)
+#define SL_CONTAINERTYPE_AAC ((SLuint32) 0x00000016)
+#define SL_CONTAINERTYPE_3GPP ((SLuint32) 0x00000017)
+#define SL_CONTAINERTYPE_3GA ((SLuint32) 0x00000018)
+#define SL_CONTAINERTYPE_RM ((SLuint32) 0x00000019)
+#define SL_CONTAINERTYPE_DMF ((SLuint32) 0x0000001A)
+#define SL_CONTAINERTYPE_SMF ((SLuint32) 0x0000001B)
+#define SL_CONTAINERTYPE_MOBILE_DLS ((SLuint32) 0x0000001C)
+#define SL_CONTAINERTYPE_OGG ((SLuint32) 0x0000001D)
+
+
+/** PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM*/
+typedef struct SLDataFormat_PCM_ {
+ SLuint32 formatType;
+ SLuint32 numChannels;
+ SLuint32 samplesPerSec;
+ SLuint32 bitsPerSample;
+ SLuint32 containerSize;
+ SLuint32 channelMask;
+ SLuint32 endianness;
+} SLDataFormat_PCM;
+
+typedef struct SLDataSource_ {
+ void *pLocator;
+ void *pFormat;
+} SLDataSource;
+
+
+typedef struct SLDataSink_ {
+ void *pLocator;
+ void *pFormat;
+} SLDataSink;
+
+
+
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Standard Object Interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_OBJECT;
+
+/** Object callback */
+
+
+typedef void (SLAPIENTRY *slObjectCallback) (
+ SLObjectItf caller,
+ const void * pContext,
+ SLuint32 event,
+ SLresult result,
+ SLuint32 param,
+ void *pInterface
+);
+
+
+struct SLObjectItf_ {
+ SLresult (*Realize) (
+ SLObjectItf self,
+ SLboolean async
+ );
+ SLresult (*Resume) (
+ SLObjectItf self,
+ SLboolean async
+ );
+ SLresult (*GetState) (
+ SLObjectItf self,
+ SLuint32 * pState
+ );
+ SLresult (*GetInterface) (
+ SLObjectItf self,
+ const SLInterfaceID iid,
+ void * pInterface
+ );
+ SLresult (*RegisterCallback) (
+ SLObjectItf self,
+ slObjectCallback callback,
+ void * pContext
+ );
+ void (*AbortAsyncOperation) (
+ SLObjectItf self
+ );
+ void (*Destroy) (
+ SLObjectItf self
+ );
+ SLresult (*SetPriority) (
+ SLObjectItf self,
+ SLint32 priority,
+ SLboolean preemptable
+ );
+ SLresult (*GetPriority) (
+ SLObjectItf self,
+ SLint32 *pPriority,
+ SLboolean *pPreemptable
+ );
+ SLresult (*SetLossOfControlInterfaces) (
+ SLObjectItf self,
+ SLint16 numInterfaces,
+ SLInterfaceID * pInterfaceIDs,
+ SLboolean enabled
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Audio IO Device capabilities interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_DEFAULTDEVICEID_AUDIOINPUT ((SLuint32) 0xFFFFFFFF)
+#define SL_DEFAULTDEVICEID_AUDIOOUTPUT ((SLuint32) 0xFFFFFFFE)
+#define SL_DEFAULTDEVICEID_LED ((SLuint32) 0xFFFFFFFD)
+#define SL_DEFAULTDEVICEID_VIBRA ((SLuint32) 0xFFFFFFFC)
+#define SL_DEFAULTDEVICEID_RESERVED1 ((SLuint32) 0xFFFFFFFB)
+
+
+#define SL_DEVCONNECTION_INTEGRATED ((SLint16) 0x0001)
+#define SL_DEVCONNECTION_ATTACHED_WIRED ((SLint16) 0x0100)
+#define SL_DEVCONNECTION_ATTACHED_WIRELESS ((SLint16) 0x0200)
+#define SL_DEVCONNECTION_NETWORK ((SLint16) 0x0400)
+
+
+#define SL_DEVLOCATION_HANDSET ((SLuint16) 0x0001)
+#define SL_DEVLOCATION_HEADSET ((SLuint16) 0x0002)
+#define SL_DEVLOCATION_CARKIT ((SLuint16) 0x0003)
+#define SL_DEVLOCATION_DOCK ((SLuint16) 0x0004)
+#define SL_DEVLOCATION_REMOTE ((SLuint16) 0x0005)
+/* Note: SL_DEVLOCATION_RESLTE is deprecated, use SL_DEVLOCATION_REMOTE instead. */
+#define SL_DEVLOCATION_RESLTE ((SLuint16) 0x0005)
+
+
+#define SL_DEVSCOPE_UNKNOWN ((SLuint16) 0x0001)
+#define SL_DEVSCOPE_ENVIRONMENT ((SLuint16) 0x0002)
+#define SL_DEVSCOPE_USER ((SLuint16) 0x0003)
+
+
+typedef struct SLAudioInputDescriptor_ {
+ SLchar *deviceName;
+ SLint16 deviceConnection;
+ SLint16 deviceScope;
+ SLint16 deviceLocation;
+ SLboolean isForTelephony;
+ SLmilliHertz minSampleRate;
+ SLmilliHertz maxSampleRate;
+ SLboolean isFreqRangeContinuous;
+ SLmilliHertz *samplingRatesSupported;
+ SLint16 numOfSamplingRatesSupported;
+ SLint16 maxChannels;
+} SLAudioInputDescriptor;
+
+
+typedef struct SLAudioOutputDescriptor_ {
+ SLchar *pDeviceName;
+ SLint16 deviceConnection;
+ SLint16 deviceScope;
+ SLint16 deviceLocation;
+ SLboolean isForTelephony;
+ SLmilliHertz minSampleRate;
+ SLmilliHertz maxSampleRate;
+ SLboolean isFreqRangeContinuous;
+ SLmilliHertz *samplingRatesSupported;
+ SLint16 numOfSamplingRatesSupported;
+ SLint16 maxChannels;
+} SLAudioOutputDescriptor;
+
+
+
+extern SL_API const SLInterfaceID SL_IID_AUDIOIODEVICECAPABILITIES;
+
+struct SLAudioIODeviceCapabilitiesItf_;
+typedef const struct SLAudioIODeviceCapabilitiesItf_ * const * SLAudioIODeviceCapabilitiesItf;
+
+
+typedef void (SLAPIENTRY *slAvailableAudioInputsChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf caller,
+ void *pContext,
+ SLuint32 deviceID,
+ SLint32 numInputs,
+ SLboolean isNew
+);
+
+
+typedef void (SLAPIENTRY *slAvailableAudioOutputsChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf caller,
+ void *pContext,
+ SLuint32 deviceID,
+ SLint32 numOutputs,
+ SLboolean isNew
+);
+
+typedef void (SLAPIENTRY *slDefaultDeviceIDMapChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf caller,
+ void *pContext,
+ SLboolean isOutput,
+ SLint32 numDevices
+);
+
+
+struct SLAudioIODeviceCapabilitiesItf_ {
+ SLresult (*GetAvailableAudioInputs)(
+ SLAudioIODeviceCapabilitiesItf self,
+ SLint32 *pNumInputs,
+ SLuint32 *pInputDeviceIDs
+ );
+ SLresult (*QueryAudioInputCapabilities)(
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 deviceId,
+ SLAudioInputDescriptor *pDescriptor
+ );
+ SLresult (*RegisterAvailableAudioInputsChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf self,
+ slAvailableAudioInputsChangedCallback callback,
+ void *pContext
+ );
+ SLresult (*GetAvailableAudioOutputs)(
+ SLAudioIODeviceCapabilitiesItf self,
+ SLint32 *pNumOutputs,
+ SLuint32 *pOutputDeviceIDs
+ );
+ SLresult (*QueryAudioOutputCapabilities)(
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 deviceId,
+ SLAudioOutputDescriptor *pDescriptor
+ );
+ SLresult (*RegisterAvailableAudioOutputsChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf self,
+ slAvailableAudioOutputsChangedCallback callback,
+ void *pContext
+ );
+ SLresult (*RegisterDefaultDeviceIDMapChangedCallback) (
+ SLAudioIODeviceCapabilitiesItf self,
+ slDefaultDeviceIDMapChangedCallback callback,
+ void *pContext
+ );
+ SLresult (*GetAssociatedAudioInputs) (
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 deviceId,
+ SLint32 *pNumAudioInputs,
+ SLuint32 *pAudioInputDeviceIDs
+ );
+ SLresult (*GetAssociatedAudioOutputs) (
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 deviceId,
+ SLint32 *pNumAudioOutputs,
+ SLuint32 *pAudioOutputDeviceIDs
+ );
+ SLresult (*GetDefaultAudioDevices) (
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 defaultDeviceID,
+ SLint32 *pNumAudioDevices,
+ SLuint32 *pAudioDeviceIDs
+ );
+ SLresult (*QuerySampleFormatsSupported)(
+ SLAudioIODeviceCapabilitiesItf self,
+ SLuint32 deviceId,
+ SLmilliHertz samplingRate,
+ SLint32 *pSampleFormats,
+ SLint32 *pNumOfSampleFormats
+ );
+};
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Capabilities of the LED array IODevice */
+/*---------------------------------------------------------------------------*/
+
+typedef struct SLLEDDescriptor_ {
+ SLuint8 ledCount;
+ SLuint8 primaryLED;
+ SLuint32 colorMask;
+} SLLEDDescriptor;
+
+
+/*---------------------------------------------------------------------------*/
+/* LED Array interface */
+/*---------------------------------------------------------------------------*/
+
+typedef struct SLHSL_ {
+ SLmillidegree hue;
+ SLpermille saturation;
+ SLpermille lightness;
+} SLHSL;
+
+
+extern SL_API const SLInterfaceID SL_IID_LED;
+
+struct SLLEDArrayItf_;
+typedef const struct SLLEDArrayItf_ * const * SLLEDArrayItf;
+
+struct SLLEDArrayItf_ {
+ SLresult (*ActivateLEDArray) (
+ SLLEDArrayItf self,
+ SLuint32 lightMask
+ );
+ SLresult (*IsLEDArrayActivated) (
+ SLLEDArrayItf self,
+ SLuint32 *lightMask
+ );
+ SLresult (*SetColor) (
+ SLLEDArrayItf self,
+ SLuint8 index,
+ const SLHSL *color
+ );
+ SLresult (*GetColor) (
+ SLLEDArrayItf self,
+ SLuint8 index,
+ SLHSL *color
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Capabilities of the Vibra IODevice */
+/*---------------------------------------------------------------------------*/
+
+typedef struct SLVibraDescriptor_ {
+ SLboolean supportsFrequency;
+ SLboolean supportsIntensity;
+ SLmilliHertz minFrequency;
+ SLmilliHertz maxFrequency;
+} SLVibraDescriptor;
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Vibra interface */
+/*---------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_VIBRA;
+
+
+struct SLVibraItf_;
+typedef const struct SLVibraItf_ * const * SLVibraItf;
+
+struct SLVibraItf_ {
+ SLresult (*Vibrate) (
+ SLVibraItf self,
+ SLboolean vibrate
+ );
+ SLresult (*IsVibrating) (
+ SLVibraItf self,
+ SLboolean *pVibrating
+ );
+ SLresult (*SetFrequency) (
+ SLVibraItf self,
+ SLmilliHertz frequency
+ );
+ SLresult (*GetFrequency) (
+ SLVibraItf self,
+ SLmilliHertz *pFrequency
+ );
+ SLresult (*SetIntensity) (
+ SLVibraItf self,
+ SLpermille intensity
+ );
+ SLresult (*GetIntensity) (
+ SLVibraItf self,
+ SLpermille *pIntensity
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Meta data extraction related types and interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_CHARACTERENCODING_UNKNOWN ((SLuint32) 0x00000000)
+#define SL_CHARACTERENCODING_BINARY ((SLuint32) 0x00000001)
+#define SL_CHARACTERENCODING_ASCII ((SLuint32) 0x00000002)
+#define SL_CHARACTERENCODING_BIG5 ((SLuint32) 0x00000003)
+#define SL_CHARACTERENCODING_CODEPAGE1252 ((SLuint32) 0x00000004)
+#define SL_CHARACTERENCODING_GB2312 ((SLuint32) 0x00000005)
+#define SL_CHARACTERENCODING_HZGB2312 ((SLuint32) 0x00000006)
+#define SL_CHARACTERENCODING_GB12345 ((SLuint32) 0x00000007)
+#define SL_CHARACTERENCODING_GB18030 ((SLuint32) 0x00000008)
+#define SL_CHARACTERENCODING_GBK ((SLuint32) 0x00000009)
+#define SL_CHARACTERENCODING_IMAPUTF7 ((SLuint32) 0x0000000A)
+#define SL_CHARACTERENCODING_ISO2022JP ((SLuint32) 0x0000000B)
+#define SL_CHARACTERENCODING_ISO2022JP1 ((SLuint32) 0x0000000B)
+#define SL_CHARACTERENCODING_ISO88591 ((SLuint32) 0x0000000C)
+#define SL_CHARACTERENCODING_ISO885910 ((SLuint32) 0x0000000D)
+#define SL_CHARACTERENCODING_ISO885913 ((SLuint32) 0x0000000E)
+#define SL_CHARACTERENCODING_ISO885914 ((SLuint32) 0x0000000F)
+#define SL_CHARACTERENCODING_ISO885915 ((SLuint32) 0x00000010)
+#define SL_CHARACTERENCODING_ISO88592 ((SLuint32) 0x00000011)
+#define SL_CHARACTERENCODING_ISO88593 ((SLuint32) 0x00000012)
+#define SL_CHARACTERENCODING_ISO88594 ((SLuint32) 0x00000013)
+#define SL_CHARACTERENCODING_ISO88595 ((SLuint32) 0x00000014)
+#define SL_CHARACTERENCODING_ISO88596 ((SLuint32) 0x00000015)
+#define SL_CHARACTERENCODING_ISO88597 ((SLuint32) 0x00000016)
+#define SL_CHARACTERENCODING_ISO88598 ((SLuint32) 0x00000017)
+#define SL_CHARACTERENCODING_ISO88599 ((SLuint32) 0x00000018)
+#define SL_CHARACTERENCODING_ISOEUCJP ((SLuint32) 0x00000019)
+#define SL_CHARACTERENCODING_SHIFTJIS ((SLuint32) 0x0000001A)
+#define SL_CHARACTERENCODING_SMS7BIT ((SLuint32) 0x0000001B)
+#define SL_CHARACTERENCODING_UTF7 ((SLuint32) 0x0000001C)
+#define SL_CHARACTERENCODING_UTF8 ((SLuint32) 0x0000001D)
+#define SL_CHARACTERENCODING_JAVACONFORMANTUTF8 ((SLuint32) 0x0000001E)
+#define SL_CHARACTERENCODING_UTF16BE ((SLuint32) 0x0000001F)
+#define SL_CHARACTERENCODING_UTF16LE ((SLuint32) 0x00000020)
+
+
+#define SL_METADATA_FILTER_KEY ((SLuint8) 0x01)
+#define SL_METADATA_FILTER_LANG ((SLuint8) 0x02)
+#define SL_METADATA_FILTER_ENCODING ((SLuint8) 0x04)
+
+
+typedef struct SLMetadataInfo_ {
+ SLuint32 size;
+ SLuint32 encoding;
+ SLchar langCountry[16];
+ SLuint8 data[1];
+} SLMetadataInfo;
+
+extern SL_API const SLInterfaceID SL_IID_METADATAEXTRACTION;
+
+struct SLMetadataExtractionItf_;
+typedef const struct SLMetadataExtractionItf_ * const * SLMetadataExtractionItf;
+
+
+struct SLMetadataExtractionItf_ {
+ SLresult (*GetItemCount) (
+ SLMetadataExtractionItf self,
+ SLuint32 *pItemCount
+ );
+ SLresult (*GetKeySize) (
+ SLMetadataExtractionItf self,
+ SLuint32 index,
+ SLuint32 *pKeySize
+ );
+ SLresult (*GetKey) (
+ SLMetadataExtractionItf self,
+ SLuint32 index,
+ SLuint32 keySize,
+ SLMetadataInfo *pKey
+ );
+ SLresult (*GetValueSize) (
+ SLMetadataExtractionItf self,
+ SLuint32 index,
+ SLuint32 *pValueSize
+ );
+ SLresult (*GetValue) (
+ SLMetadataExtractionItf self,
+ SLuint32 index,
+ SLuint32 valueSize,
+ SLMetadataInfo *pValue
+ );
+ SLresult (*AddKeyFilter) (
+ SLMetadataExtractionItf self,
+ SLuint32 keySize,
+ const void *pKey,
+ SLuint32 keyEncoding,
+ const SLchar *pValueLangCountry,
+ SLuint32 valueEncoding,
+ SLuint8 filterMask
+ );
+ SLresult (*ClearKeyFilter) (
+ SLMetadataExtractionItf self
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Meta data traversal related types and interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_METADATATRAVERSALMODE_ALL ((SLuint32) 0x00000001)
+#define SL_METADATATRAVERSALMODE_NODE ((SLuint32) 0x00000002)
+
+
+#define SL_NODETYPE_UNSPECIFIED ((SLuint32) 0x00000001)
+#define SL_NODETYPE_AUDIO ((SLuint32) 0x00000002)
+#define SL_NODETYPE_VIDEO ((SLuint32) 0x00000003)
+#define SL_NODETYPE_IMAGE ((SLuint32) 0x00000004)
+
+#define SL_NODE_PARENT 0xFFFFFFFF
+
+extern SL_API const SLInterfaceID SL_IID_METADATATRAVERSAL;
+
+struct SLMetadataTraversalItf_;
+typedef const struct SLMetadataTraversalItf_ * const * SLMetadataTraversalItf;
+
+struct SLMetadataTraversalItf_ {
+ SLresult (*SetMode) (
+ SLMetadataTraversalItf self,
+ SLuint32 mode
+ );
+ SLresult (*GetChildCount) (
+ SLMetadataTraversalItf self,
+ SLuint32 *pCount
+ );
+ SLresult (*GetChildMIMETypeSize) (
+ SLMetadataTraversalItf self,
+ SLuint32 index,
+ SLuint32 *pSize
+ );
+ SLresult (*GetChildInfo) (
+ SLMetadataTraversalItf self,
+ SLuint32 index,
+ SLint32 *pNodeID,
+ SLuint32 *pType,
+ SLuint32 size,
+ SLchar *pMimeType
+ );
+ SLresult (*SetActiveNode) (
+ SLMetadataTraversalItf self,
+ SLuint32 index
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Dynamic Source types and interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_DYNAMICSOURCE;
+
+struct SLDynamicSourceItf_;
+typedef const struct SLDynamicSourceItf_ * const * SLDynamicSourceItf;
+
+struct SLDynamicSourceItf_ {
+ SLresult (*SetSource) (
+ SLDynamicSourceItf self,
+ SLDataSource *pDataSource
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Output Mix interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_OUTPUTMIX;
+
+struct SLOutputMixItf_;
+typedef const struct SLOutputMixItf_ * const * SLOutputMixItf;
+
+typedef void (SLAPIENTRY *slMixDeviceChangeCallback) (
+ SLOutputMixItf caller,
+ void *pContext
+);
+
+
+struct SLOutputMixItf_ {
+ SLresult (*GetDestinationOutputDeviceIDs) (
+ SLOutputMixItf self,
+ SLint32 *pNumDevices,
+ SLuint32 *pDeviceIDs
+ );
+ SLresult (*RegisterDeviceChangeCallback) (
+ SLOutputMixItf self,
+ slMixDeviceChangeCallback callback,
+ void *pContext
+ );
+ SLresult (*ReRoute)(
+ SLOutputMixItf self,
+ SLint32 numOutputDevices,
+ SLuint32 *pOutputDeviceIDs
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Playback interface */
+/*---------------------------------------------------------------------------*/
+
+/** Playback states */
+#define SL_PLAYSTATE_STOPPED ((SLuint32) 0x00000001)
+#define SL_PLAYSTATE_PAUSED ((SLuint32) 0x00000002)
+#define SL_PLAYSTATE_PLAYING ((SLuint32) 0x00000003)
+
+/** Play events **/
+#define SL_PLAYEVENT_HEADATEND ((SLuint32) 0x00000001)
+#define SL_PLAYEVENT_HEADATMARKER ((SLuint32) 0x00000002)
+#define SL_PLAYEVENT_HEADATNEWPOS ((SLuint32) 0x00000004)
+#define SL_PLAYEVENT_HEADMOVING ((SLuint32) 0x00000008)
+#define SL_PLAYEVENT_HEADSTALLED ((SLuint32) 0x00000010)
+
+#define SL_TIME_UNKNOWN ((SLuint32) 0xFFFFFFFF)
+
+
+extern SL_API const SLInterfaceID SL_IID_PLAY;
+
+/** Playback interface methods */
+
+struct SLPlayItf_;
+typedef const struct SLPlayItf_ * const * SLPlayItf;
+
+typedef void (SLAPIENTRY *slPlayCallback) (
+ SLPlayItf caller,
+ void *pContext,
+ SLuint32 event
+);
+
+struct SLPlayItf_ {
+ SLresult (*SetPlayState) (
+ SLPlayItf self,
+ SLuint32 state
+ );
+ SLresult (*GetPlayState) (
+ SLPlayItf self,
+ SLuint32 *pState
+ );
+ SLresult (*GetDuration) (
+ SLPlayItf self,
+ SLmillisecond *pMsec
+ );
+ SLresult (*GetPosition) (
+ SLPlayItf self,
+ SLmillisecond *pMsec
+ );
+ SLresult (*RegisterCallback) (
+ SLPlayItf self,
+ slPlayCallback callback,
+ void *pContext
+ );
+ SLresult (*SetCallbackEventsMask) (
+ SLPlayItf self,
+ SLuint32 eventFlags
+ );
+ SLresult (*GetCallbackEventsMask) (
+ SLPlayItf self,
+ SLuint32 *pEventFlags
+ );
+ SLresult (*SetMarkerPosition) (
+ SLPlayItf self,
+ SLmillisecond mSec
+ );
+ SLresult (*ClearMarkerPosition) (
+ SLPlayItf self
+ );
+ SLresult (*GetMarkerPosition) (
+ SLPlayItf self,
+ SLmillisecond *pMsec
+ );
+ SLresult (*SetPositionUpdatePeriod) (
+ SLPlayItf self,
+ SLmillisecond mSec
+ );
+ SLresult (*GetPositionUpdatePeriod) (
+ SLPlayItf self,
+ SLmillisecond *pMsec
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Prefetch status interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_PREFETCHEVENT_STATUSCHANGE ((SLuint32) 0x00000001)
+#define SL_PREFETCHEVENT_FILLLEVELCHANGE ((SLuint32) 0x00000002)
+
+#define SL_PREFETCHSTATUS_UNDERFLOW ((SLuint32) 0x00000001)
+#define SL_PREFETCHSTATUS_SUFFICIENTDATA ((SLuint32) 0x00000002)
+#define SL_PREFETCHSTATUS_OVERFLOW ((SLuint32) 0x00000003)
+
+
+extern SL_API const SLInterfaceID SL_IID_PREFETCHSTATUS;
+
+
+/** Prefetch status interface methods */
+
+struct SLPrefetchStatusItf_;
+typedef const struct SLPrefetchStatusItf_ * const * SLPrefetchStatusItf;
+
+typedef void (SLAPIENTRY *slPrefetchCallback) (
+ SLPrefetchStatusItf caller,
+ void *pContext,
+ SLuint32 event
+);
+
+struct SLPrefetchStatusItf_ {
+ SLresult (*GetPrefetchStatus) (
+ SLPrefetchStatusItf self,
+ SLuint32 *pStatus
+ );
+ SLresult (*GetFillLevel) (
+ SLPrefetchStatusItf self,
+ SLpermille *pLevel
+ );
+ SLresult (*RegisterCallback) (
+ SLPrefetchStatusItf self,
+ slPrefetchCallback callback,
+ void *pContext
+ );
+ SLresult (*SetCallbackEventsMask) (
+ SLPrefetchStatusItf self,
+ SLuint32 eventFlags
+ );
+ SLresult (*GetCallbackEventsMask) (
+ SLPrefetchStatusItf self,
+ SLuint32 *pEventFlags
+ );
+ SLresult (*SetFillUpdatePeriod) (
+ SLPrefetchStatusItf self,
+ SLpermille period
+ );
+ SLresult (*GetFillUpdatePeriod) (
+ SLPrefetchStatusItf self,
+ SLpermille *pPeriod
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Playback Rate interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_RATEPROP_RESERVED1 ((SLuint32) 0x00000001)
+#define SL_RATEPROP_RESERVED2 ((SLuint32) 0x00000002)
+#define SL_RATEPROP_SILENTAUDIO ((SLuint32) 0x00000100)
+#define SL_RATEPROP_STAGGEREDAUDIO ((SLuint32) 0x00000200)
+#define SL_RATEPROP_NOPITCHCORAUDIO ((SLuint32) 0x00000400)
+#define SL_RATEPROP_PITCHCORAUDIO ((SLuint32) 0x00000800)
+
+
+extern SL_API const SLInterfaceID SL_IID_PLAYBACKRATE;
+
+struct SLPlaybackRateItf_;
+typedef const struct SLPlaybackRateItf_ * const * SLPlaybackRateItf;
+
+struct SLPlaybackRateItf_ {
+ SLresult (*SetRate)(
+ SLPlaybackRateItf self,
+ SLpermille rate
+ );
+ SLresult (*GetRate)(
+ SLPlaybackRateItf self,
+ SLpermille *pRate
+ );
+ SLresult (*SetPropertyConstraints)(
+ SLPlaybackRateItf self,
+ SLuint32 constraints
+ );
+ SLresult (*GetProperties)(
+ SLPlaybackRateItf self,
+ SLuint32 *pProperties
+ );
+ SLresult (*GetCapabilitiesOfRate)(
+ SLPlaybackRateItf self,
+ SLpermille rate,
+ SLuint32 *pCapabilities
+ );
+ SLresult (*GetRateRange) (
+ SLPlaybackRateItf self,
+ SLuint8 index,
+ SLpermille *pMinRate,
+ SLpermille *pMaxRate,
+ SLpermille *pStepSize,
+ SLuint32 *pCapabilities
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Seek Interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_SEEKMODE_FAST ((SLuint32) 0x0001)
+#define SL_SEEKMODE_ACCURATE ((SLuint32) 0x0002)
+
+extern SL_API const SLInterfaceID SL_IID_SEEK;
+
+struct SLSeekItf_;
+typedef const struct SLSeekItf_ * const * SLSeekItf;
+
+struct SLSeekItf_ {
+ SLresult (*SetPosition)(
+ SLSeekItf self,
+ SLmillisecond pos,
+ SLuint32 seekMode
+ );
+ SLresult (*SetLoop)(
+ SLSeekItf self,
+ SLboolean loopEnable,
+ SLmillisecond startPos,
+ SLmillisecond endPos
+ );
+ SLresult (*GetLoop)(
+ SLSeekItf self,
+ SLboolean *pLoopEnabled,
+ SLmillisecond *pStartPos,
+ SLmillisecond *pEndPos
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Standard Recording Interface */
+/*---------------------------------------------------------------------------*/
+
+/** Recording states */
+#define SL_RECORDSTATE_STOPPED ((SLuint32) 0x00000001)
+#define SL_RECORDSTATE_PAUSED ((SLuint32) 0x00000002)
+#define SL_RECORDSTATE_RECORDING ((SLuint32) 0x00000003)
+
+
+/** Record event **/
+#define SL_RECORDEVENT_HEADATLIMIT ((SLuint32) 0x00000001)
+#define SL_RECORDEVENT_HEADATMARKER ((SLuint32) 0x00000002)
+#define SL_RECORDEVENT_HEADATNEWPOS ((SLuint32) 0x00000004)
+#define SL_RECORDEVENT_HEADMOVING ((SLuint32) 0x00000008)
+#define SL_RECORDEVENT_HEADSTALLED ((SLuint32) 0x00000010)
+/* Note: SL_RECORDEVENT_BUFFER_INSUFFICIENT is deprecated, use SL_RECORDEVENT_BUFFER_FULL instead. */
+#define SL_RECORDEVENT_BUFFER_INSUFFICIENT ((SLuint32) 0x00000020)
+#define SL_RECORDEVENT_BUFFER_FULL ((SLuint32) 0x00000020)
+
+
+extern SL_API const SLInterfaceID SL_IID_RECORD;
+
+struct SLRecordItf_;
+typedef const struct SLRecordItf_ * const * SLRecordItf;
+
+typedef void (SLAPIENTRY *slRecordCallback) (
+ SLRecordItf caller,
+ void *pContext,
+ SLuint32 event
+);
+
+/** Recording interface methods */
+struct SLRecordItf_ {
+ SLresult (*SetRecordState) (
+ SLRecordItf self,
+ SLuint32 state
+ );
+ SLresult (*GetRecordState) (
+ SLRecordItf self,
+ SLuint32 *pState
+ );
+ SLresult (*SetDurationLimit) (
+ SLRecordItf self,
+ SLmillisecond msec
+ );
+ SLresult (*GetPosition) (
+ SLRecordItf self,
+ SLmillisecond *pMsec
+ );
+ SLresult (*RegisterCallback) (
+ SLRecordItf self,
+ slRecordCallback callback,
+ void *pContext
+ );
+ SLresult (*SetCallbackEventsMask) (
+ SLRecordItf self,
+ SLuint32 eventFlags
+ );
+ SLresult (*GetCallbackEventsMask) (
+ SLRecordItf self,
+ SLuint32 *pEventFlags
+ );
+ SLresult (*SetMarkerPosition) (
+ SLRecordItf self,
+ SLmillisecond mSec
+ );
+ SLresult (*ClearMarkerPosition) (
+ SLRecordItf self
+ );
+ SLresult (*GetMarkerPosition) (
+ SLRecordItf self,
+ SLmillisecond *pMsec
+ );
+ SLresult (*SetPositionUpdatePeriod) (
+ SLRecordItf self,
+ SLmillisecond mSec
+ );
+ SLresult (*GetPositionUpdatePeriod) (
+ SLRecordItf self,
+ SLmillisecond *pMsec
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Equalizer interface */
+/*---------------------------------------------------------------------------*/
+
+#define SL_EQUALIZER_UNDEFINED ((SLuint16) 0xFFFF)
+
+extern SL_API const SLInterfaceID SL_IID_EQUALIZER;
+
+struct SLEqualizerItf_;
+typedef const struct SLEqualizerItf_ * const * SLEqualizerItf;
+
+struct SLEqualizerItf_ {
+ SLresult (*SetEnabled)(
+ SLEqualizerItf self,
+ SLboolean enabled
+ );
+ SLresult (*IsEnabled)(
+ SLEqualizerItf self,
+ SLboolean *pEnabled
+ );
+ SLresult (*GetNumberOfBands)(
+ SLEqualizerItf self,
+ SLuint16 *pAmount
+ );
+ SLresult (*GetBandLevelRange)(
+ SLEqualizerItf self,
+ SLmillibel *pMin,
+ SLmillibel *pMax
+ );
+ SLresult (*SetBandLevel)(
+ SLEqualizerItf self,
+ SLuint16 band,
+ SLmillibel level
+ );
+ SLresult (*GetBandLevel)(
+ SLEqualizerItf self,
+ SLuint16 band,
+ SLmillibel *pLevel
+ );
+ SLresult (*GetCenterFreq)(
+ SLEqualizerItf self,
+ SLuint16 band,
+ SLmilliHertz *pCenter
+ );
+ SLresult (*GetBandFreqRange)(
+ SLEqualizerItf self,
+ SLuint16 band,
+ SLmilliHertz *pMin,
+ SLmilliHertz *pMax
+ );
+ SLresult (*GetBand)(
+ SLEqualizerItf self,
+ SLmilliHertz frequency,
+ SLuint16 *pBand
+ );
+ SLresult (*GetCurrentPreset)(
+ SLEqualizerItf self,
+ SLuint16 *pPreset
+ );
+ SLresult (*UsePreset)(
+ SLEqualizerItf self,
+ SLuint16 index
+ );
+ SLresult (*GetNumberOfPresets)(
+ SLEqualizerItf self,
+ SLuint16 *pNumPresets
+ );
+ SLresult (*GetPresetName)(
+ SLEqualizerItf self,
+ SLuint16 index,
+ const SLchar ** ppName
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Volume Interface */
+/* --------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_VOLUME;
+
+struct SLVolumeItf_;
+typedef const struct SLVolumeItf_ * const * SLVolumeItf;
+
+struct SLVolumeItf_ {
+ SLresult (*SetVolumeLevel) (
+ SLVolumeItf self,
+ SLmillibel level
+ );
+ SLresult (*GetVolumeLevel) (
+ SLVolumeItf self,
+ SLmillibel *pLevel
+ );
+ SLresult (*GetMaxVolumeLevel) (
+ SLVolumeItf self,
+ SLmillibel *pMaxLevel
+ );
+ SLresult (*SetMute) (
+ SLVolumeItf self,
+ SLboolean mute
+ );
+ SLresult (*GetMute) (
+ SLVolumeItf self,
+ SLboolean *pMute
+ );
+ SLresult (*EnableStereoPosition) (
+ SLVolumeItf self,
+ SLboolean enable
+ );
+ SLresult (*IsEnabledStereoPosition) (
+ SLVolumeItf self,
+ SLboolean *pEnable
+ );
+ SLresult (*SetStereoPosition) (
+ SLVolumeItf self,
+ SLpermille stereoPosition
+ );
+ SLresult (*GetStereoPosition) (
+ SLVolumeItf self,
+ SLpermille *pStereoPosition
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Device Volume Interface */
+/* --------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_DEVICEVOLUME;
+
+struct SLDeviceVolumeItf_;
+typedef const struct SLDeviceVolumeItf_ * const * SLDeviceVolumeItf;
+
+struct SLDeviceVolumeItf_ {
+ SLresult (*GetVolumeScale) (
+ SLDeviceVolumeItf self,
+ SLuint32 deviceID,
+ SLint32 *pMinValue,
+ SLint32 *pMaxValue,
+ SLboolean *pIsMillibelScale
+ );
+ SLresult (*SetVolume) (
+ SLDeviceVolumeItf self,
+ SLuint32 deviceID,
+ SLint32 volume
+ );
+ SLresult (*GetVolume) (
+ SLDeviceVolumeItf self,
+ SLuint32 deviceID,
+ SLint32 *pVolume
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Buffer Queue Interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_BUFFERQUEUE;
+
+struct SLBufferQueueItf_;
+typedef const struct SLBufferQueueItf_ * const * SLBufferQueueItf;
+
+typedef void (SLAPIENTRY *slBufferQueueCallback)(
+ SLBufferQueueItf caller,
+ void *pContext
+);
+
+/** Buffer queue state **/
+
+typedef struct SLBufferQueueState_ {
+ SLuint32 count;
+ SLuint32 playIndex;
+} SLBufferQueueState;
+
+
+struct SLBufferQueueItf_ {
+ SLresult (*Enqueue) (
+ SLBufferQueueItf self,
+ const void *pBuffer,
+ SLuint32 size
+ );
+ SLresult (*Clear) (
+ SLBufferQueueItf self
+ );
+ SLresult (*GetState) (
+ SLBufferQueueItf self,
+ SLBufferQueueState *pState
+ );
+ SLresult (*RegisterCallback) (
+ SLBufferQueueItf self,
+ slBufferQueueCallback callback,
+ void* pContext
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* PresetReverb */
+/*---------------------------------------------------------------------------*/
+
+#define SL_REVERBPRESET_NONE ((SLuint16) 0x0000)
+#define SL_REVERBPRESET_SMALLROOM ((SLuint16) 0x0001)
+#define SL_REVERBPRESET_MEDIUMROOM ((SLuint16) 0x0002)
+#define SL_REVERBPRESET_LARGEROOM ((SLuint16) 0x0003)
+#define SL_REVERBPRESET_MEDIUMHALL ((SLuint16) 0x0004)
+#define SL_REVERBPRESET_LARGEHALL ((SLuint16) 0x0005)
+#define SL_REVERBPRESET_PLATE ((SLuint16) 0x0006)
+
+
+extern SL_API const SLInterfaceID SL_IID_PRESETREVERB;
+
+struct SLPresetReverbItf_;
+typedef const struct SLPresetReverbItf_ * const * SLPresetReverbItf;
+
+struct SLPresetReverbItf_ {
+ SLresult (*SetPreset) (
+ SLPresetReverbItf self,
+ SLuint16 preset
+ );
+ SLresult (*GetPreset) (
+ SLPresetReverbItf self,
+ SLuint16 *pPreset
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* EnvironmentalReverb */
+/*---------------------------------------------------------------------------*/
+
+#define SL_I3DL2_ENVIRONMENT_PRESET_DEFAULT \
+ { SL_MILLIBEL_MIN, 0, 1000, 500, SL_MILLIBEL_MIN, 20, SL_MILLIBEL_MIN, 40, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_GENERIC \
+ { -1000, -100, 1490, 830, -2602, 7, 200, 11, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_PADDEDCELL \
+ { -1000,-6000, 170, 100, -1204, 1, 207, 2, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_ROOM \
+ { -1000, -454, 400, 830, -1646, 2, 53, 3, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_BATHROOM \
+ { -1000,-1200, 1490, 540, -370, 7, 1030, 11, 1000, 600 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_LIVINGROOM \
+ { -1000,-6000, 500, 100, -1376, 3, -1104, 4, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_STONEROOM \
+ { -1000, -300, 2310, 640, -711, 12, 83, 17, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_AUDITORIUM \
+ { -1000, -476, 4320, 590, -789, 20, -289, 30, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_CONCERTHALL \
+ { -1000, -500, 3920, 700, -1230, 20, -2, 29, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_CAVE \
+ { -1000, 0, 2910, 1300, -602, 15, -302, 22, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_ARENA \
+ { -1000, -698, 7240, 330, -1166, 20, 16, 30, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_HANGAR \
+ { -1000,-1000, 10050, 230, -602, 20, 198, 30, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_CARPETEDHALLWAY \
+ { -1000,-4000, 300, 100, -1831, 2, -1630, 30, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_HALLWAY \
+ { -1000, -300, 1490, 590, -1219, 7, 441, 11, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR \
+ { -1000, -237, 2700, 790, -1214, 13, 395, 20, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_ALLEY \
+ { -1000, -270, 1490, 860, -1204, 7, -4, 11, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_FOREST \
+ { -1000,-3300, 1490, 540, -2560, 162, -613, 88, 790,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_CITY \
+ { -1000, -800, 1490, 670, -2273, 7, -2217, 11, 500,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_MOUNTAINS \
+ { -1000,-2500, 1490, 210, -2780, 300, -2014, 100, 270,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_QUARRY \
+ { -1000,-1000, 1490, 830, SL_MILLIBEL_MIN, 61, 500, 25, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_PLAIN \
+ { -1000,-2000, 1490, 500, -2466, 179, -2514, 100, 210,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_PARKINGLOT \
+ { -1000, 0, 1650, 1500, -1363, 8, -1153, 12, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_SEWERPIPE \
+ { -1000,-1000, 2810, 140, 429, 14, 648, 21, 800, 600 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_UNDERWATER \
+ { -1000,-4000, 1490, 100, -449, 7, 1700, 11, 1000,1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_SMALLROOM \
+ { -1000,-600, 1100, 830, -400, 5, 500, 10, 1000, 1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMROOM \
+ { -1000,-600, 1300, 830, -1000, 20, -200, 20, 1000, 1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_LARGEROOM \
+ { -1000,-600, 1500, 830, -1600, 5, -1000, 40, 1000, 1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMHALL \
+ { -1000,-600, 1800, 700, -1300, 15, -800, 30, 1000, 1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_LARGEHALL \
+ { -1000,-600, 1800, 700, -2000, 30, -1400, 60, 1000, 1000 }
+#define SL_I3DL2_ENVIRONMENT_PRESET_PLATE \
+ { -1000,-200, 1300, 900, 0, 2, 0, 10, 1000, 750 }
+
+
+typedef struct SLEnvironmentalReverbSettings_ {
+ SLmillibel roomLevel;
+ SLmillibel roomHFLevel;
+ SLmillisecond decayTime;
+ SLpermille decayHFRatio;
+ SLmillibel reflectionsLevel;
+ SLmillisecond reflectionsDelay;
+ SLmillibel reverbLevel;
+ SLmillisecond reverbDelay;
+ SLpermille diffusion;
+ SLpermille density;
+} SLEnvironmentalReverbSettings;
+
+
+
+
+extern SL_API const SLInterfaceID SL_IID_ENVIRONMENTALREVERB;
+
+
+struct SLEnvironmentalReverbItf_;
+typedef const struct SLEnvironmentalReverbItf_ * const * SLEnvironmentalReverbItf;
+
+struct SLEnvironmentalReverbItf_ {
+ SLresult (*SetRoomLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel room
+ );
+ SLresult (*GetRoomLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel *pRoom
+ );
+ SLresult (*SetRoomHFLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel roomHF
+ );
+ SLresult (*GetRoomHFLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel *pRoomHF
+ );
+ SLresult (*SetDecayTime) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond decayTime
+ );
+ SLresult (*GetDecayTime) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond *pDecayTime
+ );
+ SLresult (*SetDecayHFRatio) (
+ SLEnvironmentalReverbItf self,
+ SLpermille decayHFRatio
+ );
+ SLresult (*GetDecayHFRatio) (
+ SLEnvironmentalReverbItf self,
+ SLpermille *pDecayHFRatio
+ );
+ SLresult (*SetReflectionsLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel reflectionsLevel
+ );
+ SLresult (*GetReflectionsLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel *pReflectionsLevel
+ );
+ SLresult (*SetReflectionsDelay) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond reflectionsDelay
+ );
+ SLresult (*GetReflectionsDelay) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond *pReflectionsDelay
+ );
+ SLresult (*SetReverbLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel reverbLevel
+ );
+ SLresult (*GetReverbLevel) (
+ SLEnvironmentalReverbItf self,
+ SLmillibel *pReverbLevel
+ );
+ SLresult (*SetReverbDelay) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond reverbDelay
+ );
+ SLresult (*GetReverbDelay) (
+ SLEnvironmentalReverbItf self,
+ SLmillisecond *pReverbDelay
+ );
+ SLresult (*SetDiffusion) (
+ SLEnvironmentalReverbItf self,
+ SLpermille diffusion
+ );
+ SLresult (*GetDiffusion) (
+ SLEnvironmentalReverbItf self,
+ SLpermille *pDiffusion
+ );
+ SLresult (*SetDensity) (
+ SLEnvironmentalReverbItf self,
+ SLpermille density
+ );
+ SLresult (*GetDensity) (
+ SLEnvironmentalReverbItf self,
+ SLpermille *pDensity
+ );
+ SLresult (*SetEnvironmentalReverbProperties) (
+ SLEnvironmentalReverbItf self,
+ const SLEnvironmentalReverbSettings *pProperties
+ );
+ SLresult (*GetEnvironmentalReverbProperties) (
+ SLEnvironmentalReverbItf self,
+ SLEnvironmentalReverbSettings *pProperties
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Effects Send Interface */
+/*---------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_EFFECTSEND;
+
+struct SLEffectSendItf_;
+typedef const struct SLEffectSendItf_ * const * SLEffectSendItf;
+
+struct SLEffectSendItf_ {
+ SLresult (*EnableEffectSend) (
+ SLEffectSendItf self,
+ const void *pAuxEffect,
+ SLboolean enable,
+ SLmillibel initialLevel
+ );
+ SLresult (*IsEnabled) (
+ SLEffectSendItf self,
+ const void * pAuxEffect,
+ SLboolean *pEnable
+ );
+ SLresult (*SetDirectLevel) (
+ SLEffectSendItf self,
+ SLmillibel directLevel
+ );
+ SLresult (*GetDirectLevel) (
+ SLEffectSendItf self,
+ SLmillibel *pDirectLevel
+ );
+ SLresult (*SetSendLevel) (
+ SLEffectSendItf self,
+ const void *pAuxEffect,
+ SLmillibel sendLevel
+ );
+ SLresult (*GetSendLevel)(
+ SLEffectSendItf self,
+ const void *pAuxEffect,
+ SLmillibel *pSendLevel
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* 3D Grouping Interface */
+/*---------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_3DGROUPING;
+
+
+struct SL3DGroupingItf_ ;
+typedef const struct SL3DGroupingItf_ * const * SL3DGroupingItf;
+
+struct SL3DGroupingItf_ {
+ SLresult (*Set3DGroup) (
+ SL3DGroupingItf self,
+ SLObjectItf group
+ );
+ SLresult (*Get3DGroup) (
+ SL3DGroupingItf self,
+ SLObjectItf *pGroup
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* 3D Commit Interface */
+/*---------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_3DCOMMIT;
+
+struct SL3DCommitItf_;
+typedef const struct SL3DCommitItf_* const * SL3DCommitItf;
+
+struct SL3DCommitItf_ {
+ SLresult (*Commit) (
+ SL3DCommitItf self
+ );
+ SLresult (*SetDeferred) (
+ SL3DCommitItf self,
+ SLboolean deferred
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* 3D Location Interface */
+/*---------------------------------------------------------------------------*/
+
+typedef struct SLVec3D_ {
+ SLint32 x;
+ SLint32 y;
+ SLint32 z;
+} SLVec3D;
+
+extern SL_API const SLInterfaceID SL_IID_3DLOCATION;
+
+struct SL3DLocationItf_;
+typedef const struct SL3DLocationItf_ * const * SL3DLocationItf;
+
+struct SL3DLocationItf_ {
+ SLresult (*SetLocationCartesian) (
+ SL3DLocationItf self,
+ const SLVec3D *pLocation
+ );
+ SLresult (*SetLocationSpherical) (
+ SL3DLocationItf self,
+ SLmillidegree azimuth,
+ SLmillidegree elevation,
+ SLmillimeter distance
+ );
+ SLresult (*Move) (
+ SL3DLocationItf self,
+ const SLVec3D *pMovement
+ );
+ SLresult (*GetLocationCartesian) (
+ SL3DLocationItf self,
+ SLVec3D *pLocation
+ );
+ SLresult (*SetOrientationVectors) (
+ SL3DLocationItf self,
+ const SLVec3D *pFront,
+ const SLVec3D *pAbove
+ );
+ SLresult (*SetOrientationAngles) (
+ SL3DLocationItf self,
+ SLmillidegree heading,
+ SLmillidegree pitch,
+ SLmillidegree roll
+ );
+ SLresult (*Rotate) (
+ SL3DLocationItf self,
+ SLmillidegree theta,
+ const SLVec3D *pAxis
+ );
+ SLresult (*GetOrientationVectors) (
+ SL3DLocationItf self,
+ SLVec3D *pFront,
+ SLVec3D *pUp
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* 3D Doppler Interface */
+/*---------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_3DDOPPLER;
+
+struct SL3DDopplerItf_;
+typedef const struct SL3DDopplerItf_ * const * SL3DDopplerItf;
+
+struct SL3DDopplerItf_ {
+ SLresult (*SetVelocityCartesian) (
+ SL3DDopplerItf self,
+ const SLVec3D *pVelocity
+ );
+ SLresult (*SetVelocitySpherical) (
+ SL3DDopplerItf self,
+ SLmillidegree azimuth,
+ SLmillidegree elevation,
+ SLmillimeter speed
+ );
+ SLresult (*GetVelocityCartesian) (
+ SL3DDopplerItf self,
+ SLVec3D *pVelocity
+ );
+ SLresult (*SetDopplerFactor) (
+ SL3DDopplerItf self,
+ SLpermille dopplerFactor
+ );
+ SLresult (*GetDopplerFactor) (
+ SL3DDopplerItf self,
+ SLpermille *pDopplerFactor
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* 3D Source Interface and associated defines */
+/* --------------------------------------------------------------------------*/
+
+#define SL_ROLLOFFMODEL_EXPONENTIAL ((SLuint32) 0x00000000)
+#define SL_ROLLOFFMODEL_LINEAR ((SLuint32) 0x00000001)
+
+
+extern SL_API const SLInterfaceID SL_IID_3DSOURCE;
+
+struct SL3DSourceItf_;
+typedef const struct SL3DSourceItf_ * const * SL3DSourceItf;
+
+struct SL3DSourceItf_ {
+ SLresult (*SetHeadRelative) (
+ SL3DSourceItf self,
+ SLboolean headRelative
+ );
+ SLresult (*GetHeadRelative) (
+ SL3DSourceItf self,
+ SLboolean *pHeadRelative
+ );
+ SLresult (*SetRolloffDistances) (
+ SL3DSourceItf self,
+ SLmillimeter minDistance,
+ SLmillimeter maxDistance
+ );
+ SLresult (*GetRolloffDistances) (
+ SL3DSourceItf self,
+ SLmillimeter *pMinDistance,
+ SLmillimeter *pMaxDistance
+ );
+ SLresult (*SetRolloffMaxDistanceMute) (
+ SL3DSourceItf self,
+ SLboolean mute
+ );
+ SLresult (*GetRolloffMaxDistanceMute) (
+ SL3DSourceItf self,
+ SLboolean *pMute
+ );
+ SLresult (*SetRolloffFactor) (
+ SL3DSourceItf self,
+ SLpermille rolloffFactor
+ );
+ SLresult (*GetRolloffFactor) (
+ SL3DSourceItf self,
+ SLpermille *pRolloffFactor
+ );
+ SLresult (*SetRoomRolloffFactor) (
+ SL3DSourceItf self,
+ SLpermille roomRolloffFactor
+ );
+ SLresult (*GetRoomRolloffFactor) (
+ SL3DSourceItf self,
+ SLpermille *pRoomRolloffFactor
+ );
+ SLresult (*SetRolloffModel) (
+ SL3DSourceItf self,
+ SLuint8 model
+ );
+ SLresult (*GetRolloffModel) (
+ SL3DSourceItf self,
+ SLuint8 *pModel
+ );
+ SLresult (*SetCone) (
+ SL3DSourceItf self,
+ SLmillidegree innerAngle,
+ SLmillidegree outerAngle,
+ SLmillibel outerLevel
+ );
+ SLresult (*GetCone) (
+ SL3DSourceItf self,
+ SLmillidegree *pInnerAngle,
+ SLmillidegree *pOuterAngle,
+ SLmillibel *pOuterLevel
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* 3D Macroscopic Interface */
+/* --------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_3DMACROSCOPIC;
+
+struct SL3DMacroscopicItf_;
+typedef const struct SL3DMacroscopicItf_ * const * SL3DMacroscopicItf;
+
+struct SL3DMacroscopicItf_ {
+ SLresult (*SetSize) (
+ SL3DMacroscopicItf self,
+ SLmillimeter width,
+ SLmillimeter height,
+ SLmillimeter depth
+ );
+ SLresult (*GetSize) (
+ SL3DMacroscopicItf self,
+ SLmillimeter *pWidth,
+ SLmillimeter *pHeight,
+ SLmillimeter *pDepth
+ );
+ SLresult (*SetOrientationAngles) (
+ SL3DMacroscopicItf self,
+ SLmillidegree heading,
+ SLmillidegree pitch,
+ SLmillidegree roll
+ );
+ SLresult (*SetOrientationVectors) (
+ SL3DMacroscopicItf self,
+ const SLVec3D *pFront,
+ const SLVec3D *pAbove
+ );
+ SLresult (*Rotate) (
+ SL3DMacroscopicItf self,
+ SLmillidegree theta,
+ const SLVec3D *pAxis
+ );
+ SLresult (*GetOrientationVectors) (
+ SL3DMacroscopicItf self,
+ SLVec3D *pFront,
+ SLVec3D *pUp
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Mute Solo Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_MUTESOLO;
+
+struct SLMuteSoloItf_;
+typedef const struct SLMuteSoloItf_ * const * SLMuteSoloItf;
+
+struct SLMuteSoloItf_ {
+ SLresult (*SetChannelMute) (
+ SLMuteSoloItf self,
+ SLuint8 chan,
+ SLboolean mute
+ );
+ SLresult (*GetChannelMute) (
+ SLMuteSoloItf self,
+ SLuint8 chan,
+ SLboolean *pMute
+ );
+ SLresult (*SetChannelSolo) (
+ SLMuteSoloItf self,
+ SLuint8 chan,
+ SLboolean solo
+ );
+ SLresult (*GetChannelSolo) (
+ SLMuteSoloItf self,
+ SLuint8 chan,
+ SLboolean *pSolo
+ );
+ SLresult (*GetNumChannels) (
+ SLMuteSoloItf self,
+ SLuint8 *pNumChannels
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Dynamic Interface Management Interface and associated types and macros */
+/* --------------------------------------------------------------------------*/
+
+#define SL_DYNAMIC_ITF_EVENT_RUNTIME_ERROR ((SLuint32) 0x00000001)
+#define SL_DYNAMIC_ITF_EVENT_ASYNC_TERMINATION ((SLuint32) 0x00000002)
+#define SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST ((SLuint32) 0x00000003)
+#define SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST_PERMANENTLY ((SLuint32) 0x00000004)
+#define SL_DYNAMIC_ITF_EVENT_RESOURCES_AVAILABLE ((SLuint32) 0x00000005)
+
+
+
+
+extern SL_API const SLInterfaceID SL_IID_DYNAMICINTERFACEMANAGEMENT;
+
+struct SLDynamicInterfaceManagementItf_;
+typedef const struct SLDynamicInterfaceManagementItf_ * const * SLDynamicInterfaceManagementItf;
+
+typedef void (SLAPIENTRY *slDynamicInterfaceManagementCallback) (
+ SLDynamicInterfaceManagementItf caller,
+ void * pContext,
+ SLuint32 event,
+ SLresult result,
+ const SLInterfaceID iid
+);
+
+
+struct SLDynamicInterfaceManagementItf_ {
+ SLresult (*AddInterface) (
+ SLDynamicInterfaceManagementItf self,
+ const SLInterfaceID iid,
+ SLboolean async
+ );
+ SLresult (*RemoveInterface) (
+ SLDynamicInterfaceManagementItf self,
+ const SLInterfaceID iid
+ );
+ SLresult (*ResumeInterface) (
+ SLDynamicInterfaceManagementItf self,
+ const SLInterfaceID iid,
+ SLboolean async
+ );
+ SLresult (*RegisterCallback) (
+ SLDynamicInterfaceManagementItf self,
+ slDynamicInterfaceManagementCallback callback,
+ void * pContext
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Midi Message Interface and associated types */
+/* --------------------------------------------------------------------------*/
+
+#define SL_MIDIMESSAGETYPE_NOTE_ON_OFF ((SLuint32) 0x00000001)
+#define SL_MIDIMESSAGETYPE_POLY_PRESSURE ((SLuint32) 0x00000002)
+#define SL_MIDIMESSAGETYPE_CONTROL_CHANGE ((SLuint32) 0x00000003)
+#define SL_MIDIMESSAGETYPE_PROGRAM_CHANGE ((SLuint32) 0x00000004)
+#define SL_MIDIMESSAGETYPE_CHANNEL_PRESSURE ((SLuint32) 0x00000005)
+#define SL_MIDIMESSAGETYPE_PITCH_BEND ((SLuint32) 0x00000006)
+#define SL_MIDIMESSAGETYPE_SYSTEM_MESSAGE ((SLuint32) 0x00000007)
+
+
+extern SL_API const SLInterfaceID SL_IID_MIDIMESSAGE;
+
+struct SLMIDIMessageItf_;
+typedef const struct SLMIDIMessageItf_ * const * SLMIDIMessageItf;
+
+typedef void (SLAPIENTRY *slMetaEventCallback) (
+ SLMIDIMessageItf caller,
+ void *pContext,
+ SLuint8 type,
+ SLuint32 length,
+ const SLuint8 *pData,
+ SLuint32 tick,
+ SLuint16 track
+);
+
+typedef void (SLAPIENTRY *slMIDIMessageCallback) (
+ SLMIDIMessageItf caller,
+ void *pContext,
+ SLuint8 statusByte,
+ SLuint32 length,
+ const SLuint8 *pData,
+ SLuint32 tick,
+ SLuint16 track
+);
+
+struct SLMIDIMessageItf_ {
+ SLresult (*SendMessage) (
+ SLMIDIMessageItf self,
+ const SLuint8 *data,
+ SLuint32 length
+ );
+ SLresult (*RegisterMetaEventCallback) (
+ SLMIDIMessageItf self,
+ slMetaEventCallback callback,
+ void *pContext
+ );
+ SLresult (*RegisterMIDIMessageCallback) (
+ SLMIDIMessageItf self,
+ slMIDIMessageCallback callback,
+ void *pContext
+ );
+ SLresult (*AddMIDIMessageCallbackFilter) (
+ SLMIDIMessageItf self,
+ SLuint32 messageType
+ );
+ SLresult (*ClearMIDIMessageCallbackFilter) (
+ SLMIDIMessageItf self
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Midi Mute Solo interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_MIDIMUTESOLO;
+
+struct SLMIDIMuteSoloItf_;
+typedef const struct SLMIDIMuteSoloItf_ * const * SLMIDIMuteSoloItf;
+
+struct SLMIDIMuteSoloItf_ {
+ SLresult (*SetChannelMute) (
+ SLMIDIMuteSoloItf self,
+ SLuint8 channel,
+ SLboolean mute
+ );
+ SLresult (*GetChannelMute) (
+ SLMIDIMuteSoloItf self,
+ SLuint8 channel,
+ SLboolean *pMute
+ );
+ SLresult (*SetChannelSolo) (
+ SLMIDIMuteSoloItf self,
+ SLuint8 channel,
+ SLboolean solo
+ );
+ SLresult (*GetChannelSolo) (
+ SLMIDIMuteSoloItf self,
+ SLuint8 channel,
+ SLboolean *pSolo
+ );
+ SLresult (*GetTrackCount) (
+ SLMIDIMuteSoloItf self,
+ SLuint16 *pCount
+ );
+ SLresult (*SetTrackMute) (
+ SLMIDIMuteSoloItf self,
+ SLuint16 track,
+ SLboolean mute
+ );
+ SLresult (*GetTrackMute) (
+ SLMIDIMuteSoloItf self,
+ SLuint16 track,
+ SLboolean *pMute
+ );
+ SLresult (*SetTrackSolo) (
+ SLMIDIMuteSoloItf self,
+ SLuint16 track,
+ SLboolean solo
+ );
+ SLresult (*GetTrackSolo) (
+ SLMIDIMuteSoloItf self,
+ SLuint16 track,
+ SLboolean *pSolo
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Midi Tempo interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_MIDITEMPO;
+
+struct SLMIDITempoItf_;
+typedef const struct SLMIDITempoItf_ * const * SLMIDITempoItf;
+
+struct SLMIDITempoItf_ {
+ SLresult (*SetTicksPerQuarterNote) (
+ SLMIDITempoItf self,
+ SLuint32 tpqn
+ );
+ SLresult (*GetTicksPerQuarterNote) (
+ SLMIDITempoItf self,
+ SLuint32 *pTpqn
+ );
+ SLresult (*SetMicrosecondsPerQuarterNote) (
+ SLMIDITempoItf self,
+ SLmicrosecond uspqn
+ );
+ SLresult (*GetMicrosecondsPerQuarterNote) (
+ SLMIDITempoItf self,
+ SLmicrosecond *uspqn
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Midi Time interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_MIDITIME;
+
+struct SLMIDITimeItf_;
+typedef const struct SLMIDITimeItf_ * const * SLMIDITimeItf;
+
+struct SLMIDITimeItf_ {
+ SLresult (*GetDuration) (
+ SLMIDITimeItf self,
+ SLuint32 *pDuration
+ );
+ SLresult (*SetPosition) (
+ SLMIDITimeItf self,
+ SLuint32 position
+ );
+ SLresult (*GetPosition) (
+ SLMIDITimeItf self,
+ SLuint32 *pPosition
+ );
+ SLresult (*SetLoopPoints) (
+ SLMIDITimeItf self,
+ SLuint32 startTick,
+ SLuint32 numTicks
+ );
+ SLresult (*GetLoopPoints) (
+ SLMIDITimeItf self,
+ SLuint32 *pStartTick,
+ SLuint32 *pNumTicks
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Audio Decoder Capabilities Interface */
+/* --------------------------------------------------------------------------*/
+
+/*Audio Codec related defines*/
+
+#define SL_RATECONTROLMODE_CONSTANTBITRATE ((SLuint32) 0x00000001)
+#define SL_RATECONTROLMODE_VARIABLEBITRATE ((SLuint32) 0x00000002)
+
+#define SL_AUDIOCODEC_PCM ((SLuint32) 0x00000001)
+#define SL_AUDIOCODEC_MP3 ((SLuint32) 0x00000002)
+#define SL_AUDIOCODEC_AMR ((SLuint32) 0x00000003)
+#define SL_AUDIOCODEC_AMRWB ((SLuint32) 0x00000004)
+#define SL_AUDIOCODEC_AMRWBPLUS ((SLuint32) 0x00000005)
+#define SL_AUDIOCODEC_AAC ((SLuint32) 0x00000006)
+#define SL_AUDIOCODEC_WMA ((SLuint32) 0x00000007)
+#define SL_AUDIOCODEC_REAL ((SLuint32) 0x00000008)
+
+#define SL_AUDIOPROFILE_PCM ((SLuint32) 0x00000001)
+
+#define SL_AUDIOPROFILE_MPEG1_L3 ((SLuint32) 0x00000001)
+#define SL_AUDIOPROFILE_MPEG2_L3 ((SLuint32) 0x00000002)
+#define SL_AUDIOPROFILE_MPEG25_L3 ((SLuint32) 0x00000003)
+
+#define SL_AUDIOCHANMODE_MP3_MONO ((SLuint32) 0x00000001)
+#define SL_AUDIOCHANMODE_MP3_STEREO ((SLuint32) 0x00000002)
+#define SL_AUDIOCHANMODE_MP3_JOINTSTEREO ((SLuint32) 0x00000003)
+#define SL_AUDIOCHANMODE_MP3_DUAL ((SLuint32) 0x00000004)
+
+#define SL_AUDIOPROFILE_AMR ((SLuint32) 0x00000001)
+
+#define SL_AUDIOSTREAMFORMAT_CONFORMANCE ((SLuint32) 0x00000001)
+#define SL_AUDIOSTREAMFORMAT_IF1 ((SLuint32) 0x00000002)
+#define SL_AUDIOSTREAMFORMAT_IF2 ((SLuint32) 0x00000003)
+#define SL_AUDIOSTREAMFORMAT_FSF ((SLuint32) 0x00000004)
+#define SL_AUDIOSTREAMFORMAT_RTPPAYLOAD ((SLuint32) 0x00000005)
+#define SL_AUDIOSTREAMFORMAT_ITU ((SLuint32) 0x00000006)
+
+#define SL_AUDIOPROFILE_AMRWB ((SLuint32) 0x00000001)
+
+#define SL_AUDIOPROFILE_AMRWBPLUS ((SLuint32) 0x00000001)
+
+#define SL_AUDIOPROFILE_AAC_AAC ((SLuint32) 0x00000001)
+
+#define SL_AUDIOMODE_AAC_MAIN ((SLuint32) 0x00000001)
+#define SL_AUDIOMODE_AAC_LC ((SLuint32) 0x00000002)
+#define SL_AUDIOMODE_AAC_SSR ((SLuint32) 0x00000003)
+#define SL_AUDIOMODE_AAC_LTP ((SLuint32) 0x00000004)
+#define SL_AUDIOMODE_AAC_HE ((SLuint32) 0x00000005)
+#define SL_AUDIOMODE_AAC_SCALABLE ((SLuint32) 0x00000006)
+#define SL_AUDIOMODE_AAC_ERLC ((SLuint32) 0x00000007)
+#define SL_AUDIOMODE_AAC_LD ((SLuint32) 0x00000008)
+#define SL_AUDIOMODE_AAC_HE_PS ((SLuint32) 0x00000009)
+#define SL_AUDIOMODE_AAC_HE_MPS ((SLuint32) 0x0000000A)
+
+#define SL_AUDIOSTREAMFORMAT_MP2ADTS ((SLuint32) 0x00000001)
+#define SL_AUDIOSTREAMFORMAT_MP4ADTS ((SLuint32) 0x00000002)
+#define SL_AUDIOSTREAMFORMAT_MP4LOAS ((SLuint32) 0x00000003)
+#define SL_AUDIOSTREAMFORMAT_MP4LATM ((SLuint32) 0x00000004)
+#define SL_AUDIOSTREAMFORMAT_ADIF ((SLuint32) 0x00000005)
+#define SL_AUDIOSTREAMFORMAT_MP4FF ((SLuint32) 0x00000006)
+#define SL_AUDIOSTREAMFORMAT_RAW ((SLuint32) 0x00000007)
+
+#define SL_AUDIOPROFILE_WMA7 ((SLuint32) 0x00000001)
+#define SL_AUDIOPROFILE_WMA8 ((SLuint32) 0x00000002)
+#define SL_AUDIOPROFILE_WMA9 ((SLuint32) 0x00000003)
+#define SL_AUDIOPROFILE_WMA10 ((SLuint32) 0x00000004)
+
+#define SL_AUDIOMODE_WMA_LEVEL1 ((SLuint32) 0x00000001)
+#define SL_AUDIOMODE_WMA_LEVEL2 ((SLuint32) 0x00000002)
+#define SL_AUDIOMODE_WMA_LEVEL3 ((SLuint32) 0x00000003)
+#define SL_AUDIOMODE_WMA_LEVEL4 ((SLuint32) 0x00000004)
+#define SL_AUDIOMODE_WMAPRO_LEVELM0 ((SLuint32) 0x00000005)
+#define SL_AUDIOMODE_WMAPRO_LEVELM1 ((SLuint32) 0x00000006)
+#define SL_AUDIOMODE_WMAPRO_LEVELM2 ((SLuint32) 0x00000007)
+#define SL_AUDIOMODE_WMAPRO_LEVELM3 ((SLuint32) 0x00000008)
+
+#define SL_AUDIOPROFILE_REALAUDIO ((SLuint32) 0x00000001)
+
+#define SL_AUDIOMODE_REALAUDIO_G2 ((SLuint32) 0x00000001)
+#define SL_AUDIOMODE_REALAUDIO_8 ((SLuint32) 0x00000002)
+#define SL_AUDIOMODE_REALAUDIO_10 ((SLuint32) 0x00000003)
+#define SL_AUDIOMODE_REALAUDIO_SURROUND ((SLuint32) 0x00000004)
+
+typedef struct SLAudioCodecDescriptor_ {
+ SLuint32 maxChannels;
+ SLuint32 minBitsPerSample;
+ SLuint32 maxBitsPerSample;
+ SLmilliHertz minSampleRate;
+ SLmilliHertz maxSampleRate;
+ SLboolean isFreqRangeContinuous;
+ SLmilliHertz *pSampleRatesSupported;
+ SLuint32 numSampleRatesSupported;
+ SLuint32 minBitRate;
+ SLuint32 maxBitRate;
+ SLboolean isBitrateRangeContinuous;
+ SLuint32 *pBitratesSupported;
+ SLuint32 numBitratesSupported;
+ SLuint32 profileSetting;
+ SLuint32 modeSetting;
+} SLAudioCodecDescriptor;
+
+/*Structure used to retrieve the profile and level settings supported by an audio encoder */
+
+typedef struct SLAudioCodecProfileMode_ {
+ SLuint32 profileSetting;
+ SLuint32 modeSetting;
+} SLAudioCodecProfileMode;
+
+extern SL_API const SLInterfaceID SL_IID_AUDIODECODERCAPABILITIES;
+
+struct SLAudioDecoderCapabilitiesItf_;
+typedef const struct SLAudioDecoderCapabilitiesItf_ * const * SLAudioDecoderCapabilitiesItf;
+
+struct SLAudioDecoderCapabilitiesItf_ {
+ SLresult (*GetAudioDecoders) (
+ SLAudioDecoderCapabilitiesItf self,
+ SLuint32 * pNumDecoders ,
+ SLuint32 *pDecoderIds
+ );
+ SLresult (*GetAudioDecoderCapabilities) (
+ SLAudioDecoderCapabilitiesItf self,
+ SLuint32 decoderId,
+ SLuint32 *pIndex,
+ SLAudioCodecDescriptor *pDescriptor
+ );
+};
+
+
+
+
+/*---------------------------------------------------------------------------*/
+/* Audio Encoder Capabilities Interface */
+/* --------------------------------------------------------------------------*/
+
+/* Structure used when setting audio encoding parameters */
+
+typedef struct SLAudioEncoderSettings_ {
+ SLuint32 encoderId;
+ SLuint32 channelsIn;
+ SLuint32 channelsOut;
+ SLmilliHertz sampleRate;
+ SLuint32 bitRate;
+ SLuint32 bitsPerSample;
+ SLuint32 rateControl;
+ SLuint32 profileSetting;
+ SLuint32 levelSetting;
+ SLuint32 channelMode;
+ SLuint32 streamFormat;
+ SLuint32 encodeOptions;
+ SLuint32 blockAlignment;
+} SLAudioEncoderSettings;
+
+extern SL_API const SLInterfaceID SL_IID_AUDIOENCODERCAPABILITIES;
+
+struct SLAudioEncoderCapabilitiesItf_;
+typedef const struct SLAudioEncoderCapabilitiesItf_ * const * SLAudioEncoderCapabilitiesItf;
+
+struct SLAudioEncoderCapabilitiesItf_ {
+ SLresult (*GetAudioEncoders) (
+ SLAudioEncoderCapabilitiesItf self,
+ SLuint32 *pNumEncoders ,
+ SLuint32 *pEncoderIds
+ );
+ SLresult (*GetAudioEncoderCapabilities) (
+ SLAudioEncoderCapabilitiesItf self,
+ SLuint32 encoderId,
+ SLuint32 *pIndex,
+ SLAudioCodecDescriptor * pDescriptor
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Audio Encoder Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_AUDIOENCODER;
+
+struct SLAudioEncoderItf_;
+typedef const struct SLAudioEncoderItf_ * const * SLAudioEncoderItf;
+
+struct SLAudioEncoderItf_ {
+ SLresult (*SetEncoderSettings) (
+ SLAudioEncoderItf self,
+ SLAudioEncoderSettings *pSettings
+ );
+ SLresult (*GetEncoderSettings) (
+ SLAudioEncoderItf self,
+ SLAudioEncoderSettings *pSettings
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Bass Boost Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_BASSBOOST;
+
+struct SLBassBoostItf_;
+typedef const struct SLBassBoostItf_ * const * SLBassBoostItf;
+
+struct SLBassBoostItf_ {
+ SLresult (*SetEnabled)(
+ SLBassBoostItf self,
+ SLboolean enabled
+ );
+ SLresult (*IsEnabled)(
+ SLBassBoostItf self,
+ SLboolean *pEnabled
+ );
+ SLresult (*SetStrength)(
+ SLBassBoostItf self,
+ SLpermille strength
+ );
+ SLresult (*GetRoundedStrength)(
+ SLBassBoostItf self,
+ SLpermille *pStrength
+ );
+ SLresult (*IsStrengthSupported)(
+ SLBassBoostItf self,
+ SLboolean *pSupported
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Pitch Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_PITCH;
+
+struct SLPitchItf_;
+typedef const struct SLPitchItf_ * const * SLPitchItf;
+
+struct SLPitchItf_ {
+ SLresult (*SetPitch) (
+ SLPitchItf self,
+ SLpermille pitch
+ );
+ SLresult (*GetPitch) (
+ SLPitchItf self,
+ SLpermille *pPitch
+ );
+ SLresult (*GetPitchCapabilities) (
+ SLPitchItf self,
+ SLpermille *pMinPitch,
+ SLpermille *pMaxPitch
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Rate Pitch Interface */
+/* RatePitchItf is an interface for controlling the rate a sound is played */
+/* back. A change in rate will cause a change in pitch. */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_RATEPITCH;
+
+struct SLRatePitchItf_;
+typedef const struct SLRatePitchItf_ * const * SLRatePitchItf;
+
+struct SLRatePitchItf_ {
+ SLresult (*SetRate) (
+ SLRatePitchItf self,
+ SLpermille rate
+ );
+ SLresult (*GetRate) (
+ SLRatePitchItf self,
+ SLpermille *pRate
+ );
+ SLresult (*GetRatePitchCapabilities) (
+ SLRatePitchItf self,
+ SLpermille *pMinRate,
+ SLpermille *pMaxRate
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Virtualizer Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_VIRTUALIZER;
+
+struct SLVirtualizerItf_;
+typedef const struct SLVirtualizerItf_ * const * SLVirtualizerItf;
+
+struct SLVirtualizerItf_ {
+ SLresult (*SetEnabled)(
+ SLVirtualizerItf self,
+ SLboolean enabled
+ );
+ SLresult (*IsEnabled)(
+ SLVirtualizerItf self,
+ SLboolean *pEnabled
+ );
+ SLresult (*SetStrength)(
+ SLVirtualizerItf self,
+ SLpermille strength
+ );
+ SLresult (*GetRoundedStrength)(
+ SLVirtualizerItf self,
+ SLpermille *pStrength
+ );
+ SLresult (*IsStrengthSupported)(
+ SLVirtualizerItf self,
+ SLboolean *pSupported
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Visualization Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_VISUALIZATION;
+
+struct SLVisualizationItf_;
+typedef const struct SLVisualizationItf_ * const * SLVisualizationItf;
+
+typedef void (SLAPIENTRY *slVisualizationCallback) (
+ void *pContext,
+ const SLuint8 waveform[],
+ const SLuint8 fft[],
+ SLmilliHertz samplerate
+);
+
+struct SLVisualizationItf_{
+ SLresult (*RegisterVisualizationCallback)(
+ SLVisualizationItf self,
+ slVisualizationCallback callback,
+ void *pContext,
+ SLmilliHertz rate
+ );
+ SLresult (*GetMaxRate)(
+ SLVisualizationItf self,
+ SLmilliHertz* pRate
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Engine Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_ENGINE;
+
+struct SLEngineItf_;
+typedef const struct SLEngineItf_ * const * SLEngineItf;
+
+
+struct SLEngineItf_ {
+
+ SLresult (*CreateLEDDevice) (
+ SLEngineItf self,
+ SLObjectItf * pDevice,
+ SLuint32 deviceID,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateVibraDevice) (
+ SLEngineItf self,
+ SLObjectItf * pDevice,
+ SLuint32 deviceID,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateAudioPlayer) (
+ SLEngineItf self,
+ SLObjectItf * pPlayer,
+ SLDataSource *pAudioSrc,
+ SLDataSink *pAudioSnk,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateAudioRecorder) (
+ SLEngineItf self,
+ SLObjectItf * pRecorder,
+ SLDataSource *pAudioSrc,
+ SLDataSink *pAudioSnk,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateMidiPlayer) (
+ SLEngineItf self,
+ SLObjectItf * pPlayer,
+ SLDataSource *pMIDISrc,
+ SLDataSource *pBankSrc,
+ SLDataSink *pAudioOutput,
+ SLDataSink *pVibra,
+ SLDataSink *pLEDArray,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateListener) (
+ SLEngineItf self,
+ SLObjectItf * pListener,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*Create3DGroup) (
+ SLEngineItf self,
+ SLObjectItf * pGroup,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateOutputMix) (
+ SLEngineItf self,
+ SLObjectItf * pMix,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateMetadataExtractor) (
+ SLEngineItf self,
+ SLObjectItf * pMetadataExtractor,
+ SLDataSource * pDataSource,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*CreateExtensionObject) (
+ SLEngineItf self,
+ SLObjectItf * pObject,
+ void * pParameters,
+ SLuint32 objectID,
+ SLuint32 numInterfaces,
+ const SLInterfaceID * pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+ );
+ SLresult (*QueryNumSupportedInterfaces) (
+ SLEngineItf self,
+ SLuint32 objectID,
+ SLuint32 * pNumSupportedInterfaces
+ );
+ SLresult (*QuerySupportedInterfaces) (
+ SLEngineItf self,
+ SLuint32 objectID,
+ SLuint32 index,
+ SLInterfaceID * pInterfaceId
+ );
+ SLresult (*QueryNumSupportedExtensions) (
+ SLEngineItf self,
+ SLuint32 * pNumExtensions
+ );
+ SLresult (*QuerySupportedExtension) (
+ SLEngineItf self,
+ SLuint32 index,
+ SLchar * pExtensionName,
+ SLint16 * pNameLength
+ );
+ SLresult (*IsExtensionSupported) (
+ SLEngineItf self,
+ const SLchar * pExtensionName,
+ SLboolean * pSupported
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Engine Capabilities Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_ENGINECAPABILITIES;
+
+struct SLEngineCapabilitiesItf_;
+typedef const struct SLEngineCapabilitiesItf_ * const * SLEngineCapabilitiesItf;
+
+struct SLEngineCapabilitiesItf_ {
+ SLresult (*QuerySupportedProfiles) (
+ SLEngineCapabilitiesItf self,
+ SLuint16 *pProfilesSupported
+ );
+ SLresult (*QueryAvailableVoices) (
+ SLEngineCapabilitiesItf self,
+ SLuint16 voiceType,
+ SLint16 *pNumMaxVoices,
+ SLboolean *pIsAbsoluteMax,
+ SLint16 *pNumFreeVoices
+ );
+ SLresult (*QueryNumberOfMIDISynthesizers) (
+ SLEngineCapabilitiesItf self,
+ SLint16 *pNumMIDIsynthesizers
+ );
+ SLresult (*QueryAPIVersion) (
+ SLEngineCapabilitiesItf self,
+ SLint16 *pMajor,
+ SLint16 *pMinor,
+ SLint16 *pStep
+ );
+ SLresult (*QueryLEDCapabilities) (
+ SLEngineCapabilitiesItf self,
+ SLuint32 *pIndex,
+ SLuint32 *pLEDDeviceID,
+ SLLEDDescriptor *pDescriptor
+ );
+ SLresult (*QueryVibraCapabilities) (
+ SLEngineCapabilitiesItf self,
+ SLuint32 *pIndex,
+ SLuint32 *pVibraDeviceID,
+ SLVibraDescriptor *pDescriptor
+ );
+ SLresult (*IsThreadSafe) (
+ SLEngineCapabilitiesItf self,
+ SLboolean *pIsThreadSafe
+ );
+};
+
+/*---------------------------------------------------------------------------*/
+/* Thread Sync Interface */
+/* --------------------------------------------------------------------------*/
+
+
+extern SL_API const SLInterfaceID SL_IID_THREADSYNC;
+
+struct SLThreadSyncItf_;
+typedef const struct SLThreadSyncItf_ * const * SLThreadSyncItf;
+
+
+struct SLThreadSyncItf_ {
+ SLresult (*EnterCriticalSection) (
+ SLThreadSyncItf self
+ );
+ SLresult (*ExitCriticalSection) (
+ SLThreadSyncItf self
+ );
+};
+
+
+/*****************************************************************************/
+/* SL engine constructor */
+/*****************************************************************************/
+
+#define SL_ENGINEOPTION_THREADSAFE ((SLuint32) 0x00000001)
+#define SL_ENGINEOPTION_LOSSOFCONTROL ((SLuint32) 0x00000002)
+
+typedef struct SLEngineOption_ {
+ SLuint32 feature;
+ SLuint32 data;
+} SLEngineOption;
+
+
+SL_API SLresult SLAPIENTRY slCreateEngine(
+ SLObjectItf *pEngine,
+ SLuint32 numOptions,
+ const SLEngineOption *pEngineOptions,
+ SLuint32 numInterfaces,
+ const SLInterfaceID *pInterfaceIds,
+ const SLboolean * pInterfaceRequired
+);
+
+SL_API SLresult SLAPIENTRY slQueryNumSupportedEngineInterfaces(
+ SLuint32 * pNumSupportedInterfaces
+);
+
+SL_API SLresult SLAPIENTRY slQuerySupportedEngineInterfaces(
+ SLuint32 index,
+ SLInterfaceID * pInterfaceId
+);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* OPENSL_ES_H_ */
diff --git a/ndk/platforms/android-24/include/SLES/OpenSLES_Android.h b/ndk/platforms/android-24/include/SLES/OpenSLES_Android.h
new file mode 100644
index 0000000..b4b5350
--- /dev/null
+++ b/ndk/platforms/android-24/include/SLES/OpenSLES_Android.h
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OPENSL_ES_ANDROID_H_
+#define OPENSL_ES_ANDROID_H_
+
+#include "OpenSLES_AndroidConfiguration.h"
+#include "OpenSLES_AndroidMetadata.h"
+#include <jni.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "OpenSLES.h"
+
+/*---------------------------------------------------------------------------*/
+/* Android common types */
+/*---------------------------------------------------------------------------*/
+
+typedef sl_int64_t SLAint64; /* 64 bit signed integer */
+
+typedef sl_uint64_t SLAuint64; /* 64 bit unsigned integer */
+
+/*---------------------------------------------------------------------------*/
+/* Android PCM Data Format */
+/*---------------------------------------------------------------------------*/
+
+/* The following pcm representations and data formats map to those in OpenSLES 1.1 */
+#define SL_ANDROID_PCM_REPRESENTATION_SIGNED_INT ((SLuint32) 0x00000001)
+#define SL_ANDROID_PCM_REPRESENTATION_UNSIGNED_INT ((SLuint32) 0x00000002)
+#define SL_ANDROID_PCM_REPRESENTATION_FLOAT ((SLuint32) 0x00000003)
+
+#define SL_ANDROID_DATAFORMAT_PCM_EX ((SLuint32) 0x00000004)
+
+typedef struct SLAndroidDataFormat_PCM_EX_ {
+ SLuint32 formatType;
+ SLuint32 numChannels;
+ SLuint32 sampleRate;
+ SLuint32 bitsPerSample;
+ SLuint32 containerSize;
+ SLuint32 channelMask;
+ SLuint32 endianness;
+ SLuint32 representation;
+} SLAndroidDataFormat_PCM_EX;
+
+#define SL_ANDROID_SPEAKER_NON_POSITIONAL ((SLuint32) 0x80000000)
+
+// Make an indexed channel mask from a bitfield.
+//
+// Each bit in the bitfield corresponds to a channel index,
+// from least-significant bit (channel 0) up to the bit
+// corresponding to the maximum channel count (currently FCC_8).
+// A '1' in the bitfield indicates that the channel should be
+// included in the stream, while a '0' indicates that it
+// should be excluded. For instance, a bitfield of 0x0A (binary 00001010)
+// would define a stream that contains channels 1 and 3. (The corresponding
+// indexed mask, after setting the SL_ANDROID_NON_POSITIONAL bit,
+// would be 0x8000000A.)
+#define SL_ANDROID_MAKE_INDEXED_CHANNEL_MASK(bitfield) \
+ ((bitfield) | SL_ANDROID_SPEAKER_NON_POSITIONAL)
+
+// Specifying SL_ANDROID_SPEAKER_USE_DEFAULT as a channel mask in
+// SLAndroidDataFormat_PCM_EX causes OpenSL ES to assign a default
+// channel mask based on the number of channels requested. This
+// value cannot be combined with SL_ANDROID_SPEAKER_NON_POSITIONAL.
+#define SL_ANDROID_SPEAKER_USE_DEFAULT ((SLuint32)0)
+
+/*---------------------------------------------------------------------------*/
+/* Android Effect interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_ANDROIDEFFECT;
+
+/** Android Effect interface methods */
+
+struct SLAndroidEffectItf_;
+typedef const struct SLAndroidEffectItf_ * const * SLAndroidEffectItf;
+
+struct SLAndroidEffectItf_ {
+
+ SLresult (*CreateEffect) (SLAndroidEffectItf self,
+ SLInterfaceID effectImplementationId);
+
+ SLresult (*ReleaseEffect) (SLAndroidEffectItf self,
+ SLInterfaceID effectImplementationId);
+
+ SLresult (*SetEnabled) (SLAndroidEffectItf self,
+ SLInterfaceID effectImplementationId,
+ SLboolean enabled);
+
+ SLresult (*IsEnabled) (SLAndroidEffectItf self,
+ SLInterfaceID effectImplementationId,
+ SLboolean *pEnabled);
+
+ SLresult (*SendCommand) (SLAndroidEffectItf self,
+ SLInterfaceID effectImplementationId,
+ SLuint32 command,
+ SLuint32 commandSize,
+ void *pCommandData,
+ SLuint32 *replySize,
+ void *pReplyData);
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Effect Send interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_ANDROIDEFFECTSEND;
+
+/** Android Effect Send interface methods */
+
+struct SLAndroidEffectSendItf_;
+typedef const struct SLAndroidEffectSendItf_ * const * SLAndroidEffectSendItf;
+
+struct SLAndroidEffectSendItf_ {
+ SLresult (*EnableEffectSend) (
+ SLAndroidEffectSendItf self,
+ SLInterfaceID effectImplementationId,
+ SLboolean enable,
+ SLmillibel initialLevel
+ );
+ SLresult (*IsEnabled) (
+ SLAndroidEffectSendItf self,
+ SLInterfaceID effectImplementationId,
+ SLboolean *pEnable
+ );
+ SLresult (*SetDirectLevel) (
+ SLAndroidEffectSendItf self,
+ SLmillibel directLevel
+ );
+ SLresult (*GetDirectLevel) (
+ SLAndroidEffectSendItf self,
+ SLmillibel *pDirectLevel
+ );
+ SLresult (*SetSendLevel) (
+ SLAndroidEffectSendItf self,
+ SLInterfaceID effectImplementationId,
+ SLmillibel sendLevel
+ );
+ SLresult (*GetSendLevel)(
+ SLAndroidEffectSendItf self,
+ SLInterfaceID effectImplementationId,
+ SLmillibel *pSendLevel
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Effect Capabilities interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_ANDROIDEFFECTCAPABILITIES;
+
+/** Android Effect Capabilities interface methods */
+
+struct SLAndroidEffectCapabilitiesItf_;
+typedef const struct SLAndroidEffectCapabilitiesItf_ * const * SLAndroidEffectCapabilitiesItf;
+
+struct SLAndroidEffectCapabilitiesItf_ {
+
+ SLresult (*QueryNumEffects) (SLAndroidEffectCapabilitiesItf self,
+ SLuint32 *pNumSupportedEffects);
+
+
+ SLresult (*QueryEffect) (SLAndroidEffectCapabilitiesItf self,
+ SLuint32 index,
+ SLInterfaceID *pEffectType,
+ SLInterfaceID *pEffectImplementation,
+ SLchar *pName,
+ SLuint16 *pNameSize);
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Configuration interface */
+/*---------------------------------------------------------------------------*/
+extern SL_API const SLInterfaceID SL_IID_ANDROIDCONFIGURATION;
+
+/** Android Configuration interface methods */
+
+struct SLAndroidConfigurationItf_;
+typedef const struct SLAndroidConfigurationItf_ * const * SLAndroidConfigurationItf;
+
+/*
+ * Java Proxy Type IDs
+ */
+#define SL_ANDROID_JAVA_PROXY_ROUTING 0x0001
+
+struct SLAndroidConfigurationItf_ {
+
+ SLresult (*SetConfiguration) (SLAndroidConfigurationItf self,
+ const SLchar *configKey,
+ const void *pConfigValue,
+ SLuint32 valueSize);
+
+ SLresult (*GetConfiguration) (SLAndroidConfigurationItf self,
+ const SLchar *configKey,
+ SLuint32 *pValueSize,
+ void *pConfigValue
+ );
+
+ SLresult (*AcquireJavaProxy) (SLAndroidConfigurationItf self,
+ SLuint32 proxyType,
+ jobject *pProxyObj);
+
+ SLresult (*ReleaseJavaProxy) (SLAndroidConfigurationItf self,
+ SLuint32 proxyType);
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Simple Buffer Queue Interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_ANDROIDSIMPLEBUFFERQUEUE;
+
+struct SLAndroidSimpleBufferQueueItf_;
+typedef const struct SLAndroidSimpleBufferQueueItf_ * const * SLAndroidSimpleBufferQueueItf;
+
+typedef void (SLAPIENTRY *slAndroidSimpleBufferQueueCallback)(
+ SLAndroidSimpleBufferQueueItf caller,
+ void *pContext
+);
+
+/** Android simple buffer queue state **/
+
+typedef struct SLAndroidSimpleBufferQueueState_ {
+ SLuint32 count;
+ SLuint32 index;
+} SLAndroidSimpleBufferQueueState;
+
+
+struct SLAndroidSimpleBufferQueueItf_ {
+ SLresult (*Enqueue) (
+ SLAndroidSimpleBufferQueueItf self,
+ const void *pBuffer,
+ SLuint32 size
+ );
+ SLresult (*Clear) (
+ SLAndroidSimpleBufferQueueItf self
+ );
+ SLresult (*GetState) (
+ SLAndroidSimpleBufferQueueItf self,
+ SLAndroidSimpleBufferQueueState *pState
+ );
+ SLresult (*RegisterCallback) (
+ SLAndroidSimpleBufferQueueItf self,
+ slAndroidSimpleBufferQueueCallback callback,
+ void* pContext
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Buffer Queue Interface */
+/*---------------------------------------------------------------------------*/
+
+extern SL_API const SLInterfaceID SL_IID_ANDROIDBUFFERQUEUESOURCE;
+
+struct SLAndroidBufferQueueItf_;
+typedef const struct SLAndroidBufferQueueItf_ * const * SLAndroidBufferQueueItf;
+
+#define SL_ANDROID_ITEMKEY_NONE ((SLuint32) 0x00000000)
+#define SL_ANDROID_ITEMKEY_EOS ((SLuint32) 0x00000001)
+#define SL_ANDROID_ITEMKEY_DISCONTINUITY ((SLuint32) 0x00000002)
+#define SL_ANDROID_ITEMKEY_BUFFERQUEUEEVENT ((SLuint32) 0x00000003)
+#define SL_ANDROID_ITEMKEY_FORMAT_CHANGE ((SLuint32) 0x00000004)
+
+#define SL_ANDROIDBUFFERQUEUEEVENT_NONE ((SLuint32) 0x00000000)
+#define SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED ((SLuint32) 0x00000001)
+#if 0 // reserved for future use
+#define SL_ANDROIDBUFFERQUEUEEVENT_UNREALIZED ((SLuint32) 0x00000002)
+#define SL_ANDROIDBUFFERQUEUEEVENT_CLEARED ((SLuint32) 0x00000004)
+#define SL_ANDROIDBUFFERQUEUEEVENT_STOPPED ((SLuint32) 0x00000008)
+#define SL_ANDROIDBUFFERQUEUEEVENT_ERROR ((SLuint32) 0x00000010)
+#define SL_ANDROIDBUFFERQUEUEEVENT_CONTENT_END ((SLuint32) 0x00000020)
+#endif
+
+typedef struct SLAndroidBufferItem_ {
+ SLuint32 itemKey; // identifies the item
+ SLuint32 itemSize;
+ SLuint8 itemData[0];
+} SLAndroidBufferItem;
+
+typedef SLresult (SLAPIENTRY *slAndroidBufferQueueCallback)(
+ SLAndroidBufferQueueItf caller,/* input */
+ void *pCallbackContext, /* input */
+ void *pBufferContext, /* input */
+ void *pBufferData, /* input */
+ SLuint32 dataSize, /* input */
+ SLuint32 dataUsed, /* input */
+ const SLAndroidBufferItem *pItems,/* input */
+ SLuint32 itemsLength /* input */
+);
+
+typedef struct SLAndroidBufferQueueState_ {
+ SLuint32 count;
+ SLuint32 index;
+} SLAndroidBufferQueueState;
+
+struct SLAndroidBufferQueueItf_ {
+ SLresult (*RegisterCallback) (
+ SLAndroidBufferQueueItf self,
+ slAndroidBufferQueueCallback callback,
+ void* pCallbackContext
+ );
+
+ SLresult (*Clear) (
+ SLAndroidBufferQueueItf self
+ );
+
+ SLresult (*Enqueue) (
+ SLAndroidBufferQueueItf self,
+ void *pBufferContext,
+ void *pData,
+ SLuint32 dataLength,
+ const SLAndroidBufferItem *pItems,
+ SLuint32 itemsLength
+ );
+
+ SLresult (*GetState) (
+ SLAndroidBufferQueueItf self,
+ SLAndroidBufferQueueState *pState
+ );
+
+ SLresult (*SetCallbackEventsMask) (
+ SLAndroidBufferQueueItf self,
+ SLuint32 eventFlags
+ );
+
+ SLresult (*GetCallbackEventsMask) (
+ SLAndroidBufferQueueItf self,
+ SLuint32 *pEventFlags
+ );
+};
+
+
+/*---------------------------------------------------------------------------*/
+/* Android File Descriptor Data Locator */
+/*---------------------------------------------------------------------------*/
+
+/** Addendum to Data locator macros */
+#define SL_DATALOCATOR_ANDROIDFD ((SLuint32) 0x800007BC)
+
+#define SL_DATALOCATOR_ANDROIDFD_USE_FILE_SIZE ((SLAint64) 0xFFFFFFFFFFFFFFFFll)
+
+/** File Descriptor-based data locator definition, locatorType must be SL_DATALOCATOR_ANDROIDFD */
+typedef struct SLDataLocator_AndroidFD_ {
+ SLuint32 locatorType;
+ SLint32 fd;
+ SLAint64 offset;
+ SLAint64 length;
+} SLDataLocator_AndroidFD;
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Android Simple Buffer Queue Data Locator */
+/*---------------------------------------------------------------------------*/
+
+/** Addendum to Data locator macros */
+#define SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE ((SLuint32) 0x800007BD)
+
+/** BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE*/
+typedef struct SLDataLocator_AndroidSimpleBufferQueue {
+ SLuint32 locatorType;
+ SLuint32 numBuffers;
+} SLDataLocator_AndroidSimpleBufferQueue;
+
+
+/*---------------------------------------------------------------------------*/
+/* Android Buffer Queue Data Locator */
+/*---------------------------------------------------------------------------*/
+
+/** Addendum to Data locator macros */
+#define SL_DATALOCATOR_ANDROIDBUFFERQUEUE ((SLuint32) 0x800007BE)
+
+/** Android Buffer Queue-based data locator definition,
+ * locatorType must be SL_DATALOCATOR_ANDROIDBUFFERQUEUE */
+typedef struct SLDataLocator_AndroidBufferQueue_ {
+ SLuint32 locatorType;
+ SLuint32 numBuffers;
+} SLDataLocator_AndroidBufferQueue;
+
+/**
+ * MIME types required for data in Android Buffer Queues
+ */
+#define SL_ANDROID_MIME_AACADTS ((SLchar *) "audio/vnd.android.aac-adts")
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OPENSL_ES_ANDROID_H_ */
diff --git a/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidConfiguration.h b/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidConfiguration.h
new file mode 100644
index 0000000..3846dcd
--- /dev/null
+++ b/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidConfiguration.h
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OPENSL_ES_ANDROIDCONFIGURATION_H_
+#define OPENSL_ES_ANDROIDCONFIGURATION_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+/* Android AudioRecorder configuration */
+/*---------------------------------------------------------------------------*/
+
+/** Audio recording preset */
+/** Audio recording preset key */
+#define SL_ANDROID_KEY_RECORDING_PRESET ((const SLchar*) "androidRecordingPreset")
+/** Audio recording preset values */
+/** preset "none" cannot be set, it is used to indicate the current settings
+ * do not match any of the presets. */
+#define SL_ANDROID_RECORDING_PRESET_NONE ((SLuint32) 0x00000000)
+/** generic recording configuration on the platform */
+#define SL_ANDROID_RECORDING_PRESET_GENERIC ((SLuint32) 0x00000001)
+/** uses the microphone audio source with the same orientation as the camera
+ * if available, the main device microphone otherwise */
+#define SL_ANDROID_RECORDING_PRESET_CAMCORDER ((SLuint32) 0x00000002)
+/** uses the main microphone tuned for voice recognition */
+#define SL_ANDROID_RECORDING_PRESET_VOICE_RECOGNITION ((SLuint32) 0x00000003)
+/** uses the main microphone tuned for audio communications */
+#define SL_ANDROID_RECORDING_PRESET_VOICE_COMMUNICATION ((SLuint32) 0x00000004)
+/** uses the main microphone unprocessed */
+#define SL_ANDROID_RECORDING_PRESET_UNPROCESSED ((SLuint32) 0x00000005)
+
+
+/*---------------------------------------------------------------------------*/
+/* Android AudioPlayer configuration */
+/*---------------------------------------------------------------------------*/
+
+/** Audio playback stream type */
+/** Audio playback stream type key */
+#define SL_ANDROID_KEY_STREAM_TYPE ((const SLchar*) "androidPlaybackStreamType")
+
+/** Audio playback stream type values */
+/* same as android.media.AudioManager.STREAM_VOICE_CALL */
+#define SL_ANDROID_STREAM_VOICE ((SLint32) 0x00000000)
+/* same as android.media.AudioManager.STREAM_SYSTEM */
+#define SL_ANDROID_STREAM_SYSTEM ((SLint32) 0x00000001)
+/* same as android.media.AudioManager.STREAM_RING */
+#define SL_ANDROID_STREAM_RING ((SLint32) 0x00000002)
+/* same as android.media.AudioManager.STREAM_MUSIC */
+#define SL_ANDROID_STREAM_MEDIA ((SLint32) 0x00000003)
+/* same as android.media.AudioManager.STREAM_ALARM */
+#define SL_ANDROID_STREAM_ALARM ((SLint32) 0x00000004)
+/* same as android.media.AudioManager.STREAM_NOTIFICATION */
+#define SL_ANDROID_STREAM_NOTIFICATION ((SLint32) 0x00000005)
+
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OPENSL_ES_ANDROIDCONFIGURATION_H_ */
diff --git a/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidMetadata.h b/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidMetadata.h
new file mode 100644
index 0000000..01e33b8
--- /dev/null
+++ b/ndk/platforms/android-24/include/SLES/OpenSLES_AndroidMetadata.h
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OPENSL_ES_ANDROIDMETADATA_H_
+#define OPENSL_ES_ANDROIDMETADATA_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*---------------------------------------------------------------------------*/
+/* Android metadata keys */
+/*---------------------------------------------------------------------------*/
+
+/**
+ * Additional metadata keys to be used in SLMetadataExtractionItf:
+ * the ANDROID_KEY_PCMFORMAT_* keys follow the fields of the SLDataFormat_PCM struct, and as such
+ * all values corresponding to these keys are of SLuint32 type, and are defined as the fields
+ * of the same name in SLDataFormat_PCM. The exception is that sample rate is expressed here
+ * in Hz units, rather than in milliHz units.
+ */
+#define ANDROID_KEY_PCMFORMAT_NUMCHANNELS "AndroidPcmFormatNumChannels"
+#define ANDROID_KEY_PCMFORMAT_SAMPLERATE "AndroidPcmFormatSampleRate"
+#define ANDROID_KEY_PCMFORMAT_BITSPERSAMPLE "AndroidPcmFormatBitsPerSample"
+#define ANDROID_KEY_PCMFORMAT_CONTAINERSIZE "AndroidPcmFormatContainerSize"
+#define ANDROID_KEY_PCMFORMAT_CHANNELMASK "AndroidPcmFormatChannelMask"
+#define ANDROID_KEY_PCMFORMAT_ENDIANNESS "AndroidPcmFormatEndianness"
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* OPENSL_ES_ANDROIDMETADATA_H_ */
diff --git a/ndk/platforms/android-24/include/SLES/OpenSLES_Platform.h b/ndk/platforms/android-24/include/SLES/OpenSLES_Platform.h
new file mode 100644
index 0000000..527693d
--- /dev/null
+++ b/ndk/platforms/android-24/include/SLES/OpenSLES_Platform.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2007-2009 The Khronos Group Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and /or associated documentation files (the "Materials "), to
+ * deal in the Materials without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Materials, and to permit persons to whom the Materials are
+ * furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Materials.
+ *
+ * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE
+ * MATERIALS.
+ *
+ * OpenSLES_Platform.h - OpenSL ES version 1.0
+ *
+ */
+
+/****************************************************************************/
+/* NOTE: This file contains definitions for the base types and the */
+/* SLAPIENTRY macro. This file **WILL NEED TO BE EDITED** to provide */
+/* the correct definitions specific to the platform being used. */
+/****************************************************************************/
+
+#ifndef _OPENSLES_PLATFORM_H_
+#define _OPENSLES_PLATFORM_H_
+
+typedef unsigned char sl_uint8_t;
+typedef signed char sl_int8_t;
+typedef unsigned short sl_uint16_t;
+typedef signed short sl_int16_t;
+typedef unsigned int /*long*/ sl_uint32_t;
+typedef signed int /*long*/ sl_int32_t;
+typedef long long sl_int64_t;
+typedef unsigned long long sl_uint64_t;
+
+#ifndef SL_API
+#ifdef __GNUC__
+#define SL_API /* override per-platform */
+#else
+#define SL_API __declspec(dllimport)
+#endif
+#endif
+
+#ifndef SLAPIENTRY
+#define SLAPIENTRY
+#endif
+
+#endif /* _OPENSLES_PLATFORM_H_ */
