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; }