自学教程：C++ FunctionIn函数代码示例

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

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