OMX_ERRORTYPE PortCommTest_TransmitTest(PortCommTestCtxt* pContext, OMX_BOOL bInit, OMX_BOOL bClose) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_BOOL bTimeout; if (bInit) { OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, OpenFile)); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateIdle, pContext)); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateExecuting, pContext)); } /* process buffers */ while (pContext->nBufDoneCalls < OMX_CONF_BUFFERS_OF_TRAFFIC) { if (pContext->nOutBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_ReadOutBuffers(pContext)); if (pContext->nInBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_WriteInBuffers(pContext)); /* if no empty input or output buffer, wait for bufferdone call */ if (pContext->nOutBuf == pContext->nOutBufBusy && pContext->nInBuf == pContext->nInBufBusy) { OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("Component is not processing any buffers\n", OMX_ErrorUndefined); } } } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Processed %d buffers\n", pContext->nBufDoneCalls); if (bClose) { OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, CloseFile)); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateIdle, pContext)); while (pContext->nOutBufBusy || pContext->nInBufBusy) { OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("All buffers not returned\n", OMX_ErrorUndefined); } } OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateLoaded, pContext)); } pContext->nBufDoneCalls = 0; OMX_CONF_TEST_BAIL: return eError; }
OMX_ERRORTYPE PortCommTest_TransitionWait(OMX_STATETYPE eToState, PortCommTestCtxt* pContext) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_BOOL bTimeout = OMX_FALSE; OMX_OSAL_EventReset(pContext->hStateSetEvent); eError = OMX_SendCommand(pContext->hWComp, OMX_CommandStateSet, eToState, 0); OMX_CONF_BAIL_IF_ERROR(eError); if (eToState == OMX_StateIdle && (pContext->eState == OMX_StateLoaded)) { OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, AllocBuf)); } else if (eToState == OMX_StateLoaded && pContext->eState == OMX_StateIdle) { OMX_CONF_BAIL_IF_ERROR(PortCommTest_DeInitBuffer(pContext)); } OMX_OSAL_EventWait(pContext->hStateSetEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (bTimeout == OMX_TRUE) OMX_CONF_SET_ERROR_BAIL("Transition timed out\n", OMX_ErrorUndefined); if (pContext->eState != eToState) OMX_CONF_SET_ERROR_BAIL("Incorrect transition\n", OMX_ErrorUndefined); OMX_CONF_TEST_BAIL: return eError; }
OMX_ERRORTYPE PortCommTest_PauseResume(PortCommTestCtxt* pContext) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_BOOL bTimeout; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pContext, OMX_TRUE, OMX_FALSE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Pause the component\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StatePause, pContext)); OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("bufferdone callbacks made after pause cmdcomplete\n", OMX_ErrorUndefined); } pContext->nBufDoneCalls = 0; OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Attempting to process buffers while paused\n"); OMX_OSAL_EventReset(pContext->hBufDoneEvent); if (pContext->nOutBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_ReadOutBuffers(pContext)); if (pContext->nInBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_WriteInBuffers(pContext)); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("bufferdone callbacks made during paused state\n", OMX_ErrorUndefined); } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Processed %d buffers\n", pContext->nBufDoneCalls); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Return to executing\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateExecuting, pContext)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Process buffers after resuming\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pContext, OMX_FALSE, OMX_TRUE)); OMX_CONF_TEST_BAIL: return eError; }
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; }
OMX_ERRORTYPE PortCommTest_RepackTest(PortCommTestCtxt* pContext) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_BOOL bTimeout; OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, OpenFile)); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateIdle, pContext)); if (pContext->nInBuf == 0) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Source component, Repack Test not applicable\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, CloseFile)); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateLoaded, pContext)); goto OMX_CONF_TEST_BAIL; } OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransitionWait(OMX_StateExecuting, pContext)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Sending single byte payloads\n"); pContext->nBufFactor = 0; OMX_OSAL_EventReset(pContext->hEmptyBufDoneEvent); if (pContext->nOutBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_ReadOutBuffers(pContext)); if (pContext->nInBuf) OMX_CONF_BAIL_IF_ERROR(PortCommTest_WriteInBuffers(pContext)); OMX_OSAL_EventWait(pContext->hEmptyBufDoneEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (pContext->nOutBuf && OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("Component is not repacking\n", OMX_ErrorUndefined); } if (pContext->nInBuf && !pContext->pInBufferList->pBufHdr) { OMX_CONF_SET_ERROR_BAIL("first buffer has to be returned\n", OMX_ErrorUndefined); } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Sending full payloads\n"); pContext->nBufFactor = 1; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pContext, OMX_FALSE, OMX_TRUE)); OMX_CONF_TEST_BAIL: return eError; }
OMX_ERRORTYPE OMX_CONF_BufferTest(OMX_IN OMX_STRING cComponentName) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_ERRORTYPE eCleanupError = OMX_ErrorNone; TEST_CTXTYPE ctx; TEST_CTXTYPE *pCtx; OMX_HANDLETYPE hComp = 0x0; OMX_CALLBACKTYPE oCallbacks; OMX_HANDLETYPE hWrappedComp = 0x0; OMX_CALLBACKTYPE *pWrappedCallbacks; OMX_PTR pWrappedAppData; OMX_BOOL bTimeout; TEST_PORTTYPE *pPort; OMX_U32 i; OMX_U32 nPortIndex; OMX_PARAM_PORTDEFINITIONTYPE sPortDefinition; oCallbacks.EventHandler = BufferTest_EventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; pCtx = &ctx; pCtx->hStateChangeEvent = 0x0; pCtx->hPortDisableEvent = 0x0; pCtx->hPortEnableEvent = 0x0; pCtx->hPortErrorEvent = 0x0; pCtx->aPorts = 0x0; pCtx->bRestartAllPorts = OMX_FALSE; pCtx->bStopAllPorts = OMX_FALSE; /* initialize events to track callbacks */ OMX_OSAL_EventCreate(&pCtx->hStateChangeEvent); OMX_OSAL_EventReset(pCtx->hStateChangeEvent); OMX_OSAL_EventCreate(&pCtx->hPortDisableEvent); OMX_OSAL_EventReset(pCtx->hPortDisableEvent); OMX_OSAL_EventCreate(&pCtx->hPortEnableEvent); OMX_OSAL_EventReset(pCtx->hPortEnableEvent); OMX_OSAL_EventCreate(&pCtx->hPortErrorEvent); OMX_OSAL_EventReset(pCtx->hPortErrorEvent); eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR)pCtx, cComponentName, &pWrappedCallbacks, &pWrappedAppData); OMX_CONF_BAIL_ON_ERROR(eError); /* Initialize OpenMax */ eError = OMX_Init(); OMX_CONF_BAIL_ON_ERROR(eError); eError = OMX_GetHandle(&hComp, cComponentName, pWrappedAppData, pWrappedCallbacks); OMX_CONF_BAIL_ON_ERROR(eError); eError = OMX_CONF_ComponentTracerCreate(hComp, cComponentName, &hWrappedComp); OMX_CONF_BAIL_ON_ERROR(eError); pCtx->hWrappedComp = hWrappedComp; OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected all port on component %s\n", cComponentName); /* inspect component's ports */ OMX_CONF_INIT_STRUCT(pCtx->sPortParam[0], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(hWrappedComp, OMX_IndexParamAudioInit, (OMX_PTR) & pCtx->sPortParam[0]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i audio ports starting at %i \n", pCtx->sPortParam[0].nPorts, pCtx->sPortParam[0].nStartPortNumber); /* detect all video ports on the component */ OMX_CONF_INIT_STRUCT(pCtx->sPortParam[1], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(hWrappedComp, OMX_IndexParamVideoInit, (OMX_PTR) & pCtx->sPortParam[1]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i video ports starting at %i \n", pCtx->sPortParam[1].nPorts, pCtx->sPortParam[1].nStartPortNumber); /* detect all image ports on the component */ OMX_CONF_INIT_STRUCT(pCtx->sPortParam[2], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(hWrappedComp, OMX_IndexParamImageInit, (OMX_PTR) & pCtx->sPortParam[2]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i image ports starting at %i \n", pCtx->sPortParam[2].nPorts, pCtx->sPortParam[2].nStartPortNumber); /* detect all other ports on the component */ OMX_CONF_INIT_STRUCT(pCtx->sPortParam[3], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(hWrappedComp, OMX_IndexParamOtherInit, (OMX_PTR) & pCtx->sPortParam[3]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i other ports starting at %i \n", pCtx->sPortParam[3].nPorts, pCtx->sPortParam[3].nStartPortNumber); /* record total number of ports and allocate port structures */ pCtx->nNumPorts = pCtx->sPortParam[0].nPorts + pCtx->sPortParam[1].nPorts + pCtx->sPortParam[2].nPorts + pCtx->sPortParam[3].nPorts; if (0x0 == pCtx->nNumPorts) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Component has no ports\n"); } /* allocate port structures */ eError = BufferTest_AllocatePortStructures(pCtx); OMX_CONF_BAIL_ON_ERROR(eError); /* transition component to idle, verifying that the component does not go to IDLE within a certain timeout */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command component to OMX_StateIdle\n"); OMX_OSAL_EventReset(pCtx->hStateChangeEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); /* allocate some buffers on the ports, vertifying the component does not transition to idle */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Allocate some buffers on all ports\n"); eError = BufferTest_AllocateAllButOne(pCtx); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Unexpected state transition to OMX_StateIdle\n"); } /* allocate all buffers on the ports, vertifying the component does transition to idle */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Allocate remaining buffers on all ports\n"); eError = BufferTest_AllocateAllPlusOne(pCtx); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "State transition to OMX_StateIdle never occured\n"); } /* transition the component to from idle to loaded, verifying the component does not transition */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command component to OMX_StateLoaded\n"); OMX_OSAL_EventReset(pCtx->hStateChangeEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateLoaded, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); /* free some buffers */ eError = BufferTest_FreeAllButOne(pCtx); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Unexpected state transition to OMX_StateLoaded\n"); } /* free all buffers and confirm component transitions to loaded */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Free buffers on all ports\n"); eError = BufferTest_FreeAll(pCtx); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Expected state transition to OMX_StateLoaded\n"); } /* stop all ports */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command all ports to disabled\n"); pCtx->bStopAllPorts = OMX_TRUE; pCtx->nNumPortsStopped = 0x0; OMX_OSAL_EventReset(pCtx->hPortDisableEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortDisable, OMX_ALL, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortDisableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "All ports not disabled\n"); } pCtx->bStopAllPorts = OMX_FALSE; /* set the component to idle */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command component to OMX_StateIdle\n"); OMX_OSAL_EventReset(pCtx->hStateChangeEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Expected state transition to OMX_StateIdle\n"); } pPort = pCtx->aPorts; for (i = 0; i < pCtx->nNumPorts; i++) { /* verify port enable and populated status */ nPortIndex = pPort->sPortDef.nPortIndex; OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); /* enable port, and verify it does not restart */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command port %i to enabled\n", nPortIndex); OMX_OSAL_EventReset(pCtx->hPortEnableEvent); pCtx->nRestartPort = nPortIndex; eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortEnable, nPortIndex, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortEnableEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port enabled unexpectedly\n"); } /* verify port enabled, but not populated */ OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_TRUE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); /* allocate buffers on the port, and verify it restarts */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Allocate buffers on port %i\n", nPortIndex); eError = BufferTest_PortAllocateNumBuffers(pCtx, pPort, (pPort->sPortDef.nBufferCountActual)); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortEnableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port never enabled\n"); } /* verify port enabled and populated */ OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_TRUE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_TRUE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); /* stop port, verifying it does not stop */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command port %i to disabled\n", nPortIndex); OMX_OSAL_EventReset(pCtx->hPortDisableEvent); pCtx->nStopPort = nPortIndex; eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortDisable, nPortIndex, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortDisableEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port disabled unexpectedly\n"); } /* free buffers on the port, verifying it stops */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Free buffers on port %i\n", nPortIndex); eError = BufferTest_PortFreeNumBuffers(pCtx, pPort, LIFO_INQUEUE(pPort->pLifo)); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortDisableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port never disabled\n"); } /* verify port not enabled, not populated */ OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); /* enable the port and allocate buffers */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command port %i to enabled\n", nPortIndex); OMX_OSAL_EventReset(pCtx->hPortEnableEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortEnable, nPortIndex, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Allocate buffers on port %i\n", nPortIndex); eError = BufferTest_PortAllocateNumBuffers(pCtx, pPort, (pPort->sPortDef.nBufferCountActual)); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortEnableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port never enabled\n"); } /* test the port errors when buffers are freed */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Free buffers on port %i\n", nPortIndex); OMX_OSAL_EventReset(pCtx->hPortErrorEvent); eError = BufferTest_PortFreeNumBuffers(pCtx, pPort, LIFO_INQUEUE(pPort->pLifo)); OMX_CONF_BAIL_ON_ERROR(eError); /* waiting for component to report error due to lost buffers */ OMX_OSAL_EventWait(pCtx->hPortErrorEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Component did not report OMX_ErrorPortUnpopulated\n"); } /* verify port enabled, but not populated */ OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_TRUE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); /* stop the port */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command port %i to disabled\n", nPortIndex); OMX_OSAL_EventReset(pCtx->hPortDisableEvent); pCtx->nStopPort = nPortIndex; eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortDisable, nPortIndex, 0x0); OMX_OSAL_EventWait(pCtx->hPortDisableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Port never disabled\n"); } /* verify port not enabled, but not populated */ OMX_CONF_INIT_STRUCT(sPortDefinition, OMX_PARAM_PORTDEFINITIONTYPE); sPortDefinition.nPortIndex = nPortIndex; eError = OMX_GetParameter(pCtx->hWrappedComp, OMX_IndexParamPortDefinition, (OMX_PTR) & sPortDefinition); OMX_CONF_BAIL_ON_ERROR(eError); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bEnabled), "Incorrect value in PortDefinition bEnabled field\n"); OMX_CONF_ASSERT(eError, (OMX_FALSE == sPortDefinition.bPopulated), "Incorrect value in PortDefinition bPopulated field\n"); pPort++; } /* transition component from idle to loaded */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command component to OMX_StateLoaded\n"); OMX_OSAL_EventReset(pCtx->hStateChangeEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateLoaded, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "Expected state transition to OMX_StateLoaded\n"); } /* restart all ports */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Command all ports to enable\n"); pCtx->bRestartAllPorts = OMX_TRUE; pCtx->nNumPortsRestarted = 0x0; OMX_OSAL_EventReset(pCtx->hPortEnableEvent); eError = OMX_SendCommand(hWrappedComp, OMX_CommandPortEnable, OMX_ALL, 0x0); OMX_CONF_BAIL_ON_ERROR(eError); OMX_OSAL_EventWait(pCtx->hPortEnableEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, "All ports not enabled\n"); } pCtx->bRestartAllPorts = OMX_FALSE; OMX_CONF_TEST_BAIL: eCleanupError = BufferTest_FreePortStructures(pCtx); if (hWrappedComp) { OMX_CONF_ComponentTracerDestroy(hWrappedComp); } if (hComp) { if (OMX_ErrorNone == eCleanupError) { eCleanupError = OMX_FreeHandle(hComp); } else { OMX_FreeHandle(hComp); } } if (OMX_ErrorNone != eCleanupError) { OMX_Deinit(); } else { eCleanupError = OMX_Deinit(); } OMX_OSAL_EventDestroy(pCtx->hStateChangeEvent); OMX_OSAL_EventDestroy(pCtx->hPortDisableEvent); OMX_OSAL_EventDestroy(pCtx->hPortEnableEvent); OMX_OSAL_EventDestroy(pCtx->hPortErrorEvent); if (OMX_ErrorNone == eError) { /* if there were no failures during the test, report any errors found during cleanup */ eError = eCleanupError; } return(eError); }
OMX_ERRORTYPE OMX_CONF_WaitForResourcesTest(OMX_IN OMX_STRING cComponentName) { /* Interop test 4.7: Wait For Resources */ /* --------------------------------------- * 1. Load component * 2. Transition to idle * 3. Repeat from steps 1-3 until transition to idle returns * OMX_ErrorInsufficientResources and transitions to Wait state * 4. Switch one of the previous components to the loaded state to free resources * 5. Verify the component in the WaitForResources state transitions to idle */ OMX_HANDLETYPE hComp[1000]; OMX_U32 i, nComp = 0; OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_CALLBACKTYPE oCallbacks; OMXWFRTESTDATA oAppData[1000]; OMX_STATETYPE eState = OMX_StateLoaded; OMX_BOOL bTimeout = OMX_FALSE; OMX_PRIORITYMGMTTYPE oPriority; OMX_HANDLETYPE hTraceComp[1000]; OMX_HANDLETYPE hEventStateChange; OMX_ERRORTYPE eErrorCleanup; OMX_PTR pWrappedAppData[1000]; OMX_CALLBACKTYPE *pWrappedCallbacks[1000]; char szInstantiationName[256]; /* Initialize data */ oCallbacks.EventHandler = WaitResEventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; /* Begin test */ eError = OMX_Init(); if (OMX_ErrorNone != eError) return OMX_ErrorUndefined; hEventStateChange = 0; hEventStateChangeIdle = 0; hEventStateChangeLoaded = 0; eError = OMX_OSAL_EventCreate(&hEventStateChange); OMX_CONF_FAIL_IF_ERROR(eError); eError = OMX_OSAL_EventCreate(&hEventStateChangeIdle); OMX_CONF_FAIL_IF_ERROR(eError); eError = OMX_OSAL_EventCreate(&hEventStateChangeLoaded); OMX_CONF_FAIL_IF_ERROR(eError); INIT_PARAM(oPriority); oPriority.nGroupPriority = OMX_RESOURCETEST_PRIORITY_LOW; oPriority.nGroupID = 1; nComp = 0; do { hComp[nComp] = hTraceComp[nComp] = NULL; GetInstantiationName(cComponentName, nComp, szInstantiationName); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Trying to create and idle instantiation %i (priority = %i)\n", nComp, OMX_RESOURCETEST_PRIORITY_LOW); if (nComp >= 1000) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Test unable to complete. Too many components requested (%d)\n", nComp); eError = OMX_ErrorUndefined; goto OMX_CONF_TEST_FAIL; } oAppData[nComp].bErrorInsufficientResources = OMX_FALSE; oAppData[nComp].hEventStateChange = hEventStateChange; oAppData[nComp].nInstantiation = nComp; eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR) & oAppData[nComp], szInstantiationName, &pWrappedCallbacks[nComp], &pWrappedAppData[nComp]); OMX_CONF_FAIL_IF_ERROR(eError); hComp[nComp] = NULL; eError = OMX_GetHandle(&hComp[nComp], cComponentName, pWrappedAppData[nComp], pWrappedCallbacks[nComp]); OMX_CONF_FAIL_IF_ERROR(eError); /* Problem acquiring handle. bail. */ eError = OMX_CONF_ComponentTracerCreate(hComp[nComp], szInstantiationName, &hTraceComp[nComp]); OMX_CONF_FAIL_IF_ERROR(eError); /* Set priority and transition to idle */ eError = OMX_SetParameter(hTraceComp[nComp], OMX_IndexParamPriorityMgmt, &oPriority); OMX_CONF_FAIL_IF_ERROR(eError); /* Disable all ports so we can go idle without buffers */ eError = DisableAllPorts(hTraceComp[nComp]); OMX_CONF_FAIL_IF_ERROR(eError); eError = OMX_SendCommand(hTraceComp[nComp], OMX_CommandStateSet, OMX_StateIdle, 0); OMX_CONF_FAIL_IF_ERROR(eError); OMX_OSAL_EventWait(hEventStateChange, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (bTimeout == OMX_TRUE) { eError = OMX_ErrorTimeout; goto OMX_CONF_TEST_FAIL; } OMX_OSAL_EventReset(hEventStateChange); eError = OMX_GetState(hTraceComp[nComp], &eState); OMX_CONF_FAIL_IF_ERROR(eError); nComp++; } while (!oAppData[nComp-1].bErrorInsufficientResources); nComp--; /* check that the last try stayed in loaded because of insufficient resources */ if ((eState != OMX_StateLoaded) || !oAppData[nComp].bErrorInsufficientResources) { eError = OMX_ErrorUndefined; goto OMX_CONF_TEST_FAIL; } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Instantiation %i failed to idle (insuffient resources)\n", nComp); /* tell last try it to wait for resources */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Telling instantiation %i to wait for resources\n", nComp); OMX_OSAL_EventReset(hEventStateChange); OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hTraceComp[nComp], OMX_CommandStateSet, OMX_StateWaitForResources, 0)); OMX_OSAL_EventWait(hEventStateChange, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (bTimeout == OMX_TRUE) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: Timed out waiting for state change from instantiation %i\n", nComp); eError = OMX_ErrorTimeout; goto OMX_CONF_TEST_FAIL; } OMX_CONF_FAIL_IF_ERROR(OMX_GetState(hTraceComp[nComp], &eState)); if (eState != OMX_StateWaitForResources) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: State of instantiation %i is not OMX_StateWaitForResources\n", nComp); eError = OMX_ErrorUndefined; goto OMX_CONF_TEST_FAIL; } /* transition first try to loaded */ OMX_OSAL_EventReset(hEventStateChange); OMX_OSAL_EventReset(hEventStateChangeIdle); OMX_OSAL_EventReset(hEventStateChangeLoaded); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Telling instantiation 0 to go to loaded\n", nComp); OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hTraceComp[0], OMX_CommandStateSet, OMX_StateLoaded, 0)); OMX_OSAL_EventWait(hEventStateChangeLoaded, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (bTimeout == OMX_TRUE) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: Timed out waiting for state change from instantiation 0\n"); eError = OMX_ErrorTimeout; goto OMX_CONF_TEST_FAIL; } OMX_CONF_FAIL_IF_ERROR(OMX_GetState(hTraceComp[0], &eState)); if (eState != OMX_StateLoaded) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: State of instantiation 0 is not OMX_StateLoaded\n"); eError = OMX_ErrorUndefined; goto OMX_CONF_TEST_FAIL; } /* wait for last try to get resources */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Waiting for instantiation %i to go to idle\n", nComp); OMX_OSAL_EventWait(hEventStateChangeIdle, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); if (bTimeout == OMX_TRUE) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: Timed out waiting for state change from instantiation %i\n", nComp); eError = OMX_ErrorTimeout; goto OMX_CONF_TEST_FAIL; } OMX_CONF_FAIL_IF_ERROR(OMX_GetState(hTraceComp[nComp], &eState)); if (eState != OMX_StateIdle) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: State of instantiation %i is not OMX_StateIdle\n", nComp); eError = OMX_ErrorUndefined; goto OMX_CONF_TEST_FAIL; } OMX_CONF_TEST_FAIL: /* Cleanup */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Cleaning up\n"); for (i = 1;i <= nComp;i++) { OMX_ERRORTYPE eErrorCleanup; if (hTraceComp[i] != NULL) { OMX_OSAL_EventReset(hEventStateChange); eErrorCleanup = OMX_SendCommand(hTraceComp[i], OMX_CommandStateSet, OMX_StateLoaded, 0); if (OMX_ErrorNone == eErrorCleanup) { OMX_OSAL_EventWait(hEventStateChange, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimeout); } } } for (i = 0;i <= nComp;i++) { OMX_OSAL_EventReset(hEventStateChange); OMX_OSAL_EventWait(hEventStateChange, 20, &bTimeout); if (hComp[i] != NULL) eErrorCleanup = OMX_FreeHandle(hComp[i]); } for (i = 0;i <= nComp;i++) { /* unset trace component */ if (hTraceComp[i] != NULL) OMX_CONF_ComponentTracerDestroy(hTraceComp[i]); } for (i = 0;i <= nComp;i++) { OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks[i], pWrappedAppData[i]); } if (hEventStateChange) { OMX_OSAL_EventDestroy(hEventStateChange); } if (hEventStateChangeIdle) { OMX_OSAL_EventDestroy(hEventStateChangeIdle); } if (hEventStateChangeLoaded) { OMX_OSAL_EventDestroy(hEventStateChangeLoaded); } OMX_Deinit(); return eError; }
OMX_ERRORTYPE OMX_CONF_ResourceExhaustionTest(OMX_IN OMX_STRING cComponentName) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_CALLBACKTYPE oCallbacks; ResourceExhaustionTestContext oAppData; OMX_CALLBACKTYPE *pWrapCallbacks; OMX_PTR pWrapAppData; ResourceExhaustionTestContext *pCtxt; OMX_U32 i; pCtxt = &oAppData; memset(pCtxt, 0x0, sizeof(ResourceExhaustionTestContext)); oCallbacks.EventHandler = ResourceExhaustionTest_EventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR)pCtxt, cComponentName, &pWrapCallbacks, &pWrapAppData); OMX_OSAL_EventCreate(&pCtxt->hStateSetEvent); OMX_OSAL_EventReset(pCtxt->hStateSetEvent); /* Initialize OpenMax */ eError = OMX_Init(); OMX_CONF_BAIL_IF_ERROR(eError); eError = ResourceExhaustionTest_LOAD(pCtxt, cComponentName, pWrapAppData, pWrapCallbacks); OMX_CONF_BAIL_IF_ERROR(eError); /* detect all audio ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[0], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp[pCtxt->nInst], OMX_IndexParamAudioInit, (OMX_PTR) & pCtxt->sPortParam[0]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i audio ports starting at %i \n", pCtxt->sPortParam[0].nPorts, pCtxt->sPortParam[0].nStartPortNumber); /* detect all video ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[1], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp[pCtxt->nInst], OMX_IndexParamVideoInit, (OMX_PTR) & pCtxt->sPortParam[1]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i video ports starting at %i \n", pCtxt->sPortParam[1].nPorts, pCtxt->sPortParam[1].nStartPortNumber); /* detect all image ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[2], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp[pCtxt->nInst], OMX_IndexParamImageInit, (OMX_PTR) & pCtxt->sPortParam[2]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i image ports starting at %i \n", pCtxt->sPortParam[2].nPorts, pCtxt->sPortParam[2].nStartPortNumber); /* detect all other ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[3], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp[pCtxt->nInst], OMX_IndexParamOtherInit, (OMX_PTR) & pCtxt->sPortParam[3]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i other ports starting at %i \n", pCtxt->sPortParam[3].nPorts, pCtxt->sPortParam[3].nStartPortNumber); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateIdle)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Repeatedly load and idle component\n"); /* JVW-NVIDIA: set bound to MAX_INSTANCE-1 http://cvs.khronos.org/bugzilla/show_bug.cgi?id=219 */ while (pCtxt->nInst++ < MAX_INSTANCE - 1) { eError = ResourceExhaustionTest_LOAD(pCtxt, cComponentName, pWrapAppData, pWrapCallbacks); if (eError != OMX_ErrorNone) break; eError = ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateIdle); if (eError != OMX_ErrorNone) break; } if (eError == OMX_ErrorInsufficientResources) eError = OMX_ErrorNone; if (pCtxt->nInst == MAX_INSTANCE) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Resources not exhausted - increase max instance\n"); eError = OMX_ErrorUndefined; } OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Resources exhausted by instance %d\n", pCtxt->nInst); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Alternatively de-allocate/allocate last 2 instances\n"); for (i = 0x0; i < MAX_ITERATIONS; i++) { /* Unload last successfully idled instance */ pCtxt->nInst--; OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateLoaded)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_UNLOAD(pCtxt)); /* Load last failing instance */ pCtxt->nInst++; OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_UNLOAD(pCtxt)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_LOAD(pCtxt, cComponentName, pWrapAppData, pWrapCallbacks)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateIdle)); /* Unload last successfully idled instance */ OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateLoaded)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_UNLOAD(pCtxt)); /* Load last failing instance */ pCtxt->nInst--; OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_LOAD(pCtxt, cComponentName, pWrapAppData, pWrapCallbacks)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateIdle)); pCtxt->nInst++; } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "De-allocate all instances\n"); while (pCtxt->nInst--) { OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateLoaded)); OMX_CONF_BAIL_IF_ERROR(ResourceExhaustionTest_UNLOAD(pCtxt)); } OMX_CONF_TEST_BAIL: /* cleanup: return function errors rather than closing errors if appropriate */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Cleanup\n"); if (OMX_ErrorNone == eError) { eError = OMX_CONF_CallbackTracerDestroy(pWrapCallbacks, pWrapAppData); eError = OMX_Deinit(); } else { do { if (pCtxt->hWComp[pCtxt->nInst]) { ResourceExhaustionTest_TransitionWait(pCtxt, OMX_StateInvalid); ResourceExhaustionTest_DeInitBuffer(pCtxt); ResourceExhaustionTest_UNLOAD(pCtxt); } } while (pCtxt->nInst--); OMX_CONF_CallbackTracerDestroy(pWrapCallbacks, pWrapAppData); OMX_Deinit(); } OMX_OSAL_EventDestroy(pCtxt->hStateSetEvent); return eError; }
/* Main entrypoint into the Incomplete Stop Test */ OMX_ERRORTYPE OMX_CONF_IncompleteStopTest(OMX_IN OMX_STRING cComponentName) { OMX_PTR pWrappedAppData; OMX_CALLBACKTYPE *pWrappedCallbacks; OMX_HANDLETYPE hComp, hWrappedComp, hTTComp, hWrappedTTComp; OMX_ERRORTYPE eTemp, eError = OMX_ErrorNone; OMX_CALLBACKTYPE oCallbacks; ISTDATATYPE oAppData; OMX_BOOL bTimedOut; /* create state change event */ OMX_OSAL_EventCreate(&oAppData.hStateChangeEvent); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_OSAL_EventCreate(&oAppData.hEOSEvent); OMX_OSAL_EventReset(oAppData.hEOSEvent); /* init component handles */ hComp = hWrappedComp = hTTComp = hWrappedTTComp = 0; oCallbacks.EventHandler = ISTEventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR) & oAppData, cComponentName, &pWrappedCallbacks, &pWrappedAppData); /* Initialize OpenMax */ eError = OMX_Init(); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Creating component under test and tunnel test component.\n"); /* Acquire component under test handle */ OMX_CONF_FAIL_IF_ERROR(OMX_GetHandle(&hComp, cComponentName, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hComp, cComponentName, &hWrappedComp)); oAppData.hCUT = hComp; /* Acquire tunnel test component handle */ OMX_CONF_FAIL_IF_ERROR(OMX_CONF_GetTunnelTestComponentHandle(&hTTComp, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hTTComp, "OMX.CONF.tunnel.test", &hWrappedTTComp)); /* Connect CUT to TTC */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Connecting all ports.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_TTCConnectAllPorts(hWrappedTTComp, hWrappedComp)); /* Force all CUT ports to be suppliers */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Forcing all component ports to be suppliers.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ForceSuppliers(hWrappedComp, OMX_TRUE)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ForceSuppliers(hWrappedTTComp, OMX_FALSE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transitioning to executing.\n"); /* transition CUT to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* transition TTC to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* transition CUT to executing */ OMX_CONF_FAIL_IF_ERROR(ISTWaitForState(&oAppData, OMX_StateIdle)); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateExecuting, 0)); OMX_CONF_FAIL_IF_ERROR(ISTWaitForState(&oAppData, OMX_StateExecuting)); /* transition TTC to executing */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateExecuting, 0)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_WaitForBufferTraffic(hTTComp)); /* tell TTC to hold buffers */ TTCHoldBuffers(hTTComp); /* transition CUT to back to idle */ OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* wait for change to idle - this must time out */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Holding outstanding buffers, waiting for transition to idle.\n"); OMX_OSAL_EventWait(oAppData.hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimedOut); if (!bTimedOut) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: Transitioned to idle.\n"); eError = OMX_ErrorUndefined; } else { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-OK: Didn't transitioned to idle.\n"); } /* tell TTC to release buffers */ TTCReleaseBuffers(hTTComp); /* wait for change to idle - this must succeed */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Released outstanding buffers, waiting for transition to idle.\n"); OMX_OSAL_EventWait(oAppData.hStateChangeEvent, OMX_CONF_TIMEOUT_EXPECTING_SUCCESS, &bTimedOut); if (bTimedOut || oAppData.eState != OMX_StateIdle) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-ERROR: Didn't transition to idle.\n"); eError = OMX_ErrorUndefined; } else { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-OK: Transitioned to idle.\n"); } OMX_CONF_TEST_FAIL: /* Cleanup: Return function errors rather than closing errors if appropriate */ /* transition CUT to Loaded state */ if (hWrappedComp) { OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); } /* transition TTC to Loaded state */ if (hWrappedTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateIdle, 0)); OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); } OMX_CONF_REMEMBER_ERROR(ISTWaitForState(&oAppData, OMX_StateLoaded)); /* destroy state change event */ OMX_OSAL_EventDestroy(oAppData.hStateChangeEvent); OMX_OSAL_EventDestroy(oAppData.hEOSEvent); if (hWrappedComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedComp)); } if (hComp) { OMX_CONF_REMEMBER_ERROR(OMX_FreeHandle(hComp)); } if (hTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_FreeTunnelTestComponentHandle(hTTComp)); OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedTTComp)); } OMX_CONF_REMEMBER_ERROR(OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks, pWrappedAppData)); OMX_CONF_REMEMBER_ERROR(OMX_Deinit()); return eError; }
/* Main entrypoint into the Seeking Component Test */ OMX_ERRORTYPE OMX_CONF_SeekingComponentTest(OMX_IN OMX_STRING cComponentName) { OMX_TIME_CONFIG_SEEKMODETYPE oSeekMode; OMX_TIME_CONFIG_TIMESTAMPTYPE oTimeStamp; OMX_PTR pWrappedAppData; OMX_CALLBACKTYPE *pWrappedCallbacks; OMX_HANDLETYPE hComp, hWrappedComp, hTTComp, hWrappedTTComp; OMX_ERRORTYPE eTemp, eError = OMX_ErrorNone; OMX_CALLBACKTYPE oCallbacks; SCTDATATYPE oAppData; /* create state change event */ OMX_OSAL_EventCreate(&oAppData.hStateChangeEvent); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_OSAL_EventCreate(&oAppData.hEOSEvent); OMX_OSAL_EventReset(oAppData.hEOSEvent); /* init component handles */ hComp = hWrappedComp = hTTComp = hWrappedTTComp = 0; oCallbacks.EventHandler = SCTEventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR) & oAppData, cComponentName, &pWrappedCallbacks, &pWrappedAppData); /* Initialize OpenMax */ eError = OMX_Init(); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Creating component under test and tunnel test component.\n"); /* Acquire component under test handle */ OMX_CONF_FAIL_IF_ERROR(OMX_GetHandle(&hComp, cComponentName, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hComp, cComponentName, &hWrappedComp)); oAppData.hCUT = hComp; /* Acquire tunnel test component handle */ OMX_CONF_FAIL_IF_ERROR(OMX_CONF_GetTunnelTestComponentHandle(&hTTComp, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hTTComp, "OMX.CONF.tunnel.test", &hWrappedTTComp)); /* Set the OnEmptyThisBuffer callback */ OMX_CONF_SetTTCOnEmptyThisBuffer(hTTComp, SCTOnEmptyThisBuffer); /* Connect CUT to TTC */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Connecting all ports.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_TTCConnectAllPorts(hWrappedTTComp, hWrappedComp)); /* Force all CUT ports to be suppliers */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Forcing all component ports to be suppliers.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ForceSuppliers(hWrappedComp, OMX_TRUE)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ForceSuppliers(hWrappedTTComp, OMX_FALSE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transitioning to executing.\n"); /* transition CUT to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* transition TTC to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* transition CUT to executing */ OMX_CONF_FAIL_IF_ERROR(SCTWaitForState(&oAppData, OMX_StateIdle)); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateExecuting, 0)); OMX_CONF_FAIL_IF_ERROR(SCTWaitForState(&oAppData, OMX_StateExecuting)); /* transition TTC to executing */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateExecuting, 0)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_WaitForBufferTraffic(hTTComp)); /* Get/Set OMX_IndexConfigTimeSeekMode */ INIT_CONFIG(oSeekMode); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Confirm support for OMX_IndexConfigTimeSeekMode\n"); OMX_CONF_FAIL_IF_ERROR(OMX_GetConfig(hComp, OMX_IndexConfigTimeSeekMode, (OMX_PTR)&oSeekMode)); oSeekMode.eType = OMX_TIME_SeekModeAccurate; OMX_CONF_FAIL_IF_ERROR(OMX_SetConfig(hComp, OMX_IndexConfigTimeSeekMode, (OMX_PTR)&oSeekMode)); /* Get OMX_IndexConfigTimePosition */ INIT_CONFIG(oTimeStamp); oTimeStamp.nPortIndex = 0; /* ignored - but we clear it anyway */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Confirm support for OMX_IndexConfigTimePosition\n"); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-Get the current position (remember it for later).\n"); OMX_CONF_FAIL_IF_ERROR(OMX_GetConfig(hComp, OMX_IndexConfigTimePosition, (OMX_PTR)&oTimeStamp)); /* Set OMX_IndexConfigTimePosition */ /* Wait for the position to move on and then return to it */ g_StartTimeDetected = OMX_FALSE; OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-Run for a while.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_WaitForBufferTraffic(hTTComp)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-Seek to the remembered position.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_SetConfig(hComp, OMX_IndexConfigTimePosition, (OMX_PTR)&oTimeStamp)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "-Run for a while - wait for seek (i.e. a OMX_BUFFERFLAG_STARTTIME).\n"); OMX_CONF_WaitForBufferTraffic(hTTComp); if (g_StartTimeDetected) { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "--OK: Saw OMX_BUFFERFLAG_STARTTIME.\n"); } else { OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "--ERROR: No OMX_BUFFERFLAG_STARTTIME.\n"); eError = OMX_ErrorUndefined; } OMX_CONF_TEST_FAIL: /* Cleanup: Return function errors rather than closing errors if appropriate */ /* transition CUT and TTC to Loaded state */ if (hWrappedComp) { OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0)); } if (hWrappedTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateIdle, 0)); TTCReleaseBuffers(hTTComp); } if (hWrappedComp) { OMX_CONF_REMEMBER_ERROR(SCTWaitForState(&oAppData, OMX_StateIdle)); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); OMX_CONF_REMEMBER_ERROR(SCTWaitForState(&oAppData, OMX_StateLoaded)); } if (hWrappedTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); } /* destroy state change event */ OMX_OSAL_EventDestroy(oAppData.hStateChangeEvent); OMX_OSAL_EventDestroy(oAppData.hEOSEvent); if (hWrappedComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedComp)); } if (hComp) { OMX_CONF_REMEMBER_ERROR(OMX_FreeHandle(hComp)); } if (hTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_FreeTunnelTestComponentHandle(hTTComp)); OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedTTComp)); } OMX_CONF_REMEMBER_ERROR(OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks, pWrappedAppData)); OMX_CONF_REMEMBER_ERROR(OMX_Deinit()); return eError; }
/* Main entrypoint into the Valid Input Output Test */ OMX_ERRORTYPE OMX_CONF_ValidInputOutputTest(OMX_IN OMX_STRING cComponentName) { OMX_PTR pWrappedAppData; OMX_CALLBACKTYPE *pWrappedCallbacks; OMX_HANDLETYPE hComp, hWrappedComp, hTTComp, hWrappedTTComp; OMX_ERRORTYPE eTemp, eError = OMX_ErrorNone; OMX_CALLBACKTYPE oCallbacks; VIOTDATATYPE oAppData; /* create state change event */ OMX_OSAL_EventCreate(&oAppData.hStateChangeEvent); OMX_OSAL_EventReset(oAppData.hStateChangeEvent); /* init component handles */ hComp = hWrappedComp = hTTComp = hWrappedTTComp = 0; oCallbacks.EventHandler = VIOTEventHandler; oCallbacks.EmptyBufferDone = StubbedEmptyBufferDone; oCallbacks.FillBufferDone = StubbedFillBufferDone; eError = OMX_CONF_CallbackTracerCreate(&oCallbacks, (OMX_PTR) & oAppData, cComponentName, &pWrappedCallbacks, &pWrappedAppData); /* Initialize OpenMax */ eError = OMX_Init(); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Creating component under test and tunnel test component.\n"); /* Acquire component under test handle */ OMX_CONF_FAIL_IF_ERROR(OMX_GetHandle(&hComp, cComponentName, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hComp, cComponentName, &hWrappedComp)); oAppData.hCUT = hComp; /* Acquire tunnel test component handle */ OMX_CONF_FAIL_IF_ERROR(OMX_CONF_GetTunnelTestComponentHandle(&hTTComp, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hTTComp, "OMX.CONF.tunnel.test", &hWrappedTTComp)); /* Connect CUT to TTC */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Connecting all ports.\n"); OMX_CONF_FAIL_IF_ERROR(OMX_CONF_TTCConnectAllPorts(hWrappedTTComp, hWrappedComp)); /* transition CUT to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateIdle, 0)); /* transition TTC to idle */ OMX_CONF_FAIL_IF_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateIdle, 0)); OMX_CONF_FAIL_IF_ERROR(VOITWaitForState(&oAppData, OMX_StateIdle)); OMX_CONF_TEST_FAIL: /* Cleanup: Return function errors rather than closing errors if appropriate */ /* transition CUT to Loaded state */ if (hWrappedComp) { OMX_OSAL_EventReset(oAppData.hStateChangeEvent); OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); } /* transition TTC to Loaded state */ if (hWrappedTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_SendCommand(hWrappedTTComp, OMX_CommandStateSet, OMX_StateLoaded, 0)); } OMX_CONF_REMEMBER_ERROR(VOITWaitForState(&oAppData, OMX_StateLoaded)); /* destroy state change event */ OMX_OSAL_EventDestroy(oAppData.hStateChangeEvent); if (hWrappedComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedComp)); } if (hComp) { OMX_CONF_REMEMBER_ERROR(OMX_FreeHandle(hComp)); } if (hTTComp) { OMX_CONF_REMEMBER_ERROR(OMX_CONF_FreeTunnelTestComponentHandle(hTTComp)); OMX_CONF_REMEMBER_ERROR(OMX_CONF_ComponentTracerDestroy(hWrappedTTComp)); } OMX_CONF_REMEMBER_ERROR(OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks, pWrappedAppData)); OMX_CONF_REMEMBER_ERROR(OMX_Deinit()); return eError; }
OMX_ERRORTYPE OMX_CONF_PortCommunicationTest(OMX_IN OMX_STRING cComponentName) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_HANDLETYPE hComp = 0; OMX_CALLBACKTYPE sCallbacks; PortCommTestCtxt sContext; OMX_HANDLETYPE hWrappedComp = 0; OMX_CALLBACKTYPE *pWrappedCallbacks; OMX_PTR pWrappedAppData; PortCommTestCtxt *pCtxt; pCtxt = &sContext; memset(pCtxt, 0x0, sizeof(PortCommTestCtxt)); sCallbacks.EventHandler = PortCommTest_EventHandler; sCallbacks.EmptyBufferDone = PortCommTest_EmptyBufferDone; sCallbacks.FillBufferDone = PortCommTest_FillBufferDone; eError = OMX_CONF_CallbackTracerCreate(&sCallbacks, (OMX_PTR)pCtxt, cComponentName, &pWrappedCallbacks, &pWrappedAppData); /* initialize events to track callbacks */ OMX_OSAL_EventCreate(&pCtxt->hStateSetEvent); OMX_OSAL_EventReset(pCtxt->hStateSetEvent); OMX_OSAL_EventCreate(&pCtxt->hPortDisableEvent); OMX_OSAL_EventReset(pCtxt->hPortDisableEvent); OMX_OSAL_EventCreate(&pCtxt->hPortEnableEvent); OMX_OSAL_EventReset(pCtxt->hPortEnableEvent); OMX_OSAL_EventCreate(&pCtxt->hBufDoneEvent); OMX_OSAL_EventReset(pCtxt->hBufDoneEvent); OMX_OSAL_EventCreate(&pCtxt->hEmptyBufDoneEvent); OMX_OSAL_EventReset(pCtxt->hEmptyBufDoneEvent); /* Initialize OpenMax */ eError = OMX_Init(); OMX_CONF_BAIL_IF_ERROR(eError); OMX_CONF_BAIL_IF_ERROR(OMX_GetHandle(&hComp, cComponentName, pWrappedAppData, pWrappedCallbacks)); OMX_CONF_BAIL_IF_ERROR(OMX_CONF_ComponentTracerCreate(hComp, cComponentName, &hWrappedComp)); pCtxt->hWComp = hWrappedComp; /* Verify start in Loaded state */ OMX_CONF_BAIL_IF_ERROR(OMX_GetState(pCtxt->hWComp, &pCtxt->eState)); if (pCtxt->eState != OMX_StateLoaded) OMX_CONF_SET_ERROR_BAIL("Component not in loaded state at init\n", OMX_ErrorUndefined); /* detect all audio ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[0], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp, OMX_IndexParamAudioInit, (OMX_PTR) & pCtxt->sPortParam[0]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i audio ports starting at %i \n", pCtxt->sPortParam[0].nPorts, pCtxt->sPortParam[0].nStartPortNumber); /* detect all video ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[1], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp, OMX_IndexParamVideoInit, (OMX_PTR) & pCtxt->sPortParam[1]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i video ports starting at %i \n", pCtxt->sPortParam[1].nPorts, pCtxt->sPortParam[1].nStartPortNumber); /* detect all image ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[2], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp, OMX_IndexParamImageInit, (OMX_PTR) & pCtxt->sPortParam[2]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i image ports starting at %i \n", pCtxt->sPortParam[2].nPorts, pCtxt->sPortParam[2].nStartPortNumber); /* detect all other ports on the component */ OMX_CONF_INIT_STRUCT(pCtxt->sPortParam[3], OMX_PORT_PARAM_TYPE); eError = OMX_GetParameter(pCtxt->hWComp, OMX_IndexParamOtherInit, (OMX_PTR) & pCtxt->sPortParam[3]); if (OMX_ErrorUnsupportedIndex == eError) eError = OMX_ErrorNone; OMX_CONF_BAIL_IF_ERROR(eError); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "detected %i other ports starting at %i \n", pCtxt->sPortParam[3].nPorts, pCtxt->sPortParam[3].nStartPortNumber); pCtxt->nPorts = pCtxt->sPortParam[0].nPorts + pCtxt->sPortParam[1].nPorts + pCtxt->sPortParam[2].nPorts + pCtxt->sPortParam[3].nPorts; /* 3.4.1. Non-Tunneling Setup Test */ /* TODO: reference core does not take null as port */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Non-Tunneling Setup Test\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pCtxt, NonTunnelTest)); /* 3.4.2. Transmit Buffers Between Input and Output Ports and Application */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transmit Test - Client allocates - Full payload\n"); pCtxt->nBufFactor = 1; pCtxt->bClientAllocBuf = OMX_TRUE; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pCtxt, OMX_TRUE, OMX_TRUE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transmit Test - Client allocates - Half payload\n"); pCtxt->nBufFactor = 2; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pCtxt, OMX_TRUE, OMX_TRUE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transmit Test - Client allocates - Quarter payload\n"); pCtxt->nBufFactor = 4; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pCtxt, OMX_TRUE, OMX_TRUE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Transmit Test - Component allocates - Full payload\n"); pCtxt->bClientAllocBuf = OMX_FALSE; pCtxt->nBufFactor = 1; OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pCtxt, OMX_TRUE, OMX_TRUE)); /* 3.4.3. Port Repack Test */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Repack Test\n"); pCtxt->bClientAllocBuf = OMX_TRUE; OMX_CONF_BAIL_IF_ERROR(PortCommTest_RepackTest(pCtxt)); /* 3.4.4. Port Stop and Restart Test */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Port Stop and Restart Test\n"); pCtxt->nBufFactor = 1; OMX_CONF_BAIL_IF_ERROR(PortCommTest_StopRestartTest(pCtxt)); /* 3.4.5. Component Pause and Resume Test*/ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Component Pause and Resume Test\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_PauseResume(pCtxt)); OMX_CONF_TEST_BAIL: /* cleanup: return function errors rather than closing errors if appropriate */ OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Cleanup\n"); if (OMX_ErrorNone == eError) { if (hWrappedComp) { eError = OMX_CONF_ComponentTracerDestroy(hWrappedComp); } if (hComp) { eError = OMX_FreeHandle(hComp); } eError = OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks, pWrappedAppData); eError = OMX_Deinit(); } else { PortCommTest_TransitionWait(OMX_StateInvalid, pCtxt); PortCommTest_DeInitBuffer(pCtxt); if (hWrappedComp) { OMX_CONF_ComponentTracerDestroy(hWrappedComp); } if (hComp) { OMX_FreeHandle(hComp); } OMX_CONF_CallbackTracerDestroy(pWrappedCallbacks, pWrappedAppData); OMX_Deinit(); } OMX_OSAL_EventDestroy(pCtxt->hStateSetEvent); OMX_OSAL_EventDestroy(pCtxt->hPortDisableEvent); OMX_OSAL_EventDestroy(pCtxt->hPortEnableEvent); OMX_OSAL_EventDestroy(pCtxt->hBufDoneEvent); OMX_OSAL_EventDestroy(pCtxt->hEmptyBufDoneEvent); return eError; }
OMX_ERRORTYPE PortCommTest_StopRestartTest(PortCommTestCtxt* pContext) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_BOOL bTimeout; /* process max frames */ OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pContext, OMX_TRUE, OMX_FALSE)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Stopping all ports\n"); OMX_OSAL_EventReset(pContext->hPortDisableEvent); OMX_CONF_BAIL_IF_ERROR(OMX_SendCommand(pContext->hWComp, OMX_CommandPortDisable, OMX_ALL, 0x0)); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Wait for all buffers to be returned\n"); while (pContext->nOutBufBusy || pContext->nInBufBusy) { OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("All buffers not returned\n", OMX_ErrorUndefined); } } /* check if command completed before de-allocation*/ OMX_OSAL_EventWait(pContext->hPortDisableEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("Ports stopped unexpectedly\n", OMX_ErrorUndefined); } OMX_OSAL_EventReset(pContext->hPortDisableEvent); /* free all buffers */ OMX_CONF_BAIL_IF_ERROR(PortCommTest_DeInitBuffer(pContext)); /* wait for cmd complete */ OMX_OSAL_EventWait(pContext->hPortDisableEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("All ports not stopped\n", OMX_ErrorUndefined); } /* ensure no more buffer done callbacks are made */ OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("callbacks made after cmdcomplete\n", OMX_ErrorUndefined); } pContext->nBufDoneCalls = 0; OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Attempting to process buffers while stopped\n"); OMX_OSAL_EventReset(pContext->hBufDoneEvent); OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, EmptyFill)); OMX_OSAL_EventWait(pContext->hBufDoneEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("callbacks made while ports disabled\n", OMX_ErrorUndefined); } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Processed %d buffers\n", pContext->nBufDoneCalls); OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Restarting all ports\n"); OMX_OSAL_EventReset(pContext->hPortEnableEvent); /* send restart command */ OMX_CONF_BAIL_IF_ERROR(OMX_SendCommand(pContext->hWComp, OMX_CommandPortEnable, OMX_ALL, 0x0)); /* check if command completed before allocation*/ OMX_OSAL_EventWait(pContext->hPortEnableEvent, OMX_CONF_TIMEOUT_EXPECTING_FAILURE, &bTimeout); if (OMX_FALSE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("Ports restarted unexpectedly\n", OMX_ErrorUndefined); } OMX_OSAL_EventReset(pContext->hPortEnableEvent); /* allocate buffers */ OMX_CONF_BAIL_IF_ERROR(PortCommTest_OperateOnPorts(pContext, AllocBuf)); /* wait for command complete */ OMX_OSAL_EventWait(pContext->hPortEnableEvent, OMX_CONF_TIMEOUT_BUFFER_TRAFFIC, &bTimeout); if (OMX_TRUE == bTimeout) { OMX_CONF_SET_ERROR_BAIL("All ports not restarted\n", OMX_ErrorUndefined); } OMX_OSAL_Trace(OMX_OSAL_TRACE_INFO, "Process buffers after restarting\n"); OMX_CONF_BAIL_IF_ERROR(PortCommTest_TransmitTest(pContext, OMX_FALSE, OMX_TRUE)); OMX_CONF_TEST_BAIL: return eError; }