api/1.1/OpenSLES.h

/*
 * Copyright (c) 2007-2011 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.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_char_t              SLchar;          /* UTF-8 is to be used     */
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 sl_float32_t           SLfloat32;       /* 32 bit floating point   */
typedef sl_float64_t           Slfloat64;       /* 64 bit floating point   */


typedef SLuint32                    SLboolean;
#define SL_BOOLEAN_FALSE            ((SLboolean) 0x00000000)
#define SL_BOOLEAN_TRUE             ((SLboolean) 0x00000001)

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         ((SLuint32) 0xFFFFFFFF)
#define SL_PRIORITY_VERYLOW        ((SLuint32) 0xE0000000)
#define SL_PRIORITY_LOW            ((SLuint32) 0xC0000000)
#define SL_PRIORITY_BELOWNORMAL    ((SLuint32) 0xA0000000)
#define SL_PRIORITY_NORMAL         ((SLuint32) 0x7FFFFFFF)
#define SL_PRIORITY_ABOVENORMAL    ((SLuint32) 0x60000000)
#define SL_PRIORITY_HIGH           ((SLuint32) 0x40000000)
#define SL_PRIORITY_VERYHIGH       ((SLuint32) 0x20000000)
#define SL_PRIORITY_HIGHEST        ((SLuint32) 0x00000000)

/** These macros list types of PCM data **/
#define SL_PCM_REPRESENTATION_SIGNED_INT       ((SLuint32) 0x00000001)
#define SL_PCM_REPRESENTATION_UNSIGNED_INT     ((SLuint32) 0x00000002)
#define SL_PCM_REPRESENTATION_FLOAT            ((SLuint32) 0x00000003)

/** 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)
#define SL_PCMSAMPLEFORMAT_FIXED_64    ((SLuint16) 0x0040)

/** 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)
#define SL_RESULT_READONLY                     ((SLuint32) 0x00000011)
#define SL_RESULT_ENGINEOPTION_UNSUPPORTED     ((SLuint32) 0x00000012)
#define SL_RESULT_SOURCE_SINK_INCOMPATIBLE     ((SLuint32) 0x00000013)

/* 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 */

SL_API extern const SLInterfaceID SL_IID_NULL;

/*---------------------------------------------------------------------------*/
/* Data Source and Data Sink Structures                                      */
/*---------------------------------------------------------------------------*/

/** Data locator macros  */
#define SL_DATALOCATOR_NULL                   ((SLuint32) 0x00000000)
#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_MEDIAOBJECT            ((SLuint32) 0x00000008)
#define SL_DATALOCATOR_CONTENTPIPE            ((SLuint32) 0x00000009)


/** URI-based data locator definition where locatorType must be SL_DATALOCATOR_URI*/
typedef struct SLDataLocator_URI_ {
    SLuint32         locatorType;
    const SLchar *    pURI;
} 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)
#define SL_IODEVICE_AUDIOOUTPUT     ((SLuint32) 0x00000006)

/** 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;

/** ContentPipe-based data locator definition where locatorType must be SL_DATALOCATOR_CONTENTPIPE */
typedef struct SLDataLocator_ContentPipe_ {
    SLuint32 locatorType;
    void * pContentPipe;
    const SLchar * pURI;
} SLDataLocator_ContentPipe;

/** 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)
#define SL_DATAFORMAT_PCM_EX    ((SLuint32) 0x00000004)


/** MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME*/
typedef struct SLDataFormat_MIME_ {
    SLuint32         formatType;
    const SLchar *    pMimeType;
    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)

#ifdef SL_BYTEORDER_NATIVEBIGENDIAN
#define SL_BYTEORDER_NATIVE                SL_BYTEORDER_BIGENDIAN
#else
#define SL_BYTEORDER_NATIVE                SL_BYTEORDER_LITTLEENDIAN
#endif

/* 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*/
/* SLDataFormat_PCM IS DEPRECATED. Use SLDataFormat_PCM_EX instead. */
typedef struct SLDataFormat_PCM_ {
    SLuint32         formatType;
    SLuint32         numChannels;
    SLuint32         samplesPerSec;
    SLuint32         bitsPerSample;
    SLuint32         containerSize;
    SLuint32         channelMask;
    SLuint32        endianness;
} SLDataFormat_PCM;

/** PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM_EX*/
typedef struct SLDataFormat_PCM_EX_ {
    SLuint32         formatType;
    SLuint32         numChannels;
    SLuint32         sampleRate;
    SLuint32         bitsPerSample;
    SLuint32         containerSize;
    SLuint32         channelMask;
    SLuint32        endianness;
    SLuint32        representation;
} SLDataFormat_PCM_EX;

/** MediaObject-type-based data format definition where formatType must be SL_DATAFORMAT_MEDIAOBJECT*/
typedef struct SLDataLocator_MediaObject_ {
    SLuint32 locatorType;
    SLObjectItf mediaObject;
} SLDataLocator_MediaObject;

/** NULL-type-based data format definition where formatType must be SL_DATAFORMAT_NULL*/
typedef struct SLDataLocator_Null_ {
    SLuint32 locatorType;
} SLDataLocator_Null;


typedef struct SLDataSource_ {
    void *pLocator;
    void *pFormat;
} SLDataSource;


typedef struct SLDataSink_ {
    void *pLocator;
    void *pFormat;
} SLDataSink;

/*---------------------------------------------------------------------------*/
/* Standard Object Interface                                                 */
/*---------------------------------------------------------------------------*/

SL_API extern 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,
        SLuint32 priority
    );
    SLresult (*GetPriority) (
        SLObjectItf self,
        SLuint32 *pPriority
    );
    SLresult (*SetLossOfControlInterfaces) (
        SLObjectItf self,
        SLuint16 numInterfaces,
        const 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 *pDeviceName;
    SLint16 deviceNameLength;
    SLint16 deviceConnection;
    SLint16 deviceScope;
    SLint16 deviceLocation;
    SLboolean isForTelephony;
    SLmilliHertz minSampleRate;
    SLmilliHertz maxSampleRate;
    SLboolean isFreqRangeContinuous;
    SLmilliHertz *pSamplingRatesSupported;
    SLint16 numOfSamplingRatesSupported;
    SLint16 maxChannels;
} SLAudioInputDescriptor;


typedef struct SLAudioOutputDescriptor_ {
    SLchar *pDeviceName;
    SLint16 deviceNameLength;
    SLint16 deviceConnection;
    SLint16 deviceScope;
    SLint16 deviceLocation;
    SLboolean isForTelephony;
    SLmilliHertz minSampleRate;
    SLmilliHertz maxSampleRate;
    SLboolean isFreqRangeContinuous;
    SLmilliHertz *pSamplingRatesSupported;
    SLint16 numOfSamplingRatesSupported;
    SLint16 maxChannels;
} SLAudioOutputDescriptor;


SL_API extern const SLInterfaceID SL_IID_AUDIOIODEVICECAPABILITIES;

struct SLAudioIODeviceCapabilitiesItf_;
typedef const struct SLAudioIODeviceCapabilitiesItf_ * const * SLAudioIODeviceCapabilitiesItf;


typedef void (SLAPIENTRY *slAvailableAudioInputsChangedCallback) (
    SLAudioIODeviceCapabilitiesItf caller,
    void *pContext,
    SLuint32 deviceID,
    SLuint32 numInputs,
    SLboolean isNew
);


typedef void (SLAPIENTRY *slAvailableAudioOutputsChangedCallback) (
    SLAudioIODeviceCapabilitiesItf caller,
    void *pContext,
    SLuint32 deviceID,
    SLuint32 numOutputs,
    SLboolean isNew
);

typedef void (SLAPIENTRY *slDefaultDeviceIDMapChangedCallback) (
    SLAudioIODeviceCapabilitiesItf caller,
    void *pContext,
    SLboolean isOutput,
    SLuint32 numDevices
);


