mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-20 23:36:38 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/sys/opensles/openslesringbuffer.c
Sebastian Dröge 4ccd425772 openslesringbuffer: Only allocate at most half the number of internal buffers as external audioringbuffer ones 
Otherwise we might end up reading too much from the audioringbuffer, which
would result in reading silence.
2015-02-10 16:18:34 +01:00

1016 lines
30 KiB
C
Raw Blame History

/* 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;
}
Reference in a new issue View git blame Copy permalink