OSCL_EXPORT_REF void OsclScheduler::Init(const char *name, Oscl_DefAlloc *alloc, int nreserve) //Init the scheduler for this thread. { int32 err; OSCL_TRY(err, OsclExecScheduler *sched = OsclExecScheduler::NewL(name, alloc, nreserve); sched->InstallScheduler(););
void OmxDecTestBase::StartTestApp() { if (!IsAdded()) { AddToScheduler(); } RunIfNotReady(); OsclExecScheduler* sched = OsclExecScheduler::Current(); if (sched) { sched->StartScheduler(); } }
int MetadataDriver::retrieverThread() { LOGV("retrieverThread"); if (!InitializeForThread()) { LOGV("InitializeForThread fail"); mSyncSem->Signal(); return -1; } OMX_MasterInit(); OsclScheduler::Init("PVAuthorEngineWrapper"); mState = STATE_CREATE; AddToScheduler(); RunIfNotReady(); OsclExecScheduler *sched = OsclExecScheduler::Current(); sched->StartScheduler(); mSyncSem->Signal(); // Signal that doSetDataSource() is done. OsclScheduler::Cleanup(); OMX_MasterDeinit(); UninitializeForThread(); return 0; }
void OmxEncTestCompRole::Run() { switch (iState) { case StateUnLoaded: { OMX_ERRORTYPE Err; OMX_U32 ii; OMX_U32 NumComps = 0; OMX_STRING* pCompOfRole = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEncTestCompRole::Run() - StateUnLoaded IN")); #if PROXY_INTERFACE ipThreadSafeHandlerEventHandler = OSCL_NEW(OmxEncEventHandlerThreadSafeCallbackAO, (this, EVENT_HANDLER_QUEUE_DEPTH, "EventHandlerAO")); ipThreadSafeHandlerEmptyBufferDone = OSCL_NEW(OmxEncEmptyBufferDoneThreadSafeCallbackAO, (this, EMPTY_BUFFER_DONE_QUEUE_DEPTH, "EmptyBufferDoneAO")); ipThreadSafeHandlerFillBufferDone = OSCL_NEW(OmxEncFillBufferDoneThreadSafeCallbackAO, (this, FILL_BUFFER_DONE_QUEUE_DEPTH, "FillBufferDoneAO")); if ((NULL == ipThreadSafeHandlerEventHandler) || (NULL == ipThreadSafeHandlerEmptyBufferDone) || (NULL == ipThreadSafeHandlerFillBufferDone)) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - Error, ThreadSafe Callback Handler initialization failed, OUT")); iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } #endif if (!iCallbacks->initCallbacks()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - ERROR initCallbacks failed, OUT")); iTestStatus = OMX_FALSE; iState = StateStop; RunIfNotReady(); break; } ipAppPriv = (AppPrivateType*) oscl_malloc(sizeof(AppPrivateType)); CHECK_MEM_ROLE_TEST(ipAppPriv, "Component_Handle"); //This should be the first call to the component to load it. Err = OMX_MasterInit(); CHECK_ERROR_ROLE_TEST(Err, "OMX_MasterInit"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxEncTestCompRole::Run() - OMX_MasterInit done")); if (NULL != iRole) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxEncTestCompRole::Run() - Finding out the components that can support the role %s", iRole)); //Given the role, determine the component first & then get the handle // Call once to find out the number of components that can fit the role Err = OMX_MasterGetComponentsOfRole(iRole, &NumComps, NULL); if (OMX_ErrorNone != Err || NumComps < 1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - ERROR, No component can handle the specified role %s", iRole)); iTestStatus = OMX_FALSE; ipAppPriv->Handle = NULL; iState = StateStop; RunIfNotReady(); break; } pCompOfRole = (OMX_STRING*) oscl_malloc(NumComps * sizeof(OMX_STRING)); CHECK_MEM_ROLE_TEST(pCompOfRole, "ComponentRoleArray"); for (ii = 0; ii < NumComps; ii++) { pCompOfRole[ii] = (OMX_STRING) oscl_malloc(PV_OMX_MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8)); CHECK_MEM_ROLE_TEST(pCompOfRole[ii], "ComponentRoleArray"); } if (OMX_FALSE == iTestStatus) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - Error occured in this state, StateUnLoaded OUT")); break; } // call 2nd time to get the component names Err = OMX_MasterGetComponentsOfRole(iRole, &NumComps, (OMX_U8**) pCompOfRole); CHECK_ERROR_ROLE_TEST(Err, "GetComponentsOfRole"); for (ii = 0; ii < NumComps; ii++) { // try to create component Err = OMX_MasterGetHandle(&ipAppPriv->Handle, (OMX_STRING) pCompOfRole[ii], (OMX_PTR) this, iCallbacks->getCallbackStruct()); // if successful, no need to continue if ((OMX_ErrorNone == Err) && (NULL != ipAppPriv->Handle)) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxEncTestCompRole::Run() - Got Handle for the component %s", pCompOfRole[ii])); break; } else { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - ERROR, Cannot get component %s handle, try another if possible", pCompOfRole[ii])); } } CHECK_ERROR_ROLE_TEST(Err, "GetHandle"); CHECK_MEM_ROLE_TEST(ipAppPriv->Handle, "ComponentHandle"); } //Free the role of component arrays if (pCompOfRole) { for (ii = 0; ii < NumComps; ii++) { oscl_free(pCompOfRole[ii]); pCompOfRole[ii] = NULL; } oscl_free(pCompOfRole); pCompOfRole = NULL; } iState = StateStop; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEncTestCompRole::Run() - StateUnLoaded OUT, moving to next state")); RunIfNotReady(); } break; /********* FREE THE HANDLE & CLOSE FILES FOR THE COMPONENT ********/ case StateStop: { OMX_U8 TestName[] = "GET_ROLES_TEST"; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEncTestCompRole::Run() - StateStop IN")); if (ipAppPriv) { if (ipAppPriv->Handle) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxEncTestCompRole::Run() - Free the Component Handle")); Err = OMX_MasterFreeHandle(ipAppPriv->Handle); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - FreeHandle Error")); iTestStatus = OMX_FALSE; } } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxEncTestCompRole::Run() - De-initialize the omx component")); Err = OMX_MasterDeinit(); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxEncTestCompRole::Run() - OMX_MasterDeinit Error")); iTestStatus = OMX_FALSE; } if (ipAppPriv) { oscl_free(ipAppPriv); ipAppPriv = NULL; } #if PROXY_INTERFACE OSCL_DELETE(ipThreadSafeHandlerEventHandler); ipThreadSafeHandlerEventHandler = NULL; OSCL_DELETE(ipThreadSafeHandlerEmptyBufferDone); ipThreadSafeHandlerEmptyBufferDone = NULL; OSCL_DELETE(ipThreadSafeHandlerFillBufferDone); ipThreadSafeHandlerFillBufferDone = NULL; #endif if (OMX_FALSE == iTestStatus) { #ifdef PRINT_RESULT printf("%s: Fail \n", TestName); #endif PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0, "OmxComponentEncTest::VerifyOutput() - %s : Fail", TestName)); } else { #ifdef PRINT_RESULT printf("%s: Success \n", TestName); OMX_ENC_TEST(true); iTestCase->TestCompleted(); #endif PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0, "OmxComponentEncTest::VerifyOutput() - %s : Success", TestName)); } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxEncTestCompRole::Run() - StateStop OUT")); iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } break; default: { break; } } return ; }
void OmxDecTestWithoutMarker::Run() { switch (iState) { case StateUnLoaded: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateUnLoaded IN")); OMX_ERRORTYPE Err; OMX_BOOL Status; if (!iCallbacks->initCallbacks()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - ERROR initCallbacks failed, OUT")); StopOnError(); break; } ipAppPriv = (AppPrivateType*) oscl_malloc(sizeof(AppPrivateType)); CHECK_MEM(ipAppPriv, "Component_Handle"); ipAppPriv->Handle = NULL; //Allocate bitstream buffer for AVC component if (0 == oscl_strcmp(iFormat, "H264")) { ipAVCBSO = OSCL_NEW(AVCBitstreamObject, (ipInputFile)); CHECK_MEM(ipAVCBSO, "Bitstream_Buffer"); } //Allocate bitstream buffer for MPEG4/H263 component if (0 == oscl_strcmp(iFormat, "M4V") || 0 == oscl_strcmp(iFormat, "H263")) { ipBitstreamBuffer = (OMX_U8*) oscl_malloc(BIT_BUFF_SIZE); CHECK_MEM(ipBitstreamBuffer, "Bitstream_Buffer") ipBitstreamBufferPointer = ipBitstreamBuffer; } iNoMarkerBitTest = OMX_TRUE; //This should be the first call to the component to load it. Err = OMX_MasterInit(); CHECK_ERROR(Err, "OMX_MasterInit"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - OMX_MasterInit done")); Status = PrepareComponent(); if (OMX_FALSE == Status) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() Error while loading component OUT")); iState = StateError; if (iInputParameters.inPtr) { oscl_free(iInputParameters.inPtr); iInputParameters.inPtr = NULL; } RunIfNotReady(); break; } #if PROXY_INTERFACE ipThreadSafeHandlerEventHandler = OSCL_NEW(OmxEventHandlerThreadSafeCallbackAO, (this, EVENT_HANDLER_QUEUE_DEPTH, "EventHandlerAO")); ipThreadSafeHandlerEmptyBufferDone = OSCL_NEW(OmxEmptyBufferDoneThreadSafeCallbackAO, (this, iInBufferCount, "EmptyBufferDoneAO")); ipThreadSafeHandlerFillBufferDone = OSCL_NEW(OmxFillBufferDoneThreadSafeCallbackAO, (this, iOutBufferCount, "FillBufferDoneAO")); if ((NULL == ipThreadSafeHandlerEventHandler) || (NULL == ipThreadSafeHandlerEmptyBufferDone) || (NULL == ipThreadSafeHandlerFillBufferDone)) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - Error ThreadSafe Callback Handler initialization failed, OUT")); iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } #endif if (StateError != iState) { iState = StateLoaded; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateUnLoaded OUT, moving to next state")); } RunIfNotReady(); } break; case StateLoaded: { OMX_ERRORTYPE Err; OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateLoaded IN")); // allocate memory for ipInBuffer ipInBuffer = (OMX_BUFFERHEADERTYPE**) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE*) * iInBufferCount); CHECK_MEM(ipInBuffer, "InputBufferHeader"); ipInputAvail = (OMX_BOOL*) oscl_malloc(sizeof(OMX_BOOL) * iInBufferCount); CHECK_MEM(ipInputAvail, "InputBufferFlag"); /* Initialize all the buffers to NULL */ for (ii = 0; ii < iInBufferCount; ii++) { ipInBuffer[ii] = NULL; } //allocate memory for output buffer ipOutBuffer = (OMX_BUFFERHEADERTYPE**) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE*) * iOutBufferCount); CHECK_MEM(ipOutBuffer, "OutputBuffer"); ipOutReleased = (OMX_BOOL*) oscl_malloc(sizeof(OMX_BOOL) * iOutBufferCount); CHECK_MEM(ipOutReleased, "OutputBufferFlag"); /* Initialize all the buffers to NULL */ for (ii = 0; ii < iOutBufferCount; ii++) { ipOutBuffer[ii] = NULL; } Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateIdle, NULL); CHECK_ERROR(Err, "SendCommand Loaded->Idle"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Sent State Transition Command from Loaded->Idle")); iPendingCommands = 1; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Allocating %d input and %d output buffers", iInBufferCount, iOutBufferCount)); //These calls are required because the control of in & out buffer should be with the testapp. for (ii = 0; ii < iInBufferCount; ii++) { Err = OMX_AllocateBuffer(ipAppPriv->Handle, &ipInBuffer[ii], iInputPortIndex, NULL, iInBufferSize); CHECK_ERROR(Err, "AllocateBuffer_Input"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called AllocateBuffer for buffer index %d on port %d", ii, iInputPortIndex)); ipInputAvail[ii] = OMX_TRUE; ipInBuffer[ii]->nInputPortIndex = iInputPortIndex; } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - AllocateBuffer Error, StateLoaded OUT")); RunIfNotReady(); break; } for (ii = 0; ii < iOutBufferCount; ii++) { Err = OMX_AllocateBuffer(ipAppPriv->Handle, &ipOutBuffer[ii], iOutputPortIndex, NULL, iOutBufferSize); CHECK_ERROR(Err, "AllocateBuffer_Output"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called AllocateBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); ipOutReleased[ii] = OMX_TRUE; ipOutBuffer[ii]->nOutputPortIndex = iOutputPortIndex; ipOutBuffer[ii]->nInputPortIndex = 0; } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - AllocateBuffer Error, StateLoaded OUT")); RunIfNotReady(); break; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateLoaded OUT, Moving to next state")); } break; case StateIdle: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateIdle IN")); OMX_ERRORTYPE Err = OMX_ErrorNone; /*Send an output buffer before dynamic reconfig */ Err = OMX_FillThisBuffer(ipAppPriv->Handle, ipOutBuffer[0]); CHECK_ERROR(Err, "FillThisBuffer"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - FillThisBuffer command called for initiating dynamic port reconfiguration")); ipOutReleased[0] = OMX_FALSE; Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateExecuting, NULL); CHECK_ERROR(Err, "SendCommand Idle->Executing"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Sent State Transition Command from Idle->Executing")); iPendingCommands = 1; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateIdle OUT")); } break; case StateDecodeHeader: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDecodeHeader IN, Sending configuration input buffers to the component to start dynamic port reconfiguration")); if (!iFlagDecodeHeader) { if (0 == oscl_strcmp(iFormat, "WMV") || 0 == oscl_strcmp(iFormat, "WMA") || 0 == oscl_strcmp(iFormat, "RV") || 0 == oscl_strcmp(iFormat, "RA")) { (*this.*pGetInputFrame)(); } else { GetInput(); } iFlagDecodeHeader = OMX_TRUE; //Proceed to executing state and if Port settings changed callback comes, //then do the dynamic port reconfiguration iState = StateExecuting; RunIfNotReady(); } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDecodeHeader OUT")); } break; case StateDisablePort: { OMX_ERRORTYPE Err = OMX_ErrorNone; OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDisablePort IN")); if (!iDisableRun) { if (!iFlagDisablePort) { Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandPortDisable, iOutputPortIndex, NULL); CHECK_ERROR(Err, "SendCommand_PortDisable"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Sent Command for OMX_CommandPortDisable on port %d as a part of dynamic port reconfiguration", iOutputPortIndex)); iPendingCommands = 1; iFlagDisablePort = OMX_TRUE; RunIfNotReady(); } else { //Wait for all the buffers to be returned on output port before freeing them //This wait is required because of the queueing delay in all the Callbacks for (ii = 0; ii < iOutBufferCount; ii++) { if (OMX_FALSE == ipOutReleased[ii]) { break; } } if (ii != iOutBufferCount) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Not all the output buffers returned by component yet, wait for it")); RunIfNotReady(); break; } for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Output_DynamicReconfig"); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } if (ipOutBuffer) { oscl_free(ipOutBuffer); ipOutBuffer = NULL; } if (ipOutReleased) { oscl_free(ipOutReleased); ipOutReleased = NULL; } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - Error occured in this state, StateDisablePort OUT")); RunIfNotReady(); break; } iDisableRun = OMX_TRUE; } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDisablePort OUT")); } break; case StateDynamicReconfig: { OMX_BOOL Status = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDynamicReconfig IN")); Status = HandlePortReEnable(); if (OMX_FALSE == Status) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - Error occured in this state, StateDynamicReconfig OUT")); iState = StateError; RunIfNotReady(); break; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateDynamicReconfig OUT")); } break; case StateExecuting: { OMX_U32 Index; OMX_BOOL MoreOutput; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateExecuting IN")); MoreOutput = OMX_TRUE; while (MoreOutput) { Index = 0; while (OMX_FALSE == ipOutReleased[Index] && Index < iOutBufferCount) { Index++; } if (Index != iOutBufferCount) { //This call is being made only once per frame Err = OMX_FillThisBuffer(ipAppPriv->Handle, ipOutBuffer[Index]); CHECK_ERROR(Err, "FillThisBuffer"); //Make this flag OMX_TRUE till u receive the callback for output buffer free ipOutReleased[Index] = OMX_FALSE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - FillThisBuffer command called for output buffer index %d", Index)); } else { MoreOutput = OMX_FALSE; } } if (!iStopProcessingInput || (OMX_ErrorInsufficientResources == iStatusExecuting)) { if (0 == oscl_strcmp(iFormat, "WMV") || 0 == oscl_strcmp(iFormat, "WMA") || 0 == oscl_strcmp(iFormat, "RV") || 0 == oscl_strcmp(iFormat, "RA")) { iStatusExecuting = (*this.*pGetInputFrame)(); } else { iStatusExecuting = GetInput(); } } else if (OMX_FALSE == iEosFlagExecuting) { //Only send one successful dummy buffer with flag set to signal EOS Index = 0; while (OMX_FALSE == ipInputAvail[Index] && Index < iInBufferCount) { Index++; } if (Index != iInBufferCount) { ipInBuffer[Index]->nFlags |= OMX_BUFFERFLAG_EOS; ipInBuffer[Index]->nFilledLen = 0; Err = OMX_EmptyThisBuffer(ipAppPriv->Handle, ipInBuffer[Index]); CHECK_ERROR(Err, "EmptyThisBuffer_EOS"); ipInputAvail[Index] = OMX_FALSE; // mark unavailable iEosFlagExecuting = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Input buffer sent to the component with OMX_BUFFERFLAG_EOS flag set")); } } else { //nothing to do here } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateExecuting OUT")); RunIfNotReady(); } break; case StateStopping: { OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateStopping IN")); //stop execution by state transition to Idle state. if (!iFlagStopping) { Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateIdle, NULL); CHECK_ERROR(Err, "SendCommand Executing->Idle"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Sent State Transition Command from Executing->Idle")); iPendingCommands = 1; iFlagStopping = OMX_TRUE; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateStopping OUT")); } break; case StateCleanUp: { OMX_U32 ii; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateCleanUp IN")); if (!iFlagCleanUp) { //Added a check here to verify whether all the ip/op buffers are returned back by the component or not //in case of Executing->Idle state transition if (OMX_FALSE == VerifyAllBuffersReturned()) { // not all buffers have been returned yet, reschedule RunIfNotReady(); break; } //Destroy the component by state transition to Loaded state Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateLoaded, NULL); CHECK_ERROR(Err, "SendCommand Idle->Loaded"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Sent State Transition Command from Idle->Loaded")); iPendingCommands = 1; if (ipInBuffer) { for (ii = 0; ii < iInBufferCount; ii++) { if (ipInBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iInputPortIndex, ipInBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Input"); ipInBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iInputPortIndex)); } } oscl_free(ipInBuffer); ipInBuffer = NULL; } if (ipInputAvail) { oscl_free(ipInputAvail); ipInputAvail = NULL; } if (ipOutBuffer) { for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Output"); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } oscl_free(ipOutBuffer); ipOutBuffer = NULL; } if (ipOutReleased) { oscl_free(ipOutReleased); ipOutReleased = NULL; } iFlagCleanUp = OMX_TRUE; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateCleanUp OUT")); } break; /********* FREE THE HANDLE & CLOSE FILES FOR THE COMPONENT ********/ case StateStop: { OMX_U8 TestName[] = "WITHOUT_MARKER_BIT_TEST"; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateStop IN")); if (ipAppPriv) { if (ipAppPriv->Handle) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Free the Component Handle")); Err = OMX_MasterFreeHandle(ipAppPriv->Handle); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - FreeHandle Error")); iTestStatus = OMX_FALSE; } } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - De-initialize the omx component")); Err = OMX_MasterDeinit(); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestWithoutMarker::Run() - OMX_MasterDeinit Error")); iTestStatus = OMX_FALSE; } if (0 == oscl_strcmp(iFormat, "H264")) { if (ipAVCBSO) { OSCL_DELETE(ipAVCBSO); ipAVCBSO = NULL; } } if (0 == oscl_strcmp(iFormat, "M4V") || 0 == oscl_strcmp(iFormat, "H263")) { if (ipBitstreamBuffer) { oscl_free(ipBitstreamBufferPointer); ipBitstreamBuffer = NULL; ipBitstreamBufferPointer = NULL; } } if (iOutputParameters) { oscl_free(iOutputParameters); iOutputParameters = NULL; } if (ipAppPriv) { oscl_free(ipAppPriv); ipAppPriv = NULL; } #if PROXY_INTERFACE if (ipThreadSafeHandlerEventHandler) { OSCL_DELETE(ipThreadSafeHandlerEventHandler); ipThreadSafeHandlerEventHandler = NULL; } if (ipThreadSafeHandlerEmptyBufferDone) { OSCL_DELETE(ipThreadSafeHandlerEmptyBufferDone); ipThreadSafeHandlerEmptyBufferDone = NULL; } if (ipThreadSafeHandlerFillBufferDone) { OSCL_DELETE(ipThreadSafeHandlerFillBufferDone); ipThreadSafeHandlerFillBufferDone = NULL; } #endif VerifyOutput(TestName); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateStop OUT")); iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } break; case StateError: { //Do all the cleanup's and exit from here OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateError IN")); iTestStatus = OMX_FALSE; if (ipInBuffer) { for (ii = 0; ii < iInBufferCount; ii++) { if (ipInBuffer[ii]) { OMX_FreeBuffer(ipAppPriv->Handle, iInputPortIndex, ipInBuffer[ii]); ipInBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iInputPortIndex)); } } oscl_free(ipInBuffer); ipInBuffer = NULL; } if (ipInputAvail) { oscl_free(ipInputAvail); ipInputAvail = NULL; } if (ipOutBuffer) { for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestWithoutMarker::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } oscl_free(ipOutBuffer); ipOutBuffer = NULL; } if (ipOutReleased) { oscl_free(ipOutReleased); ipOutReleased = NULL; } iState = StateStop; RunIfNotReady(); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestWithoutMarker::Run() - StateError OUT")); } break; default: { break; } } return ; }
void OmxDecTestFlushPort::Run() { switch (iState) { case StateUnLoaded: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateUnLoaded IN")); OMX_ERRORTYPE Err; OMX_BOOL Status; if (!iCallbacks->initCallbacks()) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - ERROR initCallbacks failed, OUT")); StopOnError(); break; } ipAppPriv = (AppPrivateType*) oscl_malloc(sizeof(AppPrivateType)); CHECK_MEM(ipAppPriv, "Component_Handle"); ipAppPriv->Handle = NULL; //Allocate bitstream buffer for AVC component if (0 == oscl_strcmp(iFormat, "H264")) { ipAVCBSO = OSCL_NEW(AVCBitstreamObject, (ipInputFile)); CHECK_MEM(ipAVCBSO, "Bitstream_Buffer"); } //Allocate bitstream buffer for MPEG4/H263 component if (0 == oscl_strcmp(iFormat, "M4V") || 0 == oscl_strcmp(iFormat, "H263")) { ipBitstreamBuffer = (OMX_U8*) oscl_malloc(BIT_BUFF_SIZE); CHECK_MEM(ipBitstreamBuffer, "Bitstream_Buffer") ipBitstreamBufferPointer = ipBitstreamBuffer; } //Allocate bitstream buffer for MP3 component if (0 == oscl_strcmp(iFormat, "MP3")) { ipMp3Bitstream = OSCL_NEW(Mp3BitstreamObject, (ipInputFile)); CHECK_MEM(ipMp3Bitstream, "Bitstream_Buffer"); } //This should be the first call to the component to load it. Err = OMX_MasterInit(); CHECK_ERROR(Err, "OMX_MasterInit"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - OMX_MasterInit done")); Status = PrepareComponent(); if (OMX_FALSE == Status) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() Error while loading component OUT")); iState = StateError; if (iInputParameters.inPtr) { oscl_free(iInputParameters.inPtr); iInputParameters.inPtr = NULL; } RunIfNotReady(); break; } #if PROXY_INTERFACE ipThreadSafeHandlerEventHandler = OSCL_NEW(EventHandlerThreadSafeCallbackAO, (this, EVENT_HANDLER_QUEUE_DEPTH, "EventHandlerAO")); ipThreadSafeHandlerEmptyBufferDone = OSCL_NEW(EmptyBufferDoneThreadSafeCallbackAO, (this, iInBufferCount, "EmptyBufferDoneAO")); ipThreadSafeHandlerFillBufferDone = OSCL_NEW(FillBufferDoneThreadSafeCallbackAO, (this, iOutBufferCount, "FillBufferDoneAO")); if ((NULL == ipThreadSafeHandlerEventHandler) || (NULL == ipThreadSafeHandlerEmptyBufferDone) || (NULL == ipThreadSafeHandlerFillBufferDone)) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - Error, ThreadSafe Callback Handler initialization failed, OUT")); iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } #endif if (StateError != iState) { iState = StateLoaded; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateUnLoaded OUT, moving to next state")); } RunIfNotReady(); } break; case StateLoaded: { OMX_ERRORTYPE Err; OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateLoaded IN")); // allocate memory for ipInBuffer ipInBuffer = (OMX_BUFFERHEADERTYPE**) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE*) * iInBufferCount); CHECK_MEM(ipInBuffer, "InputBufferHeader"); ipInputAvail = (OMX_BOOL*) oscl_malloc(sizeof(OMX_BOOL) * iInBufferCount); CHECK_MEM(ipInputAvail, "InputBufferFlag"); /* Initialize all the buffers to NULL */ for (ii = 0; ii < iInBufferCount; ii++) { ipInBuffer[ii] = NULL; } //allocate memory for output buffer ipOutBuffer = (OMX_BUFFERHEADERTYPE**) oscl_malloc(sizeof(OMX_BUFFERHEADERTYPE*) * iOutBufferCount); CHECK_MEM(ipOutBuffer, "OutputBuffer"); ipOutReleased = (OMX_BOOL*) oscl_malloc(sizeof(OMX_BOOL) * iOutBufferCount); CHECK_MEM(ipOutReleased, "OutputBufferFlag"); /* Initialize all the buffers to NULL */ for (ii = 0; ii < iOutBufferCount; ii++) { ipOutBuffer[ii] = NULL; } Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateIdle, NULL); CHECK_ERROR(Err, "SendCommand Loaded->Idle"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent State Transition Command from Loaded->Idle")); iPendingCommands = 1; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Allocating %d input and %d output buffers", iInBufferCount, iOutBufferCount)); //These calls are required because the control of in & out buffer should be with the testapp. for (ii = 0; ii < iInBufferCount; ii++) { Err = OMX_AllocateBuffer(ipAppPriv->Handle, &ipInBuffer[ii], iInputPortIndex, NULL, iInBufferSize); CHECK_ERROR(Err, "AllocateBuffer_Input"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called AllocateBuffer for buffer index %d on port %d", ii, iInputPortIndex)); ipInputAvail[ii] = OMX_TRUE; ipInBuffer[ii]->nInputPortIndex = iInputPortIndex; } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - AllocateBuffer Error, StateLoaded OUT")); RunIfNotReady(); break; } for (ii = 0; ii < iOutBufferCount; ii++) { Err = OMX_AllocateBuffer(ipAppPriv->Handle, &ipOutBuffer[ii], iOutputPortIndex, NULL, iOutBufferSize); CHECK_ERROR(Err, "AllocateBuffer_Output"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called AllocateBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); ipOutReleased[ii] = OMX_TRUE; ipOutBuffer[ii]->nOutputPortIndex = iOutputPortIndex; ipOutBuffer[ii]->nInputPortIndex = 0; } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - AllocateBuffer Error, StateLoaded OUT")); RunIfNotReady(); break; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateLoaded OUT, Moving to next state")); } break; case StateIdle: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateIdle IN")); OMX_ERRORTYPE Err = OMX_ErrorNone; Err = OMX_FillThisBuffer(ipAppPriv->Handle, ipOutBuffer[0]); CHECK_ERROR(Err, "FillThisBuffer"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - FillThisBuffer command called for initiating dynamic port reconfiguration")); ipOutReleased[0] = OMX_FALSE; Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateExecuting, NULL); CHECK_ERROR(Err, "SendCommand Idle->Executing"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent State Transition Command from Idle->Executing")); iPendingCommands = 1; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateIdle OUT")); } break; case StateDecodeHeader: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDecodeHeader IN, Sending configuration input buffers to the component to start dynamic port reconfiguration")); if (!iFlagDecodeHeader) { (*this.*pGetInputFrame)(); //For AAC component , send one more frame apart from the config frame, so that we can receive the callback if (0 == oscl_strcmp(iFormat, "AAC") || 0 == oscl_strcmp(iFormat, "AMR")) { (*this.*pGetInputFrame)(); } iFlagDecodeHeader = OMX_TRUE; iFrameCount++; //Proceed to executing state and if Port settings changed callback comes, //then do the dynamic port reconfiguration iState = StateExecuting; RunIfNotReady(); } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDecodeHeader OUT")); } break; case StateDisablePort: { OMX_ERRORTYPE Err = OMX_ErrorNone; OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDisablePort IN")); if (!iDisableRun) { if (!iFlagDisablePort) { Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandPortDisable, iOutputPortIndex, NULL); CHECK_ERROR(Err, "SendCommand_PortDisable"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent Command for OMX_CommandPortDisable on port %d as a part of dynamic port reconfiguration", iOutputPortIndex)); iPendingCommands = 1; iFlagDisablePort = OMX_TRUE; RunIfNotReady(); } else { //Wait for all the buffers to be returned on output port before freeing them //This wait is required because of the queueing delay in all the Callbacks for (ii = 0; ii < iOutBufferCount; ii++) { if (OMX_FALSE == ipOutReleased[ii]) { break; } } if (ii != iOutBufferCount) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Not all the output buffers returned by component yet, wait for it")); RunIfNotReady(); break; } for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Output_DynamicReconfig"); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - Error occured in this state, StateDisablePort OUT")); RunIfNotReady(); break; } iDisableRun = OMX_TRUE; } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDisablePort OUT")); } break; case StateDynamicReconfig: { OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDynamicReconfig IN")); INIT_GETPARAMETER_STRUCT(OMX_PARAM_PORTDEFINITIONTYPE, iParamPort); iParamPort.nPortIndex = iOutputPortIndex; Err = OMX_GetParameter(ipAppPriv->Handle, OMX_IndexParamPortDefinition, &iParamPort); CHECK_ERROR(Err, "GetParameter_DynamicReconfig"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - GetParameter called for OMX_IndexParamPortDefinition on port %d", iParamPort.nPortIndex)); Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandPortEnable, iOutputPortIndex, NULL); CHECK_ERROR(Err, "SendCommand_PortEnable"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent Command for OMX_CommandPortEnable on port %d as a part of dynamic port reconfiguration", iOutputPortIndex)); iPendingCommands = 1; if (0 == oscl_strcmp(iFormat, "H264") || 0 == oscl_strcmp(iFormat, "H263") || 0 == oscl_strcmp(iFormat, "M4V") || 0 == oscl_strcmp(iFormat, "RV")) { iOutBufferSize = ((iParamPort.format.video.nFrameWidth + 15) & ~15) * ((iParamPort.format.video.nFrameHeight + 15) & ~15) * 3 / 2; if (iOutBufferSize < iParamPort.nBufferSize) { iOutBufferSize = iParamPort.nBufferSize; } } else if (0 == oscl_strcmp(iFormat, "WMV")) { iOutBufferSize = ((iParamPort.format.video.nFrameWidth + 3) & ~3) * ((iParamPort.format.video.nFrameHeight + 3) & ~3) * 3 / 2; if (iOutBufferSize < iParamPort.nBufferSize) { iOutBufferSize = iParamPort.nBufferSize; } } else { //For audio components take the size from the component iOutBufferSize = iParamPort.nBufferSize; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Allocating buffer again after port reconfigutauion has been complete")); for (OMX_U32 ii = 0; ii < iOutBufferCount; ii++) { Err = OMX_AllocateBuffer(ipAppPriv->Handle, &ipOutBuffer[ii], iOutputPortIndex, NULL, iOutBufferSize); CHECK_ERROR(Err, "AllocateBuffer_Output_DynamicReconfig"); ipOutReleased[ii] = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - AllocateBuffer called for buffer index %d on port %d", ii, iOutputPortIndex)); } if (StateError == iState) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - Error occured in this state, StateDynamicReconfig OUT")); RunIfNotReady(); break; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateDynamicReconfig OUT")); } break; case StateExecuting: { OMX_U32 Index; OMX_BOOL MoreOutput; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateExecuting IN")); //After Processing N number of buffers, send the flush command on both the ports if ((iFrameCount > TEST_NUM_BUFFERS_TO_PROCESS) && (OMX_FALSE == iFlushCommandSent)) { Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandFlush, OMX_ALL, NULL); CHECK_ERROR(Err, "SendCommand OMX_CommandFlush"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sending Flush Command on each port")); //Expecting 2 callbacks from each port iPendingCommands = 2; iFlushCommandSent = OMX_TRUE; } else { MoreOutput = OMX_TRUE; while (MoreOutput) { Index = 0; while (OMX_FALSE == ipOutReleased[Index] && Index < iOutBufferCount) { Index++; } if (Index != iOutBufferCount) { //This call is being made only once per frame Err = OMX_FillThisBuffer(ipAppPriv->Handle, ipOutBuffer[Index]); CHECK_ERROR(Err, "FillThisBuffer"); //Reset this till u receive the callback for output buffer free ipOutReleased[Index] = OMX_FALSE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - FillThisBuffer command called for output buffer index %d", Index)); } else { MoreOutput = OMX_FALSE; } } //while (MoreOutput) loop end here if (!iStopProcessingInput || (OMX_ErrorInsufficientResources == iStatusExecuting)) { // find available input buffer Index = 0; while (OMX_FALSE == ipInputAvail[Index] && Index < iInBufferCount) { Index++; } if (Index != iInBufferCount) { iStatusExecuting = (*this.*pGetInputFrame)(); iFrameCount++; } } else if (OMX_FALSE == iEosFlagExecuting) { //Only send one successful dummy buffer with flag set to signal EOS Index = 0; while (OMX_FALSE == ipInputAvail[Index] && Index < iInBufferCount) { Index++; } if (Index != iInBufferCount) { ipInBuffer[Index]->nFlags |= OMX_BUFFERFLAG_EOS; ipInBuffer[Index]->nFilledLen = 0; Err = OMX_EmptyThisBuffer(ipAppPriv->Handle, ipInBuffer[Index]); CHECK_ERROR(Err, "EmptyThisBuffer_EOS"); ipInputAvail[Index] = OMX_FALSE; // mark unavailable iEosFlagExecuting = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Input buffer sent to the component with OMX_BUFFERFLAG_EOS flag set")); } } //else if (OMX_FALSE == iEosFlagExecuting) else { //nothing to do here } RunIfNotReady(); } //else of if ((iFrameCount > TEST_NUM_BUFFERS_TO_PROCESS) && (OMX_FALSE == iFlushCommandSent)) ends here PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateExecuting OUT")); } break; case StateIntermediate: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateIntermediate IN, for verification if ip/op buffers")); /* check whether all the buffers are returned on each port after a flush comand, * then change the Client AO state back to executing to resume processing */ if (OMX_TRUE == VerifyAllBuffersReturned()) { // All buffers have returned, change the AO state back to executing to resume processing //Note that component is already in Executing state iState = StateExecuting; } else { // not all buffers have been returned yet, remain in StateIntermediate and reschedule } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateIntermediate OUT")); RunIfNotReady(); } break; case StateStopping: { OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateStopping IN")); //stop execution by state transition to Idle state. if (!iFlagStopping) { Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateIdle, NULL); CHECK_ERROR(Err, "SendCommand Executing->Idle"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent State Transition Command from Executing->Idle")); iPendingCommands = 1; iFlagStopping = OMX_TRUE; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateStopping OUT")); } break; case StateCleanUp: { OMX_U32 ii; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateCleanUp IN")); if (!iFlagCleanUp) { //Added a check here to verify whether all the ip/op buffers are returned back by the component or not //in case of Executing->Idle state transition if (OMX_FALSE == VerifyAllBuffersReturned()) { // not all buffers have been returned yet, reschedule RunIfNotReady(); break; } //Destroy the component by state transition to Loaded state Err = OMX_SendCommand(ipAppPriv->Handle, OMX_CommandStateSet, OMX_StateLoaded, NULL); CHECK_ERROR(Err, "SendCommand Idle->Loaded"); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Sent State Transition Command from Idle->Loaded")); iPendingCommands = 1; if (ipInBuffer) { for (ii = 0; ii < iInBufferCount; ii++) { if (ipInBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iInputPortIndex, ipInBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Input"); ipInBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iInputPortIndex)); } } oscl_free(ipInBuffer); ipInBuffer = NULL; } if (ipInputAvail) { oscl_free(ipInputAvail); ipInputAvail = NULL; } if (ipOutBuffer) { for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { Err = OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); CHECK_ERROR(Err, "FreeBuffer_Output"); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } oscl_free(ipOutBuffer); ipOutBuffer = NULL; } if (ipOutReleased) { oscl_free(ipOutReleased); ipOutReleased = NULL; } iFlagCleanUp = OMX_TRUE; } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateCleanUp OUT")); } break; /********* FREE THE HANDLE & CLOSE FILES FOR THE COMPONENT ********/ case StateStop: { OMX_U8 TestName[] = "FLUSH_PORT_TEST"; OMX_ERRORTYPE Err = OMX_ErrorNone; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateStop IN")); if (ipAppPriv) { if (ipAppPriv->Handle) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Free the Component Handle")); Err = OMX_MasterFreeHandle(ipAppPriv->Handle); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - FreeHandle Error")); iTestStatus = OMX_FALSE; } } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - De-initialize the omx component")); Err = OMX_MasterDeinit(); if (OMX_ErrorNone != Err) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestFlushPort::Run() - OMX_MasterDeinit Error")); iTestStatus = OMX_FALSE; } if (0 == oscl_strcmp(iFormat, "H264")) { if (ipAVCBSO) { OSCL_DELETE(ipAVCBSO); ipAVCBSO = NULL; } } if (0 == oscl_strcmp(iFormat, "M4V") || 0 == oscl_strcmp(iFormat, "H263")) { if (ipBitstreamBuffer) { oscl_free(ipBitstreamBufferPointer); ipBitstreamBuffer = NULL; ipBitstreamBufferPointer = NULL; } } if (0 == oscl_strcmp(iFormat, "MP3")) { if (ipMp3Bitstream) { OSCL_DELETE(ipMp3Bitstream); ipMp3Bitstream = NULL; } } if (iOutputParameters) { oscl_free(iOutputParameters); iOutputParameters = NULL; } if (ipAppPriv) { oscl_free(ipAppPriv); ipAppPriv = NULL; } #if PROXY_INTERFACE if (ipThreadSafeHandlerEventHandler) { OSCL_DELETE(ipThreadSafeHandlerEventHandler); ipThreadSafeHandlerEventHandler = NULL; } if (ipThreadSafeHandlerEmptyBufferDone) { OSCL_DELETE(ipThreadSafeHandlerEmptyBufferDone); ipThreadSafeHandlerEmptyBufferDone = NULL; } if (ipThreadSafeHandlerFillBufferDone) { OSCL_DELETE(ipThreadSafeHandlerFillBufferDone); ipThreadSafeHandlerFillBufferDone = NULL; } #endif //VerifyOutput(TestName); if (OMX_FALSE == iTestStatus) { #ifdef PRINT_RESULT fprintf(iConsOutFile, "%s: Fail \n", TestName); #endif PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0, "OmxDecTestFlushPort::Run() - %s : Fail", TestName)); } else { #ifdef PRINT_RESULT fprintf(iConsOutFile, "%s: Success \n", TestName); #endif PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_INFO, (0, "OmxDecTestFlushPort::Run() - %s : Success", TestName)); } iState = StateUnLoaded; OsclExecScheduler* sched = OsclExecScheduler::Current(); sched->StopScheduler(); } break; case StateError: { //Do all the cleanup's and exit from here OMX_U32 ii; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateError IN")); iTestStatus = OMX_FALSE; if (ipInBuffer) { for (ii = 0; ii < iInBufferCount; ii++) { if (ipInBuffer[ii]) { OMX_FreeBuffer(ipAppPriv->Handle, iInputPortIndex, ipInBuffer[ii]); ipInBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iInputPortIndex)); } } oscl_free(ipInBuffer); ipInBuffer = NULL; } if (ipInputAvail) { oscl_free(ipInputAvail); ipInputAvail = NULL; } if (ipOutBuffer) { for (ii = 0; ii < iOutBufferCount; ii++) { if (ipOutBuffer[ii]) { OMX_FreeBuffer(ipAppPriv->Handle, iOutputPortIndex, ipOutBuffer[ii]); ipOutBuffer[ii] = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestFlushPort::Run() - Called FreeBuffer for buffer index %d on port %d", ii, iOutputPortIndex)); } } oscl_free(ipOutBuffer); ipOutBuffer = NULL; } if (ipOutReleased) { oscl_free(ipOutReleased); ipOutReleased = NULL; } iState = StateStop; RunIfNotReady(); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestFlushPort::Run() - StateError OUT")); } break; default: { break; } } return ; }
void PVMediaInputAuthorEngineTest::test() { iTotalSuccess = 0; iTotalFail = 0; iTotalError = 0; PVAECmdType resetState = PVAE_CMD_OPEN; while ((iNextTestCase <= iLastTest) || (iNextTestCase < Invalid_Test)) { if (iCurrentTest) { delete iCurrentTest; iCurrentTest = NULL; // Shutdown PVLogger and scheduler before checking mem stats CleanupLoggerScheduler(); #if !(OSCL_BYPASS_MEMMGT) // Print out the memory usage results for this test case OsclAuditCB auditCB; OsclMemInit(auditCB); if (auditCB.pAudit) { MM_Stats_t* stats = auditCB.pAudit->MM_GetStats(""); if (stats) { uint32 alloclks = stats->numAllocs - iNumAllocs; fprintf(iFile, " Mem stats: TotalAllocs(%d), TotalBytes(%d),\n AllocFailures(%d), AllocLeak(%d)\n", stats->totalNumAllocs - iTotalAlloc, stats->totalNumBytes - iTotalBytes, stats->numAllocFails - iAllocFails, stats->numAllocs - iNumAllocs); } else { fprintf(iFile, "Retrieving memory statistics after running test case failed! Memory statistics result is not available.\n"); } } else { fprintf(iFile, "Memory audit not available! Memory statistics result is not available.\n"); } #endif } //iCurrentTest #if !(OSCL_BYPASS_MEMMGT) // Obtain the current mem stats before running the test case OsclAuditCB auditCB; OsclMemInit(auditCB); if (auditCB.pAudit) { MM_Stats_t* stats = auditCB.pAudit->MM_GetStats(""); if (stats) { iTotalAlloc = stats->totalNumAllocs; iTotalBytes = stats->totalNumBytes; iAllocFails = stats->numAllocFails; iNumAllocs = stats->numAllocs; } else { fprintf(iFile, "Retrieving memory statistics before running test case failed! Memory statistics result would be invalid.\n"); } } else { fprintf(iFile, "Memory audit not available! Memory statistics result would be invalid.\n"); } #endif //stop at last test if (iNextTestCase > iLastTest) { iNextTestCase = Invalid_Test; } else { fprintf(iFile, "\nStarting Test %d: ", iNextTestCase); InitLoggerScheduler(); } PVAuthorAsyncTestParam testparam; testparam.iObserver = this; testparam.iTestCase = this; testparam.iTestCaseNum = iNextTestCase; testparam.iStdOut = iFile; switch (iNextTestCase) { case PVMediaInput_Open_Compose_Stop_Test: { fprintf(iFile, "Open Compose Stop test with AVI/WAV MIO Comp:\n"); iCurrentTest = new pv_mediainput_async_test_opencomposestop(testparam, iMediaInputParam, false); // Go to next test ++iNextTestCase; } break; case PVMediaInput_Open_RealTimeCompose_Stop_Test: { fprintf(iFile, "Open Real Time Compose Stop test with AVI/WAV MIO Comp:\n"); iMediaInputParam.iRealTimeAuthoring = true; iCurrentTest = new pv_mediainput_async_test_opencomposestop(testparam, iMediaInputParam, false); // Go to next test ++iNextTestCase; } break; case PVMediaInput_Pause_Resume_Test: { fprintf(iFile, "Pause Resume test with AVI/WAV MIO Comp:\n"); iCurrentTest = new pv_mediainput_async_test_opencomposestop(testparam, iMediaInputParam, true); // Go to next test ++iNextTestCase; } break; case PVMediaInput_ErrorHandling_Test_WrongFormat: { fprintf(iFile, "Error Handling Wrong Format test with AVI/WAV MIO Comp\n"); iMediaInputParam.iIPFileInfo = FILE_NAME_ERROR_HANDLING; iMediaInputParam.iInputFormat = DEFAULTSOURCEFORMATTYPE; iCurrentTest = new pv_mediainput_async_test_errorhandling(testparam, iMediaInputParam, false, true); // Go to next test ++iNextTestCase; } break; case PVMediaInput_ErrorHandling_Test_WrongIPFileName: { fprintf(iFile, "Error Handling wrong IP File test with AVI/WAV MIO Comp\n"); iMediaInputParam.iIPFileInfo = WRONGIPFILENAME_ERRORHANDLING; iMediaInputParam.iInputFormat = DEFAULTSOURCEFORMATTYPE; iCurrentTest = new pv_mediainput_async_test_errorhandling(testparam, iMediaInputParam, false, false); // Go to next test ++iNextTestCase; } break; case PVMediaInput_Reset_Test: { fprintf(iFile, "Reset test with AVI/WAV MIO Comp\n"); switch (resetState) { case PVAE_CMD_OPEN: { fprintf(iFile, "Current reset state: PVAE_CMD_OPEN\n"); } break; case PVAE_CMD_ADD_DATA_SOURCE: { fprintf(iFile, "Current reset state: PVAE_CMD_ADD_DATA_SOURCE\n"); } break; case PVAE_CMD_SELECT_COMPOSER: { fprintf(iFile, "Current reset state: PVAE_CMD_SELECT_COMPOSER\n"); } break; case PVAE_CMD_ADD_MEDIA_TRACK: { fprintf(iFile, "Current reset state: PVAE_CMD_ADD_MEDIA_TRACK\n"); } break; case PVAE_CMD_INIT: { fprintf(iFile, "Current reset state: PVAE_CMD_INIT\n"); } break; case PVAE_CMD_START: { fprintf(iFile, "Current reset state: PVAE_CMD_START\n"); } break; case PVAE_CMD_PAUSE: { fprintf(iFile, "Current reset state: PVAE_CMD_PAUSE\n"); } break; case PVAE_CMD_RECORDING: { fprintf(iFile, "Current reset state: PVAE_CMD_RECORDING\n"); } break; default: break; } iCurrentTest = new pv_mediainput_async_test_reset(testparam, iMediaInputParam, false, resetState); resetState = ((pv_mediainput_async_test_reset*)iCurrentTest)->GetNextResetState(); //run reset test for all states. if (PVAE_CMD_STOP == resetState) { // Go to next test ++iNextTestCase; } } break; case AVI_Input_Longetivity_Test: { fprintf(iFile, "AVI Input Longetivity test:\n"); iCurrentTest = new pv_mediainput_async_test_opencomposestop(testparam, iMediaInputParam, false); // Go to next test ++iNextTestCase; } break; default: { iCurrentTest = NULL; break; } } if (iCurrentTest) { // Setup Scheduler OsclExecScheduler *sched = OsclExecScheduler::Current(); if (sched) { iCurrentTest->StartTest(); #if USE_NATIVE_SCHEDULER // Have PV scheduler use the scheduler native to the system sched->StartNativeScheduler(); #else int32 err; OSCL_TRY(err, sched->StartScheduler();); #endif } else { fprintf(iFile, "ERROR! Scheduler is not available. Test case could not run."); iNextTestCase++; } }
int PlayerDriver::playerThread() { int error; LOGV("InitializeForThread"); if(!InitializeForThread()) { LOGV("InitializeForThread fail"); mPlayer = NULL; mSyncSem->Signal(); return -1; } LOGV("OMX_Init"); PV_MasterOMX_Init(); LOGV("OsclScheduler::Init"); OsclScheduler::Init("AndroidPVWrapper"); LOGV("CreatePlayer"); OSCL_TRY(error, mPlayer = PVPlayerFactory::CreatePlayer(this, this, this)); if (error) { // Just crash the first time someone tries to use it for now? mPlayer = NULL; mSyncSem->Signal(); return -1; } LOGV("AddToScheduler"); AddToScheduler(); LOGV("PendForExec"); PendForExec(); LOGV("OsclActiveScheduler::Current"); OsclExecScheduler *sched = OsclExecScheduler::Current(); LOGV("StartScheduler"); sched->StartScheduler(mSyncSem); LOGV("DeletePlayer"); PVPlayerFactory::DeletePlayer(mPlayer); delete mDownloadContextData; mDownloadContextData = NULL; delete mDataSource; mDataSource = NULL; delete mAudioSink; PVMediaOutputNodeFactory::DeleteMediaOutputNode(mAudioNode); delete mAudioOutputMIO; delete mVideoSink; if (mVideoNode) { PVMediaOutputNodeFactory::DeleteMediaOutputNode(mVideoNode); delete mVideoOutputMIO; } mSyncStatus = OK; mSyncSem->Signal(); // note that we only signal mSyncSem. Deleting it is handled // in enqueueCommand(). This is done because waiting for an // already-deleted OsclSemaphore doesn't work (it blocks), // and it's entirely possible for this thread to exit before // enqueueCommand() gets around to waiting for the semaphore. // do some of destructor's work here // goodbye cruel world delete this; //Moved after the delete this, as Oscl cleanup should be done in the end. //delete this was cleaning up OsclSemaphore objects, eventually causing a crash OsclScheduler::Cleanup(); LOGV("OsclScheduler::Cleanup"); PV_MasterOMX_Deinit(); UninitializeForThread(); return 0; }
void PlayerDriver::handleQuit(PlayerQuit* ec) { OsclExecScheduler *sched = OsclExecScheduler::Current(); sched->StopScheduler(); }