struct SLAudioIODeviceCapabilitiesItf_ {
    SLresult (*GetAvailableAudioInputs)(
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32  *pNumInputs,
        SLuint32 *pInputDeviceIDs
    );
    SLresult (*QueryAudioInputCapabilities)(
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32 deviceId,
        SLAudioInputDescriptor *pDescriptor
    );
    SLresult (*RegisterAvailableAudioInputsChangedCallback) (
        SLAudioIODeviceCapabilitiesItf self,
        slAvailableAudioInputsChangedCallback callback,
        void *pContext
    );
    SLresult (*GetAvailableAudioOutputs)(
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32 *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,
        SLuint32 *pNumAudioInputs,
        SLuint32 *pAudioInputDeviceIDs
    );
    SLresult (*GetAssociatedAudioOutputs) (
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32 deviceId,
        SLuint32 *pNumAudioOutputs,
        SLuint32 *pAudioOutputDeviceIDs
    );
    SLresult (*GetDefaultAudioDevices) (
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32 defaultDeviceID,
        SLuint32 *pNumAudioDevices,
        SLuint32 *pAudioDeviceIDs
    );
    SLresult (*QuerySampleFormatsSupported)(
        SLAudioIODeviceCapabilitiesItf self,
        SLuint32 deviceId,
        SLmilliHertz samplingRate,
        SLint32 *pSampleFormats,
        SLuint32 *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;


SL_API extern 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                                                           */
/*---------------------------------------------------------------------------*/


SL_API extern 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;

SL_API extern 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 message related types and interface                          */
/*---------------------------------------------------------------------------*/

SL_API extern const SLInterfaceID SL_IID_METADATAMESSAGE;

struct SLMetadataMessageItf_;
typedef const struct SLMetadataMessageItf_ * const * SLMetadataMessageItf;

typedef void (SLAPIENTRY *slMetadataCallback) (
    SLMetadataMessageItf caller,
    void *pContext,
    SLuint32 index
);

struct SLMetadataMessageItf_ {
    SLresult (*RegisterMetadataCallback) (
        SLMetadataMessageItf self,
        slMetadataCallback callback,
        void *pContext
    );
};


/*---------------------------------------------------------------------------*/
/* 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

SL_API extern 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                                        */
/*---------------------------------------------------------------------------*/

SL_API extern const SLInterfaceID SL_IID_DYNAMICSOURCE;

struct SLDynamicSourceItf_;
typedef const struct SLDynamicSourceItf_ * const * SLDynamicSourceItf;

struct SLDynamicSourceItf_ {
    SLresult (*SetSource) (
        SLDynamicSourceItf self,
        const SLDataSource *pDataSource
    );
};

/*---------------------------------------------------------------------------*/
/* Dynamic Source/Sink Change Interface                                      */
/*---------------------------------------------------------------------------*/
SL_API extern const SLInterfaceID SL_IID_DYNAMICSOURCESINKCHANGE;

struct SLDynamicSourceSinkChangeItf_;
typedef const struct SLDynamicSourceSinkChangeItf_ * const * SLDynamicSourceSinkChangeItf;

typedef void (SLAPIENTRY *slSourceChangeCallback)(
    SLDynamicSourceSinkChangeItf caller,
    void *pContext,
    SLuint32 resultCode,
    const SLDataSource *pExistingDataSource,
    const SLDataSource *pNewDataSource
);

typedef void (SLAPIENTRY *slSinkChangeCallback)(
    SLDynamicSourceSinkChangeItf caller,
    void *pContext,
    SLuint32 resultCode,
    const SLDataSource *pExistingDataSink,
    const SLDataSource *pNewDataSink
);

struct SLDynamicSourceSinkChangeItf_ {
    SLresult (*ChangeSource) (
        SLDynamicSourceSinkChangeItf self,
        const SLDataSource * pExistingDataSource,
        const SLDataSource * pNewDataSource,
        SLboolean async
    );
    SLresult (*ChangeSink) (
        SLDynamicSourceSinkChangeItf self,
        const SLDataSink * pExistingDataSink,
        const SLDataSink * pNewDataSink,
        SLboolean async
    );
    SLresult (*RegisterSourceChangeCallback) (
        SLDynamicSourceSinkChangeItf self,
        slSourceChangeCallback callback,
        void * pContext
    );
    SLresult (*RegisterSinkChangeCallback) (
        SLDynamicSourceSinkChangeItf self,
        slSinkChangeCallback callback,
        void * pContext
    );
};


/*---------------------------------------------------------------------------*/
/* Output Mix interface                                                      */
/*---------------------------------------------------------------------------*/

SL_API extern 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_PLAYEVENT_DURATIONUPDATED    ((SLuint32) 0x00000020)

#define SL_TIME_UNKNOWN    ((SLuint32) 0xFFFFFFFF)


SL_API extern 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_PREFETCHEVENT_ERROR               ((SLuint32) 0x00000003)
#define SL_PREFETCHEVENT_ERROR_UNRECOVERABLE ((SLuint32) 0x00000004)


#define SL_PREFETCHSTATUS_UNDERFLOW            ((SLuint32) 0x00000001)
#define SL_PREFETCHSTATUS_SUFFICIENTDATA    ((SLuint32) 0x00000002)
#define SL_PREFETCHSTATUS_OVERFLOW            ((SLuint32) 0x00000003)


SL_API extern 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
    );
    SLresult (*GetError) (
        SLPrefetchStatusItf self,
        SLresult *pResult
    );
};

