mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-27 04:01:08 +00:00
Code Issues 1 Projects Releases Wiki Activity

omxaudioenc: Add initial version of audio encoder base class

Browse source
This commit is contained in:
Sebastian Dröge 2011-08-15 15:10:04 +02:00
parent c0202cc283
commit 3f33a577a9
3 changed files with 960 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
omx/Makefile.am
View file

@ -4,6 +4,7 @@ libgstopenmax_la_SOURCES = \
gstomx.c \
gstomxvideodec.c \
gstomxvideoenc.c \
gstomxaudioenc.c \
gstomxmpeg4videodec.c \
gstomxh264dec.c \
gstomxh263dec.c \
@ -23,6 +24,7 @@ noinst_HEADERS = \
gstomx.h \
gstomxvideodec.h \
gstomxvideoenc.h \
gstomxaudioenc.h \
gstomxmpeg4videodec.h \
gstomxh264dec.h \
gstomxh263dec.h \

873
omx/gstomxaudioenc.c Normal file
View file

@ -0,0 +1,873 @@
/*
* Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation
* version 2.1 of the License.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <gst/gst.h>
#include <string.h>
#include "gstomxaudioenc.h"
GST_DEBUG_CATEGORY_STATIC (gst_omx_audio_enc_debug_category);
#define GST_CAT_DEFAULT gst_omx_audio_enc_debug_category
/* prototypes */
static void gst_omx_audio_enc_finalize (GObject * object);
static GstStateChangeReturn
gst_omx_audio_enc_change_state (GstElement * element,
GstStateChange transition);
static gboolean gst_omx_audio_enc_start (GstBaseAudioEncoder * encoder);
static gboolean gst_omx_audio_enc_stop (GstBaseAudioEncoder * encoder);
static gboolean gst_omx_audio_enc_set_format (GstBaseAudioEncoder * encoder,
GstAudioState * state);
static gboolean gst_omx_audio_enc_event (GstBaseAudioEncoder * encoder,
GstEvent * event);
static GstFlowReturn gst_omx_audio_enc_handle_frame (GstBaseAudioEncoder *
encoder, GstBuffer * buffer);
static void gst_omx_audio_enc_flush (GstBaseAudioEncoder * encoder);
enum
{
PROP_0
};
/* class initialization */
#define DEBUG_INIT(bla) \
GST_DEBUG_CATEGORY_INIT (gst_omx_audio_enc_debug_category, "omxaudioenc", 0, \
"debug category for gst-omx audio encoder base class");
GST_BOILERPLATE_FULL (GstOMXAudioEnc, gst_omx_audio_enc, GstBaseAudioEncoder,
GST_TYPE_BASE_AUDIO_ENCODER, DEBUG_INIT);
static void
gst_omx_audio_enc_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
GstOMXAudioEncClass *audioenc_class = GST_OMX_AUDIO_ENC_CLASS (g_class);
GKeyFile *config;
const gchar *element_name;
GError *err;
gchar *core_name, *component_name, *component_role;
gint in_port_index, out_port_index;
gchar *template_caps;
GstPadTemplate *templ;
GstCaps *caps;
gchar **hacks;
element_name =
g_type_get_qdata (G_TYPE_FROM_CLASS (g_class),
gst_omx_element_name_quark);
/* This happens for the base class and abstract subclasses */
if (!element_name)
return;
config = gst_omx_get_configuration ();
/* This will always succeed, see check in plugin_init */
core_name = g_key_file_get_string (config, element_name, "core-name", NULL);
g_assert (core_name != NULL);
audioenc_class->core_name = core_name;
component_name =
g_key_file_get_string (config, element_name, "component-name", NULL);
g_assert (component_name != NULL);
audioenc_class->component_name = component_name;
/* If this fails we simply don't set a role */
if ((component_role =
g_key_file_get_string (config, element_name, "component-role",
NULL))) {
GST_DEBUG ("Using component-role '%s' for element '%s'", component_role,
element_name);
audioenc_class->component_role = component_role;
}
/* Now set the inport/outport indizes and assume sane defaults */
err = NULL;
in_port_index =
g_key_file_get_integer (config, element_name, "in-port-index", &err);
if (err != NULL) {
GST_DEBUG ("No 'in-port-index' set for element '%s', assuming 0: %s",
element_name, err->message);
in_port_index = 0;
g_error_free (err);
}
audioenc_class->in_port_index = in_port_index;
err = NULL;
out_port_index =
g_key_file_get_integer (config, element_name, "out-port-index", &err);
if (err != NULL) {
GST_DEBUG ("No 'out-port-index' set for element '%s', assuming 1: %s",
element_name, err->message);
out_port_index = 1;
g_error_free (err);
}
audioenc_class->out_port_index = out_port_index;
/* Add pad templates */
err = NULL;
if (!(template_caps =
g_key_file_get_string (config, element_name, "sink-template-caps",
&err))) {
GST_DEBUG
("No sink template caps specified for element '%s', using default '%s'",
element_name, audioenc_class->default_sink_template_caps);
caps = gst_caps_from_string (audioenc_class->default_sink_template_caps);
g_assert (caps != NULL);
g_error_free (err);
} else {
caps = gst_caps_from_string (template_caps);
if (!caps) {
GST_DEBUG
("Could not parse sink template caps '%s' for element '%s', using default '%s'",
template_caps, element_name,
audioenc_class->default_sink_template_caps);
caps = gst_caps_from_string (audioenc_class->default_sink_template_caps);
g_assert (caps != NULL);
}
}
templ = gst_pad_template_new ("sink", GST_PAD_SINK, GST_PAD_ALWAYS, caps);
g_free (template_caps);
gst_element_class_add_pad_template (element_class, templ);
gst_object_unref (templ);
err = NULL;
if (!(template_caps =
g_key_file_get_string (config, element_name, "src-template-caps",
&err))) {
GST_DEBUG
("No src template caps specified for element '%s', using default '%s'",
element_name, audioenc_class->default_src_template_caps);
caps = gst_caps_from_string (audioenc_class->default_src_template_caps);
g_assert (caps != NULL);
g_error_free (err);
} else {
caps = gst_caps_from_string (template_caps);
if (!caps) {
GST_DEBUG
("Could not parse src template caps '%s' for element '%s', using default '%s'",
template_caps, element_name,
audioenc_class->default_src_template_caps);
caps = gst_caps_from_string (audioenc_class->default_src_template_caps);
g_assert (caps != NULL);
}
}
templ = gst_pad_template_new ("src", GST_PAD_SRC, GST_PAD_ALWAYS, caps);
g_free (template_caps);
gst_element_class_add_pad_template (element_class, templ);
gst_object_unref (templ);
if ((hacks =
g_key_file_get_string_list (config, element_name, "hacks", NULL,
NULL))) {
#ifndef GST_DISABLE_GST_DEBUG
gchar **walk = hacks;
while (*walk) {
GST_DEBUG ("Using hack: %s", *walk);
walk++;
}
#endif
audioenc_class->hacks = gst_omx_parse_hacks (hacks);
}
}
static void
gst_omx_audio_enc_class_init (GstOMXAudioEncClass * klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GstElementClass *element_class = GST_ELEMENT_CLASS (klass);
GstBaseAudioEncoderClass *base_audio_encoder_class =
GST_BASE_AUDIO_ENCODER_CLASS (klass);
gobject_class->finalize = gst_omx_audio_enc_finalize;
element_class->change_state =
GST_DEBUG_FUNCPTR (gst_omx_audio_enc_change_state);
base_audio_encoder_class->start = GST_DEBUG_FUNCPTR (gst_omx_audio_enc_start);
base_audio_encoder_class->stop = GST_DEBUG_FUNCPTR (gst_omx_audio_enc_stop);
base_audio_encoder_class->flush = GST_DEBUG_FUNCPTR (gst_omx_audio_enc_flush);
base_audio_encoder_class->set_format =
GST_DEBUG_FUNCPTR (gst_omx_audio_enc_set_format);
base_audio_encoder_class->handle_frame =
GST_DEBUG_FUNCPTR (gst_omx_audio_enc_handle_frame);
base_audio_encoder_class->event = GST_DEBUG_FUNCPTR (gst_omx_audio_enc_event);
klass->default_sink_template_caps = "audio/x-raw-int, "
"rate = (int) [ 1, MAX ], "
"channels = (int) [ 1, " G_STRINGIFY (OMX_AUDIO_MAXCHANNELS) " ], "
"endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "
"width = (int) 8, "
"depth = (int) 8, "
"signed = (boolean) { true, false }; "
"audio/x-raw-int, "
"rate = (int) [ 1, MAX ], "
"channels = (int) [ 1, " G_STRINGIFY (OMX_AUDIO_MAXCHANNELS) " ], "
"endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "
"width = (int) 16, "
"depth = (int) 16, "
"signed = (boolean) { true, false }; "
"audio/x-raw-int, "
"rate = (int) [ 1, MAX ], "
"channels = (int) [ 1, " G_STRINGIFY (OMX_AUDIO_MAXCHANNELS) " ], "
"endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "
"width = (int) 24, "
"depth = (int) 24, "
"signed = (boolean) { true, false }; "
"audio/x-raw-int, "
"rate = (int) [ 1, MAX ], "
"channels = (int) [ 1, " G_STRINGIFY (OMX_AUDIO_MAXCHANNELS) " ], "
"endianness = (int) { LITTLE_ENDIAN, BIG_ENDIAN }, "
"width = (int) 32, "
"depth = (int) 32, " "signed = (boolean) { true, false }";
}
static void
gst_omx_audio_enc_init (GstOMXAudioEnc * self, GstOMXAudioEncClass * klass)
{
}
static gboolean
gst_omx_audio_enc_open (GstOMXAudioEnc * self)
{
GstOMXAudioEncClass *klass = GST_OMX_AUDIO_ENC_GET_CLASS (self);
self->component =
gst_omx_component_new (GST_OBJECT_CAST (self), klass->core_name,
klass->component_name, klass->component_role, klass->hacks);
self->started = FALSE;
if (!self->component)
return FALSE;
if (gst_omx_component_get_state (self->component,
GST_CLOCK_TIME_NONE) != OMX_StateLoaded)
return FALSE;
self->in_port =
gst_omx_component_add_port (self->component, klass->in_port_index);
self->out_port =
gst_omx_component_add_port (self->component, klass->out_port_index);
if (!self->in_port || !self->out_port)
return FALSE;
return TRUE;
}
static gboolean
gst_omx_audio_enc_close (GstOMXAudioEnc * self)
{
OMX_STATETYPE state;
state = gst_omx_component_get_state (self->component, 0);
if (state > OMX_StateLoaded || state == OMX_StateInvalid) {
gst_omx_component_set_state (self->component, OMX_StateLoaded);
gst_omx_port_deallocate_buffers (self->in_port);
gst_omx_port_deallocate_buffers (self->out_port);
if (state > OMX_StateLoaded)
gst_omx_component_get_state (self->component, 5 * GST_SECOND);
}
self->in_port = NULL;
self->out_port = NULL;
if (self->component)
gst_omx_component_free (self->component);
self->component = NULL;
return TRUE;
}
static void
gst_omx_audio_enc_finalize (GObject * object)
{
/* GstOMXAudioEnc *self = GST_OMX_AUDIO_ENC (object); */
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static GstStateChangeReturn
gst_omx_audio_enc_change_state (GstElement * element, GstStateChange transition)
{
GstOMXAudioEnc *self;
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
g_return_val_if_fail (GST_IS_OMX_AUDIO_ENC (element),
GST_STATE_CHANGE_FAILURE);
self = GST_OMX_AUDIO_ENC (element);
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
if (!gst_omx_audio_enc_open (self))
ret = GST_STATE_CHANGE_FAILURE;
break;
case GST_STATE_CHANGE_READY_TO_PAUSED:
if (self->in_port)
gst_omx_port_set_flushing (self->in_port, FALSE);
if (self->out_port)
gst_omx_port_set_flushing (self->out_port, FALSE);
break;
case GST_STATE_CHANGE_PAUSED_TO_PLAYING:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (self->in_port)
gst_omx_port_set_flushing (self->in_port, TRUE);
if (self->out_port)
gst_omx_port_set_flushing (self->out_port, TRUE);
break;
default:
break;
}
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PLAYING_TO_PAUSED:
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
break;
case GST_STATE_CHANGE_READY_TO_NULL:
if (!gst_omx_audio_enc_close (self))
ret = GST_STATE_CHANGE_FAILURE;
break;
default:
break;
}
return ret;
}
static void
gst_omx_audio_enc_loop (GstOMXAudioEnc * self)
{
GstOMXAudioEncClass *klass;
GstOMXPort *port = self->out_port;
GstOMXBuffer *buf = NULL;
GstFlowReturn flow_ret = GST_FLOW_OK;
GstOMXAcquireBufferReturn acq_return;
klass = GST_OMX_AUDIO_ENC_GET_CLASS (self);
acq_return = gst_omx_port_acquire_buffer (port, &buf);
if (acq_return == GST_OMX_ACQUIRE_BUFFER_ERROR) {
goto component_error;
} else if (acq_return == GST_OMX_ACQUIRE_BUFFER_FLUSHING) {
goto flushing;
} else if (acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) {
if (gst_omx_port_reconfigure (self->out_port) != OMX_ErrorNone)
goto reconfigure_error;
/* And restart the loop */
return;
}
if (!GST_PAD_CAPS (GST_BASE_AUDIO_ENCODER_SRC_PAD (self))
|| acq_return == GST_OMX_ACQUIRE_BUFFER_RECONFIGURED) {
GstAudioState *state = &GST_BASE_AUDIO_ENCODER (self)->ctx->state;
GstCaps *caps;
GST_DEBUG_OBJECT (self, "Port settings have changed, updating caps");
caps = klass->get_caps (self, self->out_port, state);
if (!caps) {
if (buf)
gst_omx_port_release_buffer (self->out_port, buf);
goto caps_failed;
}
if (!gst_pad_set_caps (GST_BASE_AUDIO_ENCODER_SRC_PAD (self), caps)) {
gst_caps_unref (caps);
if (buf)
gst_omx_port_release_buffer (self->out_port, buf);
goto caps_failed;
}
gst_caps_unref (caps);
/* Now get a buffer */
if (acq_return != GST_OMX_ACQUIRE_BUFFER_OK)
return;
}
g_assert (acq_return == GST_OMX_ACQUIRE_BUFFER_OK && buf != NULL);
GST_DEBUG_OBJECT (self, "Handling buffer: 0x%08x %lu", buf->omx_buf->nFlags,
buf->omx_buf->nTimeStamp);
if ((buf->omx_buf->nFlags & OMX_BUFFERFLAG_CODECCONFIG)
&& buf->omx_buf->nFilledLen > 0) {
GstCaps *caps;
GstBuffer *codec_data;
caps = gst_caps_copy (GST_PAD_CAPS (GST_BASE_AUDIO_ENCODER_SRC_PAD (self)));
codec_data = gst_buffer_new_and_alloc (buf->omx_buf->nFilledLen);
memcpy (GST_BUFFER_DATA (codec_data),
buf->omx_buf->pBuffer + buf->omx_buf->nOffset,
buf->omx_buf->nFilledLen);
gst_caps_set_simple (caps, "codec_data", GST_TYPE_BUFFER, codec_data, NULL);
if (!gst_pad_set_caps (GST_BASE_AUDIO_ENCODER_SRC_PAD (self), caps)) {
gst_caps_unref (caps);
if (buf)
gst_omx_port_release_buffer (self->out_port, buf);
goto caps_failed;
}
gst_caps_unref (caps);
flow_ret = GST_FLOW_OK;
} else if (buf->omx_buf->nFilledLen > 0) {
GstBuffer *outbuf;
if (buf->omx_buf->nFilledLen > 0) {
outbuf = gst_buffer_new_and_alloc (buf->omx_buf->nFilledLen);
memcpy (GST_BUFFER_DATA (outbuf),
buf->omx_buf->pBuffer + buf->omx_buf->nOffset,
buf->omx_buf->nFilledLen);
} else {
outbuf = gst_buffer_new ();
}
gst_buffer_set_caps (outbuf,
GST_PAD_CAPS (GST_BASE_AUDIO_ENCODER_SRC_PAD (self)));
GST_BUFFER_TIMESTAMP (outbuf) =
gst_util_uint64_scale (buf->omx_buf->nTimeStamp, GST_SECOND,
OMX_TICKS_PER_SECOND);
if (buf->omx_buf->nTickCount != 0)
GST_BUFFER_DURATION (outbuf) =
gst_util_uint64_scale (buf->omx_buf->nTickCount, GST_SECOND,
OMX_TICKS_PER_SECOND);
if ((klass->hacks & GST_OMX_HACK_SYNCFRAME_FLAG_NOT_USED)
|| (buf->omx_buf->nFlags & OMX_BUFFERFLAG_SYNCFRAME)) {
}
flow_ret =
gst_base_audio_encoder_finish_frame (GST_BASE_AUDIO_ENCODER (self),
outbuf, -1);
}
if (flow_ret == GST_FLOW_OK && (buf->omx_buf->nFlags & OMX_BUFFERFLAG_EOS))
flow_ret = GST_FLOW_UNEXPECTED;
gst_omx_port_release_buffer (port, buf);
if (flow_ret != GST_FLOW_OK)
goto flow_error;
return;
component_error:
{
GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
("OpenMAX component in error state %s (0x%08x)",
gst_omx_component_get_last_error_string (self->component),
gst_omx_component_get_last_error (self->component)));
gst_pad_push_event (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
gst_event_new_eos ());
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
return;
}
flushing:
{
GST_DEBUG_OBJECT (self, "Flushing -- stopping task");
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
return;
}
flow_error:
{
if (flow_ret == GST_FLOW_UNEXPECTED) {
GST_DEBUG_OBJECT (self, "EOS");
gst_pad_push_event (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
gst_event_new_eos ());
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
} else if (flow_ret == GST_FLOW_NOT_LINKED
|| flow_ret < GST_FLOW_UNEXPECTED) {
GST_ELEMENT_ERROR (self, STREAM, FAILED, ("Internal data stream error."),
("stream stopped, reason %s", gst_flow_get_name (flow_ret)));
gst_pad_push_event (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
gst_event_new_eos ());
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
}
return;
}
reconfigure_error:
{
GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
("Unable to reconfigure output port"));
gst_pad_push_event (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
gst_event_new_eos ());
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
return;
}
caps_failed:
{
GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL), ("Failed to set caps"));
gst_pad_push_event (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
gst_event_new_eos ());
gst_pad_pause_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
return;
}
}
static gboolean
gst_omx_audio_enc_start (GstBaseAudioEncoder * encoder)
{
GstOMXAudioEnc *self;
gboolean ret;
self = GST_OMX_AUDIO_ENC (encoder);
ret =
gst_pad_start_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
(GstTaskFunction) gst_omx_audio_enc_loop, self);
return ret;
}
static gboolean
gst_omx_audio_enc_stop (GstBaseAudioEncoder * encoder)
{
GstOMXAudioEnc *self;
self = GST_OMX_AUDIO_ENC (encoder);
gst_pad_stop_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (encoder));
if (gst_omx_component_get_state (self->component, 0) > OMX_StateIdle)
gst_omx_component_set_state (self->component, OMX_StateIdle);
gst_omx_port_set_flushing (self->in_port, TRUE);
gst_omx_port_set_flushing (self->out_port, TRUE);
gst_omx_component_get_state (self->component, 5 * GST_SECOND);
return TRUE;
}
static gboolean
gst_omx_audio_enc_set_format (GstBaseAudioEncoder * encoder,
GstAudioState * state)
{
GstOMXAudioEnc *self;
GstOMXAudioEncClass *klass;
gboolean needs_disable = FALSE;
OMX_PARAM_PORTDEFINITIONTYPE port_def;
OMX_AUDIO_PARAM_PCMMODETYPE pcm_param;
gint i;
OMX_ERRORTYPE err;
self = GST_OMX_AUDIO_ENC (encoder);
klass = GST_OMX_AUDIO_ENC_GET_CLASS (encoder);
GST_DEBUG_OBJECT (self, "Setting new caps");
gst_omx_port_get_port_definition (self->in_port, &port_def);
needs_disable =
gst_omx_component_get_state (self->component,
GST_CLOCK_TIME_NONE) != OMX_StateLoaded;
/* If the component is not in Loaded state and a real format change happens
* we have to disable the port and re-allocate all buffers. If no real
* format change happened we can just exit here.
*/
if (needs_disable) {
if (gst_omx_port_manual_reconfigure (self->in_port, TRUE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_set_enabled (self->in_port, FALSE) != OMX_ErrorNone)
return FALSE;
}
port_def.format.audio.eEncoding = OMX_AUDIO_CodingPCM;
if (!gst_omx_port_update_port_definition (self->in_port, &port_def))
return FALSE;
if (!gst_omx_port_update_port_definition (self->out_port, NULL))
return FALSE;
GST_OMX_INIT_STRUCT (&pcm_param);
pcm_param.nPortIndex = self->in_port->index;
pcm_param.nChannels = state->channels;
pcm_param.eNumData =
(state->sign ? OMX_NumericalDataSigned : OMX_NumericalDataUnsigned);
pcm_param.eEndian =
((state->endian == G_LITTLE_ENDIAN) ? OMX_EndianLittle : OMX_EndianBig);
pcm_param.bInterleaved = OMX_TRUE;
pcm_param.nBitPerSample = state->width;
pcm_param.nSamplingRate = state->rate;
pcm_param.ePCMMode = OMX_AUDIO_PCMModeLinear;
for (i = 0; i < pcm_param.nChannels; i++) {
OMX_AUDIO_CHANNELTYPE pos;
switch (state->channel_pos[i]) {
case GST_AUDIO_CHANNEL_POSITION_FRONT_MONO:
case GST_AUDIO_CHANNEL_POSITION_FRONT_CENTER:
pos = OMX_AUDIO_ChannelCF;
break;
case GST_AUDIO_CHANNEL_POSITION_FRONT_LEFT:
pos = OMX_AUDIO_ChannelLF;
break;
case GST_AUDIO_CHANNEL_POSITION_FRONT_RIGHT:
pos = OMX_AUDIO_ChannelRF;
break;
case GST_AUDIO_CHANNEL_POSITION_SIDE_LEFT:
pos = OMX_AUDIO_ChannelLS;
break;
case GST_AUDIO_CHANNEL_POSITION_SIDE_RIGHT:
pos = OMX_AUDIO_ChannelRS;
break;
case GST_AUDIO_CHANNEL_POSITION_LFE:
pos = OMX_AUDIO_ChannelLFE;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_CENTER:
pos = OMX_AUDIO_ChannelCS;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_LEFT:
pos = OMX_AUDIO_ChannelLR;
break;
case GST_AUDIO_CHANNEL_POSITION_REAR_RIGHT:
pos = OMX_AUDIO_ChannelRR;
break;
default:
pos = OMX_AUDIO_ChannelNone;
break;
}
pcm_param.eChannelMapping[i] = pos;
}
err =
gst_omx_component_set_parameter (self->component, OMX_IndexParamAudioPcm,
&pcm_param);
if (err != OMX_ErrorNone) {
GST_ERROR_OBJECT (self, "Failed to set PCM parameters: %s (0x%08x)",
gst_omx_error_to_string (err), err);
return FALSE;
}
if (klass->set_format) {
if (!klass->set_format (self, self->in_port, state)) {
GST_ERROR_OBJECT (self, "Subclass failed to set the new format");
return FALSE;
}
}
if (needs_disable) {
if (gst_omx_port_set_enabled (self->in_port, TRUE) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_manual_reconfigure (self->in_port, FALSE) != OMX_ErrorNone)
return FALSE;
} else {
if (gst_omx_component_set_state (self->component,
OMX_StateIdle) != OMX_ErrorNone)
return FALSE;
/* Need to allocate buffers to reach Idle state */
if (gst_omx_port_allocate_buffers (self->in_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_port_allocate_buffers (self->out_port) != OMX_ErrorNone)
return FALSE;
if (gst_omx_component_get_state (self->component,
GST_CLOCK_TIME_NONE) != OMX_StateIdle)
return FALSE;
if (gst_omx_component_set_state (self->component,
OMX_StateExecuting) != OMX_ErrorNone)
return FALSE;
}
/* Unset flushing to allow ports to accept data again */
gst_omx_port_set_flushing (self->in_port, FALSE);
gst_omx_port_set_flushing (self->out_port, FALSE);
if (gst_omx_component_get_last_error (self->component) != OMX_ErrorNone) {
GST_ERROR_OBJECT (self, "Component in error state: %s (0x%08x)",
gst_omx_component_get_last_error_string (self->component),
gst_omx_component_get_last_error (self->component));
return FALSE;
}
/* Start the srcpad loop again */
gst_pad_start_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
(GstTaskFunction) gst_omx_audio_enc_loop, encoder);
return (gst_omx_component_get_state (self->component,
GST_CLOCK_TIME_NONE) == OMX_StateExecuting);
}
static void
gst_omx_audio_enc_flush (GstBaseAudioEncoder * encoder)
{
GstOMXAudioEnc *self;
self = GST_OMX_AUDIO_ENC (encoder);
GST_DEBUG_OBJECT (self, "Resetting encoder");
if (self->started) {
gst_omx_port_set_flushing (self->in_port, TRUE);
gst_omx_port_set_flushing (self->out_port, TRUE);
/* Wait until the srcpad loop is finished */
GST_PAD_STREAM_LOCK (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
GST_PAD_STREAM_UNLOCK (GST_BASE_AUDIO_ENCODER_SRC_PAD (self));
gst_omx_port_set_flushing (self->in_port, FALSE);
gst_omx_port_set_flushing (self->out_port, FALSE);
}
/* Start the srcpad loop again */
gst_pad_start_task (GST_BASE_AUDIO_ENCODER_SRC_PAD (self),
(GstTaskFunction) gst_omx_audio_enc_loop, encoder);
}
static GstFlowReturn
gst_omx_audio_enc_handle_frame (GstBaseAudioEncoder * encoder,
GstBuffer * inbuf)
{
GstOMXAcquireBufferReturn acq_ret = GST_OMX_ACQUIRE_BUFFER_ERROR;
GstOMXAudioEnc *self;
GstOMXBuffer *buf;
guint offset = 0;
GstClockTime timestamp, duration, timestamp_offset = 0;
self = GST_OMX_AUDIO_ENC (encoder);
GST_DEBUG_OBJECT (self, "Handling frame");
timestamp = GST_BUFFER_TIMESTAMP (inbuf);
duration = GST_BUFFER_DURATION (inbuf);
while (offset < GST_BUFFER_SIZE (inbuf)) {
acq_ret = gst_omx_port_acquire_buffer (self->in_port, &buf);
if (acq_ret == GST_OMX_ACQUIRE_BUFFER_ERROR) {
goto component_error;
} else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_FLUSHING) {
goto flushing;
} else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_RECONFIGURE) {
if (gst_omx_port_reconfigure (self->in_port) != OMX_ErrorNone)
goto reconfigure_error;
/* Now get a new buffer and fill it */
continue;
} else if (acq_ret == GST_OMX_ACQUIRE_BUFFER_RECONFIGURED) {
/* TODO: Anything to do here? Don't think so */
continue;
}
g_assert (acq_ret == GST_OMX_ACQUIRE_BUFFER_OK && buf != NULL);
/* Copy the buffer content in chunks of size as requested
* by the port */
buf->omx_buf->nFilledLen =
MIN (GST_BUFFER_SIZE (inbuf) - offset,
buf->omx_buf->nAllocLen - buf->omx_buf->nOffset);
memcpy (buf->omx_buf->pBuffer + buf->omx_buf->nOffset,
GST_BUFFER_DATA (inbuf) + offset, buf->omx_buf->nFilledLen);
/* Interpolate timestamps if we're passing the buffer
* in multiple chunks */
if (offset != 0 && duration != GST_CLOCK_TIME_NONE) {
timestamp_offset =
gst_util_uint64_scale (offset, duration, GST_BUFFER_SIZE (inbuf));
}
if (timestamp != GST_CLOCK_TIME_NONE) {
buf->omx_buf->nTimeStamp =
gst_util_uint64_scale (timestamp + timestamp_offset,
OMX_TICKS_PER_SECOND, GST_SECOND);
}
if (duration != GST_CLOCK_TIME_NONE) {
buf->omx_buf->nTickCount =
gst_util_uint64_scale (buf->omx_buf->nFilledLen, duration,
GST_BUFFER_SIZE (inbuf));
}
offset += buf->omx_buf->nFilledLen;
self->started = TRUE;
gst_omx_port_release_buffer (self->in_port, buf);
}
return GST_FLOW_OK;
component_error:
{
GST_ELEMENT_ERROR (self, LIBRARY, FAILED, (NULL),
("OpenMAX component in error state %s (0x%08x)",
gst_omx_component_get_last_error_string (self->component),
gst_omx_component_get_last_error (self->component)));
return GST_FLOW_ERROR;
}
flushing:
{
GST_DEBUG_OBJECT (self, "Flushing -- returning WRONG_STATE");
return GST_FLOW_WRONG_STATE;
}
reconfigure_error:
{
GST_ELEMENT_ERROR (self, LIBRARY, SETTINGS, (NULL),
("Unable to reconfigure input port"));
return GST_FLOW_ERROR;
}
}
static gboolean
gst_omx_audio_enc_event (GstBaseAudioEncoder * encoder, GstEvent * event)
{
GstOMXAudioEnc *self;
self = GST_OMX_AUDIO_ENC (encoder);
if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
GstOMXBuffer *buf;
GstOMXAcquireBufferReturn acq_ret;
GST_DEBUG_OBJECT (self, "Sending EOS to the component");
/* Send an EOS buffer to the component and let the base
* class drop the EOS event. We will send it later when
* the EOS buffer arrives on the output port. */
acq_ret = gst_omx_port_acquire_buffer (self->in_port, &buf);
if (acq_ret == GST_OMX_ACQUIRE_BUFFER_OK) {
buf->omx_buf->nFlags |= OMX_BUFFERFLAG_EOS;
gst_omx_port_release_buffer (self->in_port, buf);
}
return FALSE;
}
return TRUE;
}

