OMX_ERRORTYPE Exynos_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
OMX_U32 i = 0, elemNum = 0;
EXYNOS_OMX_MESSAGE *message;
FunctionIn();
pExynosPort = &pExynosComponent->pExynosPort[portIndex];
if (!CHECK_PORT_ENABLED(pExynosPort)) {
ret = OMX_ErrorNone;
goto EXIT;
}
if (pExynosComponent->currentState != OMX_StateLoaded) {
if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) {
while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) {
message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ);
Exynos_OSAL_Free(message);
}
}
pExynosPort->portDefinition.bPopulated = OMX_FALSE;
Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource);
}
pExynosPort->portDefinition.bEnabled = OMX_FALSE;
ret = OMX_ErrorNone;
EXIT:
FunctionOut();
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_U32 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;
}
/* MFC Encode */
OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_bufferProcess(OMX_COMPONENTTYPE *pOMXComponent, SEC_OMX_DATA *pInputData, SEC_OMX_DATA *pOutputData)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
SEC_OMX_BASEPORT *pInputPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
SEC_OMX_BASEPORT *pOutputPort = &pSECComponent->pSECPort[OUTPUT_PORT_INDEX];
FunctionIn();
if ((!CHECK_PORT_ENABLED(pInputPort)) || (!CHECK_PORT_ENABLED(pOutputPort)) ||
(!CHECK_PORT_POPULATED(pInputPort)) || (!CHECK_PORT_POPULATED(pOutputPort))) {
goto EXIT;
}
if (OMX_FALSE == SEC_Check_BufferProcess_State(pSECComponent)) {
goto EXIT;
}
ret = SEC_MFC_Mpeg4_Encode(pOMXComponent, pInputData, pOutputData);
if (ret != OMX_ErrorNone) {
if (ret == OMX_ErrorInputDataEncodeYet) {
pOutputData->usedDataLen = 0;
pOutputData->remainDataLen = pOutputData->dataLen;
} else {
pSECComponent->pCallbacks->EventHandler((OMX_HANDLETYPE)pOMXComponent,
pSECComponent->callbackData,
OMX_EventError, ret, 0, NULL);
}
} else {
pInputData->usedDataLen += pInputData->dataLen;
pInputData->remainDataLen = pInputData->dataLen - pInputData->usedDataLen;
pInputData->dataLen -= pInputData->usedDataLen;
pInputData->usedDataLen = 0;
pOutputData->usedDataLen = 0;
pOutputData->remainDataLen = pOutputData->dataLen;
}
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_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 Exynos_OMX_FillThisBuffer(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL;
EXYNOS_OMX_BASEPORT *pExynosPort = NULL;
OMX_BOOL findBuffer = OMX_FALSE;
EXYNOS_OMX_MESSAGE *message;
OMX_U32 i = 0;
FunctionIn();
if (hComponent == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
pOMXComponent = (OMX_COMPONENTTYPE *)hComponent;
ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pOMXComponent->pComponentPrivate == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate;
if (pExynosComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
if (pBuffer == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pBuffer->nOutputPortIndex != OUTPUT_PORT_INDEX) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = Exynos_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if ((pExynosComponent->currentState != OMX_StateIdle) &&
(pExynosComponent->currentState != OMX_StateExecuting) &&
(pExynosComponent->currentState != OMX_StatePause)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
pExynosPort = &pExynosComponent->pExynosPort[OUTPUT_PORT_INDEX];
if ((!CHECK_PORT_ENABLED(pExynosPort)) ||
((CHECK_PORT_BEING_FLUSHED(pExynosPort) || CHECK_PORT_BEING_DISABLED(pExynosPort)) &&
(!CHECK_PORT_TUNNELED(pExynosPort) || !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort))) ||
((pExynosComponent->transientState == EXYNOS_OMX_TransStateExecutingToIdle) &&
(CHECK_PORT_TUNNELED(pExynosPort) && !CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)))) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
Exynos_OSAL_MutexLock(pExynosPort->hPortMutex);
for (i = 0; i < pExynosPort->portDefinition.nBufferCountActual; i++) {
if (pBuffer == pExynosPort->extendBufferHeader[i].OMXBufferHeader) {
pExynosPort->extendBufferHeader[i].bBufferInOMX = OMX_TRUE;
findBuffer = OMX_TRUE;
break;
}
}
if (findBuffer == OMX_FALSE) {
ret = OMX_ErrorBadParameter;
Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
goto EXIT;
}
message = Exynos_OSAL_Malloc(sizeof(EXYNOS_OMX_MESSAGE));
if (message == NULL) {
ret = OMX_ErrorInsufficientResources;
Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
goto EXIT;
}
message->messageType = EXYNOS_OMX_CommandFillBuffer;
message->messageParam = (OMX_U32) i;
message->pCmdData = (OMX_PTR)pBuffer;
ret = Exynos_OSAL_Queue(&pExynosPort->bufferQ, (void *)message);
if (ret != 0) {
ret = OMX_ErrorUndefined;
Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
goto EXIT;
}
ret = Exynos_OSAL_SemaphorePost(pExynosPort->bufferSemID);
Exynos_OSAL_MutexUnlock(pExynosPort->hPortMutex);
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_OMX_EmptyThisBuffer(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_BUFFERHEADERTYPE *pBuffer)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
SEC_OMX_BASEPORT *pSECPort = NULL;
OMX_BOOL findBuffer = OMX_FALSE;
SEC_OMX_MESSAGE *message;
OMX_U32 i = 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;
if (pSECComponent->currentState == OMX_StateInvalid) {
ret = OMX_ErrorInvalidState;
goto EXIT;
}
if (pBuffer == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (pBuffer->nInputPortIndex != INPUT_PORT_INDEX) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
ret = SEC_OMX_Check_SizeVersion(pBuffer, sizeof(OMX_BUFFERHEADERTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if ((pSECComponent->currentState != OMX_StateIdle) &&
(pSECComponent->currentState != OMX_StateExecuting) &&
(pSECComponent->currentState != OMX_StatePause)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
pSECPort = &pSECComponent->pSECPort[INPUT_PORT_INDEX];
if ((!CHECK_PORT_ENABLED(pSECPort)) ||
((CHECK_PORT_BEING_FLUSHED(pSECPort) || CHECK_PORT_BEING_DISABLED(pSECPort)) &&
(!CHECK_PORT_TUNNELED(pSECPort) || !CHECK_PORT_BUFFER_SUPPLIER(pSECPort))) ||
((pSECComponent->transientState == SEC_OMX_TransStateExecutingToIdle) &&
(CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)))) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
for (i = 0; i < pSECPort->portDefinition.nBufferCountActual; i++) {
if (pBuffer == pSECPort->bufferHeader[i]) {
findBuffer = OMX_TRUE;
break;
}
}
if (findBuffer == OMX_FALSE) {
ret = OMX_ErrorBadParameter;
goto EXIT;
} else {
ret = OMX_ErrorNone;
}
message = SEC_OSAL_Malloc(sizeof(SEC_OMX_MESSAGE));
if (message == NULL) {
ret = OMX_ErrorInsufficientResources;
goto EXIT;
}
message->messageType = SEC_OMX_CommandEmptyBuffer;
message->messageParam = (OMX_U32) i;
message->pCmdData = (OMX_PTR)pBuffer;
SEC_OSAL_Queue(&pSECPort->bufferQ, (void *)message);
SEC_OSAL_SemaphorePost(pSECPort->bufferSemID);
EXIT:
FunctionOut();
return ret;
}
