gstreamer/subprojects/gst-plugins-bad/sys/opensles/openslesringbuffer.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1074 lines
32 KiB
C
Raw Normal View History

2012-09-20 09:50:50 +00:00
/* 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
2012-10-18 14:23:49 +00:00
#define _do_init \
GST_DEBUG_CATEGORY_INIT (opensles_ringbuffer_debug, \
"opensles_ringbuffer", 0, "OpenSL ES ringbuffer");
2012-10-18 14:23:49 +00:00
#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
2012-10-18 14:23:49 +00:00
_opensles_channel_mask (GstAudioRingBufferSpec * spec)
{
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
_opensles_format (GstAudioRingBufferSpec * spec, SLDataFormat_PCM * format)
{
format->formatType = SL_DATAFORMAT_PCM;
2012-10-18 14:23:49 +00:00
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 =
2012-10-18 14:23:49 +00:00
((spec->info.finfo->endianness ==
G_BIG_ENDIAN) ? SL_BYTEORDER_BIGENDIAN : SL_BYTEORDER_LITTLEENDIAN);
}
/*
* Recorder related functions
*/
static gboolean
2012-10-18 14:23:49 +00:00
_opensles_recorder_acquire (GstAudioRingBuffer * rb,
GstAudioRingBufferSpec * spec)
{
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
SLresult result;
SLDataFormat_PCM format;
SLAndroidConfigurationItf config;
/* 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 ids[2] = { SL_IID_ANDROIDSIMPLEBUFFERQUEUE,
SL_IID_ANDROIDCONFIGURATION
};
const SLboolean req[2] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_FALSE };
/* 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, 2, ids, req);
if (result != SL_RESULT_SUCCESS) {
GST_ERROR_OBJECT (thiz, "engine.CreateAudioRecorder failed(0x%08x)",
(guint32) result);
goto failed;
}
/* Set the recording preset if we have one */
if (thiz->preset != GST_OPENSLES_RECORDING_PRESET_NONE) {
SLint32 preset = gst_to_opensles_recording_preset (thiz->preset);
result = (*thiz->recorderObject)->GetInterface (thiz->recorderObject,
SL_IID_ANDROIDCONFIGURATION, &config);
if (result == SL_RESULT_SUCCESS) {
result = (*config)->SetConfiguration (config,
SL_ANDROID_KEY_RECORDING_PRESET, &preset, sizeof (preset));
if (result != SL_RESULT_SUCCESS) {
GST_WARNING_OBJECT (thiz, "Failed to set playback stream type (0x%08x)",
(guint32) result);
}
} else {
GST_WARNING_OBJECT (thiz,
"Could not get configuration interface 0x%08x", (guint32) result);
}
}
/* 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)
{
2012-10-18 14:23:49 +00:00
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) {
2012-10-18 14:23:49 +00:00
gst_audio_ring_buffer_advance (rb, 1);
}
/* Get a segment form the GStreamer ringbuffer to write in */
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
_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
2012-10-18 14:23:49 +00:00
_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
2012-10-18 14:23:49 +00:00
_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
2012-10-18 14:23:49 +00:00
_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 */
2012-09-27 12:52:59 +00:00
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);
2012-09-27 12:52:59 +00:00
}
}
static gboolean
2012-10-18 14:23:49 +00:00
_opensles_player_acquire (GstAudioRingBuffer * rb,
GstAudioRingBufferSpec * spec)
{
GstOpenSLESRingBuffer *thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
SLresult result;
SLDataFormat_PCM format;
SLAndroidConfigurationItf config;
/* 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[3] = { SL_IID_BUFFERQUEUE, SL_IID_VOLUME,
SL_IID_ANDROIDCONFIGURATION
};
const SLboolean req[3] = { SL_BOOLEAN_TRUE, SL_BOOLEAN_TRUE,
SL_BOOLEAN_FALSE
};
/* 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, 3, ids, req);
if (result != SL_RESULT_SUCCESS) {
GST_ERROR_OBJECT (thiz, "engine.CreateAudioPlayer failed(0x%08x)",
(guint32) result);
goto failed;
}
/* Set the stream type if we have one */
if (thiz->stream_type != GST_OPENSLES_STREAM_TYPE_NONE) {
SLint32 stream_type = gst_to_opensles_stream_type (thiz->stream_type);
result = (*thiz->playerObject)->GetInterface (thiz->playerObject,
SL_IID_ANDROIDCONFIGURATION, &config);
if (result == SL_RESULT_SUCCESS) {
result = (*config)->SetConfiguration (config,
SL_ANDROID_KEY_STREAM_TYPE, &stream_type, sizeof (stream_type));
if (result != SL_RESULT_SUCCESS) {
GST_WARNING_OBJECT (thiz, "Failed to set playback stream type (0x%08x)",
(guint32) result);
}
} else {
GST_WARNING_OBJECT (thiz,
"Could not get configuration interface 0x%08x", (guint32) result);
}
}
/* 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);
2012-09-27 12:52:59 +00:00
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);
2012-09-27 12:52:59 +00:00
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);
2012-10-01 10:54:15 +00:00
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)
{
2012-10-18 14:23:49 +00:00
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 */
2012-10-18 14:23:49 +00:00
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);
2012-09-27 12:52:59 +00:00
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 */
2012-09-27 12:52:59 +00:00
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 */
2012-10-18 14:23:49 +00:00
gst_audio_ring_buffer_clear (rb, seg);
/* Make the segment reusable */
2012-10-18 14:23:49 +00:00
gst_audio_ring_buffer_advance (rb, 1);
}
static gboolean
2012-10-18 14:23:49 +00:00
_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 */
2012-10-01 10:54:15 +00:00
if (!g_atomic_int_get (&thiz->is_prerolled)) {
_opensles_player_cb (NULL, rb);
2012-10-01 10:54:15 +00:00
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
2012-10-18 14:23:49 +00:00
_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
2012-10-18 14:23:49 +00:00
_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;
2012-09-27 03:40:46 +00:00
return TRUE;
}
/*
* OpenSL ES ringbuffer wrapper
*/
2012-10-18 14:23:49 +00:00
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");
2012-10-18 14:23:49 +00:00
return GST_AUDIO_RING_BUFFER (thiz);
}
void
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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 */
2012-10-18 14:23:49 +00:00
rb->size = spec->segtotal * spec->segsize;
rb->memory = g_malloc0 (rb->size);
GST_DEBUG_OBJECT (thiz, "ringbuffer acquired");
return TRUE;
}
static gboolean
2012-10-18 14:23:49 +00:00
gst_opensles_ringbuffer_release (GstAudioRingBuffer * rb)
{
GstOpenSLESRingBuffer *thiz;
thiz = GST_OPENSLES_RING_BUFFER (rb);
opensles: Work around race condition in Android < 4.2 that leads to deadlocks on shutdown 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).
2014-05-16 07:10:48 +00:00
/* 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) {
opensles: Work around race condition in Android < 4.2 that leads to deadlocks on shutdown 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).
2014-05-16 07:10:48 +00:00
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) {
opensles: Work around race condition in Android < 4.2 that leads to deadlocks on shutdown 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).
2014-05-16 07:10:48 +00:00
g_usleep (50000);
(*thiz->recorderObject)->Destroy (thiz->recorderObject);
thiz->recorderObject = NULL;
thiz->recorderRecord = NULL;
}
if (thiz->data) {
g_free (thiz->data);
thiz->data = NULL;
}
2012-10-18 14:23:49 +00:00
if (rb->memory) {
g_free (rb->memory);
rb->memory = NULL;
rb->size = 0;
}
GST_DEBUG_OBJECT (thiz, "ringbuffer released");
return TRUE;
}
static gboolean
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
gst_opensles_ringbuffer_delay (GstAudioRingBuffer * rb)
{
2012-09-27 03:40:46 +00:00
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);
2012-10-18 14:23:49 +00:00
playedpos =
gst_util_uint64_scale_round (position, rb->spec.info.rate, 1000);
queuedpos = g_atomic_int_get (&thiz->segqueued) * rb->samples_per_seg;
if (queuedpos < playedpos) {
res = 0;
GST_ERROR_OBJECT (thiz,
"Queued position smaller than playback position (%" G_GUINT64_FORMAT
" < %" G_GUINT64_FORMAT ")", queuedpos, playedpos);
} else {
res = queuedpos - playedpos;
}
}
2012-09-27 03:40:46 +00:00
GST_LOG_OBJECT (thiz, "queued samples %" G_GUINT64_FORMAT " position %u ms "
"(%" G_GUINT64_FORMAT " samples) delay %u samples",
queuedpos, (guint) position, playedpos, res);
2012-09-27 03:40:46 +00:00
}
return res;
}
static void
2012-10-18 14:23:49 +00:00
gst_opensles_ringbuffer_clear_all (GstAudioRingBuffer * rb)
{
GstOpenSLESRingBuffer *thiz;
thiz = GST_OPENSLES_RING_BUFFER_CAST (rb);
if (thiz->data) {
2012-10-01 10:54:15 +00:00
SLresult result;
memset (thiz->data, 0, thiz->data_size);
g_atomic_int_set (&thiz->segqueued, 0);
thiz->cursor = 0;
2012-10-01 10:54:15 +00:00
/* 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);
}
2012-10-01 09:46:50 +00:00
2012-10-18 14:23:49 +00:00
GST_CALL_PARENT (GST_AUDIO_RING_BUFFER_CLASS, clear_all, (rb));
}
static void
gst_opensles_ringbuffer_dispose (GObject * object)
{
2012-10-18 14:23:49 +00:00
G_OBJECT_CLASS (parent_class)->dispose (object);
}
static void
gst_opensles_ringbuffer_finalize (GObject * object)
{
2012-10-18 14:23:49 +00:00
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void
gst_opensles_ringbuffer_class_init (GstOpenSLESRingBufferClass * klass)
{
GObjectClass *gobject_class;
2012-10-18 14:23:49 +00:00
GstAudioRingBufferClass *gstringbuffer_class;
gobject_class = (GObjectClass *) klass;
2012-10-18 14:23:49 +00:00
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
2012-10-18 14:23:49 +00:00
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;
}