jenna
/
hardware_samsung
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
66 Commits
3 Branches
0 Tags
10 MiB
Tag: Branch: Tree: c5b109bede
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c5b109bede'
${ noResults }
hardware_samsung/exynos/multimedia/openmax/component/common/SEC_OMX_Basecomponent.c

1536 lines
50 KiB
Raw Normal View History Unescape

initial commit, taken and modified from linaro/insignal
13 years ago
/*
*
* Copyright 2010 Samsung Electronics S.LSI Co. LTD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* @file SEC_OMX_Basecomponent.c
* @brief
* @author SeungBeom Kim (sbcrux.kim@samsung.com)
* Yunji Kim (yunji.kim@samsung.com)
* @version 1.1.0
* @history
* 2010.7.15 : Create
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "SEC_OSAL_Event.h"
#include "SEC_OSAL_Thread.h"
#include "SEC_OSAL_ETC.h"
#include "SEC_OSAL_Semaphore.h"
#include "SEC_OSAL_Mutex.h"
#include "SEC_OMX_Baseport.h"
#include "SEC_OMX_Basecomponent.h"
#include "SEC_OMX_Resourcemanager.h"
#include "SEC_OMX_Macros.h"
#undef SEC_LOG_TAG
#define SEC_LOG_TAG "SEC_BASE_COMP"
#define SEC_LOG_OFF
#include "SEC_OSAL_Log.h"
/* Change CHECK_SIZE_VERSION Macro */
OMX_ERRORTYPE SEC_OMX_Check_SizeVersion(OMX_PTR header, OMX_U32 size)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_VERSIONTYPE* version = NULL;
if (header == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
version = (OMX_VERSIONTYPE*)((char*)header + sizeof(OMX_U32));
if (*((OMX_U32*)header) != size) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (version->s.nVersionMajor != VERSIONMAJOR_NUMBER ||
version->s.nVersionMinor != VERSIONMINOR_NUMBER) {
ret = OMX_ErrorVersionMismatch;
goto EXIT;
}
ret = OMX_ErrorNone;
EXIT:
return ret;
}
OMX_ERRORTYPE SEC_OMX_GetComponentVersion(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_OUT OMX_STRING pComponentName,
OMX_OUT OMX_VERSIONTYPE *pComponentVersion,
OMX_OUT OMX_VERSIONTYPE *pSpecVersion,
OMX_OUT OMX_UUIDTYPE *pComponentUUID)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
OMX_U32 compUUID[3];
FunctionIn();
/* check parameters */
if (hComponent == NULL ||
pComponentName == NULL || pComponentVersion == NULL ||
pSpecVersion == NULL || pComponentUUID == 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;
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
SEC_OSAL_Strcpy(pComponentName, pSECComponent->componentName);
SEC_OSAL_Memcpy(pComponentVersion, &(pSECComponent->componentVersion), sizeof(OMX_VERSIONTYPE));
SEC_OSAL_Memcpy(pSpecVersion, &(pSECComponent->specVersion), sizeof(OMX_VERSIONTYPE));
/* Fill UUID with handle address, PID and UID.
* This should guarantee uiniqness */
compUUID[0] = (OMX_U32)pOMXComponent;
compUUID[1] = getpid();
compUUID[2] = getuid();
SEC_OSAL_Memcpy(*pComponentUUID, compUUID, 3 * sizeof(*compUUID));
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_GetState (
OMX_IN OMX_HANDLETYPE hComponent,
OMX_OUT OMX_STATETYPE *pState)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
FunctionIn();
if (hComponent == NULL || pState == 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;
*pState = pSECComponent->currentState;
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
static OMX_ERRORTYPE SEC_OMX_BufferProcessThread(OMX_PTR threadData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
SEC_OMX_MESSAGE *message = NULL;
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;
pSECComponent->sec_BufferProcess(pOMXComponent);
SEC_OSAL_ThreadExit(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;
unsigned int i = 0, j = 0;
int k = 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_StateWaitForResources:
SEC_OMX_Out_WaitForResource(pOMXComponent);
case OMX_StateIdle:
case OMX_StateExecuting:
case OMX_StatePause:
case OMX_StateLoaded:
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);
ret = OMX_ErrorInvalidState;
break;
default:
ret = OMX_ErrorInvalidState;
break;
}
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(pSECPort, 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 (pSECPort == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
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++) {
ret = SEC_OSAL_SemaphoreCreate(&pSECComponent->pSECPort[i].bufferSemID);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
}
for (i = 0; i < ALL_PORT_NUM; i++) {
ret = SEC_OSAL_MutexCreate(&pSECComponent->secDataBuffer[i].bufferMutex);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
}
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;
default:
ret = OMX_ErrorIncorrectStateTransition;
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_S32 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 (k = 0; k < cnt; k++) {
SEC_OSAL_SemaphorePost(pSECComponent->pSECPort[i].bufferSemID);
}
}
}
}
pSECComponent->currentState = OMX_StateExecuting;
SEC_OSAL_SignalSet(pSECComponent->pauseEvent);
break;
case OMX_StateWaitForResources:
ret = OMX_ErrorIncorrectStateTransition;
break;
default:
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;
default:
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;
default:
ret = OMX_ErrorIncorrectStateTransition;
break;
}
break;
default:
ret = OMX_ErrorIncorrectStateTransition;
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;
}
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_FALSE) {
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_ThreadExit(NULL);
EXIT:
FunctionOut();
return ret;
}
static OMX_ERRORTYPE SEC_StateSet(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
{
OMX_U32 destState = nParam;
OMX_U32 i = 0;
if ((destState == OMX_StateIdle) && (pSECComponent->currentState == OMX_StateLoaded)) {
pSECComponent->transientState = SEC_OMX_TransStateLoadedToIdle;
for(i = 0; i < pSECComponent->portParam.nPorts; i++) {
pSECComponent->pSECPort[i].portState = OMX_StateIdle;
}
SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateIdle");
} else if ((destState == OMX_StateLoaded) && (pSECComponent->currentState == OMX_StateIdle)) {
pSECComponent->transientState = SEC_OMX_TransStateIdleToLoaded;
for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
pSECComponent->pSECPort[i].portState = OMX_StateLoaded;
}
SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateLoaded");
} else if ((destState == OMX_StateIdle) && (pSECComponent->currentState == OMX_StateExecuting)) {
pSECComponent->transientState = SEC_OMX_TransStateExecutingToIdle;
SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateIdle");
} else if ((destState == OMX_StateExecuting) && (pSECComponent->currentState == OMX_StateIdle)) {
pSECComponent->transientState = SEC_OMX_TransStateIdleToExecuting;
SEC_OSAL_Log(SEC_LOG_TRACE, "to OMX_StateExecuting");
} else if (destState == OMX_StateInvalid) {
for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
pSECComponent->pSECPort[i].portState = OMX_StateInvalid;
}
}
return OMX_ErrorNone;
}
static OMX_ERRORTYPE SEC_SetPortFlush(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASEPORT *pSECPort = NULL;
OMX_S32 portIndex = nParam;
OMX_U16 i = 0, cnt = 0, index = 0;
if ((pSECComponent->currentState == OMX_StateExecuting) ||
(pSECComponent->currentState == OMX_StatePause)) {
if ((portIndex != ALL_PORT_INDEX) &&
((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
/*********************
* need flush event set ?????
**********************/
cnt = (portIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
for (i = 0; i < cnt; i++) {
if (portIndex == ALL_PORT_INDEX)
index = i;
else
index = portIndex;
pSECComponent->pSECPort[index].bIsPortFlushed = OMX_TRUE;
}
} else {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
ret = OMX_ErrorNone;
EXIT:
return ret;
}
static OMX_ERRORTYPE SEC_SetPortEnable(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASEPORT *pSECPort = NULL;
OMX_S32 portIndex = nParam;
OMX_U16 i = 0, cnt = 0;
FunctionIn();
if ((portIndex != ALL_PORT_INDEX) &&
((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
if (portIndex == ALL_PORT_INDEX) {
for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
pSECPort = &pSECComponent->pSECPort[i];
if (CHECK_PORT_ENABLED(pSECPort)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
} else {
pSECPort->portState = OMX_StateIdle;
}
}
} else {
pSECPort = &pSECComponent->pSECPort[portIndex];
if (CHECK_PORT_ENABLED(pSECPort)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
} else {
pSECPort->portState = OMX_StateIdle;
}
}
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
static OMX_ERRORTYPE SEC_SetPortDisable(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASEPORT *pSECPort = NULL;
OMX_S32 portIndex = nParam;
OMX_U16 i = 0, cnt = 0;
FunctionIn();
if ((portIndex != ALL_PORT_INDEX) &&
((OMX_S32)portIndex >= (OMX_S32)pSECComponent->portParam.nPorts)) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
if (portIndex == ALL_PORT_INDEX) {
for (i = 0; i < pSECComponent->portParam.nPorts; i++) {
pSECPort = &pSECComponent->pSECPort[i];
if (!CHECK_PORT_ENABLED(pSECPort)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
pSECPort->portState = OMX_StateLoaded;
pSECPort->bIsPortDisabled = OMX_TRUE;
}
} else {
pSECPort = &pSECComponent->pSECPort[portIndex];
pSECPort->portState = OMX_StateLoaded;
pSECPort->bIsPortDisabled = OMX_TRUE;
}
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
static OMX_ERRORTYPE SEC_SetMarkBuffer(SEC_OMX_BASECOMPONENT *pSECComponent, OMX_U32 nParam)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASEPORT *pSECPort = NULL;
OMX_U32 portIndex = nParam;
OMX_U16 i = 0, cnt = 0;
if (nParam >= pSECComponent->portParam.nPorts) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
if ((pSECComponent->currentState == OMX_StateExecuting) ||
(pSECComponent->currentState == OMX_StatePause)) {
ret = OMX_ErrorNone;
} else {
ret = OMX_ErrorIncorrectStateOperation;
}
EXIT:
return ret;
}
static OMX_ERRORTYPE SEC_OMX_CommandQueue(
SEC_OMX_BASECOMPONENT *pSECComponent,
OMX_COMMANDTYPE Cmd,
OMX_U32 nParam,
OMX_PTR pCmdData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_MESSAGE *command = (SEC_OMX_MESSAGE *)SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
if (command == NULL) {
ret = OMX_ErrorInsufficientResources;
goto EXIT;
}
command->messageType = (OMX_U32)Cmd;
command->messageParam = nParam;
command->pCmdData = pCmdData;
ret = SEC_OSAL_Queue(&pSECComponent->messageQ, (void *)command);
if (ret != 0) {
ret = OMX_ErrorUndefined;
goto EXIT;
}
ret = SEC_OSAL_SemaphorePost(pSECComponent->msgSemaphoreHandle);
EXIT:
return ret;
}
OMX_ERRORTYPE SEC_OMX_SendCommand(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_COMMANDTYPE Cmd,
OMX_IN OMX_U32 nParam,
OMX_IN OMX_PTR pCmdData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
SEC_OMX_MESSAGE *message = NULL;
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;
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
switch (Cmd) {
case OMX_CommandStateSet :
SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandStateSet");
SEC_StateSet(pSECComponent, nParam);
break;
case OMX_CommandFlush :
SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandFlush");
ret = SEC_SetPortFlush(pSECComponent, nParam);
if (ret != OMX_ErrorNone)
goto EXIT;
break;
case OMX_CommandPortDisable :
SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandPortDisable");
ret = SEC_SetPortDisable(pSECComponent, nParam);
if (ret != OMX_ErrorNone)
goto EXIT;
break;
case OMX_CommandPortEnable :
SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandPortEnable");
ret = SEC_SetPortEnable(pSECComponent, nParam);
if (ret != OMX_ErrorNone)
goto EXIT;
break;
case OMX_CommandMarkBuffer :
SEC_OSAL_Log(SEC_LOG_TRACE, "Command: OMX_CommandMarkBuffer");
ret = SEC_SetMarkBuffer(pSECComponent, nParam);
if (ret != OMX_ErrorNone)
goto EXIT;
break;
/*
case SEC_CommandFillBuffer :
case SEC_CommandEmptyBuffer :
case SEC_CommandDeInit :
*/
default:
break;
}
ret = SEC_OMX_CommandQueue(pSECComponent, Cmd, nParam, pCmdData);
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_GetParameter(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nParamIndex,
OMX_INOUT OMX_PTR ComponentParameterStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if (ComponentParameterStructure == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
switch (nParamIndex) {
case (OMX_INDEXTYPE)OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
{
/* For Android PV OpenCORE */
OMXComponentCapabilityFlagsType *capabilityFlags = (OMXComponentCapabilityFlagsType *)ComponentParameterStructure;
SEC_OSAL_Memcpy(capabilityFlags, &pSECComponent->capabilityFlags, sizeof(OMXComponentCapabilityFlagsType));
}
break;
case OMX_IndexParamAudioInit:
case OMX_IndexParamVideoInit:
case OMX_IndexParamImageInit:
case OMX_IndexParamOtherInit:
{
OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
portParam->nPorts = 0;
portParam->nStartPortNumber = 0;
}
break;
case OMX_IndexParamPortDefinition:
{
OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
OMX_U32 portIndex = portDefinition->nPortIndex;
SEC_OMX_BASEPORT *pSECPort;
if (portIndex >= pSECComponent->portParam.nPorts) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
pSECPort = &pSECComponent->pSECPort[portIndex];
SEC_OSAL_Memcpy(portDefinition, &pSECPort->portDefinition, portDefinition->nSize);
}
break;
case OMX_IndexParamPriorityMgmt:
{
OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
ret = SEC_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
compPriority->nGroupID = pSECComponent->compPriority.nGroupID;
compPriority->nGroupPriority = pSECComponent->compPriority.nGroupPriority;
}
break;
case OMX_IndexParamCompBufferSupplier:
{
OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
OMX_U32 portIndex = bufferSupplier->nPortIndex;
SEC_OMX_BASEPORT *pSECPort;
if ((pSECComponent->currentState == OMX_StateLoaded) ||
(pSECComponent->currentState == OMX_StateWaitForResources)) {
if (portIndex >= pSECComponent->portParam.nPorts) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
pSECPort = &pSECComponent->pSECPort[portIndex];
if (pSECPort->portDefinition.eDir == OMX_DirInput) {
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
} else if (CHECK_PORT_TUNNELED(pSECPort)) {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
} else {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
}
} else {
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyOutput;
} else if (CHECK_PORT_TUNNELED(pSECPort)) {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyInput;
} else {
bufferSupplier->eBufferSupplier = OMX_BufferSupplyUnspecified;
}
}
}
else
{
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
}
break;
default:
{
ret = OMX_ErrorUnsupportedIndex;
goto EXIT;
}
break;
}
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_SetParameter(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nIndex,
OMX_IN OMX_PTR ComponentParameterStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if (ComponentParameterStructure == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
switch (nIndex) {
case OMX_IndexParamAudioInit:
case OMX_IndexParamVideoInit:
case OMX_IndexParamImageInit:
case OMX_IndexParamOtherInit:
{
OMX_PORT_PARAM_TYPE *portParam = (OMX_PORT_PARAM_TYPE *)ComponentParameterStructure;
ret = SEC_OMX_Check_SizeVersion(portParam, sizeof(OMX_PORT_PARAM_TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if ((pSECComponent->currentState != OMX_StateLoaded) &&
(pSECComponent->currentState != OMX_StateWaitForResources)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
ret = OMX_ErrorUndefined;
/* SEC_OSAL_Memcpy(&pSECComponent->portParam, portParam, sizeof(OMX_PORT_PARAM_TYPE)); */
}
break;
case OMX_IndexParamPortDefinition:
{
OMX_PARAM_PORTDEFINITIONTYPE *portDefinition = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
OMX_U32 portIndex = portDefinition->nPortIndex;
SEC_OMX_BASEPORT *pSECPort;
if (portIndex >= pSECComponent->portParam.nPorts) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(portDefinition, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
pSECPort = &pSECComponent->pSECPort[portIndex];
if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
}
if (portDefinition->nBufferCountActual < pSECPort->portDefinition.nBufferCountMin) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
SEC_OSAL_Memcpy(&pSECPort->portDefinition, portDefinition, portDefinition->nSize);
}
break;
case OMX_IndexParamPriorityMgmt:
{
OMX_PRIORITYMGMTTYPE *compPriority = (OMX_PRIORITYMGMTTYPE *)ComponentParameterStructure;
if ((pSECComponent->currentState != OMX_StateLoaded) &&
(pSECComponent->currentState != OMX_StateWaitForResources)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(compPriority, sizeof(OMX_PRIORITYMGMTTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
pSECComponent->compPriority.nGroupID = compPriority->nGroupID;
pSECComponent->compPriority.nGroupPriority = compPriority->nGroupPriority;
}
break;
case OMX_IndexParamCompBufferSupplier:
{
OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplier = (OMX_PARAM_BUFFERSUPPLIERTYPE *)ComponentParameterStructure;
OMX_U32 portIndex = bufferSupplier->nPortIndex;
SEC_OMX_BASEPORT *pSECPort = NULL;
if (portIndex >= pSECComponent->portParam.nPorts) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(bufferSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
pSECPort = &pSECComponent->pSECPort[portIndex];
if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
}
if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyUnspecified) {
ret = OMX_ErrorNone;
goto EXIT;
}
if (CHECK_PORT_TUNNELED(pSECPort) == 0) {
ret = OMX_ErrorNone; /*OMX_ErrorNone ?????*/
goto EXIT;
}
if (pSECPort->portDefinition.eDir == OMX_DirInput) {
if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
/*
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
ret = OMX_ErrorNone;
}
*/
pSECPort->tunnelFlags |= SEC_TUNNEL_IS_SUPPLIER;
bufferSupplier->nPortIndex = pSECPort->tunneledPort;
ret = OMX_SetParameter(pSECPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
goto EXIT;
} else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
ret = OMX_ErrorNone;
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
pSECPort->tunnelFlags &= ~SEC_TUNNEL_IS_SUPPLIER;
bufferSupplier->nPortIndex = pSECPort->tunneledPort;
ret = OMX_SetParameter(pSECPort->tunneledComponent, OMX_IndexParamCompBufferSupplier, bufferSupplier);
}
goto EXIT;
}
} else if (pSECPort->portDefinition.eDir == OMX_DirOutput) {
if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyInput) {
ret = OMX_ErrorNone;
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
pSECPort->tunnelFlags &= ~SEC_TUNNEL_IS_SUPPLIER;
ret = OMX_ErrorNone;
}
goto EXIT;
} else if (bufferSupplier->eBufferSupplier == OMX_BufferSupplyOutput) {
/*
if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) {
ret = OMX_ErrorNone;
}
*/
pSECPort->tunnelFlags |= SEC_TUNNEL_IS_SUPPLIER;
ret = OMX_ErrorNone;
goto EXIT;
}
}
}
break;
default:
{
ret = OMX_ErrorUnsupportedIndex;
goto EXIT;
}
break;
}
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_GetConfig(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nIndex,
OMX_INOUT OMX_PTR pComponentConfigStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if (pComponentConfigStructure == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
switch (nIndex) {
default:
ret = OMX_ErrorUnsupportedIndex;
break;
}
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_SetConfig(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nIndex,
OMX_IN OMX_PTR pComponentConfigStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if (pComponentConfigStructure == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
switch (nIndex) {
default:
ret = OMX_ErrorUnsupportedIndex;
break;
}
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_GetExtensionIndex(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_STRING cParameterName,
OMX_OUT OMX_INDEXTYPE *pIndexType)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if ((cParameterName == NULL) || (pIndexType == NULL)) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
ret = OMX_ErrorBadParameter;
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_SetCallbacks (
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_CALLBACKTYPE* pCallbacks,
OMX_IN OMX_PTR pAppData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
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;
if (pCallbacks == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
if (pSECComponent->currentState != OMX_StateLoaded) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
pSECComponent->pCallbacks = pCallbacks;
pSECComponent->callbackData = pAppData;
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_UseEGLImage(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_INOUT OMX_BUFFERHEADERTYPE **ppBufferHdr,
OMX_IN OMX_U32 nPortIndex,
OMX_IN OMX_PTR pAppPrivate,
OMX_IN void *eglImage)
{
return OMX_ErrorNotImplemented;
}
OMX_ERRORTYPE SEC_OMX_BaseComponent_Constructor(
OMX_IN OMX_HANDLETYPE hComponent)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
FunctionIn();
if (hComponent == NULL) {
ret = OMX_ErrorBadParameter;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__);
goto EXIT;
}
pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
pSECComponent = SEC_OSAL_Malloc(sizeof(SEC_OMX_BASECOMPONENT));
if (pSECComponent == NULL) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
SEC_OSAL_Memset(pSECComponent, 0, sizeof(SEC_OMX_BASECOMPONENT));
pOMXComponent->pComponentPrivate = (OMX_PTR)pSECComponent;
ret = SEC_OSAL_SemaphoreCreate(&pSECComponent->msgSemaphoreHandle);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
ret = SEC_OSAL_MutexCreate(&pSECComponent->compMutex);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
pSECComponent->bExitMessageHandlerThread = OMX_FALSE;
SEC_OSAL_QueueCreate(&pSECComponent->messageQ);
ret = SEC_OSAL_ThreadCreate(&pSECComponent->hMessageHandler, SEC_OMX_MessageHandlerThread, pOMXComponent);
if (ret != OMX_ErrorNone) {
ret = OMX_ErrorInsufficientResources;
SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__);
goto EXIT;
}
pOMXComponent->GetComponentVersion = &SEC_OMX_GetComponentVersion;
pOMXComponent->SendCommand = &SEC_OMX_SendCommand;
pOMXComponent->GetState = &SEC_OMX_GetState;
pOMXComponent->SetCallbacks = &SEC_OMX_SetCallbacks;
pOMXComponent->UseEGLImage = &SEC_OMX_UseEGLImage;
EXIT:
FunctionOut();
return ret;
}
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_S32 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;
}