godot/platform/android/audio_driver_opensl.cpp

345 lines
11 KiB
C++
Raw Normal View History

2014-02-10 09:10:30 +08:00
/*************************************************************************/
2017-09-01 22:07:55 +08:00
/* audio_driver_opensl.cpp */
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 09:10:30 +08:00
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 09:10:30 +08:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is 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 Software. */
/* */
/* THE SOFTWARE IS 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 */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "audio_driver_opensl.h"
2014-02-10 09:10:30 +08:00
#include <string.h>
2014-02-10 09:10:30 +08:00
#define MAX_NUMBER_INTERFACES 3
#define MAX_NUMBER_OUTPUT_DEVICES 6
/* Structure for passing information to callback function */
void AudioDriverOpenSL::_buffer_callback(
SLAndroidSimpleBufferQueueItf queueItf) {
bool mix = true;
2014-02-10 09:10:30 +08:00
if (pause) {
mix = false;
} else {
mix = mutex.try_lock() == OK;
}
2014-02-10 09:10:30 +08:00
if (mix) {
audio_server_process(buffer_size, mixdown_buffer);
} else {
int32_t *src_buff = mixdown_buffer;
for (unsigned int i = 0; i < buffer_size * 2; i++) {
src_buff[i] = 0;
}
}
2014-02-10 09:10:30 +08:00
if (mix)
mutex.unlock();
2014-02-10 09:10:30 +08:00
const int32_t *src_buff = mixdown_buffer;
2014-02-10 09:10:30 +08:00
int16_t *ptr = (int16_t *)buffers[last_free];
last_free = (last_free + 1) % BUFFER_COUNT;
2014-02-10 09:10:30 +08:00
for (unsigned int i = 0; i < buffer_size * 2; i++) {
ptr[i] = src_buff[i] >> 16;
2014-02-10 09:10:30 +08:00
}
(*queueItf)->Enqueue(queueItf, ptr, 4 * buffer_size);
2014-02-10 09:10:30 +08:00
}
void AudioDriverOpenSL::_buffer_callbacks(
SLAndroidSimpleBufferQueueItf queueItf,
void *pContext) {
AudioDriverOpenSL *ad = (AudioDriverOpenSL *)pContext;
2014-02-10 09:10:30 +08:00
ad->_buffer_callback(queueItf);
}
2020-04-02 07:20:12 +08:00
AudioDriverOpenSL *AudioDriverOpenSL::s_ad = nullptr;
2014-02-10 09:10:30 +08:00
const char *AudioDriverOpenSL::get_name() const {
2014-02-10 09:10:30 +08:00
return "Android";
}
Error AudioDriverOpenSL::init() {
SLresult res;
2014-02-10 09:10:30 +08:00
SLEngineOption EngineOption[] = {
{ (SLuint32)SL_ENGINEOPTION_THREADSAFE, (SLuint32)SL_BOOLEAN_TRUE }
2014-02-10 09:10:30 +08:00
};
2020-04-02 07:20:12 +08:00
res = slCreateEngine(&sl, 1, EngineOption, 0, nullptr, nullptr);
ERR_FAIL_COND_V_MSG(res != SL_RESULT_SUCCESS, ERR_INVALID_PARAMETER, "Could not initialize OpenSL.");
2014-02-10 09:10:30 +08:00
res = (*sl)->Realize(sl, SL_BOOLEAN_FALSE);
ERR_FAIL_COND_V_MSG(res != SL_RESULT_SUCCESS, ERR_INVALID_PARAMETER, "Could not realize OpenSL.");
2014-02-10 09:10:30 +08:00
return OK;
}
void AudioDriverOpenSL::start() {
active = false;
2014-02-10 09:10:30 +08:00
SLresult res;
buffer_size = 1024;
for (int i = 0; i < BUFFER_COUNT; i++) {
buffers[i] = memnew_arr(int16_t, buffer_size * 2);
memset(buffers[i], 0, buffer_size * 4);
2014-02-10 09:10:30 +08:00
}
mixdown_buffer = memnew_arr(int32_t, buffer_size * 2);
2014-02-10 09:10:30 +08:00
/* Callback context for the buffer queue callback function */
/* Get the SL Engine Interface which is implicit */
res = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void *)&EngineItf);
2014-02-10 09:10:30 +08:00
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
{
const SLInterfaceID ids[1] = { SL_IID_ENVIRONMENTALREVERB };
const SLboolean req[1] = { SL_BOOLEAN_FALSE };
res = (*EngineItf)->CreateOutputMix(EngineItf, &OutputMix, 0, ids, req);
2014-02-10 09:10:30 +08:00
}
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
// Realizing the Output Mix object in synchronous mode.
2014-02-10 09:10:30 +08:00
res = (*OutputMix)->Realize(OutputMix, SL_BOOLEAN_FALSE);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = { SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, BUFFER_COUNT };
//bufferQueue.locatorType = SL_DATALOCATOR_BUFFERQUEUE;
//bufferQueue.numBuffers = BUFFER_COUNT; /* Four buffers in our buffer queue */
2014-02-10 09:10:30 +08:00
/* Setup the format of the content in the buffer queue */
pcm.formatType = SL_DATAFORMAT_PCM;
pcm.numChannels = 2;
pcm.samplesPerSec = SL_SAMPLINGRATE_44_1;
pcm.bitsPerSample = SL_PCMSAMPLEFORMAT_FIXED_16;
pcm.containerSize = SL_PCMSAMPLEFORMAT_FIXED_16;
pcm.channelMask = SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT;
#ifdef BIG_ENDIAN_ENABLED
pcm.endianness = SL_BYTEORDER_BIGENDIAN;
#else
pcm.endianness = SL_BYTEORDER_LITTLEENDIAN;
#endif
audioSource.pFormat = (void *)&pcm;
audioSource.pLocator = (void *)&loc_bufq;
/* Setup the data sink structure */
locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX;
locator_outputmix.outputMix = OutputMix;
2014-02-10 09:10:30 +08:00
audioSink.pLocator = (void *)&locator_outputmix;
2020-04-02 07:20:12 +08:00
audioSink.pFormat = nullptr;
2014-02-10 09:10:30 +08:00
/* Initialize the context for Buffer queue callbacks */
//cntxt.pDataBase = (void*)&pcmData;
2014-02-10 09:10:30 +08:00
//cntxt.pData = cntxt.pDataBase;
//cntxt.size = sizeof(pcmData);
2018-03-26 07:36:34 +08:00
2014-02-10 09:10:30 +08:00
/* Create the music player */
{
const SLInterfaceID ids[2] = { SL_IID_BUFFERQUEUE, SL_IID_EFFECTSEND };
const SLboolean req[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
2014-02-10 09:10:30 +08:00
res = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &audioSource, &audioSink, 1, ids, req);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
}
/* Realizing the player in synchronous mode. */
res = (*player)->Realize(player, SL_BOOLEAN_FALSE);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
/* Get seek and play interfaces */
res = (*player)->GetInterface(player, SL_IID_PLAY, (void *)&playItf);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
res = (*player)->GetInterface(player, SL_IID_BUFFERQUEUE,
(void *)&bufferQueueItf);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
/* Setup to receive buffer queue event callbacks */
res = (*bufferQueueItf)->RegisterCallback(bufferQueueItf, _buffer_callbacks, this);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2017-08-28 03:07:15 +08:00
last_free = 0;
2017-08-28 03:07:15 +08:00
2014-02-10 09:10:30 +08:00
//fill up buffers
for (int i = 0; i < BUFFER_COUNT; i++) {
2014-02-10 09:10:30 +08:00
/* Enqueue a few buffers to get the ball rolling */
res = (*bufferQueueItf)->Enqueue(bufferQueueItf, buffers[i], 4 * buffer_size); /* Size given in */
2014-02-10 09:10:30 +08:00
}
res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
2014-02-10 09:10:30 +08:00
active = true;
2014-02-10 09:10:30 +08:00
}
void AudioDriverOpenSL::_record_buffer_callback(SLAndroidSimpleBufferQueueItf queueItf) {
for (int i = 0; i < rec_buffer.size(); i++) {
int32_t sample = rec_buffer[i] << 16;
input_buffer_write(sample);
input_buffer_write(sample); // call twice to convert to Stereo
}
SLresult res = (*recordBufferQueueItf)->Enqueue(recordBufferQueueItf, rec_buffer.ptrw(), rec_buffer.size() * sizeof(int16_t));
ERR_FAIL_COND(res != SL_RESULT_SUCCESS);
}
void AudioDriverOpenSL::_record_buffer_callbacks(SLAndroidSimpleBufferQueueItf queueItf, void *pContext) {
AudioDriverOpenSL *ad = (AudioDriverOpenSL *)pContext;
ad->_record_buffer_callback(queueItf);
}
Error AudioDriverOpenSL::capture_init_device() {
SLDataLocator_IODevice loc_dev = {
SL_DATALOCATOR_IODEVICE,
SL_IODEVICE_AUDIOINPUT,
SL_DEFAULTDEVICEID_AUDIOINPUT,
2020-04-02 07:20:12 +08:00
nullptr
};
2020-04-02 07:20:12 +08:00
SLDataSource recSource = { &loc_dev, nullptr };
SLDataLocator_AndroidSimpleBufferQueue loc_bq = {
SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,
2
};
SLDataFormat_PCM format_pcm = {
SL_DATAFORMAT_PCM,
1,
SL_SAMPLINGRATE_44_1,
SL_PCMSAMPLEFORMAT_FIXED_16,
SL_PCMSAMPLEFORMAT_FIXED_16,
SL_SPEAKER_FRONT_CENTER,
SL_BYTEORDER_LITTLEENDIAN
};
SLDataSink recSnk = { &loc_bq, &format_pcm };
const SLInterfaceID ids[2] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE, SL_IID_ANDROIDCONFIGURATION };
const SLboolean req[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
SLresult res = (*EngineItf)->CreateAudioRecorder(EngineItf, &recorder, &recSource, &recSnk, 2, ids, req);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recorder)->Realize(recorder, SL_BOOLEAN_FALSE);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recorder)->GetInterface(recorder, SL_IID_RECORD, (void *)&recordItf);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recorder)->GetInterface(recorder, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, (void *)&recordBufferQueueItf);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recordBufferQueueItf)->RegisterCallback(recordBufferQueueItf, _record_buffer_callbacks, this);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
SLuint32 state;
res = (*recordItf)->GetRecordState(recordItf, &state);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
if (state != SL_RECORDSTATE_STOPPED) {
res = (*recordItf)->SetRecordState(recordItf, SL_RECORDSTATE_STOPPED);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recordBufferQueueItf)->Clear(recordBufferQueueItf);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
}
const int rec_buffer_frames = 2048;
rec_buffer.resize(rec_buffer_frames);
input_buffer_init(rec_buffer_frames);
res = (*recordBufferQueueItf)->Enqueue(recordBufferQueueItf, rec_buffer.ptrw(), rec_buffer.size() * sizeof(int16_t));
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recordItf)->SetRecordState(recordItf, SL_RECORDSTATE_RECORDING);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
return OK;
}
Error AudioDriverOpenSL::capture_start() {
if (OS::get_singleton()->request_permission("RECORD_AUDIO")) {
return capture_init_device();
}
return OK;
}
Error AudioDriverOpenSL::capture_stop() {
SLuint32 state;
SLresult res = (*recordItf)->GetRecordState(recordItf, &state);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
if (state != SL_RECORDSTATE_STOPPED) {
res = (*recordItf)->SetRecordState(recordItf, SL_RECORDSTATE_STOPPED);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
res = (*recordBufferQueueItf)->Clear(recordBufferQueueItf);
ERR_FAIL_COND_V(res != SL_RESULT_SUCCESS, ERR_CANT_OPEN);
}
return OK;
}
int AudioDriverOpenSL::get_mix_rate() const {
return 44100; // hardcoded for Android, as selected by SL_SAMPLINGRATE_44_1
2014-02-10 09:10:30 +08:00
}
AudioDriver::SpeakerMode AudioDriverOpenSL::get_speaker_mode() const {
return SPEAKER_MODE_STEREO;
2014-02-10 09:10:30 +08:00
}
void AudioDriverOpenSL::lock() {
2020-03-01 02:40:24 +08:00
if (active)
mutex.lock();
2014-02-10 09:10:30 +08:00
}
void AudioDriverOpenSL::unlock() {
2020-03-01 02:40:24 +08:00
if (active)
mutex.unlock();
2014-02-10 09:10:30 +08:00
}
void AudioDriverOpenSL::finish() {
2014-02-10 09:10:30 +08:00
(*sl)->Destroy(sl);
}
void AudioDriverOpenSL::set_pause(bool p_pause) {
pause = p_pause;
if (active) {
if (pause) {
(*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED);
} else {
(*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
}
}
}
AudioDriverOpenSL::AudioDriverOpenSL() {
s_ad = this;
pause = false;
active = false;
2014-02-10 09:10:30 +08:00
}