566 lines
16 KiB
C++
566 lines
16 KiB
C++
/* Copyright (C) 2012 Doubango Telecom <http://www.doubango.org>
|
|
*
|
|
* This file is part of Open Source Doubango Framework.
|
|
*
|
|
* DOUBANGO is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* DOUBANGO is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with DOUBANGO.
|
|
*/
|
|
#include "audio_opensles.h"
|
|
|
|
#include "audio_opensles_consumer.h"
|
|
#include "audio_opensles_producer.h"
|
|
#include "audio_opensles_device.h"
|
|
#include "audio_opensles_device_impl.h"
|
|
|
|
#include "tinymedia/tmedia_consumer.h"
|
|
#include "tinymedia/tmedia_producer.h"
|
|
|
|
#include "tsk_list.h"
|
|
#include "tsk_safeobj.h"
|
|
#include "tsk_debug.h"
|
|
|
|
typedef enum PLUGIN_INDEX_E
|
|
{
|
|
PLUGIN_INDEX_AUDIO_CONSUMER,
|
|
PLUGIN_INDEX_AUDIO_PRODUCER,
|
|
PLUGIN_INDEX_COUNT
|
|
}
|
|
PLUGIN_INDEX_T;
|
|
|
|
|
|
int __plugin_get_def_count()
|
|
{
|
|
return PLUGIN_INDEX_COUNT;
|
|
}
|
|
|
|
tsk_plugin_def_type_t __plugin_get_def_type_at(int index)
|
|
{
|
|
switch(index){
|
|
case PLUGIN_INDEX_AUDIO_CONSUMER: return tsk_plugin_def_type_consumer;
|
|
case PLUGIN_INDEX_AUDIO_PRODUCER: return tsk_plugin_def_type_producer;
|
|
default:
|
|
{
|
|
AUDIO_OPENSLES_DEBUG_ERROR("No plugin at index %d", index);
|
|
return tsk_plugin_def_type_none;
|
|
}
|
|
}
|
|
}
|
|
|
|
tsk_plugin_def_media_type_t __plugin_get_def_media_type_at(int index)
|
|
{
|
|
switch(index){
|
|
case PLUGIN_INDEX_AUDIO_CONSUMER:
|
|
case PLUGIN_INDEX_AUDIO_PRODUCER:
|
|
{
|
|
return tsk_plugin_def_media_type_audio;
|
|
}
|
|
default:
|
|
{
|
|
AUDIO_OPENSLES_DEBUG_ERROR("No plugin at index %d", index);
|
|
return tsk_plugin_def_media_type_none;
|
|
}
|
|
}
|
|
}
|
|
|
|
tsk_plugin_def_ptr_const_t __plugin_get_def_at(int index)
|
|
{
|
|
switch(index){
|
|
case PLUGIN_INDEX_AUDIO_CONSUMER:
|
|
{
|
|
return audio_consumer_opensles_plugin_def_t;
|
|
}
|
|
case PLUGIN_INDEX_AUDIO_PRODUCER:
|
|
{
|
|
return audio_producer_opensles_plugin_def_t;
|
|
}
|
|
default:
|
|
{
|
|
AUDIO_OPENSLES_DEBUG_ERROR("No plugin at index %d", index);
|
|
return tsk_null;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// SLES AudioInstance
|
|
//
|
|
|
|
typedef struct audio_opensles_instance_s
|
|
{
|
|
TSK_DECLARE_OBJECT;
|
|
|
|
uint64_t sessionId;
|
|
|
|
bool isStarted;
|
|
|
|
bool isConsumerPrepared;
|
|
bool isConsumerStarted;
|
|
bool isProducerPrepared;
|
|
bool isProducerStarted;
|
|
|
|
bool isSpeakerAvailable;
|
|
bool isPlayoutAvailable;
|
|
bool isRecordingAvailable;
|
|
|
|
SLAudioDevice* device;
|
|
SLAudioDeviceCallbackImpl* callback;
|
|
|
|
TSK_DECLARE_SAFEOBJ;
|
|
}
|
|
audio_opensles_instance_t;
|
|
typedef tsk_list_t audio_opensles_instances_L_t;
|
|
|
|
static audio_opensles_instances_L_t* __audioInstances = tsk_null;
|
|
|
|
static tsk_object_t* audio_opensles_instance_ctor(tsk_object_t * self, va_list * app)
|
|
{
|
|
audio_opensles_instance_t* audioInstance = (audio_opensles_instance_t*)self;
|
|
if(audioInstance){
|
|
tsk_safeobj_init(audioInstance);
|
|
}
|
|
return self;
|
|
}
|
|
static tsk_object_t* audio_opensles_instance_dtor(tsk_object_t * self)
|
|
{
|
|
AUDIO_OPENSLES_DEBUG_INFO("Audio Instance destroyed");
|
|
audio_opensles_instance_t* audioInstance = (audio_opensles_instance_t*)self;
|
|
if(audioInstance){
|
|
tsk_safeobj_lock(audioInstance);
|
|
if(audioInstance->device){
|
|
audioInstance->device->SetCallback(NULL);
|
|
audioInstance->device->Terminate();
|
|
delete audioInstance->device;
|
|
audioInstance->device = tsk_null;
|
|
}
|
|
if(audioInstance->callback){
|
|
delete audioInstance->callback;
|
|
audioInstance->callback = tsk_null;
|
|
}
|
|
tsk_safeobj_unlock(audioInstance);
|
|
|
|
tsk_safeobj_deinit(audioInstance);
|
|
}
|
|
return self;
|
|
}
|
|
static int audio_opensles_instance_cmp(const tsk_object_t *_ai1, const tsk_object_t *_ai2)
|
|
{
|
|
return ((int)_ai1 - (int)_ai2);
|
|
}
|
|
static const tsk_object_def_t audio_opensles_instance_def_s =
|
|
{
|
|
sizeof(audio_opensles_instance_t),
|
|
audio_opensles_instance_ctor,
|
|
audio_opensles_instance_dtor,
|
|
audio_opensles_instance_cmp,
|
|
};
|
|
const tsk_object_def_t *audio_opensles_instance_def_t = &audio_opensles_instance_def_s;
|
|
|
|
|
|
audio_opensles_instance_handle_t* audio_opensles_instance_create(uint64_t sessionId)
|
|
{
|
|
audio_opensles_instance_t* audioInstance = tsk_null;
|
|
|
|
// create list used to hold instances
|
|
if(!__audioInstances && !(__audioInstances = tsk_list_create())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Failed to create new list");
|
|
return tsk_null;
|
|
}
|
|
|
|
//= lock the list
|
|
tsk_list_lock(__audioInstances);
|
|
|
|
// find the instance from the list
|
|
const tsk_list_item_t* item;
|
|
tsk_list_foreach(item, __audioInstances){
|
|
if(((audio_opensles_instance_t*)item->data)->sessionId == sessionId){
|
|
audioInstance = (audio_opensles_instance_t*)tsk_object_ref(item->data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!audioInstance){
|
|
audio_opensles_instance_t* _audioInstance;
|
|
if(!(_audioInstance = (audio_opensles_instance_t*)tsk_object_new(&audio_opensles_instance_def_s))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Failed to create new audio instance");
|
|
goto done;
|
|
}
|
|
|
|
if(!(_audioInstance->device = new SLAudioDevice())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Failed to create audio device");
|
|
TSK_OBJECT_SAFE_FREE(_audioInstance);
|
|
goto done;
|
|
}
|
|
|
|
if(!(_audioInstance->callback = new SLAudioDeviceCallbackImpl())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Failed to create audio transport");
|
|
TSK_OBJECT_SAFE_FREE(_audioInstance);
|
|
goto done;
|
|
}
|
|
if((_audioInstance->device->SetCallback(_audioInstance->callback))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("AudioDeviceModule::RegisterAudioCallback() failed");
|
|
TSK_OBJECT_SAFE_FREE(_audioInstance);
|
|
goto done;
|
|
}
|
|
|
|
if((_audioInstance->device->Init())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("AudioDeviceModule::Init() failed");
|
|
TSK_OBJECT_SAFE_FREE(_audioInstance);
|
|
goto done;
|
|
}
|
|
|
|
_audioInstance->sessionId = sessionId;
|
|
audioInstance = _audioInstance;
|
|
tsk_list_push_back_data(__audioInstances, (void**)&_audioInstance);
|
|
}
|
|
|
|
done:
|
|
//= unlock the list
|
|
tsk_list_unlock(__audioInstances);
|
|
|
|
return audioInstance;
|
|
}
|
|
|
|
int audio_opensles_instance_prepare_consumer(audio_opensles_instance_handle_t* _self, tmedia_consumer_t** _consumer)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
const struct audio_consumer_opensles_s* consumer = (const struct audio_consumer_opensles_s*)*_consumer;
|
|
if(!self || !self->device || !self->callback || !_consumer || !*_consumer){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
if(self->isConsumerPrepared){
|
|
AUDIO_OPENSLES_DEBUG_WARN("Consumer already prepared");
|
|
return 0;
|
|
}
|
|
|
|
int ret;
|
|
bool _bool;
|
|
|
|
tsk_safeobj_lock(self);
|
|
|
|
self->callback->SetConsumer(consumer);
|
|
|
|
if((ret = self->device->SpeakerIsAvailable(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SpeakerIsAvailable() failed with error code=%d", ret);
|
|
}
|
|
else{
|
|
if(!_bool){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SpeakerIsAvailable() returned false");
|
|
}
|
|
self->isSpeakerAvailable = _bool;
|
|
}
|
|
|
|
if((ret = self->device->InitSpeaker())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("InitSpeaker() failed with error code=%d", ret);
|
|
}
|
|
else if((ret = self->device->SetSpeakerOn(audio_consumer_opensles_is_speakerOn(consumer)))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetSpeakerOn() failed with error code=%d", ret);
|
|
}
|
|
|
|
if((ret = self->device->PlayoutIsAvailable(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("PlayoutIsAvailable() failed with error code =%d", ret);
|
|
}
|
|
else{
|
|
if(!_bool){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("PlayoutIsAvailable() returned false");
|
|
}
|
|
self->isPlayoutAvailable = _bool;
|
|
}
|
|
|
|
if((ret = self->device->SetStereoPlayout(((*_consumer)->audio.in.channels == 2)))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetStereoPlayout(%d==2) failed with error code=%d", (*_consumer)->audio.in.channels, ret);
|
|
}
|
|
|
|
//if((ret = self->device->SetPlayoutBuffer(AudioDeviceModule::kFixedBufferSize, (*_consumer)->audio.ptime))){
|
|
// AUDIO_OPENSLES_DEBUG_ERROR("SetPlayoutBuffer(%d ms) failed with error code=%d", (*_consumer)->audio.ptime, ret);
|
|
//}
|
|
// always request 10ms buffers
|
|
if((ret = self->device->SetPlayoutBuffer(10))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetPlayoutBuffer(%d ms) failed with error code=%d", 10, ret);
|
|
}
|
|
|
|
int playoutSampleRate = (*_consumer)->audio.out.rate ? (*_consumer)->audio.out.rate : (*_consumer)->audio.in.rate;
|
|
if((ret = self->device->SetPlayoutSampleRate(playoutSampleRate))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetPlayoutSampleRate(%d) failed with error code=%d", playoutSampleRate, ret);
|
|
}
|
|
|
|
if((ret = self->device->InitPlayout())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("AudioDeviceModule::InitPlayout() failed with error code = %d", ret);
|
|
goto done;
|
|
}
|
|
|
|
// init output parameters
|
|
if((ret = self->device->StereoPlayout(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StereoPlayout() failed with error code=%d", ret);
|
|
}
|
|
else{
|
|
(*_consumer)->audio.out.channels = (_bool ? 2 : 1);
|
|
}
|
|
if((ret = self->device->PlayoutSampleRate(&playoutSampleRate))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("PlayoutSampleRate() failed with error code=%d", ret);
|
|
}
|
|
else{
|
|
(*_consumer)->audio.out.rate = playoutSampleRate;
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
|
|
self->isConsumerPrepared = (ret == 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int audio_opensles_instance_prepare_producer(audio_opensles_instance_handle_t* _self, tmedia_producer_t** _producer)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device || !self->callback || !_producer || !*_producer){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
if(self->isProducerPrepared){
|
|
AUDIO_OPENSLES_DEBUG_WARN("Producer already prepared");
|
|
return 0;
|
|
}
|
|
|
|
int ret;
|
|
bool _bool;
|
|
|
|
tsk_safeobj_lock(self);
|
|
|
|
self->callback->SetProducer((const struct audio_producer_opensles_s*)*_producer);
|
|
|
|
if((ret = self->device->RecordingIsAvailable(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("RecordingIsAvailable() failed with error code =%d", ret);
|
|
}
|
|
else{
|
|
if(!_bool){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("RecordingIsAvailable() returned false");
|
|
}
|
|
self->isRecordingAvailable = _bool;
|
|
}
|
|
|
|
if((ret = self->device->MicrophoneIsAvailable(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("MicrophoneIsAvailable() failed with error code =%d", ret);
|
|
}
|
|
else{
|
|
if(!_bool){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("MicrophoneIsAvailable() returned false");
|
|
}
|
|
else{
|
|
if((ret = self->device->InitMicrophone())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("InitMicrophone() failed with error code =%d", ret);
|
|
}
|
|
}
|
|
}
|
|
|
|
if((ret = self->device->SetStereoRecording(((*_producer)->audio.channels == 2)))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetStereoRecording(%d==2) failed with error code=%d", (*_producer)->audio.channels, ret);
|
|
}
|
|
|
|
int recordingSampleRate = (*_producer)->audio.rate;
|
|
if((ret = self->device->SetRecordingSampleRate(recordingSampleRate))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("SetRecordingSampleRate(%d) failed with error code=%d", recordingSampleRate, ret);
|
|
}
|
|
|
|
if((ret = self->device->InitRecording())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("AudioDeviceModule::InitRecording() failed with error code = %d", ret);
|
|
goto done;
|
|
}
|
|
|
|
// init output parameters
|
|
if((ret = self->device->StereoRecording(&_bool))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StereoRecording() failed with error code=%d", ret);
|
|
}
|
|
else{
|
|
(*_producer)->audio.channels = (_bool ? 2 : 1);
|
|
}
|
|
if((ret = self->device->RecordingSampleRate(&recordingSampleRate))){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("RecordingSampleRate() failed with error code=%d", ret);
|
|
}
|
|
else{
|
|
(*_producer)->audio.rate = recordingSampleRate;
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
|
|
self->isProducerPrepared = (ret == 0);
|
|
|
|
return ret;
|
|
}
|
|
|
|
int audio_opensles_instance_start_consumer(audio_opensles_instance_handle_t* _self)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device || !self->callback){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
tsk_safeobj_lock(self);
|
|
if(!self->isConsumerPrepared){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Consumer not prepared");
|
|
goto done;
|
|
}
|
|
|
|
if(self->isConsumerStarted){
|
|
AUDIO_OPENSLES_DEBUG_WARN("Consumer already started");
|
|
goto done;
|
|
}
|
|
|
|
if(self->isPlayoutAvailable){
|
|
int ret;
|
|
if((ret = self->device->StartPlayout())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StartPlayout() failed with error code = %d", ret);
|
|
}
|
|
|
|
self->isConsumerStarted = self->device->Playing();
|
|
AUDIO_OPENSLES_DEBUG_INFO("isPlaying=%s", (self->isConsumerPrepared ? "true" : "false"));
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
return (self->isConsumerStarted ? 0 : -1);
|
|
}
|
|
|
|
int audio_opensles_instance_start_producer(audio_opensles_instance_handle_t* _self)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device || !self->callback){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
tsk_safeobj_lock(self);
|
|
if(!self->isProducerPrepared){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Producer not prepared");
|
|
goto done;
|
|
}
|
|
|
|
if(self->isProducerStarted){
|
|
AUDIO_OPENSLES_DEBUG_WARN("Consumer already started");
|
|
goto done;
|
|
}
|
|
|
|
if(self->isRecordingAvailable){
|
|
int ret;
|
|
if((ret = self->device->StartRecording())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StartRecording() failed with error code = %d", ret);
|
|
}
|
|
|
|
self->isProducerStarted = self->device->Recording();
|
|
AUDIO_OPENSLES_DEBUG_INFO("isRecording=%s", (self->isProducerStarted ? "true" : "false"));
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
return (self->isProducerStarted ? 0 : -1);
|
|
}
|
|
|
|
int audio_opensles_instance_stop_consumer(audio_opensles_instance_handle_t* _self)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device || !self->callback){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
tsk_safeobj_lock(self);
|
|
|
|
if(!self->isConsumerStarted){
|
|
goto done;
|
|
}
|
|
|
|
int ret;
|
|
if((ret = self->device->StopPlayout())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StopPlayout() failed with error code = %d", ret);
|
|
}
|
|
else{
|
|
self->isConsumerStarted = self->device->Playing();
|
|
self->isConsumerPrepared = false;
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
return (self->isConsumerStarted ? -1 : 0);
|
|
}
|
|
|
|
int audio_opensles_instance_stop_producer(audio_opensles_instance_handle_t* _self)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device || !self->callback){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("invalid parameter");
|
|
return -1;
|
|
}
|
|
|
|
tsk_safeobj_lock(self);
|
|
|
|
if(!self->isProducerStarted){
|
|
goto done;
|
|
}
|
|
|
|
int ret;
|
|
if((ret = self->device->StopRecording())){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("StopRecording() failed with error code = %d", ret);
|
|
}
|
|
else{
|
|
self->isProducerStarted = self->device->Recording();
|
|
self->isProducerPrepared = false;
|
|
}
|
|
|
|
done:
|
|
tsk_safeobj_unlock(self);
|
|
return (self->isProducerStarted ? -1 : 0);
|
|
}
|
|
|
|
int audio_opensles_instance_set_speakerOn(audio_opensles_instance_handle_t* _self, bool speakerOn)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device ){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Invalid parameter");
|
|
return -1;
|
|
}
|
|
return self->device->SetSpeakerOn(speakerOn);
|
|
}
|
|
|
|
int audio_opensles_instance_set_microphone_volume(audio_opensles_instance_handle_t* _self, int32_t volume)
|
|
{
|
|
audio_opensles_instance_t* self = (audio_opensles_instance_t*)_self;
|
|
if(!self || !self->device ){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Invalid parameter");
|
|
return -1;
|
|
}
|
|
return self->device->SetMicrophoneVolume(volume);
|
|
}
|
|
|
|
int audio_opensles_instance_destroy(audio_opensles_instance_handle_t** _self){
|
|
if(!_self || !*_self){
|
|
AUDIO_OPENSLES_DEBUG_ERROR("Invalid parameter");
|
|
return -1;
|
|
}
|
|
tsk_list_lock(__audioInstances);
|
|
if(tsk_object_get_refcount(*_self)==1){
|
|
tsk_list_remove_item_by_data(__audioInstances, *_self);
|
|
}
|
|
else {
|
|
tsk_object_unref(*_self);
|
|
}
|
|
tsk_list_unlock(__audioInstances);
|
|
*_self = tsk_null;
|
|
return 0;
|
|
}
|
|
|