Plexi09/eden-miror
1
0
Fork 0
mirror of https://git.eden-emu.dev/eden-emu/eden synced 2026-04-16 10:58:56 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move dead submodules in-tree

Browse source 
Signed-off-by: swurl <swurl@swurl.xyz>
This commit is contained in:
swurl 2025-05-31 02:33:02 -04:00
parent c0cceff365
commit 6c655321e6
No known key found for this signature in database
GPG key ID: A5A7629F109C8FD1
4081 changed files with 1185566 additions and 45 deletions
Download patch file Download diff file Expand all files Collapse all files

206
externals/oboe/src/opensles/EngineOpenSLES.cpp vendored Normal file
View file

@ -0,0 +1,206 @@
/*
* 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 <dlfcn.h>
#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<std::mutex> 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<std::mutex> 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);
}