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