static void
get_property (GObject *obj,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (obj);
switch (prop_id)
{
case ARG_COMPONENT_NAME:
g_value_set_string (value, self->omx_component);
break;
case ARG_LIBRARY_NAME:
g_value_set_string (value, self->omx_library);
break;
case ARG_USE_TIMESTAMPS:
g_value_set_boolean (value, self->use_timestamps);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static gboolean
pad_event (GstPad *pad, GstEvent *event)
{
GstOmxBaseVideoEnc *self;
GstOmxBaseFilter *omx_base;
self = GST_OMX_BASE_VIDEOENC (GST_OBJECT_PARENT (pad));
omx_base = GST_OMX_BASE_FILTER (self);
GST_INFO_OBJECT (self, "begin: event=%s", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event))
{
case GST_EVENT_CROP:
{
gint top, left;
gst_event_parse_crop (event, &top, &left, NULL, NULL);
omx_base->in_port->n_offset = (self->rowstride * top) + left;
return TRUE;
}
default:
{
return parent_class->pad_event (pad, event);
}
}
}
static gboolean
sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstStructure *structure;
GstOmxBaseFilter *omx_base;
OMX_AUDIO_PARAM_AACPROFILETYPE param;
gint channels = 0;
gint sample_rate = 0;
gint mpegversion = 0;
const gchar *stream_format;
G_OMX_INIT_PARAM (param);
omx_base = GST_OMX_BASE_FILTER (GST_PAD_PARENT (pad));
GST_INFO_OBJECT (omx_base, "setcaps (sink): %" GST_PTR_FORMAT, caps);
structure = gst_caps_get_structure (caps, 0);
{
const GValue *codec_data;
GstBuffer *buffer;
codec_data = gst_structure_get_value (structure, "codec_data");
if (codec_data) {
buffer = gst_value_get_buffer (codec_data);
omx_base->codec_data = buffer;
gst_buffer_ref (buffer);
}
}
gst_structure_get_int(structure, "mpegversion", &mpegversion);
gst_structure_get_int(structure, "channels", &channels);
gst_structure_get_int(structure, "rate", &sample_rate);
stream_format = gst_structure_get_string(structure, "stream-format");
/* retrieve current in port params */
param.nPortIndex = omx_base->in_port->port_index;
OMX_GetParameter (omx_base->gomx->omx_handle, OMX_IndexParamAudioAac, ¶m);
if(channels > 0)
param.nChannels = (OMX_U32)channels;
if(sample_rate > 0)
param.nSampleRate = (OMX_U32)sample_rate;
if(!g_strcmp0(stream_format, "adif")) {
param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatADIF;
}
else if(!g_strcmp0(stream_format, "raw")) {
param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
}
else if(!g_strcmp0(stream_format, "adts")) {
if(mpegversion == 2)
param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
else if(mpegversion == 4)
param.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP4ADTS;
}
OMX_SetParameter(omx_base->gomx->omx_handle, OMX_IndexParamAudioAac, ¶m);
return gst_pad_set_caps (pad, caps);
}
static void
type_instance_init (GTypeInstance * instance, gpointer g_class)
{
GstOmxBaseFilter *omx_base;
omx_base = GST_OMX_BASE_FILTER (instance);
gst_pad_set_setcaps_function (omx_base->sinkpad, sink_setcaps);
}
static gboolean
activate_push (GstPad *pad,
gboolean active)
{
gboolean result = TRUE;
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
if (active)
{
GST_DEBUG_OBJECT (self, "activate");
/* task may carry on */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_OK);
/* we do not start the task yet if the pad is not connected */
if (gst_pad_is_linked (pad))
{
if (self->ready)
{
/** @todo link callback function also needed */
g_omx_port_resume (self->in_port);
g_omx_port_resume (self->out_port);
result = gst_pad_start_task (pad, output_loop, pad);
}
}
}
else
{
GST_DEBUG_OBJECT (self, "deactivate");
/* persuade task to bail out */
g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_WRONG_STATE);
if (self->ready)
{
/** @todo disable this until we properly reinitialize the buffers. */
#if 0
/* flush all buffers */
OMX_SendCommand (self->gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);
#endif
/* unlock loops */
g_omx_port_pause (self->in_port);
g_omx_port_pause (self->out_port);
}
/* make sure streaming finishes */
result = gst_pad_stop_task (pad);
}
gst_object_unref (self);
return result;
}
static void
set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (obj);
switch (prop_id)
{
case ARG_USE_TIMESTAMPS:
self->use_timestamps = g_value_get_boolean (value);
break;
case ARG_NUM_INPUT_BUFFERS:
case ARG_NUM_OUTPUT_BUFFERS:
{
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
OMX_U32 nBufferCountActual;
GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
self->in_port : self->out_port;
if (G_UNLIKELY (!omx_handle))
{
GST_WARNING_OBJECT (self, "no component");
break;
}
nBufferCountActual = g_value_get_uint (value);
G_OMX_INIT_PARAM (param);
param.nPortIndex = port->port_index;
OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
if (nBufferCountActual < param.nBufferCountMin)
{
GST_ERROR_OBJECT (self, "buffer count %lu is less than minimum %lu",
nBufferCountActual, param.nBufferCountMin);
return;
}
param.nBufferCountActual = nBufferCountActual;
OMX_SetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
type_instance_init (GTypeInstance *instance,
gpointer g_class)
{
GstOmxBaseFilter *self;
GstElementClass *element_class;
element_class = GST_ELEMENT_CLASS (g_class);
self = GST_OMX_BASE_FILTER (instance);
GST_LOG_OBJECT (self, "begin");
self->use_timestamps = TRUE;
/* GOmx */
{
GOmxCore *gomx;
self->gomx = gomx = g_omx_core_new ();
gomx->object = self;
}
self->ready_lock = g_mutex_new ();
self->sinkpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (element_class, "sink"), "sink");
gst_pad_set_chain_function (self->sinkpad, pad_chain);
gst_pad_set_event_function (self->sinkpad, pad_event);
self->srcpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (element_class, "src"), "src");
gst_pad_set_activatepush_function (self->srcpad, activate_push);
gst_pad_use_fixed_caps (self->srcpad);
gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
{
const char *tmp;
tmp = g_type_get_qdata (G_OBJECT_CLASS_TYPE (g_class),
g_quark_from_static_string ("library-name"));
self->omx_library = g_strdup (tmp);
tmp = g_type_get_qdata (G_OBJECT_CLASS_TYPE (g_class),
g_quark_from_static_string ("component-name"));
self->omx_component = g_strdup (tmp);
}
GST_LOG_OBJECT (self, "end");
}
static void
type_instance_init (GTypeInstance * instance, gpointer g_class)
{
GstOmxBaseVideoDec *omx_base;
GstOmxBaseFilter *omx_base_filter;
omx_base = GST_OMX_BASE_VIDEODEC (instance);
omx_base_filter = GST_OMX_BASE_FILTER (instance);
omx_base->compression_format = OMX_VIDEO_CodingAVC;
gst_pad_set_setcaps_function (omx_base_filter->sinkpad, sink_setcaps);
}
static void
type_instance_init (GTypeInstance * instance, gpointer g_class)
{
GstOmxBaseFilter *omx_base;
omx_base = GST_OMX_BASE_FILTER (instance);
omx_base->omx_setup = omx_setup;
omx_base->gomx->settings_changed_cb = settings_changed_cb;
gst_pad_set_setcaps_function (omx_base->sinkpad, sink_setcaps);
}
static gboolean
sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstStructure *structure;
GstOmxBaseFilter *omx_base;
GOmxCore *gomx;
gint rate = 0;
omx_base = GST_OMX_BASE_FILTER (GST_PAD_PARENT (pad));
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (omx_base, "setcaps (sink): %" GST_PTR_FORMAT, caps);
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "rate", &rate);
/* Input port configuration. */
{
OMX_AUDIO_PARAM_PCMMODETYPE param;
G_OMX_INIT_PARAM (param);
param.nPortIndex = omx_base->out_port->port_index;
OMX_GetParameter (gomx->omx_handle, OMX_IndexParamAudioPcm, ¶m);
param.nSamplingRate = rate;
OMX_SetParameter (gomx->omx_handle, OMX_IndexParamAudioPcm, ¶m);
}
/* set caps on the srcpad */
{
GstCaps *tmp_caps;
tmp_caps = gst_pad_get_allowed_caps (omx_base->srcpad);
tmp_caps = gst_caps_make_writable (tmp_caps);
gst_caps_truncate (tmp_caps);
gst_pad_fixate_caps (omx_base->srcpad, tmp_caps);
if (gst_caps_is_fixed (tmp_caps)) {
GST_INFO_OBJECT (omx_base, "fixated to: %" GST_PTR_FORMAT, tmp_caps);
gst_pad_set_caps (omx_base->srcpad, tmp_caps);
}
gst_caps_unref (tmp_caps);
}
return gst_pad_set_caps (pad, caps);
}
static void
type_instance_init (GTypeInstance * instance, gpointer g_class)
{
GstOmxBaseFilter *omx_base;
GstOmxAmrWbEnc *self;
omx_base = GST_OMX_BASE_FILTER (instance);
self = GST_OMX_AMRWBENC (instance);
omx_base->gomx->settings_changed_cb = settings_changed_cb;
gst_pad_set_setcaps_function (omx_base->sinkpad, sink_setcaps);
self->bitrate = DEFAULT_BITRATE;
}
static void
get_property (GObject *obj,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (obj);
if (gstomx_get_property_helper (self->gomx, prop_id, value))
return;
switch (prop_id)
{
case ARG_USE_TIMESTAMPS:
g_value_set_boolean (value, self->use_timestamps);
break;
case ARG_NUM_INPUT_BUFFERS:
case ARG_NUM_OUTPUT_BUFFERS:
{
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
self->in_port : self->out_port;
if (G_UNLIKELY (!omx_handle))
{
GST_WARNING_OBJECT (self, "no component");
g_value_set_uint (value, 0);
break;
}
G_OMX_INIT_PARAM (param);
param.nPortIndex = port->port_index;
OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
g_value_set_uint (value, param.nBufferCountActual);
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
break;
}
}
static void
finalize (GObject * obj)
{
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (obj);
if (self->codec_data) {
gst_buffer_unref (self->codec_data);
self->codec_data = NULL;
}
g_omx_core_free (self->gomx);
g_mutex_free (self->ready_lock);
G_OBJECT_CLASS (parent_class)->finalize (obj);
}
static void
type_instance_init (GTypeInstance *instance,
gpointer g_class)
{
GstOmxBaseFilter *self;
GstElementClass *element_class;
element_class = GST_ELEMENT_CLASS (g_class);
self = GST_OMX_BASE_FILTER (instance);
GST_LOG_OBJECT (self, "begin");
self->use_timestamps = TRUE;
/* GOmx */
{
GOmxCore *gomx;
self->gomx = gomx = g_omx_core_new ();
gomx->client_data = self;
}
self->sinkpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (element_class, "sink"), "sink");
gst_pad_set_chain_function (self->sinkpad, pad_chain);
gst_pad_set_event_function (self->sinkpad, pad_event);
self->srcpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (element_class, "src"), "src");
gst_pad_set_activatepush_function (self->srcpad, activate_push);
gst_pad_use_fixed_caps (self->srcpad);
gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
self->omx_library = g_strdup (DEFAULT_LIBRARY_NAME);
GST_LOG_OBJECT (self, "end");
}
static void
dispose (GObject *obj)
{
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (obj);
if (self->codec_data)
{
gst_buffer_unref (self->codec_data);
self->codec_data = NULL;
}
g_omx_core_free (self->gomx);
g_free (self->omx_component);
g_free (self->omx_library);
G_OBJECT_CLASS (parent_class)->dispose (obj);
}
static void
type_instance_init (GTypeInstance *instance,
gpointer g_class)
{
GstOmxBaseFilter *omx_base;
GstOmxJpegEnc *self;
omx_base = GST_OMX_BASE_FILTER (instance);
self = GST_OMX_JPEGENC (instance);
omx_base->omx_setup = omx_setup;
omx_base->gomx->settings_changed_cb = settings_changed_cb;
gst_pad_set_setcaps_function (omx_base->sinkpad, sink_setcaps);
self->framerate_num = 0;
self->framerate_denom = 1;
self->quality = DEFAULT_QUALITY;
}
static void
type_instance_init (GTypeInstance * instance, gpointer g_class)
{
GstOmxBaseFilter *self;
GstElementClass *element_class;
element_class = GST_ELEMENT_CLASS (g_class);
self = GST_OMX_BASE_FILTER (instance);
GST_LOG_OBJECT (self, "begin");
self->use_timestamps = TRUE;
self->gomx = gstomx_core_new (self, G_TYPE_FROM_CLASS (g_class));
self->in_port = g_omx_core_new_port (self->gomx, 0);
self->out_port = g_omx_core_new_port (self->gomx, 1);
self->ready_lock = g_mutex_new ();
self->sinkpad =
gst_pad_new_from_template (gst_element_class_get_pad_template
(element_class, "sink"), "sink");
gst_pad_set_chain_function (self->sinkpad, pad_chain);
gst_pad_set_event_function (self->sinkpad, pad_event);
self->srcpad =
gst_pad_new_from_template (gst_element_class_get_pad_template
(element_class, "src"), "src");
gst_pad_set_activatepush_function (self->srcpad, activate_push);
gst_pad_use_fixed_caps (self->srcpad);
gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
GST_LOG_OBJECT (self, "end");
}
static gboolean
sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstStructure *structure;
GstOmxBaseFilter *omx_base;
GOmxCore *gomx;
gint rate = 0;
gint channels = 0;
omx_base = GST_OMX_BASE_FILTER (GST_PAD_PARENT (pad));
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (omx_base, "setcaps (sink): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (gst_caps_get_size (caps) == 1, FALSE);
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "rate", &rate);
gst_structure_get_int (structure, "channels", &channels);
/* Input port configuration. */
{
OMX_AUDIO_PARAM_PCMMODETYPE param;
G_OMX_INIT_PARAM (param);
param.nPortIndex = omx_base->in_port->port_index;
OMX_GetParameter (gomx->omx_handle, OMX_IndexParamAudioPcm, ¶m);
param.nSamplingRate = rate;
param.nChannels = channels;
OMX_SetParameter (gomx->omx_handle, OMX_IndexParamAudioPcm, ¶m);
}
return gst_pad_set_caps (pad, caps);
}
static void
type_instance_init (GTypeInstance *instance,
gpointer g_class)
{
GstOmxBaseFilter *omx_base;
GstOmxBaseVideoEnc *self;
omx_base = GST_OMX_BASE_FILTER (instance);
self = GST_OMX_BASE_VIDEOENC (instance);
omx_base->omx_setup = omx_setup;
omx_base->in_port->omx_allocate = TRUE;
omx_base->out_port->omx_allocate = TRUE;
omx_base->in_port->share_buffer = FALSE;
omx_base->out_port->share_buffer = FALSE;
omx_base->out_port->always_copy = FALSE;
omx_base->in_port->always_copy = TRUE;
gst_pad_set_setcaps_function (omx_base->sinkpad, sink_setcaps);
self->bitrate = DEFAULT_BITRATE;
}
static gboolean
pad_event (GstPad *pad,
GstEvent *event)
{
GstOmxBaseFilter *self;
GOmxCore *gomx;
GOmxPort *in_port;
GOmxPort *out_port;
gboolean ret;
self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
gomx = self->gomx;
in_port = self->in_port;
out_port = self->out_port;
GST_LOG_OBJECT (self, "begin");
GST_INFO_OBJECT (self, "event: %s", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event))
{
case GST_EVENT_EOS:
if (self->initialized)
{
/* send buffer with eos flag */
/** @todo move to util */
{
OMX_BUFFERHEADERTYPE *omx_buffer;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
if (G_LIKELY (omx_buffer))
{
omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
GST_LOG_OBJECT (self, "release_buffer");
/* foo_buffer_untaint (omx_buffer); */
g_omx_port_release_buffer (in_port, omx_buffer);
}
else
{
g_omx_core_set_done (gomx);
}
}
/* Wait for the output port to get the EOS. */
g_omx_core_wait_for_done (gomx);
}
ret = gst_pad_push_event (self->srcpad, event);
break;
case GST_EVENT_FLUSH_START:
gst_pad_push_event (self->srcpad, event);
self->last_pad_push_return = GST_FLOW_WRONG_STATE;
g_omx_core_flush_start (gomx);
gst_pad_pause_task (self->srcpad);
ret = TRUE;
break;
case GST_EVENT_FLUSH_STOP:
gst_pad_push_event (self->srcpad, event);
self->last_pad_push_return = GST_FLOW_OK;
g_omx_core_flush_stop (gomx);
gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
ret = TRUE;
break;
case GST_EVENT_NEWSEGMENT:
ret = gst_pad_push_event (self->srcpad, event);
break;
default:
ret = gst_pad_push_event (self->srcpad, event);
break;
}
GST_LOG_OBJECT (self, "end");
return ret;
}
static gboolean
sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstStructure *structure;
GstOmxBaseVideoDec *self;
GstOmxBaseFilter *omx_base;
GOmxCore *gomx;
OMX_PARAM_PORTDEFINITIONTYPE param;
gint width = 0;
gint height = 0;
self = GST_OMX_BASE_VIDEODEC (GST_PAD_PARENT (pad));
omx_base = GST_OMX_BASE_FILTER (self);
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (self, "setcaps (sink): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (gst_caps_get_size (caps) == 1, FALSE);
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "width", &width);
gst_structure_get_int (structure, "height", &height);
{
const GValue *framerate = NULL;
framerate = gst_structure_get_value (structure, "framerate");
if (framerate) {
self->framerate_num = gst_value_get_fraction_numerator (framerate);
self->framerate_denom = gst_value_get_fraction_denominator (framerate);
}
}
G_OMX_INIT_PARAM (param);
{
const GValue *codec_data;
GstBuffer *buffer;
codec_data = gst_structure_get_value (structure, "codec_data");
if (codec_data) {
buffer = gst_value_get_buffer (codec_data);
omx_base->codec_data = buffer;
gst_buffer_ref (buffer);
}
}
/* Input port configuration. */
{
param.nPortIndex = omx_base->in_port->port_index;
OMX_GetParameter (gomx->omx_handle, OMX_IndexParamPortDefinition, ¶m);
param.format.video.nFrameWidth = width;
param.format.video.nFrameHeight = height;
OMX_SetParameter (gomx->omx_handle, OMX_IndexParamPortDefinition, ¶m);
}
return gst_pad_set_caps (pad, caps);
}
static void
output_loop (gpointer data)
{
GstPad *pad;
GOmxCore *gomx;
GOmxPort *out_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
pad = data;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
/* do not bother if we have been setup to bail out */
if ((ret = g_atomic_int_get (&self->last_pad_push_return)) != GST_FLOW_OK)
goto leave;
if (!self->ready) {
g_error ("not ready");
return;
}
out_port = self->out_port;
if (G_LIKELY (out_port->enabled)) {
OMX_BUFFERHEADERTYPE *omx_buffer = NULL;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (out_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_UNLIKELY (!omx_buffer)) {
GST_WARNING_OBJECT (self, "null buffer: leaving");
ret = GST_FLOW_WRONG_STATE;
goto leave;
}
log_buffer (self, omx_buffer);
if (G_LIKELY (omx_buffer->nFilledLen > 0)) {
GstBuffer *buf;
#if 1
/** @todo remove this check */
if (G_LIKELY (self->in_port->enabled)) {
GstCaps *caps = NULL;
caps = gst_pad_get_negotiated_caps (self->srcpad);
#ifdef ANDROID
if (!caps || gomx->settings_changed) {
#else
if (!caps) {
#endif
/** @todo We shouldn't be doing this. */
GST_WARNING_OBJECT (self, "faking settings changed notification");
if (gomx->settings_changed_cb)
gomx->settings_changed_cb (gomx);
#ifdef ANDROID
gomx->settings_changed = FALSE;
#endif
} else {
GST_LOG_OBJECT (self, "caps already fixed: %" GST_PTR_FORMAT, caps);
gst_caps_unref (caps);
}
}
#endif
/* buf is always null when the output buffer pointer isn't shared. */
buf = omx_buffer->pAppPrivate;
/** @todo we need to move all the caps handling to one single
* place, in the output loop probably. */
if (G_UNLIKELY (omx_buffer->nFlags & 0x80)) {
GstCaps *caps = NULL;
GstStructure *structure;
GValue value = { 0, {{0}
}
};
caps = gst_pad_get_negotiated_caps (self->srcpad);
caps = gst_caps_make_writable (caps);
structure = gst_caps_get_structure (caps, 0);
g_value_init (&value, GST_TYPE_BUFFER);
buf = gst_buffer_new_and_alloc (omx_buffer->nFilledLen);
memcpy (GST_BUFFER_DATA (buf),
omx_buffer->pBuffer + omx_buffer->nOffset, omx_buffer->nFilledLen);
gst_value_set_buffer (&value, buf);
gst_buffer_unref (buf);
gst_structure_set_value (structure, "codec_data", &value);
g_value_unset (&value);
gst_pad_set_caps (self->srcpad, caps);
} else if (buf && !(omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
GST_BUFFER_SIZE (buf) = omx_buffer->nFilledLen;
if (self->use_timestamps) {
GST_BUFFER_TIMESTAMP (buf) =
gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
OMX_TICKS_PER_SECOND);
}
omx_buffer->pAppPrivate = NULL;
omx_buffer->pBuffer = NULL;
ret = push_buffer (self, buf);
gst_buffer_unref (buf);
} else {
/* This is only meant for the first OpenMAX buffers,
* which need to be pre-allocated. */
/* Also for the very last one. */
ret = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nFilledLen, GST_PAD_CAPS (self->srcpad), &buf);
if (G_LIKELY (buf)) {
memcpy (GST_BUFFER_DATA (buf),
omx_buffer->pBuffer + omx_buffer->nOffset,
omx_buffer->nFilledLen);
if (self->use_timestamps) {
GST_BUFFER_TIMESTAMP (buf) =
gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
OMX_TICKS_PER_SECOND);
}
if (self->share_output_buffer) {
GST_WARNING_OBJECT (self, "couldn't zero-copy");
/* If pAppPrivate is NULL, it means it was a dummy
* allocation, free it. */
if (!omx_buffer->pAppPrivate) {
g_free (omx_buffer->pBuffer);
omx_buffer->pBuffer = NULL;
}
}
ret = push_buffer (self, buf);
} else {
GST_WARNING_OBJECT (self, "couldn't allocate buffer of size %lu",
omx_buffer->nFilledLen);
}
}
} else {
GST_WARNING_OBJECT (self, "empty buffer");
}
if (self->share_output_buffer &&
!omx_buffer->pBuffer && omx_buffer->nOffset == 0) {
GstBuffer *buf;
GstFlowReturn result;
GST_LOG_OBJECT (self, "allocate buffer");
result = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nAllocLen, GST_PAD_CAPS (self->srcpad), &buf);
if (G_LIKELY (result == GST_FLOW_OK)) {
gst_buffer_ref (buf);
omx_buffer->pAppPrivate = buf;
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
} else {
GST_WARNING_OBJECT (self,
"could not pad allocate buffer, using malloc");
omx_buffer->pBuffer = g_malloc (omx_buffer->nAllocLen);
}
}
if (self->share_output_buffer && !omx_buffer->pBuffer) {
GST_ERROR_OBJECT (self, "no input buffer to share");
}
if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
GST_DEBUG_OBJECT (self, "got eos");
gst_pad_push_event (self->srcpad, gst_event_new_eos ());
omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
ret = GST_FLOW_UNEXPECTED;
}
omx_buffer->nFilledLen = 0;
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (out_port, omx_buffer);
}
leave:
self->last_pad_push_return = ret;
if (gomx->omx_error != OMX_ErrorNone)
ret = GST_FLOW_ERROR;
if (ret != GST_FLOW_OK) {
GST_INFO_OBJECT (self, "pause task, reason: %s", gst_flow_get_name (ret));
gst_pad_pause_task (self->srcpad);
}
GST_LOG_OBJECT (self, "end");
gst_object_unref (self);
}
static GstFlowReturn
pad_chain (GstPad * pad, GstBuffer * buf)
{
GOmxCore *gomx;
GOmxPort *in_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
GST_LOG_OBJECT (self, "gst_buffer: size=%u", GST_BUFFER_SIZE (buf));
GST_LOG_OBJECT (self, "state: %d", gomx->omx_state);
if (G_UNLIKELY (gomx->omx_state == OMX_StateLoaded)) {
g_mutex_lock (self->ready_lock);
GST_INFO_OBJECT (self, "omx: prepare");
/** @todo this should probably go after doing preparations. */
if (self->omx_setup) {
self->omx_setup (self);
}
setup_ports (self);
g_omx_core_prepare (self->gomx);
if (gomx->omx_state == OMX_StateIdle) {
self->ready = TRUE;
GST_INFO_OBJECT (self, "start srcpad task");
gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
}
g_mutex_unlock (self->ready_lock);
if (gomx->omx_state != OMX_StateIdle)
goto out_flushing;
}
#ifdef ANDROID
if (gomx->settings_changed) {
GST_DEBUG_OBJECT (self, "settings changed called from streaming thread... Android");
if (gomx->settings_changed_cb)
gomx->settings_changed_cb (gomx);
gomx->settings_changed = FALSE;
}
#endif
in_port = self->in_port;
if (G_LIKELY (in_port->enabled)) {
guint buffer_offset = 0;
if (G_UNLIKELY (gomx->omx_state == OMX_StateIdle)) {
GST_INFO_OBJECT (self, "omx: play");
g_omx_core_start (gomx);
if (gomx->omx_state != OMX_StateExecuting)
goto out_flushing;
/* send buffer with codec data flag */
/** @todo move to util */
if (self->codec_data) {
OMX_BUFFERHEADERTYPE *omx_buffer;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
if (G_LIKELY (omx_buffer)) {
omx_buffer->nFlags |= 0x00000080; /* codec data flag */
omx_buffer->nFilledLen = GST_BUFFER_SIZE (self->codec_data);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
GST_BUFFER_DATA (self->codec_data), omx_buffer->nFilledLen);
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (in_port, omx_buffer);
}
}
}
if (G_UNLIKELY (gomx->omx_state != OMX_StateExecuting)) {
GST_ERROR_OBJECT (self, "Whoa! very wrong");
}
while (G_LIKELY (buffer_offset < GST_BUFFER_SIZE (buf))) {
OMX_BUFFERHEADERTYPE *omx_buffer;
if (self->last_pad_push_return != GST_FLOW_OK ||
!(gomx->omx_state == OMX_StateExecuting ||
gomx->omx_state == OMX_StatePause)) {
goto out_flushing;
}
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_LIKELY (omx_buffer)) {
log_buffer (self, omx_buffer);
if (omx_buffer->nOffset == 0 && self->share_input_buffer) {
{
GstBuffer *old_buf;
old_buf = omx_buffer->pAppPrivate;
if (old_buf) {
gst_buffer_unref (old_buf);
} else if (omx_buffer->pBuffer) {
g_free (omx_buffer->pBuffer);
}
}
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
omx_buffer->nFilledLen = GST_BUFFER_SIZE (buf);
omx_buffer->pAppPrivate = buf;
} else {
omx_buffer->nFilledLen = MIN (GST_BUFFER_SIZE (buf) - buffer_offset,
omx_buffer->nAllocLen - omx_buffer->nOffset);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
GST_BUFFER_DATA (buf) + buffer_offset, omx_buffer->nFilledLen);
}
if (self->use_timestamps) {
GstClockTime timestamp_offset = 0;
if (buffer_offset && GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE) {
timestamp_offset = gst_util_uint64_scale_int (buffer_offset,
GST_BUFFER_DURATION (buf), GST_BUFFER_SIZE (buf));
}
omx_buffer->nTimeStamp =
gst_util_uint64_scale_int (GST_BUFFER_TIMESTAMP (buf) +
timestamp_offset, OMX_TICKS_PER_SECOND, GST_SECOND);
}
buffer_offset += omx_buffer->nFilledLen;
#ifdef ANDROID
omx_buffer->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
log_buffer (self, omx_buffer);
#endif
GST_LOG_OBJECT (self, "release_buffer");
/** @todo untaint buffer */
g_omx_port_release_buffer (in_port, omx_buffer);
} else {
GST_WARNING_OBJECT (self, "null buffer");
ret = GST_FLOW_WRONG_STATE;
goto out_flushing;
}
}
} else {
GST_WARNING_OBJECT (self, "done");
ret = GST_FLOW_UNEXPECTED;
}
if (!self->share_input_buffer) {
gst_buffer_unref (buf);
}
leave:
GST_LOG_OBJECT (self, "end");
return ret;
/* special conditions */
out_flushing:
{
const gchar *error_msg = NULL;
if (gomx->omx_error) {
error_msg = "Error from OpenMAX component";
} else if (gomx->omx_state != OMX_StateExecuting &&
gomx->omx_state != OMX_StatePause) {
error_msg = "OpenMAX component in wrong state";
}
if (error_msg) {
GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
ret = GST_FLOW_ERROR;
}
gst_buffer_unref (buf);
goto leave;
}
}
static gboolean
sink_setcaps (GstPad *pad,
GstCaps *caps)
{
GstStructure *structure;
GstOmxBaseFilter *omx_base;
GstOmxJpegEnc *self;
GOmxCore *gomx;
OMX_COLOR_FORMATTYPE color_format = OMX_COLOR_FormatYUV420PackedPlanar;
gint width = 0;
gint height = 0;
omx_base = GST_OMX_BASE_FILTER (GST_PAD_PARENT (pad));
self = GST_OMX_JPEGENC (omx_base);
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (omx_base, "setcaps (sink): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (gst_caps_get_size (caps) == 1, FALSE);
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "width", &width);
gst_structure_get_int (structure, "height", &height);
if (!gst_structure_get_fraction (structure, "framerate",
&self->framerate_num,
&self->framerate_denom))
{
self->framerate_num = 0;
self->framerate_denom = 1;
omx_base->duration = gst_util_uint64_scale_int(GST_SECOND,0,1);
GST_DEBUG_OBJECT (self, "Nominal frame duration =%"GST_TIME_FORMAT,
GST_TIME_ARGS (omx_base->duration));
}
if (strcmp (gst_structure_get_name (structure), "video/x-raw-yuv") == 0)
{
guint32 fourcc;
if (gst_structure_get_fourcc (structure, "format", &fourcc))
{
color_format = g_omx_fourcc_to_colorformat (fourcc);
}
}
{
OMX_PARAM_PORTDEFINITIONTYPE param;
/* Input port configuration. */
G_OMX_PORT_GET_DEFINITION (omx_base->in_port, ¶m);
param.format.image.nFrameWidth = width;
param.format.image.nFrameHeight = height;
param.format.image.eColorFormat = color_format;
G_OMX_PORT_SET_DEFINITION (omx_base->in_port, ¶m);
}
return gst_pad_set_caps (pad, caps);
}
static GstStateChangeReturn
change_state (GstElement *element,
GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstOmxBaseFilter *self;
GOmxCore *core;
self = GST_OMX_BASE_FILTER (element);
core = self->gomx;
GST_LOG_OBJECT (self, "begin");
GST_INFO_OBJECT (self, "changing state %s - %s",
gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
switch (transition)
{
case GST_STATE_CHANGE_NULL_TO_READY:
g_omx_core_init (core, self->omx_library, self->omx_component);
if (core->omx_state != OMX_StateLoaded)
{
ret = GST_STATE_CHANGE_FAILURE;
goto leave;
}
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (ret == GST_STATE_CHANGE_FAILURE)
goto leave;
switch (transition)
{
case GST_STATE_CHANGE_PAUSED_TO_READY:
g_mutex_lock (self->ready_lock);
if (self->ready)
{
/* unlock */
g_omx_port_finish (self->in_port);
g_omx_port_finish (self->out_port);
g_omx_core_stop (core);
g_omx_core_unload (core);
self->ready = FALSE;
}
g_mutex_unlock (self->ready_lock);
if (core->omx_state != OMX_StateLoaded &&
core->omx_state != OMX_StateInvalid)
{
ret = GST_STATE_CHANGE_FAILURE;
goto leave;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
g_omx_core_deinit (core);
break;
default:
break;
}
leave:
GST_LOG_OBJECT (self, "end");
return ret;
}
static gboolean
pad_event (GstPad *pad,
GstEvent *event)
{
GstOmxBaseFilter *self;
GOmxCore *gomx;
GOmxPort *in_port;
gboolean ret = TRUE;
self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
gomx = self->gomx;
in_port = self->in_port;
GST_LOG_OBJECT (self, "begin");
GST_INFO_OBJECT (self, "event: %s", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event))
{
case GST_EVENT_EOS:
/* if we are init'ed, and there is a running loop; then
* if we get a buffer to inform it of EOS, let it handle the rest
* in any other case, we send EOS */
if (self->ready && self->last_pad_push_return == GST_FLOW_OK)
{
/* send buffer with eos flag */
/** @todo move to util */
{
OMX_BUFFERHEADERTYPE *omx_buffer;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
if (G_LIKELY (omx_buffer))
{
omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
GST_LOG_OBJECT (self, "release_buffer");
/* foo_buffer_untaint (omx_buffer); */
g_omx_port_release_buffer (in_port, omx_buffer);
/* loop handles EOS, eat it here */
gst_event_unref (event);
break;
}
}
}
/* we tried, but it's up to us here */
ret = gst_pad_push_event (self->srcpad, event);
break;
case GST_EVENT_FLUSH_START:
gst_pad_push_event (self->srcpad, event);
self->last_pad_push_return = GST_FLOW_WRONG_STATE;
g_omx_core_flush_start (gomx);
gst_pad_pause_task (self->srcpad);
ret = TRUE;
break;
case GST_EVENT_FLUSH_STOP:
gst_pad_push_event (self->srcpad, event);
self->last_pad_push_return = GST_FLOW_OK;
g_omx_core_flush_stop (gomx);
if (self->ready)
gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
ret = TRUE;
break;
case GST_EVENT_NEWSEGMENT:
ret = gst_pad_push_event (self->srcpad, event);
break;
default:
ret = gst_pad_push_event (self->srcpad, event);
break;
}
GST_LOG_OBJECT (self, "end");
return ret;
}
static GstFlowReturn
pad_chain (GstPad *pad,
GstBuffer *buf)
{
GOmxCore *gomx;
GOmxPort *in_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
GST_LOG_OBJECT (self, "gst_buffer: size=%u", GST_BUFFER_SIZE (buf));
GST_LOG_OBJECT (self, "state: %d", gomx->omx_state);
if (G_UNLIKELY (gomx->omx_state == OMX_StateLoaded))
{
g_mutex_lock (self->ready_lock);
GST_INFO_OBJECT (self, "omx: prepare");
/** @todo this should probably go after doing preparations. */
if (self->omx_setup)
{
self->omx_setup (self);
}
setup_ports (self);
g_omx_core_prepare (self->gomx);
if (gomx->omx_state == OMX_StateIdle)
{
self->ready = TRUE;
gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
}
g_mutex_unlock (self->ready_lock);
if (gomx->omx_state != OMX_StateIdle)
goto out_flushing;
}
in_port = self->in_port;
if (G_LIKELY (in_port->enabled))
{
guint buffer_offset = 0;
if (G_UNLIKELY (gomx->omx_state == OMX_StateIdle))
{
GST_INFO_OBJECT (self, "omx: play");
g_omx_core_start (gomx);
if (gomx->omx_state != OMX_StateExecuting)
goto out_flushing;
/* send buffer with codec data flag */
/** @todo move to util */
if (self->codec_data)
{
OMX_BUFFERHEADERTYPE *omx_buffer;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
if (G_LIKELY (omx_buffer))
{
omx_buffer->nFlags |= 0x00000080; /* codec data flag */
omx_buffer->nFilledLen = GST_BUFFER_SIZE (self->codec_data);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset, GST_BUFFER_DATA (self->codec_data), omx_buffer->nFilledLen);
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (in_port, omx_buffer);
}
}
}
if (G_UNLIKELY (gomx->omx_state != OMX_StateExecuting))
{
GST_ERROR_OBJECT (self, "Whoa! very wrong");
}
while (G_LIKELY (buffer_offset < GST_BUFFER_SIZE (buf)))
{
OMX_BUFFERHEADERTYPE *omx_buffer;
if (self->last_pad_push_return != GST_FLOW_OK ||
!(gomx->omx_state == OMX_StateExecuting ||
gomx->omx_state == OMX_StatePause))
{
goto out_flushing;
}
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (in_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_LIKELY (omx_buffer))
{
GST_DEBUG_OBJECT (self, "omx_buffer: size=%lu, len=%lu, flags=%lu, offset=%lu, timestamp=%lld",
omx_buffer->nAllocLen, omx_buffer->nFilledLen, omx_buffer->nFlags,
omx_buffer->nOffset, omx_buffer->nTimeStamp);
if (omx_buffer->nOffset == 0 &&
self->share_input_buffer)
{
{
GstBuffer *old_buf;
old_buf = omx_buffer->pAppPrivate;
if (old_buf)
{
gst_buffer_unref (old_buf);
}
else if (omx_buffer->pBuffer)
{
g_free (omx_buffer->pBuffer);
}
}
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
omx_buffer->nFilledLen = GST_BUFFER_SIZE (buf);
omx_buffer->pAppPrivate = buf;
}
else
{
omx_buffer->nFilledLen = MIN (GST_BUFFER_SIZE (buf) - buffer_offset,
omx_buffer->nAllocLen - omx_buffer->nOffset);
memcpy (omx_buffer->pBuffer + omx_buffer->nOffset, GST_BUFFER_DATA (buf) + buffer_offset, omx_buffer->nFilledLen);
}
if (self->use_timestamps)
{
GstClockTime timestamp_offset = 0;
if (buffer_offset && GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE)
{
timestamp_offset = gst_util_uint64_scale_int (buffer_offset,
GST_BUFFER_DURATION (buf),
GST_BUFFER_SIZE (buf));
}
omx_buffer->nTimeStamp = gst_util_uint64_scale_int (GST_BUFFER_TIMESTAMP (buf) + timestamp_offset,
OMX_TICKS_PER_SECOND,
GST_SECOND);
}
buffer_offset += omx_buffer->nFilledLen;
GST_LOG_OBJECT (self, "release_buffer");
/** @todo untaint buffer */
g_omx_port_release_buffer (in_port, omx_buffer);
}
else
{
GST_WARNING_OBJECT (self, "null buffer");
ret = GST_FLOW_WRONG_STATE;
goto out_flushing;
}
}
}
else
{
GST_WARNING_OBJECT (self, "done");
ret = GST_FLOW_UNEXPECTED;
}
if (!self->share_input_buffer)
{
gst_buffer_unref (buf);
}
leave:
GST_LOG_OBJECT (self, "end");
return ret;
/* special conditions */
out_flushing:
{
const gchar *error_msg = NULL;
if (gomx->omx_error)
{
error_msg = "Error from OpenMAX component";
}
else if (gomx->omx_state != OMX_StateExecuting &&
gomx->omx_state != OMX_StatePause)
{
error_msg = "OpenMAX component in wrong state";
}
if (error_msg)
{
GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), (error_msg));
ret = GST_FLOW_ERROR;
}
gst_buffer_unref (buf);
goto leave;
}
}
static void
output_loop (gpointer data)
{
GstPad *pad;
GOmxCore *gomx;
GOmxPort *out_port;
GstOmxBaseFilter *self;
GstFlowReturn ret = GST_FLOW_OK;
pad = data;
self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
gomx = self->gomx;
GST_LOG_OBJECT (self, "begin");
if (!self->ready)
{
g_error ("not ready");
return;
}
out_port = self->out_port;
if (G_LIKELY (out_port->enabled))
{
OMX_BUFFERHEADERTYPE *omx_buffer = NULL;
GST_LOG_OBJECT (self, "request buffer");
omx_buffer = g_omx_port_request_buffer (out_port);
GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
if (G_UNLIKELY (!omx_buffer))
{
GST_WARNING_OBJECT (self, "null buffer: leaving");
ret = GST_FLOW_WRONG_STATE;
goto leave;
}
GST_DEBUG_OBJECT (self, "omx_buffer: size=%lu, len=%lu, flags=%lu, offset=%lu, timestamp=%lld",
omx_buffer->nAllocLen, omx_buffer->nFilledLen, omx_buffer->nFlags,
omx_buffer->nOffset, omx_buffer->nTimeStamp);
if (G_LIKELY (omx_buffer->nFilledLen > 0))
{
GstBuffer *buf;
#if 1
/** @todo remove this check */
if (G_LIKELY (self->in_port->enabled))
{
GstCaps *caps = NULL;
caps = gst_pad_get_negotiated_caps (self->srcpad);
if (!caps)
{
/** @todo We shouldn't be doing this. */
GST_WARNING_OBJECT (self, "faking settings changed notification");
if (gomx->settings_changed_cb)
gomx->settings_changed_cb (gomx);
}
else
{
GST_LOG_OBJECT (self, "caps already fixed: %" GST_PTR_FORMAT, caps);
gst_caps_unref (caps);
}
}
#endif
/* buf is always null when the output buffer pointer isn't shared. */
buf = omx_buffer->pAppPrivate;
/** @todo we need to move all the caps handling to one single
* place, in the output loop probably. */
if (G_UNLIKELY (omx_buffer->nFlags & 0x80))
{
GstCaps *caps = NULL;
GstStructure *structure;
GValue value = { 0 };
caps = gst_pad_get_negotiated_caps (self->srcpad);
caps = gst_caps_make_writable (caps);
structure = gst_caps_get_structure (caps, 0);
g_value_init (&value, GST_TYPE_BUFFER);
buf = gst_buffer_new_and_alloc (omx_buffer->nFilledLen);
memcpy (GST_BUFFER_DATA (buf), omx_buffer->pBuffer + omx_buffer->nOffset, omx_buffer->nFilledLen);
gst_value_set_buffer (&value, buf);
gst_buffer_unref (buf);
gst_structure_set_value (structure, "codec_data", &value);
g_value_unset (&value);
gst_pad_set_caps (self->srcpad, caps);
}
else if (buf && !(omx_buffer->nFlags & OMX_BUFFERFLAG_EOS))
{
GST_BUFFER_SIZE (buf) = omx_buffer->nFilledLen;
if (self->use_timestamps)
{
GST_BUFFER_TIMESTAMP (buf) = gst_util_uint64_scale_int (omx_buffer->nTimeStamp,
GST_SECOND,
OMX_TICKS_PER_SECOND);
}
omx_buffer->pAppPrivate = NULL;
omx_buffer->pBuffer = NULL;
ret = push_buffer (self, buf);
gst_buffer_unref (buf);
}
else
{
/* This is only meant for the first OpenMAX buffers,
* which need to be pre-allocated. */
/* Also for the very last one. */
ret = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nFilledLen,
GST_PAD_CAPS (self->srcpad),
&buf);
if (G_LIKELY (buf))
{
memcpy (GST_BUFFER_DATA (buf), omx_buffer->pBuffer + omx_buffer->nOffset, omx_buffer->nFilledLen);
if (self->use_timestamps)
{
GST_BUFFER_TIMESTAMP (buf) = gst_util_uint64_scale_int (omx_buffer->nTimeStamp,
GST_SECOND,
OMX_TICKS_PER_SECOND);
}
if (self->share_output_buffer)
{
GST_WARNING_OBJECT (self, "couldn't zero-copy");
/* If pAppPrivate is NULL, it means it was a dummy
* allocation, free it. */
if (!omx_buffer->pAppPrivate)
{
g_free (omx_buffer->pBuffer);
omx_buffer->pBuffer = NULL;
}
}
ret = push_buffer (self, buf);
}
else
{
GST_WARNING_OBJECT (self, "couldn't allocate buffer of size %d",
omx_buffer->nFilledLen);
}
}
}
else
{
GST_WARNING_OBJECT (self, "empty buffer");
}
if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS))
{
GST_DEBUG_OBJECT (self, "got eos");
gst_pad_push_event (self->srcpad, gst_event_new_eos ());
ret = GST_FLOW_UNEXPECTED;
goto leave;
}
if (self->share_output_buffer &&
!omx_buffer->pBuffer &&
omx_buffer->nOffset == 0)
{
GstBuffer *buf;
GstFlowReturn result;
GST_LOG_OBJECT (self, "allocate buffer");
result = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
GST_BUFFER_OFFSET_NONE,
omx_buffer->nAllocLen,
GST_PAD_CAPS (self->srcpad),
&buf);
if (G_LIKELY (result == GST_FLOW_OK))
{
gst_buffer_ref (buf);
omx_buffer->pAppPrivate = buf;
omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
}
else
{
GST_WARNING_OBJECT (self, "could not pad allocate buffer, using malloc");
omx_buffer->pBuffer = g_malloc (omx_buffer->nAllocLen);
}
}
if (self->share_output_buffer &&
!omx_buffer->pBuffer)
{
GST_ERROR_OBJECT (self, "no input buffer to share");
}
omx_buffer->nFilledLen = 0;
GST_LOG_OBJECT (self, "release_buffer");
g_omx_port_release_buffer (out_port, omx_buffer);
}
leave:
self->last_pad_push_return = ret;
if (gomx->omx_error != OMX_ErrorNone)
ret = GST_FLOW_ERROR;
if (ret != GST_FLOW_OK)
{
GST_INFO_OBJECT (self, "pause task, reason: %s",
gst_flow_get_name (ret));
gst_pad_pause_task (self->srcpad);
}
GST_LOG_OBJECT (self, "end");
gst_object_unref (self);
}
/* h264 dec has its own sink_setcaps for supporting nalu convert codec data */
static gboolean
sink_setcaps (GstPad * pad, GstCaps * caps)
{
GstStructure *structure;
GstOmxBaseVideoDec *self;
GstOmxH264Dec *h264_self;
GstOmxBaseFilter *omx_base;
GOmxCore *gomx;
OMX_PARAM_PORTDEFINITIONTYPE param;
gint width = 0;
gint height = 0;
self = GST_OMX_BASE_VIDEODEC (GST_PAD_PARENT (pad));
h264_self = GST_OMX_H264DEC (GST_PAD_PARENT (pad));
omx_base = GST_OMX_BASE_FILTER (self);
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (self, "setcaps (sink)(h264): %" GST_PTR_FORMAT, caps);
g_return_val_if_fail (gst_caps_get_size (caps) == 1, FALSE);
structure = gst_caps_get_structure (caps, 0);
gst_structure_get_int (structure, "width", &width);
gst_structure_get_int (structure, "height", &height);
{
const GValue *framerate = NULL;
framerate = gst_structure_get_value (structure, "framerate");
if (framerate) {
self->framerate_num = gst_value_get_fraction_numerator (framerate);
self->framerate_denom = gst_value_get_fraction_denominator (framerate);
}
}
G_OMX_INIT_PARAM (param);
{
const GValue *codec_data;
GstBuffer *buffer;
gboolean ret = FALSE;
guint8 *buf_data = NULL;
codec_data = gst_structure_get_value (structure, "codec_data");
if (codec_data) {
buffer = gst_value_get_buffer (codec_data);
buf_data = GST_BUFFER_DATA(buffer);
if (GST_BUFFER_SIZE(buffer) < 4) GST_ERROR("codec data size is less than 4!!"); //check this.
if ((buf_data[0] == 0x00)&&(buf_data[1] == 0x00)&&
((buf_data[2] == 0x01)||((buf_data[2] == 0x00)&&(buf_data[3] == 0x01)))) {
h264_self->h264Format = GSTOMX_H264_FORMAT_NALU;
GST_INFO_OBJECT(self, "H264 format is NALU");
} else {
h264_self->h264Format = GSTOMX_H264_FORMAT_3GPP;
GST_INFO_OBJECT(self, "H264 format is 3GPP");
}
/* if codec data is 3gpp format, convert nalu format */
if(h264_self->h264Format == GSTOMX_H264_FORMAT_3GPP) {
GstBuffer *nalu_dci = NULL;
ret = convert_dci(h264_self, buffer, &nalu_dci);
if (ret) {
omx_base->codec_data = nalu_dci;
} else {
if (nalu_dci) { gst_buffer_unref (nalu_dci); }
GST_ERROR_OBJECT(h264_self, "converting dci error.");
omx_base->codec_data = buffer;
gst_buffer_ref (buffer);
}
} else { /* not 3GPP format */
omx_base->codec_data = buffer;
gst_buffer_ref (buffer);
}
h264_self->h264Format = GSTOMX_H264_FORMAT_UNKNOWN;
}
}
/* Input port configuration. */
{
param.nPortIndex = omx_base->in_port->port_index;
OMX_GetParameter (gomx->omx_handle, OMX_IndexParamPortDefinition, ¶m);
param.format.video.nFrameWidth = width;
param.format.video.nFrameHeight = height;
OMX_SetParameter (gomx->omx_handle, OMX_IndexParamPortDefinition, ¶m);
}
return gst_pad_set_caps (pad, caps);
}
static void
omx_setup (GstOmxBaseFilter *omx_base)
{
GstOmxBaseVideoEnc *self;
GOmxCore *gomx;
self = GST_OMX_BASE_VIDEOENC (omx_base);
gomx = (GOmxCore *) omx_base->gomx;
GST_INFO_OBJECT (omx_base, "begin");
{
OMX_PARAM_PORTDEFINITIONTYPE param;
/* Output port configuration. */
G_OMX_PORT_GET_DEFINITION (omx_base->out_port, ¶m);
param.format.video.eCompressionFormat = self->compression_format;
/** @todo this should be set with a property */
param.format.video.nBitrate = self->bitrate;
G_OMX_PORT_SET_DEFINITION (omx_base->out_port, ¶m);
/* some workarounds required for TI components. */
{
guint32 fourcc;
gint width, height;
gulong framerate;
/* the component should do this instead */
{
G_OMX_PORT_GET_DEFINITION (omx_base->in_port, ¶m);
width = param.format.video.nFrameWidth;
height = param.format.video.nFrameHeight;
framerate = param.format.video.xFramerate;
/* this is against the standard; nBufferSize is read-only. */
fourcc = GST_MAKE_FOURCC ('N', 'V', '1', '2');
param.nBufferSize = gst_video_format_get_size_strided (
gst_video_format_from_fourcc (fourcc),
width, height, param.format.video.nStride);
G_OMX_PORT_SET_DEFINITION (omx_base->in_port, ¶m);
}
/* the component should do this instead */
{
G_OMX_PORT_GET_DEFINITION (omx_base->out_port, ¶m);
/* this is against the standard; nBufferSize is read-only. */
param.nBufferSize = width * height;
param.format.video.nFrameWidth = width;
param.format.video.nFrameHeight = height;
param.format.video.xFramerate = framerate;
G_OMX_PORT_SET_DEFINITION (omx_base->out_port, ¶m);
}
/* the component should do this instead */
{
GOmxPort *port;
/* enable input port */
port = omx_base->in_port;
OMX_SendCommand (g_omx_core_get_handle (port->core), OMX_CommandPortEnable,
port->port_index, NULL);
g_sem_down (port->core->port_sem);
/* enable output port */
port = omx_base->out_port;
OMX_SendCommand (g_omx_core_get_handle (port->core), OMX_CommandPortEnable,
port->port_index, NULL);
g_sem_down (port->core->port_sem);
}
}
}
if (self->omx_setup)
self->omx_setup (GST_OMX_BASE_FILTER (self));
GST_INFO_OBJECT (omx_base, "end");
}
static GstStateChangeReturn
change_state (GstElement *element,
GstStateChange transition)
{
GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
GstOmxBaseFilter *self;
self = GST_OMX_BASE_FILTER (element);
GST_LOG_OBJECT (self, "begin");
GST_INFO_OBJECT (self, "changing state %s - %s",
gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
switch (transition)
{
case GST_STATE_CHANGE_NULL_TO_READY:
g_omx_core_init (self->gomx, self->omx_library, self->omx_component);
if (self->gomx->omx_error)
return GST_STATE_CHANGE_FAILURE;
break;
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (self->initialized)
{
g_omx_port_finish (self->in_port);
g_omx_port_finish (self->out_port);
}
break;
default:
break;
}
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:
if (self->initialized)
{
g_omx_core_finish (self->gomx);
self->initialized = FALSE;
}
break;
case GST_STATE_CHANGE_READY_TO_NULL:
g_omx_core_deinit (self->gomx);
if (self->gomx->omx_error)
return GST_STATE_CHANGE_FAILURE;
break;
default:
break;
}
GST_LOG_OBJECT (self, "end");
return ret;
}