85
omx/gstomxaudioenc.h Normal file
View file

@ -0,0 +1,85 @@
/*
* Copyright (C) 2011, Hewlett-Packard Development Company, L.P.
* Author: Sebastian Dröge <sebastian.droege@collabora.co.uk>, Collabora Ltd.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation
* version 2.1 of the License.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifndef __GST_OMX_AUDIO_ENC_H__
#define __GST_OMX_AUDIO_ENC_H__
#include <gst/gst.h>
#include "gstbaseaudioencoder.h"
#include "gstomx.h"
G_BEGIN_DECLS
#define GST_TYPE_OMX_AUDIO_ENC \
(gst_omx_audio_enc_get_type())
#define GST_OMX_AUDIO_ENC(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_OMX_AUDIO_ENC,GstOMXAudioEnc))
#define GST_OMX_AUDIO_ENC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_OMX_AUDIO_ENC,GstOMXAudioEncClass))
#define GST_OMX_AUDIO_ENC_GET_CLASS(obj) \
(G_TYPE_INSTANCE_GET_CLASS((obj),GST_TYPE_OMX_AUDIO_ENC,GstOMXAudioEncClass))
#define GST_IS_OMX_AUDIO_ENC(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_OMX_AUDIO_ENC))
#define GST_IS_OMX_AUDIO_ENC_CLASS(obj) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_OMX_AUDIO_ENC))
typedef struct _GstOMXAudioEnc GstOMXAudioEnc;
typedef struct _GstOMXAudioEncClass GstOMXAudioEncClass;
struct _GstOMXAudioEnc
{
GstBaseAudioEncoder parent;
/* < protected > */
GstOMXCore *core;
GstOMXComponent *component;
GstOMXPort *in_port, *out_port;
/* < private > */
/* TRUE if the component is configured and saw
* the first buffer */
gboolean started;
};
struct _GstOMXAudioEncClass
{
GstBaseAudioEncoderClass parent_class;
const gchar *core_name;
const gchar *component_name;
const gchar *component_role;
const gchar *default_src_template_caps;
const gchar *default_sink_template_caps;
guint32 in_port_index, out_port_index;
guint64 hacks;
gboolean (*set_format) (GstOMXAudioEnc * self, GstOMXPort * port, GstAudioState * state);
GstCaps *(*get_caps) (GstOMXAudioEnc * self, GstOMXPort * port, GstAudioState * state);
};
GType gst_omx_audio_enc_get_type (void);
G_END_DECLS
#endif /* __GST_OMX_AUDIO_ENC_H__ */