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