OMX_ERRORTYPE SEC_OMX_ComponentUnload(SEC_OMX_COMPONENT *sec_component) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; FunctionIn(); if (!sec_component) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = sec_component->pOMXComponent; if (pOMXComponent != NULL) { pOMXComponent->ComponentDeInit(pOMXComponent); SEC_OSAL_Free(pOMXComponent); sec_component->pOMXComponent = NULL; } if (sec_component->libHandle != NULL) { SEC_OSAL_dlclose(sec_component->libHandle); sec_component->libHandle = NULL; } EXIT: FunctionOut(); return ret; }
RT_STATUS GAS_OnInitReq( IN PADAPTER pAdapter, IN PRT_RFD pRfd, IN POCTET_STRING posMpdu ) { RT_STATUS RtStatus = RT_STATUS_SUCCESS; pu1Byte pOUI = NULL; FunctionIn(COMP_MLME); PlatformIndicateActionFrame(pAdapter, (PVOID)posMpdu); pOUI = Frame_GAS_QueryReq_OUI(*posMpdu); RT_PRINT_DATA(COMP_MLME, DBG_LOUD, ("GAS Initial request: "), pOUI, 3); if( PlatformCompareMemory(pOUI, WFA_OUI, SIZE_OUI) == 0 ) { pOUI = Frame_GAS_QueryReq_Type(*posMpdu); if(0x09 == *pOUI) P2P_OnSDReq(pAdapter, pRfd, posMpdu); } else { RT_TRACE(COMP_MLME, DBG_WARNING, ("No matched OUI: %2x:%2x:%2x\n", pOUI[0], pOUI[1], pOUI[2])); } FunctionOut(COMP_MLME); return RtStatus; }
OMX_API OMX_ERRORTYPE OMX_APIENTRY Exynos_OMX_Init(void) { OMX_ERRORTYPE ret = OMX_ErrorNone; FunctionIn(); if (gInitialized == 0) { if (Exynos_OMX_Component_Register(&gComponentList, &gComponentNum)) { ret = OMX_ErrorInsufficientResources; Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Exynos_OMX_Init : %s", "OMX_ErrorInsufficientResources"); goto EXIT; } ret = Exynos_OMX_ResourceManager_Init(); if (OMX_ErrorNone != ret) { Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Exynos_OMX_Init : Exynos_OMX_ResourceManager_Init failed"); goto EXIT; } ret = Exynos_OSAL_MutexCreate(&ghLoadComponentListMutex); if (OMX_ErrorNone != ret) { Exynos_OSAL_Log(EXYNOS_LOG_ERROR, "Exynos_OMX_Init : Exynos_OSAL_MutexCreate(&ghLoadComponentListMutex) failed"); goto EXIT; } gInitialized = 1; Exynos_OSAL_Log(EXYNOS_LOG_TRACE, "Exynos_OMX_Init : %s", "OMX_ErrorNone"); } EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_GetState ( OMX_IN OMX_HANDLETYPE hComponent, OMX_OUT OMX_STATETYPE *pState) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; FunctionIn(); if (hComponent == NULL || pState == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; *pState = pSECComponent->currentState; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; EXYNOS_OMX_BASEPORT *pExynosPort = NULL; OMX_U32 i = 0, elemNum = 0; EXYNOS_OMX_MESSAGE *message; FunctionIn(); pExynosPort = &pExynosComponent->pExynosPort[portIndex]; if (!CHECK_PORT_ENABLED(pExynosPort)) { ret = OMX_ErrorNone; goto EXIT; } if (pExynosComponent->currentState != OMX_StateLoaded) { if (CHECK_PORT_BUFFER_SUPPLIER(pExynosPort)) { while (Exynos_OSAL_GetElemNum(&pExynosPort->bufferQ) > 0) { message = (EXYNOS_OMX_MESSAGE*)Exynos_OSAL_Dequeue(&pExynosPort->bufferQ); Exynos_OSAL_Free(message); } } pExynosPort->portDefinition.bPopulated = OMX_FALSE; Exynos_OSAL_SemaphoreWait(pExynosPort->unloadedResource); } pExynosPort->portDefinition.bEnabled = OMX_FALSE; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_EnablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; EXYNOS_OMX_BASEPORT *pExynosPort = NULL; OMX_U32 i = 0, cnt = 0; FunctionIn(); pExynosPort = &pExynosComponent->pExynosPort[portIndex]; if ((pExynosComponent->currentState != OMX_StateLoaded) && (pExynosComponent->currentState != OMX_StateWaitForResources)) { Exynos_OSAL_SemaphoreWait(pExynosPort->loadedResource); pExynosPort->portDefinition.bPopulated = OMX_TRUE; } pExynosPort->exceptionFlag = GENERAL_STATE; pExynosPort->portDefinition.bEnabled = OMX_TRUE; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_Out_WaitForResource(OMX_COMPONENTTYPE *pOMXComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL; EXYNOS_OMX_RM_COMPONENT_LIST *pRMComponentWaitList = NULL; FunctionIn(); Exynos_OSAL_MutexLock(ghVideoRMComponentListMutex); pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; pRMComponentWaitList = getRMList(pExynosComponent, gpRMWaitList, NULL); ret = removeElementList(&pRMComponentWaitList, pOMXComponent); if (ret != OMX_ErrorNone) goto EXIT; ret = setRMList(pExynosComponent, gpRMWaitList, pRMComponentWaitList); EXIT: Exynos_OSAL_MutexUnlock(ghVideoRMComponentListMutex); FunctionOut(); return ret; }
static OMX_ERRORTYPE SEC_OMX_BufferProcessThread(OMX_PTR threadData) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; SEC_OMX_MESSAGE *message = NULL; FunctionIn(); if (threadData == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)threadData; ret = SEC_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; pSECComponent->sec_BufferProcess(pOMXComponent); SEC_OSAL_TheadExit(NULL); EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_ComponentUnload(EXYNOS_OMX_COMPONENT *exynos_component) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; FunctionIn(); if (!exynos_component) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = exynos_component->pOMXComponent; if (pOMXComponent != NULL) { pOMXComponent->ComponentDeInit(pOMXComponent); Exynos_OSAL_Free(pOMXComponent); exynos_component->pOMXComponent = NULL; } if (exynos_component->libHandle != NULL) { Exynos_OSAL_dlclose(exynos_component->libHandle); exynos_component->libHandle = NULL; } EXIT: FunctionOut(); return ret; }
/* MFC Init */ OMX_ERRORTYPE SEC_MFC_Mpeg4Enc_Init(OMX_COMPONENTTYPE *pOMXComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_BASEPORT *pSECPort = NULL; SEC_MPEG4ENC_HANDLE *pMpeg4Enc = NULL; OMX_HANDLETYPE hMFCHandle = NULL; OMX_S32 returnCodec = 0; FunctionIn(); pMpeg4Enc = (SEC_MPEG4ENC_HANDLE *)pSECComponent->hCodecHandle; pMpeg4Enc->hMFCMpeg4Handle.bConfiguredMFC = OMX_FALSE; pSECComponent->bUseFlagEOF = OMX_FALSE; pSECComponent->bSaveFlagEOS = OMX_FALSE; /* MFC(Multi Format Codec) encoder and CMM(Codec Memory Management) driver open */ hMFCHandle = SsbSipMfcEncOpen(); if (hMFCHandle == NULL) { ret = OMX_ErrorInsufficientResources; goto EXIT; } pMpeg4Enc->hMFCMpeg4Handle.hMFCHandle = hMFCHandle; /* set MFC ENC VIDEO PARAM and initialize MFC encoder instance */ if (pMpeg4Enc->hMFCMpeg4Handle.codecType == CODEC_TYPE_MPEG4) { Set_Mpeg4Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam), pSECComponent); returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.mpeg4MFCParam)); } else { Set_H263Enc_Param(&(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam), pSECComponent); returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.h263MFCParam)); } if (returnCodec != MFC_RET_OK) { ret = OMX_ErrorInsufficientResources; goto EXIT; } /* allocate encoder's input buffer */ returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pMpeg4Enc->hMFCMpeg4Handle.inputInfo)); if (returnCodec != MFC_RET_OK) { ret = OMX_ErrorInsufficientResources; goto EXIT; } pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YPhyAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CPhyAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YVirAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CVirAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.YSize; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pMpeg4Enc->hMFCMpeg4Handle.inputInfo.CSize; SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP); SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS); pMpeg4Enc->hMFCMpeg4Handle.indexTimestamp = 0; EXIT: FunctionOut(); return ret; }
RT_STATUS GAS_OnComebackRsp( IN PADAPTER pAdapter, IN PRT_RFD pRfd, IN POCTET_STRING posMpdu ) { RT_STATUS RtStatus = RT_STATUS_SUCCESS; pu1Byte pOUI = NULL; FunctionIn(COMP_MLME); PlatformIndicateActionFrame(pAdapter, (PVOID)posMpdu); pOUI = Frame_GAS_ComebackRsp_OUI(*posMpdu); if( PlatformCompareMemory(pOUI, WFA_OUI, SIZE_OUI) == 0 ) { pOUI = Frame_GAS_ComebackRsp_Type(*posMpdu); if(0x09 == *pOUI) P2P_OnSDComebackRsp(pAdapter, pRfd, posMpdu); } else { RT_TRACE(COMP_MLME, DBG_WARNING, ("No matched OUI: %2x:%2x:%2x\n", pOUI[0], pOUI[1], pOUI[2])); } FunctionOut(COMP_MLME); return RtStatus; }
OMX_ERRORTYPE Exynos_OMX_Release_Resource(OMX_COMPONENTTYPE *pOMXComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL; EXYNOS_OMX_RM_COMPONENT_LIST *pRMComponentList = NULL; EXYNOS_OMX_RM_COMPONENT_LIST *pRMComponentWaitList = NULL; EXYNOS_OMX_RM_COMPONENT_LIST *pComponentTemp = NULL; OMX_COMPONENTTYPE *pOMXWaitComponent = NULL; int numElem = 0; FunctionIn(); Exynos_OSAL_MutexLock(ghVideoRMComponentListMutex); pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; pRMComponentList = getRMList(pExynosComponent, gpRMList, NULL); if (pRMComponentList == NULL) { ret = OMX_ErrorUndefined; goto EXIT; } ret = removeElementList(&pRMComponentList, pOMXComponent); if (ret != OMX_ErrorNone) goto EXIT; ret = setRMList(pExynosComponent, gpRMList, pRMComponentList); if (ret != OMX_ErrorNone) goto EXIT; pRMComponentWaitList = getRMList(pExynosComponent, gpRMWaitList, NULL); pComponentTemp = pRMComponentWaitList; while (pComponentTemp) { numElem++; pComponentTemp = pComponentTemp->pNext; } if (numElem > 0) { pOMXWaitComponent = pRMComponentWaitList->pOMXStandComp; ret = removeElementList(&pRMComponentWaitList, pOMXWaitComponent); if (ret != OMX_ErrorNone) goto EXIT; ret = setRMList(pExynosComponent, gpRMWaitList, pRMComponentWaitList); if (ret != OMX_ErrorNone) goto EXIT; ret = OMX_SendCommand(pOMXWaitComponent, OMX_CommandStateSet, OMX_StateIdle, NULL); if (ret != OMX_ErrorNone) goto EXIT; } EXIT: Exynos_OSAL_MutexUnlock(ghVideoRMComponentListMutex); FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_Port_Destructor(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL; EXYNOS_OMX_BASEPORT *pExynosPort = NULL; OMX_S32 countValue = 0; int i = 0; FunctionIn(); if (hComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; if (pExynosComponent->transientState == EXYNOS_OMX_TransStateLoadedToIdle) { pExynosComponent->abendState = OMX_TRUE; for (i = 0; i < ALL_PORT_NUM; i++) { pExynosPort = &pExynosComponent->pExynosPort[i]; Exynos_OSAL_SemaphorePost(pExynosPort->loadedResource); } Exynos_OSAL_SignalWait(pExynosComponent->abendStateEvent, DEF_MAX_WAIT_TIME); Exynos_OSAL_SignalReset(pExynosComponent->abendStateEvent); } for (i = 0; i < ALL_PORT_NUM; i++) { pExynosPort = &pExynosComponent->pExynosPort[i]; Exynos_OSAL_SemaphoreTerminate(pExynosPort->loadedResource); pExynosPort->loadedResource = NULL; Exynos_OSAL_SemaphoreTerminate(pExynosPort->unloadedResource); pExynosPort->unloadedResource = NULL; Exynos_OSAL_Free(pExynosPort->bufferStateAllocate); pExynosPort->bufferStateAllocate = NULL; Exynos_OSAL_Free(pExynosPort->extendBufferHeader); pExynosPort->extendBufferHeader = NULL; Exynos_OSAL_QueueTerminate(&pExynosPort->bufferQ); } Exynos_OSAL_Free(pExynosComponent->pExynosPort); pExynosComponent->pExynosPort = NULL; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_BaseComponent_Constructor( OMX_IN OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; FunctionIn(); if (hComponent == NULL) { ret = OMX_ErrorBadParameter; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorBadParameter, Line:%d", __LINE__); goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)hComponent; pSECComponent = SEC_OSAL_Malloc(sizeof(SEC_OMX_BASECOMPONENT)); if (pSECComponent == NULL) { ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } SEC_OSAL_Memset(pSECComponent, 0, sizeof(SEC_OMX_BASECOMPONENT)); pOMXComponent->pComponentPrivate = (OMX_PTR)pSECComponent; ret = SEC_OSAL_SemaphoreCreate(&pSECComponent->msgSemaphoreHandle); if (ret != OMX_ErrorNone) { ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } ret = SEC_OSAL_MutexCreate(&pSECComponent->compMutex); if (ret != OMX_ErrorNone) { ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } pSECComponent->bExitMessageHandlerThread = OMX_FALSE; SEC_OSAL_QueueCreate(&pSECComponent->messageQ); ret = SEC_OSAL_ThreadCreate(&pSECComponent->hMessageHandler, SEC_OMX_MessageHandlerThread, pOMXComponent); if (ret != OMX_ErrorNone) { ret = OMX_ErrorInsufficientResources; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInsufficientResources, Line:%d", __LINE__); goto EXIT; } pOMXComponent->GetComponentVersion = &SEC_OMX_GetComponentVersion; pOMXComponent->SendCommand = &SEC_OMX_SendCommand; pOMXComponent->GetConfig = &SEC_OMX_GetConfig; pOMXComponent->GetExtensionIndex = &SEC_OMX_GetExtensionIndex; pOMXComponent->GetState = &SEC_OMX_GetState; pOMXComponent->SetCallbacks = &SEC_OMX_SetCallbacks; pOMXComponent->UseEGLImage = &SEC_OMX_UseEGLImage; EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_ResourceManager_Deinit() { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_RM_COMPONENT_LIST *pCurrComponent; EXYNOS_OMX_RM_COMPONENT_LIST *pNextComponent; FunctionIn(); Exynos_OSAL_MutexLock(ghVideoRMComponentListMutex); if (gpVideoDecRMComponentList) { pCurrComponent = gpVideoDecRMComponentList; while (pCurrComponent != NULL) { pNextComponent = pCurrComponent->pNext; Exynos_OSAL_Free(pCurrComponent); pCurrComponent = pNextComponent; } gpVideoDecRMComponentList = NULL; } if (gpVideoDecRMWaitingList) { pCurrComponent = gpVideoDecRMWaitingList; while (pCurrComponent != NULL) { pNextComponent = pCurrComponent->pNext; Exynos_OSAL_Free(pCurrComponent); pCurrComponent = pNextComponent; } gpVideoDecRMWaitingList = NULL; } if (gpVideoEncRMComponentList) { pCurrComponent = gpVideoEncRMComponentList; while (pCurrComponent != NULL) { pNextComponent = pCurrComponent->pNext; Exynos_OSAL_Free(pCurrComponent); pCurrComponent = pNextComponent; } gpVideoEncRMComponentList = NULL; } if (gpVideoEncRMWaitingList) { pCurrComponent = gpVideoEncRMWaitingList; while (pCurrComponent != NULL) { pNextComponent = pCurrComponent->pNext; Exynos_OSAL_Free(pCurrComponent); pCurrComponent = pNextComponent; } gpVideoEncRMWaitingList = NULL; } Exynos_OSAL_MutexUnlock(ghVideoRMComponentListMutex); Exynos_OSAL_MutexTerminate(ghVideoRMComponentListMutex); ghVideoRMComponentListMutex = NULL; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
/* MFC Init */ OMX_ERRORTYPE SEC_MFC_H264Enc_Init(OMX_COMPONENTTYPE *pOMXComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_H264ENC_HANDLE *pH264Enc = NULL; OMX_PTR hMFCHandle = NULL; OMX_S32 returnCodec = 0; FunctionIn(); pH264Enc = (SEC_H264ENC_HANDLE *)pSECComponent->hCodecHandle; pH264Enc->hMFCH264Handle.bConfiguredMFC = OMX_FALSE; pSECComponent->bUseFlagEOF = OMX_FALSE; pSECComponent->bSaveFlagEOS = OMX_FALSE; /* MFC(Multi Function Codec) encoder and CMM(Codec Memory Management) driver open */ hMFCHandle = (OMX_PTR)SsbSipMfcEncOpen(); if (hMFCHandle == NULL) { ret = OMX_ErrorInsufficientResources; goto EXIT; } pH264Enc->hMFCH264Handle.hMFCHandle = hMFCHandle; Set_H264ENC_Param(&(pH264Enc->hMFCH264Handle.mfcVideoAvc), pSECComponent); returnCodec = SsbSipMfcEncInit(hMFCHandle, &(pH264Enc->hMFCH264Handle.mfcVideoAvc)); if (returnCodec != MFC_RET_OK) { ret = OMX_ErrorInsufficientResources; goto EXIT; } /* Allocate encoder's input buffer */ returnCodec = SsbSipMfcEncGetInBuf(hMFCHandle, &(pH264Enc->hMFCH264Handle.inputInfo)); if (returnCodec != MFC_RET_OK) { ret = OMX_ErrorInsufficientResources; goto EXIT; } SEC_OSAL_Log(SEC_LOG_TRACE, "pH264Enc->hMFCH264Handle.inputInfo.YVirAddr : 0x%x", pH264Enc->hMFCH264Handle.inputInfo.YVirAddr); SEC_OSAL_Log(SEC_LOG_TRACE, "pH264Enc->hMFCH264Handle.inputInfo.CVirAddr : 0x%x", pH264Enc->hMFCH264Handle.inputInfo.CVirAddr); pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.YPhyAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CPhyAddr = pH264Enc->hMFCH264Handle.inputInfo.CPhyAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YVirAddr = pH264Enc->hMFCH264Handle.inputInfo.YVirAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CVirAddr = pH264Enc->hMFCH264Handle.inputInfo.CVirAddr; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.YSize = pH264Enc->hMFCH264Handle.inputInfo.YSize; pSECComponent->processData[INPUT_PORT_INDEX].specificBufferHeader.CSize = pH264Enc->hMFCH264Handle.inputInfo.CSize; SEC_OSAL_Memset(pSECComponent->timeStamp, -19771003, sizeof(OMX_TICKS) * MAX_TIMESTAMP); SEC_OSAL_Memset(pSECComponent->nFlags, 0, sizeof(OMX_U32) * MAX_FLAGS); pH264Enc->hMFCH264Handle.indexTimestamp = 0; 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 Exynos_OMX_ResourceManager_Init() { OMX_ERRORTYPE ret = OMX_ErrorNone; FunctionIn(); ret = Exynos_OSAL_MutexCreate(&ghVideoRMComponentListMutex); FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_ComponentLoad(SEC_OMX_COMPONENT *sec_component) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_HANDLETYPE libHandle; OMX_COMPONENTTYPE *pOMXComponent; FunctionIn(); OMX_ERRORTYPE (*SEC_OMX_ComponentInit)(OMX_HANDLETYPE hComponent, OMX_STRING componentName); libHandle = SEC_OSAL_dlopen((OMX_STRING)sec_component->libName, RTLD_NOW); if (!libHandle) { ret = OMX_ErrorInvalidComponentName; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponentName, Line:%d", __LINE__); goto EXIT; } SEC_OMX_ComponentInit = SEC_OSAL_dlsym(libHandle, "SEC_OMX_ComponentInit"); if (!SEC_OMX_ComponentInit) { SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } pOMXComponent = (OMX_COMPONENTTYPE *)SEC_OSAL_Malloc(sizeof(OMX_COMPONENTTYPE)); INIT_SET_SIZE_VERSION(pOMXComponent, OMX_COMPONENTTYPE); ret = (*SEC_OMX_ComponentInit)((OMX_HANDLETYPE)pOMXComponent, (OMX_STRING)sec_component->componentName); if (ret != OMX_ErrorNone) { SEC_OSAL_Free(pOMXComponent); SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } else { if (SEC_OMX_ComponentAPICheck(pOMXComponent) != OMX_ErrorNone) { if (NULL != pOMXComponent->ComponentDeInit) pOMXComponent->ComponentDeInit(pOMXComponent); SEC_OSAL_Free(pOMXComponent); SEC_OSAL_dlclose(libHandle); ret = OMX_ErrorInvalidComponent; SEC_OSAL_Log(SEC_LOG_ERROR, "OMX_ErrorInvalidComponent, Line:%d", __LINE__); goto EXIT; } sec_component->libHandle = libHandle; sec_component->pOMXComponent = pOMXComponent; ret = OMX_ErrorNone; } EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE Exynos_OMX_PortEnableProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL; OMX_S32 portIndex = 0; OMX_U32 i = 0, cnt = 0; FunctionIn(); if (pOMXComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; 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 = Exynos_OMX_EnablePort(pOMXComponent, portIndex); if (ret == OMX_ErrorNone) { pExynosComponent->pCallbacks->EventHandler(pOMXComponent, pExynosComponent->callbackData, OMX_EventCmdComplete, OMX_CommandPortEnable, portIndex, NULL); } } EXIT: if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) { pExynosComponent->pCallbacks->EventHandler(pOMXComponent, pExynosComponent->callbackData, OMX_EventError, ret, 0, NULL); } FunctionOut(); return ret; }
VOID chnl_HalSwBwChnl( PADAPTER Adapter ) { PCHANNEL_COMMON_CONTEXT pChnlCommInfo = Adapter->pPortCommonInfo->pChnlCommInfo; PHAL_DATA_TYPE pHalData = GET_HAL_DATA(Adapter); FunctionIn(COMP_SCAN); if(HAL_ChipSupport80MHz(Adapter)) { Adapter->HalFunc.SwChnlAndSetBWHandler( Adapter, TRUE, TRUE, pChnlCommInfo->CurrentChannelCenterFrequency, pChnlCommInfo->CurrentChannelBandWidth, pChnlCommInfo->Ext20MHzChnlOffsetOf40MHz, pChnlCommInfo->Ext40MHzChnlOffsetOf80MHz, pChnlCommInfo->CurrentChannelCenterFrequency ); } else { u1Byte offset; Mgnt_SwChnl(Adapter, pChnlCommInfo->CurrentChannelCenterFrequency, 1); // last bandwidth offset if(pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER) offset = EXTCHNL_OFFSET_LOWER; else if (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) offset = EXTCHNL_OFFSET_UPPER; else offset = EXTCHNL_OFFSET_NO_EXT; // 1.20M to 40M or 40M to 20M // 2.40M to 40M as offset different or bandtype different if( (pHalData->CurrentChannelBW != pChnlCommInfo->CurrentChannelBandWidth )|| (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40 && pChnlCommInfo->Ext20MHzChnlOffsetOf40MHz !=offset) || (pHalData->LastBandType !=pHalData->CurrentBandType)) { Adapter->HalFunc.SetBWModeHandler( Adapter, pChnlCommInfo->CurrentChannelBandWidth, pChnlCommInfo->Ext20MHzChnlOffsetOf40MHz ); } } FunctionOut(COMP_SCAN); }
OMX_API OMX_ERRORTYPE OMX_APIENTRY Exynos_OMX_FreeHandle(OMX_IN OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_COMPONENT *currentComponent = NULL; EXYNOS_OMX_COMPONENT *deleteComponent = NULL; FunctionIn(); if ((gInitialized != 1) || (gLoadComponentList == NULL)) { ret = OMX_ErrorNotReady; goto EXIT; } if (!hComponent) { ret = OMX_ErrorBadParameter; goto EXIT; } Exynos_OSAL_MutexLock(ghLoadComponentListMutex); if (gLoadComponentList->pOMXComponent == hComponent) { deleteComponent = gLoadComponentList; gLoadComponentList = gLoadComponentList->nextOMXComp; } else { currentComponent = gLoadComponentList; while ((currentComponent != NULL) && (currentComponent->nextOMXComp != NULL)) { if (currentComponent->nextOMXComp->pOMXComponent == hComponent) { deleteComponent = currentComponent->nextOMXComp; currentComponent->nextOMXComp = deleteComponent->nextOMXComp; break; } currentComponent = currentComponent->nextOMXComp; } if (deleteComponent == NULL) { ret = OMX_ErrorComponentNotFound; Exynos_OSAL_MutexUnlock(ghLoadComponentListMutex); goto EXIT; } } Exynos_OSAL_MutexUnlock(ghLoadComponentListMutex); Exynos_OMX_ComponentUnload(deleteComponent); Exynos_OSAL_Free(deleteComponent); EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE NAM_OSAL_SignalWait(OMX_HANDLETYPE eventHandle, OMX_U32 ms) { NAM_OSAL_THREADEVENT *event = (NAM_OSAL_THREADEVENT *)eventHandle; OMX_ERRORTYPE ret = OMX_ErrorNone; struct timespec timeout; struct timeval now; int funcret = 0; OMX_U32 tv_us; FunctionIn(); if (!event) { ret = OMX_ErrorBadParameter; goto EXIT; } gettimeofday(&now, NULL); tv_us = now.tv_usec + ms * 1000; timeout.tv_sec = now.tv_sec + tv_us / 1000000; timeout.tv_nsec = (tv_us % 1000000) * 1000; ret = NAM_OSAL_MutexLock(event->mutex); if (ret != OMX_ErrorNone) { ret = OMX_ErrorBadParameter; goto EXIT; } if (ms == 0) { if (!event->signal) ret = OMX_ErrorTimeout; } else if (ms == DEF_MAX_WAIT_TIME) { while (!event->signal) pthread_cond_wait(&event->condition, (pthread_mutex_t *)(event->mutex)); ret = OMX_ErrorNone; } else { while (!event->signal) { funcret = pthread_cond_timedwait(&event->condition, (pthread_mutex_t *)(event->mutex), &timeout); if ((!event->signal) && (funcret == ETIMEDOUT)) { ret = OMX_ErrorTimeout; break; } } } NAM_OSAL_MutexUnlock(event->mutex); EXIT: FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_BaseComponent_Destructor( OMX_IN OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_COMPONENTTYPE *pOMXComponent = NULL; SEC_OMX_BASECOMPONENT *pSECComponent = NULL; OMX_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 Exynos_OMX_BufferFlushProcess(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 nPortIndex, OMX_BOOL bEvent) { OMX_ERRORTYPE ret = OMX_ErrorNone; EXYNOS_OMX_BASECOMPONENT *pExynosComponent = NULL; EXYNOS_OMX_BASEPORT *pExynosPort = NULL; OMX_S32 portIndex = 0; EXYNOS_OMX_DATABUFFER *flushPortBuffer[2] = {NULL, NULL}; OMX_U32 i = 0, cnt = 0; FunctionIn(); if (pOMXComponent == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } ret = Exynos_OMX_Check_SizeVersion(pOMXComponent, sizeof(OMX_COMPONENTTYPE)); if (ret != OMX_ErrorNone) { goto EXIT; } if (pOMXComponent->pComponentPrivate == NULL) { ret = OMX_ErrorBadParameter; goto EXIT; } pExynosComponent = (EXYNOS_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; 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; pExynosComponent->exynos_BufferFlush(pOMXComponent, portIndex, bEvent); } EXIT: if ((ret != OMX_ErrorNone) && (pOMXComponent != NULL) && (pExynosComponent != NULL)) { Exynos_OSAL_Log(EXYNOS_LOG_ERROR,"%s : %d", __FUNCTION__, __LINE__); pExynosComponent->pCallbacks->EventHandler(pOMXComponent, pExynosComponent->callbackData, OMX_EventError, ret, 0, NULL); } FunctionOut(); return ret; }
OMX_ERRORTYPE SEC_OMX_DisablePort(OMX_COMPONENTTYPE *pOMXComponent, OMX_S32 portIndex) { OMX_ERRORTYPE ret = OMX_ErrorNone; SEC_OMX_BASECOMPONENT *pSECComponent = (SEC_OMX_BASECOMPONENT *)pOMXComponent->pComponentPrivate; SEC_OMX_BASEPORT *pSECPort = NULL; OMX_U32 i = 0, elemNum = 0; SEC_OMX_MESSAGE *message; FunctionIn(); pSECPort = &pSECComponent->pSECPort[portIndex]; if (!CHECK_PORT_ENABLED(pSECPort)) { ret = OMX_ErrorNone; goto EXIT; } if (pSECComponent->currentState!=OMX_StateLoaded) { if (CHECK_PORT_TUNNELED(pSECPort) && CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) { message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ); SEC_OSAL_Free(message); } ret = pSECComponent->sec_FreeTunnelBuffer(pSECPort, portIndex); if (OMX_ErrorNone != ret) { goto EXIT; } pSECPort->portDefinition.bPopulated = OMX_FALSE; } else if (CHECK_PORT_TUNNELED(pSECPort) && !CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { pSECPort->portDefinition.bPopulated = OMX_FALSE; SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource); } else { if (CHECK_PORT_BUFFER_SUPPLIER(pSECPort)) { while (SEC_OSAL_GetElemNum(&pSECPort->bufferQ) >0 ) { message = (SEC_OMX_MESSAGE*)SEC_OSAL_Dequeue(&pSECPort->bufferQ); SEC_OSAL_Free(message); } } pSECPort->portDefinition.bPopulated = OMX_FALSE; SEC_OSAL_SemaphoreWait(pSECPort->unloadedResource); } } pSECPort->portDefinition.bEnabled = OMX_FALSE; ret = OMX_ErrorNone; EXIT: FunctionOut(); return ret; }
OMX_API OMX_ERRORTYPE Exynos_OMX_GetRolesOfComponent ( OMX_IN OMX_STRING compName, OMX_INOUT OMX_U32 *pNumRoles, OMX_OUT OMX_U8 **roles) { OMX_ERRORTYPE ret = OMX_ErrorNone; OMX_BOOL detectComp = OMX_FALSE; int compNum = 0, totalRoleNum = 0; int i = 0; FunctionIn(); if (gInitialized != 1) { ret = OMX_ErrorNotReady; goto EXIT; } for (i = 0; i < MAX_OMX_COMPONENT_NUM; i++) { if (gComponentList != NULL) { if (Exynos_OSAL_Strcmp(gComponentList[i].component.componentName, compName) == 0) { *pNumRoles = totalRoleNum = gComponentList[i].component.totalRoleNum; compNum = i; detectComp = OMX_TRUE; break; } } else { ret = OMX_ErrorUndefined; goto EXIT; } } if (detectComp == OMX_FALSE) { *pNumRoles = 0; ret = OMX_ErrorComponentNotFound; goto EXIT; } if (roles != NULL) { for (i = 0; i < totalRoleNum; i++) { Exynos_OSAL_Strcpy(roles[i], gComponentList[compNum].component.roles[i]); } } EXIT: FunctionOut(); return ret; }
OMX_S32 RegisterLibrary(OTRegisterComponentType *componentEnums) { FunctionIn(); if (componentEnums == NULL) { goto EXIT; } strcpy(componentEnums[0]->component_name, OT_OMX_COMPONENT_YUV2RGB); strcpy(componentEnums[0]->roles[0], OT_OMX_COMPONENT_YUV2RGB_ROLE); componentEnums[0]->total_role_num = OT_OMX_COMPONENT_MAX_NUM; EXIT: FunctionOut(); return OT_OMX_COMPONENT_MAX_NUM; }
OSCL_EXPORT_REF int SEC_OMX_COMPONENT_Library_Register(SECRegisterComponentType **ppSECComponent) { FunctionIn(); if (ppSECComponent == NULL) goto EXIT; /* component 1 - video decoder VP8 */ SEC_OSAL_Strcpy(ppSECComponent[0]->componentName, SEC_OMX_COMPONENT_VP8_DEC); SEC_OSAL_Strcpy(ppSECComponent[0]->roles[0], SEC_OMX_COMPONENT_VP8_DEC_ROLE); ppSECComponent[0]->totalRoleNum = MAX_COMPONENT_ROLE_NUM; EXIT: FunctionOut(); return MAX_COMPONENT_NUM; }