mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 05:38:58 +00:00
Otherwise we might end up reading too much from the audioringbuffer, which would result in reading silence.
1016 lines
30 KiB
C
1016 lines
30 KiB
C
/* GStreamer
|
|
* Copyright (C) 2012 Fluendo S.A. <support@fluendo.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <string.h>
|
|
|
|
#include "opensles.h"
|
|
#include "openslesringbuffer.h"
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (opensles_ringbuffer_debug);
|
|
#define GST_CAT_DEFAULT opensles_ringbuffer_debug
|
|
|
|
#define _do_init \
|
|
GST_DEBUG_CATEGORY_INIT (opensles_ringbuffer_debug, \
|
|
"opensles_ringbuffer", 0, "OpenSL ES ringbuffer");
|
|
|
|
#define parent_class gst_opensles_ringbuffer_parent_class
|
|
G_DEFINE_TYPE_WITH_CODE (GstOpenSLESRingBuffer, gst_opensles_ringbuffer,
|
|
GST_TYPE_AUDIO_RING_BUFFER, _do_init);
|
|
|
|
/*
|
|
* Some generic helper functions
|
|
*/
|
|
|
|
static inline SLuint32
|
|
_opensles_sample_rate (guint rate)
|
|
{
|
|
switch (rate) {
|
|
case 8000:
|
|
return SL_SAMPLINGRATE_8;
|
|
case 11025:
|
|
return SL_SAMPLINGRATE_11_025;
|
|
case 12000:
|
|
return SL_SAMPLINGRATE_12;
|
|
case 16000:
|
|
return SL_SAMPLINGRATE_16;
|
|
case 22050:
|
|
return SL_SAMPLINGRATE_22_05;
|
|
case 24000:
|
|
return SL_SAMPLINGRATE_24;
|
|
case 32000:
|
|
return SL_SAMPLINGRATE_32;
|
|
case 44100:
|
|
return SL_SAMPLINGRATE_44_1;
|
|
case 48000:
|
|
return SL_SAMPLINGRATE_48;
|
|
case 64000:
|
|
return SL_SAMPLINGRATE_64;
|
|
case 88200:
|
|
return SL_SAMPLINGRATE_88_2;
|
|
case 96000:
|
|
return SL_SAMPLINGRATE_96;
|
|
case 192000:
|
|
return SL_SAMPLINGRATE_192;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static inline SLuint32
|
|
_opensles_channel_mask (GstAudioRingBufferSpec * spec)
|
|
{
|
|
switch (spec->info.channels) {
|
|
case 1:
|
|
return (SL_SPEAKER_FRONT_CENTER);
|
|
case 2:
|
|
return (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
_opensles_format (GstAudioRingBufferSpec * spec, SLDataFormat_PCM * format)
|
|
{
|
|
format->formatType = SL_DATAFORMAT_PCM;
|
|
format->numChannels = spec->info.channels;
|
|
format->samplesPerSec = _opensles_sample_rate (spec->info.rate);
|
|
format->bitsPerSample = spec->info.finfo->depth;
|
|
format->containerSize = spec->info.finfo->width;
|
|
format->channelMask = _opensles_channel_mask (spec);
|
|
format->endianness =
|
|
((spec->info.finfo->endianness ==
|
|
G_BIG_ENDIAN) ? SL_BYTEORDER_BIGENDIAN : SL_BYTEORDER_LITTLEENDIAN);
|
|
}
|
|
|
|
/*
|
|
* Recorder related functions
|
|
*/
|
|
|
|
static gboolean
|
|
_opensles_recorder_acquire (GstAudioRingBuffer * rb,
|
|
GstAudioRingBufferSpec * spec)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
SLDataFormat_PCM format;
|
|
|
|
/* Configure audio source */
|
|
SLDataLocator_IODevice loc_dev = {
|
|
SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT,
|
|
SL_DEFAULTDEVICEID_AUDIOINPUT, NULL
|
|
};
|
|
SLDataSource audioSrc = { &loc_dev, NULL };
|
|
|
|
/* Configure audio sink */
|
|
SLDataLocator_AndroidSimpleBufferQueue loc_bq = {
|
|
SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2
|
|
};
|
|
SLDataSink audioSink = { &loc_bq, &format };
|
|
|
|
/* Required optional interfaces */
|
|
const SLInterfaceID id[1] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE };
|
|
const SLboolean req[1] = { SL_BOOLEAN_TRUE };
|
|
|
|
/* Define the audio format in OpenSL ES terminology */
|
|
_opensles_format (spec, &format);
|
|
|
|
/* Create the audio recorder object (requires the RECORD_AUDIO permission) */
|
|
result = (*thiz->engineEngine)->CreateAudioRecorder (thiz->engineEngine,
|
|
&thiz->recorderObject, &audioSrc, &audioSink, 1, id, req);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "engine.CreateAudioRecorder failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Realize the audio recorder object */
|
|
result =
|
|
(*thiz->recorderObject)->Realize (thiz->recorderObject, SL_BOOLEAN_FALSE);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "recorder.Realize failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the record interface */
|
|
result = (*thiz->recorderObject)->GetInterface (thiz->recorderObject,
|
|
SL_IID_RECORD, &thiz->recorderRecord);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "recorder.GetInterface(Record) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the buffer queue interface */
|
|
result =
|
|
(*thiz->recorderObject)->GetInterface (thiz->recorderObject,
|
|
SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &thiz->bufferQueue);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "recorder.GetInterface(BufferQueue) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
failed:
|
|
return FALSE;
|
|
}
|
|
|
|
/* This callback function is executed when the ringbuffer is started to preroll
|
|
* the output buffer queue with empty buffers, from app thread, and each time
|
|
* there's a filled buffer, from audio device processing thread,
|
|
* the callback behaviour.
|
|
*/
|
|
static void
|
|
_opensles_recorder_cb (SLAndroidSimpleBufferQueueItf bufferQueue, void *context)
|
|
{
|
|
GstAudioRingBuffer *rb = GST_AUDIO_RING_BUFFER_CAST (context);
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
guint8 *ptr;
|
|
gint seg;
|
|
gint len;
|
|
|
|
/* Advance only when we are called by the callback function */
|
|
if (bufferQueue) {
|
|
gst_audio_ring_buffer_advance (rb, 1);
|
|
}
|
|
|
|
/* Get a segment form the GStreamer ringbuffer to write in */
|
|
if (!gst_audio_ring_buffer_prepare_read (rb, &seg, &ptr, &len)) {
|
|
GST_WARNING_OBJECT (rb, "No segment available");
|
|
return;
|
|
}
|
|
|
|
GST_LOG_OBJECT (thiz, "enqueue: %p size %d segment: %d", ptr, len, seg);
|
|
|
|
/* Enqueue the sefment as buffer to be written */
|
|
result = (*thiz->bufferQueue)->Enqueue (thiz->bufferQueue, ptr, len);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.Enqueue failed(0x%08x)",
|
|
(guint32) result);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_recorder_start (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
|
|
/* Register callback on the buffer queue */
|
|
if (!thiz->is_queue_callback_registered) {
|
|
result = (*thiz->bufferQueue)->RegisterCallback (thiz->bufferQueue,
|
|
_opensles_recorder_cb, rb);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.RegisterCallback failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
thiz->is_queue_callback_registered = TRUE;
|
|
}
|
|
|
|
/* Preroll one buffer */
|
|
_opensles_recorder_cb (NULL, rb);
|
|
|
|
/* Start recording */
|
|
result =
|
|
(*thiz->recorderRecord)->SetRecordState (thiz->recorderRecord,
|
|
SL_RECORDSTATE_RECORDING);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "recorder.SetRecordState failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_recorder_stop (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
|
|
/* Stop recording */
|
|
result =
|
|
(*thiz->recorderRecord)->SetRecordState (thiz->recorderRecord,
|
|
SL_RECORDSTATE_STOPPED);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "recorder.SetRecordState failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Unregister callback on the buffer queue */
|
|
result = (*thiz->bufferQueue)->RegisterCallback (thiz->bufferQueue,
|
|
NULL, NULL);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.RegisterCallback failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
thiz->is_queue_callback_registered = FALSE;
|
|
|
|
/* Reset the queue */
|
|
result = (*thiz->bufferQueue)->Clear (thiz->bufferQueue);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.Clear failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Player related functions
|
|
*/
|
|
|
|
static gboolean
|
|
_opensles_player_change_volume (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
SLresult result;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
if (thiz->playerVolume) {
|
|
gint millibel = (1.0 - thiz->volume) * -5000.0;
|
|
result =
|
|
(*thiz->playerVolume)->SetVolumeLevel (thiz->playerVolume, millibel);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetVolumeLevel failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
GST_DEBUG_OBJECT (thiz, "changed volume to %d", millibel);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_player_change_mute (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
SLresult result;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
if (thiz->playerVolume) {
|
|
result = (*thiz->playerVolume)->SetMute (thiz->playerVolume, thiz->mute);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetMute failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
GST_DEBUG_OBJECT (thiz, "changed mute to %d", thiz->mute);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* This is a callback function invoked by the playback device thread and
|
|
* it's used to monitor position changes */
|
|
static void
|
|
_opensles_player_event_cb (SLPlayItf caller, void *context, SLuint32 event)
|
|
{
|
|
if (event & SL_PLAYEVENT_HEADATNEWPOS) {
|
|
SLmillisecond position;
|
|
|
|
(*caller)->GetPosition (caller, &position);
|
|
GST_LOG_OBJECT (context, "at position=%u ms", (guint) position);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_player_acquire (GstAudioRingBuffer * rb,
|
|
GstAudioRingBufferSpec * spec)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
SLDataFormat_PCM format;
|
|
|
|
/* Configure audio source
|
|
* 4 buffers is the "typical" size as optimized inside Android's
|
|
* OpenSL ES, see frameworks/wilhelm/src/itfstruct.h BUFFER_HEADER_TYPICAL
|
|
*
|
|
* Also only use half of our segment size to make sure that there's always
|
|
* some more queued up in our ringbuffer and we don't start to read silence.
|
|
*/
|
|
SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {
|
|
SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, MIN (4, MAX (spec->segtotal >> 1,
|
|
1))
|
|
};
|
|
SLDataSource audioSrc = { &loc_bufq, &format };
|
|
|
|
/* Configure audio sink */
|
|
SLDataLocator_OutputMix loc_outmix = {
|
|
SL_DATALOCATOR_OUTPUTMIX, thiz->outputMixObject
|
|
};
|
|
SLDataSink audioSink = { &loc_outmix, NULL };
|
|
|
|
/* Define the required interfaces */
|
|
const SLInterfaceID ids[2] = { SL_IID_BUFFERQUEUE, SL_IID_VOLUME };
|
|
const SLboolean req[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE };
|
|
|
|
/* Define the format in OpenSL ES terminology */
|
|
_opensles_format (spec, &format);
|
|
|
|
/* Create the player object */
|
|
result = (*thiz->engineEngine)->CreateAudioPlayer (thiz->engineEngine,
|
|
&thiz->playerObject, &audioSrc, &audioSink, 2, ids, req);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "engine.CreateAudioPlayer failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Realize the player object */
|
|
result =
|
|
(*thiz->playerObject)->Realize (thiz->playerObject, SL_BOOLEAN_FALSE);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.Realize failed(0x%08x)", (guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the play interface */
|
|
result = (*thiz->playerObject)->GetInterface (thiz->playerObject,
|
|
SL_IID_PLAY, &thiz->playerPlay);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.GetInterface(Play) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the buffer queue interface */
|
|
result = (*thiz->playerObject)->GetInterface (thiz->playerObject,
|
|
SL_IID_BUFFERQUEUE, &thiz->bufferQueue);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.GetInterface(BufferQueue) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the volume interface */
|
|
result = (*thiz->playerObject)->GetInterface (thiz->playerObject,
|
|
SL_IID_VOLUME, &thiz->playerVolume);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.GetInterface(Volume) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Request position update events at each 20 ms */
|
|
result = (*thiz->playerPlay)->SetPositionUpdatePeriod (thiz->playerPlay, 20);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetPositionUpdatePeriod failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Define the event mask to be monitorized */
|
|
result = (*thiz->playerPlay)->SetCallbackEventsMask (thiz->playerPlay,
|
|
SL_PLAYEVENT_HEADATNEWPOS);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetCallbackEventsMask failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Register a callback to process the events */
|
|
result = (*thiz->playerPlay)->RegisterCallback (thiz->playerPlay,
|
|
_opensles_player_event_cb, thiz);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.RegisterCallback(event_cb) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Configure the volume and mute state */
|
|
_opensles_player_change_volume (rb);
|
|
_opensles_player_change_mute (rb);
|
|
|
|
/* Allocate the queue associated ringbuffer memory */
|
|
thiz->data_segtotal = loc_bufq.numBuffers;
|
|
thiz->data_size = spec->segsize * thiz->data_segtotal;
|
|
thiz->data = g_malloc0 (thiz->data_size);
|
|
g_atomic_int_set (&thiz->segqueued, 0);
|
|
g_atomic_int_set (&thiz->is_prerolled, 0);
|
|
thiz->cursor = 0;
|
|
|
|
return TRUE;
|
|
|
|
failed:
|
|
return FALSE;
|
|
}
|
|
|
|
/* This callback function is executed when the ringbuffer is started to preroll
|
|
* the input buffer queue with few buffers, from app thread, and each time
|
|
* that rendering of one buffer finishes, from audio device processing thread,
|
|
* the callback behaviour.
|
|
*
|
|
* We wrap the queue behaviour with an appropriate chunk of memory (queue len *
|
|
* ringbuffer segment size) which is used to hold the audio data while it's
|
|
* being processed in the queue. The memory region is used whit a ringbuffer
|
|
* behaviour.
|
|
*/
|
|
static void
|
|
_opensles_player_cb (SLAndroidSimpleBufferQueueItf bufferQueue, void *context)
|
|
{
|
|
GstAudioRingBuffer *rb = GST_AUDIO_RING_BUFFER_CAST (context);
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
guint8 *ptr, *cur;
|
|
gint seg;
|
|
gint len;
|
|
|
|
/* Get a segment form the GStreamer ringbuffer to read some samples */
|
|
if (!gst_audio_ring_buffer_prepare_read (rb, &seg, &ptr, &len)) {
|
|
GST_WARNING_OBJECT (rb, "No segment available");
|
|
return;
|
|
}
|
|
|
|
/* copy the segment data to our queue associated ringbuffer memory */
|
|
cur = thiz->data + (thiz->cursor * rb->spec.segsize);
|
|
memcpy (cur, ptr, len);
|
|
g_atomic_int_inc (&thiz->segqueued);
|
|
|
|
GST_LOG_OBJECT (thiz, "enqueue: %p size %d segment: %d in queue[%d]",
|
|
cur, len, seg, thiz->cursor);
|
|
/* advance the cursor in our queue associated ringbuffer */
|
|
thiz->cursor = (thiz->cursor + 1) % thiz->data_segtotal;
|
|
|
|
/* Enqueue the buffer to be rendered */
|
|
result = (*thiz->bufferQueue)->Enqueue (thiz->bufferQueue, cur, len);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.Enqueue failed(0x%08x)",
|
|
(guint32) result);
|
|
return;
|
|
}
|
|
|
|
/* Fill with silence samples the segment of the GStreamer ringbuffer */
|
|
gst_audio_ring_buffer_clear (rb, seg);
|
|
/* Make the segment reusable */
|
|
gst_audio_ring_buffer_advance (rb, 1);
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_player_start (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
|
|
/* Register callback on the buffer queue */
|
|
if (!thiz->is_queue_callback_registered) {
|
|
result = (*thiz->bufferQueue)->RegisterCallback (thiz->bufferQueue,
|
|
_opensles_player_cb, rb);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.RegisterCallback failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
thiz->is_queue_callback_registered = TRUE;
|
|
}
|
|
|
|
/* Fill the queue by enqueing a buffer */
|
|
if (!g_atomic_int_get (&thiz->is_prerolled)) {
|
|
_opensles_player_cb (NULL, rb);
|
|
g_atomic_int_set (&thiz->is_prerolled, 1);
|
|
}
|
|
|
|
/* Change player state into PLAYING */
|
|
result =
|
|
(*thiz->playerPlay)->SetPlayState (thiz->playerPlay,
|
|
SL_PLAYSTATE_PLAYING);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetPlayState failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_player_pause (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
|
|
result =
|
|
(*thiz->playerPlay)->SetPlayState (thiz->playerPlay, SL_PLAYSTATE_PAUSED);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetPlayState failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
_opensles_player_stop (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
SLresult result;
|
|
|
|
/* Change player state into STOPPED */
|
|
result =
|
|
(*thiz->playerPlay)->SetPlayState (thiz->playerPlay,
|
|
SL_PLAYSTATE_STOPPED);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "player.SetPlayState failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Unregister callback on the buffer queue */
|
|
result = (*thiz->bufferQueue)->RegisterCallback (thiz->bufferQueue,
|
|
NULL, NULL);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.RegisterCallback failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
thiz->is_queue_callback_registered = FALSE;
|
|
|
|
/* Reset the queue */
|
|
result = (*thiz->bufferQueue)->Clear (thiz->bufferQueue);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "bufferQueue.Clear failed(0x%08x)",
|
|
(guint32) result);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Reset our state */
|
|
g_atomic_int_set (&thiz->segqueued, 0);
|
|
thiz->cursor = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* OpenSL ES ringbuffer wrapper
|
|
*/
|
|
|
|
GstAudioRingBuffer *
|
|
gst_opensles_ringbuffer_new (RingBufferMode mode)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
g_return_val_if_fail (mode > RB_MODE_NONE && mode < RB_MODE_LAST, NULL);
|
|
|
|
thiz = g_object_new (GST_TYPE_OPENSLES_RING_BUFFER, NULL);
|
|
|
|
if (thiz) {
|
|
thiz->mode = mode;
|
|
if (mode == RB_MODE_SRC) {
|
|
thiz->acquire = _opensles_recorder_acquire;
|
|
thiz->start = _opensles_recorder_start;
|
|
thiz->pause = _opensles_recorder_stop;
|
|
thiz->stop = _opensles_recorder_stop;
|
|
thiz->change_volume = NULL;
|
|
} else if (mode == RB_MODE_SINK_PCM) {
|
|
thiz->acquire = _opensles_player_acquire;
|
|
thiz->start = _opensles_player_start;
|
|
thiz->pause = _opensles_player_pause;
|
|
thiz->stop = _opensles_player_stop;
|
|
thiz->change_volume = _opensles_player_change_volume;
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer created");
|
|
|
|
return GST_AUDIO_RING_BUFFER (thiz);
|
|
}
|
|
|
|
void
|
|
gst_opensles_ringbuffer_set_volume (GstAudioRingBuffer * rb, gfloat volume)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
thiz->volume = volume;
|
|
|
|
if (thiz->change_volume) {
|
|
thiz->change_volume (rb);
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_opensles_ringbuffer_set_mute (GstAudioRingBuffer * rb, gboolean mute)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
thiz->mute = mute;
|
|
|
|
if (thiz->change_mute) {
|
|
thiz->change_mute (rb);
|
|
}
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_open_device (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
SLresult result;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
/* Create and realize the engine object */
|
|
thiz->engineObject = gst_opensles_get_engine ();
|
|
if (!thiz->engineObject) {
|
|
GST_ERROR_OBJECT (thiz, "Failed to get engine object");
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the engine interface, which is needed in order to create other objects */
|
|
result = (*thiz->engineObject)->GetInterface (thiz->engineObject,
|
|
SL_IID_ENGINE, &thiz->engineEngine);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "engine.GetInterface(Engine) failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
if (thiz->mode == RB_MODE_SINK_PCM) {
|
|
SLOutputMixItf outputMix;
|
|
|
|
/* Create an output mixer object */
|
|
result = (*thiz->engineEngine)->CreateOutputMix (thiz->engineEngine,
|
|
&thiz->outputMixObject, 0, NULL, NULL);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "engine.CreateOutputMix failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Realize the output mixer object */
|
|
result = (*thiz->outputMixObject)->Realize (thiz->outputMixObject,
|
|
SL_BOOLEAN_FALSE);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_ERROR_OBJECT (thiz, "outputMix.Realize failed(0x%08x)",
|
|
(guint32) result);
|
|
goto failed;
|
|
}
|
|
|
|
/* Get the mixer interface */
|
|
result = (*thiz->outputMixObject)->GetInterface (thiz->outputMixObject,
|
|
SL_IID_OUTPUTMIX, &outputMix);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_WARNING_OBJECT (thiz, "outputMix.GetInterface failed(0x%08x)",
|
|
(guint32) result);
|
|
} else {
|
|
SLint32 numDevices = MAX_NUMBER_OUTPUT_DEVICES;
|
|
SLuint32 deviceIDs[MAX_NUMBER_OUTPUT_DEVICES];
|
|
gint i;
|
|
|
|
/* Query the list of output devices */
|
|
(*outputMix)->GetDestinationOutputDeviceIDs (outputMix, &numDevices,
|
|
deviceIDs);
|
|
GST_DEBUG_OBJECT (thiz, "Found %d output devices", (gint) numDevices);
|
|
for (i = 0; i < numDevices; i++) {
|
|
GST_DEBUG_OBJECT (thiz, " DeviceID: %08x", (guint) deviceIDs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (thiz, "device opened");
|
|
return TRUE;
|
|
|
|
failed:
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_close_device (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
/* Destroy the output mix object */
|
|
if (thiz->outputMixObject) {
|
|
(*thiz->outputMixObject)->Destroy (thiz->outputMixObject);
|
|
thiz->outputMixObject = NULL;
|
|
}
|
|
|
|
/* Destroy the engine object and invalidate all associated interfaces */
|
|
if (thiz->engineObject) {
|
|
gst_opensles_release_engine (thiz->engineObject);
|
|
thiz->engineObject = NULL;
|
|
thiz->engineEngine = NULL;
|
|
}
|
|
|
|
thiz->bufferQueue = NULL;
|
|
|
|
GST_DEBUG_OBJECT (thiz, "device closed");
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_acquire (GstAudioRingBuffer * rb,
|
|
GstAudioRingBufferSpec * spec)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
/* Instantiate and configure the OpenSL ES interfaces */
|
|
if (!thiz->acquire (rb, spec)) {
|
|
return FALSE;
|
|
}
|
|
|
|
/* Initialize our ringbuffer memory region */
|
|
rb->size = spec->segtotal * spec->segsize;
|
|
rb->memory = g_malloc0 (rb->size);
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer acquired");
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_release (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER (rb);
|
|
|
|
/* XXX: We need to sleep a bit before destroying the player object
|
|
* because of a bug in Android in versions < 4.2.
|
|
*
|
|
* OpenSLES is using AudioTrack for rendering the sound. AudioTrack
|
|
* has a thread that pulls raw audio from the buffer queue and then
|
|
* passes it forward to AudioFlinger (AudioTrack::processAudioBuffer()).
|
|
* This thread is calling various callbacks on events, e.g. when
|
|
* an underrun happens or to request data. OpenSLES sets this callback
|
|
* on AudioTrack (audioTrack_callBack_pullFromBuffQueue() from
|
|
* android_AudioPlayer.cpp). Among other things this is taking a lock
|
|
* on the player interface.
|
|
*
|
|
* Now if we destroy the player interface object, it will first of all
|
|
* take the player interface lock (IObject_Destroy()). Then it destroys
|
|
* the audio player instance (android_audioPlayer_destroy()) which then
|
|
* calls stop() on the AudioTrack and deletes it. Now the destructor of
|
|
* AudioTrack will wait until the rendering thread (AudioTrack::processAudioBuffer())
|
|
* has finished.
|
|
*
|
|
* If all this happens with bad timing it can happen that the rendering
|
|
* thread is currently e.g. handling underrun but did not lock the player
|
|
* interface object yet. Then destroying happens and takes the lock and waits
|
|
* for the thread to finish. Then the thread tries to take the lock and waits
|
|
* forever.
|
|
*
|
|
* We wait a bit before destroying the player object to make sure that
|
|
* the rendering thread finished whatever it was doing, and then stops
|
|
* (note: we called gst_opensles_ringbuffer_stop() before this already).
|
|
*/
|
|
|
|
/* Destroy audio player object, and invalidate all associated interfaces */
|
|
if (thiz->playerObject) {
|
|
g_usleep (50000);
|
|
(*thiz->playerObject)->Destroy (thiz->playerObject);
|
|
thiz->playerObject = NULL;
|
|
thiz->playerPlay = NULL;
|
|
thiz->playerVolume = NULL;
|
|
}
|
|
|
|
/* Destroy audio recorder object, and invalidate all associated interfaces */
|
|
if (thiz->recorderObject) {
|
|
g_usleep (50000);
|
|
(*thiz->recorderObject)->Destroy (thiz->recorderObject);
|
|
thiz->recorderObject = NULL;
|
|
thiz->recorderRecord = NULL;
|
|
}
|
|
|
|
if (thiz->data) {
|
|
g_free (thiz->data);
|
|
thiz->data = NULL;
|
|
}
|
|
|
|
if (rb->memory) {
|
|
g_free (rb->memory);
|
|
rb->memory = NULL;
|
|
rb->size = 0;
|
|
}
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer released");
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_start (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
gboolean res;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
res = thiz->start (rb);
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer %s started", (res ? "" : "not"));
|
|
return res;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_pause (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
gboolean res;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
res = thiz->pause (rb);
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer %s paused", (res ? "" : "not"));
|
|
return res;
|
|
}
|
|
|
|
static gboolean
|
|
gst_opensles_ringbuffer_stop (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
gboolean res;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
res = thiz->stop (rb);
|
|
|
|
GST_DEBUG_OBJECT (thiz, "ringbuffer %s stopped", (res ? " " : "not"));
|
|
return res;
|
|
}
|
|
|
|
static guint
|
|
gst_opensles_ringbuffer_delay (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
guint res = 0;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
if (thiz->playerPlay) {
|
|
SLuint32 state;
|
|
SLmillisecond position;
|
|
guint64 playedpos = 0, queuedpos = 0;
|
|
(*thiz->playerPlay)->GetPlayState (thiz->playerPlay, &state);
|
|
if (state == SL_PLAYSTATE_PLAYING) {
|
|
(*thiz->playerPlay)->GetPosition (thiz->playerPlay, &position);
|
|
playedpos =
|
|
gst_util_uint64_scale_round (position, rb->spec.info.rate, 1000);
|
|
queuedpos = g_atomic_int_get (&thiz->segqueued) * rb->samples_per_seg;
|
|
res = queuedpos - playedpos;
|
|
}
|
|
|
|
GST_LOG_OBJECT (thiz, "queued samples %" G_GUINT64_FORMAT " position %u ms "
|
|
"(%" G_GUINT64_FORMAT " samples) delay %u samples",
|
|
queuedpos, (guint) position, playedpos, res);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static void
|
|
gst_opensles_ringbuffer_clear_all (GstAudioRingBuffer * rb)
|
|
{
|
|
GstOpenSLESRingBuffer *thiz;
|
|
|
|
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
|
|
|
|
if (thiz->data) {
|
|
SLresult result;
|
|
|
|
memset (thiz->data, 0, thiz->data_size);
|
|
g_atomic_int_set (&thiz->segqueued, 0);
|
|
thiz->cursor = 0;
|
|
/* Reset the queue */
|
|
result = (*thiz->bufferQueue)->Clear (thiz->bufferQueue);
|
|
if (result != SL_RESULT_SUCCESS) {
|
|
GST_WARNING_OBJECT (thiz, "bufferQueue.Clear failed(0x%08x)",
|
|
(guint32) result);
|
|
}
|
|
g_atomic_int_set (&thiz->is_prerolled, 0);
|
|
}
|
|
|
|
GST_CALL_PARENT (GST_AUDIO_RING_BUFFER_CLASS, clear_all, (rb));
|
|
}
|
|
|
|
static void
|
|
gst_opensles_ringbuffer_dispose (GObject * object)
|
|
{
|
|
G_OBJECT_CLASS (parent_class)->dispose (object);
|
|
}
|
|
|
|
static void
|
|
gst_opensles_ringbuffer_finalize (GObject * object)
|
|
{
|
|
G_OBJECT_CLASS (parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
gst_opensles_ringbuffer_class_init (GstOpenSLESRingBufferClass * klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
GstAudioRingBufferClass *gstringbuffer_class;
|
|
|
|
gobject_class = (GObjectClass *) klass;
|
|
gstringbuffer_class = (GstAudioRingBufferClass *) klass;
|
|
|
|
gobject_class->dispose = gst_opensles_ringbuffer_dispose;
|
|
gobject_class->finalize = gst_opensles_ringbuffer_finalize;
|
|
|
|
gstringbuffer_class->open_device =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_open_device);
|
|
gstringbuffer_class->close_device =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_close_device);
|
|
gstringbuffer_class->acquire =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_acquire);
|
|
gstringbuffer_class->release =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_release);
|
|
gstringbuffer_class->start =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_start);
|
|
gstringbuffer_class->pause =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_pause);
|
|
gstringbuffer_class->resume =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_start);
|
|
gstringbuffer_class->stop = GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_stop);
|
|
gstringbuffer_class->delay =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_delay);
|
|
gstringbuffer_class->clear_all =
|
|
GST_DEBUG_FUNCPTR (gst_opensles_ringbuffer_clear_all);
|
|
}
|
|
|
|
static void
|
|
gst_opensles_ringbuffer_init (GstOpenSLESRingBuffer * thiz)
|
|
{
|
|
thiz->mode = RB_MODE_NONE;
|
|
thiz->engineObject = NULL;
|
|
thiz->outputMixObject = NULL;
|
|
thiz->playerObject = NULL;
|
|
thiz->recorderObject = NULL;
|
|
thiz->is_queue_callback_registered = FALSE;
|
|
}
|