/*---------------------------------------------------------------------------*/
/* 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)


SL_API extern 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)

SL_API extern 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)
#define SL_RECORDEVENT_BUFFERQUEUE_STARVED    ((SLuint32) 0x00000040)


SL_API extern 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)

SL_API extern 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,
        SLuint16 * pSize,
        SLchar * pName
    );
};

/*---------------------------------------------------------------------------*/
/* Volume Interface                                                           */
/* --------------------------------------------------------------------------*/

SL_API extern 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                                                   */
/* --------------------------------------------------------------------------*/

SL_API extern 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                                                    */
/*---------------------------------------------------------------------------*/
/** Flags for buffer queue events */
#define SL_BUFFERQUEUEEVENT_PROCESSED    ((SLuint32) 0x00000001)
#define SL_BUFFERQUEUEEVENT_UNREALIZED    ((SLuint32) 0x00000002)
#define SL_BUFFERQUEUEEVENT_CLEARED        ((SLuint32) 0x00000004)
#define SL_BUFFERQUEUEEVENT_STOPPED        ((SLuint32) 0x00000008)
#define SL_BUFFERQUEUEEVENT_ERROR        ((SLuint32) 0x00000010)
#define SL_BUFFERQUEUEEVENT_CONTENT_END    ((SLuint32) 0x00000020)

SL_API extern const SLInterfaceID SL_IID_BUFFERQUEUE;

struct SLBufferQueueItf_;
typedef const struct SLBufferQueueItf_ * const * SLBufferQueueItf;

typedef void (SLAPIENTRY *slBufferQueueCallback) (
    SLBufferQueueItf caller,
    SLuint32 eventFlags,
    const void *pBuffer,
    SLuint32 bufferSize,
    SLuint32 dataUsed,
    void *pContext
);


/** Buffer queue state **/

typedef struct SLBufferQueueState_ {
    SLuint32    count;
    SLuint32    index;
} SLBufferQueueState;


struct SLBufferQueueItf_ {
    SLresult (*Enqueue) (
        SLBufferQueueItf self,
        const void *pBuffer,
        SLuint32 size,
        SLboolean isLastBuffer
    );
    SLresult (*Clear) (
        SLBufferQueueItf self
    );
    SLresult (*GetState) (
        SLBufferQueueItf self,
        SLBufferQueueState *pState
    );
    SLresult (*RegisterCallback) (
        SLBufferQueueItf self,
        slBufferQueueCallback callback,
        void* pContext
    );
    SLresult (*SetCallbackEventsMask) (
        SLBufferQueueItf self,
        SLuint32 eventFlags
    );
    SLresult (*GetCallbackEventsMask) (
        SLBufferQueueItf self,
        SLuint32 *pEventFlags
    );

};

/*---------------------------------------------------------------------------*/
/* ConfigExtension                                                           */
/*---------------------------------------------------------------------------*/
SL_API extern const SLInterfaceID SL_IID_CONFIGEXTENSION;

struct SLConfigExtensionsItf_;
typedef const struct SLConfigExtensionsItf_
    * const * SLConfigExtensionsItf;

struct SLConfigExtensionsItf_ {
    SLresult (*SetConfiguration) (
        SLConfigExtensionsItf self,
        const SLchar * pConfigKey,
        SLuint32 valueSize,
        const void * pConfigValue
    );
    SLresult (*GetConfiguration) (
        SLConfigExtensionsItf self,
        const SLchar * pConfigKey,
        SLuint32 * pValueSize,
        void * pConfigValue
    );
};


/*---------------------------------------------------------------------------*/
/* 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)


SL_API extern 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;


SL_API extern 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                                                    */
/*---------------------------------------------------------------------------*/


SL_API extern 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                                                     */
/*---------------------------------------------------------------------------*/


