/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* Engine implementation */
#include "sles_allinclusive.h"
static SLresult IEngine_CreateLEDDevice(SLEngineItf self, SLObjectItf *pDevice, SLuint32 deviceID,
SLuint32 numInterfaces, const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & USE_PROFILES_OPTIONAL
if ((NULL == pDevice) || (SL_DEFAULTDEVICEID_LED != deviceID)) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pDevice = NULL;
unsigned exposedMask;
const ClassTable *pCLEDDevice_class = objectIDtoClass(SL_OBJECTID_LEDDEVICE);
if (NULL == pCLEDDevice_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCLEDDevice_class, numInterfaces, pInterfaceIds,
pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
CLEDDevice *this = (CLEDDevice *) construct(pCLEDDevice_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
this->mDeviceID = deviceID;
IObject_Publish(&this->mObject);
// return the new LED object
*pDevice = &this->mObject.mItf;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateVibraDevice(SLEngineItf self, SLObjectItf *pDevice, SLuint32 deviceID,
SLuint32 numInterfaces, const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & USE_PROFILES_OPTIONAL
if ((NULL == pDevice) || (SL_DEFAULTDEVICEID_VIBRA != deviceID)) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pDevice = NULL;
unsigned exposedMask;
const ClassTable *pCVibraDevice_class = objectIDtoClass(SL_OBJECTID_VIBRADEVICE);
if (NULL == pCVibraDevice_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCVibraDevice_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
CVibraDevice *this = (CVibraDevice *) construct(pCVibraDevice_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
this->mDeviceID = deviceID;
IObject_Publish(&this->mObject);
// return the new vibra object
*pDevice = &this->mObject.mItf;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateAudioPlayer(SLEngineItf self, SLObjectItf *pPlayer,
SLDataSource *pAudioSrc, SLDataSink *pAudioSnk, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
if (NULL == pPlayer) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pPlayer = NULL;
unsigned exposedMask;
const ClassTable *pCAudioPlayer_class = objectIDtoClass(SL_OBJECTID_AUDIOPLAYER);
assert(NULL != pCAudioPlayer_class);
result = checkInterfaces(pCAudioPlayer_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
if (SL_RESULT_SUCCESS == result) {
// Construct our new AudioPlayer instance
CAudioPlayer *this = (CAudioPlayer *) construct(pCAudioPlayer_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
do {
// Initialize private fields not associated with an interface
// Default data source in case of failure in checkDataSource
this->mDataSource.mLocator.mLocatorType = SL_DATALOCATOR_NULL;
this->mDataSource.mFormat.mFormatType = SL_DATAFORMAT_NULL;
// Default data sink in case of failure in checkDataSink
this->mDataSink.mLocator.mLocatorType = SL_DATALOCATOR_NULL;
this->mDataSink.mFormat.mFormatType = SL_DATAFORMAT_NULL;
// Default is no per-channel mute or solo
this->mMuteMask = 0;
this->mSoloMask = 0;
// Will be set soon for PCM buffer queues, or later by platform-specific code
// during Realize or Prefetch
this->mNumChannels = 0;
this->mSampleRateMilliHz = 0;
// More default values, in case destructor needs to be called early
this->mDirectLevel = 0;
#ifdef USE_OUTPUTMIXEXT
this->mTrack = NULL;
this->mGains[0] = 1.0f;
this->mGains[1] = 1.0f;
this->mDestroyRequested = SL_BOOLEAN_FALSE;
#endif
#ifdef USE_SNDFILE
this->mSndFile.mPathname = NULL;
this->mSndFile.mSNDFILE = NULL;
memset(&this->mSndFile.mSfInfo, 0, sizeof(SF_INFO));
memset(&this->mSndFile.mMutex, 0, sizeof(pthread_mutex_t));
this->mSndFile.mEOF = SL_BOOLEAN_FALSE;
this->mSndFile.mWhich = 0;
memset(this->mSndFile.mBuffer, 0, sizeof(this->mSndFile.mBuffer));
#endif
#ifdef ANDROID
// extra safe initializations of pointers, in case of incomplete construction
this->mpLock = NULL;
this->mAudioTrack = NULL;
// placement new (explicit constructor)
(void) new (&this->mSfPlayer) android::sp<android::SfPlayer>();
(void) new (&this->mAuxEffect) android::sp<android::AudioEffect>();
#endif
// Check the source and sink parameters against generic constraints,
// and make a local copy of all parameters in case other application threads
// change memory concurrently.
result = checkDataSource(pAudioSrc, &this->mDataSource);
if (SL_RESULT_SUCCESS != result) {
break;
}
result = checkDataSink(pAudioSnk, &this->mDataSink, SL_OBJECTID_AUDIOPLAYER);
if (SL_RESULT_SUCCESS != result) {
break;
}
// It would be unsafe to ever refer to the application pointers again
pAudioSrc = NULL;
pAudioSnk = NULL;
// Check that the requested interfaces are compatible with the data source
result = checkSourceFormatVsInterfacesCompatibility(&this->mDataSource,
pCAudioPlayer_class, exposedMask);
if (SL_RESULT_SUCCESS != result) {
break;
}
// copy the buffer queue count from source locator to the buffer queue interface
// we have already range-checked the value down to a smaller width
switch (this->mDataSource.mLocator.mLocatorType) {
case SL_DATALOCATOR_BUFFERQUEUE:
#ifdef ANDROID
case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE:
#endif
this->mBufferQueue.mNumBuffers =
(SLuint16) this->mDataSource.mLocator.mBufferQueue.numBuffers;
assert(SL_DATAFORMAT_PCM == this->mDataSource.mFormat.mFormatType);
this->mNumChannels = this->mDataSource.mFormat.mPCM.numChannels;
this->mSampleRateMilliHz = this->mDataSource.mFormat.mPCM.samplesPerSec;
break;
default:
this->mBufferQueue.mNumBuffers = 0;
break;
}
// check the audio source and sink parameters against platform support
#ifdef ANDROID
result = android_audioPlayer_checkSourceSink(this);
if (SL_RESULT_SUCCESS != result) {
break;
}
#endif
#ifdef USE_SNDFILE
result = SndFile_checkAudioPlayerSourceSink(this);
if (SL_RESULT_SUCCESS != result) {
break;
}
#endif
#ifdef USE_OUTPUTMIXEXT
result = IOutputMixExt_checkAudioPlayerSourceSink(this);
if (SL_RESULT_SUCCESS != result) {
break;
}
#endif
// FIXME move to dedicated function
// Allocate memory for buffer queue
//if (0 != this->mBufferQueue.mNumBuffers) {
// inline allocation of circular mArray, up to a typical max
if (BUFFER_HEADER_TYPICAL >= this->mBufferQueue.mNumBuffers) {
this->mBufferQueue.mArray = this->mBufferQueue.mTypical;
} else {
// Avoid possible integer overflow during multiplication; this arbitrary
// maximum is big enough to not interfere with real applications, but
// small enough to not overflow.
if (this->mBufferQueue.mNumBuffers >= 256) {
result = SL_RESULT_MEMORY_FAILURE;
break;
}
this->mBufferQueue.mArray = (BufferHeader *) malloc((this->mBufferQueue.
mNumBuffers + 1) * sizeof(BufferHeader));
if (NULL == this->mBufferQueue.mArray) {
result = SL_RESULT_MEMORY_FAILURE;
break;
}
}
this->mBufferQueue.mFront = this->mBufferQueue.mArray;
this->mBufferQueue.mRear = this->mBufferQueue.mArray;
//}
// used to store the data source of our audio player
this->mDynamicSource.mDataSource = &this->mDataSource.u.mSource;
// platform-specific initialization
#ifdef ANDROID
android_audioPlayer_create(this);
#endif
} while (0);
if (SL_RESULT_SUCCESS != result) {
IObject_Destroy(&this->mObject.mItf);
} else {
IObject_Publish(&this->mObject);
// return the new audio player object
*pPlayer = &this->mObject.mItf;
}
}
}
}
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateAudioRecorder(SLEngineItf self, SLObjectItf *pRecorder,
SLDataSource *pAudioSrc, SLDataSink *pAudioSnk, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if (USE_PROFILES & USE_PROFILES_OPTIONAL) || defined(ANDROID)
if (NULL == pRecorder) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pRecorder = NULL;
unsigned exposedMask;
const ClassTable *pCAudioRecorder_class = objectIDtoClass(SL_OBJECTID_AUDIORECORDER);
if (NULL == pCAudioRecorder_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCAudioRecorder_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
// Construct our new AudioRecorder instance
CAudioRecorder *this = (CAudioRecorder *) construct(pCAudioRecorder_class, exposedMask,
self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
do {
// Initialize fields not associated with any interface
// Default data source in case of failure in checkDataSource
this->mDataSource.mLocator.mLocatorType = SL_DATALOCATOR_NULL;
this->mDataSource.mFormat.mFormatType = SL_DATAFORMAT_NULL;
// Default data sink in case of failure in checkDataSink
this->mDataSink.mLocator.mLocatorType = SL_DATALOCATOR_NULL;
this->mDataSink.mFormat.mFormatType = SL_DATAFORMAT_NULL;
// These fields are set to real values by
// android_audioRecorder_checkSourceSinkSupport. Note that the data sink is
// always PCM buffer queue, so we know the channel count and sample rate early.
this->mNumChannels = 0;
this->mSampleRateMilliHz = 0;
#ifdef ANDROID
this->mAudioRecord = NULL;
this->mRecordSource = android::AUDIO_SOURCE_DEFAULT;
#endif
// Check the source and sink parameters, and make a local copy of all parameters
result = checkDataSource(pAudioSrc, &this->mDataSource);
if (SL_RESULT_SUCCESS != result) {
break;
}
result = checkDataSink(pAudioSnk, &this->mDataSink, SL_OBJECTID_AUDIORECORDER);
if (SL_RESULT_SUCCESS != result) {
break;
}
// It would be unsafe to ever refer to the application pointers again
pAudioSrc = NULL;
pAudioSnk = NULL;
// check the audio source and sink parameters against platform support
#ifdef ANDROID
result = android_audioRecorder_checkSourceSinkSupport(this);
if (SL_RESULT_SUCCESS != result) {
SL_LOGE("Cannot create AudioRecorder: invalid source or sink");
break;
}
#endif
#ifdef ANDROID
// Allocate memory for buffer queue
SLuint32 locatorType = this->mDataSink.mLocator.mLocatorType;
if (locatorType == SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE) {
this->mBufferQueue.mNumBuffers =
this->mDataSink.mLocator.mBufferQueue.numBuffers;
// inline allocation of circular Buffer Queue mArray, up to a typical max
if (BUFFER_HEADER_TYPICAL >= this->mBufferQueue.mNumBuffers) {
this->mBufferQueue.mArray = this->mBufferQueue.mTypical;
} else {
// Avoid possible integer overflow during multiplication; this arbitrary
// maximum is big enough to not interfere with real applications, but
// small enough to not overflow.
if (this->mBufferQueue.mNumBuffers >= 256) {
result = SL_RESULT_MEMORY_FAILURE;
break;
}
this->mBufferQueue.mArray = (BufferHeader *) malloc((this->mBufferQueue.
mNumBuffers + 1) * sizeof(BufferHeader));
if (NULL == this->mBufferQueue.mArray) {
result = SL_RESULT_MEMORY_FAILURE;
break;
}
}
this->mBufferQueue.mFront = this->mBufferQueue.mArray;
this->mBufferQueue.mRear = this->mBufferQueue.mArray;
}
#endif
// platform-specific initialization
#ifdef ANDROID
android_audioRecorder_create(this);
#endif
} while (0);
if (SL_RESULT_SUCCESS != result) {
IObject_Destroy(&this->mObject.mItf);
} else {
IObject_Publish(&this->mObject);
// return the new audio recorder object
*pRecorder = &this->mObject.mItf;
}
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateMidiPlayer(SLEngineItf self, SLObjectItf *pPlayer,
SLDataSource *pMIDISrc, SLDataSource *pBankSrc, SLDataSink *pAudioOutput,
SLDataSink *pVibra, SLDataSink *pLEDArray, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_PHONE)
if ((NULL == pPlayer) || (NULL == pMIDISrc) || (NULL == pAudioOutput)) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pPlayer = NULL;
unsigned exposedMask;
const ClassTable *pCMidiPlayer_class = objectIDtoClass(SL_OBJECTID_MIDIPLAYER);
if (NULL == pCMidiPlayer_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCMidiPlayer_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
CMidiPlayer *this = (CMidiPlayer *) construct(pCMidiPlayer_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
// FIXME a fake value - why not use value from IPlay_init? what does CT check for?
this->mPlay.mDuration = 0;
IObject_Publish(&this->mObject);
// return the new MIDI player object
*pPlayer = &this->mObject.mItf;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateListener(SLEngineItf self, SLObjectItf *pListener,
SLuint32 numInterfaces, const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & USE_PROFILES_GAME
if (NULL == pListener) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pListener = NULL;
unsigned exposedMask;
const ClassTable *pCListener_class = objectIDtoClass(SL_OBJECTID_LISTENER);
if (NULL == pCListener_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCListener_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
CListener *this = (CListener *) construct(pCListener_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
IObject_Publish(&this->mObject);
// return the new 3D listener object
*pListener = &this->mObject.mItf;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_Create3DGroup(SLEngineItf self, SLObjectItf *pGroup, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & USE_PROFILES_GAME
if (NULL == pGroup) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pGroup = NULL;
unsigned exposedMask;
const ClassTable *pC3DGroup_class = objectIDtoClass(SL_OBJECTID_3DGROUP);
if (NULL == pC3DGroup_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pC3DGroup_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
C3DGroup *this = (C3DGroup *) construct(pC3DGroup_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
this->mMemberMask = 0;
IObject_Publish(&this->mObject);
// return the new 3D group object
*pGroup = &this->mObject.mItf;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateOutputMix(SLEngineItf self, SLObjectItf *pMix, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
if (NULL == pMix) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pMix = NULL;
unsigned exposedMask;
const ClassTable *pCOutputMix_class = objectIDtoClass(SL_OBJECTID_OUTPUTMIX);
assert(NULL != pCOutputMix_class);
result = checkInterfaces(pCOutputMix_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
if (SL_RESULT_SUCCESS == result) {
COutputMix *this = (COutputMix *) construct(pCOutputMix_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
#ifdef ANDROID
android_outputMix_create(this);
#endif
#ifdef USE_SDL
IEngine *thisEngine = this->mObject.mEngine;
interface_lock_exclusive(thisEngine);
bool unpause = false;
if (NULL == thisEngine->mOutputMix) {
thisEngine->mOutputMix = this;
unpause = true;
}
interface_unlock_exclusive(thisEngine);
#endif
IObject_Publish(&this->mObject);
#ifdef USE_SDL
if (unpause) {
// Enable SDL_callback to be called periodically by SDL's internal thread
SDL_PauseAudio(0);
}
#endif
// return the new output mix object
*pMix = &this->mObject.mItf;
}
}
}
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateMetadataExtractor(SLEngineItf self, SLObjectItf *pMetadataExtractor,
SLDataSource *pDataSource, SLuint32 numInterfaces, const SLInterfaceID *pInterfaceIds,
const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
#if USE_PROFILES & (USE_PROFILES_GAME | USE_PROFILES_MUSIC)
if (NULL == pMetadataExtractor) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pMetadataExtractor = NULL;
unsigned exposedMask;
const ClassTable *pCMetadataExtractor_class =
objectIDtoClass(SL_OBJECTID_METADATAEXTRACTOR);
if (NULL == pCMetadataExtractor_class) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = checkInterfaces(pCMetadataExtractor_class, numInterfaces,
pInterfaceIds, pInterfaceRequired, &exposedMask);
}
if (SL_RESULT_SUCCESS == result) {
CMetadataExtractor *this = (CMetadataExtractor *)
construct(pCMetadataExtractor_class, exposedMask, self);
if (NULL == this) {
result = SL_RESULT_MEMORY_FAILURE;
} else {
IObject_Publish(&this->mObject);
// return the new metadata extractor object
*pMetadataExtractor = &this->mObject.mItf;
result = SL_RESULT_SUCCESS;
}
}
}
#else
result = SL_RESULT_FEATURE_UNSUPPORTED;
#endif
SL_LEAVE_INTERFACE
}
static SLresult IEngine_CreateExtensionObject(SLEngineItf self, SLObjectItf *pObject,
void *pParameters, SLuint32 objectID, SLuint32 numInterfaces,
const SLInterfaceID *pInterfaceIds, const SLboolean *pInterfaceRequired)
{
SL_ENTER_INTERFACE
if (NULL == pObject) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pObject = NULL;
result = SL_RESULT_FEATURE_UNSUPPORTED;
}
SL_LEAVE_INTERFACE
}
static SLresult IEngine_QueryNumSupportedInterfaces(SLEngineItf self,
SLuint32 objectID, SLuint32 *pNumSupportedInterfaces)
{
SL_ENTER_INTERFACE
if (NULL == pNumSupportedInterfaces) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
const ClassTable *class__ = objectIDtoClass(objectID);
if (NULL == class__) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
SLuint32 count = 0;
SLuint32 i;
for (i = 0; i < class__->mInterfaceCount; ++i) {
switch (class__->mInterfaces[i].mInterface) {
case INTERFACE_IMPLICIT:
case INTERFACE_IMPLICIT_PREREALIZE:
case INTERFACE_EXPLICIT:
case INTERFACE_EXPLICIT_PREREALIZE:
case INTERFACE_DYNAMIC:
++count;
break;
case INTERFACE_UNAVAILABLE:
break;
default:
assert(false);
break;
}
}
*pNumSupportedInterfaces = count;
result = SL_RESULT_SUCCESS;
}
}
SL_LEAVE_INTERFACE;
}
static SLresult IEngine_QuerySupportedInterfaces(SLEngineItf self,
SLuint32 objectID, SLuint32 index, SLInterfaceID *pInterfaceId)
{
SL_ENTER_INTERFACE
if (NULL == pInterfaceId) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pInterfaceId = NULL;
const ClassTable *class__ = objectIDtoClass(objectID);
if (NULL == class__) {
result = SL_RESULT_FEATURE_UNSUPPORTED;
} else {
result = SL_RESULT_PARAMETER_INVALID; // will be reset later
SLuint32 i;
for (i = 0; i < class__->mInterfaceCount; ++i) {
switch (class__->mInterfaces[i].mInterface) {
case INTERFACE_IMPLICIT:
case INTERFACE_IMPLICIT_PREREALIZE:
case INTERFACE_EXPLICIT:
case INTERFACE_EXPLICIT_PREREALIZE:
case INTERFACE_DYNAMIC:
break;
case INTERFACE_UNAVAILABLE:
continue;
default:
assert(false);
break;
}
if (index == 0) {
*pInterfaceId = &SL_IID_array[class__->mInterfaces[i].mMPH];
result = SL_RESULT_SUCCESS;
break;
}
--index;
}
}
}
SL_LEAVE_INTERFACE
};
static const char * const extensionNames[] = {
#ifdef ANDROID
"ANDROID_SDK_LEVEL_9", // Android 2.3 aka "Gingerbread"
// in the future, add more entries for each SDK level here, and
// don't delete the entries for previous SDK levels unless support is removed
#else
"WILHELM_DESKTOP",
#endif
};
static SLresult IEngine_QueryNumSupportedExtensions(SLEngineItf self, SLuint32 *pNumExtensions)
{
SL_ENTER_INTERFACE
if (NULL == pNumExtensions) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
*pNumExtensions = sizeof(extensionNames) / sizeof(extensionNames[0]);
result = SL_RESULT_SUCCESS;
}
SL_LEAVE_INTERFACE
}
static SLresult IEngine_QuerySupportedExtension(SLEngineItf self,
SLuint32 index, SLchar *pExtensionName, SLint16 *pNameLength)
{
SL_ENTER_INTERFACE
if (NULL == pNameLength) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
size_t actualNameLength;
unsigned numExtensions = sizeof(extensionNames) / sizeof(extensionNames[0]);
if (index >= numExtensions) {
actualNameLength = 0;
result = SL_RESULT_PARAMETER_INVALID;
} else {
const char *extensionName = extensionNames[index];
actualNameLength = strlen(extensionName) + 1;
if (NULL == pExtensionName) {
// application is querying the name length in order to allocate a buffer
result = SL_RESULT_SUCCESS;
} else {
SLint16 availableNameLength = *pNameLength;
if (0 >= availableNameLength) {
// there is not even room for the terminating NUL
result = SL_RESULT_BUFFER_INSUFFICIENT;
} else if (actualNameLength > (size_t) availableNameLength) {
// "no invalid strings are written. That is, the null-terminator always exists"
memcpy(pExtensionName, extensionName, (size_t) availableNameLength - 1);
pExtensionName[(size_t) availableNameLength - 1] = '\0';
result = SL_RESULT_BUFFER_INSUFFICIENT;
} else {
memcpy(pExtensionName, extensionName, actualNameLength);
result = SL_RESULT_SUCCESS;
}
}
}
*pNameLength = actualNameLength;
}
SL_LEAVE_INTERFACE
}
static SLresult IEngine_IsExtensionSupported(SLEngineItf self,
const SLchar *pExtensionName, SLboolean *pSupported)
{
SL_ENTER_INTERFACE
if (NULL == pSupported) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
SLboolean isSupported = SL_BOOLEAN_FALSE;
if (NULL == pExtensionName) {
result = SL_RESULT_PARAMETER_INVALID;
} else {
unsigned numExtensions = sizeof(extensionNames) / sizeof(extensionNames[0]);
unsigned i;
for (i = 0; i < numExtensions; ++i) {
if (!strcmp((const char *) pExtensionName, extensionNames[i])) {
isSupported = SL_BOOLEAN_TRUE;
break;
}
}
result = SL_RESULT_SUCCESS;
}
*pSupported = isSupported;
}
SL_LEAVE_INTERFACE
}
static const struct SLEngineItf_ IEngine_Itf = {
IEngine_CreateLEDDevice,
IEngine_CreateVibraDevice,
IEngine_CreateAudioPlayer,
IEngine_CreateAudioRecorder,
IEngine_CreateMidiPlayer,
IEngine_CreateListener,
IEngine_Create3DGroup,
IEngine_CreateOutputMix,
IEngine_CreateMetadataExtractor,
IEngine_CreateExtensionObject,
IEngine_QueryNumSupportedInterfaces,
IEngine_QuerySupportedInterfaces,
IEngine_QueryNumSupportedExtensions,
IEngine_QuerySupportedExtension,
IEngine_IsExtensionSupported
};
void IEngine_init(void *self)
{
IEngine *this = (IEngine *) self;
this->mItf = &IEngine_Itf;
// mLossOfControlGlobal is initialized in slCreateEngine
#ifdef USE_SDL
this->mOutputMix = NULL;
#endif
this->mInstanceCount = 1; // ourself
this->mInstanceMask = 0;
this->mChangedMask = 0;
unsigned i;
for (i = 0; i < MAX_INSTANCE; ++i) {
this->mInstances[i] = NULL;
}
this->mShutdown = SL_BOOLEAN_FALSE;
this->mShutdownAck = SL_BOOLEAN_FALSE;
// mThreadPool is initialized in CEngine_Realize
memset(&this->mThreadPool, 0, sizeof(ThreadPool));
#if defined(ANDROID) && !defined(USE_BACKPORT)
this->mEqNumPresets = 0;
this->mEqPresetNames = NULL;
#endif
}
void IEngine_deinit(void *self)
{
#if defined(ANDROID) && !defined(USE_BACKPORT)
IEngine *this = (IEngine *) self;
// free equalizer preset names
if (NULL != this->mEqPresetNames) {
for (unsigned i = 0; i < this->mEqNumPresets; ++i) {
if (NULL != this->mEqPresetNames[i]) {
delete[] this->mEqPresetNames[i];
this->mEqPresetNames[i] = NULL;
}
}
delete[] this->mEqPresetNames;
this->mEqPresetNames = NULL;
}
this->mEqNumPresets = 0;
#endif
}