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_TheadExit(NULL);
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;
}
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_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
OMX_S32 portIndex = 0;
OMX_U32 i = 0, cnt = 0;
FunctionIn();
if (pOMXComponent == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
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;
cnt = (nPortIndex == ALL_PORT_INDEX) ? ALL_PORT_NUM : 1;
for (i = 0; i < cnt; i++) {
if (nPortIndex == ALL_PORT_INDEX)
portIndex = i;
else
portIndex = nPortIndex;
ret = SEC_OMX_EnablePort(pOMXComponent, portIndex);
if (ret == OMX_ErrorNone) {
pSECComponent->pCallbacks->EventHandler(pOMXComponent,
pSECComponent->callbackData,
OMX_EventCmdComplete,
OMX_CommandPortEnable, portIndex, NULL);
}
}
EXIT:
if (ret != OMX_ErrorNone) {
pSECComponent->pCallbacks->EventHandler(pOMXComponent,
pSECComponent->callbackData,
OMX_EventError,
ret, 0, NULL);
}
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_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_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_MFC_Mpeg4Enc_ComponentRoleEnum(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_OUT OMX_U8 *cRole,
OMX_IN OMX_U32 nIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
OMX_S32 codecType;
FunctionIn();
if ((hComponent == NULL) || (cRole == NULL)) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
if (nIndex != (MAX_COMPONENT_ROLE_NUM - 1)) {
ret = OMX_ErrorNoMore;
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_StateInvalid;
goto EXIT;
}
codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
if (codecType == CODEC_TYPE_MPEG4)
SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE);
else
SEC_OSAL_Strcpy((char *)cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE);
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_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_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_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;
if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
if (pSECPort->portDefinition.bEnabled == OMX_TRUE) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
}
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 (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_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_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_FillThisBuffer(
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->nOutputPortIndex != OUTPUT_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[OUTPUT_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_CommandFillBuffer;
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;
}
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_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_PortDisableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
OMX_S32 portIndex = 0;
OMX_U32 i = 0, cnt = 0;
SEC_OMX_DATABUFFER *flushBuffer = NULL;
FunctionIn();
if (pOMXComponent == NULL) {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
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;
cnt = (nPortIndex == ALL_PORT_INDEX ) ? ALL_PORT_NUM : 1;
/* port flush*/
for(i = 0; i < cnt; i++) {
if (nPortIndex == ALL_PORT_INDEX)
portIndex = i;
else
portIndex = nPortIndex;
pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_TRUE;
flushBuffer = &pSECComponent->secDataBuffer[portIndex];
SEC_OSAL_MutexLock(flushBuffer->bufferMutex);
ret = SEC_OMX_FlushPort(pOMXComponent, portIndex);
SEC_OSAL_MutexUnlock(flushBuffer->bufferMutex);
pSECComponent->pSECPort[portIndex].bIsPortFlushed = OMX_FALSE;
if (portIndex == INPUT_PORT_INDEX) {
pSECComponent->checkTimeStamp.needSetStartTimeStamp = OMX_TRUE;
pSECComponent->checkTimeStamp.needCheckStartTimeStamp = OMX_FALSE;
SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP);
SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS);
pSECComponent->getAllDelayBuffer = OMX_FALSE;
pSECComponent->bSaveFlagEOS = OMX_FALSE;
pSECComponent->reInputData = OMX_FALSE;
} else if (portIndex == OUTPUT_PORT_INDEX) {
pSECComponent->remainOutputData = OMX_FALSE;
}
}
for(i = 0; i < cnt; i++) {
if (nPortIndex == ALL_PORT_INDEX)
portIndex = i;
else
portIndex = nPortIndex;
ret = SEC_OMX_DisablePort(pOMXComponent, portIndex);
pSECComponent->pSECPort[portIndex].bIsPortDisabled = OMX_FALSE;
if (ret == OMX_ErrorNone) {
pSECComponent->pCallbacks->EventHandler(pOMXComponent,
pSECComponent->callbackData,
OMX_EventCmdComplete,
OMX_CommandPortDisable, portIndex, NULL);
}
}
EXIT:
if (ret != OMX_ErrorNone) {
pSECComponent->pCallbacks->EventHandler(pOMXComponent,
pSECComponent->callbackData,
OMX_EventError,
ret, 0, NULL);
}
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_SetParameter(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nIndex,
OMX_IN OMX_PTR pComponentParameterStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
FunctionIn();
if (hComponent == NULL || pComponentParameterStructure == 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_StateInvalid;
goto EXIT;
}
switch (nIndex) {
case OMX_IndexParamVideoMpeg4:
{
OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pSrcMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pDstMpeg4Param = &pMpeg4Enc->mpeg4Component[pSrcMpeg4Param->nPortIndex];
SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
}
break;
case OMX_IndexParamVideoH263:
{
OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pSrcH263Param->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pDstH263Param = &pMpeg4Enc->h263Component[pSrcH263Param->nPortIndex];
SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
}
break;
case OMX_IndexParamStandardComponentRole:
{
OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE*)pComponentParameterStructure;
ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if ((pSECComponent->currentState != OMX_StateLoaded) && (pSECComponent->currentState != OMX_StateWaitForResources)) {
ret = OMX_ErrorIncorrectStateOperation;
goto EXIT;
}
if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE)) {
pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
//((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_MPEG4;
} else if (!SEC_OSAL_Strcmp((char*)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE)) {
pSECComponent->pSECPort[OUTPUT_PORT_INDEX].portDefinition.format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
//((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType = CODEC_TYPE_H263;
} else {
ret = OMX_ErrorBadParameter;
goto EXIT;
}
}
break;
case OMX_IndexParamVideoProfileLevelCurrent:
{
OMX_VIDEO_PARAM_PROFILELEVELTYPE *pSrcProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = NULL;
OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
OMX_S32 codecType;
ret = SEC_OMX_Check_SizeVersion(pSrcProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pSrcProfileLevel->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
if (codecType == CODEC_TYPE_MPEG4) {
/*
* To do: Check validity of profile & level parameters
*/
pDstMpeg4Param = &pMpeg4Enc->mpeg4Component[pSrcProfileLevel->nPortIndex];
pDstMpeg4Param->eProfile = pSrcProfileLevel->eProfile;
pDstMpeg4Param->eLevel = pSrcProfileLevel->eLevel;
} else {
/*
* To do: Check validity of profile & level parameters
*/
pDstH263Param = &pMpeg4Enc->h263Component[pSrcProfileLevel->nPortIndex];
pDstH263Param->eProfile = pSrcProfileLevel->eProfile;
pDstH263Param->eLevel = pSrcProfileLevel->eLevel;
}
}
break;
case OMX_IndexParamVideoErrorCorrection:
{
OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pSrcErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pSrcErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pDstErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
}
break;
default:
ret = SEC_OMX_VideoEncodeSetParameter(hComponent, nIndex, pComponentParameterStructure);
break;
}
EXIT:
FunctionOut();
return ret;
}
OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_GetParameter(
OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_INDEXTYPE nParamIndex,
OMX_INOUT OMX_PTR pComponentParameterStructure)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_COMPONENTTYPE *pOMXComponent = NULL;
SEC_OMX_BASECOMPONENT *pSECComponent = NULL;
FunctionIn();
if (hComponent == NULL || pComponentParameterStructure == 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_StateInvalid;
goto EXIT;
}
switch (nParamIndex) {
case OMX_IndexParamVideoMpeg4:
{
OMX_VIDEO_PARAM_MPEG4TYPE *pDstMpeg4Param = (OMX_VIDEO_PARAM_MPEG4TYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pDstMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pDstMpeg4Param->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pSrcMpeg4Param = &pMpeg4Enc->mpeg4Component[pDstMpeg4Param->nPortIndex];
SEC_OSAL_Memcpy(pDstMpeg4Param, pSrcMpeg4Param, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
}
break;
case OMX_IndexParamVideoH263:
{
OMX_VIDEO_PARAM_H263TYPE *pDstH263Param = (OMX_VIDEO_PARAM_H263TYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pDstH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pDstH263Param->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pSrcH263Param = &pMpeg4Enc->h263Component[pDstH263Param->nPortIndex];
SEC_OSAL_Memcpy(pDstH263Param, pSrcH263Param, sizeof(OMX_VIDEO_PARAM_H263TYPE));
}
break;
case OMX_IndexParamStandardComponentRole:
{
OMX_S32 codecType;
OMX_PARAM_COMPONENTROLETYPE *pComponentRole = (OMX_PARAM_COMPONENTROLETYPE *)pComponentParameterStructure;
ret = SEC_OMX_Check_SizeVersion(pComponentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
if (codecType == CODEC_TYPE_MPEG4)
SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_MPEG4_ENC_ROLE);
else
SEC_OSAL_Strcpy((char *)pComponentRole->cRole, SEC_OMX_COMPOMENT_H263_ENC_ROLE);
}
break;
case OMX_IndexParamVideoProfileLevelQuerySupported:
{
OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
SEC_OMX_VIDEO_PROFILELEVEL *pProfileLevel = NULL;
OMX_U32 maxProfileLevelNum = 0;
OMX_S32 codecType;
ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
codecType = ((SEC_MPEG4ENC_HANDLE *)(pSECComponent->hCodecHandle))->hMFCMpeg4Handle.codecType;
if (codecType == CODEC_TYPE_MPEG4) {
pProfileLevel = supportedMPEG4ProfileLevels;
maxProfileLevelNum = sizeof(supportedMPEG4ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
} else {
pProfileLevel = supportedH263ProfileLevels;
maxProfileLevelNum = sizeof(supportedH263ProfileLevels) / sizeof(SEC_OMX_VIDEO_PROFILELEVEL);
}
if (pDstProfileLevel->nProfileIndex >= maxProfileLevelNum) {
ret = OMX_ErrorNoMore;
goto EXIT;
}
pProfileLevel += pDstProfileLevel->nProfileIndex;
pDstProfileLevel->eProfile = pProfileLevel->profile;
pDstProfileLevel->eLevel = pProfileLevel->level;
}
break;
case OMX_IndexParamVideoProfileLevelCurrent:
{
OMX_VIDEO_PARAM_PROFILELEVELTYPE *pDstProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_MPEG4TYPE *pSrcMpeg4Param = NULL;
OMX_VIDEO_PARAM_H263TYPE *pSrcH263Param = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
OMX_S32 codecType;
ret = SEC_OMX_Check_SizeVersion(pDstProfileLevel, sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pDstProfileLevel->nPortIndex >= ALL_PORT_NUM) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
codecType = pMpeg4Enc->hMFCMpeg4Handle.codecType;
if (codecType == CODEC_TYPE_MPEG4) {
pSrcMpeg4Param = &pMpeg4Enc->mpeg4Component[pDstProfileLevel->nPortIndex];
pDstProfileLevel->eProfile = pSrcMpeg4Param->eProfile;
pDstProfileLevel->eLevel = pSrcMpeg4Param->eLevel;
} else {
pSrcH263Param = &pMpeg4Enc->h263Component[pDstProfileLevel->nPortIndex];
pDstProfileLevel->eProfile = pSrcH263Param->eProfile;
pDstProfileLevel->eLevel = pSrcH263Param->eLevel;
}
}
break;
case OMX_IndexParamVideoErrorCorrection:
{
OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pDstErrorCorrectionType = (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *)pComponentParameterStructure;
OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE *pSrcErrorCorrectionType = NULL;
SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL;
ret = SEC_OMX_Check_SizeVersion(pDstErrorCorrectionType, sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
if (ret != OMX_ErrorNone) {
goto EXIT;
}
if (pDstErrorCorrectionType->nPortIndex != OUTPUT_PORT_INDEX) {
ret = OMX_ErrorBadPortIndex;
goto EXIT;
}
pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle;
pSrcErrorCorrectionType = &pMpeg4Enc->errorCorrectionType[OUTPUT_PORT_INDEX];
pDstErrorCorrectionType->bEnableHEC = pSrcErrorCorrectionType->bEnableHEC;
pDstErrorCorrectionType->bEnableResync = pSrcErrorCorrectionType->bEnableResync;
pDstErrorCorrectionType->nResynchMarkerSpacing = pSrcErrorCorrectionType->nResynchMarkerSpacing;
pDstErrorCorrectionType->bEnableDataPartitioning = pSrcErrorCorrectionType->bEnableDataPartitioning;
pDstErrorCorrectionType->bEnableRVLC = pSrcErrorCorrectionType->bEnableRVLC;
}
break;
default:
ret = SEC_OMX_VideoEncodeGetParameter(hComponent, nParamIndex, pComponentParameterStructure);
break;
}
EXIT:
FunctionOut();
return ret;
}