SL_API extern 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 Hint Interface                                                         */
/*---------------------------------------------------------------------------*/
#define SL_3DHINT_OFF                    ((SLuint16) 0x0000)
#define SL_3DHINT_QUALITY_LOWEST        ((SLuint16) 0x0001)
#define SL_3DHINT_QUALITY_LOW            ((SLuint16) 0x4000)
#define SL_3DHINT_QUALITY_MEDIUM        ((SLuint16) 0x8000)
#define SL_3DHINT_QUALITY_HIGH            ((SLuint16) 0xC000)
#define SL_3DHINT_QUALITY_HIGHEST        ((SLuint16) 0xFFFF)

SL_API extern const SLInterfaceID SL_IID_3DHINT;

struct SL3DHintItf_;
typedef const struct SL3DHintItf_ * const * SL3DHintItf;

struct SL3DHintItf_ {
    SLresult (*SetRenderHint) (
        SL3DHintItf self,
        SLuint16 qualityHint
    );
    SLresult (*GetRenderHint) (
        SL3DHintItf self,
        SLuint16 *pQualityHint
    );
};


/*---------------------------------------------------------------------------*/
/* 3D Commit Interface                                                       */
/*---------------------------------------------------------------------------*/


SL_API extern 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;

SL_API extern 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                                                      */
/*---------------------------------------------------------------------------*/


SL_API extern 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)


SL_API extern 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                                                  */
/* --------------------------------------------------------------------------*/

SL_API extern 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                                                       */
/* --------------------------------------------------------------------------*/


SL_API extern 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)


SL_API extern 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)


SL_API extern 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 *pData,
        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                                                  */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                      */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                       */
/* --------------------------------------------------------------------------*/


SL_API extern 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_AUDIOSTREAMFORMAT_UNDEFINED        ((SLuint32) 0x00000000)

#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_AUDIOCODEC_VORBIS      ((SLuint32) 0x00000009)

#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;
    SLuint32      streamFormat;
} SLAudioCodecDescriptor;

SL_API extern 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;

SL_API extern 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                                                   */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                      */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                           */
/* --------------------------------------------------------------------------*/


SL_API extern 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.                      */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                      */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                   */
/* --------------------------------------------------------------------------*/


SL_API extern 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                                                          */
/* --------------------------------------------------------------------------*/


SL_API extern 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,
        const SLDataSource *pAudioSrc,
        const SLDataSink *pAudioSnk,
        SLuint32 numInterfaces,
        const SLInterfaceID * pInterfaceIds,
        const SLboolean * pInterfaceRequired
    );
    SLresult (*CreateAudioRecorder) (
        SLEngineItf self,
        SLObjectItf * pRecorder,
        const SLDataSource *pAudioSrc,
        const SLDataSink *pAudioSnk,
        SLuint32 numInterfaces,
        const SLInterfaceID * pInterfaceIds,
        const SLboolean * pInterfaceRequired
    );
    SLresult (*CreateMidiPlayer) (
        SLEngineItf self,
        SLObjectItf * pPlayer,
        const SLDataSource *pMIDISrc,
        const SLDataSource *pBankSrc,
        const SLDataSink *pAudioOutput,
        const SLDataSink *pVibra,
        const 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,
        const 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,
        SLuint16 * pNameLength
    );
    SLresult (*IsExtensionSupported) (
        SLEngineItf self,
        const SLchar * pExtensionName,
        SLboolean * pSupported
    );
};


/*---------------------------------------------------------------------------*/
/* Engine Capabilities Interface                                             */
/* --------------------------------------------------------------------------*/


SL_API extern 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,
        SLuint16 *pNumMaxVoices,
        SLboolean *pIsAbsoluteMax,
        SLuint16 *pNumFreeVoices
    );
    SLresult (*QueryNumberOfMIDISynthesizers) (
        SLEngineCapabilitiesItf self,
        SLuint16 *pNumMIDIsynthesizers
    );
    SLresult (*QueryAPIVersion) (
        SLEngineCapabilitiesItf self,
        SLuint16 *pMajor,
        SLuint16 *pMinor,
        SLuint16 *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                                                     */
/* --------------------------------------------------------------------------*/


SL_API extern 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)
#define SL_ENGINEOPTION_MAJORVERSION    ((SLuint32) 0x00000003)
#define SL_ENGINEOPTION_MINORVERSION    ((SLuint32) 0x00000004)
#define SL_ENGINEOPTION_STEPVERSION        ((SLuint32) 0x00000005)


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_ */