/* * Copyright 2017 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. */ #include #include "common/OboeDebug.h" #include "EngineOpenSLES.h" #include "OpenSLESUtilities.h" using namespace oboe; // OpenSL ES is deprecated in SDK 30. // So we use custom dynamic linking to access the library. #define LIB_OPENSLES_NAME "libOpenSLES.so" EngineOpenSLES &EngineOpenSLES::getInstance() { static EngineOpenSLES sInstance; return sInstance; } // Satisfy extern in OpenSLES.h // These are required because of b/337360630, which was causing // Oboe to have link failures if libOpenSLES.so was not available. // If you are statically linking Oboe and libOpenSLES.so is a shared library // and you observe crashes, you can pass DO_NOT_DEFINE_OPENSL_ES_CONSTANTS to cmake. #ifndef DO_NOT_DEFINE_OPENSL_ES_CONSTANTS SL_API const SLInterfaceID SL_IID_ENGINE = nullptr; SL_API const SLInterfaceID SL_IID_ANDROIDSIMPLEBUFFERQUEUE = nullptr; SL_API const SLInterfaceID SL_IID_ANDROIDCONFIGURATION = nullptr; SL_API const SLInterfaceID SL_IID_RECORD = nullptr; SL_API const SLInterfaceID SL_IID_BUFFERQUEUE = nullptr; SL_API const SLInterfaceID SL_IID_VOLUME = nullptr; SL_API const SLInterfaceID SL_IID_PLAY = nullptr; #endif static const char *getSafeDlerror() { static const char *defaultMessage = "not found?"; char *errorMessage = dlerror(); return (errorMessage == nullptr) ? defaultMessage : errorMessage; } // Load the OpenSL ES library and the one primary entry point. // @return true if linked OK bool EngineOpenSLES::linkOpenSLES() { if (mDynamicLinkState == kLinkStateBad) { LOGE("%s(), OpenSL ES not available, based on previous link failure.", __func__); } else if (mDynamicLinkState == kLinkStateUninitialized) { // Set to BAD now in case we return because of an error. // This is safe form race conditions because this function is always called // under mLock amd the state is only accessed from this function. mDynamicLinkState = kLinkStateBad; // Use RTLD_NOW to avoid the unpredictable behavior that RTLD_LAZY can cause. // Also resolving all the links now will prevent a run-time penalty later. mLibOpenSlesLibraryHandle = dlopen(LIB_OPENSLES_NAME, RTLD_NOW); if (mLibOpenSlesLibraryHandle == nullptr) { LOGE("%s() could not dlopen(%s), %s", __func__, LIB_OPENSLES_NAME, getSafeDlerror()); return false; } else { mFunction_slCreateEngine = (prototype_slCreateEngine) dlsym( mLibOpenSlesLibraryHandle, "slCreateEngine"); LOGD("%s(): dlsym(%s) returned %p", __func__, "slCreateEngine", mFunction_slCreateEngine); if (mFunction_slCreateEngine == nullptr) { LOGE("%s(): dlsym(slCreateEngine) returned null, %s", __func__, getSafeDlerror()); return false; } // Load IID interfaces. LOCAL_SL_IID_ENGINE = getIidPointer("SL_IID_ENGINE"); if (LOCAL_SL_IID_ENGINE == nullptr) return false; LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE = getIidPointer( "SL_IID_ANDROIDSIMPLEBUFFERQUEUE"); if (LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE == nullptr) return false; LOCAL_SL_IID_ANDROIDCONFIGURATION = getIidPointer( "SL_IID_ANDROIDCONFIGURATION"); if (LOCAL_SL_IID_ANDROIDCONFIGURATION == nullptr) return false; LOCAL_SL_IID_RECORD = getIidPointer("SL_IID_RECORD"); if (LOCAL_SL_IID_RECORD == nullptr) return false; LOCAL_SL_IID_BUFFERQUEUE = getIidPointer("SL_IID_BUFFERQUEUE"); if (LOCAL_SL_IID_BUFFERQUEUE == nullptr) return false; LOCAL_SL_IID_VOLUME = getIidPointer("SL_IID_VOLUME"); if (LOCAL_SL_IID_VOLUME == nullptr) return false; LOCAL_SL_IID_PLAY = getIidPointer("SL_IID_PLAY"); if (LOCAL_SL_IID_PLAY == nullptr) return false; mDynamicLinkState = kLinkStateGood; } } return (mDynamicLinkState == kLinkStateGood); } // A symbol like SL_IID_PLAY is a pointer to a structure. // The dlsym() function returns the address of the pointer, not the structure. // To get the address of the structure we have to dereference the pointer. SLInterfaceID EngineOpenSLES::getIidPointer(const char *symbolName) { SLInterfaceID *iid_address = (SLInterfaceID *) dlsym( mLibOpenSlesLibraryHandle, symbolName); if (iid_address == nullptr) { LOGE("%s(): dlsym(%s) returned null, %s", __func__, symbolName, getSafeDlerror()); return (SLInterfaceID) nullptr; } return *iid_address; // Get address of the structure. } SLresult EngineOpenSLES::open() { std::lock_guard lock(mLock); SLresult result = SL_RESULT_SUCCESS; if (mOpenCount++ == 0) { // load the library and link to it if (!linkOpenSLES()) { result = SL_RESULT_FEATURE_UNSUPPORTED; goto error; }; // create engine result = (*mFunction_slCreateEngine)(&mEngineObject, 0, NULL, 0, NULL, NULL); if (SL_RESULT_SUCCESS != result) { LOGE("EngineOpenSLES - slCreateEngine() result:%s", getSLErrStr(result)); goto error; } // realize the engine result = (*mEngineObject)->Realize(mEngineObject, SL_BOOLEAN_FALSE); if (SL_RESULT_SUCCESS != result) { LOGE("EngineOpenSLES - Realize() engine result:%s", getSLErrStr(result)); goto error; } // get the engine interface, which is needed in order to create other objects result = (*mEngineObject)->GetInterface(mEngineObject, EngineOpenSLES::getInstance().getIidEngine(), &mEngineInterface); if (SL_RESULT_SUCCESS != result) { LOGE("EngineOpenSLES - GetInterface() engine result:%s", getSLErrStr(result)); goto error; } } return result; error: close_l(); return result; } void EngineOpenSLES::close() { std::lock_guard lock(mLock); close_l(); } // This must be called under mLock void EngineOpenSLES::close_l() { if (--mOpenCount == 0) { if (mEngineObject != nullptr) { (*mEngineObject)->Destroy(mEngineObject); mEngineObject = nullptr; mEngineInterface = nullptr; } } } SLresult EngineOpenSLES::createOutputMix(SLObjectItf *objectItf) { return (*mEngineInterface)->CreateOutputMix(mEngineInterface, objectItf, 0, 0, 0); } SLresult EngineOpenSLES::createAudioPlayer(SLObjectItf *objectItf, SLDataSource *audioSource, SLDataSink *audioSink) { SLInterfaceID ids[] = {LOCAL_SL_IID_BUFFERQUEUE, LOCAL_SL_IID_ANDROIDCONFIGURATION}; SLboolean reqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE}; return (*mEngineInterface)->CreateAudioPlayer(mEngineInterface, objectItf, audioSource, audioSink, sizeof(ids) / sizeof(ids[0]), ids, reqs); } SLresult EngineOpenSLES::createAudioRecorder(SLObjectItf *objectItf, SLDataSource *audioSource, SLDataSink *audioSink) { SLInterfaceID ids[] = {LOCAL_SL_IID_ANDROIDSIMPLEBUFFERQUEUE, LOCAL_SL_IID_ANDROIDCONFIGURATION }; SLboolean reqs[] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE}; return (*mEngineInterface)->CreateAudioRecorder(mEngineInterface, objectItf, audioSource, audioSink, sizeof(ids) / sizeof(ids[0]), ids, reqs); }