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; }
/* WORKAROUND for DR OMAPS00164744 */ static void goo_ti_aacenc_eos_buffer_flag (GooComponent* self, guint portindex) { g_assert (GOO_IS_COMPONENT (self)); g_assert (portindex >= 0); g_print ("INFORMATION: workaround for OMAPS00164744\n"); GooPort* port = NULL; OMX_PARAM_PORTDEFINITIONTYPE* param = NULL; GooIterator* iter = goo_component_iterate_ports (self); goo_iterator_nth (iter, portindex); port = GOO_PORT (goo_iterator_get_current (iter)); g_assert (port != NULL); goo_port_set_eos (port); param = GOO_PORT_GET_DEFINITION (port); if (param->eDir == OMX_DirOutput) { goo_component_set_done (self); } g_object_unref (G_OBJECT (port)); g_object_unref (G_OBJECT (iter)); 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; }
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 void goo_engine_inport_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->instream != NULL); guint r; guint read_bytes; read_bytes = goo_engine_get_buffer_len (self, port); r = fread (buffer->pBuffer, 1, read_bytes, self->instream); GOO_OBJECT_DEBUG (self, "%d bytes read", r); if (read_bytes == 0 || feof (self->instream)) { /* set EOS flag */ buffer->nFlags |= OMX_BUFFERFLAG_EOS; if (self->eosevent == TRUE) { goo_component_set_done (self->component); } } buffer->nFilledLen = (r >= 0) ? r : 0; return; }
static void omx_wait_for_done (GstGooEncPcm* self) { g_assert (self != NULL); OMX_BUFFERHEADERTYPE* omx_buffer = NULL; OMX_PARAM_PORTDEFINITIONTYPE* param = NULL; param = GOO_PORT_GET_DEFINITION (self->inport); int omxbufsiz = param->nBufferSize; int avail = gst_goo_adapter_available (self->adapter); if (goo_port_is_tunneled (self->inport)) { GST_INFO_OBJECT (self, "Tunneled Input port: Setting done"); goo_component_set_done (self->component); return; } if (avail < omxbufsiz && avail >= 0) { GST_DEBUG_OBJECT (self, "Sending an EOS buffer"); goo_component_send_eos (self->component); } else { /* For some reason the adapter didn't extract all possible buffers */ g_assert_not_reached (); } gst_goo_adapter_clear (self->adapter); GST_INFO_OBJECT (self, "Waiting for done signal"); goo_component_wait_for_done (self->component); return; }
static void gst_goo_filter_wait_for_done (GstGooFilter* self) { g_assert (self != NULL); GstGooFilterPrivate* priv = GST_GOO_FILTER_GET_PRIVATE (self); /* flushing the last buffers in adapter */ OMX_BUFFERHEADERTYPE* omx_buffer; OMX_PARAM_PORTDEFINITIONTYPE* param = GOO_PORT_GET_DEFINITION (self->inport); GstGooAdapter* adapter = self->adapter; int omxbufsiz = param->nBufferSize; int avail = gst_goo_adapter_available (adapter); if (goo_port_is_tunneled (self->inport)) { GST_INFO ("Input port is tunneled: Setting done"); goo_component_set_done (self->component); return; } if (avail < omxbufsiz && avail > 0) { GST_INFO ("Marking EOS buffer"); omx_buffer = goo_port_grab_buffer (self->inport); GST_DEBUG ("Peek to buffer %d bytes", avail); gst_goo_adapter_peek (adapter, avail, omx_buffer); omx_buffer->nFilledLen = avail; /* let's send the EOS flag right now */ omx_buffer->nFlags = OMX_BUFFERFLAG_EOS; /** @todo timestamp the buffers */ priv->incount++; goo_component_release_buffer (self->component, omx_buffer); } else if (avail == 0) { GST_DEBUG ("Sending empty buffer with EOS flag in it"); goo_component_send_eos (self->component); } else { /* For some reason the adapter didn't extract all possible buffers */ GST_ERROR ("Adapter algorithm error!"); goo_component_send_eos (self->component); } gst_goo_adapter_clear (adapter); if (goo_port_is_tunneled (self->outport)) { GST_INFO ("Outport is tunneled: Setting done"); goo_component_set_done (self->component); } else { GST_INFO ("Waiting for done signal"); goo_component_wait_for_done (self->component); } return; }
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; }