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