bool Component::setToStateIdle()
{
bool result = false;
OMX_STATETYPE currentState;
OMX_GetState(handle, ¤tState);
if(currentState == OMX_StateIdle)
{
result = true;
}else
{
switch (currentState)
{
case OMX_StateExecuting:
{
setState(OMX_StatePause);
break;
}
default:
{
break;
}
}
setState(OMX_StateIdle);
OMX_GetState(handle, ¤tState);
if(currentState == OMX_StateIdle)
{
result = true;
}
}
ofLogVerbose(__func__) << getName() << " RESULT: " << result;
return result;
}
static void *fps(void *p)
{
enum OMX_STATETYPE state;
int lastframe;
while (1) {
lastframe = ctx.framecount;
sleep(1);
printf("Frame %6d (%5ds). Frames last second: %d \r",
ctx.framecount, ctx.framecount/25,
ctx.framecount-lastframe);
fflush(stdout);
if (0 && ctx.fps == 0) {
printf("In fps thread, after %d frames:\n",
ctx.framecount);
dumpport(ctx.m2, ctx.decportidx);
dumpport(ctx.m2, ctx.decportidx+1);
dumpport(ctx.resize, ctx.resizeportidx);
dumpport(ctx.resize, ctx.resizeportidx+1);
dumpport(ctx.m4, ctx.encportidx);
dumpport(ctx.m4, ctx.encportidx+1);
OMX_GetState(ctx.m2, &state);
printf("Decoder state: %d\n", state);
OMX_GetState(ctx.m4, &state);
printf("Encoder state: %d\n", state);
}
}
return NULL;
}
// Wait for a component to transition to the specified state
OMX_ERRORTYPE COpenMax::WaitForState(OMX_STATETYPE state)
{
OMX_ERRORTYPE omx_error = OMX_ErrorNone;
OMX_STATETYPE test_state;
int tries = 0;
struct timespec timeout;
omx_error = OMX_GetState(m_omx_decoder, &test_state);
#if defined(OMX_DEBUG_VERBOSE)
CLog::Log(LOGDEBUG, "%s::%s - waiting for state(%d)\n", CLASSNAME, __func__, state);
#endif
while ((omx_error == OMX_ErrorNone) && (test_state != state))
{
clock_gettime(CLOCK_REALTIME, &timeout);
timeout.tv_sec += 1;
sem_timedwait(m_omx_decoder_state_change, &timeout);
if (errno == ETIMEDOUT)
tries++;
if (tries > 5)
return OMX_ErrorUndefined;
omx_error = OMX_GetState(m_omx_decoder, &test_state);
}
return omx_error;
}
omx_tunnel_t *
omx_tunnel_create(omx_component_t *src, int srcport, omx_component_t *dst,
int dstport, const char *name)
{
OMX_STATETYPE state;
omxchk(OMX_GetState(src->oc_handle, &state));
if(state == OMX_StateLoaded)
omx_set_state(src, OMX_StateIdle);
omxdbg("Creating tunnel %s from %s:%d to %s:%d\n",
name, src->oc_name, srcport, dst->oc_name, dstport);
omx_send_command(src, OMX_CommandPortDisable, srcport, NULL, 1);
omx_send_command(dst, OMX_CommandPortDisable, dstport, NULL, 1);
omxchk(OMX_SetupTunnel(src->oc_handle, srcport, dst->oc_handle, dstport));
omx_send_command(src, OMX_CommandPortEnable, srcport, NULL, 0);
omx_send_command(dst, OMX_CommandPortEnable, dstport, NULL, 0);
omxchk(OMX_GetState(dst->oc_handle, &state));
if(state == OMX_StateLoaded)
omx_set_state(dst, OMX_StateIdle);
omx_tunnel_t *ot = malloc(sizeof(omx_tunnel_t));
ot->ot_src = src;
ot->ot_srcport = srcport;
ot->ot_dst = dst;
ot->ot_dstport = dstport;
ot->ot_name = name;
return ot;
}
static void Close(vlc_object_t *obj)
{
filter_t *filter = (filter_t*) obj;
filter_sys_t *sys = filter->p_sys;
unsigned int i, j;
if (sys->omx_handle) {
OMX_STATETYPE state;
OMX_GetState(sys->omx_handle, &state);
if (state == OMX_StateExecuting) {
OMX_SendCommand(sys->omx_handle, OMX_CommandStateSet,
OMX_StateIdle, 0);
while (1) {
OMX_U32 cmd, state;
WaitForSpecificOmxEvent(&sys->event_queue, OMX_EventCmdComplete,
&cmd, &state, 0);
if (cmd == OMX_CommandStateSet && state == OMX_StateIdle)
break;
}
}
OMX_GetState(sys->omx_handle, &state);
if (state == OMX_StateIdle) {
OMX_SendCommand(sys->omx_handle, OMX_CommandStateSet,
OMX_StateLoaded, 0);
for (i = 0; i < sys->num_ports; i++) {
OmxPort *port = &sys->ports[i];
for (j = 0; j < sys->ports[i].i_buffers; j++) {
OMX_BUFFERHEADERTYPE *buffer;
OMX_FIFO_GET(&port->fifo, buffer);
OMX_FreeBuffer(sys->omx_handle, port->i_port_index,
buffer);
}
}
WaitForSpecificOmxEvent(&sys->event_queue, OMX_EventCmdComplete,
0, 0, 0);
}
for (i = 0; i < sys->num_ports; i++)
free(sys->ports[i].pp_buffers);
pf_free_handle(sys->omx_handle);
DeinitOmxEventQueue(&sys->event_queue);
}
free(sys);
DeinitOmxCore();
}
OMX_ERRORTYPE ResourceExhaustionTest_TransitionWait(ResourceExhaustionTestContext* pCtxt,
OMX_STATETYPE eToState)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_BOOL bTimeout = OMX_FALSE;
OMX_STATETYPE eState;
OMX_OSAL_EventReset(pCtxt->hStateSetEvent);
pCtxt->eLastError = OMX_ErrorNone;
OMX_CONF_BAIL_IF_ERROR(OMX_GetState(pCtxt->hWComp[pCtxt->nInst], &eState));
eError = OMX_SendCommand(pCtxt->hWComp[pCtxt->nInst], OMX_CommandStateSet, eToState, 0);
OMX_CONF_BAIL_IF_ERROR(eError);
if (eToState == OMX_StateIdle && (eState == OMX_StateLoaded))
{
OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_AllocateAllBuffers(pCtxt));
}
else if (eToState == OMX_StateLoaded && eState == OMX_StateIdle)
{
OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_DeInitBuffer(pCtxt));
}
OMX_OSAL_EventWait(pCtxt->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout);
OMX_CONF_BAIL_IF_ERROR(pCtxt->eLastError);
if (bTimeout == OMX_TRUE)
OMX_CONF_SET_ERROR_BAIL("Timeout on state transition\n", OMX_ErrorUndefined);
OMX_CONF_BAIL_IF_ERROR(OMX_GetState(pCtxt->hWComp[pCtxt->nInst], &eState));
if (eState != eToState)
OMX_CONF_SET_ERROR_BAIL("Incorrect transition\n", OMX_ErrorUndefined);
OMX_CONF_TEST_BAIL:
if (OMX_ErrorNone != eError && eToState == OMX_StateIdle && (eState == OMX_StateLoaded))
{
/* Add some delay before cleaning up */
OMX_OSAL_EventWait(pCtxt->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout);
/* Disable all ports to free buffers*/
OMX_SendCommand(pCtxt->hWComp[pCtxt->nInst], OMX_CommandPortDisable, OMX_ALL, 0x0);
/* Cleanup last instance */
ResourceExhaustionTest_DeInitBuffer(pCtxt);
}
return eError;
}
status_t OMXNodeInstance::getState(OMX_STATETYPE* state) {
Mutex::Autolock autoLock(mLock);
OMX_ERRORTYPE err = OMX_GetState(mHandle, state);
return StatusFromOMXError(err);
}
OMX_ERRORTYPE process_event(HTEST *hTest, MSG *pMsg)
{
OMX_EVENTTYPE event = pMsg->data.event.eEvent;
OMX_U32 nPortIndex = pMsg->data.event.nData1;
if(event == OMX_EventPortSettingsChanged)
{
port_disable(hTest, nPortIndex);
port_enable(hTest, nPortIndex);
OMX_STATETYPE eState = OMX_StateInvalid;
OMX_GetState(hTest->hComponent, &eState);
if(eState == OMX_StateExecuting)
{
/* Send output buffers */
OMX_S32 i;
for(i=0; i<hTest->nBufferHdr[1]; i++)
{
hTest->pBufferHdr[1][i]->nFilledLen = 0;
hTest->pBufferHdr[1][i]->nOffset = 0;
OMX_FillThisBuffer(hTest->hComponent, hTest->pBufferHdr[1][i]);
}
}
}
return OMX_ErrorNone;
}
void
omx_set_state(omx_component_t *oc, OMX_STATETYPE reqstate)
{
OMX_STATETYPE state;
int attempts = 20;
omxchk(OMX_GetState(oc->oc_handle, &state));
omxdbg("Telling component '%s' to go from state %d -> to state %d\n", oc->oc_name, state, reqstate);
while(1) {
oc->oc_cmd_done = 0;
int r = OMX_SendCommand(oc->oc_handle, OMX_CommandStateSet,
reqstate, NULL);
if(r == OMX_ErrorInsufficientResources && attempts) {
usleep(10000);
attempts--;
continue;
}
if(r != 0) {
panic("OMX Setstate %s from %d to %d error 0x%x",
oc->oc_name, state, reqstate, r);
}
if(reqstate == OMX_StateExecuting)
omx_wait_command(oc);
return;
}
}
/*
* Wait for state change of variable number of handles.
* IMPORTANT : Last element should be NULL.
*/
OMX_BOOL wait_for_state_change(OMX_STATETYPE state_tobe, ...) {
va_list ap;
va_start(ap, state_tobe);
OMX_STATETYPE state_current;
OMX_HANDLETYPE pHandler = NULL;
OMX_BOOL isValid = OMX_TRUE;
while((pHandler = va_arg(ap, OMX_HANDLETYPE))) {
print_log("Waiting for 0x%08x", pHandler);
int timeout_counter = 0;
isValid = OMX_FALSE;
while(timeout_counter < 5000) {
OMX_GetState(pHandler, &state_current);
if((isValid = (state_current == state_tobe))) break;
usleep(100);
timeout_counter++;
}
if(!isValid) break;
}
va_end(ap);
return isValid;
}
OMX_BOOL isState(OMX_HANDLETYPE* hComponent, OMX_STATETYPE state) {
if(hComponent == NULL) return OMX_FALSE;
OMX_STATETYPE currentState;
OMX_GetState(hComponent, ¤tState);
return currentState == state;
}
OMX_ERRORTYPE ComponentStateTrans(
HCOMPONENT *component,
OMX_STATETYPE eState)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *hComponent = NULL;
OMX_STATETYPE eCurState = OMX_StateInvalid;
hComponent = component->hComponent;
OMX_GetState(hComponent, &eCurState);
ret = SendCommand2Component(component, OMX_CommandStateSet,eState,NULL);
if(ret != OMX_ErrorNone)
{
printf("State trans to %d failed.\n", eState);
return ret;
}
/* Loaded->Idle */
if(eCurState == OMX_StateLoaded && eState == OMX_StateIdle)
Load2Idle(component);
/* Idle->Loaded */
else if(eCurState == OMX_StateIdle && eState == OMX_StateLoaded)
Idle2Load(component);
return ret;
}
static void dumpportstate(void)
{
enum OMX_STATETYPE state;
printf("\n\nIn exit handler, after %d frames:\n", ctx.framecount);
dumpport(ctx.m2, ctx.decportidx);
dumpport(ctx.m2, ctx.decportidx+1);
dumpport(ctx.resize, ctx.resizeportidx);
dumpport(ctx.resize, ctx.resizeportidx+1);
dumpport(ctx.m4, ctx.encportidx);
dumpport(ctx.m4, ctx.encportidx+1);
OMX_GetState(ctx.m2, &state);
printf("Decoder state: %d\n", state);
OMX_GetState(ctx.m4, &state);
printf("Encoder state: %d\n", state);
}
void
omx_set_state(omx_component_t *oc, OMX_STATETYPE reqstate)
{
OMX_STATETYPE state;
omxchk(OMX_GetState(oc->oc_handle, &state));
omxdbg("Telling component '%s' to go from state %d -> to state %d\n", oc->oc_name, state, reqstate);
omx_send_command(oc, OMX_CommandStateSet, reqstate, NULL, reqstate != OMX_StateLoaded);
}
int32_t ilctts_get_state(TTSRENDER_STATE_T *st, OMX_STATETYPE *state) {
OMX_ERRORTYPE omx_err = OMX_GetState(ILC_GET_HANDLE(st->audio_render), state);
if (omx_err != OMX_ErrorNone) {
ERROR("OMX_GetState returned error in ilctts_get_state: %d", omx_err);
return -1;
}
return 0;
} // end ilctts_get_state
OMX_ERRORTYPE EnableDataFlow::configure(const ImageInfo &aThumbnailInfo,
const ImageInfo &aPreviewInfo)
{
DBGT_PROLOG("");
OMX_ERRORTYPE err = OMX_ErrorNone;
/* check whether mArmIvProc and mSwJpegEnc are in executing state or not,
* if not, send them to executing first.
* This being the case when without doing setParameters(), startPreview()
* is called. As thumbnailhandler is setup for disableDataFlow, when a
* setParameters() is done with some valid thumbnail size, enableDataFlow's
* sendComponentToExecuting() is not called leading to a deadlock.
*/
OMX_STATETYPE armIvProcState, swJpegEncState;
OMX_GetState(mArmIvProc, &armIvProcState);
OMX_GetState(mSwJpegEnc, &swJpegEncState);
if(OMX_StateExecuting != armIvProcState || OMX_StateExecuting != swJpegEncState){
err = sendComponentToExecuting();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("sendComponentToExecuting failed err = %d", err);
DBGT_EPILOG("");
return err;
}
}
err = configPorts(aThumbnailInfo, aPreviewInfo);
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("configPorts() failed err = %d", err);
DBGT_EPILOG("");
return err;
}
err = enablePorts();
if(OMX_ErrorNone != err) {
DBGT_CRITICAL("enablePorts failed err = %d", err);
DBGT_EPILOG("");
return err;
}
DBGT_EPILOG("");
return err;
}
// Some busy loops to verify we're running in order
static void block_until_state_changed(OMX_HANDLETYPE hComponent, OMX_STATETYPE wanted_eState) {
OMX_STATETYPE eState;
int i = 0;
while(i++ == 0 || eState != wanted_eState) {
OMX_GetState(hComponent, &eState);
if(eState != wanted_eState) {
usleep(10000);
}
}
}
OMX_ERRORTYPE
PureOmxPlatformLayer::GetState(OMX_STATETYPE* aType)
{
LOG("");
if (mComponent) {
return OMX_GetState(mComponent, aType);
}
return OMX_ErrorUndefined;
}
OMX_ERRORTYPE omxil_comp::GetState(OMX_STATETYPE *pState) const
{
OMX_ERRORTYPE result;
result = OMX_GetState(comp, pState);
if (result != OMX_ErrorNone) {
fprintf(stderr, "OMX_GetState failed.\n");
}
return result;
}
void CComponent::ChangeState(OMX_STATETYPE State)
{
OMX_STATETYPE CurrentState;
CHECK_OMX(OMX_GetState(m_hComponent, &CurrentState), "failed to query the current state of the component");
if (CurrentState == State)
{
return;
}
CHECK_OMX(OMX_SendCommand(m_hComponent, OMX_CommandStateSet, State, NULL), "component state transtition failed");
CHECK_VCOS(vcos_event_wait(&m_StateChangedEvent), "failed to wait for component state transition");
}
OMX_STATETYPE Component::getState()
{
lock();
OMX_STATETYPE state;
OMX_ERRORTYPE error = OMX_GetState(handle, &state);
OMX_TRACE(error);
unlock();
return state;
}
OMX_STATETYPE COMXCoreComponent::GetState()
{
if(!m_handle)
return (OMX_STATETYPE)0;
Lock();
OMX_STATETYPE state;
OMX_GetState(m_handle, &state);
UnLock();
return state;
}
static void Close(vlc_object_t *p_this)
{
vout_display_t *vd = (vout_display_t *)p_this;
vout_display_sys_t *p_sys = vd->sys;
if (p_sys->omx_handle) {
OMX_STATETYPE state;
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateExecuting) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateIdle, 0);
while (1) {
OMX_U32 cmd, state;
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, &cmd, &state, 0);
if (cmd == OMX_CommandStateSet && state == OMX_StateIdle)
break;
}
}
OMX_GetState(p_sys->omx_handle, &state);
if (state == OMX_StateIdle) {
OMX_SendCommand(p_sys->omx_handle, OMX_CommandStateSet, OMX_StateLoaded, 0);
for (unsigned int i = 0; i < p_sys->port.i_buffers; i++) {
OMX_BUFFERHEADERTYPE *p_buffer;
OMX_FIFO_GET(&p_sys->port.fifo, p_buffer);
OMX_FreeBuffer(p_sys->omx_handle, p_sys->port.i_port_index, p_buffer);
}
WaitForSpecificOmxEvent(&p_sys->event_queue, OMX_EventCmdComplete, 0, 0, 0);
}
free(p_sys->port.pp_buffers);
pf_free_handle(p_sys->omx_handle);
DeinitOmxEventQueue(&p_sys->event_queue);
OMX_FIFO_DESTROY(&p_sys->port.fifo);
}
if (p_sys->pool)
picture_pool_Release(p_sys->pool);
free(p_sys);
DeinitOmxCore();
}
ret_code_t ilcore_get_state(ilcore_comp_h h, OMX_STATETYPE *state)
{
OMX_ERRORTYPE err;
ilcore_comp_ctx_t *ctx = (ilcore_comp_ctx_t *)h;
err = OMX_GetState(ctx->handle, state);
if (err != OMX_ErrorNone)
{
DBG_E("OMX_GetState failed\n");
return L_FAILED;
}
return L_OK;
}
OMX_ERRORTYPE COMXCoreComponent::SetStateForComponent(OMX_STATETYPE state)
{
Lock();
OMX_ERRORTYPE omx_err = OMX_ErrorNone;
OMX_STATETYPE state_actual = OMX_StateMax;
if(!m_handle)
{
UnLock();
return OMX_ErrorUndefined;
}
OMX_GetState(m_handle, &state_actual);
if(state == state_actual)
{
UnLock();
return OMX_ErrorNone;
}
omx_err = OMX_SendCommand(m_handle, OMX_CommandStateSet, state, 0);
if (omx_err != OMX_ErrorNone)
{
if(omx_err == OMX_ErrorSameState)
{
omx_err = OMX_ErrorNone;
}
else
{
CLog::Log(LOGERROR, "COMXCoreComponent::SetStateForComponent - %s failed with omx_err(0x%x)\n",
m_componentName.c_str(), omx_err);
}
}
else
{
omx_err = WaitForCommand(OMX_CommandStateSet, state);
if(omx_err == OMX_ErrorSameState)
{
CLog::Log(LOGERROR, "COMXCoreComponent::SetStateForComponent - %s ignore OMX_ErrorSameState\n",
m_componentName.c_str());
UnLock();
return OMX_ErrorNone;
}
}
UnLock();
return omx_err;
}
OMX_ERRORTYPE audiosrcFillBufferDone(
OMX_OUT OMX_HANDLETYPE hComponent,
OMX_OUT OMX_PTR pAppData,
OMX_OUT OMX_BUFFERHEADERTYPE* pBuffer) {
OMX_ERRORTYPE err;
OMX_STATETYPE eState;
if(pBuffer != NULL) {
if(!bEOS) {
/** if there is volume component component in processing state then send this buffer, in non tunneled case
* else in non tunneled case, write the output buffer contents in the specified output file
*/
if(flagIsVolCompRequested && (!flagSetupTunnel)) {
OMX_GetState(appPriv->volume_handle,&eState);
if(eState == OMX_StateExecuting || eState == OMX_StatePause) {
if(pInBufferVolc[0]->pBuffer == pBuffer->pBuffer) {
pInBufferVolc[0]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->volume_handle, pInBufferVolc[0]);
} else {
pInBufferVolc[1]->nFilledLen = pBuffer->nFilledLen;
err = OMX_EmptyThisBuffer(appPriv->volume_handle, pInBufferVolc[1]);
}
if(err != OMX_ErrorNone) {
DEBUG(DEB_LEV_ERR, "In %s Error %08x Calling FillThisBuffer\n", __func__,err);
}
} else {
err = OMX_FillThisBuffer(hComponent, pBuffer);
}
} else if((pBuffer->nFilledLen > 0) && (!flagSetupTunnel)) {
fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, outfile);
pBuffer->nFilledLen = 0;
}
if(pBuffer->nFlags == OMX_BUFFERFLAG_EOS) {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Calling Empty This Buffer\n", __func__, (int)pBuffer->nFlags);
bEOS = OMX_TRUE;
}
if(!bEOS && !flagIsVolCompRequested && (!flagSetupTunnel)) {
err = OMX_FillThisBuffer(hComponent, pBuffer);
}
} else {
DEBUG(DEB_LEV_ERR, "In %s: eos=%x Dropping Empty This Buffer\n", __func__,(int)pBuffer->nFlags);
}
} else {
DEBUG(DEB_LEV_ERR, "Ouch! In %s: had NULL buffer to output...\n", __func__);
}
return OMX_ErrorNone;
}
void printState() {
OMX_STATETYPE state;
err = OMX_GetState(handle, &state);
if (err != OMX_ErrorNone) {
fprintf(stderr, "Error on getting state\n");
exit(1);
}
switch (state) {
case OMX_StateLoaded: fprintf(stderr, "StateLoaded\n"); break;
case OMX_StateIdle: fprintf(stderr, "StateIdle\n"); break;
case OMX_StateExecuting: fprintf(stderr, "StateExecuting\n"); break;
case OMX_StatePause: fprintf(stderr, "StatePause\n"); break;
case OMX_StateWaitForResources: fprintf(stderr, "StateWiat\n"); break;
default: fprintf(stderr, "State unknown\n"); break;
}
}
static gboolean
goo_ti_clock_load (GooComponent* self)
{
GOO_OBJECT_LOCK (self);
RETURN_GOO_RUN (
OMX_GetHandle (&self->handle, self->id, self,
&self->callbacks)
);
GOO_RUN (
OMX_GetState (self->handle, &self->cur_state)
);
GOO_OBJECT_UNLOCK (self);
GOO_OBJECT_DEBUG (self, "");
return TRUE;
}
void printState(OMX_HANDLETYPE handle) {
OMX_STATETYPE state;
OMX_ERRORTYPE err;
err = OMX_GetState(handle, &state);
if (err != OMX_ErrorNone) {
fprintf(stderr, "Error on getting state\n");
exit(1);
}
switch (state) {
case OMX_StateLoaded: printf("StateLoaded\n"); break;
case OMX_StateIdle: printf("StateIdle\n"); break;
case OMX_StateExecuting: printf("StateExecuting\n"); break;
case OMX_StatePause: printf("StatePause\n"); break;
case OMX_StateWaitForResources: printf("StateWait\n"); break;
case OMX_StateInvalid: printf("StateInvalid\n"); break;
default: printf("State unknown\n"); break;
}
}
OMX_ERRORTYPE ResourceExhaustionTest_LOAD(ResourceExhaustionTestContext *pCtxt,
OMX_STRING cComponentName,
OMX_PTR pWAppData,
OMX_PTR pWCallbacks)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_STATETYPE eState;
eError = OMX_GetHandle(&pCtxt->hComp[pCtxt->nInst], cComponentName, pWAppData, pWCallbacks);
OMX_CONF_BAIL_IF_ERROR(eError);
eError = OMX_CONF_ComponentTracerCreate(pCtxt->hComp[pCtxt->nInst], cComponentName,
&pCtxt->hWComp[pCtxt->nInst]);
OMX_CONF_BAIL_IF_ERROR(eError);
eError = OMX_GetState(pCtxt->hWComp[pCtxt->nInst], &eState);
OMX_CONF_BAIL_IF_ERROR(eError);
if (eState != OMX_StateLoaded)
OMX_CONF_SET_ERROR_BAIL("Not in loaded state\n", OMX_ErrorUndefined);
OMX_CONF_TEST_BAIL:
return eError;
}
