/*
 * Copyright (c) 2007-2009 The Khronos Group Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and /or associated documentation files (the "Materials "), to
 * deal in the Materials without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Materials, and to permit persons to whom the Materials are
 * furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS IN THE
 * MATERIALS.
 *
 * OpenSLES.h - OpenSL ES version 1.0.1
 *
 */

/****************************************************************************/
/* NOTE: This file is a standard OpenSL ES header file and should not be    */
/* modified in any way.                                                     */
/****************************************************************************/

#ifndef OPENSL_ES_H_
#define OPENSL_ES_H_

#ifdef __cplusplus
extern "C" {
#endif

#include "OpenSLES_Platform.h"


/*****************************************************************************/
/* Common types, structures, and defines                                */
/*****************************************************************************/

#ifndef _KHRONOS_KEYS_
#define _KHRONOS_KEYS_

#define KHRONOS_TITLE "KhronosTitle"
#define KHRONOS_ALBUM "KhronosAlbum"
#define KHRONOS_TRACK_NUMBER "KhronosTrackNumber"
#define KHRONOS_ARTIST "KhronosArtist"
#define KHRONOS_GENRE "KhronosGenre"
#define KHRONOS_YEAR "KhronosYear"
#define KHRONOS_COMMENT "KhronosComment"
#define KHRONOS_ARTIST_URL "KhronosArtistURL"
#define KHRONOS_CONTENT_URL "KhronosContentURL"
#define KHRONOS_RATING "KhronosRating"
#define KHRONOS_ALBUM_ART "KhronosAlbumArt"
#define KHRONOS_COPYRIGHT "KhronosCopyright"

#endif


/* remap common types to SL types for clarity */
typedef sl_int8_t              SLint8;          /* 8 bit signed integer  */
typedef sl_uint8_t             SLuint8;         /* 8 bit unsigned integer */
typedef sl_int16_t             SLint16;         /* 16 bit signed integer */
typedef sl_uint16_t            SLuint16;        /* 16 bit unsigned integer */
typedef sl_int32_t             SLint32;           /* 32 bit signed integer */
typedef sl_uint32_t            SLuint32;          /* 32 bit unsigned integer */

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

typedef SLuint8						SLchar;			/* UTF-8 is to be used */
typedef SLint16						SLmillibel;
typedef SLuint32					SLmillisecond;
typedef SLuint32					SLmilliHertz;
typedef SLint32						SLmillimeter;
typedef SLint32						SLmillidegree;
typedef SLint16						SLpermille;
typedef SLuint32					SLmicrosecond;
typedef SLuint32					SLresult;

#define SL_MILLIBEL_MAX 	((SLmillibel) 0x7FFF)
#define SL_MILLIBEL_MIN 	((SLmillibel) (-SL_MILLIBEL_MAX-1))

#define SL_MILLIHERTZ_MAX	((SLmilliHertz) 0xFFFFFFFF)
#define SL_MILLIMETER_MAX	((SLmillimeter) 0x7FFFFFFF)

/** Interface ID defined as a UUID */
typedef const struct SLInterfaceID_ {
    SLuint32 time_low;
    SLuint16 time_mid;
    SLuint16 time_hi_and_version;
    SLuint16 clock_seq;
    SLuint8  node[6];
} * SLInterfaceID;

/* Forward declaration for the object interface */
struct SLObjectItf_;

typedef const struct SLObjectItf_ * const * SLObjectItf;

/* Objects ID's */

#define SL_OBJECTID_ENGINE			((SLuint32) 0x00001001)
#define SL_OBJECTID_LEDDEVICE		((SLuint32) 0x00001002)
#define SL_OBJECTID_VIBRADEVICE		((SLuint32) 0x00001003)
#define SL_OBJECTID_AUDIOPLAYER		((SLuint32) 0x00001004)
#define SL_OBJECTID_AUDIORECORDER	((SLuint32) 0x00001005)
#define SL_OBJECTID_MIDIPLAYER		((SLuint32) 0x00001006)
#define SL_OBJECTID_LISTENER		((SLuint32) 0x00001007)
#define SL_OBJECTID_3DGROUP			((SLuint32) 0x00001008)
#define SL_OBJECTID_OUTPUTMIX		((SLuint32) 0x00001009)
#define SL_OBJECTID_METADATAEXTRACTOR	((SLuint32) 0x0000100A)


/* SL Profiles */

#define SL_PROFILES_PHONE	((SLuint16) 0x0001)
#define SL_PROFILES_MUSIC	((SLuint16) 0x0002)
#define SL_PROFILES_GAME	((SLuint16) 0x0004)

/* Types of voices supported by the system */

#define SL_VOICETYPE_2D_AUDIO		((SLuint16) 0x0001)
#define SL_VOICETYPE_MIDI			((SLuint16) 0x0002)
#define SL_VOICETYPE_3D_AUDIO 		((SLuint16) 0x0004)
#define SL_VOICETYPE_3D_MIDIOUTPUT 	((SLuint16) 0x0008)

/* Convenient macros representing various different priority levels, for use with the SetPriority method */

#define SL_PRIORITY_LOWEST		((SLint32) (-0x7FFFFFFF-1))
#define SL_PRIORITY_VERYLOW		((SLint32) -0x60000000)
#define SL_PRIORITY_LOW			((SLint32) -0x40000000)
#define SL_PRIORITY_BELOWNORMAL	((SLint32) -0x20000000)
#define SL_PRIORITY_NORMAL		((SLint32) 0x00000000)
#define SL_PRIORITY_ABOVENORMAL	((SLint32) 0x20000000)
#define SL_PRIORITY_HIGH		((SLint32) 0x40000000)
#define SL_PRIORITY_VERYHIGH	((SLint32) 0x60000000)
#define SL_PRIORITY_HIGHEST	((SLint32) 0x7FFFFFFF)


/** These macros list the various sample formats that are possible on audio input and output devices. */

#define SL_PCMSAMPLEFORMAT_FIXED_8	((SLuint16) 0x0008)
#define SL_PCMSAMPLEFORMAT_FIXED_16	((SLuint16) 0x0010)
#define SL_PCMSAMPLEFORMAT_FIXED_20 	((SLuint16) 0x0014)
#define SL_PCMSAMPLEFORMAT_FIXED_24	((SLuint16) 0x0018)
#define SL_PCMSAMPLEFORMAT_FIXED_28 	((SLuint16) 0x001C)
#define SL_PCMSAMPLEFORMAT_FIXED_32	((SLuint16) 0x0020)


/** These macros specify the commonly used sampling rates (in milliHertz) supported by most audio I/O devices. */

#define SL_SAMPLINGRATE_8		((SLuint32) 8000000)
#define SL_SAMPLINGRATE_11_025	((SLuint32) 11025000)
#define SL_SAMPLINGRATE_12		((SLuint32) 12000000)
#define SL_SAMPLINGRATE_16		((SLuint32) 16000000)
#define SL_SAMPLINGRATE_22_05	((SLuint32) 22050000)
#define SL_SAMPLINGRATE_24		((SLuint32) 24000000)
#define SL_SAMPLINGRATE_32		((SLuint32) 32000000)
#define SL_SAMPLINGRATE_44_1	((SLuint32) 44100000)
#define SL_SAMPLINGRATE_48		((SLuint32) 48000000)
#define SL_SAMPLINGRATE_64		((SLuint32) 64000000)
#define SL_SAMPLINGRATE_88_2	((SLuint32) 88200000)
#define SL_SAMPLINGRATE_96		((SLuint32) 96000000)
#define SL_SAMPLINGRATE_192	((SLuint32) 192000000)

#define SL_SPEAKER_FRONT_LEFT			((SLuint32) 0x00000001)
#define SL_SPEAKER_FRONT_RIGHT			((SLuint32) 0x00000002)
#define SL_SPEAKER_FRONT_CENTER			((SLuint32) 0x00000004)
#define SL_SPEAKER_LOW_FREQUENCY			((SLuint32) 0x00000008)
#define SL_SPEAKER_BACK_LEFT			((SLuint32) 0x00000010)
#define SL_SPEAKER_BACK_RIGHT			((SLuint32) 0x00000020)
#define SL_SPEAKER_FRONT_LEFT_OF_CENTER	((SLuint32) 0x00000040)
#define SL_SPEAKER_FRONT_RIGHT_OF_CENTER	((SLuint32) 0x00000080)
#define SL_SPEAKER_BACK_CENTER			((SLuint32) 0x00000100)
#define SL_SPEAKER_SIDE_LEFT			((SLuint32) 0x00000200)
#define SL_SPEAKER_SIDE_RIGHT			((SLuint32) 0x00000400)
#define SL_SPEAKER_TOP_CENTER			((SLuint32) 0x00000800)
#define SL_SPEAKER_TOP_FRONT_LEFT		((SLuint32) 0x00001000)
#define SL_SPEAKER_TOP_FRONT_CENTER		((SLuint32) 0x00002000)
#define SL_SPEAKER_TOP_FRONT_RIGHT		((SLuint32) 0x00004000)
#define SL_SPEAKER_TOP_BACK_LEFT			((SLuint32) 0x00008000)
#define SL_SPEAKER_TOP_BACK_CENTER		((SLuint32) 0x00010000)
#define SL_SPEAKER_TOP_BACK_RIGHT		((SLuint32) 0x00020000)


/*****************************************************************************/
/* Errors                                                                    */
/*                                                                           */
/*****************************************************************************/

#define SL_RESULT_SUCCESS				((SLuint32) 0x00000000)
#define SL_RESULT_PRECONDITIONS_VIOLATED	((SLuint32) 0x00000001)
#define SL_RESULT_PARAMETER_INVALID		((SLuint32) 0x00000002)
#define SL_RESULT_MEMORY_FAILURE			((SLuint32) 0x00000003)
#define SL_RESULT_RESOURCE_ERROR			((SLuint32) 0x00000004)
#define SL_RESULT_RESOURCE_LOST			((SLuint32) 0x00000005)
#define SL_RESULT_IO_ERROR				((SLuint32) 0x00000006)
#define SL_RESULT_BUFFER_INSUFFICIENT		((SLuint32) 0x00000007)
#define SL_RESULT_CONTENT_CORRUPTED		((SLuint32) 0x00000008)
#define SL_RESULT_CONTENT_UNSUPPORTED		((SLuint32) 0x00000009)
#define SL_RESULT_CONTENT_NOT_FOUND		((SLuint32) 0x0000000A)
#define SL_RESULT_PERMISSION_DENIED		((SLuint32) 0x0000000B)
#define SL_RESULT_FEATURE_UNSUPPORTED		((SLuint32) 0x0000000C)
#define SL_RESULT_INTERNAL_ERROR			((SLuint32) 0x0000000D)
#define SL_RESULT_UNKNOWN_ERROR			((SLuint32) 0x0000000E)
#define SL_RESULT_OPERATION_ABORTED		((SLuint32) 0x0000000F)
#define SL_RESULT_CONTROL_LOST			((SLuint32) 0x00000010)


/* Object state definitions */

#define SL_OBJECT_STATE_UNREALIZED	((SLuint32) 0x00000001)
#define SL_OBJECT_STATE_REALIZED		((SLuint32) 0x00000002)
#define SL_OBJECT_STATE_SUSPENDED	((SLuint32) 0x00000003)

/* Object event definitions */

#define SL_OBJECT_EVENT_RUNTIME_ERROR			((SLuint32) 0x00000001)
#define SL_OBJECT_EVENT_ASYNC_TERMINATION		((SLuint32) 0x00000002)
#define SL_OBJECT_EVENT_RESOURCES_LOST			((SLuint32) 0x00000003)
#define SL_OBJECT_EVENT_RESOURCES_AVAILABLE		((SLuint32) 0x00000004)
#define SL_OBJECT_EVENT_ITF_CONTROL_TAKEN		((SLuint32) 0x00000005)
#define SL_OBJECT_EVENT_ITF_CONTROL_RETURNED		((SLuint32) 0x00000006)
#define SL_OBJECT_EVENT_ITF_PARAMETERS_CHANGED	((SLuint32) 0x00000007)


/*****************************************************************************/
/* Interface definitions                                                     */
/*****************************************************************************/

/** NULL Interface */

extern SLAPIENTRY const SLInterfaceID SL_IID_NULL;

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

/** Data locator macros  */
#define SL_DATALOCATOR_URI			((SLuint32) 0x00000001)
#define SL_DATALOCATOR_ADDRESS		((SLuint32) 0x00000002)
#define SL_DATALOCATOR_IODEVICE		((SLuint32) 0x00000003)
#define SL_DATALOCATOR_OUTPUTMIX		((SLuint32) 0x00000004)
#define SL_DATALOCATOR_RESERVED5		((SLuint32) 0x00000005)
#define SL_DATALOCATOR_BUFFERQUEUE	((SLuint32) 0x00000006)
#define SL_DATALOCATOR_MIDIBUFFERQUEUE	((SLuint32) 0x00000007)
#define SL_DATALOCATOR_RESERVED8		((SLuint32) 0x00000008)



/** URI-based data locator definition where locatorType must be SL_DATALOCATOR_URI*/
typedef struct SLDataLocator_URI_ {
	SLuint32 		locatorType;
	SLchar *		URI;
} SLDataLocator_URI;

/** Address-based data locator definition where locatorType must be SL_DATALOCATOR_ADDRESS*/
typedef struct SLDataLocator_Address_ {
	SLuint32 	locatorType;
	void 		*pAddress;
	SLuint32	length;
} SLDataLocator_Address;

/** IODevice-types */
#define SL_IODEVICE_AUDIOINPUT	((SLuint32) 0x00000001)
#define SL_IODEVICE_LEDARRAY	((SLuint32) 0x00000002)
#define SL_IODEVICE_VIBRA		((SLuint32) 0x00000003)
#define SL_IODEVICE_RESERVED4	((SLuint32) 0x00000004)
#define SL_IODEVICE_RESERVED5	((SLuint32) 0x00000005)

/** IODevice-based data locator definition where locatorType must be SL_DATALOCATOR_IODEVICE*/
typedef struct SLDataLocator_IODevice_ {
	SLuint32	locatorType;
	SLuint32	deviceType;
	SLuint32	deviceID;
	SLObjectItf	device;
} SLDataLocator_IODevice;

/** OutputMix-based data locator definition where locatorType must be SL_DATALOCATOR_OUTPUTMIX*/
typedef struct SLDataLocator_OutputMix {
	SLuint32 		locatorType;
	SLObjectItf		outputMix;
} SLDataLocator_OutputMix;


/** BufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_BUFFERQUEUE*/
typedef struct SLDataLocator_BufferQueue {
	SLuint32	locatorType;
	SLuint32	numBuffers;
} SLDataLocator_BufferQueue;

/** MidiBufferQueue-based data locator definition where locatorType must be SL_DATALOCATOR_MIDIBUFFERQUEUE*/
typedef struct SLDataLocator_MIDIBufferQueue {
	SLuint32	locatorType;
	SLuint32	tpqn;
	SLuint32	numBuffers;
} SLDataLocator_MIDIBufferQueue;

/** Data format defines */
#define SL_DATAFORMAT_MIME		((SLuint32) 0x00000001)
#define SL_DATAFORMAT_PCM		((SLuint32) 0x00000002)
#define SL_DATAFORMAT_RESERVED3	((SLuint32) 0x00000003)


/** MIME-type-based data format definition where formatType must be SL_DATAFORMAT_MIME*/
typedef struct SLDataFormat_MIME_ {
	SLuint32 		formatType;
	SLchar * 		mimeType;
	SLuint32		containerType;
} SLDataFormat_MIME;

/* Byte order of a block of 16- or 32-bit data */
#define SL_BYTEORDER_BIGENDIAN				((SLuint32) 0x00000001)
#define SL_BYTEORDER_LITTLEENDIAN			((SLuint32) 0x00000002)

/* Container type */
#define SL_CONTAINERTYPE_UNSPECIFIED	((SLuint32) 0x00000001)
#define SL_CONTAINERTYPE_RAW		((SLuint32) 0x00000002)
#define SL_CONTAINERTYPE_ASF		((SLuint32) 0x00000003)
#define SL_CONTAINERTYPE_AVI		((SLuint32) 0x00000004)
#define SL_CONTAINERTYPE_BMP		((SLuint32) 0x00000005)
#define SL_CONTAINERTYPE_JPG		((SLuint32) 0x00000006)
#define SL_CONTAINERTYPE_JPG2000		((SLuint32) 0x00000007)
#define SL_CONTAINERTYPE_M4A		((SLuint32) 0x00000008)
#define SL_CONTAINERTYPE_MP3		((SLuint32) 0x00000009)
#define SL_CONTAINERTYPE_MP4		((SLuint32) 0x0000000A)
#define SL_CONTAINERTYPE_MPEG_ES		((SLuint32) 0x0000000B)
#define SL_CONTAINERTYPE_MPEG_PS		((SLuint32) 0x0000000C)
#define SL_CONTAINERTYPE_MPEG_TS		((SLuint32) 0x0000000D)
#define SL_CONTAINERTYPE_QT		((SLuint32) 0x0000000E)
#define SL_CONTAINERTYPE_WAV		((SLuint32) 0x0000000F)
#define SL_CONTAINERTYPE_XMF_0		((SLuint32) 0x00000010)
#define SL_CONTAINERTYPE_XMF_1		((SLuint32) 0x00000011)
#define SL_CONTAINERTYPE_XMF_2		((SLuint32) 0x00000012)
#define SL_CONTAINERTYPE_XMF_3		((SLuint32) 0x00000013)
#define SL_CONTAINERTYPE_XMF_GENERIC	((SLuint32) 0x00000014)
#define SL_CONTAINERTYPE_AMR  		((SLuint32) 0x00000015)
#define SL_CONTAINERTYPE_AAC		((SLuint32) 0x00000016)
#define SL_CONTAINERTYPE_3GPP		((SLuint32) 0x00000017)
#define SL_CONTAINERTYPE_3GA		((SLuint32) 0x00000018)
#define SL_CONTAINERTYPE_RM		((SLuint32) 0x00000019)
#define SL_CONTAINERTYPE_DMF		((SLuint32) 0x0000001A)
#define SL_CONTAINERTYPE_SMF		((SLuint32) 0x0000001B)
#define SL_CONTAINERTYPE_MOBILE_DLS	((SLuint32) 0x0000001C)
#define SL_CONTAINERTYPE_OGG	((SLuint32) 0x0000001D)


/** PCM-type-based data format definition where formatType must be SL_DATAFORMAT_PCM*/
typedef struct SLDataFormat_PCM_ {
	SLuint32 		formatType;
	SLuint32 		numChannels;
	SLuint32 		samplesPerSec;
	SLuint32 		bitsPerSample;
	SLuint32 		containerSize;
	SLuint32 		channelMask;
	SLuint32		endianness;
} SLDataFormat_PCM;

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


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






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

extern SLAPIENTRY const SLInterfaceID SL_IID_OBJECT;

/** Object callback */


typedef void (/*SLAPIENTRY*/ *slObjectCallback) (
	SLObjectItf caller,
	const void * pContext,
	SLuint32 event,
	SLresult result,
    SLuint32 param,
    void *pInterface
);


struct SLObjectItf_ {
	SLresult (*Realize) (
		SLObjectItf self,
		SLboolean async
	);
	SLresult (*Resume) (
		SLObjectItf self,
		SLboolean async
	);
	SLresult (*GetState) (
		SLObjectItf self,
		SLuint32 * pState
	);
	SLresult (*GetInterface) (
		SLObjectItf self,
		const SLInterfaceID iid,
		void * pInterface
	);
	SLresult (*RegisterCallback) (
		SLObjectItf self,
		slObjectCallback callback,
		void * pContext
	);
	void (*AbortAsyncOperation) (
		SLObjectItf self
	);
	void (*Destroy) (
		SLObjectItf self
	);
	SLresult (*SetPriority) (
		SLObjectItf self,
		SLint32 priority,
		SLboolean preemptable
	);
	SLresult (*GetPriority) (
		SLObjectItf self,
		SLint32 *pPriority,
		SLboolean *pPreemptable
	);
	SLresult (*SetLossOfControlInterfaces) (
		SLObjectItf self,
		SLint16 numInterfaces,
		SLInterfaceID * pInterfaceIDs,
		SLboolean enabled
	);
};


/*---------------------------------------------------------------------------*/
/* Audio IO Device capabilities interface                                    */
/*---------------------------------------------------------------------------*/

#define SL_DEFAULTDEVICEID_AUDIOINPUT 	((SLuint32) 0xFFFFFFFF)
#define SL_DEFAULTDEVICEID_AUDIOOUTPUT 	((SLuint32) 0xFFFFFFFE)
#define SL_DEFAULTDEVICEID_LED          ((SLuint32) 0xFFFFFFFD)
#define SL_DEFAULTDEVICEID_VIBRA        ((SLuint32) 0xFFFFFFFC)
#define SL_DEFAULTDEVICEID_RESERVED1    ((SLuint32) 0xFFFFFFFB)


#define SL_DEVCONNECTION_INTEGRATED         ((SLint16) 0x0001)
#define SL_DEVCONNECTION_ATTACHED_WIRED     ((SLint16) 0x0100)
#define SL_DEVCONNECTION_ATTACHED_WIRELESS  ((SLint16) 0x0200)
#define SL_DEVCONNECTION_NETWORK 		    ((SLint16) 0x0400)


#define SL_DEVLOCATION_HANDSET 	((SLuint16) 0x0001)
#define SL_DEVLOCATION_HEADSET 	((SLuint16) 0x0002)
#define SL_DEVLOCATION_CARKIT 	((SLuint16) 0x0003)
#define SL_DEVLOCATION_DOCK 	((SLuint16) 0x0004)
#define SL_DEVLOCATION_REMOTE 	((SLuint16) 0x0005)
/* Note: SL_DEVLOCATION_RESLTE is deprecated, use SL_DEVLOCATION_REMOTE instead. */
#define SL_DEVLOCATION_RESLTE 	((SLuint16) 0x0005)


#define SL_DEVSCOPE_UNKNOWN     ((SLuint16) 0x0001)
#define SL_DEVSCOPE_ENVIRONMENT ((SLuint16) 0x0002)
#define SL_DEVSCOPE_USER        ((SLuint16) 0x0003)


typedef struct SLAudioInputDescriptor_ {
	SLchar *deviceName;
	SLint16 deviceConnection;
	SLint16 deviceScope;
	SLint16 deviceLocation;
	SLboolean isForTelephony;
	SLmilliHertz minSampleRate;
	SLmilliHertz maxSampleRate;
	SLboolean isFreqRangeContinuous;
	SLmilliHertz *samplingRatesSupported;
	SLint16 numOfSamplingRatesSupported;
	SLint16 maxChannels;
} SLAudioInputDescriptor;


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



extern SLAPIENTRY const SLInterfaceID SL_IID_AUDIOIODEVICECAPABILITIES;

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


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


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

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


struct SLAudioIODeviceCapabilitiesItf_ {
	SLresult (*GetAvailableAudioInputs)(
		SLAudioIODeviceCapabilitiesItf self,
		SLint32  *pNumInputs,
		SLuint32 *pInputDeviceIDs
	);
	SLresult (*QueryAudioInputCapabilities)(
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 deviceId,
		SLAudioInputDescriptor *pDescriptor
	);
	SLresult (*RegisterAvailableAudioInputsChangedCallback) (
		SLAudioIODeviceCapabilitiesItf self,
		slAvailableAudioInputsChangedCallback callback,
		void *pContext
	);
	SLresult (*GetAvailableAudioOutputs)(
		SLAudioIODeviceCapabilitiesItf self,
		SLint32 *pNumOutputs,
		SLuint32 *pOutputDeviceIDs
	);
	SLresult (*QueryAudioOutputCapabilities)(
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 deviceId,
		SLAudioOutputDescriptor *pDescriptor
	);
	SLresult (*RegisterAvailableAudioOutputsChangedCallback) (
		SLAudioIODeviceCapabilitiesItf self,
		slAvailableAudioOutputsChangedCallback callback,
		void *pContext
	);
	SLresult (*RegisterDefaultDeviceIDMapChangedCallback) (
		SLAudioIODeviceCapabilitiesItf self,
		slDefaultDeviceIDMapChangedCallback callback,
		void *pContext
	);
	SLresult (*GetAssociatedAudioInputs) (
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 deviceId,
		SLint32 *pNumAudioInputs,
		SLuint32 *pAudioInputDeviceIDs
	);
	SLresult (*GetAssociatedAudioOutputs) (
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 deviceId,
		SLint32 *pNumAudioOutputs,
		SLuint32 *pAudioOutputDeviceIDs
	);
	SLresult (*GetDefaultAudioDevices) (
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 defaultDeviceID,
		SLint32 *pNumAudioDevices,
		SLuint32 *pAudioDeviceIDs
	);
	SLresult (*QuerySampleFormatsSupported)(
		SLAudioIODeviceCapabilitiesItf self,
		SLuint32 deviceId,
		SLmilliHertz samplingRate,
		SLint32 *pSampleFormats,
		SLint32 *pNumOfSampleFormats
	);
};



/*---------------------------------------------------------------------------*/
/* Capabilities of the LED array IODevice                                    */
/*---------------------------------------------------------------------------*/

typedef struct SLLEDDescriptor_ {
	SLuint8   ledCount;
	SLuint8   primaryLED;
	SLuint32  colorMask;
} SLLEDDescriptor;


/*---------------------------------------------------------------------------*/
/* LED Array interface                                                       */
/*---------------------------------------------------------------------------*/

typedef struct SLHSL_ {
    SLmillidegree  hue;
    SLpermille     saturation;
    SLpermille     lightness;
} SLHSL;


extern SLAPIENTRY const SLInterfaceID SL_IID_LED;

struct SLLEDArrayItf_;
typedef const struct SLLEDArrayItf_ * const * SLLEDArrayItf;

struct SLLEDArrayItf_ {
	SLresult (*ActivateLEDArray) (
		SLLEDArrayItf self,
		SLuint32 lightMask
	);
	SLresult (*IsLEDArrayActivated) (
		SLLEDArrayItf self,
		SLuint32 *lightMask
	);
	SLresult (*SetColor) (
		SLLEDArrayItf self,
		SLuint8 index,
		const SLHSL *color
	);
	SLresult (*GetColor) (
		SLLEDArrayItf self,
		SLuint8 index,
		SLHSL *color
	);
};

/*---------------------------------------------------------------------------*/
/* Capabilities of the Vibra IODevice                                        */
/*---------------------------------------------------------------------------*/

typedef struct SLVibraDescriptor_ {
	SLboolean supportsFrequency;
	SLboolean supportsIntensity;
	SLmilliHertz  minFrequency;
	SLmilliHertz  maxFrequency;
} SLVibraDescriptor;



/*---------------------------------------------------------------------------*/
/* Vibra interface                                                           */
/*---------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_VIBRA;


struct SLVibraItf_;
typedef const struct SLVibraItf_ * const * SLVibraItf;

struct SLVibraItf_ {
	SLresult (*Vibrate) (
		SLVibraItf self,
		SLboolean vibrate
	);
	SLresult (*IsVibrating) (
		SLVibraItf self,
		SLboolean *pVibrating
	);
	SLresult (*SetFrequency) (
		SLVibraItf self,
		SLmilliHertz frequency
	);
	SLresult (*GetFrequency) (
		SLVibraItf self,
		SLmilliHertz *pFrequency
	);
	SLresult (*SetIntensity) (
		SLVibraItf self,
		SLpermille intensity
	);
	SLresult (*GetIntensity) (
		SLVibraItf self,
		SLpermille *pIntensity
	);
};


/*---------------------------------------------------------------------------*/
/* Meta data extraction related types and interface                          */
/*---------------------------------------------------------------------------*/

#define SL_CHARACTERENCODING_UNKNOWN			((SLuint32) 0x00000000)
#define SL_CHARACTERENCODING_BINARY       ((SLuint32) 0x00000001)
#define SL_CHARACTERENCODING_ASCII        ((SLuint32) 0x00000002)
#define SL_CHARACTERENCODING_BIG5         ((SLuint32) 0x00000003)
#define SL_CHARACTERENCODING_CODEPAGE1252		((SLuint32) 0x00000004)
#define SL_CHARACTERENCODING_GB2312			((SLuint32) 0x00000005)
#define SL_CHARACTERENCODING_HZGB2312			((SLuint32) 0x00000006)
#define SL_CHARACTERENCODING_GB12345			((SLuint32) 0x00000007)
#define SL_CHARACTERENCODING_GB18030			((SLuint32) 0x00000008)
#define SL_CHARACTERENCODING_GBK				((SLuint32) 0x00000009)
#define SL_CHARACTERENCODING_IMAPUTF7			((SLuint32) 0x0000000A)
#define SL_CHARACTERENCODING_ISO2022JP			((SLuint32) 0x0000000B)
#define SL_CHARACTERENCODING_ISO2022JP1		((SLuint32) 0x0000000B)
#define SL_CHARACTERENCODING_ISO88591			((SLuint32) 0x0000000C)
#define SL_CHARACTERENCODING_ISO885910			((SLuint32) 0x0000000D)
#define SL_CHARACTERENCODING_ISO885913			((SLuint32) 0x0000000E)
#define SL_CHARACTERENCODING_ISO885914			((SLuint32) 0x0000000F)
#define SL_CHARACTERENCODING_ISO885915			((SLuint32) 0x00000010)
#define SL_CHARACTERENCODING_ISO88592			((SLuint32) 0x00000011)
#define SL_CHARACTERENCODING_ISO88593			((SLuint32) 0x00000012)
#define SL_CHARACTERENCODING_ISO88594			((SLuint32) 0x00000013)
#define SL_CHARACTERENCODING_ISO88595			((SLuint32) 0x00000014)
#define SL_CHARACTERENCODING_ISO88596			((SLuint32) 0x00000015)
#define SL_CHARACTERENCODING_ISO88597			((SLuint32) 0x00000016)
#define SL_CHARACTERENCODING_ISO88598			((SLuint32) 0x00000017)
#define SL_CHARACTERENCODING_ISO88599			((SLuint32) 0x00000018)
#define SL_CHARACTERENCODING_ISOEUCJP			((SLuint32) 0x00000019)
#define SL_CHARACTERENCODING_SHIFTJIS			((SLuint32) 0x0000001A)
#define SL_CHARACTERENCODING_SMS7BIT			((SLuint32) 0x0000001B)
#define SL_CHARACTERENCODING_UTF7			((SLuint32) 0x0000001C)
#define SL_CHARACTERENCODING_UTF8			((SLuint32) 0x0000001D)
#define SL_CHARACTERENCODING_JAVACONFORMANTUTF8	((SLuint32) 0x0000001E)
#define SL_CHARACTERENCODING_UTF16BE			((SLuint32) 0x0000001F)
#define SL_CHARACTERENCODING_UTF16LE			((SLuint32) 0x00000020)


#define SL_METADATA_FILTER_KEY		((SLuint8) 0x01)
#define SL_METADATA_FILTER_LANG		((SLuint8) 0x02)
#define SL_METADATA_FILTER_ENCODING	((SLuint8) 0x04)


typedef struct SLMetadataInfo_ {
    SLuint32     size;
    SLuint32     encoding;
    SLchar       langCountry[16];
    SLuint8      data[1];
} SLMetadataInfo;

extern SLAPIENTRY const SLInterfaceID SL_IID_METADATAEXTRACTION;

struct SLMetadataExtractionItf_;
typedef const struct SLMetadataExtractionItf_ * const * SLMetadataExtractionItf;


struct SLMetadataExtractionItf_ {
	SLresult (*GetItemCount) (
		SLMetadataExtractionItf self,
		SLuint32 *pItemCount
	);
	SLresult (*GetKeySize) (
		SLMetadataExtractionItf self,
		SLuint32 index,
		SLuint32 *pKeySize
	);
	SLresult (*GetKey) (
		SLMetadataExtractionItf self,
		SLuint32 index,
		SLuint32 keySize,
		SLMetadataInfo *pKey
	);
	SLresult (*GetValueSize) (
		SLMetadataExtractionItf self,
		SLuint32 index,
		SLuint32 *pValueSize
	);
	SLresult (*GetValue) (
		SLMetadataExtractionItf self,
		SLuint32 index,
		SLuint32 valueSize,
		SLMetadataInfo *pValue
	);
	SLresult (*AddKeyFilter) (
		SLMetadataExtractionItf self,
		SLuint32 keySize,
		const void *pKey,
		SLuint32 keyEncoding,
		const SLchar *pValueLangCountry,
		SLuint32 valueEncoding,
		SLuint8 filterMask
	);
	SLresult (*ClearKeyFilter) (
		SLMetadataExtractionItf self
	);
};


/*---------------------------------------------------------------------------*/
/* Meta data traversal related types and interface                          */
/*---------------------------------------------------------------------------*/

#define SL_METADATATRAVERSALMODE_ALL	((SLuint32) 0x00000001)
#define SL_METADATATRAVERSALMODE_NODE	((SLuint32) 0x00000002)


#define SL_NODETYPE_UNSPECIFIED	((SLuint32) 0x00000001)
#define SL_NODETYPE_AUDIO		((SLuint32) 0x00000002)
#define SL_NODETYPE_VIDEO		((SLuint32) 0x00000003)
#define SL_NODETYPE_IMAGE		((SLuint32) 0x00000004)

#define SL_NODE_PARENT 0xFFFFFFFF

extern SLAPIENTRY const SLInterfaceID SL_IID_METADATATRAVERSAL;

struct SLMetadataTraversalItf_;
typedef const struct SLMetadataTraversalItf_ * const * SLMetadataTraversalItf;

struct SLMetadataTraversalItf_ {
	SLresult (*SetMode) (
		SLMetadataTraversalItf self,
		SLuint32 mode
	);
	SLresult (*GetChildCount) (
		SLMetadataTraversalItf self,
		SLuint32 *pCount
	);
	SLresult (*GetChildMIMETypeSize) (
		SLMetadataTraversalItf self,
		SLuint32 index,
		SLuint32 *pSize
	);
	SLresult (*GetChildInfo) (
		SLMetadataTraversalItf self,
		SLuint32 index,
		SLint32 *pNodeID,
		SLuint32 *pType,
		SLuint32 size,
		SLchar *pMimeType
	);
	SLresult (*SetActiveNode) (
		SLMetadataTraversalItf self,
		SLuint32 index
	);
};

/*---------------------------------------------------------------------------*/
/* Dynamic Source types and interface                                        */
/*---------------------------------------------------------------------------*/

extern SLAPIENTRY const SLInterfaceID SL_IID_DYNAMICSOURCE;

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

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

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

extern SLAPIENTRY const SLInterfaceID SL_IID_OUTPUTMIX;

struct SLOutputMixItf_;
typedef const struct SLOutputMixItf_ * const * SLOutputMixItf;

typedef void (/*SLAPIENTRY*/ *slMixDeviceChangeCallback) (
	SLOutputMixItf caller,
    void *pContext
);


struct SLOutputMixItf_ {
	SLresult (*GetDestinationOutputDeviceIDs) (
		SLOutputMixItf self,
		SLint32 *pNumDevices,
		SLuint32 *pDeviceIDs
	);
	SLresult (*RegisterDeviceChangeCallback) (
		SLOutputMixItf self,
		slMixDeviceChangeCallback callback,
		void *pContext
    );
    SLresult (*ReRoute)(
        SLOutputMixItf self,
        SLint32 numOutputDevices,
        SLuint32 *pOutputDeviceIDs
    );
};


/*---------------------------------------------------------------------------*/
/* Playback interface                                                        */
/*---------------------------------------------------------------------------*/

/** Playback states */
#define SL_PLAYSTATE_STOPPED	((SLuint32) 0x00000001)
#define SL_PLAYSTATE_PAUSED	((SLuint32) 0x00000002)
#define SL_PLAYSTATE_PLAYING	((SLuint32) 0x00000003)

/** Play events **/
#define SL_PLAYEVENT_HEADATEND		((SLuint32) 0x00000001)
#define SL_PLAYEVENT_HEADATMARKER	((SLuint32) 0x00000002)
#define SL_PLAYEVENT_HEADATNEWPOS	((SLuint32) 0x00000004)
#define SL_PLAYEVENT_HEADMOVING		((SLuint32) 0x00000008)
#define SL_PLAYEVENT_HEADSTALLED	((SLuint32) 0x00000010)

#define SL_TIME_UNKNOWN	((SLuint32) 0xFFFFFFFF)


extern SLAPIENTRY const SLInterfaceID SL_IID_PLAY;

/** Playback interface methods */

struct SLPlayItf_;
typedef const struct SLPlayItf_ * const * SLPlayItf;

typedef void (/*SLAPIENTRY*/ *slPlayCallback) (
	SLPlayItf caller,
	void *pContext,
	SLuint32 event
);

struct SLPlayItf_ {
	SLresult (*SetPlayState) (
		SLPlayItf self,
		SLuint32 state
	);
	SLresult (*GetPlayState) (
		SLPlayItf self,
		SLuint32 *pState
	);
	SLresult (*GetDuration) (
		SLPlayItf self,
		SLmillisecond *pMsec
	);
	SLresult (*GetPosition) (
		SLPlayItf self,
		SLmillisecond *pMsec
	);
	SLresult (*RegisterCallback) (
		SLPlayItf self,
		slPlayCallback callback,
		void *pContext
	);
	SLresult (*SetCallbackEventsMask) (
		SLPlayItf self,
		SLuint32 eventFlags
	);
	SLresult (*GetCallbackEventsMask) (
		SLPlayItf self,
		SLuint32 *pEventFlags
	);
	SLresult (*SetMarkerPosition) (
		SLPlayItf self,
		SLmillisecond mSec
	);
	SLresult (*ClearMarkerPosition) (
		SLPlayItf self
	);
	SLresult (*GetMarkerPosition) (
		SLPlayItf self,
		SLmillisecond *pMsec
	);
	SLresult (*SetPositionUpdatePeriod) (
		SLPlayItf self,
		SLmillisecond mSec
	);
	SLresult (*GetPositionUpdatePeriod) (
		SLPlayItf self,
		SLmillisecond *pMsec
	);
};

/*---------------------------------------------------------------------------*/
/* Prefetch status interface                                                 */
/*---------------------------------------------------------------------------*/

#define SL_PREFETCHEVENT_STATUSCHANGE		((SLuint32) 0x00000001)
#define SL_PREFETCHEVENT_FILLLEVELCHANGE	((SLuint32) 0x00000002)

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


extern SLAPIENTRY const SLInterfaceID SL_IID_PREFETCHSTATUS;


/** Prefetch status interface methods */

struct SLPrefetchStatusItf_;
typedef const struct SLPrefetchStatusItf_ * const * SLPrefetchStatusItf;

typedef void (/*SLAPIENTRY*/ *slPrefetchCallback) (
	SLPrefetchStatusItf caller,
	void *pContext,
	SLuint32 event
);

struct SLPrefetchStatusItf_ {
	SLresult (*GetPrefetchStatus) (
		SLPrefetchStatusItf self,
		SLuint32 *pStatus
	);
	SLresult (*GetFillLevel) (
		SLPrefetchStatusItf self,
		SLpermille *pLevel
	);
	SLresult (*RegisterCallback) (
		SLPrefetchStatusItf self,
		slPrefetchCallback callback,
		void *pContext
	);
	SLresult (*SetCallbackEventsMask) (
		SLPrefetchStatusItf self,
		SLuint32 eventFlags
	);
	SLresult (*GetCallbackEventsMask) (
		SLPrefetchStatusItf self,
		SLuint32 *pEventFlags
	);
	SLresult (*SetFillUpdatePeriod) (
		SLPrefetchStatusItf self,
		SLpermille period
	);
	SLresult (*GetFillUpdatePeriod) (
		SLPrefetchStatusItf self,
		SLpermille *pPeriod
	);
};

/*---------------------------------------------------------------------------*/
/* Playback Rate interface                                                   */
/*---------------------------------------------------------------------------*/

#define SL_RATEPROP_RESERVED1		  		((SLuint32) 0x00000001)
#define SL_RATEPROP_RESERVED2		  		((SLuint32) 0x00000002)
#define SL_RATEPROP_SILENTAUDIO				((SLuint32) 0x00000100)
#define SL_RATEPROP_STAGGEREDAUDIO	((SLuint32) 0x00000200)
#define SL_RATEPROP_NOPITCHCORAUDIO	((SLuint32) 0x00000400)
#define SL_RATEPROP_PITCHCORAUDIO	((SLuint32) 0x00000800)


extern SLAPIENTRY const SLInterfaceID SL_IID_PLAYBACKRATE;

struct SLPlaybackRateItf_;
typedef const struct SLPlaybackRateItf_ * const * SLPlaybackRateItf;

struct SLPlaybackRateItf_ {
	SLresult (*SetRate)(
		SLPlaybackRateItf self,
		SLpermille rate
	);
	SLresult (*GetRate)(
		SLPlaybackRateItf self,
		SLpermille *pRate
	);
	SLresult (*SetPropertyConstraints)(
		SLPlaybackRateItf self,
		SLuint32 constraints
	);
	SLresult (*GetProperties)(
		SLPlaybackRateItf self,
		SLuint32 *pProperties
	);
	SLresult (*GetCapabilitiesOfRate)(
		SLPlaybackRateItf self,
		SLpermille rate,
		SLuint32 *pCapabilities
	);
	SLresult (*GetRateRange) (
		SLPlaybackRateItf self,
		SLuint8 index,
		SLpermille *pMinRate,
		SLpermille *pMaxRate,
		SLpermille *pStepSize,
		SLuint32 *pCapabilities
	);
};

/*---------------------------------------------------------------------------*/
/* Seek Interface                                                            */
/*---------------------------------------------------------------------------*/

#define SL_SEEKMODE_FAST		((SLuint32) 0x0001)
#define SL_SEEKMODE_ACCURATE	((SLuint32) 0x0002)

extern SLAPIENTRY const SLInterfaceID SL_IID_SEEK;

struct SLSeekItf_;
typedef const struct SLSeekItf_ * const * SLSeekItf;

struct SLSeekItf_ {
	SLresult (*SetPosition)(
		SLSeekItf self,
		SLmillisecond pos,
		SLuint32 seekMode
	);
	SLresult (*SetLoop)(
		SLSeekItf self,
		SLboolean loopEnable,
		SLmillisecond startPos,
		SLmillisecond endPos
	);
	SLresult (*GetLoop)(
		SLSeekItf self,
		SLboolean *pLoopEnabled,
		SLmillisecond *pStartPos,
		SLmillisecond *pEndPos
	);
};

/*---------------------------------------------------------------------------*/
/* Standard Recording Interface                                              */
/*---------------------------------------------------------------------------*/

/** Recording states */
#define SL_RECORDSTATE_STOPPED 	((SLuint32) 0x00000001)
#define SL_RECORDSTATE_PAUSED	((SLuint32) 0x00000002)
#define SL_RECORDSTATE_RECORDING	((SLuint32) 0x00000003)


/** Record event **/
#define SL_RECORDEVENT_HEADATLIMIT	((SLuint32) 0x00000001)
#define SL_RECORDEVENT_HEADATMARKER	((SLuint32) 0x00000002)
#define SL_RECORDEVENT_HEADATNEWPOS	((SLuint32) 0x00000004)
#define SL_RECORDEVENT_HEADMOVING	((SLuint32) 0x00000008)
#define SL_RECORDEVENT_HEADSTALLED 	((SLuint32) 0x00000010)
/* Note: SL_RECORDEVENT_BUFFER_INSUFFICIENT is deprecated, use SL_RECORDEVENT_BUFFER_FULL instead. */
#define SL_RECORDEVENT_BUFFER_INSUFFICIENT      ((SLuint32) 0x00000020)
#define SL_RECORDEVENT_BUFFER_FULL	((SLuint32) 0x00000020)


extern SLAPIENTRY const SLInterfaceID SL_IID_RECORD;

struct SLRecordItf_;
typedef const struct SLRecordItf_ * const * SLRecordItf;

typedef void (/*SLAPIENTRY*/ *slRecordCallback) (
	SLRecordItf caller,
	void *pContext,
	SLuint32 event
);

/** Recording interface methods */
struct SLRecordItf_ {
	SLresult (*SetRecordState) (
		SLRecordItf self,
		SLuint32 state
	);
	SLresult (*GetRecordState) (
		SLRecordItf self,
		SLuint32 *pState
	);
	SLresult (*SetDurationLimit) (
		SLRecordItf self,
		SLmillisecond msec
	);
	SLresult (*GetPosition) (
		SLRecordItf self,
		SLmillisecond *pMsec
	);
	SLresult (*RegisterCallback) (
		SLRecordItf self,
		slRecordCallback callback,
		void *pContext
	);
	SLresult (*SetCallbackEventsMask) (
		SLRecordItf self,
		SLuint32 eventFlags
	);
	SLresult (*GetCallbackEventsMask) (
		SLRecordItf self,
		SLuint32 *pEventFlags
	);
	SLresult (*SetMarkerPosition) (
		SLRecordItf self,
		SLmillisecond mSec
	);
	SLresult (*ClearMarkerPosition) (
		SLRecordItf self
	);
	SLresult (*GetMarkerPosition) (
		SLRecordItf self,
		SLmillisecond *pMsec
	);
	SLresult (*SetPositionUpdatePeriod) (
		SLRecordItf self,
		SLmillisecond mSec
	);
	SLresult (*GetPositionUpdatePeriod) (
		SLRecordItf self,
		SLmillisecond *pMsec
	);
};

/*---------------------------------------------------------------------------*/
/* Equalizer interface                                                       */
/*---------------------------------------------------------------------------*/

#define SL_EQUALIZER_UNDEFINED				((SLuint16) 0xFFFF)

extern SLAPIENTRY const SLInterfaceID SL_IID_EQUALIZER;

struct SLEqualizerItf_;
typedef const struct SLEqualizerItf_ * const * SLEqualizerItf;

struct SLEqualizerItf_ {
	SLresult (*SetEnabled)(
		SLEqualizerItf self,
		SLboolean enabled
	);
	SLresult (*IsEnabled)(
		SLEqualizerItf self,
		SLboolean *pEnabled
	);
	SLresult (*GetNumberOfBands)(
		SLEqualizerItf self,
		SLuint16 *pAmount
	);
	SLresult (*GetBandLevelRange)(
		SLEqualizerItf self,
		SLmillibel *pMin,
		SLmillibel *pMax
	);
	SLresult (*SetBandLevel)(
		SLEqualizerItf self,
		SLuint16 band,
		SLmillibel level
	);
	SLresult (*GetBandLevel)(
		SLEqualizerItf self,
		SLuint16 band,
		SLmillibel *pLevel
	);
	SLresult (*GetCenterFreq)(
		SLEqualizerItf self,
		SLuint16 band,
		SLmilliHertz *pCenter
	);
	SLresult (*GetBandFreqRange)(
		SLEqualizerItf self,
		SLuint16 band,
		SLmilliHertz *pMin,
		SLmilliHertz *pMax
	);
	SLresult (*GetBand)(
		SLEqualizerItf self,
		SLmilliHertz frequency,
		SLuint16 *pBand
	);
	SLresult (*GetCurrentPreset)(
		SLEqualizerItf self,
		SLuint16 *pPreset
	);
	SLresult (*UsePreset)(
		SLEqualizerItf self,
		SLuint16 index
	);
	SLresult (*GetNumberOfPresets)(
		SLEqualizerItf self,
		SLuint16 *pNumPresets
	);
	SLresult (*GetPresetName)(
		SLEqualizerItf self,
		SLuint16 index,
		const SLchar ** ppName
	);
};

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

extern SLAPIENTRY const SLInterfaceID SL_IID_VOLUME;

struct SLVolumeItf_;
typedef const struct SLVolumeItf_ * const * SLVolumeItf;

struct SLVolumeItf_ {
	SLresult (*SetVolumeLevel) (
		SLVolumeItf self,
		SLmillibel level
	);
	SLresult (*GetVolumeLevel) (
		SLVolumeItf self,
		SLmillibel *pLevel
	);
	SLresult (*GetMaxVolumeLevel) (
		SLVolumeItf  self,
		SLmillibel *pMaxLevel
	);
	SLresult (*SetMute) (
		SLVolumeItf self,
		SLboolean mute
	);
	SLresult (*GetMute) (
		SLVolumeItf self,
		SLboolean *pMute
	);
	SLresult (*EnableStereoPosition) (
		SLVolumeItf self,
		SLboolean enable
	);
	SLresult (*IsEnabledStereoPosition) (
		SLVolumeItf self,
		SLboolean *pEnable
	);
	SLresult (*SetStereoPosition) (
		SLVolumeItf self,
		SLpermille stereoPosition
	);
	SLresult (*GetStereoPosition) (
		SLVolumeItf self,
		SLpermille *pStereoPosition
	);
};


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

extern SLAPIENTRY const SLInterfaceID SL_IID_DEVICEVOLUME;

struct SLDeviceVolumeItf_;
typedef const struct SLDeviceVolumeItf_ * const * SLDeviceVolumeItf;

struct SLDeviceVolumeItf_ {
	SLresult (*GetVolumeScale) (
		SLDeviceVolumeItf self,
		SLuint32 deviceID,
		SLint32 *pMinValue,
		SLint32 *pMaxValue,
		SLboolean *pIsMillibelScale
	);
	SLresult (*SetVolume) (
		SLDeviceVolumeItf self,
		SLuint32 deviceID,
		SLint32 volume
	);
	SLresult (*GetVolume) (
		SLDeviceVolumeItf self,
		SLuint32 deviceID,
		SLint32 *pVolume
	);
};


/*---------------------------------------------------------------------------*/
/* Buffer Queue Interface                                                    */
/*---------------------------------------------------------------------------*/

extern SLAPIENTRY const SLInterfaceID SL_IID_BUFFERQUEUE;

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

typedef void (/*SLAPIENTRY*/ *slBufferQueueCallback)(
	SLBufferQueueItf caller,
	void *pContext
);

/** Buffer queue state **/

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


struct SLBufferQueueItf_ {
	SLresult (*Enqueue) (
		SLBufferQueueItf self,
		const void *pBuffer,
		SLuint32 size
	);
	SLresult (*Clear) (
		SLBufferQueueItf self
	);
	SLresult (*GetState) (
		SLBufferQueueItf self,
		SLBufferQueueState *pState
	);
	SLresult (*RegisterCallback) (
		SLBufferQueueItf self,
		slBufferQueueCallback callback,
		void* pContext
	);
};


/*---------------------------------------------------------------------------*/
/* PresetReverb                                                              */
/*---------------------------------------------------------------------------*/

#define SL_REVERBPRESET_NONE		((SLuint16) 0x0000)
#define SL_REVERBPRESET_SMALLROOM	((SLuint16) 0x0001)
#define SL_REVERBPRESET_MEDIUMROOM	((SLuint16) 0x0002)
#define SL_REVERBPRESET_LARGEROOM	((SLuint16) 0x0003)
#define SL_REVERBPRESET_MEDIUMHALL	((SLuint16) 0x0004)
#define SL_REVERBPRESET_LARGEHALL	((SLuint16) 0x0005)
#define SL_REVERBPRESET_PLATE 		((SLuint16) 0x0006)


extern SLAPIENTRY const SLInterfaceID SL_IID_PRESETREVERB;

struct SLPresetReverbItf_;
typedef const struct SLPresetReverbItf_ * const * SLPresetReverbItf;

struct SLPresetReverbItf_ {
	SLresult (*SetPreset) (
		SLPresetReverbItf self,
		SLuint16 preset
	);
	SLresult (*GetPreset) (
		SLPresetReverbItf self,
		SLuint16 *pPreset
	);
};


/*---------------------------------------------------------------------------*/
/* EnvironmentalReverb                                                       */
/*---------------------------------------------------------------------------*/

#define SL_I3DL2_ENVIRONMENT_PRESET_DEFAULT \
	{ SL_MILLIBEL_MIN,    0,  1000,   500, SL_MILLIBEL_MIN,  20, SL_MILLIBEL_MIN,  40, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_GENERIC \
	{ -1000, -100, 1490,  830, -2602,   7,   200,  11, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_PADDEDCELL \
	{ -1000,-6000,  170,  100, -1204,   1,   207,   2, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_ROOM \
	{ -1000, -454,  400,  830, -1646,   2,    53,   3, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_BATHROOM \
	{ -1000,-1200, 1490,  540,  -370,   7,  1030,  11, 1000, 600 }
#define SL_I3DL2_ENVIRONMENT_PRESET_LIVINGROOM \
	{ -1000,-6000,  500,  100, -1376,   3, -1104,   4, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_STONEROOM \
	{ -1000, -300, 2310,  640,  -711,  12,    83,  17, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_AUDITORIUM \
	{ -1000, -476, 4320,  590,  -789,  20,  -289,  30, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_CONCERTHALL \
	{ -1000, -500, 3920,  700, -1230,  20,    -2,  29, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_CAVE \
	{ -1000,    0, 2910, 1300,  -602,  15,  -302,  22, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_ARENA \
	{ -1000, -698, 7240,  330, -1166,  20,    16,  30, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_HANGAR \
	{ -1000,-1000, 10050,  230,  -602,  20,   198,  30, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_CARPETEDHALLWAY \
	{ -1000,-4000,  300,  100, -1831,   2, -1630,  30, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_HALLWAY \
	{ -1000, -300, 1490,  590, -1219,   7,   441,  11, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_STONECORRIDOR \
	{ -1000, -237, 2700,  790, -1214,  13,   395,  20, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_ALLEY \
	{ -1000, -270, 1490,  860, -1204,   7,    -4,  11, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_FOREST \
	{ -1000,-3300, 1490,  540, -2560, 162,  -613,  88,  790,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_CITY \
	{ -1000, -800, 1490,  670, -2273,   7, -2217,  11,  500,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_MOUNTAINS \
	{ -1000,-2500, 1490,  210, -2780, 300, -2014, 100,  270,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_QUARRY \
	{ -1000,-1000, 1490,  830, SL_MILLIBEL_MIN,  61,   500,  25, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_PLAIN \
	{ -1000,-2000, 1490,  500, -2466, 179, -2514, 100,  210,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_PARKINGLOT \
	{ -1000,    0, 1650, 1500, -1363,   8, -1153,  12, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_SEWERPIPE \
	{ -1000,-1000, 2810,  140,   429,  14,   648,  21,  800, 600 }
#define SL_I3DL2_ENVIRONMENT_PRESET_UNDERWATER \
	{ -1000,-4000, 1490,  100,  -449,   7,  1700,  11, 1000,1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_SMALLROOM \
	{ -1000,-600, 1100, 830, -400, 5, 500, 10, 1000, 1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMROOM \
	{ -1000,-600, 1300, 830, -1000, 20, -200, 20, 1000, 1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_LARGEROOM \
	{ -1000,-600, 1500, 830, -1600, 5, -1000, 40, 1000, 1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_MEDIUMHALL \
	{ -1000,-600, 1800, 700, -1300, 15, -800, 30, 1000, 1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_LARGEHALL \
	{ -1000,-600, 1800, 700, -2000, 30, -1400, 60, 1000, 1000 }
#define SL_I3DL2_ENVIRONMENT_PRESET_PLATE \
	{ -1000,-200, 1300, 900, 0, 2, 0, 10, 1000, 750 }


typedef struct SLEnvironmentalReverbSettings_ {
	SLmillibel    roomLevel;
	SLmillibel    roomHFLevel;
	SLmillisecond decayTime;
	SLpermille    decayHFRatio;
	SLmillibel    reflectionsLevel;
	SLmillisecond reflectionsDelay;
	SLmillibel    reverbLevel;
	SLmillisecond reverbDelay;
	SLpermille    diffusion;
	SLpermille    density;
} SLEnvironmentalReverbSettings;




extern SLAPIENTRY const SLInterfaceID SL_IID_ENVIRONMENTALREVERB;


struct SLEnvironmentalReverbItf_;
typedef const struct SLEnvironmentalReverbItf_ * const * SLEnvironmentalReverbItf;

struct SLEnvironmentalReverbItf_ {
	SLresult (*SetRoomLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel room
	);
	SLresult (*GetRoomLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel *pRoom
	);
	SLresult (*SetRoomHFLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel roomHF
	);
	SLresult (*GetRoomHFLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel *pRoomHF
	);
	SLresult (*SetDecayTime) (
		SLEnvironmentalReverbItf self,
		SLmillisecond decayTime
	);
	SLresult (*GetDecayTime) (
		SLEnvironmentalReverbItf self,
		SLmillisecond *pDecayTime
	);
	SLresult (*SetDecayHFRatio) (
		SLEnvironmentalReverbItf self,
		SLpermille decayHFRatio
	);
	SLresult (*GetDecayHFRatio) (
		SLEnvironmentalReverbItf self,
		SLpermille *pDecayHFRatio
	);
	SLresult (*SetReflectionsLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel reflectionsLevel
	);
	SLresult (*GetReflectionsLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel *pReflectionsLevel
	);
	SLresult (*SetReflectionsDelay) (
		SLEnvironmentalReverbItf self,
		SLmillisecond reflectionsDelay
	);
	SLresult (*GetReflectionsDelay) (
		SLEnvironmentalReverbItf self,
		SLmillisecond *pReflectionsDelay
	);
	SLresult (*SetReverbLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel reverbLevel
	);
	SLresult (*GetReverbLevel) (
		SLEnvironmentalReverbItf self,
		SLmillibel *pReverbLevel
	);
	SLresult (*SetReverbDelay) (
		SLEnvironmentalReverbItf self,
		SLmillisecond reverbDelay
	);
	SLresult (*GetReverbDelay) (
		SLEnvironmentalReverbItf self,
		SLmillisecond *pReverbDelay
	);
	SLresult (*SetDiffusion) (
		SLEnvironmentalReverbItf self,
		SLpermille diffusion
	);
	SLresult (*GetDiffusion) (
		SLEnvironmentalReverbItf self,
		SLpermille *pDiffusion
	);
	SLresult (*SetDensity) (
		SLEnvironmentalReverbItf self,
		SLpermille density
	);
	SLresult (*GetDensity) (
		SLEnvironmentalReverbItf self,
		SLpermille *pDensity
	);
	SLresult (*SetEnvironmentalReverbProperties) (
		SLEnvironmentalReverbItf self,
		const SLEnvironmentalReverbSettings *pProperties
	);
	SLresult (*GetEnvironmentalReverbProperties) (
		SLEnvironmentalReverbItf self,
		SLEnvironmentalReverbSettings *pProperties
	);
};

/*---------------------------------------------------------------------------*/
/* Effects Send Interface                                                    */
/*---------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_EFFECTSEND;

struct SLEffectSendItf_;
typedef const struct SLEffectSendItf_ * const * SLEffectSendItf;

struct SLEffectSendItf_ {
	SLresult (*EnableEffectSend) (
		SLEffectSendItf self,
		const void *pAuxEffect,
		SLboolean enable,
		SLmillibel initialLevel
	);
	SLresult (*IsEnabled) (
		SLEffectSendItf self,
		const void * pAuxEffect,
		SLboolean *pEnable
	);
	SLresult (*SetDirectLevel) (
		SLEffectSendItf self,
		SLmillibel directLevel
	);
	SLresult (*GetDirectLevel) (
		SLEffectSendItf self,
		SLmillibel *pDirectLevel
	);
	SLresult (*SetSendLevel) (
		SLEffectSendItf self,
		const void *pAuxEffect,
		SLmillibel sendLevel
	);
	SLresult (*GetSendLevel)(
		SLEffectSendItf self,
		const void *pAuxEffect,
		SLmillibel *pSendLevel
	);
};


/*---------------------------------------------------------------------------*/
/* 3D Grouping Interface                                                     */
/*---------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_3DGROUPING;


struct SL3DGroupingItf_ ;
typedef const struct SL3DGroupingItf_ * const * SL3DGroupingItf;

struct SL3DGroupingItf_ {
	SLresult (*Set3DGroup) (
		SL3DGroupingItf self,
		SLObjectItf group
	);
	SLresult (*Get3DGroup) (
		SL3DGroupingItf self,
		SLObjectItf *pGroup
	);
};


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


extern SLAPIENTRY const SLInterfaceID SL_IID_3DCOMMIT;

struct SL3DCommitItf_;
typedef const struct SL3DCommitItf_* const * SL3DCommitItf;

struct SL3DCommitItf_ {
	SLresult (*Commit) (
		SL3DCommitItf self
	);
	SLresult (*SetDeferred) (
		SL3DCommitItf self,
		SLboolean deferred
	);
};


/*---------------------------------------------------------------------------*/
/* 3D Location Interface                                                     */
/*---------------------------------------------------------------------------*/

typedef struct SLVec3D_ {
	SLint32	x;
	SLint32	y;
	SLint32	z;
} SLVec3D;

extern SLAPIENTRY const SLInterfaceID SL_IID_3DLOCATION;

struct SL3DLocationItf_;
typedef const struct SL3DLocationItf_ * const * SL3DLocationItf;

struct SL3DLocationItf_ {
	SLresult (*SetLocationCartesian) (
		SL3DLocationItf self,
		const SLVec3D *pLocation
	);
	SLresult (*SetLocationSpherical) (
		SL3DLocationItf self,
		SLmillidegree azimuth,
		SLmillidegree elevation,
		SLmillimeter distance
	);
	SLresult (*Move) (
		SL3DLocationItf self,
		const SLVec3D *pMovement
	);
	SLresult (*GetLocationCartesian) (
		SL3DLocationItf self,
		SLVec3D *pLocation
	);
	SLresult (*SetOrientationVectors) (
		SL3DLocationItf self,
		const SLVec3D *pFront,
		const SLVec3D *pAbove
	);
	SLresult (*SetOrientationAngles) (
		SL3DLocationItf self,
		SLmillidegree heading,
		SLmillidegree pitch,
		SLmillidegree roll
	);
	SLresult (*Rotate) (
		SL3DLocationItf self,
		SLmillidegree theta,
		const SLVec3D *pAxis
	);
	SLresult (*GetOrientationVectors) (
		SL3DLocationItf self,
		SLVec3D *pFront,
		SLVec3D *pUp
	);
};


/*---------------------------------------------------------------------------*/
/* 3D Doppler Interface                                                      */
/*---------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_3DDOPPLER;

struct SL3DDopplerItf_;
typedef const struct SL3DDopplerItf_ * const * SL3DDopplerItf;

struct SL3DDopplerItf_ {
	SLresult (*SetVelocityCartesian) (
		SL3DDopplerItf self,
		const SLVec3D *pVelocity
	);
	SLresult (*SetVelocitySpherical) (
		SL3DDopplerItf self,
		SLmillidegree azimuth,
		SLmillidegree elevation,
		SLmillimeter speed
	);
	SLresult (*GetVelocityCartesian) (
		SL3DDopplerItf self,
		SLVec3D *pVelocity
	);
	SLresult (*SetDopplerFactor) (
		SL3DDopplerItf self,
		SLpermille dopplerFactor
	);
	SLresult (*GetDopplerFactor) (
		SL3DDopplerItf self,
		SLpermille *pDopplerFactor
	);
};

/*---------------------------------------------------------------------------*/
/* 3D Source Interface and associated defines                                */
/* --------------------------------------------------------------------------*/

#define SL_ROLLOFFMODEL_EXPONENTIAL	((SLuint32) 0x00000000)
#define SL_ROLLOFFMODEL_LINEAR		((SLuint32) 0x00000001)


extern SLAPIENTRY const SLInterfaceID SL_IID_3DSOURCE;

struct SL3DSourceItf_;
typedef const struct SL3DSourceItf_ * const * SL3DSourceItf;

struct SL3DSourceItf_ {
	SLresult (*SetHeadRelative) (
		SL3DSourceItf self,
		SLboolean headRelative
	);
	SLresult (*GetHeadRelative) (
		SL3DSourceItf self,
		SLboolean *pHeadRelative
	);
	SLresult (*SetRolloffDistances) (
		SL3DSourceItf self,
		SLmillimeter minDistance,
		SLmillimeter maxDistance
	);
	SLresult (*GetRolloffDistances) (
		SL3DSourceItf self,
		SLmillimeter *pMinDistance,
		SLmillimeter *pMaxDistance
	);
	SLresult (*SetRolloffMaxDistanceMute) (
		SL3DSourceItf self,
		SLboolean mute
	);
	SLresult (*GetRolloffMaxDistanceMute) (
		SL3DSourceItf self,
		SLboolean *pMute
	);
	SLresult (*SetRolloffFactor) (
		SL3DSourceItf self,
		SLpermille rolloffFactor
	);
	SLresult (*GetRolloffFactor) (
		SL3DSourceItf self,
		SLpermille *pRolloffFactor
	);
	SLresult (*SetRoomRolloffFactor) (
		SL3DSourceItf self,
		SLpermille roomRolloffFactor
	);
	SLresult (*GetRoomRolloffFactor) (
		SL3DSourceItf self,
		SLpermille *pRoomRolloffFactor
	);
	SLresult (*SetRolloffModel) (
		SL3DSourceItf self,
		SLuint8 model
	);
	SLresult (*GetRolloffModel) (
		SL3DSourceItf self,
		SLuint8 *pModel
	);
	SLresult (*SetCone) (
		SL3DSourceItf self,
		SLmillidegree innerAngle,
		SLmillidegree outerAngle,
		SLmillibel outerLevel
	);
	SLresult (*GetCone) (
		SL3DSourceItf self,
		SLmillidegree *pInnerAngle,
		SLmillidegree *pOuterAngle,
		SLmillibel *pOuterLevel
	);
};

/*---------------------------------------------------------------------------*/
/* 3D Macroscopic Interface                                                  */
/* --------------------------------------------------------------------------*/

extern SLAPIENTRY const SLInterfaceID SL_IID_3DMACROSCOPIC;

struct SL3DMacroscopicItf_;
typedef const struct SL3DMacroscopicItf_ * const * SL3DMacroscopicItf;

struct SL3DMacroscopicItf_ {
	SLresult (*SetSize) (
		SL3DMacroscopicItf self,
		SLmillimeter width,
		SLmillimeter height,
		SLmillimeter depth
	);
	SLresult (*GetSize) (
		SL3DMacroscopicItf self,
		SLmillimeter *pWidth,
		SLmillimeter *pHeight,
		SLmillimeter *pDepth
	);
	SLresult (*SetOrientationAngles) (
		SL3DMacroscopicItf self,
		SLmillidegree heading,
		SLmillidegree pitch,
		SLmillidegree roll
	);
	SLresult (*SetOrientationVectors) (
		SL3DMacroscopicItf self,
		const SLVec3D *pFront,
		const SLVec3D *pAbove
	);
	SLresult (*Rotate) (
		SL3DMacroscopicItf self,
		SLmillidegree theta,
		const SLVec3D *pAxis
	);
	SLresult (*GetOrientationVectors) (
		SL3DMacroscopicItf self,
		SLVec3D *pFront,
		SLVec3D *pUp
	);
};

/*---------------------------------------------------------------------------*/
/* Mute Solo Interface                                                       */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_MUTESOLO;

struct SLMuteSoloItf_;
typedef const struct SLMuteSoloItf_ * const * SLMuteSoloItf;

struct SLMuteSoloItf_ {
	SLresult (*SetChannelMute) (
		SLMuteSoloItf self,
		SLuint8 chan,
		SLboolean mute
	);
	SLresult (*GetChannelMute) (
		SLMuteSoloItf self,
		SLuint8 chan,
		SLboolean *pMute
	);
	SLresult (*SetChannelSolo) (
		SLMuteSoloItf self,
		SLuint8 chan,
		SLboolean solo
	);
	SLresult (*GetChannelSolo) (
		SLMuteSoloItf self,
		SLuint8 chan,
		SLboolean *pSolo
	);
	SLresult (*GetNumChannels) (
		SLMuteSoloItf self,
		SLuint8 *pNumChannels
	);
};


/*---------------------------------------------------------------------------*/
/* Dynamic Interface Management Interface and associated types and macros    */
/* --------------------------------------------------------------------------*/

#define SL_DYNAMIC_ITF_EVENT_RUNTIME_ERROR			((SLuint32) 0x00000001)
#define SL_DYNAMIC_ITF_EVENT_ASYNC_TERMINATION		((SLuint32) 0x00000002)
#define SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST			((SLuint32) 0x00000003)
#define SL_DYNAMIC_ITF_EVENT_RESOURCES_LOST_PERMANENTLY	((SLuint32) 0x00000004)
#define SL_DYNAMIC_ITF_EVENT_RESOURCES_AVAILABLE		((SLuint32) 0x00000005)




extern SLAPIENTRY const SLInterfaceID SL_IID_DYNAMICINTERFACEMANAGEMENT;

struct SLDynamicInterfaceManagementItf_;
typedef const struct SLDynamicInterfaceManagementItf_ * const * SLDynamicInterfaceManagementItf;

typedef void (/*SLAPIENTRY*/ *slDynamicInterfaceManagementCallback) (
	SLDynamicInterfaceManagementItf caller,
	void * pContext,
	SLuint32 event,
	SLresult result,
    const SLInterfaceID iid
);


struct SLDynamicInterfaceManagementItf_ {
	SLresult (*AddInterface) (
		SLDynamicInterfaceManagementItf self,
		const SLInterfaceID iid,
		SLboolean async
	);
	SLresult (*RemoveInterface) (
		SLDynamicInterfaceManagementItf self,
		const SLInterfaceID iid
	);
	SLresult (*ResumeInterface) (
		SLDynamicInterfaceManagementItf self,
		const SLInterfaceID iid,
		SLboolean async
	);
	SLresult (*RegisterCallback) (
		SLDynamicInterfaceManagementItf self,
		slDynamicInterfaceManagementCallback callback,
		void * pContext
	);
};

/*---------------------------------------------------------------------------*/
/* Midi Message Interface and associated types                               */
/* --------------------------------------------------------------------------*/

#define SL_MIDIMESSAGETYPE_NOTE_ON_OFF		((SLuint32) 0x00000001)
#define SL_MIDIMESSAGETYPE_POLY_PRESSURE	((SLuint32) 0x00000002)
#define SL_MIDIMESSAGETYPE_CONTROL_CHANGE	((SLuint32) 0x00000003)
#define SL_MIDIMESSAGETYPE_PROGRAM_CHANGE	((SLuint32) 0x00000004)
#define SL_MIDIMESSAGETYPE_CHANNEL_PRESSURE	((SLuint32) 0x00000005)
#define SL_MIDIMESSAGETYPE_PITCH_BEND		((SLuint32) 0x00000006)
#define SL_MIDIMESSAGETYPE_SYSTEM_MESSAGE	((SLuint32) 0x00000007)


extern SLAPIENTRY const SLInterfaceID SL_IID_MIDIMESSAGE;

struct SLMIDIMessageItf_;
typedef const struct SLMIDIMessageItf_ * const * SLMIDIMessageItf;

typedef void (/*SLAPIENTRY*/ *slMetaEventCallback) (
	SLMIDIMessageItf caller,
	void *pContext,
	SLuint8 type,
    SLuint32 length,
	const SLuint8 *pData,
	SLuint32 tick,
	SLuint16 track
);

typedef void (/*SLAPIENTRY*/ *slMIDIMessageCallback) (
	SLMIDIMessageItf caller,
	void *pContext,
	SLuint8 statusByte,
	SLuint32 length,
	const SLuint8 *pData,
	SLuint32 tick,
	SLuint16 track
);

struct SLMIDIMessageItf_ {
	SLresult (*SendMessage) (
		SLMIDIMessageItf self,
		const SLuint8 *data,
		SLuint32 length
	);
	SLresult (*RegisterMetaEventCallback) (
		SLMIDIMessageItf self,
		slMetaEventCallback callback,
		void *pContext
	);
	SLresult (*RegisterMIDIMessageCallback) (
		SLMIDIMessageItf self,
		slMIDIMessageCallback callback,
		void *pContext
	);
	SLresult (*AddMIDIMessageCallbackFilter) (
		SLMIDIMessageItf self,
		SLuint32 messageType
	);
	SLresult (*ClearMIDIMessageCallbackFilter) (
		SLMIDIMessageItf self
	);
};


/*---------------------------------------------------------------------------*/
/* Midi Mute Solo interface                                                  */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_MIDIMUTESOLO;

struct SLMIDIMuteSoloItf_;
typedef const struct SLMIDIMuteSoloItf_ * const * SLMIDIMuteSoloItf;

struct SLMIDIMuteSoloItf_ {
	SLresult (*SetChannelMute) (
		SLMIDIMuteSoloItf self,
		SLuint8 channel,
		SLboolean mute
	);
	SLresult (*GetChannelMute) (
		SLMIDIMuteSoloItf self,
		SLuint8 channel,
		SLboolean *pMute
	);
	SLresult (*SetChannelSolo) (
		SLMIDIMuteSoloItf self,
		SLuint8 channel,
		SLboolean solo
	);
	SLresult (*GetChannelSolo) (
		SLMIDIMuteSoloItf self,
		SLuint8 channel,
		SLboolean *pSolo
	);
	SLresult (*GetTrackCount) (
		SLMIDIMuteSoloItf self,
		SLuint16 *pCount
	);
	SLresult (*SetTrackMute) (
		SLMIDIMuteSoloItf self,
		SLuint16 track,
		SLboolean mute
	);
	SLresult (*GetTrackMute) (
		SLMIDIMuteSoloItf self,
		SLuint16 track,
		SLboolean *pMute
	);
	SLresult (*SetTrackSolo) (
		SLMIDIMuteSoloItf self,
		SLuint16 track,
		SLboolean solo
	);
	SLresult (*GetTrackSolo) (
		SLMIDIMuteSoloItf self,
		SLuint16 track,
		SLboolean *pSolo
	);
};


/*---------------------------------------------------------------------------*/
/* Midi Tempo interface                                                      */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_MIDITEMPO;

struct SLMIDITempoItf_;
typedef const struct SLMIDITempoItf_ * const * SLMIDITempoItf;

struct SLMIDITempoItf_ {
	SLresult (*SetTicksPerQuarterNote) (
		SLMIDITempoItf self,
		SLuint32 tpqn
	);
	SLresult (*GetTicksPerQuarterNote) (
		SLMIDITempoItf self,
		SLuint32 *pTpqn
	);
	SLresult (*SetMicrosecondsPerQuarterNote) (
		SLMIDITempoItf self,
		SLmicrosecond uspqn
	);
	SLresult (*GetMicrosecondsPerQuarterNote) (
		SLMIDITempoItf self,
		SLmicrosecond *uspqn
	);
};


/*---------------------------------------------------------------------------*/
/* Midi Time interface                                                       */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_MIDITIME;

struct SLMIDITimeItf_;
typedef const struct SLMIDITimeItf_ * const * SLMIDITimeItf;

struct SLMIDITimeItf_ {
	SLresult (*GetDuration) (
		SLMIDITimeItf self,
		SLuint32 *pDuration
	);
	SLresult (*SetPosition) (
		SLMIDITimeItf self,
		SLuint32 position
	);
	SLresult (*GetPosition) (
		SLMIDITimeItf self,
		SLuint32 *pPosition
	);
	SLresult (*SetLoopPoints) (
		SLMIDITimeItf self,
		SLuint32 startTick,
		SLuint32 numTicks
	);
	SLresult (*GetLoopPoints) (
		SLMIDITimeItf self,
		SLuint32 *pStartTick,
		SLuint32 *pNumTicks
	);
};


/*---------------------------------------------------------------------------*/
/* Audio Decoder Capabilities Interface                                      */
/* --------------------------------------------------------------------------*/

/*Audio Codec related defines*/

#define SL_RATECONTROLMODE_CONSTANTBITRATE	((SLuint32) 0x00000001)
#define SL_RATECONTROLMODE_VARIABLEBITRATE	((SLuint32) 0x00000002)

#define SL_AUDIOCODEC_PCM         ((SLuint32) 0x00000001)
#define SL_AUDIOCODEC_MP3         ((SLuint32) 0x00000002)
#define SL_AUDIOCODEC_AMR         ((SLuint32) 0x00000003)
#define SL_AUDIOCODEC_AMRWB       ((SLuint32) 0x00000004)
#define SL_AUDIOCODEC_AMRWBPLUS   ((SLuint32) 0x00000005)
#define SL_AUDIOCODEC_AAC         ((SLuint32) 0x00000006)
#define SL_AUDIOCODEC_WMA         ((SLuint32) 0x00000007)
#define SL_AUDIOCODEC_REAL        ((SLuint32) 0x00000008)

#define SL_AUDIOPROFILE_PCM                   ((SLuint32) 0x00000001)

#define SL_AUDIOPROFILE_MPEG1_L3              ((SLuint32) 0x00000001)
#define SL_AUDIOPROFILE_MPEG2_L3              ((SLuint32) 0x00000002)
#define SL_AUDIOPROFILE_MPEG25_L3             ((SLuint32) 0x00000003)

#define SL_AUDIOCHANMODE_MP3_MONO             ((SLuint32) 0x00000001)
#define SL_AUDIOCHANMODE_MP3_STEREO           ((SLuint32) 0x00000002)
#define SL_AUDIOCHANMODE_MP3_JOINTSTEREO      ((SLuint32) 0x00000003)
#define SL_AUDIOCHANMODE_MP3_DUAL             ((SLuint32) 0x00000004)

#define SL_AUDIOPROFILE_AMR			((SLuint32) 0x00000001)

#define SL_AUDIOSTREAMFORMAT_CONFORMANCE	((SLuint32) 0x00000001)
#define SL_AUDIOSTREAMFORMAT_IF1			((SLuint32) 0x00000002)
#define SL_AUDIOSTREAMFORMAT_IF2			((SLuint32) 0x00000003)
#define SL_AUDIOSTREAMFORMAT_FSF			((SLuint32) 0x00000004)
#define SL_AUDIOSTREAMFORMAT_RTPPAYLOAD	((SLuint32) 0x00000005)
#define SL_AUDIOSTREAMFORMAT_ITU			((SLuint32) 0x00000006)

#define SL_AUDIOPROFILE_AMRWB			((SLuint32) 0x00000001)

#define SL_AUDIOPROFILE_AMRWBPLUS		((SLuint32) 0x00000001)

#define SL_AUDIOPROFILE_AAC_AAC			((SLuint32) 0x00000001)

#define SL_AUDIOMODE_AAC_MAIN			((SLuint32) 0x00000001)
#define SL_AUDIOMODE_AAC_LC			((SLuint32) 0x00000002)
#define SL_AUDIOMODE_AAC_SSR			((SLuint32) 0x00000003)
#define SL_AUDIOMODE_AAC_LTP			((SLuint32) 0x00000004)
#define SL_AUDIOMODE_AAC_HE			((SLuint32) 0x00000005)
#define SL_AUDIOMODE_AAC_SCALABLE		((SLuint32) 0x00000006)
#define SL_AUDIOMODE_AAC_ERLC			((SLuint32) 0x00000007)
#define SL_AUDIOMODE_AAC_LD			((SLuint32) 0x00000008)
#define SL_AUDIOMODE_AAC_HE_PS			((SLuint32) 0x00000009)
#define SL_AUDIOMODE_AAC_HE_MPS			((SLuint32) 0x0000000A)

#define SL_AUDIOSTREAMFORMAT_MP2ADTS		((SLuint32) 0x00000001)
#define SL_AUDIOSTREAMFORMAT_MP4ADTS		((SLuint32) 0x00000002)
#define SL_AUDIOSTREAMFORMAT_MP4LOAS		((SLuint32) 0x00000003)
#define SL_AUDIOSTREAMFORMAT_MP4LATM		((SLuint32) 0x00000004)
#define SL_AUDIOSTREAMFORMAT_ADIF		((SLuint32) 0x00000005)
#define SL_AUDIOSTREAMFORMAT_MP4FF		((SLuint32) 0x00000006)
#define SL_AUDIOSTREAMFORMAT_RAW			((SLuint32) 0x00000007)

#define SL_AUDIOPROFILE_WMA7		((SLuint32) 0x00000001)
#define SL_AUDIOPROFILE_WMA8		((SLuint32) 0x00000002)
#define SL_AUDIOPROFILE_WMA9		((SLuint32) 0x00000003)
#define SL_AUDIOPROFILE_WMA10		((SLuint32) 0x00000004)

#define SL_AUDIOMODE_WMA_LEVEL1		((SLuint32) 0x00000001)
#define SL_AUDIOMODE_WMA_LEVEL2		((SLuint32) 0x00000002)
#define SL_AUDIOMODE_WMA_LEVEL3		((SLuint32) 0x00000003)
#define SL_AUDIOMODE_WMA_LEVEL4		((SLuint32) 0x00000004)
#define SL_AUDIOMODE_WMAPRO_LEVELM0	((SLuint32) 0x00000005)
#define SL_AUDIOMODE_WMAPRO_LEVELM1	((SLuint32) 0x00000006)
#define SL_AUDIOMODE_WMAPRO_LEVELM2	((SLuint32) 0x00000007)
#define SL_AUDIOMODE_WMAPRO_LEVELM3	((SLuint32) 0x00000008)

#define SL_AUDIOPROFILE_REALAUDIO		((SLuint32) 0x00000001)

#define SL_AUDIOMODE_REALAUDIO_G2		((SLuint32) 0x00000001)
#define SL_AUDIOMODE_REALAUDIO_8			((SLuint32) 0x00000002)
#define SL_AUDIOMODE_REALAUDIO_10		((SLuint32) 0x00000003)
#define SL_AUDIOMODE_REALAUDIO_SURROUND	((SLuint32) 0x00000004)

typedef struct SLAudioCodecDescriptor_ {
    SLuint32      maxChannels;
    SLuint32      minBitsPerSample;
    SLuint32      maxBitsPerSample;
    SLmilliHertz  minSampleRate;
    SLmilliHertz  maxSampleRate;
    SLboolean     isFreqRangeContinuous;
    SLmilliHertz *pSampleRatesSupported;
    SLuint32      numSampleRatesSupported;
    SLuint32      minBitRate;
    SLuint32      maxBitRate;
    SLboolean     isBitrateRangeContinuous;
    SLuint32     *pBitratesSupported;
    SLuint32      numBitratesSupported;
    SLuint32	  profileSetting;
    SLuint32      modeSetting;
} SLAudioCodecDescriptor;

/*Structure used to retrieve the profile and level settings supported by an audio encoder */

typedef struct SLAudioCodecProfileMode_ {
    SLuint32 profileSetting;
    SLuint32 modeSetting;
} SLAudioCodecProfileMode;

extern SLAPIENTRY const SLInterfaceID SL_IID_AUDIODECODERCAPABILITIES;

struct SLAudioDecoderCapabilitiesItf_;
typedef const struct SLAudioDecoderCapabilitiesItf_ * const * SLAudioDecoderCapabilitiesItf;

struct SLAudioDecoderCapabilitiesItf_ {
    SLresult (*GetAudioDecoders) (
        SLAudioDecoderCapabilitiesItf self,
        SLuint32 * pNumDecoders ,
        SLuint32 *pDecoderIds
    );
    SLresult (*GetAudioDecoderCapabilities) (
        SLAudioDecoderCapabilitiesItf self,
        SLuint32 decoderId,
        SLuint32 *pIndex,
        SLAudioCodecDescriptor *pDescriptor
    );
};




/*---------------------------------------------------------------------------*/
/* Audio Encoder Capabilities Interface                                      */
/* --------------------------------------------------------------------------*/

/* Structure used when setting audio encoding parameters */

typedef struct SLAudioEncoderSettings_ {
    SLuint32 encoderId;
    SLuint32 channelsIn;
    SLuint32 channelsOut;
    SLmilliHertz sampleRate;
    SLuint32 bitRate;
    SLuint32 bitsPerSample;
    SLuint32 rateControl;
    SLuint32 profileSetting;
    SLuint32 levelSetting;
    SLuint32 channelMode;
    SLuint32 streamFormat;
    SLuint32 encodeOptions;
    SLuint32 blockAlignment;
} SLAudioEncoderSettings;

extern SLAPIENTRY const SLInterfaceID SL_IID_AUDIOENCODERCAPABILITIES;

struct SLAudioEncoderCapabilitiesItf_;
typedef const struct SLAudioEncoderCapabilitiesItf_ * const * SLAudioEncoderCapabilitiesItf;

struct SLAudioEncoderCapabilitiesItf_ {
    SLresult (*GetAudioEncoders) (
        SLAudioEncoderCapabilitiesItf self,
        SLuint32 *pNumEncoders ,
        SLuint32 *pEncoderIds
    );
    SLresult (*GetAudioEncoderCapabilities) (
        SLAudioEncoderCapabilitiesItf self,
        SLuint32 encoderId,
        SLuint32 *pIndex,
        SLAudioCodecDescriptor * pDescriptor
    );
};


/*---------------------------------------------------------------------------*/
/* Audio Encoder Interface                                                   */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_AUDIOENCODER;

struct SLAudioEncoderItf_;
typedef const struct SLAudioEncoderItf_ * const * SLAudioEncoderItf;

struct SLAudioEncoderItf_ {
    SLresult (*SetEncoderSettings) (
        SLAudioEncoderItf		self,
        SLAudioEncoderSettings 	*pSettings
    );
    SLresult (*GetEncoderSettings) (
        SLAudioEncoderItf		self,
        SLAudioEncoderSettings	*pSettings
    );
};


/*---------------------------------------------------------------------------*/
/* Bass Boost Interface                                                      */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_BASSBOOST;

struct SLBassBoostItf_;
typedef const struct SLBassBoostItf_ * const * SLBassBoostItf;

struct SLBassBoostItf_ {
	SLresult (*SetEnabled)(
		SLBassBoostItf self,
		SLboolean enabled
	);
	SLresult (*IsEnabled)(
		SLBassBoostItf self,
		SLboolean *pEnabled
	);
	SLresult (*SetStrength)(
		SLBassBoostItf self,
		SLpermille strength
	);
	SLresult (*GetRoundedStrength)(
		SLBassBoostItf self,
		SLpermille *pStrength
	);
	SLresult (*IsStrengthSupported)(
		SLBassBoostItf self,
		SLboolean *pSupported
	);
};

/*---------------------------------------------------------------------------*/
/* Pitch Interface                                                           */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_PITCH;

struct SLPitchItf_;
typedef const struct SLPitchItf_ * const * SLPitchItf;

struct SLPitchItf_ {
	SLresult (*SetPitch) (
		SLPitchItf self,
		SLpermille pitch
	);
	SLresult (*GetPitch) (
		SLPitchItf self,
		SLpermille *pPitch
	);
	SLresult (*GetPitchCapabilities) (
		SLPitchItf self,
		SLpermille *pMinPitch,
		SLpermille *pMaxPitch
	);
};


/*---------------------------------------------------------------------------*/
/* Rate Pitch Interface                                                      */
/* RatePitchItf is an interface for controlling the rate a sound is played   */
/* back. A change in rate will cause a change in pitch.                      */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_RATEPITCH;

struct SLRatePitchItf_;
typedef const struct SLRatePitchItf_ * const * SLRatePitchItf;

struct SLRatePitchItf_ {
	SLresult (*SetRate) (
		SLRatePitchItf self,
		SLpermille rate
	);
	SLresult (*GetRate) (
		SLRatePitchItf self,
		SLpermille *pRate
	);
	SLresult (*GetRatePitchCapabilities) (
		SLRatePitchItf self,
		SLpermille *pMinRate,
		SLpermille *pMaxRate
	);
};


/*---------------------------------------------------------------------------*/
/* Virtualizer Interface                                                      */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_VIRTUALIZER;

struct SLVirtualizerItf_;
typedef const struct SLVirtualizerItf_ * const * SLVirtualizerItf;

struct SLVirtualizerItf_ {
	SLresult (*SetEnabled)(
		SLVirtualizerItf self,
		SLboolean enabled
	);
	SLresult (*IsEnabled)(
		SLVirtualizerItf self,
		SLboolean *pEnabled
	);
	SLresult (*SetStrength)(
		SLVirtualizerItf self,
		SLpermille strength
	);
	SLresult (*GetRoundedStrength)(
		SLVirtualizerItf self,
		SLpermille *pStrength
	);
	SLresult (*IsStrengthSupported)(
		SLVirtualizerItf self,
		SLboolean *pSupported
	);
};

/*---------------------------------------------------------------------------*/
/* Visualization Interface                                                   */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_VISUALIZATION;

struct SLVisualizationItf_;
typedef const struct SLVisualizationItf_ * const * SLVisualizationItf;

typedef void (/*SLAPIENTRY*/ *slVisualizationCallback) (
	void *pContext,
	const SLuint8 waveform[],
	const SLuint8 fft[],
	SLmilliHertz samplerate
);

struct SLVisualizationItf_{
	SLresult (*RegisterVisualizationCallback)(
		SLVisualizationItf self,
		slVisualizationCallback callback,
		void *pContext,
		SLmilliHertz rate
	);
	SLresult (*GetMaxRate)(
		SLVisualizationItf self,
		SLmilliHertz* pRate
	);
};


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


extern SLAPIENTRY const SLInterfaceID SL_IID_ENGINE;

struct SLEngineItf_;
typedef const struct SLEngineItf_ * const * SLEngineItf;


struct SLEngineItf_ {

	SLresult (*CreateLEDDevice) (
		SLEngineItf self,
		SLObjectItf * pDevice,
		SLuint32 deviceID,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateVibraDevice) (
		SLEngineItf self,
		SLObjectItf * pDevice,
		SLuint32 deviceID,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateAudioPlayer) (
		SLEngineItf self,
		SLObjectItf * pPlayer,
		SLDataSource *pAudioSrc,
		SLDataSink *pAudioSnk,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateAudioRecorder) (
		SLEngineItf self,
		SLObjectItf * pRecorder,
		SLDataSource *pAudioSrc,
		SLDataSink *pAudioSnk,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateMidiPlayer) (
		SLEngineItf self,
		SLObjectItf * pPlayer,
		SLDataSource *pMIDISrc,
		SLDataSource *pBankSrc,
		SLDataSink *pAudioOutput,
		SLDataSink *pVibra,
		SLDataSink *pLEDArray,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateListener) (
		SLEngineItf self,
		SLObjectItf * pListener,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*Create3DGroup) (
		SLEngineItf self,
		SLObjectItf * pGroup,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateOutputMix) (
		SLEngineItf self,
		SLObjectItf * pMix,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
	SLresult (*CreateMetadataExtractor) (
		SLEngineItf self,
		SLObjectItf * pMetadataExtractor,
		SLDataSource * pDataSource,
		SLuint32 numInterfaces,
		const SLInterfaceID * pInterfaceIds,
		const SLboolean * pInterfaceRequired
	);
    SLresult (*CreateExtensionObject) (
        SLEngineItf self,
        SLObjectItf * pObject,
        void * pParameters,
        SLuint32 objectID,
        SLuint32 numInterfaces,
        const SLInterfaceID * pInterfaceIds,
        const SLboolean * pInterfaceRequired
    );
	SLresult (*QueryNumSupportedInterfaces) (
		SLEngineItf self,
		SLuint32 objectID,
		SLuint32 * pNumSupportedInterfaces
	);
	SLresult (*QuerySupportedInterfaces) (
		SLEngineItf self,
		SLuint32 objectID,
		SLuint32 index,
		SLInterfaceID * pInterfaceId
	);
    SLresult (*QueryNumSupportedExtensions) (
        SLEngineItf self,
        SLuint32 * pNumExtensions
    );
    SLresult (*QuerySupportedExtension) (
        SLEngineItf self,
        SLuint32 index,
        SLchar * pExtensionName,
        SLint16 * pNameLength
    );
    SLresult (*IsExtensionSupported) (
        SLEngineItf self,
        const SLchar * pExtensionName,
        SLboolean * pSupported
    );
};


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


extern SLAPIENTRY const SLInterfaceID SL_IID_ENGINECAPABILITIES;

struct SLEngineCapabilitiesItf_;
typedef const struct SLEngineCapabilitiesItf_ * const * SLEngineCapabilitiesItf;

struct SLEngineCapabilitiesItf_ {
	SLresult (*QuerySupportedProfiles) (
		SLEngineCapabilitiesItf self,
		SLuint16 *pProfilesSupported
	);
	SLresult (*QueryAvailableVoices) (
		SLEngineCapabilitiesItf self,
		SLuint16 voiceType,
		SLint16 *pNumMaxVoices,
		SLboolean *pIsAbsoluteMax,
		SLint16 *pNumFreeVoices
	);
	SLresult (*QueryNumberOfMIDISynthesizers) (
		SLEngineCapabilitiesItf self,
		SLint16 *pNumMIDIsynthesizers
	);
	SLresult (*QueryAPIVersion) (
		SLEngineCapabilitiesItf self,
		SLint16 *pMajor,
		SLint16 *pMinor,
		SLint16 *pStep
	);
	SLresult (*QueryLEDCapabilities) (
		SLEngineCapabilitiesItf self,
        SLuint32 *pIndex,
		SLuint32 *pLEDDeviceID,
		SLLEDDescriptor *pDescriptor
	);
	SLresult (*QueryVibraCapabilities) (
		SLEngineCapabilitiesItf self,
        SLuint32 *pIndex,
		SLuint32 *pVibraDeviceID,
		SLVibraDescriptor *pDescriptor
	);
	SLresult (*IsThreadSafe) (
		SLEngineCapabilitiesItf self,
		SLboolean *pIsThreadSafe
	);
};

/*---------------------------------------------------------------------------*/
/* Thread Sync Interface                                                     */
/* --------------------------------------------------------------------------*/


extern SLAPIENTRY const SLInterfaceID SL_IID_THREADSYNC;

struct SLThreadSyncItf_;
typedef const struct SLThreadSyncItf_ * const * SLThreadSyncItf;


struct SLThreadSyncItf_ {
	SLresult (*EnterCriticalSection) (
		SLThreadSyncItf self
	);
	SLresult (*ExitCriticalSection) (
		SLThreadSyncItf self
	);
};


/*****************************************************************************/
/* SL engine constructor                                                     */
/*****************************************************************************/

#define SL_ENGINEOPTION_THREADSAFE	((SLuint32) 0x00000001)
#define SL_ENGINEOPTION_LOSSOFCONTROL	((SLuint32) 0x00000002)

typedef struct SLEngineOption_ {
	SLuint32 feature;
	SLuint32 data;
} SLEngineOption;


SLresult SLAPIENTRY slCreateEngine(
	SLObjectItf             *pEngine,
	SLuint32                numOptions,
	const SLEngineOption    *pEngineOptions,
	SLuint32                numInterfaces,
	const SLInterfaceID     *pInterfaceIds,
	const SLboolean         * pInterfaceRequired
);

SLresult SLAPIENTRY slQueryNumSupportedEngineInterfaces(
	SLuint32 * pNumSupportedInterfaces
);

SLresult SLAPIENTRY slQuerySupportedEngineInterfaces(
	SLuint32 index,
	SLInterfaceID * pInterfaceId
);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif /* OPENSL_ES_H_ */
