static gboolean
_goo_ti_post_processor_set_rotation (GooTiPostProcessor* self,
GooTiPostProcessorRotation rotation)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
gboolean retval = FALSE;
OMX_CONFIG_ROTATIONTYPE *param = NULL;
param = g_new0 (OMX_CONFIG_ROTATIONTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_ROTATIONTYPE);
param->nRotation = rotation;
GOO_OBJECT_INFO (self, "");
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self),
OMX_IndexConfigCommonRotate, param);
if (retval == TRUE)
{
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
priv->rotation = rotation;
GOO_OBJECT_INFO (self, "rotation = %d", param->nRotation);
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_post_processor_set_mirror (GooTiPostProcessor* self, gboolean mirror)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
gboolean retval = FALSE;
OMX_CONFIG_MIRRORTYPE *param = NULL;
param = g_new0 (OMX_CONFIG_MIRRORTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_SCALEFACTORTYPE);
param->eMirror = (mirror == TRUE) ?
OMX_MirrorHorizontal : OMX_MirrorNone;
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self),
OMX_IndexConfigCommonMirror, param);
if (retval == TRUE)
{
priv->mirror = mirror;
GOO_OBJECT_INFO (self, "Mirror = %s", mirror ? "yes" : "no");
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_audio_component_set_volume (GooTiAudioComponent* self, guint volume)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (volume >= MIN_VOLUME && volume <= MAX_VOLUME);
g_return_val_if_fail (self->dasf_mode == TRUE, FALSE);
gboolean retval = FALSE;
OMX_AUDIO_CONFIG_VOLUMETYPE* param = NULL;
param = g_new0 (OMX_AUDIO_CONFIG_VOLUMETYPE, 1);
GOO_INIT_PARAM (param, OMX_AUDIO_CONFIG_VOLUMETYPE);
param->bLinear = OMX_FALSE;
param->sVolume.nValue = volume;
param->sVolume.nMin = MIN_VOLUME;
param->sVolume.nMax = MAX_VOLUME;
retval = goo_component_set_config_by_index (GOO_COMPONENT (self),
OMX_IndexConfigAudioVolume,
param);
if (retval == TRUE)
{
self->volume = volume;
GOO_OBJECT_INFO (self, "volume = %d", param->sVolume.nValue);
}
g_free (param);
return retval;
}
void
gst_dasf_sink_set_halted (GstDasfSink* self, gboolean halted)
{
GST_LOG ("");
GstDasfSinkPrivate* priv = GST_DASF_SINK_GET_PRIVATE (self);
GooComponent *component = NULL;
GooComponent *pp = NULL;
if(self->component != NULL)
component = GOO_COMPONENT (self->component);
if(self->pp != NULL)
pp = GOO_COMPONENT (self->pp);
if (halted)
{
if (component != NULL && component->cur_state == OMX_StateExecuting)
goo_component_set_state_pause (component);
if (pp != NULL && pp->cur_state == OMX_StateExecuting)
goo_component_set_state_pause (pp);
}
else
{
if (pp != NULL && pp->cur_state == OMX_StatePause)
goo_component_set_state_executing (pp);
if (component != NULL && component->cur_state == OMX_StatePause)
goo_component_set_state_executing (component);
}
}
static gboolean
_goo_ti_post_processor_set_crop_height (GooTiPostProcessor* self,
guint cropheight)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
gboolean retval = FALSE;
OMX_CONFIG_RECTTYPE* param = NULL;
param = g_new0 (OMX_CONFIG_RECTTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_RECTTYPE);
param->nLeft = priv->cropleft;
param->nTop = priv->croptop;
param->nWidth = priv->cropwidth;
param->nHeight = cropheight;
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self),
OMX_IndexConfigCommonOutputCrop, param);
if (retval == TRUE)
{
priv->cropheight = cropheight;
GOO_OBJECT_INFO (self, "Crop Height = %d", priv->cropheight);
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_post_processor_set_yscale (GooTiPostProcessor* self, guint yscale)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (yscale >= 25 && yscale <= 800);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
gboolean retval = FALSE;
OMX_CONFIG_SCALEFACTORTYPE *param = NULL;
param = g_new0 (OMX_CONFIG_SCALEFACTORTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_SCALEFACTORTYPE);
param->xWidth = priv->xscale;
param->xHeight = yscale;
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self), OMX_IndexConfigCommonScale, param);
if (retval == TRUE)
{
priv->yscale = yscale;
GOO_OBJECT_INFO (self, "Y scale = %d", param->xWidth);
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_post_processor_set_ypos (GooTiPostProcessor* self, guint ypos)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
gboolean retval = FALSE;
OMX_CONFIG_POINTTYPE *param = NULL;
param = g_new0 (OMX_CONFIG_POINTTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_POINTTYPE);
param->nX = priv->xpos;
param->nY = ypos;
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self),
OMX_IndexConfigCommonOutputPosition, param);
if (retval == TRUE)
{
priv->ypos = ypos;
GOO_OBJECT_INFO (self, "Y pos = %d", param->nY);
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_post_processor_set_opacity (GooTiPostProcessor* self, guint opacity)
{
GOO_OBJECT_DEBUG (self, "Entering set opacity method");
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (opacity >= 0 && opacity <= 255);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
gboolean retval = FALSE;
OMX_CONFIG_COLORBLENDTYPE *param = NULL;
param = g_new0 (OMX_CONFIG_COLORBLENDTYPE, 1);
GOO_INIT_PARAM (param, OMX_CONFIG_COLORBLENDTYPE);
param->eColorBlend = OMX_ColorBlendAlphaConstant;
param->nRGBAlphaConstant = opacity;
retval = goo_component_set_config_by_index
(GOO_COMPONENT (self),
OMX_IndexConfigCommonColorBlend, param);
if (retval == TRUE)
{
priv->opacity = opacity;
GOO_OBJECT_INFO (self, "Opacity = %d", param->nRGBAlphaConstant);
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_audio_component_set_mute (GooTiAudioComponent* self, gboolean mute)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_return_val_if_fail (self->dasf_mode == TRUE, FALSE);
gboolean retval = FALSE;
OMX_AUDIO_CONFIG_MUTETYPE* param = NULL;
param = g_new0 (OMX_AUDIO_CONFIG_MUTETYPE, 1);
GOO_INIT_PARAM (param, OMX_AUDIO_CONFIG_MUTETYPE);
param->nPortIndex = 0;
param->bMute = (mute) ? OMX_TRUE : OMX_FALSE;
retval = goo_component_set_config_by_index (GOO_COMPONENT (self),
OMX_IndexConfigAudioMute,
param);
if (retval == TRUE)
{
self->mute = mute;
GOO_OBJECT_INFO (self, "mute = %s",
(param->bMute) ? "true" : "false");
}
g_free (param);
return retval;
}
static gboolean
_goo_ti_post_processor_set_ouput (GooTiPostProcessor* self,
GooTiPostProcessorOutput output)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
gboolean retval = TRUE;
POSTPROC_CUSTOM_OUTPUTDEVICES outdev;
if (self->video_pipeline == 1 &&
output == GOO_TI_POST_PROCESSOR_OUTPUT_LCD)
{
outdev.nVideoPipeline1 = GOO_TI_POST_PROCESSOR_OUTPUT_LCD;
outdev.nVideoPipeline2 = GOO_TI_POST_PROCESSOR_OUTPUT_NONE;
}
else if (self->video_pipeline == 2 &&
output == GOO_TI_POST_PROCESSOR_OUTPUT_LCD)
{
outdev.nVideoPipeline1 = GOO_TI_POST_PROCESSOR_OUTPUT_NONE;
outdev.nVideoPipeline2 = GOO_TI_POST_PROCESSOR_OUTPUT_LCD;
}
else if (self->video_pipeline == 1 &&
output == GOO_TI_POST_PROCESSOR_OUTPUT_TV)
{
outdev.nVideoPipeline1 = GOO_TI_POST_PROCESSOR_OUTPUT_TV;
outdev.nVideoPipeline2 = GOO_TI_POST_PROCESSOR_OUTPUT_NONE;
}
else if (self->video_pipeline == 2 &&
output == GOO_TI_POST_PROCESSOR_OUTPUT_TV)
{
outdev.nVideoPipeline1 = GOO_TI_POST_PROCESSOR_OUTPUT_NONE;
outdev.nVideoPipeline2 = GOO_TI_POST_PROCESSOR_OUTPUT_TV;
}
else if (output == GOO_TI_POST_PROCESSOR_OUTPUT_BOTH)
{
outdev.nVideoPipeline1 = GOO_TI_POST_PROCESSOR_OUTPUT_LCD;
outdev.nVideoPipeline2 = GOO_TI_POST_PROCESSOR_OUTPUT_TV;
}
else
{
GOO_OBJECT_WARNING (self, "No configurable output");
return retval;
}
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
OUTPUT_DEVICE,
(OMX_PTR*) &outdev);
if (retval == TRUE)
{
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
priv->output = output;
GOO_OBJECT_INFO (self, "output = %d", priv->output);
}
return retval;
}
static gboolean
_goo_ti_audio_component_set_dasf_mode (GooTiAudioComponent* self,
gboolean dasf_mode)
{
g_assert (GOO_IS_TI_AUDIO_COMPONENT (self));
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (self->dasf_param_name != NULL);
gboolean retval = FALSE;
self->audioinfo->dasfMode = (dasf_mode) ? 1 : 0;
if (self->audioinfo->dasfMode == 1)
{
if (G_UNLIKELY (self->manager == NULL))
{
self->manager = goo_ti_audio_manager_new
(GOO_COMPONENT (self));
_goo_ti_audio_component_get_stream_id (self);
}
g_assert (self->stream_id > 0);
self->audioinfo->streamId = self->stream_id;
GOO_OBJECT_INFO (self, "stream id = %ld",
self->audioinfo->streamId);
}
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
self->dasf_param_name,
self->audioinfo);
if (retval == TRUE && self->audioinfo->dasfMode == 1)
{
self->dasf_mode = dasf_mode;
GOO_OBJECT_INFO (self, "dasf mode = %d",
self->audioinfo->dasfMode);
/* output port is tunneled in DASF mode */
GooPort* port = NULL;
GooIterator *iter =
goo_ti_audio_component_iterate_ports (self);
while (!goo_iterator_is_done (iter))
{
port = GOO_PORT (goo_iterator_get_current (iter));
g_object_set (G_OBJECT (port),
"tunneled", self->dasf_mode, NULL);
g_object_unref (G_OBJECT (port));
goo_iterator_next (iter);
}
g_object_unref (G_OBJECT (iter));
}
return retval;
}
static void
goo_ti_clock_init (GooTiClock* self)
{
GOO_COMPONENT (self)->id = g_strdup (ID);
GOO_COMPONENT (self)->port_param_type = OMX_IndexParamOtherInit;
goo_object_set_name (GOO_OBJECT (self), NAME);
return;
}
static gboolean
_goo_ti_audio_component_get_stream_id (GooTiAudioComponent* self)
{
g_assert (GOO_TI_AUDIO_COMPONENT (self));
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (self->streamid_param_name != NULL);
gboolean retval = FALSE;
if (self->stream_id > -1)
{
return retval;
}
GOO_OBJECT_DEBUG (self, "");
#if 0 /* this is deprected since audio manager */
TI_OMX_STREAM_INFO param;
retval = goo_component_get_config_by_name (GOO_COMPONENT (self),
self->streamid_param_name,
¶m);
if (retval == TRUE)
{
self->stream_id = param.streamId;
GOO_INFO ("stream id = %d", self->stream_id);
}
#else
if (G_LIKELY (self->manager != NULL))
{
self->stream_id = goo_ti_audio_manager_get_stream_id (self->manager);
if (self->stream_id > 0)
{
retval = TRUE;
}
else
{
retval = FALSE;
}
}
else
{
retval = FALSE;
}
#endif
return retval;
}
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_ti_wmadec_set_header_info (GooTiWmaDec *self)
{
g_assert (self != NULL);
goo_component_set_config_by_name (GOO_COMPONENT(self),
GOO_TI_AUDIO_COMPONENT (self)->dasf_param_name,
GOO_TI_AUDIO_COMPONENT (self)->audioinfo);
}
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;
}
void _goo_ti_mp3dec_set_layer(GooTiMp3Dec *self, guint layer)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (layer == 2 || layer == 3);
GooTiAudioComponent *component = GOO_TI_AUDIO_COMPONENT(self);
gboolean retval = FALSE;
component->audioinfo->mpeg1_layer2 = (layer == 2) ? 1 : 0;
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
component->dasf_param_name,
component->audioinfo);
if (retval == TRUE)
{
self->layer = layer;
GOO_OBJECT_INFO (self, "mpeg1_layer2 = %d",
component->audioinfo->mpeg1_layer2);
}
}
static gboolean
_goo_ti_audio_component_set_data_path (GooTiAudioComponent* self,
guint datapath)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (self->datapath_param_name != NULL);
gboolean retval = FALSE;
self->datapath= datapath ? 1: 0;
GOO_OBJECT_DEBUG (self, "datapath set to: %p",
self->datapath);
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
self->datapath_param_name,
&(self->datapath));
GOO_OBJECT_DEBUG (self, "datapath set to: %d", self->datapath);
return retval;
}
static void
_goo_ti_aacenc_set_output_frames (GooTiAacEnc *self)
{
g_assert (self != NULL);
GOO_OBJECT_DEBUG (self, "Frames per output = %d", self->output_frames);
goo_component_set_config_by_name (GOO_COMPONENT (self),
FRAMESPERBUFFER,
&self->output_frames);
return;
}
static gboolean
_goo_ti_audio_component_set_acoustic_mode (GooTiAudioComponent *self,
gboolean acoustic_mode)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (self->acoustic_param_name != NULL);
gboolean retval = FALSE;
self->audioinfo->acousticMode = (acoustic_mode) ? 1 : 0;
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
self->acoustic_param_name,
self->audioinfo);
if (retval == TRUE)
{
self->acoustic_mode = acoustic_mode;
GOO_OBJECT_INFO (self, "acoustic mode = %d",
self->audioinfo->acousticMode);
}
return retval;
}
/**
* 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 gboolean
_goo_ti_audio_component_set_frame_mode (GooTiAudioComponent* self,
gboolean frame_mode)
{
g_assert (self != NULL);
g_assert (GOO_COMPONENT (self)->cur_state != OMX_StateInvalid);
g_assert (self->frame_param_name != NULL);
gboolean retval = FALSE;
self->audioinfo->framemode = (frame_mode) ? 1 : 0;
retval = goo_component_set_config_by_name (GOO_COMPONENT (self),
self->frame_param_name,
self->audioinfo);
if (retval == TRUE)
{
self->frame_mode = frame_mode;
GOO_OBJECT_INFO (self, "dasf mode = %d",
self->audioinfo->framemode);
#if 0
/* output port is tunneled in DASF mode */
GooPort* port = NULL;
GooIterator* iter = goo_component_iterate_output_ports
(GOO_COMPONENT (self));
while (!goo_iterator_is_done (iter))
{
port = GOO_PORT (goo_iterator_get_current (iter));
g_object_set (G_OBJECT (port),
"tunneled", self->dasf_mode, NULL);
g_object_unref (G_OBJECT (port));
goo_iterator_next (iter);
}
g_object_unref (G_OBJECT (iter));
#endif
}
return retval;
}
static void
goo_ti_gsmfrdec_init (GooTiGsmFrDec* self)
{
GOO_COMPONENT (self)->id = g_strdup (ID);
GOO_TI_AUDIO_COMPONENT (self)->dasf_param_name = g_strdup (DASF_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->frame_param_name = g_strdup (FRAME_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->streamid_param_name = g_strdup (STREAMID_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->datapath_param_name = g_strdup (DATAPATH_PARAM_NAME);
self->input_port_param = NULL;
self->output_port_param = NULL;
return;
}
static void
goo_ti_post_processor_init (GooTiPostProcessor* self)
{
GOO_COMPONENT (self)->port_param_type = OMX_IndexParamVideoInit;
GOO_COMPONENT (self)->id = g_strdup (ID);
GooTiPostProcessorPriv* priv =
GOO_TI_POST_PROCESSOR_GET_PRIVATE (self);
priv->rotation = DEFAULT_ROTATION;
priv->opacity= DEFAULT_OPACITY;
priv->xscale = DEFAULT_XSCALE;
priv->yscale = DEFAULT_YSCALE;
priv->xpos = DEFAULT_XPOS;
priv->ypos = DEFAULT_YPOS;
priv->mirror = DEFAULT_MIRROR;
priv->output = DEFAULT_OUTPUT;
self->video_pipeline = 1;
self->background_color = NULL;
self->transcolor_key = NULL;
return;
}
/**
* helper for gst_goo_util_find_goo_component() to check if the current element
* is the one we are searching for
*/
static GooComponent *
check_for_goo_component (GstElement *elem, SearchContext *ctx)
{
GooComponent *component = GOO_COMPONENT (g_object_get_data (G_OBJECT (elem), "goo"));
if (component != NULL)
{
if (!G_TYPE_CHECK_INSTANCE_TYPE (component, ctx->type))
{
GST_INFO("found GOO component: %s", G_OBJECT_TYPE_NAME (component));
component = NULL;
}
}
return component;
}
static void
goo_ti_gsmfrenc_init (GooTiGsmFrEnc* self)
{
GOO_COMPONENT (self)->id = g_strdup (ID);
GOO_TI_AUDIO_COMPONENT (self)->dasf_param_name =
g_strdup (DASF_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->acoustic_param_name =
g_strdup (ACOUSTIC_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->streamid_param_name =
g_strdup (STREAMID_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->datapath_param_name =
g_strdup (DATAPATH_PARAM_NAME);
self->output_port_param = NULL;
return;
}
static void
_goo_ti_aacenc_set_bit_rate_mode (GooTiAacEnc *self,
GooTiAacEncBitRateMode bit_rate_mode)
{
g_assert (self != NULL);
GooTiAudioComponent *me = GOO_TI_AUDIO_COMPONENT (self);
me->audioinfo->aacencHeaderInfo->bitratemode = bit_rate_mode;
goo_component_set_config_by_name (GOO_COMPONENT (self),
me->dasf_param_name,
me->audioinfo);
GOO_OBJECT_DEBUG (self, "");
return;
}
static void
goo_ti_audio_component_finalize (GObject* object)
{
g_assert (GOO_IS_TI_AUDIO_COMPONENT (object));
GooTiAudioComponent* self = GOO_TI_AUDIO_COMPONENT (object);
if (G_LIKELY (self->dasf_param_name))
{
g_free (self->dasf_param_name);
self->dasf_param_name = NULL;
}
if (G_LIKELY (self->frame_param_name))
{
g_free (self->frame_param_name);
self->frame_param_name = NULL;
}
if (G_LIKELY (self->acoustic_param_name))
{
g_free (self->acoustic_param_name);
self->acoustic_param_name = NULL;
}
if (G_LIKELY (self->datapath_param_name))
{
g_free (self->datapath_param_name);
self->datapath_param_name = NULL;
}
if (G_LIKELY (self->audioinfo))
{
g_free (self->audioinfo);
self->audioinfo = NULL;
}
if (G_LIKELY (self->streamid_param_name))
{
g_free (self->streamid_param_name);
self->streamid_param_name = NULL;
}
GOO_COMPONENT (self)->port_param_type = OMX_IndexComponentStartUnused;
(*G_OBJECT_CLASS (goo_ti_audio_component_parent_class)->finalize)
(object);
return;
}
/**
* goo_ti_clock_get_timestamp:
* @self: A #GooTiClock instance
*
* Retrieve the current media time ellapsed from the moment of an audio stream
* started to now.
*
* Return value: The number of ticks in microseconds ocurred to now.
*/
gint64
goo_ti_clock_get_timestamp (GooTiClock* self)
{
OMX_TIME_CONFIG_TIMESTAMPTYPE* param;
gint64 ts = 0;
param = g_new0 (OMX_TIME_CONFIG_TIMESTAMPTYPE, 1);
GOO_INIT_PARAM (param, OMX_TIME_CONFIG_TIMESTAMPTYPE);
goo_component_get_config_by_index (GOO_COMPONENT (self),
OMX_IndexConfigTimeCurrentMediaTime,
param);
ts = (gint64) param->nTimestamp;
g_free (param);
return ts;
}
static void
goo_ti_wmadec_init (GooTiWmaDec* self)
{
GOO_COMPONENT (self)->id = g_strdup (ID);
GOO_TI_AUDIO_COMPONENT (self)->dasf_param_name =
g_strdup (DASF_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->frame_param_name =
g_strdup (FRAME_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->datapath_param_name =
g_strdup (DATAPATH_PARAM_NAME);
GOO_TI_AUDIO_COMPONENT (self)->streamid_param_name =
g_strdup (STREAMID_PARAM_NAME);
self->input_param = NULL;
self->output_param = NULL;
GOO_TI_AUDIO_COMPONENT (self)->audioinfo->wmaHeaderInfo = g_new0(WMA_HeadInfo, 1);
return;
}
