OMX_ERRORTYPE SEC_OSAL_SignalCreate(OMX_HANDLETYPE *eventHandle) { SEC_OSAL_THREADEVENT *event; OMX_ERRORTYPE ret = OMX_ErrorNone; event = (SEC_OSAL_THREADEVENT *)SEC_OSAL_Malloc(sizeof(SEC_OSAL_THREADEVENT)); if (!event) { ret = OMX_ErrorInsufficientResources; goto EXIT; } SEC_OSAL_Memset(event, 0, sizeof(SEC_OSAL_THREADEVENT)); event->signal = OMX_FALSE; ret = SEC_OSAL_MutexCreate(&event->mutex); if (ret != OMX_ErrorNone) { SEC_OSAL_Free(event); goto EXIT; } if (pthread_cond_init(&event->condition, NULL)) { SEC_OSAL_MutexTerminate(event->mutex); SEC_OSAL_Free(event); ret = OMX_ErrorUndefined; goto EXIT; } *eventHandle = (OMX_HANDLETYPE)event; ret = OMX_ErrorNone; EXIT: return ret; }
OMX_ERRORTYPE SEC_OSAL_QueueTerminate(SEC_QUEUE *queueHandle) { int i = 0; SEC_QElem *currentqelem = NULL; SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle; OMX_ERRORTYPE ret = OMX_ErrorNone; if (!queue) return OMX_ErrorBadParameter; for ( i = 0; i < (MAX_QUEUE_ELEMENTS - 2); i++) { currentqelem = queue->first->qNext; SEC_OSAL_Free(queue->first); queue->first = currentqelem; } if(queue->first) { SEC_OSAL_Free(queue->first); queue->first = NULL; } ret = SEC_OSAL_MutexTerminate(queue->qMutex); return ret; }
OMX_ERRORTYPE SEC_OMX_ComponentLoad(SEC_OMX_COMPONENT *sec_component) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_HANDLETYPE libHandle; OMX_COMPONENTTYPE *pOMXComponent; FunctionIn(); OMX_ERRORTYPE (*SEC_OMX_ComponentInit)(OMX_HANDLETYPE hComponent, OMX_STRING componentName); libHandle = SEC_OSAL_dlopen((OMX_STRING)sec_component->libName, RTLD_NOW); if (!libHandle) { ret = OMX_ErrorInvalidComponentName; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponentName, Line:%d", __LINE__); goto EXIT; } SEC_OMX_ComponentInit = SEC_OSAL_dlsym(libHandle, "SEC_OMX_ComponentInit"); if (!SEC_OMX_ComponentInit) { SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)SEC_OSAL_Malloc(sizeof(OMX_COMPONENTTYPE)); INIT_SET_SIZE_VERSION(pOMXComponent, OMX_COMPONENTTYPE); ret = (*SEC_OMX_ComponentInit)((OMX_HANDLETYPE)pOMXComponent, (OMX_STRING)sec_component->componentName); if (ret != OMX_ErrorNone) { SEC_OSAL_Free(pOMXComponent); SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } else { if (SEC_OMX_ComponentAPICheck(pOMXComponent) != OMX_ErrorNone) { if (NULL != pOMXComponent->ComponentDeInit) pOMXComponent->ComponentDeInit(pOMXComponent); SEC_OSAL_Free(pOMXComponent); SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } sec_component->libHandle = libHandle; sec_component->pOMXComponent = pOMXComponent; ret = OMX_ErrorNone; } EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_BASEPORT *pSECPort = NULL; OMX_U32 i = 0, elemNum = 0; SEC_OMX_MESSAGE *message; FunctionIn(); pSECPort = &pSECComponent->pSECPort[portIndex]; if (!CHECK_PORT_ENABLED(pSECPort)) { ret = OMX_ErrorNone; goto EXIT; } if (pSECComponent->currentState!=OMX_StateLoaded) { if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) { message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ); SEC_OSAL_Free(message); } ret = pSECComponent->sec_FreeTunnelBuffer(pSECPort, portIndex); if (OMX_ErrorNone != ret) { goto EXIT; } pSECPort->portDefinition.bPopulated = OMX_FALSE; } else if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { pSECPort->portDefinition.bPopulated = OMX_FALSE; SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource); } else { if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) { message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ); SEC_OSAL_Free(message); } } pSECPort->portDefinition.bPopulated = OMX_FALSE; SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource); } } pSECPort->portDefinition.bEnabled = OMX_FALSE; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_ComponentUnload(SEC_OMX_COMPONENT *sec_component) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; FunctionIn(); if (!sec_component) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = sec_component->pOMXComponent; if (pOMXComponent != NULL) { pOMXComponent->ComponentDeInit(pOMXComponent); SEC_OSAL_Free(pOMXComponent); sec_component->pOMXComponent = NULL; } if (sec_component->libHandle != NULL) { SEC_OSAL_dlclose(sec_component->libHandle); sec_component->libHandle = NULL; } EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_Port_Destructor(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; SEC_OMX_BASEPORT *pSECPort = NULL; FunctionIn(); int i = 0; if (hComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; for (i = 0; i < ALL_PORT_NUM; i++) { pSECPort = &pSECComponent->pSECPort[i]; SEC_OSAL_SemaphoreTerminate(pSECPort->loadedResource); pSECPort->loadedResource = NULL; SEC_OSAL_SemaphoreTerminate(pSECPort->unloadedResource); pSECPort->unloadedResource = NULL; SEC_OSAL_Free(pSECPort->bufferStateAllocate); pSECPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECPort->bufferHeader); pSECPort->bufferHeader = NULL; SEC_OSAL_QueueTerminate(&pSECPort->bufferQ); } SEC_OSAL_Free(pSECComponent->pSECPort); pSECComponent->pSECPort = NULL; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_Component_Unregister(SEC_OMX_COMPONENT_REGLIST *componentList) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OSAL_Memset(componentList, 0, sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM); SEC_OSAL_Free(componentList); EXIT: return ret; }
OMX_ERRORTYPE SEC_OSAL_MutexTerminate(OMX_HANDLETYPE mutexHandle) { pthread_mutex_t *mutex = (pthread_mutex_t *)mutexHandle; if (mutex == NULL) return OMX_ErrorBadParameter; if (pthread_mutex_destroy(mutex) != 0) return OMX_ErrorUndefined; SEC_OSAL_Free(mutex); return OMX_ErrorNone; }
OMX_ERRORTYPE SEC_OMX_BaseComponent_Destructor( OMX_IN OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; OMX_U32 semaValue = 0; FunctionIn(); if (hComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_CommandQueue(pSECComponent, SEC_OMX_CommandComponentDeInit, 0, NULL); SEC_OSAL_SleepMillisec(0); SEC_OSAL_Get_SemaphoreCount(pSECComponent->msgSemaphoreHandle, &semaValue); if (semaValue == 0) SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle); SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle); SEC_OSAL_ThreadTerminate(pSECComponent->hMessageHandler); pSECComponent->hMessageHandler = NULL; SEC_OSAL_MutexTerminate(pSECComponent->compMutex); pSECComponent->compMutex = NULL; SEC_OSAL_SemaphoreTerminate(pSECComponent->msgSemaphoreHandle); pSECComponent->msgSemaphoreHandle = NULL; SEC_OSAL_QueueTerminate(&pSECComponent->messageQ); SEC_OSAL_Free(pSECComponent); pSECComponent = NULL; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_ComponentDeinit(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL; FunctionIn(); if (hComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OSAL_Free(pSECComponent->componentName); pSECComponent->componentName = NULL; pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle; if (pMpeg4Enc != NULL) { SEC_OSAL_Free(pMpeg4Enc); pMpeg4Enc = pSECComponent->hCodecHandle = NULL; } ret = SEC_OMX_VideoEncodeComponentDeinit(pOMXComponent); if (ret != OMX_ErrorNone) { goto EXIT; } ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OSAL_QueueCreate(SEC_QUEUE *queueHandle) { int i = 0; SEC_QElem *newqelem = NULL; SEC_QElem *currentqelem = NULL; SEC_QUEUE *queue = (SEC_QUEUE *)queueHandle; OMX_ERRORTYPE ret = OMX_ErrorNone; if (!queue) return OMX_ErrorBadParameter; ret = SEC_OSAL_MutexCreate(&queue->qMutex); if (ret != OMX_ErrorNone) return ret; queue->first = (SEC_QElem *)SEC_OSAL_Malloc(sizeof(SEC_QElem)); if (queue->first == NULL) return OMX_ErrorInsufficientResources; SEC_OSAL_Memset(queue->first, 0, sizeof(SEC_QElem)); currentqelem = queue->last = queue->first; queue->numElem = 0; for (i = 0; i < (MAX_QUEUE_ELEMENTS - 2); i++) { newqelem = (SEC_QElem *)SEC_OSAL_Malloc(sizeof(SEC_QElem)); if (newqelem == NULL) { while (queue->first != NULL) { currentqelem = queue->first->qNext; SEC_OSAL_Free((OMX_PTR)queue->first); queue->first = currentqelem; } return OMX_ErrorInsufficientResources; } else { SEC_OSAL_Memset(newqelem, 0, sizeof(SEC_QElem)); currentqelem->qNext = newqelem; currentqelem = newqelem; } } currentqelem->qNext = queue->first; return OMX_ErrorNone; }
OMX_ERRORTYPE SEC_OSAL_SignalTerminate(OMX_HANDLETYPE eventHandle) { SEC_OSAL_THREADEVENT *event = (SEC_OSAL_THREADEVENT *)eventHandle; OMX_ERRORTYPE ret = OMX_ErrorNone; if (!event) { ret = OMX_ErrorBadParameter; goto EXIT; } ret = SEC_OSAL_MutexLock(event->mutex); if (ret != OMX_ErrorNone) { ret = OMX_ErrorBadParameter; goto EXIT; } if (pthread_cond_destroy(&event->condition)) { ret = OMX_ErrorUndefined; goto EXIT; } ret = SEC_OSAL_MutexUnlock(event->mutex); if (ret != OMX_ErrorNone) { ret = OMX_ErrorUndefined; goto EXIT; } ret = SEC_OSAL_MutexTerminate(event->mutex); if (ret != OMX_ErrorNone) { ret = OMX_ErrorUndefined; goto EXIT; } SEC_OSAL_Free(event); EXIT: return ret; }
static OMX_ERRORTYPE SEC_OMX_MessageHandlerThread(OMX_PTR threadData) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; SEC_OMX_MESSAGE *message = NULL; OMX_U32 messageType = 0, portIndex = 0; FunctionIn(); if (threadData == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)threadData; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; while (pSECComponent->bExitMessageHandlerThread != OMX_TRUE) { SEC_OSAL_SemaphoreWait(pSECComponent->msgSemaphoreHandle); message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECComponent->messageQ); if (message != NULL) { messageType = message->messageType; switch (messageType) { case OMX_CommandStateSet: ret = SEC_OMX_ComponentStateSet(pOMXComponent, message->messageParam); break; case OMX_CommandFlush: ret = SEC_OMX_BufferFlushProcess(pOMXComponent, message->messageParam); break; case OMX_CommandPortDisable: ret = SEC_OMX_PortDisableProcess(pOMXComponent, message->messageParam); break; case OMX_CommandPortEnable: ret = SEC_OMX_PortEnableProcess(pOMXComponent, message->messageParam); break; case OMX_CommandMarkBuffer: portIndex = message->messageParam; pSECComponent->pSECPort[portIndex].markType.hMarkTargetComponent = ((OMX_MARKTYPE *)message->pCmdData)->hMarkTargetComponent; pSECComponent->pSECPort[portIndex].markType.pMarkData = ((OMX_MARKTYPE *)message->pCmdData)->pMarkData; break; case (OMX_COMMANDTYPE)SEC_OMX_CommandComponentDeInit: pSECComponent->bExitMessageHandlerThread = OMX_TRUE; break; default: break; } SEC_OSAL_Free(message); message = NULL; } } SEC_OSAL_TheadExit(NULL); EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_ComponentStateSet(OMX_COMPONENTTYPE *pOMXComponent, OMX_U32 messageParam) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_MESSAGE *message; OMX_STATETYPE destState = messageParam; OMX_STATETYPE currentState = pSECComponent->currentState; SEC_OMX_BASEPORT *pSECPort = NULL; OMX_S32 countValue = 0; int i = 0, j = 0; FunctionIn(); /* check parameters */ if (currentState == destState) { ret = OMX_ErrorSameState; goto EXIT; } if (currentState == OMX_StateInvalid) { ret = OMX_ErrorInvalidState; goto EXIT; } if ((currentState == OMX_StateLoaded) && (destState == OMX_StateIdle)) { ret = SEC_OMX_Get_Resource(pOMXComponent); if (ret != OMX_ErrorNone) { goto EXIT; } } if (((currentState == OMX_StateIdle) && (destState == OMX_StateLoaded)) || ((currentState == OMX_StateIdle) && (destState == OMX_StateInvalid)) || ((currentState == OMX_StateExecuting) && (destState == OMX_StateInvalid)) || ((currentState == OMX_StatePause) && (destState == OMX_StateInvalid))) { SEC_OMX_Release_Resource(pOMXComponent); } SEC_OSAL_Log(SEC_LOG_TRACE, "destState: %d", destState); switch (destState) { case OMX_StateInvalid: switch (currentState) { case OMX_StateIdle: case OMX_StateExecuting: case OMX_StatePause: case OMX_StateLoaded: case OMX_StateWaitForResources: pSECComponent->currentState = OMX_StateInvalid; if (pSECComponent->hBufferProcess) { pSECComponent->bExitBufferProcessThread = OMX_TRUE; for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &countValue); if (countValue == 0) SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID); } SEC_OSAL_SignalSet(pSECComponent->pauseEvent); SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess); pSECComponent->hBufferProcess = NULL; for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex); pSECComponent->secDataBuffer[i].bufferMutex = NULL; } SEC_OSAL_SignalTerminate(pSECComponent->pauseEvent); for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_SemaphoreTerminate(pSECComponent->pSECPort[i].bufferSemID); pSECComponent->pSECPort[i].bufferSemID = NULL; } } if (pSECComponent->sec_mfc_componentTerminate != NULL) pSECComponent->sec_mfc_componentTerminate(pOMXComponent); break; } ret = OMX_ErrorInvalidState; break; case OMX_StateLoaded: switch (currentState) { case OMX_StateIdle: pSECComponent->bExitBufferProcessThread = OMX_TRUE; for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &countValue); if (countValue == 0) SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID); } SEC_OSAL_SignalSet(pSECComponent->pauseEvent); SEC_OSAL_ThreadTerminate(pSECComponent->hBufferProcess); pSECComponent->hBufferProcess = NULL; for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex); pSECComponent->secDataBuffer[i].bufferMutex = NULL; } SEC_OSAL_SignalTerminate(pSECComponent->pauseEvent); for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_SemaphoreTerminate(pSECComponent->pSECPort[i].bufferSemID); pSECComponent->pSECPort[i].bufferSemID = NULL; } pSECComponent->sec_mfc_componentTerminate(pOMXComponent); for (i = 0; i < (pSECComponent->portParam.nPorts); i++) { pSECPort = (pSECComponent->pSECPort + i); if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > 0) { message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ); if (message != NULL) SEC_OSAL_Free(message); } ret = pSECComponent->sec_FreeTunnelBuffer(pSECComponent, i); if (OMX_ErrorNone != ret) { goto EXIT; } } else { if (CHECK_PORT_ENABLED(pSECPort)) { SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource); pSECPort->portDefinition.bPopulated = OMX_FALSE; } } } pSECComponent->currentState = OMX_StateLoaded; break; case OMX_StateWaitForResources: ret = SEC_OMX_Out_WaitForResource(pOMXComponent); pSECComponent->currentState = OMX_StateLoaded; break; case OMX_StateExecuting: case OMX_StatePause: default: ret = OMX_ErrorIncorrectStateTransition; break; } break; case OMX_StateIdle: switch (currentState) { case OMX_StateLoaded: for (i = 0; i < pSECComponent->portParam.nPorts; i++) { pSECPort = (pSECComponent->pSECPort + i); if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { if (CHECK_PORT_ENABLED(pSECPort)) { ret = pSECComponent->sec_AllocateTunnelBuffer(pSECPort, i); if (ret!=OMX_ErrorNone) goto EXIT; } } else { if (CHECK_PORT_ENABLED(pSECPort)) { SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[i].loadedResource); pSECPort->portDefinition.bPopulated = OMX_TRUE; } } } ret = pSECComponent->sec_mfc_componentInit(pOMXComponent); if (ret != OMX_ErrorNone) { /* * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free */ goto EXIT; } pSECComponent->bExitBufferProcessThread = OMX_FALSE; SEC_OSAL_SignalCreate(&pSECComponent->pauseEvent); for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_SemaphoreCreate(&pSECComponent->pSECPort[i].bufferSemID); } for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_MutexCreate(&pSECComponent->secDataBuffer[i].bufferMutex); } ret = SEC_OSAL_ThreadCreate(&pSECComponent->hBufferProcess, SEC_OMX_BufferProcessThread, pOMXComponent); if (ret != OMX_ErrorNone) { /* * if (CHECK_PORT_TUNNELED == OMX_TRUE) thenTunnel Buffer Free */ SEC_OSAL_SignalTerminate(pSECComponent->pauseEvent); for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_MutexTerminate(pSECComponent->secDataBuffer[i].bufferMutex); pSECComponent->secDataBuffer[i].bufferMutex = NULL; } for (i = 0; i < ALL_PORT_NUM; i++) { SEC_OSAL_SemaphoreTerminate(pSECComponent->pSECPort[i].bufferSemID); pSECComponent->pSECPort[i].bufferSemID = NULL; } ret = OMX_ErrorInsufficientResources; goto EXIT; } pSECComponent->currentState = OMX_StateIdle; break; case OMX_StateExecuting: case OMX_StatePause: SEC_OMX_BufferFlushProcessNoEvent(pOMXComponent, ALL_PORT_INDEX); pSECComponent->currentState = OMX_StateIdle; break; case OMX_StateWaitForResources: pSECComponent->currentState = OMX_StateIdle; break; } break; case OMX_StateExecuting: switch (currentState) { case OMX_StateLoaded: ret = OMX_ErrorIncorrectStateTransition; break; case OMX_StateIdle: for (i = 0; i < pSECComponent->portParam.nPorts; i++) { pSECPort = &pSECComponent->pSECPort[i]; if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort) && CHECK_PORT_ENABLED(pSECPort)) { for (j = 0; j < pSECPort->tunnelBufferNum; j++) { SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID); } } } pSECComponent->transientState = SEC_OMX_TransStateMax; pSECComponent->currentState = OMX_StateExecuting; SEC_OSAL_SignalSet(pSECComponent->pauseEvent); break; case OMX_StatePause: for (i = 0; i < pSECComponent->portParam.nPorts; i++) { pSECPort = &pSECComponent->pSECPort[i]; if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort) && CHECK_PORT_ENABLED(pSECPort)) { OMX_U32 semaValue = 0, cnt = 0; SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[i].bufferSemID, &semaValue); if (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > semaValue) { cnt = SEC_OSAL_GetElemNum(&pSECPort->bufferQ) - semaValue; for (j = 0; j < cnt; j++) { SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID); } } } } pSECComponent->currentState = OMX_StateExecuting; SEC_OSAL_SignalSet(pSECComponent->pauseEvent); break; case OMX_StateWaitForResources: ret = OMX_ErrorIncorrectStateTransition; break; } break; case OMX_StatePause: switch (currentState) { case OMX_StateLoaded: ret = OMX_ErrorIncorrectStateTransition; break; case OMX_StateIdle: pSECComponent->currentState = OMX_StatePause; break; case OMX_StateExecuting: pSECComponent->currentState = OMX_StatePause; break; case OMX_StateWaitForResources: ret = OMX_ErrorIncorrectStateTransition; break; } break; case OMX_StateWaitForResources: switch (currentState) { case OMX_StateLoaded: ret = SEC_OMX_In_WaitForResource(pOMXComponent); pSECComponent->currentState = OMX_StateWaitForResources; break; case OMX_StateIdle: case OMX_StateExecuting: case OMX_StatePause: ret = OMX_ErrorIncorrectStateTransition; break; } break; } EXIT: if (ret == OMX_ErrorNone) { if (pSECComponent->pCallbacks != NULL) { pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent, pSECComponent->callbackData, OMX_EventCmdComplete, OMX_CommandStateSet, destState, NULL); } } else { if (pSECComponent->pCallbacks != NULL) { pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent, pSECComponent->callbackData, OMX_EventError, ret, 0, NULL); } } FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_Component_Register(SEC_OMX_COMPONENT_REGLIST **compList, OMX_U32 *compNum) { OMX_ERRORTYPE ret = OMX_ErrorNone; int componentNum = 0, roleNum = 0, totalCompNum = 0; int read; char *libName; size_t len; const char *errorMsg; DIR *dir; struct dirent *d; int (*SEC_OMX_COMPONENT_Library_Register)(SECRegisterComponentType **secComponents); SECRegisterComponentType **secComponentsTemp; SEC_OMX_COMPONENT_REGLIST *componentList; FunctionIn(); dir = opendir(SEC_OMX_INSTALL_PATH); if (dir == NULL) { ret = OMX_ErrorUndefined; goto EXIT; } componentList = (SEC_OMX_COMPONENT_REGLIST *)SEC_OSAL_Malloc(sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM); SEC_OSAL_Memset(componentList, 0, sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM); libName = SEC_OSAL_Malloc(MAX_OMX_COMPONENT_LIBNAME_SIZE); while ((d = readdir(dir)) != NULL) { OMX_HANDLETYPE soHandle; SEC_OSAL_Log(SEC_LOG_ERROR, "%s", d->d_name); if (SEC_OSAL_Strncmp(d->d_name, "libOMX.SEC.", SEC_OSAL_Strlen("libOMX.SEC.")) == 0) { SEC_OSAL_Memset(libName, 0, MAX_OMX_COMPONENT_LIBNAME_SIZE); SEC_OSAL_Strcpy(libName, SEC_OMX_INSTALL_PATH); SEC_OSAL_Strcat(libName, d->d_name); SEC_OSAL_Log(SEC_LOG_ERROR, "Path & libName : %s", libName); if ((soHandle = SEC_OSAL_dlopen(libName, RTLD_NOW)) != NULL) { SEC_OSAL_dlerror(); /* clear error*/ if ((SEC_OMX_COMPONENT_Library_Register = SEC_OSAL_dlsym(soHandle, "SEC_OMX_COMPONENT_Library_Register")) != NULL) { int i = 0; unsigned int j = 0; componentNum = (*SEC_OMX_COMPONENT_Library_Register)(NULL); secComponentsTemp = (SECRegisterComponentType **)SEC_OSAL_Malloc(sizeof(SECRegisterComponentType*) * componentNum); for (i = 0; i < componentNum; i++) { secComponentsTemp[i] = SEC_OSAL_Malloc(sizeof(SECRegisterComponentType)); SEC_OSAL_Memset(secComponentsTemp[i], 0, sizeof(SECRegisterComponentType)); } (*SEC_OMX_COMPONENT_Library_Register)(secComponentsTemp); for (i = 0; i < componentNum; i++) { SEC_OSAL_Strcpy(componentList[totalCompNum].component.componentName, secComponentsTemp[i]->componentName); for (j = 0; j < secComponentsTemp[i]->totalRoleNum; j++) SEC_OSAL_Strcpy(componentList[totalCompNum].component.roles[j], secComponentsTemp[i]->roles[j]); componentList[totalCompNum].component.totalRoleNum = secComponentsTemp[i]->totalRoleNum; SEC_OSAL_Strcpy(componentList[totalCompNum].libName, libName); totalCompNum++; } for (i = 0; i < componentNum; i++) { SEC_OSAL_Free(secComponentsTemp[i]); } SEC_OSAL_Free(secComponentsTemp); } else { if ((errorMsg = SEC_OSAL_dlerror()) != NULL) SEC_OSAL_Log(SEC_LOG_WARNING, "dlsym failed: %s", errorMsg); } SEC_OSAL_dlclose(soHandle); } else { SEC_OSAL_Log(SEC_LOG_WARNING, "dlopen failed: %s", SEC_OSAL_dlerror()); } } else { /* not a component name line. skip */ continue; } } SEC_OSAL_Free(libName); closedir(dir); *compList = componentList; *compNum = totalCompNum; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_Port_Constructor(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; SEC_OMX_BASEPORT *pSECPort = NULL; SEC_OMX_BASEPORT *pSECInputPort = NULL; SEC_OMX_BASEPORT *pSECOutputPort = NULL; int i = 0; FunctionIn(); if (hComponent == NULL) { ret = OMX_ErrorBadParameter; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__); goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__); goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; INIT_SET_SIZE_VERSION(&pSECComponent->portParam, OMX_PORT_PARAM_TYPE); pSECComponent->portParam.nPorts = ALL_PORT_NUM; pSECComponent->portParam.nStartPortNumber = INPUT_PORT_INDEX; pSECPort = SEC_OSAL_Malloc(sizeof(SEC_OMX_BASEPORT) * ALL_PORT_NUM); if (pSECPort == NULL) { ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } SEC_OSAL_Memset(pSECPort, 0, sizeof(SEC_OMX_BASEPORT) * ALL_PORT_NUM); pSECComponent->pSECPort = pSECPort; /* Input Port */ pSECInputPort = &pSECPort[INPUT_PORT_INDEX]; SEC_OSAL_QueueCreate(&pSECInputPort->bufferQ); pSECInputPort->bufferHeader = SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM); if (pSECInputPort->bufferHeader == NULL) { SEC_OSAL_Free(pSECPort); pSECPort = NULL; ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } SEC_OSAL_Memset(pSECInputPort->bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM); pSECInputPort->bufferStateAllocate = SEC_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM); if (pSECInputPort->bufferStateAllocate == NULL) { SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } SEC_OSAL_Memset(pSECInputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM); pSECInputPort->bufferSemID = NULL; pSECInputPort->assignedBufferNum = 0; pSECInputPort->portState = OMX_StateMax; pSECInputPort->bIsPortFlushed = OMX_FALSE; pSECInputPort->bIsPortDisabled = OMX_FALSE; pSECInputPort->tunneledComponent = NULL; pSECInputPort->tunneledPort = 0; pSECInputPort->tunnelBufferNum = 0; pSECInputPort->bufferSupplier = OMX_BufferSupplyUnspecified; pSECInputPort->tunnelFlags = 0; pSECInputPort->eControlRate = OMX_Video_ControlRateDisable; ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->loadedResource); if (ret != OMX_ErrorNone) { SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; goto EXIT; } ret = SEC_OSAL_SemaphoreCreate(&pSECInputPort->unloadedResource); if (ret != OMX_ErrorNone) { SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource); pSECInputPort->loadedResource = NULL; SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; goto EXIT; } INIT_SET_SIZE_VERSION(&pSECInputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE); pSECInputPort->portDefinition.nPortIndex = INPUT_PORT_INDEX; pSECInputPort->portDefinition.eDir = OMX_DirInput; pSECInputPort->portDefinition.nBufferCountActual = 0; pSECInputPort->portDefinition.nBufferCountMin = 0; pSECInputPort->portDefinition.nBufferSize = 0; pSECInputPort->portDefinition.bEnabled = OMX_FALSE; pSECInputPort->portDefinition.bPopulated = OMX_FALSE; pSECInputPort->portDefinition.eDomain = OMX_PortDomainMax; pSECInputPort->portDefinition.bBuffersContiguous = OMX_FALSE; pSECInputPort->portDefinition.nBufferAlignment = 0; pSECInputPort->markType.hMarkTargetComponent = NULL; pSECInputPort->markType.pMarkData = NULL; /* Output Port */ pSECOutputPort = &pSECPort[OUTPUT_PORT_INDEX]; SEC_OSAL_QueueCreate(&pSECOutputPort->bufferQ); pSECOutputPort->bufferHeader = SEC_OSAL_Malloc(sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM); if (pSECOutputPort->bufferHeader == NULL) { SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource); pSECInputPort->unloadedResource = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource); pSECInputPort->loadedResource = NULL; SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; ret = OMX_ErrorInsufficientResources; goto EXIT; } SEC_OSAL_Memset(pSECOutputPort->bufferHeader, 0, sizeof(OMX_BUFFERHEADERTYPE*) * MAX_BUFFER_NUM); pSECOutputPort->bufferStateAllocate = SEC_OSAL_Malloc(sizeof(OMX_U32) * MAX_BUFFER_NUM); if (pSECOutputPort->bufferStateAllocate == NULL) { SEC_OSAL_Free(pSECOutputPort->bufferHeader); pSECOutputPort->bufferHeader = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource); pSECInputPort->unloadedResource = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource); pSECInputPort->loadedResource = NULL; SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; ret = OMX_ErrorInsufficientResources; goto EXIT; } SEC_OSAL_Memset(pSECOutputPort->bufferStateAllocate, 0, sizeof(OMX_U32) * MAX_BUFFER_NUM); pSECOutputPort->bufferSemID = NULL; pSECOutputPort->assignedBufferNum = 0; pSECOutputPort->portState = OMX_StateMax; pSECOutputPort->bIsPortFlushed = OMX_FALSE; pSECOutputPort->bIsPortDisabled = OMX_FALSE; pSECOutputPort->tunneledComponent = NULL; pSECOutputPort->tunneledPort = 0; pSECOutputPort->tunnelBufferNum = 0; pSECOutputPort->bufferSupplier = OMX_BufferSupplyUnspecified; pSECOutputPort->tunnelFlags = 0; pSECOutputPort->eControlRate = OMX_Video_ControlRateDisable; ret = SEC_OSAL_SemaphoreCreate(&pSECOutputPort->loadedResource); if (ret != OMX_ErrorNone) { SEC_OSAL_Free(pSECOutputPort->bufferStateAllocate); pSECOutputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECOutputPort->bufferHeader); pSECOutputPort->bufferHeader = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource); pSECInputPort->unloadedResource = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource); pSECInputPort->loadedResource = NULL; SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; goto EXIT; } ret = SEC_OSAL_SemaphoreCreate(&pSECOutputPort->unloadedResource); if (ret != OMX_ErrorNone) { SEC_OSAL_SemaphoreTerminate(pSECOutputPort->loadedResource); pSECOutputPort->loadedResource = NULL; SEC_OSAL_Free(pSECOutputPort->bufferStateAllocate); pSECOutputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECOutputPort->bufferHeader); pSECOutputPort->bufferHeader = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->unloadedResource); pSECInputPort->unloadedResource = NULL; SEC_OSAL_SemaphoreTerminate(pSECInputPort->loadedResource); pSECInputPort->loadedResource = NULL; SEC_OSAL_Free(pSECInputPort->bufferStateAllocate); pSECInputPort->bufferStateAllocate = NULL; SEC_OSAL_Free(pSECInputPort->bufferHeader); pSECInputPort->bufferHeader = NULL; SEC_OSAL_Free(pSECPort); pSECPort = NULL; goto EXIT; } INIT_SET_SIZE_VERSION(&pSECOutputPort->portDefinition, OMX_PARAM_PORTDEFINITIONTYPE); pSECOutputPort->portDefinition.nPortIndex = OUTPUT_PORT_INDEX; pSECOutputPort->portDefinition.eDir = OMX_DirOutput; pSECOutputPort->portDefinition.nBufferCountActual = 0; pSECOutputPort->portDefinition.nBufferCountMin = 0; pSECOutputPort->portDefinition.nBufferSize = 0; pSECOutputPort->portDefinition.bEnabled = OMX_FALSE; pSECOutputPort->portDefinition.bPopulated = OMX_FALSE; pSECOutputPort->portDefinition.eDomain = OMX_PortDomainMax; pSECOutputPort->portDefinition.bBuffersContiguous = OMX_FALSE; pSECOutputPort->portDefinition.nBufferAlignment = 0; pSECOutputPort->markType.hMarkTargetComponent = NULL; pSECOutputPort->markType.pMarkData = NULL; pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE; pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE; pSECComponent->checkTimeStamp.startTimeStamp = 0; pSECComponent->checkTimeStamp.nStartFlags = 0x0; pOMXComponent->EmptyThisBuffer = &SEC_OMX_EmptyThisBuffer; pOMXComponent->FillThisBuffer = &SEC_OMX_FillThisBuffer; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_Component_Register(SEC_OMX_COMPONENT_REGLIST **compList, OMX_U32 *compNum) { OMX_ERRORTYPE ret = OMX_ErrorNone; int componentNum = 0, roleNum = 0, totalCompNum = 0; int read; char *omxregistryfile = NULL; char *line = NULL; char *libName; FILE *omxregistryfp; size_t len; OMX_HANDLETYPE soHandle; const char *errorMsg; int (*SEC_OMX_COMPONENT_Library_Register)(SECRegisterComponentType **secComponents); SECRegisterComponentType **secComponentsTemp; SEC_OMX_COMPONENT_REGLIST *componentList; FunctionIn(); omxregistryfile = SEC_OSAL_Malloc(strlen("/system/etc/") + strlen(REGISTRY_FILENAME) + 2); SEC_OSAL_Strcpy(omxregistryfile, "/system/etc/"); SEC_OSAL_Strcat(omxregistryfile, REGISTRY_FILENAME); omxregistryfp = fopen(omxregistryfile, "r"); if (omxregistryfp == NULL) { ret = OMX_ErrorUndefined; goto EXIT; } SEC_OSAL_Free(omxregistryfile); fseek(omxregistryfp, 0, 0); componentList = (SEC_OMX_COMPONENT_REGLIST *)SEC_OSAL_Malloc(sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM); SEC_OSAL_Memset(componentList, 0, sizeof(SEC_OMX_COMPONENT_REGLIST) * MAX_OMX_COMPONENT_NUM); libName = SEC_OSAL_Malloc(MAX_OMX_COMPONENT_LIBNAME_SIZE); while ((read = getline(&line, &len, omxregistryfp)) != -1) { if ((*line == 'l') && (*(line + 1) == 'i') && (*(line + 2) == 'b') && (*(line + 3) == 'O') && (*(line + 4) == 'M') && (*(line + 5) == 'X')) { SEC_OSAL_Memset(libName, 0, MAX_OMX_COMPONENT_LIBNAME_SIZE); SEC_OSAL_Strncpy(libName, line, SEC_OSAL_Strlen(line)-1); SEC_OSAL_Log(SEC_LOG_TRACE, "libName : %s", libName); if ((soHandle = SEC_OSAL_dlopen(libName, RTLD_NOW)) != NULL) { SEC_OSAL_dlerror(); /* clear error*/ if ((SEC_OMX_COMPONENT_Library_Register = SEC_OSAL_dlsym(soHandle, "SEC_OMX_COMPONENT_Library_Register")) != NULL) { int i = 0, j = 0; componentNum = (*SEC_OMX_COMPONENT_Library_Register)(NULL); secComponentsTemp = (SECRegisterComponentType **)SEC_OSAL_Malloc(sizeof(SECRegisterComponentType*) * componentNum); for (i = 0; i < componentNum; i++) { secComponentsTemp[i] = SEC_OSAL_Malloc(sizeof(SECRegisterComponentType)); SEC_OSAL_Memset(secComponentsTemp[i], 0, sizeof(SECRegisterComponentType)); } (*SEC_OMX_COMPONENT_Library_Register)(secComponentsTemp); for (i = 0; i < componentNum; i++) { SEC_OSAL_Strcpy(componentList[totalCompNum].component.componentName, secComponentsTemp[i]->componentName); for (j = 0; j < secComponentsTemp[i]->totalRoleNum; j++) SEC_OSAL_Strcpy(componentList[totalCompNum].component.roles[j], secComponentsTemp[i]->roles[j]); componentList[totalCompNum].component.totalRoleNum = secComponentsTemp[i]->totalRoleNum; SEC_OSAL_Strcpy(componentList[totalCompNum].libName, libName); totalCompNum++; } for (i = 0; i < componentNum; i++) { SEC_OSAL_Free(secComponentsTemp[i]); } SEC_OSAL_Free(secComponentsTemp); } else { if ((errorMsg = SEC_OSAL_dlerror()) != NULL) SEC_OSAL_Log(SEC_LOG_WARNING, "dlsym failed: %s", errorMsg); } SEC_OSAL_dlclose(soHandle); } else { SEC_OSAL_Log(SEC_LOG_WARNING, "dlopen failed: %s", SEC_OSAL_dlerror()); } } else { /* not a component name line. skip */ continue; } } SEC_OSAL_Free(libName); fclose(omxregistryfp); *compList = componentList; *compNum = totalCompNum; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_FlushPort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_BASEPORT *pSECPort = NULL; OMX_BUFFERHEADERTYPE *bufferHeader = NULL; SEC_OMX_MESSAGE *message = NULL; OMX_U32 flushNum = 0; OMX_S32 semValue = 0; FunctionIn(); pSECPort = &pSECComponent->pSECPort[portIndex]; while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) > 0) { SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[portIndex].bufferSemID, &semValue); if (semValue == 0) SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[portIndex].bufferSemID); SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID); message = (SEC_OMX_MESSAGE *)SEC_OSAL_Dequeue(&pSECPort->bufferQ); if (message != NULL) { bufferHeader = (OMX_BUFFERHEADERTYPE *)message->pCmdData; bufferHeader->nFilledLen = 0; if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { if (portIndex) { OMX_EmptyThisBuffer(pSECPort->tunneledComponent, bufferHeader); } else { OMX_FillThisBuffer(pSECPort->tunneledComponent, bufferHeader); } SEC_OSAL_Free(message); message = NULL; } else if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { SEC_OSAL_Log(SEC_LOG_ERROR, "Tunneled mode is not working, Line:%d", __LINE__); ret = OMX_ErrorNotImplemented; SEC_OSAL_Queue(&pSECPort->bufferQ, pSECPort); goto EXIT; } else { if (portIndex == OUTPUT_PORT_INDEX) { pSECComponent->pCallbacks->FillBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader); } else { pSECComponent->pCallbacks->EmptyBufferDone(pOMXComponent, pSECComponent->callbackData, bufferHeader); } SEC_OSAL_Free(message); message = NULL; } } } if (pSECComponent->secDataBuffer[portIndex].dataValid == OMX_TRUE) { if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { message = SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE)); message->pCmdData = pSECComponent->secDataBuffer[portIndex].bufferHeader; message->messageType = 0; message->messageParam = -1; SEC_OSAL_Queue(&pSECPort->bufferQ, message); pSECComponent->sec_BufferReset(pOMXComponent, portIndex); } else { if (portIndex == INPUT_PORT_INDEX) pSECComponent->sec_InputBufferReturn(pOMXComponent); else if (portIndex == OUTPUT_PORT_INDEX) pSECComponent->sec_OutputBufferReturn(pOMXComponent); } } if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) < pSECPort->assignedBufferNum) { SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID); } if (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) != pSECPort->assignedBufferNum) SEC_OSAL_SetElemNum(&pSECPort->bufferQ, pSECPort->assignedBufferNum); } else { while(1) { int cnt; SEC_OSAL_Get_SemaphoreCount(pSECComponent->pSECPort[portIndex].bufferSemID, &cnt); if (cnt == 0) break; SEC_OSAL_SemaphoreWait(pSECComponent->pSECPort[portIndex].bufferSemID); } SEC_OSAL_SetElemNum(&pSECPort->bufferQ, 0); } pSECComponent->processData[portIndex].dataLen = 0; pSECComponent->processData[portIndex].nFlags = 0; pSECComponent->processData[portIndex].remainDataLen = 0; pSECComponent->processData[portIndex].timeStamp = 0; pSECComponent->processData[portIndex].usedDataLen = 0; EXIT: FunctionOut(); return ret; }