status_t OMXNodeInstance::getParameter(
OMX_INDEXTYPE index, void *params, size_t size) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetParameter(mHandle, index, params);
return StatusFromOMXError(err);
}
OMX_ERRORTYPE prepare_port_buffers(HTEST *hTest, OMX_U32 nPortIndex)
{
OMX_COMPONENTTYPE *hComponent = NULL;
OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
OMX_U8 *pBuffer = NULL;
OMX_U32 i;
hComponent = hTest->hComponent;
OMX_INIT_STRUCT(&sPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
sPortDef.nPortIndex = nPortIndex;
OMX_GetParameter(hComponent, OMX_IndexParamPortDefinition, &sPortDef);
for(i=0; i<sPortDef.nBufferCountActual; i++)
{
if(hTest->bAllocater[nPortIndex] == OMX_TRUE)
{
OMX_AllocateBuffer(hComponent, &pBufferHdr, nPortIndex, NULL, sPortDef.nBufferSize);
printf("Allocate buffer done.\n");
}
else
{
pBuffer = (OMX_U8*)FSL_MALLOC(sPortDef.nBufferSize);
OMX_UseBuffer(hComponent, &pBufferHdr, nPortIndex, NULL, sPortDef.nBufferSize, pBuffer);
printf("Use buffer done.\n");
}
hTest->pBufferHdr[nPortIndex][i] = pBufferHdr;
}
hTest->nBufferHdr[nPortIndex] = sPortDef.nBufferCountActual;
return OMX_ErrorNone;
}
void graph::gmusicops::do_retrieve_metadata ()
{
OMX_U32 index = 0;
const int gmusic_index = 0;
// Extract metadata from the gmusic source
while (OMX_ErrorNone == dump_metadata_item (index++, gmusic_index))
{
};
// Now extract metadata from the decoder
const int decoder_index = 1;
index = 0;
const bool use_first_as_heading = false;
while (OMX_ErrorNone
== dump_metadata_item (index++, decoder_index, use_first_as_heading))
{
};
OMX_GetParameter (handles_[2], OMX_IndexParamAudioPcm, &renderer_pcmtype_);
// Now print renderer metadata
TIZ_PRINTF_MAG (
" %ld Ch, %g KHz, %lu:%s:%s \n", renderer_pcmtype_.nChannels,
((float)renderer_pcmtype_.nSamplingRate) / 1000,
renderer_pcmtype_.nBitPerSample,
renderer_pcmtype_.eNumData == OMX_NumericalDataSigned ? "s" : "u",
renderer_pcmtype_.eEndian == OMX_EndianBig ? "b" : "l");
}
/* Based on allocbufs from omxtx.
Buffers are connected as a one-way linked list using pAppPrivate as the pointer to the next element */
void omx_alloc_buffers(struct omx_component_t *component, int port)
{
int i;
OMX_BUFFERHEADERTYPE *list = NULL, **end = &list;
OMX_PARAM_PORTDEFINITIONTYPE portdef;
OMX_INIT_STRUCTURE(portdef);
portdef.nPortIndex = port;
OERR(OMX_GetParameter(component->h, OMX_IndexParamPortDefinition, &portdef));
if (component == &component->pipe->audio_render) {
DEBUGF("Allocating %d buffers of %d bytes\n",(int)portdef.nBufferCountActual,(int)portdef.nBufferSize);
DEBUGF("portdef.bEnabled=%d\n",portdef.bEnabled);
}
for (i = 0; i < portdef.nBufferCountActual; i++) {
OMX_U8 *buf;
buf = vcos_malloc_aligned(portdef.nBufferSize, portdef.nBufferAlignment, "buffer");
// printf("Allocated a buffer of %u bytes\n",(unsigned int)portdef.nBufferSize);
OERR(OMX_UseBuffer(component->h, end, port, NULL, portdef.nBufferSize, buf));
end = (OMX_BUFFERHEADERTYPE **) &((*end)->pAppPrivate);
}
component->buffers = list;
}
OMX_ERRORTYPE
graph::vorbisdecops::set_vorbis_settings ()
{
// Retrieve the current vorbis settings from the decoder's port #0
OMX_AUDIO_PARAM_VORBISTYPE vorbistype_orig;
TIZ_INIT_OMX_PORT_STRUCT (vorbistype_orig, 0 /* port id */);
tiz_check_omx_err (OMX_GetParameter (handles_[1], OMX_IndexParamAudioVorbis,
&vorbistype_orig));
// Set the vorbis settings on decoder's port #0
OMX_AUDIO_PARAM_VORBISTYPE vorbistype;
TIZ_INIT_OMX_PORT_STRUCT (vorbistype, 0 /* port id */);
probe_ptr_->get_vorbis_codec_info (vorbistype);
vorbistype.nPortIndex = 0;
tiz_check_omx_err (
OMX_SetParameter (handles_[1], OMX_IndexParamAudioVorbis, &vorbistype));
// Record whether we need to wait for a port settings change event or not
// (the decoder output port implements the "slaving" behaviour)
need_port_settings_changed_evt_
= ((vorbistype_orig.nSampleRate != vorbistype.nSampleRate)
|| (vorbistype_orig.nChannels != vorbistype.nChannels));
return OMX_ErrorNone;
}
void
omx_alloc_buffers(omx_component_t *oc, int port)
{
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof(portdef));
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = port;
omxchk(OMX_GetParameter(oc->oc_handle, OMX_IndexParamPortDefinition, &portdef));
if(portdef.bEnabled != OMX_FALSE || portdef.nBufferCountActual == 0 || portdef.nBufferSize == 0)
exit(2);
omxdbg("Allocating buffers for %s:%d\n", oc->oc_name, port);
omxdbg(" buffer count = %d\n", (int)portdef.nBufferCountActual);
omxdbg(" buffer size = %d\n", (int)portdef.nBufferSize);
omx_send_command(oc, OMX_CommandPortEnable, port, NULL, 0);
int i;
for(i = 0; i < portdef.nBufferCountActual; i++) {
OMX_BUFFERHEADERTYPE *buf;
omxchk(OMX_AllocateBuffer(oc->oc_handle, &buf, port, NULL, portdef.nBufferSize));
omxdbg("buf=%p\n", buf);
buf->pAppPrivate = oc->oc_avail;
oc->oc_avail = buf;
}
omx_wait_command(oc); // Waits for the OMX_CommandPortEnable command
}
static OMX_ERRORTYPE SetFormat(filter_t *filter, OmxPort *port)
{
OMX_PARAM_PORTDEFINITIONTYPE *definition;
filter_sys_t *sys = filter->p_sys;
OMX_ERRORTYPE omx_error;
definition = &port->definition;
definition->format.image.nFrameWidth =
filter->fmt_in.video.i_width;
definition->format.image.nFrameHeight =
filter->fmt_in.video.i_height;
definition->format.image.nStride =
ALIGN(definition->format.image.nFrameWidth, 32);
definition->format.image.nSliceHeight =
ALIGN(definition->format.image.nFrameHeight, 16);
definition->nBufferSize = definition->format.image.nStride *
definition->format.image.nSliceHeight * 3 / 2;
omx_error = OMX_SetParameter(sys->omx_handle,
OMX_IndexParamPortDefinition, definition);
if (omx_error != OMX_ErrorNone)
msg_Warn(filter, "Could not configure port format (%x: %s).",
omx_error, ErrorToString(omx_error));
OMX_GetParameter(sys->omx_handle, OMX_IndexParamPortDefinition,
&definition);
msg_Dbg(filter, "Port %u\nFormat: %ux%u (%ux%u)\nnBufferSize: %u",
(unsigned)definition->nPortIndex,
(unsigned)definition->format.image.nFrameWidth,
(unsigned)definition->format.image.nFrameHeight,
(unsigned)definition->format.image.nStride,
(unsigned)definition->format.image.nSliceHeight,
(unsigned)definition->nBufferSize);
return omx_error;
}
int NonTextureEngine::getFrameCounter()
{
if (!isOpen)
{
return 0;
}
OMX_CONFIG_BRCMPORTSTATSTYPE stats;
OMX_INIT_STRUCTURE(stats);
stats.nPortIndex = VIDEO_RENDER_INPUT_PORT;
OMX_ERRORTYPE error =OMX_GetParameter(render, OMX_IndexConfigBrcmPortStats, &stats);
if (error == OMX_ErrorNone)
{
/*OMX_U32 nImageCount;
OMX_U32 nBufferCount;
OMX_U32 nFrameCount;
OMX_U32 nFrameSkips;
OMX_U32 nDiscards;
OMX_U32 nEOS;
OMX_U32 nMaxFrameSize;
OMX_TICKS nByteCount;
OMX_TICKS nMaxTimeDelta;
OMX_U32 nCorruptMBs;*/
//ofLogVerbose(__func__) << "nFrameCount: " << stats.nFrameCount;
frameCounter = stats.nFrameCount;
}else
{
ofLog(OF_LOG_ERROR, "error OMX_CONFIG_BRCMPORTSTATSTYPE FAIL error: 0x%08x", error);
//frameCounter = 0;
}
return frameCounter;
}
OMX_ERRORTYPE
graph::gmusicops::set_channels_and_rate_on_decoder (
const OMX_U32 channels, const OMX_U32 sampling_rate)
{
const OMX_HANDLETYPE handle = handles_[1]; // decoder's handle
const OMX_U32 port_id = 0; // decoder's input port
TIZ_LOG (TIZ_PRIORITY_TRACE, "channels = [%d] sampling_rate = [%d]", channels,
sampling_rate);
// Retrieve the mp3 settings from the decoder component
TIZ_INIT_OMX_PORT_STRUCT (decoder_mp3type_, port_id);
tiz_check_omx (
OMX_GetParameter (handle, OMX_IndexParamAudioMp3, &decoder_mp3type_));
TIZ_LOG (TIZ_PRIORITY_TRACE, "channels = [%d] sampling_rate = [%d]", channels,
sampling_rate);
// Now assign the actual settings to the pcmtype structure
decoder_mp3type_.nChannels = channels;
decoder_mp3type_.nSampleRate = sampling_rate;
// Set the new mp3 settings
tiz_check_omx (
OMX_SetParameter (handle, OMX_IndexParamAudioMp3, &decoder_mp3type_));
TIZ_LOG (TIZ_PRIORITY_TRACE, "channels = [%d] sampling_rate = [%d]", channels,
sampling_rate);
return OMX_ErrorNone;
}
static void
rpi_video_port_settings_changed(omx_component_t *oc)
{
media_codec_t *mc = oc->oc_opaque;
const rpi_video_codec_t *rvc = mc->opaque;
media_pipe_t *mp = mc->mp;
frame_info_t *fi = calloc(1, sizeof(frame_info_t));
int sar_num = 1;
int sar_den = 1;
if(rvc->rvc_sar_num && rvc->rvc_sar_den) {
sar_num = rvc->rvc_sar_num;
sar_den = rvc->rvc_sar_den;
} else {
OMX_CONFIG_POINTTYPE pixel_aspect;
OMX_INIT_STRUCTURE(pixel_aspect);
pixel_aspect.nPortIndex = 131;
if(OMX_GetParameter(oc->oc_handle, OMX_IndexParamBrcmPixelAspectRatio,
&pixel_aspect) == OMX_ErrorNone) {
sar_num = pixel_aspect.nX ?: sar_num;
sar_den = pixel_aspect.nY ?: sar_den;
}
}
OMX_ERRORTYPE
graph::gmusicops::set_gmusic_playlist (const OMX_HANDLETYPE handle,
const std::string &playlist)
{
// Set the Google Music playlist
OMX_TIZONIA_AUDIO_PARAM_GMUSICPLAYLISTTYPE playlisttype;
TIZ_INIT_OMX_STRUCT (playlisttype);
tiz_check_omx_err (OMX_GetParameter (
handle,
static_cast< OMX_INDEXTYPE >(OMX_TizoniaIndexParamAudioGmusicPlaylist),
&playlisttype));
copy_omx_string (playlisttype.cPlaylistName, playlist);
tizgmusicconfig_ptr_t gmusic_config
= boost::dynamic_pointer_cast< gmusicconfig >(config_);
assert (gmusic_config);
playlisttype.ePlaylistType = gmusic_config->get_playlist_type ();
playlisttype.bShuffle = playlist_->shuffle ();
return OMX_SetParameter (
handle,
static_cast< OMX_INDEXTYPE >(OMX_TizoniaIndexParamAudioGmusicPlaylist),
&playlisttype);
}
OMX_ERRORTYPE
graph::gmusicops::set_channels_and_rate_on_renderer (
const OMX_U32 channels, const OMX_U32 sampling_rate,
const std::string encoding_str)
{
const OMX_HANDLETYPE handle = handles_[2]; // renderer's handle
const OMX_U32 port_id = 0; // renderer's input port
TIZ_LOG (TIZ_PRIORITY_TRACE, "channels = [%d] sampling_rate = [%d]", channels,
sampling_rate);
// Retrieve the pcm settings from the renderer component
TIZ_INIT_OMX_PORT_STRUCT (renderer_pcmtype_, port_id);
tiz_check_omx_err (
OMX_GetParameter (handle, OMX_IndexParamAudioPcm, &renderer_pcmtype_));
// Now assign the actual settings to the pcmtype structure
renderer_pcmtype_.nChannels = channels;
renderer_pcmtype_.nSamplingRate = sampling_rate;
renderer_pcmtype_.eNumData = OMX_NumericalDataSigned;
renderer_pcmtype_.eEndian
= (encoding_ == OMX_AUDIO_CodingMP3 ? OMX_EndianBig : OMX_EndianLittle);
// Set the new pcm settings
tiz_check_omx_err (
OMX_SetParameter (handle, OMX_IndexParamAudioPcm, &renderer_pcmtype_));
std::string coding_type_str ("gmusic");
tiz::graph::util::dump_graph_info (coding_type_str.c_str (),
"Connection established",
playlist_->get_current_uri ().c_str ());
dump_stream_metadata ();
return OMX_ErrorNone;
}
static OMX_ERRORTYPE StdCompCommonImage_PortFormatSupported(
TEST_CTXTYPE *pCtx,
OMX_U32 nPortIndex,
OMX_IMAGE_CODINGTYPE eCompressionFormat,
OMX_COLOR_FORMATTYPE eColorFormat)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_IMAGE_PARAM_PORTFORMATTYPE sPortFormat;
OMX_CONF_INIT_STRUCT(sPortFormat, OMX_IMAGE_PARAM_PORTFORMATTYPE);
OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Verifying port format support\n");
sPortFormat.nPortIndex = nPortIndex;
for (sPortFormat.nIndex = 0; ; sPortFormat.nIndex++)
{
eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamImagePortFormat, (OMX_PTR) & sPortFormat);
if (OMX_ErrorNoMore == eError)
eError = OMX_ErrorBadParameter; // OMX_ErrorBadPortFormatEncoding
OMX_CONF_BAIL_ON_ERROR(eError);
if ((sPortFormat.eCompressionFormat == eCompressionFormat) &&
(sPortFormat.eColorFormat == eColorFormat))
break;
}
OMX_CONF_TEST_BAIL:
return(eError);
}
static void
get_property (GObject * obj, guint prop_id, GValue * value, GParamSpec * pspec)
{
GstOmxBaseSink *self;
self = GST_OMX_BASE_SINK (obj);
if (gstomx_get_property_helper (self->gomx, prop_id, value))
return;
switch (prop_id) {
case ARG_NUM_INPUT_BUFFERS:
{
OMX_PARAM_PORTDEFINITIONTYPE param;
OMX_HANDLETYPE omx_handle = self->gomx->omx_handle;
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 = self->in_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 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);
}
OMX_ERRORTYPE Component::allocOutputBuffers()
{
if(!handle)
{
ofLogError(__func__) << getName() << " NO HANDLE";
return OMX_ErrorNone;
}
OMX_ERRORTYPE error = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE portFormat;
OMX_INIT_STRUCTURE(portFormat);
portFormat.nPortIndex = outputPort;
error = OMX_GetParameter(handle, OMX_IndexParamPortDefinition, &portFormat);
OMX_TRACE(error);
if(error != OMX_ErrorNone)
{
return error;
}
if(getState() != OMX_StateIdle)
{
if(getState() != OMX_StateLoaded)
{
setState(OMX_StateLoaded);
}
setState(OMX_StateIdle);
}
error = enablePort(outputPort);
OMX_TRACE(error);
if(error != OMX_ErrorNone)
{
return error;
}
for (size_t i = 0; i < portFormat.nBufferCountActual; i++)
{
OMX_BUFFERHEADERTYPE *buffer = NULL;
error = OMX_AllocateBuffer(handle, &buffer, outputPort, NULL, portFormat.nBufferSize);
OMX_TRACE(error);
if(error != OMX_ErrorNone)
{
return error;
}
buffer->nOutputPortIndex = outputPort;
buffer->nFilledLen = 0;
buffer->nOffset = 0;
buffer->pAppPrivate = (void*)i;
outputBuffers.push_back(buffer);
outputBuffersAvailable.push(buffer);
}
return error;
}
OMX_ERRORTYPE load_component(HTEST *hTest)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_HANDLETYPE hComponent = NULL;
OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
OMX_U32 i;
ret = OMX_GetHandle(&hComponent, hTest->name, hTest, &gCallBacks);
if(ret != OMX_ErrorNone)
{
printf("Load component %s failed.\n", hTest->name);
return ret;
}
hTest->hComponent = (OMX_COMPONENTTYPE*)hComponent;
hTest->nPorts = get_component_ports(hComponent);
OMX_INIT_STRUCT(&sPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
for(i=0; i<hTest->nPorts; i++)
{
sPortDef.nPortIndex = i;
OMX_GetParameter(hComponent, OMX_IndexParamPortDefinition, &sPortDef);
if (sPortDef.eDomain == OMX_PortDomainAudio)
hTest->nAudioTrackNum = i;
if (sPortDef.eDomain == OMX_PortDomainVideo)
hTest->nVideoTrackNum = i;
hTest->PortDir[i] = sPortDef.eDir;
if(hTest->PortDir[i] == OMX_DirInput)
hTest->bAllocater[i] = OMX_FALSE;
if(hTest->PortDir[i] == OMX_DirOutput)
hTest->bAllocater[i] = OMX_TRUE;
}
OMX_PARAM_CONTENTURITYPE *content = NULL;
content =(OMX_PARAM_CONTENTURITYPE *) fsl_osal_malloc_new(sizeof(OMX_PARAM_CONTENTURITYPE) + 1024);
if (!content)
return OMX_ErrorInsufficientResources;
fsl_osal_memset(content, 0 , sizeof(OMX_PARAM_CONTENTURITYPE)+1024);
OMX_INIT_STRUCT(content,OMX_PARAM_CONTENTURITYPE);
char* uri = (char*)&(content->contentURI);
fsl_osal_memcpy(uri, hTest->media_name, strlen(hTest->media_name)+1);
ret = OMX_SetParameter(hTest->hComponent,OMX_IndexParamContentURI,content);
if (ret != OMX_ErrorNone)
{
OMX_FreeHandle(hTest->hComponent);
hTest->hComponent = NULL;
return ret;
}
fsl_osal_thread_create(&hTest->pThreadId, NULL, process_thread, hTest);
return OMX_ErrorNone;
}
/*========================================================*/
OMX_ERRORTYPE SampleTest_TransitionWait(OMX_STATETYPE eToState,
SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE tPortDef;
OMX_U32 i, j;
eError = OMX_SendCommand(pContext->hComp, OMX_CommandStateSet,
eToState, NULL);
OMX_TEST_BAIL_IF_ERROR(eError);
if ((eToState == OMX_StateIdle) &&
(pContext->eState == OMX_StateLoaded))
{
for (i = 0; i < NUM_DOMAINS; i++)
{
for (j = pContext->sPortParam[i].nStartPortNumber;
j < pContext->sPortParam[i].nStartPortNumber
+ pContext->sPortParam[i].nPorts; j++)
{
OMX_TEST_INIT_STRUCT(tPortDef,
OMX_PARAM_PORTDEFINITIONTYPE);
tPortDef.nPortIndex = j;
//printf("\nCalling GetParam before UseBuf on port %d\n",j);
eError = OMX_GetParameter(pContext->hComp,
OMX_IndexParamPortDefinition,
(OMX_PTR) & tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
// if(tPortDef.bEnabled)//AD
eError =
SampleTest_AllocateBuffers(pContext,
&tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
}
}
} else if ((eToState == OMX_StateLoaded) &&
(pContext->eState == OMX_StateIdle))
{
eError = SampleTest_DeInitBuffers(pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
}
printf("\nWaiting for state set event\n");
TIMM_OSAL_SemaphoreObtain(pContext->hStateSetEvent,
TIMM_OSAL_SUSPEND);
printf("\nState set event recd.\n");
if (pContext->eState != eToState)
OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
" InComplete Transition \n");
OMX_TEST_BAIL:
return eError;
}
int Init_Decoder(OMX_STRING audio_component)
{
DEBUG_PRINT("Inside %s \n", __FUNCTION__);
OMX_ERRORTYPE omxresult;
OMX_U32 total = 0;
typedef OMX_U8* OMX_U8_PTR;
char *role ="audio_decoder.aac";
static OMX_CALLBACKTYPE call_back = {
&EventHandler,&EmptyBufferDone,&FillBufferDone
};
/* Init. the OpenMAX Core */
DEBUG_PRINT("\nInitializing OpenMAX Core....\n");
omxresult = OMX_Init();
if(OMX_ErrorNone != omxresult) {
DEBUG_PRINT("\n Failed to Init OpenMAX core");
return -1;
}
else {
DEBUG_PRINT("\nOpenMAX Core Init Done\n");
}
/* Query for audio decoders*/
DEBUG_PRINT("Aac_test: Before entering OMX_GetComponentOfRole");
OMX_GetComponentsOfRole(role, &total, 0);
DEBUG_PRINT ("\nTotal components of role=%s :%lu", role, total);
omxresult = OMX_GetHandle((OMX_HANDLETYPE*)(&aac_dec_handle),
(OMX_STRING)audio_component, NULL, &call_back);
if (FAILED(omxresult)) {
DEBUG_PRINT("\nFailed to Load the component:%s\n", audio_component);
return -1;
}
else
{
DEBUG_PRINT("\nComponent %s is in LOADED state\n", audio_component);
}
/* Get the port information */
CONFIG_VERSION_SIZE(portParam);
omxresult = OMX_GetParameter(aac_dec_handle, OMX_IndexParamAudioInit,
(OMX_PTR)&portParam);
if(FAILED(omxresult)) {
DEBUG_PRINT("\nFailed to get Port Param\n");
return -1;
}
else
{
DEBUG_PRINT("\nportParam.nPorts:%lu\n", portParam.nPorts);
DEBUG_PRINT("\nportParam.nStartPortNumber:%lu\n",
portParam.nStartPortNumber);
}
return 0;
}
static void
setup_ports (GstOmxBaseFilter *self)
{
GOmxCore *core;
OMX_PARAM_PORTDEFINITIONTYPE param;
core = self->gomx;
memset (¶m, 0, sizeof (param));
param.nSize = sizeof (OMX_PARAM_PORTDEFINITIONTYPE);
param.nVersion.s.nVersionMajor = 1;
param.nVersion.s.nVersionMinor = 1;
/* Input port configuration. */
param.nPortIndex = 0;
OMX_GetParameter (core->omx_handle, OMX_IndexParamPortDefinition, ¶m);
self->in_port = g_omx_core_setup_port (core, ¶m);
gst_pad_set_element_private (self->sinkpad, self->in_port);
/* Output port configuration. */
param.nPortIndex = 1;
OMX_GetParameter (core->omx_handle, OMX_IndexParamPortDefinition, ¶m);
self->out_port = g_omx_core_setup_port (core, ¶m);
gst_pad_set_element_private (self->srcpad, self->out_port);
if (g_getenv ("OMX_ALLOCATE_ON"))
{
self->in_port->omx_allocate = TRUE;
self->out_port->omx_allocate = TRUE;
self->share_input_buffer = FALSE;
self->share_output_buffer = FALSE;
}
else if (g_getenv ("OMX_SHARE_HACK_ON"))
{
self->share_input_buffer = TRUE;
self->share_output_buffer = TRUE;
}
else if (g_getenv ("OMX_SHARE_HACK_OFF"))
{
self->share_input_buffer = FALSE;
self->share_output_buffer = FALSE;
}
}
OMX_ERRORTYPE graph::httpclntops::get_encoding_type_from_http_source ()
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
const OMX_U32 port_id = 0;
TIZ_INIT_OMX_PORT_STRUCT (port_def, port_id);
tiz_check_omx_err (
OMX_GetParameter (handles_[0], OMX_IndexParamPortDefinition, &port_def));
encoding_ = port_def.format.audio.eEncoding;
return OMX_ErrorNone;
}
OMX_U32 get_component_ports(OMX_HANDLETYPE hComponent)
{
OMX_PORT_PARAM_TYPE sPortPara;
OMX_U32 aPorts, vPorts, iPorts, oPorts;
OMX_INIT_STRUCT(&sPortPara, OMX_PORT_PARAM_TYPE);
aPorts = vPorts = iPorts = oPorts = 0;
if(OMX_ErrorNone == OMX_GetParameter(hComponent, OMX_IndexParamAudioInit, &sPortPara))
aPorts = sPortPara.nPorts;
if(OMX_ErrorNone == OMX_GetParameter(hComponent, OMX_IndexParamVideoInit, &sPortPara))
vPorts = sPortPara.nPorts;
if(OMX_ErrorNone == OMX_GetParameter(hComponent, OMX_IndexParamImageInit, &sPortPara))
iPorts = sPortPara.nPorts;
if(OMX_ErrorNone == OMX_GetParameter(hComponent, OMX_IndexParamOtherInit, &sPortPara))
oPorts = sPortPara.nPorts;
return aPorts + vPorts + iPorts + oPorts;
}
static int is_port_enabled(OMX_HANDLETYPE handle, int port)
{
OMX_PARAM_PORTDEFINITIONTYPE portdef;
OMX_INIT_STRUCTURE(portdef);
portdef.nPortIndex = port;
OERR(OMX_GetParameter(handle, OMX_IndexParamPortDefinition, &portdef));
return (portdef.bEnabled == 0 ? 0 : 1);;
}
static void init_component_handle(
const char *name,
OMX_HANDLETYPE* hComponent,
OMX_PTR pAppData,
OMX_CALLBACKTYPE* callbacks) {
OMX_ERRORTYPE r;
char fullname[32];
// Get handle
memset(fullname, 0, sizeof(fullname));
strcat(fullname, "OMX.broadcom.");
strncat(fullname, name, strlen(fullname) - 1);
//say("Initializing component %s", fullname);
if((r = OMX_GetHandle(hComponent, fullname, pAppData, callbacks)) != OMX_ErrorNone) {
omx_die(r, "Failed to get handle for component %s", fullname);
}
// Disable ports
OMX_INDEXTYPE types[] = {
OMX_IndexParamAudioInit,
OMX_IndexParamVideoInit,
OMX_IndexParamImageInit,
OMX_IndexParamOtherInit
};
OMX_PORT_PARAM_TYPE ports;
OMX_INIT_STRUCTURE(ports);
OMX_GetParameter(*hComponent, OMX_IndexParamVideoInit, &ports);
int i;
for(i = 0; i < 4; i++) {
if(OMX_GetParameter(*hComponent, types[i], &ports) == OMX_ErrorNone) {
OMX_U32 nPortIndex;
for(nPortIndex = ports.nStartPortNumber; nPortIndex < ports.nStartPortNumber + ports.nPorts; nPortIndex++) {
//say("Disabling port %d of component %s", nPortIndex, fullname);
if((r = OMX_SendCommand(*hComponent, OMX_CommandPortDisable, nPortIndex, NULL)) != OMX_ErrorNone) {
omx_die(r, "Failed to disable port %d of component %s", nPortIndex, fullname);
}
block_until_port_changed(*hComponent, nPortIndex, OMX_FALSE);
}
}
}
}
static OMX_ERRORTYPE DisableAllPorts(OMX_HANDLETYPE hComp)
{
OMX_PORT_PARAM_TYPE oPortInit;
OMX_ERRORTYPE eError = OMX_ErrorUndefined;
OMX_U32 i, d;
INIT_PARAM(oPortInit);
for (d = 0; d < 4; d++)
{
switch (d)
{
case 0:
eError = OMX_GetParameter(hComp, OMX_IndexParamOtherInit, &oPortInit);
break;
case 1:
eError = OMX_GetParameter(hComp, OMX_IndexParamAudioInit, &oPortInit);
break;
case 2:
eError = OMX_GetParameter(hComp, OMX_IndexParamVideoInit, &oPortInit);
break;
case 3:
eError = OMX_GetParameter(hComp, OMX_IndexParamImageInit, &oPortInit);
break;
default:
return OMX_ErrorUndefined;
}
if (OMX_ErrorNone == eError)
{
for (i = oPortInit.nStartPortNumber; i < oPortInit.nStartPortNumber + oPortInit.nPorts; i++)
{
eError = OMX_SendCommand(hComp, OMX_CommandPortDisable, i, 0);
if (OMX_ErrorNone != eError)
return eError;
}
}
}
return OMX_ErrorNone;
}
OMX_ERRORTYPE omxil_comp::GetParameter(OMX_INDEXTYPE nParamIndex, OMX_PTR pComponentParameterStructure) const
{
OMX_ERRORTYPE result;
result = OMX_GetParameter(comp, nParamIndex, pComponentParameterStructure);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_GetParameter failed.\n");
}
return result;
}
static int startupResizer(OMX_RESIZER *resizer, IMAGE *inImage){
OMX_PARAM_PORTDEFINITIONTYPE portdef;
int ret;
ilclient_change_component_state(resizer->component, OMX_StateIdle);
portdef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = resizer->inPort;
ret = OMX_GetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
portdef.format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
portdef.format.image.bFlagErrorConcealment = OMX_FALSE;
portdef.format.image.nFrameWidth = inImage->width;
portdef.format.image.nFrameHeight = inImage->height;
portdef.format.image.nStride = 0;
portdef.format.image.nSliceHeight = 0;
if(inImage->colorSpace == COLOR_SPACE_YUV420P)
portdef.format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
else if(inImage->colorSpace == COLOR_SPACE_RGBA)
portdef.format.image.eColorFormat = OMX_COLOR_Format32bitABGR8888;
else if(inImage->colorSpace == COLOR_SPACE_RGB16)
portdef.format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
portdef.nBufferSize=inImage->nData;
ret = OMX_SetParameter(resizer->handle, OMX_IndexParamPortDefinition, &portdef);
if (ret != OMX_ErrorNone) {
return OMX_IMAGE_ERROR_PARAMETER;
}
ret = OMX_SendCommand(resizer->handle, OMX_CommandPortEnable, resizer->inPort, NULL);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_PORTS;
}
ret = OMX_UseBuffer(resizer->handle,&resizer->pInputBufferHeader,resizer->inPort,
NULL, portdef.nBufferSize, (OMX_U8 *) inImage->pData);
if(ret != OMX_ErrorNone){
return OMX_IMAGE_ERROR_MEMORY;
}
ilclient_change_component_state(resizer->component, OMX_StateExecuting);
return OMX_IMAGE_OK;
}
OMX_ERRORTYPE Component::getParameter(OMX_INDEXTYPE paramIndex, OMX_PTR paramStruct)
{
lock();
OMX_ERRORTYPE error = OMX_GetParameter(handle, paramIndex, paramStruct);
OMX_TRACE(error);
unlock();
return error;
}
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;
}
}
OMX_ERRORTYPE graph::youtubeops::get_container_type_from_youtube_source ()
{
OMX_PARAM_PORTDEFINITIONTYPE port_def;
const OMX_U32 port_id = 0;
TIZ_INIT_OMX_PORT_STRUCT (port_def, port_id);
tiz_check_omx (
OMX_GetParameter (handles_[0], OMX_IndexParamPortDefinition, &port_def));
container_ = port_def.format.audio.eEncoding;
TIZ_LOG (TIZ_PRIORITY_DEBUG, "container_ = [%X]", container_);
return OMX_ErrorNone;
}
