From 34e8fb068f50c585a6f69eca365d1008c898f0c3 Mon Sep 17 00:00:00 2001 From: JosJuice Date: Thu, 6 Jun 2024 13:32:26 +0200 Subject: Android: Get rid of OpenSLESStream's global state Not sure if we're ever going to want to have more than one of these at the same time, but these global variables are a code smell nonetheless. I'm also deleting the existing member variables because they were unused. --- Source/Core/AudioCommon/OpenSLESStream.cpp | 105 +++++++++++++---------------- 1 file changed, 46 insertions(+), 59 deletions(-) (limited to 'Source/Core/AudioCommon/OpenSLESStream.cpp') diff --git a/Source/Core/AudioCommon/OpenSLESStream.cpp b/Source/Core/AudioCommon/OpenSLESStream.cpp index a3f6308187..84831ceec6 100644 --- a/Source/Core/AudioCommon/OpenSLESStream.cpp +++ b/Source/Core/AudioCommon/OpenSLESStream.cpp @@ -14,34 +14,19 @@ #include "Common/Logging/Log.h" #include "Core/ConfigManager.h" -// engine interfaces -static SLObjectItf engineObject; -static SLEngineItf engineEngine; -static SLObjectItf outputMixObject; - -// buffer queue player interfaces -static SLObjectItf bqPlayerObject = nullptr; -static SLPlayItf bqPlayerPlay; -static SLAndroidSimpleBufferQueueItf bqPlayerBufferQueue; -static SLVolumeItf bqPlayerVolume; -static Mixer* g_mixer; -#define BUFFER_SIZE 512 -#define BUFFER_SIZE_IN_SAMPLES (BUFFER_SIZE / 2) - -// Double buffering. -static short buffer[2][BUFFER_SIZE]; -static int curBuffer = 0; - -static void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context) +void OpenSLESStream::BQPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context) { - ASSERT(bq == bqPlayerBufferQueue); - ASSERT(nullptr == context); + reinterpret_cast(context)->PushSamples(bq); +} + +void OpenSLESStream::PushSamples(SLAndroidSimpleBufferQueueItf bq) +{ + ASSERT(bq == m_bq_player_buffer_queue); // Render to the fresh buffer - g_mixer->Mix(reinterpret_cast(buffer[curBuffer]), BUFFER_SIZE_IN_SAMPLES); - SLresult result = - (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[curBuffer], sizeof(buffer[0])); - curBuffer ^= 1; // Switch buffer + m_mixer->Mix(reinterpret_cast(m_buffer[m_current_buffer]), BUFFER_SIZE_IN_SAMPLES); + SLresult result = (*bq)->Enqueue(bq, m_buffer[m_current_buffer], sizeof(m_buffer[0])); + m_current_buffer ^= 1; // Switch buffer // Comment from sample code: // the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT, @@ -53,15 +38,15 @@ bool OpenSLESStream::Init() { SLresult result; // create engine - result = slCreateEngine(&engineObject, 0, nullptr, 0, nullptr, nullptr); + result = slCreateEngine(&m_engine_object, 0, nullptr, 0, nullptr, nullptr); ASSERT(SL_RESULT_SUCCESS == result); - result = (*engineObject)->Realize(engineObject, SL_BOOLEAN_FALSE); + result = (*m_engine_object)->Realize(m_engine_object, SL_BOOLEAN_FALSE); ASSERT(SL_RESULT_SUCCESS == result); - result = (*engineObject)->GetInterface(engineObject, SL_IID_ENGINE, &engineEngine); + result = (*m_engine_object)->GetInterface(m_engine_object, SL_IID_ENGINE, &m_engine_engine); ASSERT(SL_RESULT_SUCCESS == result); - result = (*engineEngine)->CreateOutputMix(engineEngine, &outputMixObject, 0, 0, 0); + result = (*m_engine_engine)->CreateOutputMix(m_engine_engine, &m_output_mix_object, 0, 0, 0); ASSERT(SL_RESULT_SUCCESS == result); - result = (*outputMixObject)->Realize(outputMixObject, SL_BOOLEAN_FALSE); + result = (*m_output_mix_object)->Realize(m_output_mix_object, SL_BOOLEAN_FALSE); ASSERT(SL_RESULT_SUCCESS == result); SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2}; @@ -76,36 +61,38 @@ bool OpenSLESStream::Init() SLDataSource audioSrc = {&loc_bufq, &format_pcm}; // configure audio sink - SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, outputMixObject}; + SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, m_output_mix_object}; SLDataSink audioSnk = {&loc_outmix, nullptr}; // create audio player const SLInterfaceID ids[2] = {SL_IID_BUFFERQUEUE, SL_IID_VOLUME}; const SLboolean req[2] = {SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE}; - result = - (*engineEngine) - ->CreateAudioPlayer(engineEngine, &bqPlayerObject, &audioSrc, &audioSnk, 2, ids, req); + result = (*m_engine_engine) + ->CreateAudioPlayer(m_engine_engine, &m_bq_player_object, &audioSrc, &audioSnk, 2, + ids, req); ASSERT(SL_RESULT_SUCCESS == result); - result = (*bqPlayerObject)->Realize(bqPlayerObject, SL_BOOLEAN_FALSE); + result = (*m_bq_player_object)->Realize(m_bq_player_object, SL_BOOLEAN_FALSE); ASSERT(SL_RESULT_SUCCESS == result); - result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_PLAY, &bqPlayerPlay); + result = (*m_bq_player_object)->GetInterface(m_bq_player_object, SL_IID_PLAY, &m_bq_player_play); ASSERT(SL_RESULT_SUCCESS == result); - result = - (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_BUFFERQUEUE, &bqPlayerBufferQueue); + result = (*m_bq_player_object) + ->GetInterface(m_bq_player_object, SL_IID_BUFFERQUEUE, &m_bq_player_buffer_queue); ASSERT(SL_RESULT_SUCCESS == result); - result = (*bqPlayerObject)->GetInterface(bqPlayerObject, SL_IID_VOLUME, &bqPlayerVolume); + result = + (*m_bq_player_object)->GetInterface(m_bq_player_object, SL_IID_VOLUME, &m_bq_player_volume); ASSERT(SL_RESULT_SUCCESS == result); - result = (*bqPlayerBufferQueue)->RegisterCallback(bqPlayerBufferQueue, bqPlayerCallback, nullptr); + result = (*m_bq_player_buffer_queue) + ->RegisterCallback(m_bq_player_buffer_queue, BQPlayerCallback, this); ASSERT(SL_RESULT_SUCCESS == result); - result = (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, SL_PLAYSTATE_PLAYING); + result = (*m_bq_player_play)->SetPlayState(m_bq_player_play, SL_PLAYSTATE_PLAYING); ASSERT(SL_RESULT_SUCCESS == result); // Render and enqueue a first buffer. - curBuffer ^= 1; - g_mixer = m_mixer.get(); + m_current_buffer ^= 1; - result = (*bqPlayerBufferQueue)->Enqueue(bqPlayerBufferQueue, buffer[0], sizeof(buffer[0])); + result = (*m_bq_player_buffer_queue) + ->Enqueue(m_bq_player_buffer_queue, m_buffer[0], sizeof(m_buffer[0])); if (SL_RESULT_SUCCESS != result) return false; @@ -114,39 +101,39 @@ bool OpenSLESStream::Init() OpenSLESStream::~OpenSLESStream() { - if (bqPlayerObject != nullptr) + if (m_bq_player_object != nullptr) { - (*bqPlayerObject)->Destroy(bqPlayerObject); - bqPlayerObject = nullptr; - bqPlayerPlay = nullptr; - bqPlayerBufferQueue = nullptr; - bqPlayerVolume = nullptr; + (*m_bq_player_object)->Destroy(m_bq_player_object); + m_bq_player_object = nullptr; + m_bq_player_play = nullptr; + m_bq_player_buffer_queue = nullptr; + m_bq_player_volume = nullptr; } - if (outputMixObject != nullptr) + if (m_output_mix_object != nullptr) { - (*outputMixObject)->Destroy(outputMixObject); - outputMixObject = nullptr; + (*m_output_mix_object)->Destroy(m_output_mix_object); + m_output_mix_object = nullptr; } - if (engineObject != nullptr) + if (m_engine_object != nullptr) { - (*engineObject)->Destroy(engineObject); - engineObject = nullptr; - engineEngine = nullptr; + (*m_engine_object)->Destroy(m_engine_object); + m_engine_object = nullptr; + m_engine_engine = nullptr; } } bool OpenSLESStream::SetRunning(bool running) { SLuint32 new_state = running ? SL_PLAYSTATE_PLAYING : SL_PLAYSTATE_PAUSED; - return (*bqPlayerPlay)->SetPlayState(bqPlayerPlay, new_state) == SL_RESULT_SUCCESS; + return (*m_bq_player_play)->SetPlayState(m_bq_player_play, new_state) == SL_RESULT_SUCCESS; } void OpenSLESStream::SetVolume(int volume) { const SLmillibel attenuation = volume <= 0 ? SL_MILLIBEL_MIN : static_cast(2000 * std::log10(volume / 100.0f)); - (*bqPlayerVolume)->SetVolumeLevel(bqPlayerVolume, attenuation); + (*m_bq_player_volume)->SetVolumeLevel(m_bq_player_volume, attenuation); } #endif // HAVE_OPENSL_ES -- cgit v1.2.3 From f99d3dbd5ccd80bcd071cf49e689f6b6724df499 Mon Sep 17 00:00:00 2001 From: JosJuice Date: Thu, 6 Jun 2024 15:38:41 +0200 Subject: Android: Ask system for optimal audio buffer size and sample rate This can reduce audio latency according to https://developer.android.com/ndk/guides/audio/opensl/opensl-prog-notes#perform. Previously we were using the hardcoded values of 48000 Hz and 256 frames per buffer. The sample rate we use with this change is 48000 Hz on all devices I'm aware of, but the buffer size does vary across devices. Terminology note: The old code used the term "sample" to refer to what Android refers to as a "frame". "Frame" is a clearer term to use for this, so I've changed OpenSLESStream's terminology. One frame consists of one sample per channel. --- Source/Core/AudioCommon/OpenSLESStream.cpp | 37 ++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 10 deletions(-) (limited to 'Source/Core/AudioCommon/OpenSLESStream.cpp') diff --git a/Source/Core/AudioCommon/OpenSLESStream.cpp b/Source/Core/AudioCommon/OpenSLESStream.cpp index 84831ceec6..3fc71e75df 100644 --- a/Source/Core/AudioCommon/OpenSLESStream.cpp +++ b/Source/Core/AudioCommon/OpenSLESStream.cpp @@ -8,11 +8,13 @@ #include #include +#include #include "Common/Assert.h" #include "Common/CommonTypes.h" #include "Common/Logging/Log.h" #include "Core/ConfigManager.h" +#include "jni/AndroidCommon/IDCache.h" void OpenSLESStream::BQPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void* context) { @@ -24,8 +26,8 @@ void OpenSLESStream::PushSamples(SLAndroidSimpleBufferQueueItf bq) ASSERT(bq == m_bq_player_buffer_queue); // Render to the fresh buffer - m_mixer->Mix(reinterpret_cast(m_buffer[m_current_buffer]), BUFFER_SIZE_IN_SAMPLES); - SLresult result = (*bq)->Enqueue(bq, m_buffer[m_current_buffer], sizeof(m_buffer[0])); + m_mixer->Mix(m_buffer[m_current_buffer].data(), m_frames_per_buffer); + SLresult result = (*bq)->Enqueue(bq, m_buffer[m_current_buffer].data(), m_bytes_per_buffer); m_current_buffer ^= 1; // Switch buffer // Comment from sample code: @@ -36,6 +38,23 @@ void OpenSLESStream::PushSamples(SLAndroidSimpleBufferQueueItf bq) bool OpenSLESStream::Init() { + JNIEnv* env = IDCache::GetEnvForThread(); + jclass audio_utils = IDCache::GetAudioUtilsClass(); + const SLuint32 sample_rate = + env->CallStaticIntMethod(audio_utils, IDCache::GetAudioUtilsGetSampleRate()); + m_frames_per_buffer = + env->CallStaticIntMethod(audio_utils, IDCache::GetAudioUtilsGetFramesPerBuffer()); + + INFO_LOG_FMT(AUDIO, "OpenSLES configuration: {} Hz, {} frames per buffer", sample_rate, + m_frames_per_buffer); + + constexpr SLuint32 channels = 2; + const SLuint32 samples_per_buffer = m_frames_per_buffer * channels; + m_bytes_per_buffer = m_frames_per_buffer * channels * sizeof(m_buffer[0][0]); + + for (std::vector& buffer : m_buffer) + buffer.resize(samples_per_buffer); + SLresult result; // create engine result = slCreateEngine(&m_engine_object, 0, nullptr, 0, nullptr, nullptr); @@ -50,13 +69,11 @@ bool OpenSLESStream::Init() ASSERT(SL_RESULT_SUCCESS == result); SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2}; - SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM, - 2, - m_mixer->GetSampleRate() * 1000, - SL_PCMSAMPLEFORMAT_FIXED_16, - SL_PCMSAMPLEFORMAT_FIXED_16, - SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, - SL_BYTEORDER_LITTLEENDIAN}; + SLDataFormat_PCM format_pcm = { + SL_DATAFORMAT_PCM, channels, + sample_rate * 1000, SL_PCMSAMPLEFORMAT_FIXED_16, + SL_PCMSAMPLEFORMAT_FIXED_16, SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT, + SL_BYTEORDER_LITTLEENDIAN}; SLDataSource audioSrc = {&loc_bufq, &format_pcm}; @@ -92,7 +109,7 @@ bool OpenSLESStream::Init() m_current_buffer ^= 1; result = (*m_bq_player_buffer_queue) - ->Enqueue(m_bq_player_buffer_queue, m_buffer[0], sizeof(m_buffer[0])); + ->Enqueue(m_bq_player_buffer_queue, m_buffer[0].data(), m_bytes_per_buffer); if (SL_RESULT_SUCCESS != result) return false; -- cgit v1.2.3