From 3f33a577a966e9855d40b1d112a8d6c6f4d72903 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= Date: Mon, 15 Aug 2011 15:10:04 +0200 Subject: [PATCH] omxaudioenc: Add initial version of audio encoder base class --- omx/Makefile.am | 2 + omx/gstomxaudioenc.c | 873 +++++++++++++++++++++++++++++++++++++++++++ omx/gstomxaudioenc.h | 85 +++++ 3 files changed, 960 insertions(+) create mode 100644 omx/gstomxaudioenc.c create mode 100644 omx/gstomxaudioenc.h diff --git a/omx/Makefile.am b/omx/Makefile.am index 33248fc552..72a7a2666d 100644 --- a/omx/Makefile.am +++ b/omx/Makefile.am @@ -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 \ diff --git a/omx/gstomxaudioenc.c b/omx/gstomxaudioenc.c new file mode 100644 index 0000000000..ead75dc66f --- /dev/null +++ b/omx/gstomxaudioenc.c @@ -0,0 +1,873 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , 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 +#include + +#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; +} diff --git a/omx/gstomxaudioenc.h b/omx/gstomxaudioenc.h new file mode 100644 index 0000000000..11ebcaf14e --- /dev/null +++ b/omx/gstomxaudioenc.h @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2011, Hewlett-Packard Development Company, L.P. + * Author: Sebastian Dröge , 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 +#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__ */