/** * goo_engine_play: * @self: An #GooEngine instance * * Interchange buffers **/ void goo_engine_play (GooEngine* self) { g_assert (GOO_IS_ENGINE (self)); g_assert (GOO_IS_COMPONENT (self->component)); g_assert (self->component->cur_state == OMX_StateExecuting); GOO_OBJECT_DEBUG (self, "playing"); if (self->enginetype == GOO_ENGINE_FILTER) { /* a filter must has an input and an output port */ g_assert (self->outstream != NULL && self->instream != NULL); } else if (self->enginetype == GOO_ENGINE_SINK) { /* a sink must has an input port */ g_assert (self->instream != NULL); // g_assert (self->outstream == NULL && self->instream != NULL); } else if (self->enginetype == GOO_ENGINE_SRC) { /* a src must has an output port */ g_assert (self->outstream != NULL); // g_assert (self->outstream != NULL && self->instream == NULL); } else { g_assert (self->enginetype != GOO_ENGINE_UNKNOWN); } if (self->enginetype == GOO_ENGINE_SINK || self->enginetype == GOO_ENGINE_FILTER) { GOO_OBJECT_INFO (self, "inport loop"); while (!goo_port_is_eos (self->inport)) { goo_engine_process_input (self); } } else if (self->enginetype == GOO_ENGINE_SRC) { GOO_OBJECT_INFO (self, "outport loop"); while (!goo_port_is_eos (self->outport)) { goo_engine_process_output (self); } } GOO_OBJECT_INFO (self, "Waiting for done..."); goo_component_wait_for_done (self->component); g_print ("\tInput buffers count: %d\n", self->incount); g_print ("\tOutput buffers count: %d\n", self->outcount); return; }
static void goo_engine_chain (GooEngine* self) { g_assert (GOO_IS_ENGINE (self)); g_assert (GOO_IS_COMPONENT (self->component)); gboolean input_processed = FALSE; OMX_BUFFERHEADERTYPE* buffer = NULL; while (!input_processed && !goo_component_is_done (self->component)) { /* OUTPUT PROCESSING */ if (G_LIKELY (self->outport) && !goo_port_is_tunneled (self->outport) && !goo_port_is_eos (self->outport)) { while ((buffer = goo_port_try_grab_buffer (self->outport)) != NULL) { GOO_OBJECT_DEBUG (self, "popt output buffer: 0x%x", buffer); goo_port_process_buffer (self->outport, buffer, self->component); goo_component_release_buffer (self->component, buffer); } } /* INPUT PROCESSING */ if (G_LIKELY (self->inport) && !goo_port_is_tunneled (self->inport) && !goo_port_is_eos (self->inport)) { if ((buffer = goo_port_try_grab_buffer (self->inport)) != NULL) { GOO_OBJECT_DEBUG (self, "popt input buffer: 0x%x", buffer); goo_port_process_buffer (self->inport, buffer, self); goo_component_release_buffer (self->component, buffer); input_processed = TRUE; } } } return; }
static void omx_output_buffer_cb (GooPort* port, OMX_BUFFERHEADERTYPE* buffer, gpointer data) { g_return_if_fail (buffer->nFlags != OMX_BUFFERFLAG_DATACORRUPT); g_assert (GOO_IS_PORT (port)); g_assert (buffer != NULL); g_assert (GOO_IS_COMPONENT (data)); GooComponent* component = GOO_COMPONENT (data); GstGooEncPcm* self = GST_GOO_ENCPCM ( g_object_get_data (G_OBJECT (data), "gst") ); g_assert (self != NULL); { process_output_buffer (self, buffer); if (buffer->nFlags == OMX_BUFFERFLAG_EOS || goo_port_is_eos (port)) { GST_INFO_OBJECT (self, "EOS found in output buffer (%d)", buffer->nFilledLen); goo_component_set_done (self->component); } } GST_INFO_OBJECT (self, ""); return; }
static void goo_engine_process_input (GooEngine* self) { g_assert (GOO_IS_ENGINE (self)); g_assert (GOO_IS_COMPONENT (self->component)); g_return_if_fail (G_LIKELY (self->inport)); if (goo_port_is_tunneled (self->inport) || goo_port_is_eos (self->inport)) { return; } OMX_BUFFERHEADERTYPE* buffer = NULL; buffer = goo_port_grab_buffer (self->inport); GOO_OBJECT_DEBUG (self, "popt input buffer: 0x%x", buffer); goo_engine_inport_cb (self->inport, buffer, self->component); /* goo_port_process_buffer (self->inport, buffer, self); */ g_atomic_int_inc (&self->incount); goo_component_release_buffer (self->component, buffer); return; }
static void goo_engine_outport_cb (GooPort* port, OMX_BUFFERHEADERTYPE* buffer, gpointer data) { g_assert (GOO_IS_PORT (port)); g_assert (buffer != NULL); g_assert (GOO_IS_COMPONENT (data)); GooComponent* component = GOO_COMPONENT (data); GooEngine* self = GOO_ENGINE ( g_object_get_data (G_OBJECT (component), "engine") ); g_assert (self->outstream != NULL); if (buffer->nFilledLen <= 0 && (buffer->nFlags & OMX_BUFFERFLAG_EOS) != 0x1) { GOO_OBJECT_ERROR (self, "Empty buffer received!!"); } if (buffer->nFilledLen > 0) { GOO_OBJECT_DEBUG (self, "%d bytes written", buffer->nFilledLen); fwrite (buffer->pBuffer, 1, buffer->nFilledLen, self->outstream); /* fflush (self->outfile); */ } /* we count the empty buffer only if it have de EOS flag */ if ((buffer->nFilledLen > 0) || ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == 0x1 && buffer->nFilledLen == 0)) { g_atomic_int_inc (&self->outcount); } /* if we assigned the number of buffer to process */ if (self->numbuffers != 0 && self->outcount == self->numbuffers) { goo_port_set_eos (port); } if ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == 0x1 || goo_port_is_eos (port)) { goo_component_set_done (self->component); } goo_component_release_buffer (component, buffer); return; }
/** * gst_goo_filter_outport_buffer: * @port: A #GooPort instance * @buffer: An #OMX_BUFFERHEADERTYPE pointer * @data: A pointer to extra data * * This function is a generic callback for a libgoo's output port and push * a new GStreamer's buffer. * * This method can be reused in derived classes. **/ void gst_goo_filter_outport_buffer (GooPort* port, OMX_BUFFERHEADERTYPE* buffer, gpointer data) { g_return_if_fail (buffer->nFlags != OMX_BUFFERFLAG_DATACORRUPT); GST_DEBUG ("Enter"); g_assert (GOO_IS_PORT (port)); g_assert (buffer != NULL); g_assert (GOO_IS_COMPONENT (data)); GooComponent* component = GOO_COMPONENT (data); GstGooFilter* self = GST_GOO_FILTER (g_object_get_data (G_OBJECT (data), "gst")); g_assert (self != NULL); GstGooFilterPrivate* priv = GST_GOO_FILTER_GET_PRIVATE (self); GstBuffer* gst_buffer = gst_goo_buffer_new (); gst_goo_buffer_set_data (gst_buffer, component, buffer); priv->outcount++; #if 0 if (goo_port_is_tunneled (self->inport)) { GST_DEBUG_OBJECT (self, "sem up"); gst_goo_sem_up (self->dasfsrc_sem); } #endif /** FIXME GStreamer should not insert the header. OMX component should take * care of it. Remove this function upon resolution of DR OMAPS00140835 and * OMAPS00140836 **/ gst_buffer = gst_goo_filter_insert_header (self, gst_buffer, priv->outcount); gst_goo_filter_timestamp_buffer (self, gst_buffer, buffer); GST_BUFFER_OFFSET (gst_buffer) = priv->outcount; gst_buffer_set_caps (gst_buffer, GST_PAD_CAPS (self->srcpad)); gst_pad_push (self->srcpad, gst_buffer); if (buffer->nFlags == OMX_BUFFERFLAG_EOS || goo_port_is_eos (port) || gst_goo_filter_is_last_dasf_buffer (self, priv->outcount)) { GST_INFO ("EOS flag found in output buffer (%d)", buffer->nFilledLen); goo_component_set_done (self->component); } return; }
/* output */ { GooIterator* iter = goo_component_iterate_output_ports (component); goo_iterator_nth (iter, 0); GooPort* port = GOO_PORT (goo_iterator_get_current (iter)); g_assert (port != NULL); GOO_PORT_GET_DEFINITION (port)->nBufferSize = OUTPUT_BUFFERSIZE; GOO_PORT_GET_DEFINITION (port)->nBufferCountActual = OUTPUT_NUM_BUFFERS; GOO_PORT_GET_DEFINITION (port)->format.audio.eEncoding = OMX_AUDIO_CodingPCM; g_object_unref (iter); g_object_unref (port); } return; } #if 0 /* i think it is not necessary now */ static void goo_ti_mp3dec_release_buffer (GooComponent* self, OMX_BUFFERHEADERTYPE* buffer) { g_assert (GOO_IS_COMPONENT (self)); g_assert (buffer != NULL); g_assert (self->cur_state == OMX_StateExecuting || self->cur_state == OMX_StateIdle); GooPort* port = GOO_PORT (g_object_ref (buffer->pAppPrivate)); if (goo_port_is_eos (port) || goo_port_is_tunneled (port)) { g_object_unref (port); return; } if ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == 0x1) { GOO_OBJECT_INFO (port, "eos found!"); goo_port_set_eos (port); } /* We should always push the EOS buffer */ GOO_OBJECT_NOTICE (self, "OMX_EmptyThisBuffer, 0x%x", buffer); if (self->cur_state != OMX_StateIdle) { GOO_OBJECT_LOCK (self); GOO_RUN ( OMX_EmptyThisBuffer (self->handle, buffer) ); GOO_OBJECT_UNLOCK (self); } else { g_print("INFORMATION (workaround): Implementing workaround " "for DR OMAPS00143083\n"); } g_object_unref (port); GOO_OBJECT_DEBUG (self, ""); return; }
static void omx_output_buffer_cb (GooPort* port, OMX_BUFFERHEADERTYPE* buffer, gpointer data) { g_return_if_fail (buffer->nFlags != OMX_BUFFERFLAG_DATACORRUPT); g_assert (GOO_IS_PORT (port)); g_assert (buffer != NULL); g_assert (GOO_IS_COMPONENT (data)); GooComponent* component = GOO_COMPONENT (data); GstGooEncArmAac* self = GST_GOO_ENCARMAAC ( g_object_get_data (G_OBJECT (data), "gst") ); g_assert (self != NULL); { if (buffer->nFilledLen <= 0) { GST_INFO_OBJECT (self, "Received an empty buffer!"); goo_component_release_buffer (self->component, buffer); } else { process_output_buffer (self, buffer); } if (buffer->nFlags & OMX_BUFFERFLAG_EOS == 0x1 || goo_port_is_eos (port)) { GST_INFO_OBJECT (self, "EOS found in output buffer (%d)", buffer->nFilledLen); goo_component_set_done (self->component); } } GST_DEBUG_OBJECT (self, ""); return; }
static GstFlowReturn gst_goo_filter_chain (GstPad* pad, GstBuffer* buffer) { GST_LOG (""); GstGooFilter* self = GST_GOO_FILTER (gst_pad_get_parent (pad)); GstGooFilterPrivate* priv = GST_GOO_FILTER_GET_PRIVATE (self); GstGooAdapter* adapter = self->adapter; GstFlowReturn ret = GST_FLOW_OK; static OMX_S64 omx_normalize_timestamp; GstClockTime timestamp = GST_BUFFER_TIMESTAMP (buffer); if (priv->incount == 0) { omx_normalize_timestamp = (gint64)timestamp / CONVERSION; } if (goo_port_is_tunneled (self->inport)) { /* shall we send a ghost buffer here ? */ GST_INFO ("port is tunneled"); ret = GST_FLOW_OK; GST_DEBUG_OBJECT (self, "Buffer timestamp: time %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buffer))); GST_DEBUG_OBJECT (self, "Buffer duration: %" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DURATION (buffer))); GST_DEBUG_OBJECT (self, "Pushing buffer to next element. Size =%d", GST_BUFFER_SIZE (buffer)); /** FIXME GStreamer should not insert the header. OMX component should take * care of it. Remove this function upon resolution of DR OMAPS00140835 and * OMAPS00140836 **/ priv->outcount++; buffer = gst_goo_filter_insert_header (self, buffer, priv->outcount); gst_buffer_set_caps (buffer, GST_PAD_CAPS (self->srcpad)); gst_pad_push (self->srcpad, buffer); goto done; } if (goo_port_is_eos (self->inport)) { GST_INFO ("port is eos"); ret = GST_FLOW_UNEXPECTED; goto fail; } /** @todo GstGooAdapter! */ if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { gst_goo_adapter_clear (adapter); } if (priv->incount == 0 && goo_component_get_state (self->component) == OMX_StateLoaded) { /** Some filters require header processing, apended to the first buffer **/ buffer = gst_goo_filter_codec_data_processing (self, GST_BUFFER (buffer)); /** Todo: Use the gst_caps_fixatecaps_func to make this cleaner **/ if (!gst_goo_filter_check_fixed_src_caps (self)) return GST_FLOW_NOT_NEGOTIATED; /** Remove gst_goo_filter_check_fixed_src_caps function when fixed **/ g_object_set (self->inport, "buffercount", priv->num_input_buffers, NULL); g_object_set (self->outport, "buffercount", priv->num_output_buffers, NULL); GST_INFO ("going to idle"); goo_component_set_state_idle (self->component); GST_INFO ("going to executing"); goo_component_set_state_executing (self->component); } /** Function to perform post buffering processing **/ buffer = gst_goo_filter_extra_buffer_processing (self, GST_BUFFER (buffer)); gst_goo_adapter_push (adapter, buffer); if (self->component->cur_state != OMX_StateExecuting) { goto done; } int omxbufsiz; if (priv->process_mode == STREAMMODE) omxbufsiz = GOO_PORT_GET_DEFINITION (self->inport)->nBufferSize; else omxbufsiz = GST_BUFFER_SIZE (buffer); while (gst_goo_adapter_available (adapter) >= omxbufsiz && ret == GST_FLOW_OK && omxbufsiz != 0) { GST_DEBUG ("Adapter available =%d omxbufsiz = %d", gst_goo_adapter_available (adapter), omxbufsiz); OMX_BUFFERHEADERTYPE* omx_buffer; omx_buffer = goo_port_grab_buffer (self->inport); GST_DEBUG ("memcpy to buffer %d bytes", omxbufsiz); gst_goo_adapter_peek (adapter, omxbufsiz, omx_buffer); omx_buffer->nFilledLen = omxbufsiz; gst_goo_adapter_flush (adapter, omxbufsiz); /* transfer timestamp to openmax */ { GST_DEBUG_OBJECT (self, "checking timestamp: time %" GST_TIME_FORMAT, GST_TIME_ARGS (timestamp)); if (GST_CLOCK_TIME_IS_VALID (timestamp)) { gint64 buffer_ts = (gint64)timestamp; omx_buffer->nTimeStamp = (OMX_S64)buffer_ts / CONVERSION; omx_buffer->nTimeStamp = omx_buffer->nTimeStamp - omx_normalize_timestamp; } else GST_WARNING_OBJECT (self, "Invalid timestamp!"); } priv->incount++; goo_component_release_buffer (self->component, omx_buffer); ret = GST_FLOW_OK; } if (goo_port_is_tunneled (self->outport)) { /** @todo send a ghost buffer */ GstBuffer *ghost_buffer = (GstBuffer*) gst_ghost_buffer_new (); GST_BUFFER_TIMESTAMP (ghost_buffer) = timestamp; gst_pad_push (self->srcpad, ghost_buffer); } goto done; fail: gst_goo_adapter_clear (adapter); done: gst_object_unref (self); gst_buffer_unref (buffer); return ret; }
static GstFlowReturn gst_goo_encjpeg_chain (GstPad* pad, GstBuffer* buffer) { GST_LOG (""); GstGooEncJpeg* self = GST_GOO_ENCJPEG (gst_pad_get_parent (pad)); GstGooEncJpegPrivate* priv = GST_GOO_ENCJPEG_GET_PRIVATE (self); GstFlowReturn ret = GST_FLOW_OK; GstGooAdapter* adapter = self->adapter; OMX_BUFFERHEADERTYPE* omx_buffer = NULL; GstClockTime timestamp, duration; guint64 offset, offsetend; GstBuffer* outbuf = NULL; if (goo_port_is_tunneled (self->inport)) { GST_INFO ("Inport is tunneled"); ret = GST_FLOW_OK; priv->incount++; goto process_output; } if (goo_port_is_eos (self->inport)) { GST_INFO ("port is eos"); ret = GST_FLOW_UNEXPECTED; goto fail; } if (self->component->cur_state != OMX_StateExecuting) { goto fail; } /* let's copy the timestamp meta data */ timestamp = GST_BUFFER_TIMESTAMP (buffer); duration = GST_BUFFER_DURATION (buffer); offset = GST_BUFFER_OFFSET (buffer); offsetend = GST_BUFFER_OFFSET_END (buffer); if (GST_IS_GOO_BUFFER (buffer) && goo_port_is_my_buffer (self->inport, GST_GOO_BUFFER (buffer)->omx_buffer)) { GST_INFO ("My own OMX buffer"); priv->incount++; gst_buffer_unref (buffer); /* let's push the buffer to omx */ ret = GST_FLOW_OK; } else if (GST_IS_GOO_BUFFER (buffer) && !goo_port_is_my_buffer (self->inport, GST_GOO_BUFFER (buffer)->omx_buffer)) { GST_INFO ("Other OMX buffer"); if (GST_BUFFER_SIZE (buffer) != priv->omxbufsiz) { GST_ELEMENT_ERROR (self, STREAM, FORMAT, ("Frame is incomplete (%u!=%u)", GST_BUFFER_SIZE (buffer), priv->omxbufsiz), ("Frame is incomplete (%u!=%u)", GST_BUFFER_SIZE (buffer), priv->omxbufsiz)); ret = GST_FLOW_ERROR; } omx_buffer = goo_port_grab_buffer (self->inport); memcpy (omx_buffer->pBuffer, GST_BUFFER_DATA (buffer), priv->omxbufsiz); omx_buffer->nFilledLen = priv->omxbufsiz; priv->incount++; goo_component_release_buffer (self->component, omx_buffer); gst_buffer_unref (buffer); ret = GST_FLOW_OK; } else { if (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT)) { gst_goo_adapter_clear (adapter); } GST_LOG ("size = %d bytes", GST_BUFFER_SIZE (buffer)); gst_goo_adapter_push (adapter, buffer); guint tmp = priv->incount; while (gst_goo_adapter_available (adapter) >= priv->omxbufsiz && ret == GST_FLOW_OK) { GST_DEBUG ("Pushing data to OMX"); OMX_BUFFERHEADERTYPE* omx_buffer; omx_buffer = goo_port_grab_buffer (self->inport); gst_goo_adapter_peek (adapter, priv->omxbufsiz, omx_buffer); omx_buffer->nFilledLen = priv->omxbufsiz; gst_goo_adapter_flush (adapter, priv->omxbufsiz); priv->incount++; goo_component_release_buffer (self->component, omx_buffer); ret = GST_FLOW_OK; } if (tmp == priv->incount) { goto done; } } process_output: if (goo_port_is_tunneled (self->outport)) { outbuf = gst_ghost_buffer_new (); GST_BUFFER_FLAG_SET (outbuf, GST_BUFFER_FLAG_READONLY); GST_BUFFER_DATA (outbuf) = NULL; GST_BUFFER_SIZE (outbuf) = 0; GST_BUFFER_TIMESTAMP (outbuf) = timestamp; GST_BUFFER_DURATION (outbuf) = duration; GST_BUFFER_OFFSET (outbuf) = offset; GST_BUFFER_OFFSET_END (outbuf) = offsetend; gst_buffer_set_caps (outbuf, GST_PAD_CAPS (self->srcpad)); gst_pad_push (self->srcpad, outbuf); goto done; } GST_DEBUG ("Poping out buffer from OMX"); omx_buffer = goo_port_grab_buffer (self->outport); if (omx_buffer->nFilledLen <= 0) { ret = GST_FLOW_ERROR; goto done; } if (gst_pad_alloc_buffer (self->srcpad, priv->outcount, omx_buffer->nFilledLen, GST_PAD_CAPS (self->srcpad), &outbuf) == GST_FLOW_OK) { priv->outcount++; /* if the buffer is a goo buffer of the peer element */ if (GST_IS_GOO_BUFFER (outbuf)) { GST_INFO ("It is a OMX buffer!"); memcpy (GST_GOO_BUFFER (outbuf)->omx_buffer->pBuffer, omx_buffer->pBuffer, omx_buffer->nFilledLen); GST_GOO_BUFFER (outbuf)->omx_buffer->nFilledLen = omx_buffer->nFilledLen; GST_GOO_BUFFER (outbuf)->omx_buffer->nFlags = omx_buffer->nFlags; GST_GOO_BUFFER (outbuf)->omx_buffer->nTimeStamp = GST2OMX_TIMESTAMP (timestamp); goo_component_release_buffer (self->component, omx_buffer); } else { /* @fixme! */ /* we do this because there is a buffer extarbation * when a filesink is used. * Maybe using multiple buffers it could be solved. */ memcpy (GST_BUFFER_DATA (outbuf), omx_buffer->pBuffer, omx_buffer->nFilledLen); goo_component_release_buffer (self->component, omx_buffer); /* gst_buffer_unref (outbuf); */ /* outbuf = GST_BUFFER (gst_goo_buffer_new ()); */ /* gst_goo_buffer_set_data (outbuf, */ /* self->component, */ /* omx_buffer); */ } GST_BUFFER_TIMESTAMP (outbuf) = timestamp; GST_BUFFER_DURATION (outbuf) = duration; GST_BUFFER_OFFSET (outbuf) = offset; GST_BUFFER_OFFSET_END (outbuf) = offsetend; gst_buffer_set_caps (outbuf, GST_PAD_CAPS (self->srcpad)); g_signal_emit (G_OBJECT (self), gst_goo_encjpeg_signals[FRAME_ENCODED], 0); ret = gst_pad_push (self->srcpad, outbuf); if (omx_buffer->nFlags & OMX_BUFFERFLAG_EOS || goo_port_is_eos (self->outport)) { GST_INFO ("EOS flag found in output buffer (%d)", omx_buffer->nFilledLen); goo_component_set_done (self->component); } goto done; } else { ret = GST_FLOW_ERROR; goto done; } fail: gst_buffer_unref (buffer); gst_goo_adapter_clear (adapter); done: gst_object_unref (self); return ret; }