2 * Copyright (C) 2007-2009 Nokia Corporation.
4 * Author: Felipe Contreras <felipe.contreras@nokia.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 #include "gstomx_base_filter.h"
24 #include "gstomx_interface.h"
26 #include <string.h> /* for memcpy */
28 /* MODIFICATION: for state-tuning */
29 static void output_loop (gpointer data);
33 ARG_USE_TIMESTAMPS = GSTOMX_NUM_COMMON_PROP,
34 ARG_NUM_INPUT_BUFFERS,
35 ARG_NUM_OUTPUT_BUFFERS,
38 static void init_interfaces (GType type);
39 GSTOMX_BOILERPLATE_FULL (GstOmxBaseFilter, gst_omx_base_filter, GstElement,
40 GST_TYPE_ELEMENT, init_interfaces);
43 log_buffer (GstOmxBaseFilter * self, OMX_BUFFERHEADERTYPE * omx_buffer, const gchar *name)
45 GST_DEBUG_OBJECT (self, "%s: omx_buffer: "
51 name, omx_buffer->nAllocLen, omx_buffer->nFilledLen, omx_buffer->nFlags,
52 omx_buffer->nOffset, omx_buffer->nTimeStamp);
55 /* Add_code_for_extended_color_format */
57 is_extended_color_format(GstOmxBaseFilter * self, GOmxPort * port)
59 OMX_PARAM_PORTDEFINITIONTYPE param;
60 OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
62 if (G_UNLIKELY (!omx_handle)) {
63 GST_WARNING_OBJECT (self, "no component");
67 G_OMX_INIT_PARAM (param);
69 param.nPortIndex = port->port_index;
70 OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
72 switch ((guint)param.format.video.eColorFormat) {
73 case OMX_EXT_COLOR_FormatNV12TPhysicalAddress:
74 case OMX_EXT_COLOR_FormatNV12LPhysicalAddress:
75 case OMX_EXT_COLOR_FormatNV12Tiled:
76 case OMX_EXT_COLOR_FormatNV12TFdValue:
77 case OMX_EXT_COLOR_FormatNV12LFdValue:
85 setup_ports (GstOmxBaseFilter * self)
87 /* Input port configuration. */
88 g_omx_port_setup (self->in_port);
89 gst_pad_set_element_private (self->sinkpad, self->in_port);
91 /* Output port configuration. */
92 g_omx_port_setup (self->out_port);
93 gst_pad_set_element_private (self->srcpad, self->out_port);
95 /* @todo: read from config file: */
96 if (g_getenv ("OMX_ALLOCATE_ON")) {
97 GST_DEBUG_OBJECT (self, "OMX_ALLOCATE_ON");
98 self->in_port->omx_allocate = TRUE;
99 self->out_port->omx_allocate = TRUE;
100 self->in_port->shared_buffer = FALSE;
101 self->out_port->shared_buffer = FALSE;
102 } else if (g_getenv ("OMX_SHARE_HACK_ON")) {
103 GST_DEBUG_OBJECT (self, "OMX_SHARE_HACK_ON");
104 self->in_port->shared_buffer = TRUE;
105 self->out_port->shared_buffer = TRUE;
106 } else if (g_getenv ("OMX_SHARE_HACK_OFF")) {
107 GST_DEBUG_OBJECT (self, "OMX_SHARE_HACK_OFF");
108 self->in_port->shared_buffer = FALSE;
109 self->out_port->shared_buffer = FALSE;
110 /* MODIFICATION: Add extended_color_format */
111 } else if (self->gomx->component_vendor == GOMX_VENDOR_SLSI) {
112 self->in_port->shared_buffer = (is_extended_color_format(self, self->in_port))
114 self->out_port->shared_buffer = (is_extended_color_format(self, self->out_port))
116 } else if (self->gomx->component_vendor == GOMX_VENDOR_QCT) {
117 GST_DEBUG_OBJECT (self, "GOMX_VENDOR_QCT");
118 self->in_port->omx_allocate = TRUE;
119 self->out_port->omx_allocate = TRUE;
120 self->in_port->shared_buffer = FALSE;
121 self->out_port->shared_buffer = FALSE;
123 GST_DEBUG_OBJECT (self, "default sharing and allocation");
126 GST_DEBUG_OBJECT (self, "omx_allocate: in: %d, out: %d",
127 self->in_port->omx_allocate, self->out_port->omx_allocate);
128 GST_DEBUG_OBJECT (self, "share_buffer: in: %d, out: %d",
129 self->in_port->shared_buffer, self->out_port->shared_buffer);
133 omx_change_state(GstOmxBaseFilter * self,GstOmxChangeState transition, GOmxPort *in_port, GstBuffer * buf)
136 GstFlowReturn ret = GST_FLOW_OK;
140 switch (transition) {
141 case GstOmx_LodedToIdle:
143 g_mutex_lock (self->ready_lock);
145 GST_INFO_OBJECT (self, "omx: prepare");
147 /** @todo this should probably go after doing preparations. */
148 if (self->omx_setup) {
149 self->omx_setup (self);
154 g_omx_core_prepare (self->gomx);
156 if (gomx->omx_state == OMX_StateIdle) {
158 gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
161 g_mutex_unlock (self->ready_lock);
163 if (gomx->omx_state != OMX_StateIdle)
168 case GstOmx_IdleToExcuting:
170 GST_INFO_OBJECT (self, "omx: play");
171 g_omx_core_start (gomx);
173 if (gomx->omx_state != OMX_StateExecuting)
176 /* send buffer with codec data flag */
177 /** @todo move to util */
178 if (self->codec_data) {
179 OMX_BUFFERHEADERTYPE *omx_buffer;
181 GST_LOG_OBJECT (self, "request buffer");
182 omx_buffer = g_omx_port_request_buffer (in_port);
184 if (G_LIKELY (omx_buffer)) {
185 omx_buffer->nFlags |= OMX_BUFFERFLAG_CODECCONFIG;
187 omx_buffer->nFilledLen = GST_BUFFER_SIZE (self->codec_data);
188 memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
189 GST_BUFFER_DATA (self->codec_data), omx_buffer->nFilledLen);
191 GST_LOG_OBJECT (self, "release_buffer");
192 g_omx_port_release_buffer (in_port, omx_buffer);
204 GST_LOG_OBJECT (self, "end");
207 /* special conditions */
210 const gchar *error_msg = NULL;
212 if (gomx->omx_error) {
213 error_msg = "Error from OpenMAX component";
214 } else if (gomx->omx_state != OMX_StateExecuting &&
215 gomx->omx_state != OMX_StatePause) {
216 error_msg = "OpenMAX component in wrong state";
220 GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
221 ret = GST_FLOW_ERROR;
225 gst_buffer_unref (buf);
230 static GstStateChangeReturn
231 change_state (GstElement * element, GstStateChange transition)
233 GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
234 GstOmxBaseFilter *self;
237 self = GST_OMX_BASE_FILTER (element);
240 GST_LOG_OBJECT (self, "begin");
242 GST_INFO_OBJECT (self, "changing state %s - %s",
243 gst_element_state_get_name (GST_STATE_TRANSITION_CURRENT (transition)),
244 gst_element_state_get_name (GST_STATE_TRANSITION_NEXT (transition)));
246 switch (transition) {
247 case GST_STATE_CHANGE_NULL_TO_READY:
248 GST_INFO_OBJECT (self, "GST_STATE_CHANGE_NULL_TO_READY");
249 if (core->omx_state != OMX_StateLoaded) {
250 ret = GST_STATE_CHANGE_FAILURE;
254 if (self->adapter_size > 0) {
255 GST_LOG_OBJECT (self, "gst_adapter_new. size: %d", self->adapter_size);
256 self->adapter = gst_adapter_new();
257 if (self->adapter == NULL)
258 GST_ERROR_OBJECT (self, "Failed to create adapter!!");
262 case GST_STATE_CHANGE_READY_TO_PAUSED:
263 GST_INFO_OBJECT (self, "GST_STATE_CHANGE_READY_TO_PAUSED");
265 core->omx_unrecover_err_cnt = 0;
267 /* MODIFICATION: state tuning */
268 if (self->use_state_tuning) {
269 GST_INFO_OBJECT (self, "use state-tuning feature");
270 /* to handle abnormal state change. */
271 if (self->gomx != self->in_port->core) {
272 GST_ERROR_OBJECT(self, "self->gomx != self->in_port->core. start new in_port");
273 self->in_port = g_omx_core_new_port (self->gomx, 0);
275 if (self->gomx != self->out_port->core) {
276 GST_ERROR_OBJECT(self, "self->gomx != self->out_port->core. start new out_port");
277 self->out_port = g_omx_core_new_port (self->gomx, 1);
280 omx_change_state(self, GstOmx_LodedToIdle, NULL, NULL);
282 if (core->omx_state != OMX_StateIdle) {
283 GST_ERROR_OBJECT(self, "fail to move from OMX state Loaded to Idle");
284 g_omx_port_finish(self->in_port);
285 g_omx_port_finish(self->out_port);
286 g_omx_core_stop(core);
287 g_omx_core_unload(core);
288 ret = GST_STATE_CHANGE_FAILURE;
298 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
300 if (ret == GST_STATE_CHANGE_FAILURE)
303 switch (transition) {
304 case GST_STATE_CHANGE_PAUSED_TO_READY:
305 GST_INFO_OBJECT (self, "GST_STATE_CHANGE_PAUSED_TO_READY");
306 g_mutex_lock (self->ready_lock);
308 g_omx_port_finish (self->in_port);
309 g_omx_port_finish (self->out_port);
311 g_omx_core_stop (core);
312 g_omx_core_unload (core);
315 g_mutex_unlock (self->ready_lock);
316 if (core->omx_state != OMX_StateLoaded &&
317 core->omx_state != OMX_StateInvalid) {
318 ret = GST_STATE_CHANGE_FAILURE;
323 case GST_STATE_CHANGE_READY_TO_NULL:
324 GST_INFO_OBJECT (self, "GST_STATE_CHANGE_READY_TO_NULL");
326 gst_adapter_clear(self->adapter);
327 g_object_unref(self->adapter);
328 self->adapter = NULL;
337 GST_LOG_OBJECT (self, "end");
343 finalize (GObject * obj)
345 GstOmxBaseFilter *self;
347 self = GST_OMX_BASE_FILTER (obj);
350 gst_adapter_clear(self->adapter);
351 g_object_unref(self->adapter);
352 self->adapter = NULL;
355 if (self->codec_data) {
356 gst_buffer_unref (self->codec_data);
357 self->codec_data = NULL;
360 g_omx_core_free (self->gomx);
362 g_mutex_free (self->ready_lock);
364 G_OBJECT_CLASS (parent_class)->finalize (obj);
368 set_property (GObject * obj,
369 guint prop_id, const GValue * value, GParamSpec * pspec)
371 GstOmxBaseFilter *self;
373 self = GST_OMX_BASE_FILTER (obj);
376 case ARG_USE_TIMESTAMPS:
377 self->use_timestamps = g_value_get_boolean (value);
379 case ARG_NUM_INPUT_BUFFERS:
380 case ARG_NUM_OUTPUT_BUFFERS:
382 OMX_PARAM_PORTDEFINITIONTYPE param;
383 OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
384 OMX_U32 nBufferCountActual;
385 GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
386 self->in_port : self->out_port;
388 if (G_UNLIKELY (!omx_handle)) {
389 GST_WARNING_OBJECT (self, "no component");
393 nBufferCountActual = g_value_get_uint (value);
395 G_OMX_INIT_PARAM (param);
397 param.nPortIndex = port->port_index;
398 OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
400 if (nBufferCountActual < param.nBufferCountMin) {
401 GST_ERROR_OBJECT (self, "buffer count %lu is less than minimum %lu",
402 nBufferCountActual, param.nBufferCountMin);
406 param.nBufferCountActual = nBufferCountActual;
408 OMX_SetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
412 G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
418 get_property (GObject * obj, guint prop_id, GValue * value, GParamSpec * pspec)
420 GstOmxBaseFilter *self;
422 self = GST_OMX_BASE_FILTER (obj);
424 if (gstomx_get_property_helper (self->gomx, prop_id, value))
428 case ARG_USE_TIMESTAMPS:
429 g_value_set_boolean (value, self->use_timestamps);
431 case ARG_NUM_INPUT_BUFFERS:
432 case ARG_NUM_OUTPUT_BUFFERS:
434 OMX_PARAM_PORTDEFINITIONTYPE param;
435 OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
436 GOmxPort *port = (prop_id == ARG_NUM_INPUT_BUFFERS) ?
437 self->in_port : self->out_port;
439 if (G_UNLIKELY (!omx_handle)) {
440 GST_WARNING_OBJECT (self, "no component");
441 g_value_set_uint (value, 0);
445 G_OMX_INIT_PARAM (param);
447 param.nPortIndex = port->port_index;
448 OMX_GetParameter (omx_handle, OMX_IndexParamPortDefinition, ¶m);
450 g_value_set_uint (value, param.nBufferCountActual);
454 G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, pspec);
460 type_base_init (gpointer g_class)
465 type_class_init (gpointer g_class, gpointer class_data)
467 GObjectClass *gobject_class;
468 GstElementClass *gstelement_class;
470 gobject_class = G_OBJECT_CLASS (g_class);
471 gstelement_class = GST_ELEMENT_CLASS (g_class);
473 gobject_class->finalize = finalize;
474 gstelement_class->change_state = change_state;
476 /* Properties stuff */
478 gobject_class->set_property = set_property;
479 gobject_class->get_property = get_property;
481 gstomx_install_property_helper (gobject_class);
483 g_object_class_install_property (gobject_class, ARG_USE_TIMESTAMPS,
484 g_param_spec_boolean ("use-timestamps", "Use timestamps",
485 "Whether or not to use timestamps",
486 TRUE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
488 g_object_class_install_property (gobject_class, ARG_NUM_INPUT_BUFFERS,
489 g_param_spec_uint ("input-buffers", "Input buffers",
490 "The number of OMX input buffers",
491 1, 10, 4, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
492 g_object_class_install_property (gobject_class, ARG_NUM_OUTPUT_BUFFERS,
493 g_param_spec_uint ("output-buffers", "Output buffers",
494 "The number of OMX output buffers",
495 1, 10, 4, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
500 static inline GstFlowReturn
501 push_buffer (GstOmxBaseFilter * self, GstBuffer * buf, OMX_BUFFERHEADERTYPE * omx_buffer)
503 GstFlowReturn ret = GST_FLOW_OK;
504 GstOmxBaseFilterClass *basefilter_class;
506 basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
507 /* process output gst buffer before gst_pad_push */
508 if (basefilter_class->process_output_buf) {
509 GstOmxReturn ret = GSTOMX_RETURN_OK;
510 ret = basefilter_class->process_output_buf(self, &buf, omx_buffer);
511 if (ret == GSTOMX_RETURN_SKIP) {
512 gst_buffer_unref (buf);
517 /* set average duration for memsink. need to check */
518 GST_BUFFER_DURATION(buf) = self->duration;
520 GST_LOG_OBJECT (self, "OUT_BUFFER: timestamp = %" GST_TIME_FORMAT " size = %lu",
521 GST_TIME_ARGS(GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf));
522 ret = gst_pad_push (self->srcpad, buf);
523 GST_LOG_OBJECT (self, "gst_pad_push end. ret = %d", ret);
530 output_loop (gpointer data)
535 GstOmxBaseFilter *self;
536 GstFlowReturn ret = GST_FLOW_OK;
539 self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
542 GST_LOG_OBJECT (self, "begin");
544 /* do not bother if we have been setup to bail out */
545 if ((ret = g_atomic_int_get (&self->last_pad_push_return)) != GST_FLOW_OK)
549 g_error ("not ready");
553 out_port = self->out_port;
555 if (G_LIKELY (out_port->enabled)) {
556 OMX_BUFFERHEADERTYPE *omx_buffer = NULL;
558 GST_LOG_OBJECT (self, "request buffer");
559 omx_buffer = g_omx_port_request_buffer (out_port);
561 GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
563 if (G_UNLIKELY (!omx_buffer)) {
564 GST_WARNING_OBJECT (self, "null buffer: leaving");
565 ret = GST_FLOW_WRONG_STATE;
569 log_buffer (self, omx_buffer, "output_loop");
571 if (G_LIKELY (omx_buffer->nFilledLen > 0)) {
575 /** @todo remove this check */
576 if (G_LIKELY (self->in_port->enabled)) {
577 GstCaps *caps = NULL;
579 caps = gst_pad_get_negotiated_caps (self->srcpad);
582 /** @todo We shouldn't be doing this. */
583 GST_WARNING_OBJECT (self, "faking settings changed notification");
584 if (gomx->settings_changed_cb)
585 gomx->settings_changed_cb (gomx);
587 GST_LOG_OBJECT (self, "caps already fixed: %" GST_PTR_FORMAT, caps);
588 gst_caps_unref (caps);
593 /* buf is always null when the output buffer pointer isn't shared. */
594 buf = omx_buffer->pAppPrivate;
596 /** @todo we need to move all the caps handling to one single
597 * place, in the output loop probably. */
598 if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG)) {
599 /* modification: to handle both byte-stream and packetized codec_data */
600 GstOmxBaseFilterClass *basefilter_class;
602 basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
603 if (basefilter_class->process_output_caps) {
604 basefilter_class->process_output_caps(self, omx_buffer);
606 /* MODIFICATION: to handle output ST12 HW addr (dec) */
607 } else if (is_extended_color_format(self, self->out_port)) {
608 GstCaps *caps = NULL;
609 GstStructure *structure;
610 gint width = 0, height = 0;
611 SCMN_IMGB *outbuf = NULL;
613 if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_DECODEONLY)) {
614 GST_INFO_OBJECT (self, "Decodeonly flag was set from component");
615 g_omx_port_release_buffer (out_port, omx_buffer);
619 caps = gst_pad_get_negotiated_caps(self->srcpad);
620 structure = gst_caps_get_structure(caps, 0);
622 gst_structure_get_int(structure, "width", &width);
623 gst_structure_get_int(structure, "height", &height);
625 if (G_LIKELY((width > 0) && (height > 0))) {
626 buf = gst_buffer_new_and_alloc(width * height * 3 / 2);
628 GST_ERROR_OBJECT (self, "invalid buffer size");
629 ret = GST_FLOW_UNEXPECTED;
633 outbuf = (SCMN_IMGB*)(omx_buffer->pBuffer);
634 if (outbuf->buf_share_method == 1) {
635 GST_LOG_OBJECT (self, "dec output buf: fd[0]:%d fd[1]:%d fd[2]:%d w[0]:%d h[0]:%d buf_share_method:%d",
636 outbuf->fd[0], outbuf->fd[1], outbuf->fd[2], outbuf->w[0], outbuf->h[0], outbuf->buf_share_method);
637 } else if (outbuf->buf_share_method == 0) {
638 GST_LOG_OBJECT (self, "dec output uses hw addr");
640 GST_WARNING_OBJECT (self, "dec output buf has wrong buf_share_method");
642 memcpy (GST_BUFFER_MALLOCDATA(buf), omx_buffer->pBuffer, omx_buffer->nFilledLen);
644 if (self->use_timestamps) {
645 GST_BUFFER_TIMESTAMP (buf) =
646 gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
647 OMX_TICKS_PER_SECOND);
649 gst_buffer_set_caps(buf, GST_PAD_CAPS(self->srcpad));
650 gst_caps_unref (caps);
652 ret = push_buffer (self, buf, omx_buffer);
653 } else if (buf && !(omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
654 GST_BUFFER_SIZE (buf) = omx_buffer->nFilledLen;
655 if (self->use_timestamps) {
656 GST_BUFFER_TIMESTAMP (buf) =
657 gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
658 OMX_TICKS_PER_SECOND);
661 omx_buffer->pAppPrivate = NULL;
662 omx_buffer->pBuffer = NULL;
664 ret = push_buffer (self, buf, omx_buffer);
667 /* This is only meant for the first OpenMAX buffers,
668 * which need to be pre-allocated. */
669 /* Also for the very last one. */
670 ret = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
671 GST_BUFFER_OFFSET_NONE,
672 omx_buffer->nFilledLen, GST_PAD_CAPS (self->srcpad), &buf);
674 if (G_LIKELY (buf)) {
675 memcpy (GST_BUFFER_DATA (buf),
676 omx_buffer->pBuffer + omx_buffer->nOffset,
677 omx_buffer->nFilledLen);
678 if (self->use_timestamps) {
679 GST_BUFFER_TIMESTAMP (buf) =
680 gst_util_uint64_scale_int (omx_buffer->nTimeStamp, GST_SECOND,
681 OMX_TICKS_PER_SECOND);
684 if (self->out_port->shared_buffer) {
685 GST_WARNING_OBJECT (self, "couldn't zero-copy");
686 /* If pAppPrivate is NULL, it means it was a dummy
687 * allocation, free it. */
688 if (!omx_buffer->pAppPrivate) {
689 g_free (omx_buffer->pBuffer);
690 omx_buffer->pBuffer = NULL;
694 ret = push_buffer (self, buf, omx_buffer);
696 GST_WARNING_OBJECT (self, "couldn't allocate buffer of size %lu",
697 omx_buffer->nFilledLen);
701 GST_WARNING_OBJECT (self, "empty buffer");
704 if (self->out_port->shared_buffer &&
705 !omx_buffer->pBuffer && omx_buffer->nOffset == 0) {
707 GstFlowReturn result;
709 GST_LOG_OBJECT (self, "allocate buffer");
710 result = gst_pad_alloc_buffer_and_set_caps (self->srcpad,
711 GST_BUFFER_OFFSET_NONE,
712 omx_buffer->nAllocLen, GST_PAD_CAPS (self->srcpad), &buf);
714 if (G_LIKELY (result == GST_FLOW_OK)) {
715 omx_buffer->pAppPrivate = buf;
717 omx_buffer->pBuffer = GST_BUFFER_DATA (buf);
718 omx_buffer->nAllocLen = GST_BUFFER_SIZE (buf);
720 GST_WARNING_OBJECT (self,
721 "could not pad allocate buffer, using malloc");
722 omx_buffer->pBuffer = g_malloc (omx_buffer->nAllocLen);
726 if (self->out_port->shared_buffer && !omx_buffer->pBuffer) {
727 GST_ERROR_OBJECT (self, "no input buffer to share");
730 if (G_UNLIKELY (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
731 GST_DEBUG_OBJECT (self, "got eos");
732 gst_pad_push_event (self->srcpad, gst_event_new_eos ());
733 omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
734 ret = GST_FLOW_UNEXPECTED;
737 omx_buffer->nFilledLen = 0;
738 GST_LOG_OBJECT (self, "release_buffer");
739 g_omx_port_release_buffer (out_port, omx_buffer);
744 self->last_pad_push_return = ret;
746 if (gomx->omx_error != OMX_ErrorNone)
747 ret = GST_FLOW_ERROR;
749 if (ret != GST_FLOW_OK) {
750 GST_INFO_OBJECT (self, "pause task, reason: %s", gst_flow_get_name (ret));
751 gst_pad_pause_task (self->srcpad);
754 GST_LOG_OBJECT (self, "end");
756 gst_object_unref (self);
760 pad_chain (GstPad * pad, GstBuffer * buf)
764 GstOmxBaseFilter *self;
765 GstOmxBaseFilterClass *basefilter_class;
766 GstFlowReturn ret = GST_FLOW_OK;
767 GstBuffer *adapter_buf = NULL;
769 self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
773 GST_LOG_OBJECT (self, "IN_BUFFER: timestamp = %" GST_TIME_FORMAT " size = %lu, state:%d",
774 GST_TIME_ARGS(GST_BUFFER_TIMESTAMP (buf)), GST_BUFFER_SIZE (buf), gomx->omx_state);
777 if (!self->use_state_tuning) {
778 if (G_UNLIKELY (gomx->omx_state == OMX_StateLoaded))
779 omx_change_state(self, GstOmx_LodedToIdle, NULL, NULL);
782 in_port = self->in_port;
784 if (G_LIKELY (in_port->enabled)) {
785 guint buffer_offset = 0;
786 guint8 *src_data = NULL;
788 GstClockTime src_timestamp = 0;
789 GstClockTime src_duration = 0;
791 if (G_UNLIKELY (gomx->omx_state == OMX_StateIdle))
792 omx_change_state(self, GstOmx_IdleToExcuting,in_port, buf);
794 if (G_UNLIKELY (gomx->omx_state != OMX_StateExecuting)) {
795 GST_ERROR_OBJECT (self, "Whoa! very wrong");
798 basefilter_class = GST_OMX_BASE_FILTER_GET_CLASS (self);
799 /* process input gst buffer before OMX_EmptyThisBuffer */
800 if (basefilter_class->process_input_buf)
802 GstOmxReturn ret = GSTOMX_RETURN_OK;
803 ret = basefilter_class->process_input_buf(self,&buf);
804 if (ret == GSTOMX_RETURN_SKIP) {
805 gst_buffer_unref(buf);
810 if (self->adapter_size > 0) {
811 if (!self->adapter) {
812 GST_WARNING_OBJECT (self, "adapter is NULL. retry gst_adapter_new");
813 self->adapter = gst_adapter_new();
816 if (GST_BUFFER_IS_DISCONT(buf))
818 GST_INFO_OBJECT (self, "got GST_BUFFER_IS_DISCONT.");
819 gst_adapter_clear(self->adapter);
822 gst_adapter_push(self->adapter, buf);
824 src_size = gst_adapter_available(self->adapter);
825 if (src_size < self->adapter_size) {
826 GST_LOG_OBJECT (self, "Not enough data in adapter to feed to decoder.");
830 if (src_size > self->adapter_size) {
831 src_size = src_size - GST_BUFFER_SIZE(buf);
832 GST_LOG_OBJECT (self, "take buffer from adapter. size=%d", src_size);
835 src_timestamp = gst_adapter_prev_timestamp(self->adapter, NULL);
836 adapter_buf = gst_adapter_take_buffer(self->adapter, src_size);
837 src_data = GST_BUFFER_DATA(adapter_buf);
838 src_duration = GST_BUFFER_TIMESTAMP (buf) - src_timestamp;
840 src_data = GST_BUFFER_DATA (buf);
841 src_size = GST_BUFFER_SIZE (buf);
842 src_timestamp = GST_BUFFER_TIMESTAMP (buf);
843 src_duration = GST_BUFFER_DURATION (buf);
846 while (G_LIKELY (buffer_offset < src_size)) {
847 OMX_BUFFERHEADERTYPE *omx_buffer;
849 if (self->last_pad_push_return != GST_FLOW_OK ||
850 !(gomx->omx_state == OMX_StateExecuting ||
851 gomx->omx_state == OMX_StatePause)) {
855 GST_LOG_OBJECT (self, "request buffer");
856 omx_buffer = g_omx_port_request_buffer (in_port);
858 GST_LOG_OBJECT (self, "omx_buffer: %p", omx_buffer);
860 if (G_LIKELY (omx_buffer)) {
861 log_buffer (self, omx_buffer, "pad_chain");
863 /* MODIFICATION: to handle input SN12 HW addr. (enc) */
864 if (is_extended_color_format(self, self->in_port)) {
865 SCMN_IMGB *inbuf = NULL;
867 if (!GST_BUFFER_MALLOCDATA(buf)) {
868 GST_WARNING_OBJECT (self, "null MALLOCDATA in hw color format. skip this.");
872 inbuf = (SCMN_IMGB*)(GST_BUFFER_MALLOCDATA(buf));
873 if (inbuf != NULL && inbuf->buf_share_method == 1) {
874 GST_LOG_OBJECT (self, "enc. fd[0]:%d fd[1]:%d fd[2]:%d w[0]:%d h[0]:%d buf_share_method:%d",
875 inbuf->fd[0], inbuf->fd[1], inbuf->fd[2], inbuf->w[0], inbuf->h[0], inbuf->buf_share_method);
876 } else if (inbuf != NULL && inbuf->buf_share_method == 0) {
877 GST_LOG_OBJECT (self, "enc input buf uses hw addr");
879 GST_WARNING_OBJECT (self, "enc input buf has wrong buf_share_method");
882 memcpy (omx_buffer->pBuffer, GST_BUFFER_MALLOCDATA(buf), sizeof(SCMN_IMGB));
883 omx_buffer->nAllocLen = sizeof(SCMN_IMGB);
884 omx_buffer->nFilledLen = sizeof(SCMN_IMGB);
885 } else if (omx_buffer->nOffset == 0 && self->in_port->shared_buffer) {
888 old_buf = omx_buffer->pAppPrivate;
891 gst_buffer_unref ((GstBuffer *)old_buf);
892 } else if (omx_buffer->pBuffer) {
893 g_free (omx_buffer->pBuffer);
894 omx_buffer->pBuffer = NULL;
898 omx_buffer->pBuffer = src_data;
899 omx_buffer->nAllocLen = src_size;
900 omx_buffer->nFilledLen = src_size;
901 omx_buffer->pAppPrivate = (self->adapter_size > 0) ? (OMX_PTR)adapter_buf : (OMX_PTR)buf;
903 omx_buffer->nFilledLen = MIN (src_size - buffer_offset,
904 omx_buffer->nAllocLen - omx_buffer->nOffset);
905 memcpy (omx_buffer->pBuffer + omx_buffer->nOffset,
906 src_data + buffer_offset, omx_buffer->nFilledLen);
909 if (self->use_timestamps) {
910 GstClockTime timestamp_offset = 0;
912 if (buffer_offset && src_duration != GST_CLOCK_TIME_NONE) {
913 timestamp_offset = gst_util_uint64_scale_int (buffer_offset,
914 src_duration, src_size);
917 omx_buffer->nTimeStamp =
918 gst_util_uint64_scale_int (src_timestamp +
919 timestamp_offset, OMX_TICKS_PER_SECOND, GST_SECOND);
922 /* MODIFICATION: hw addr */
923 if (is_extended_color_format(self, self->in_port)) {
924 buffer_offset = GST_BUFFER_SIZE (buf);
926 buffer_offset += omx_buffer->nFilledLen;
929 GST_LOG_OBJECT (self, "release_buffer");
930 /** @todo untaint buffer */
931 g_omx_port_release_buffer (in_port, omx_buffer);
933 GST_WARNING_OBJECT (self, "null buffer");
934 ret = GST_FLOW_WRONG_STATE;
939 GST_WARNING_OBJECT (self, "done");
940 ret = GST_FLOW_UNEXPECTED;
943 if (!self->in_port->shared_buffer) {
944 if (self->adapter_size > 0 && adapter_buf) {
945 gst_buffer_unref (adapter_buf);
948 gst_buffer_unref (buf);
954 GST_LOG_OBJECT (self, "end");
958 /* special conditions */
961 const gchar *error_msg = NULL;
963 GST_LOG_OBJECT(self, "out_flushing");
965 if (gomx->omx_error) {
966 error_msg = "Error from OpenMAX component";
967 } else if (gomx->omx_state != OMX_StateExecuting &&
968 gomx->omx_state != OMX_StatePause) {
969 error_msg = "OpenMAX component in wrong state";
973 GST_ELEMENT_ERROR (self, STREAM, FAILED, (NULL), ("%s", error_msg));
974 ret = GST_FLOW_ERROR;
977 if (self->adapter_size > 0 && adapter_buf) {
978 gst_buffer_unref (adapter_buf);
981 gst_buffer_unref (buf);
989 pad_event (GstPad * pad, GstEvent * event)
991 GstOmxBaseFilter *self;
996 self = GST_OMX_BASE_FILTER (GST_OBJECT_PARENT (pad));
998 in_port = self->in_port;
1000 GST_LOG_OBJECT (self, "begin");
1002 GST_INFO_OBJECT (self, "event: %s", GST_EVENT_TYPE_NAME (event));
1004 if (self->pad_event) {
1005 if (!self->pad_event(pad, event))
1009 switch (GST_EVENT_TYPE (event)) {
1011 /* if we are init'ed, and there is a running loop; then
1012 * if we get a buffer to inform it of EOS, let it handle the rest
1013 * in any other case, we send EOS */
1014 if (self->ready && self->last_pad_push_return == GST_FLOW_OK) {
1015 /* send buffer with eos flag */
1016 /** @todo move to util */
1018 OMX_BUFFERHEADERTYPE *omx_buffer;
1020 GST_LOG_OBJECT (self, "request buffer");
1021 omx_buffer = g_omx_port_request_buffer (in_port);
1023 if (G_LIKELY (omx_buffer)) {
1025 if (self->adapter_size > 0 && self->adapter) {
1027 GstBuffer *adapter_buf = NULL;
1029 src_len = gst_adapter_available(self->adapter);
1030 if (src_len > 0 && src_len < self->adapter_size) {
1031 omx_buffer->nTimeStamp = gst_util_uint64_scale_int(
1032 gst_adapter_prev_timestamp(self->adapter, NULL),
1033 OMX_TICKS_PER_SECOND, GST_SECOND);
1034 adapter_buf = gst_adapter_take_buffer(self->adapter, src_len);
1035 omx_buffer->pBuffer = GST_BUFFER_DATA(adapter_buf);
1036 omx_buffer->nAllocLen = src_len;
1037 omx_buffer->nFilledLen = src_len;
1038 omx_buffer->pAppPrivate = adapter_buf;
1040 gst_adapter_clear(self->adapter);
1042 omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
1044 GST_LOG_OBJECT (self, "release_buffer in EOS. size=%d", omx_buffer->nFilledLen);
1045 /* foo_buffer_untaint (omx_buffer); */
1046 g_omx_port_release_buffer (in_port, omx_buffer);
1047 /* loop handles EOS, eat it here */
1048 gst_event_unref (event);
1054 /* we tried, but it's up to us here */
1055 ret = gst_pad_push_event (self->srcpad, event);
1058 case GST_EVENT_FLUSH_START:
1059 if (gomx->omx_state == OMX_StatePause || gomx->omx_state == OMX_StateExecuting) {
1060 gst_pad_push_event (self->srcpad, event);
1061 self->last_pad_push_return = GST_FLOW_WRONG_STATE;
1063 g_omx_core_flush_start (gomx);
1065 gst_pad_pause_task (self->srcpad);
1069 GST_ERROR_OBJECT (self, "flush start in wrong omx state");
1074 case GST_EVENT_FLUSH_STOP:
1075 if (gomx->omx_state == OMX_StatePause || gomx->omx_state == OMX_StateExecuting) {
1076 gst_pad_push_event (self->srcpad, event);
1077 self->last_pad_push_return = GST_FLOW_OK;
1079 g_omx_core_flush_stop (gomx);
1081 if (self->adapter_size > 0 && self->adapter) {
1082 gst_adapter_clear(self->adapter);
1086 gst_pad_start_task (self->srcpad, output_loop, self->srcpad);
1090 GST_ERROR_OBJECT (self, "flush start in wrong omx state");
1095 case GST_EVENT_NEWSEGMENT:
1096 ret = gst_pad_push_event (self->srcpad, event);
1100 ret = gst_pad_push_event (self->srcpad, event);
1104 GST_LOG_OBJECT (self, "end");
1110 activate_push (GstPad * pad, gboolean active)
1112 gboolean result = TRUE;
1113 GstOmxBaseFilter *self;
1115 self = GST_OMX_BASE_FILTER (gst_pad_get_parent (pad));
1118 GST_DEBUG_OBJECT (self, "activate");
1119 /* task may carry on */
1120 g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_OK);
1122 /* we do not start the task yet if the pad is not connected */
1123 if (gst_pad_is_linked (pad)) {
1125 /** @todo link callback function also needed */
1126 g_omx_port_resume (self->in_port);
1127 g_omx_port_resume (self->out_port);
1129 result = gst_pad_start_task (pad, output_loop, pad);
1133 GST_DEBUG_OBJECT (self, "deactivate");
1135 /* persuade task to bail out */
1136 g_atomic_int_set (&self->last_pad_push_return, GST_FLOW_WRONG_STATE);
1139 /** @todo disable this until we properly reinitialize the buffers. */
1141 /* flush all buffers */
1142 OMX_SendCommand (self->gomx->omx_handle, OMX_CommandFlush, OMX_ALL, NULL);
1146 g_omx_port_pause (self->in_port);
1147 g_omx_port_pause (self->out_port);
1150 /* make sure streaming finishes */
1151 result = gst_pad_stop_task (pad);
1154 gst_object_unref (self);
1160 type_instance_init (GTypeInstance * instance, gpointer g_class)
1162 GstOmxBaseFilter *self;
1163 GstElementClass *element_class;
1165 element_class = GST_ELEMENT_CLASS (g_class);
1167 self = GST_OMX_BASE_FILTER (instance);
1169 GST_LOG_OBJECT (self, "begin");
1171 self->use_timestamps = TRUE;
1172 self->use_state_tuning = FALSE;
1173 self->adapter_size = 0;
1174 self->adapter = NULL;
1177 self->gomx = gstomx_core_new (self, G_TYPE_FROM_CLASS (g_class));
1178 self->in_port = g_omx_core_new_port (self->gomx, 0);
1179 self->out_port = g_omx_core_new_port (self->gomx, 1);
1181 self->ready_lock = g_mutex_new ();
1184 gst_pad_new_from_template (gst_element_class_get_pad_template
1185 (element_class, "sink"), "sink");
1187 gst_pad_set_chain_function (self->sinkpad, pad_chain);
1188 gst_pad_set_event_function (self->sinkpad, pad_event);
1191 gst_pad_new_from_template (gst_element_class_get_pad_template
1192 (element_class, "src"), "src");
1194 gst_pad_set_activatepush_function (self->srcpad, activate_push);
1196 gst_pad_use_fixed_caps (self->srcpad);
1198 gst_element_add_pad (GST_ELEMENT (self), self->sinkpad);
1199 gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
1201 GST_LOG_OBJECT (self, "end");
1205 omx_interface_init (GstImplementsInterfaceClass * klass)
1210 interface_supported (GstImplementsInterface * iface, GType type)
1212 g_assert (type == GST_TYPE_OMX);
1217 interface_init (GstImplementsInterfaceClass * klass)
1219 klass->supported = interface_supported;
1223 init_interfaces (GType type)
1225 GInterfaceInfo *iface_info;
1226 GInterfaceInfo *omx_info;
1229 iface_info = g_new0 (GInterfaceInfo, 1);
1230 iface_info->interface_init = (GInterfaceInitFunc) interface_init;
1232 g_type_add_interface_static (type, GST_TYPE_IMPLEMENTS_INTERFACE, iface_info);
1233 g_free (iface_info);
1235 omx_info = g_new0 (GInterfaceInfo, 1);
1236 omx_info->interface_init = (GInterfaceInitFunc) omx_interface_init;
1238 g_type_add_interface_static (type, GST_TYPE_OMX, omx_info);