MEMPLUGIN_ERRORTYPE MemPlugin_ION_Free(void *pMemPluginHandle,OMX_U32 nClient,
MEMPLUGIN_BUFFER_PARAMS *pIonBufferParams,
MEMPLUGIN_BUFFER_PROPERTIES *pIonBufferProp)
{
MEMPLUGIN_ERRORTYPE eError = MEMPLUGIN_ERROR_NONE;
DOMX_ENTER("%s: called with arguments ion fd %d buffer-params 0x%x buffer-prop 0x%x",__FUNCTION__,nClient,pIonBufferParams,pIonBufferProp);
//unmap
if(pIonBufferParams->bMap == OMX_TRUE)
{
munmap(pIonBufferProp->sBuffer_accessor.pBufferMappedAddress, pIonBufferParams->nHeight * pIonBufferParams->nWidth);
}
//close
close(pIonBufferProp->sBuffer_accessor.bufferFd);
//free
ion_free(nClient, (struct ion_handle*)pIonBufferProp->sBuffer_accessor.pBufferHandle);
EXIT:
if (eError != MEMPLUGIN_ERROR_NONE) {
DOMX_EXIT("%s exited with error 0x%x",__FUNCTION__,eError);
return eError;
}
else {
DOMX_EXIT("%s executed successfully",__FUNCTION__);
return MEMPLUGIN_ERROR_NONE;
}
}
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_ERRORTYPE dcc_eError = OMX_ErrorNone;
OMX_COMPONENTTYPE *pHandle = NULL;
PROXY_COMPONENT_PRIVATE *pComponentPrivate;
OMX_U32 i = 0, j = 0;
OMX_PROXY_CAM_PRIVATE* pCamPrv;
MEMPLUGIN_ERRORTYPE eMemError = MEMPLUGIN_ERROR_NONE;
pHandle = (OMX_COMPONENTTYPE *) hComponent;
TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
DOMX_ENTER("_____________________INSIDE CAMERA PROXY"
"WRAPPER__________________________\n");
pHandle->pComponentPrivate = (PROXY_COMPONENT_PRIVATE *)
TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE),
TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
pComponentPrivate =
(PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
if (pHandle->pComponentPrivate == NULL)
{
DOMX_ERROR(" ERROR IN ALLOCATING PROXY COMPONENT"
"PRIVATE STRUCTURE");
eError = OMX_ErrorInsufficientResources;
goto EXIT;
}
TIMM_OSAL_Memset(pComponentPrivate, 0,
sizeof(PROXY_COMPONENT_PRIVATE));
pComponentPrivate->cCompName =
TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
/*Copying component Name - this will be picked up in the proxy common */
assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH);
TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
strlen(COMPONENT_NAME) + 1);
pComponentPrivate->pCompProxyPrv =
(OMX_PROXY_CAM_PRIVATE *)
TIMM_OSAL_Malloc(sizeof(OMX_PROXY_CAM_PRIVATE), TIMM_OSAL_TRUE,
0, TIMMOSAL_MEM_SEGMENT_INT);
PROXY_assert(pComponentPrivate->pCompProxyPrv != NULL,
OMX_ErrorInsufficientResources,
"Could not allocate memory for proxy component private data structure");
pCamPrv = (OMX_PROXY_CAM_PRIVATE*)pComponentPrivate->pCompProxyPrv;
TIMM_OSAL_Memset(pComponentPrivate->pCompProxyPrv, 0,
sizeof(OMX_PROXY_CAM_PRIVATE));
pComponentPrivate->bMapBuffers = OMX_TRUE;
/*Calling Proxy Common Init() */
eError = OMX_ProxyCommonInit(hComponent);
if (eError != OMX_ErrorNone)
{
DOMX_ERROR("\Error in Initializing Proxy");
TIMM_OSAL_Free(pComponentPrivate->cCompName);
TIMM_OSAL_Free(pComponentPrivate);
TIMM_OSAL_Free(pComponentPrivate->pCompProxyPrv);
goto EXIT;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_FreeHandle(RPC_OMX_HANDLE hRPCCtx,
OMX_ERRORTYPE * eCompReturn)
{
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
RPC_OMX_MESSAGE *pRPCMsg = NULL;
RPC_OMX_BYTE *pMsgBody;
OMX_U32 nPacketSize = PACKET_SIZE;
RcmClient_Message *pPacket = NULL;
RcmClient_Message *pRetPacket = NULL;
OMX_S16 status;
RPC_INDEX fxnIdx;
OMX_U32 nPos = 0;
RPC_OMX_CONTEXT *hCtx = hRPCCtx;
RPC_OMX_HANDLE hComp = hCtx->remoteHandle;
DOMX_ENTER("");
RPC_exitOnDucatiFault();
fxnIdx =
rpcHndl[TARGET_CORE_ID].rpcFxns[RPC_OMX_FXN_IDX_FREE_HANDLE].
rpcFxnIdx;
//Allocating remote command message
RPC_getPacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], nPacketSize,
pPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
//Marshalled:[>hComp]
RPC_SETFIELDVALUE(pMsgBody, nPos, hComp, RPC_OMX_HANDLE);
pPacket->poolId = hCtx->nPoolId;
pPacket->jobId = hCtx->nJobId;
RPC_sendPacket_sync(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
fxnIdx, pRetPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pRetPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
*eCompReturn = pRPCMsg->msgHeader.nOMXReturn;
RPC_freePacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pRetPacket);
EXIT:
DOMX_EXIT("");
return eRPCError;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_SKEL_FillBufferDone(void *data)
{
OMX_HANDLETYPE hComp;
RPC_OMX_ERRORTYPE tRPCError = RPC_OMX_ErrorNone;
OMX_U32 nfilledLen = 0;
OMX_U32 nOffset = 0;
OMX_U32 nFlags = 0;
OMX_TICKS nTimeStamp;
OMX_U32 bufferHdr;
OMX_COMPONENTTYPE *pHandle = NULL;
PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
OMX_U32 nPos = 0;
//RPC_OMX_MESSAGE *recdMsg;
OMX_U8 *pMsgBody = NULL;
OMX_HANDLETYPE hMarkTargetComponent = NULL;
OMX_PTR pMarkData = NULL;
//recdMsg = (RPC_OMX_MESSAGE *) (data);
pMsgBody = data; //&recdMsg->msgBody[0];
DOMX_ENTER("");
//Marshalled:[>hComp|>bufferHdr|>nFilledLen|>nOffset|>nFlags|>nTimeStamp]
RPC_GETFIELDVALUE(pMsgBody, nPos, hComp, OMX_HANDLETYPE);
pHandle = (OMX_COMPONENTTYPE *) hComp;
pCompPrv = (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
RPC_GETFIELDVALUE(pMsgBody, nPos, bufferHdr, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, nfilledLen, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, nOffset, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, nFlags, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, nTimeStamp, OMX_TICKS);
RPC_GETFIELDVALUE(pMsgBody, nPos, hMarkTargetComponent,
OMX_HANDLETYPE);
RPC_GETFIELDVALUE(pMsgBody, nPos, pMarkData, OMX_PTR);
tRPCError =
pCompPrv->proxyFillBufferDone(hComp, bufferHdr, nfilledLen,
nOffset, nFlags, nTimeStamp, hMarkTargetComponent, pMarkData);
DOMX_EXIT("");
return tRPCError;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_SKEL_EventHandler(void *data)
{
OMX_HANDLETYPE hComp;
RPC_OMX_ERRORTYPE tRPCError = RPC_OMX_ErrorNone;
OMX_COMPONENTTYPE *pHandle = NULL;
PROXY_COMPONENT_PRIVATE *pCompPrv = NULL;
OMX_EVENTTYPE eEvent;
OMX_U32 nData1;
OMX_U32 nData2;
OMX_PTR pEventData;
OMX_U32 nPos = 0;
//RPC_OMX_MESSAGE *recdMsg;
OMX_U8 *pMsgBody = NULL;
//recdMsg = (RPC_OMX_MESSAGE *) (data);
pMsgBody = data; //&recdMsg->msgBody[0];
DOMX_ENTER("");
//Marshalled:[>hComp|>eEvent|>nData1|>nData2|>pEventData]
RPC_GETFIELDVALUE(pMsgBody, nPos, hComp, OMX_HANDLETYPE);
pHandle = (OMX_COMPONENTTYPE *) hComp;
pCompPrv = (PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
RPC_GETFIELDVALUE(pMsgBody, nPos, eEvent, OMX_EVENTTYPE);
RPC_GETFIELDVALUE(pMsgBody, nPos, nData1, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, nData2, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, nPos, pEventData, OMX_PTR);
DOMX_DEBUG
("\n**__**Got eventhandler from Remote Core succesffuly - values are : **__**");
DOMX_DEBUG
("hComp :0x%x,eEvent: 0x%x,nData1: 0x%x,nData2: 0x%x,pEventData: 0x%x",
hComp, eEvent, nData1, nData2, pEventData);
DOMX_DEBUG("Just Before Entering Proxy Event handler call");
tRPCError =
pCompPrv->proxyEventHandler(hComp, pCompPrv->pILAppData, eEvent,
nData1, nData2, pEventData);
DOMX_EXIT("");
return tRPCError;
}
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_ERRORTYPE dcc_eError = OMX_ErrorNone;
OMX_COMPONENTTYPE *pHandle = NULL;
PROXY_COMPONENT_PRIVATE *pComponentPrivate;
pHandle = (OMX_COMPONENTTYPE *) hComponent;
TIMM_OSAL_ERRORTYPE eOsalError = TIMM_OSAL_ERR_NONE;
DOMX_ENTER("_____________________INSIDE CAMERA PROXY"
"WRAPPER__________________________\n");
pHandle->pComponentPrivate = (PROXY_COMPONENT_PRIVATE *)
TIMM_OSAL_Malloc(sizeof(PROXY_COMPONENT_PRIVATE),
TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
pComponentPrivate =
(PROXY_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
if (pHandle->pComponentPrivate == NULL)
{
DOMX_ERROR(" ERROR IN ALLOCATING PROXY COMPONENT"
"PRIVATE STRUCTURE");
eError = OMX_ErrorInsufficientResources;
goto EXIT;
}
pComponentPrivate->cCompName =
TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8),
TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
/*Copying component Name - this will be picked up in the proxy common */
assert(strlen(COMPONENT_NAME) + 1 < MAX_COMPONENT_NAME_LENGTH);
TIMM_OSAL_Memcpy(pComponentPrivate->cCompName, COMPONENT_NAME,
strlen(COMPONENT_NAME) + 1);
/*Calling Proxy Common Init() */
eError = OMX_ProxyCommonInit(hComponent);
if (eError != OMX_ErrorNone)
{
DOMX_ERROR("\Error in Initializing Proxy");
TIMM_OSAL_Free(pComponentPrivate->cCompName);
TIMM_OSAL_Free(pComponentPrivate);
goto EXIT;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_AllocateBuffer(RPC_OMX_HANDLE hRPCCtx,
OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr, OMX_IN OMX_U32 nPortIndex,
OMX_U32 * pBufHeaderRemote, OMX_U32 * pBufferMapped, OMX_PTR pAppPrivate,
OMX_U32 nSizeBytes, OMX_ERRORTYPE * eCompReturn)
{
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
RcmClient_Message *pPacket = NULL;
RcmClient_Message *pRetPacket = NULL;
OMX_U32 nPacketSize = PACKET_SIZE;
RPC_OMX_MESSAGE *pRPCMsg = NULL;
RPC_OMX_BYTE *pMsgBody;
RPC_INDEX fxnIdx;
OMX_U32 nPos = 0;
OMX_S16 status;
RPC_OMX_CONTEXT *hCtx = hRPCCtx;
RPC_OMX_HANDLE hComp = hCtx->remoteHandle;
OMX_U32 offset = 0;
OMX_TI_PLATFORMPRIVATE *pPlatformPrivate = NULL;
OMX_BUFFERHEADERTYPE *pBufferHdr = *ppBufferHdr;
DOMX_ENTER("");
RPC_exitOnDucatiFault();
fxnIdx =
rpcHndl[TARGET_CORE_ID].rpcFxns[RPC_OMX_FXN_IDX_ALLOCATE_BUFFER].
rpcFxnIdx;
RPC_getPacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], nPacketSize,
pPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
//Marshalled:[>hComp|>nPortIndex|>pAppPrivate|>nSizeBytes|
//<pBufHeaderRemote|<offset(BufHeaderRemotecontents)|<offset(platformprivate)|
//<--BufHeaderRemotecontents--|!<--pPlatformPrivate--]
RPC_SETFIELDVALUE(pMsgBody, nPos, hComp, RPC_OMX_HANDLE);
RPC_SETFIELDVALUE(pMsgBody, nPos, nPortIndex, OMX_U32);
RPC_SETFIELDVALUE(pMsgBody, nPos, pAppPrivate, OMX_PTR);
RPC_SETFIELDVALUE(pMsgBody, nPos, nSizeBytes, OMX_U32);
pPacket->poolId = hCtx->nPoolId;
pPacket->jobId = hCtx->nJobId;
RPC_sendPacket_sync(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
fxnIdx, pRetPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pRetPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
*eCompReturn = pRPCMsg->msgHeader.nOMXReturn;
if (pRPCMsg->msgHeader.nOMXReturn == OMX_ErrorNone)
{
RPC_GETFIELDVALUE(pMsgBody, nPos, *pBufHeaderRemote, OMX_U32);
RPC_GETFIELDOFFSET(pMsgBody, nPos, offset, OMX_U32);
//save platform private before overwriting
pPlatformPrivate = (*ppBufferHdr)->pPlatformPrivate;
//RPC_GETFIELDCOPYTYPE(pMsgBody, offset, pBufferHdr, OMX_BUFFERHEADERTYPE);
/*Copying each field of the header separately due to padding issues in
the buffer header structure */
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nSize,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nVersion,
OMX_VERSIONTYPE);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->pBuffer,
OMX_U8 *);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nAllocLen,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nFilledLen,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nOffset,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->pAppPrivate,
OMX_PTR);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->pPlatformPrivate, OMX_PTR);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->pInputPortPrivate, OMX_PTR);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->pOutputPortPrivate, OMX_PTR);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->hMarkTargetComponent, OMX_HANDLETYPE);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->pMarkData,
OMX_PTR);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nTickCount,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nTimeStamp,
OMX_TICKS);
RPC_GETFIELDVALUE(pMsgBody, offset, pBufferHdr->nFlags,
OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->nInputPortIndex, OMX_U32);
RPC_GETFIELDVALUE(pMsgBody, offset,
pBufferHdr->nOutputPortIndex, OMX_U32);
(*ppBufferHdr)->pPlatformPrivate = pPlatformPrivate;
#ifdef TILER_BUFF
DOMX_DEBUG(" Copying plat pvt. ");
RPC_GETFIELDOFFSET(pMsgBody, nPos, offset, OMX_U32);
if (offset != 0)
{
RPC_GETFIELDCOPYTYPE(pMsgBody, offset,
(OMX_TI_PLATFORMPRIVATE
*) ((*ppBufferHdr)->pPlatformPrivate),
OMX_TI_PLATFORMPRIVATE);
DOMX_DEBUG("Done copying plat pvt., aux buf = 0x%x",
((OMX_TI_PLATFORMPRIVATE
*) ((*ppBufferHdr)->
pPlatformPrivate))->pAuxBuf1);
}
#endif
*pBufferMapped = (OMX_U32) (*ppBufferHdr)->pBuffer;
} else
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_SendCommand(RPC_OMX_HANDLE hRPCCtx,
OMX_COMMANDTYPE eCmd, OMX_U32 nParam, OMX_PTR pCmdData,
OMX_ERRORTYPE * eCompReturn)
{
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
RcmClient_Message *pPacket = NULL;
RcmClient_Message *pRetPacket = NULL;
OMX_U32 nPacketSize = PACKET_SIZE;
RPC_OMX_MESSAGE *pRPCMsg = NULL;
RPC_OMX_BYTE *pMsgBody;
RPC_INDEX fxnIdx;
OMX_U32 nPos = 0;
OMX_S16 status;
RPC_OMX_CONTEXT *hCtx = hRPCCtx;
RPC_OMX_HANDLE hComp = hCtx->remoteHandle;
OMX_U32 structSize = 0;
OMX_U32 offset = 0;
DOMX_ENTER("");
RPC_exitOnDucatiFault();
fxnIdx =
rpcHndl[TARGET_CORE_ID].rpcFxns[RPC_OMX_FXN_IDX_SEND_CMD].
rpcFxnIdx;
//Allocating remote command message
RPC_getPacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], nPacketSize,
pPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
//Marshalled:[>hComp|>eCmd|nParam|>offset(pCmdData)|!><--pCmdData--]
RPC_SETFIELDVALUE(pMsgBody, nPos, hComp, RPC_OMX_HANDLE);
RPC_SETFIELDVALUE(pMsgBody, nPos, eCmd, OMX_COMMANDTYPE);
RPC_SETFIELDVALUE(pMsgBody, nPos, nParam, OMX_U32);
offset =
sizeof(RPC_OMX_HANDLE) + sizeof(OMX_COMMANDTYPE) +
sizeof(OMX_U32) + sizeof(OMX_U32);
RPC_SETFIELDOFFSET(pMsgBody, nPos, offset, OMX_U32);
if (pCmdData != NULL && eCmd == OMX_CommandMarkBuffer)
{
/*The RPC_UTIL_GETSTRUCTSIZE will not work here since OMX_MARKTYPE structure
does not have nSize field */
structSize = sizeof(OMX_MARKTYPE);
RPC_SETFIELDCOPYGEN(pMsgBody, offset, pCmdData, structSize);
} else if (pCmdData != NULL)
{
structSize = RPC_UTIL_GETSTRUCTSIZE(pCmdData);
RPC_SETFIELDCOPYGEN(pMsgBody, offset, pCmdData, structSize);
}
pPacket->poolId = hCtx->nPoolId;
pPacket->jobId = hCtx->nJobId;
RPC_sendPacket_sync(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
fxnIdx, pRetPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pRetPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
*eCompReturn = pRPCMsg->msgHeader.nOMXReturn;
RPC_freePacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pRetPacket);
EXIT:
DOMX_EXIT("");
return eRPCError;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_GetConfig(RPC_OMX_HANDLE hRPCCtx,
OMX_INDEXTYPE nConfigIndex, OMX_PTR pCompConfig,
OMX_ERRORTYPE * eCompReturn)
{
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
RcmClient_Message *pPacket = NULL;
RcmClient_Message *pRetPacket = NULL;
OMX_U32 nPacketSize = PACKET_SIZE;
RPC_OMX_MESSAGE *pRPCMsg = NULL;
RPC_OMX_BYTE *pMsgBody;
RPC_INDEX fxnIdx;
OMX_U32 nPos = 0;
OMX_S16 status;
RPC_OMX_CONTEXT *hCtx = hRPCCtx;
RPC_OMX_HANDLE hComp = hCtx->remoteHandle;
OMX_U32 structSize = 0;
OMX_U32 offset = 0;
DOMX_ENTER("");
RPC_exitOnDucatiFault();
fxnIdx =
rpcHndl[TARGET_CORE_ID].rpcFxns[RPC_OMX_FXN_IDX_GET_CONFIG].
rpcFxnIdx;
//Allocating remote command message
RPC_getPacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], nPacketSize,
pPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
//Marshalled:[>hComp|>nConfigIndex|>offset(pCompConfig)|><--pCompConfig--]
RPC_SETFIELDVALUE(pMsgBody, nPos, hComp, RPC_OMX_HANDLE);
RPC_SETFIELDVALUE(pMsgBody, nPos, nConfigIndex, OMX_INDEXTYPE);
offset =
sizeof(RPC_OMX_HANDLE) + sizeof(OMX_INDEXTYPE) + sizeof(OMX_U32);
RPC_SETFIELDOFFSET(pMsgBody, nPos, offset, OMX_U32);
structSize = RPC_UTIL_GETSTRUCTSIZE(pCompConfig);
RPC_SETFIELDCOPYGEN(pMsgBody, offset, pCompConfig, structSize);
pPacket->poolId = hCtx->nPoolId;
pPacket->jobId = hCtx->nJobId;
RPC_sendPacket_sync(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
fxnIdx, pRetPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pRetPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
*eCompReturn = pRPCMsg->msgHeader.nOMXReturn;
if (pRPCMsg->msgHeader.nOMXReturn == RPC_OMX_ErrorNone)
{
RPC_GETFIELDCOPYGEN(pMsgBody, offset, pCompConfig,
structSize);
}
RPC_freePacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pRetPacket);
EXIT:
DOMX_EXIT("");
return eRPCError;
}
/* ===========================================================================*/
RPC_OMX_ERRORTYPE RPC_GetHandle(RPC_OMX_HANDLE hRPCCtx,
OMX_STRING cComponentName, OMX_PTR pAppData,
OMX_CALLBACKTYPE * pCallBacks, OMX_ERRORTYPE * eCompReturn)
{
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
RPC_OMX_MESSAGE *pRPCMsg = NULL;
RPC_OMX_BYTE *pMsgBody = NULL;
OMX_U32 dataOffset = 0;
OMX_U32 dataOffset2 = 0;
OMX_U32 offset = 0;
OMX_U32 nPacketSize = PACKET_SIZE;
RcmClient_Message *pPacket = NULL;
RcmClient_Message *pRetPacket = NULL;
OMX_U32 nPos = 0;
RPC_OMX_CONTEXT *hCtx = hRPCCtx;
RPC_OMX_HANDLE hComp = NULL;
OMX_HANDLETYPE hActualComp = NULL;
OMX_S16 status;
RPC_INDEX fxnIdx;
OMX_STRING CallingCorercmServerName;
OMX_S32 pid = 0; //For TILER memory allocation changes
DOMX_ENTER("");
DOMX_DEBUG("RPC_GetHandle: Recieved GetHandle request from %s",
cComponentName);
RPC_exitOnDucatiFault();
RPC_UTIL_GetLocalServerName(cComponentName,
&CallingCorercmServerName);
DOMX_DEBUG(" RCM Server Name Calling on Current Core: %s",
CallingCorercmServerName);
fxnIdx =
rpcHndl[TARGET_CORE_ID].rpcFxns[RPC_OMX_FXN_IDX_GET_HANDLE].
rpcFxnIdx;
//Allocating remote command message
RPC_getPacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], nPacketSize,
pPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
//Marshalled:[>offset(cParameterName)|>pAppData|>offset(CallingCorercmServerName)|>pid|
//>--cComponentName--|>--CallingCorercmServerName--|
//<hComp]
dataOffset =
sizeof(OMX_U32) + sizeof(OMX_PTR) + sizeof(OMX_U32) +
sizeof(OMX_S32);
RPC_SETFIELDOFFSET(pMsgBody, nPos, dataOffset, OMX_U32);
//To update with RPC macros
strcpy((char *)(pMsgBody + dataOffset), cComponentName);
RPC_SETFIELDVALUE(pMsgBody, nPos, pAppData, OMX_PTR);
dataOffset2 = dataOffset + 128; //max size of omx comp name
RPC_SETFIELDOFFSET(pMsgBody, nPos, dataOffset2, OMX_U32);
//To update with RPC macros
strcpy((char *)(pMsgBody + dataOffset2), CallingCorercmServerName);
//Towards TILER memory allocation changes
pid = getpid();
RPC_SETFIELDVALUE(pMsgBody, nPos, pid, OMX_S32);
pPacket->poolId = hCtx->nPoolId;
pPacket->jobId = hCtx->nJobId;
RPC_sendPacket_sync(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pPacket,
fxnIdx, pRetPacket);
pRPCMsg = (RPC_OMX_MESSAGE *) (&pRetPacket->data);
pMsgBody = &pRPCMsg->msgBody[0];
*eCompReturn = pRPCMsg->msgHeader.nOMXReturn;
if (*eCompReturn == OMX_ErrorNone)
{
offset = dataOffset2 + 32; //max size of rcm server name
RPC_GETFIELDVALUE(pMsgBody, offset, hComp, RPC_OMX_HANDLE);
DOMX_DEBUG("Received Remote Handle 0x%x", hComp);
hCtx->remoteHandle = hComp;
/* The handle received above is used for all communications
with the remote component but is not the actual component
handle (it is actually the rpc context handle which
contains lot of other info). The handle recd. below is the
actual remote component handle. This is used at present for
mark buffer implementation since in that case it is not
feasible to send the context handle */
RPC_GETFIELDVALUE(pMsgBody, offset, hActualComp,
OMX_HANDLETYPE);
hCtx->hActualRemoteCompHandle = hActualComp;
}
RPC_freePacket(hCtx->ClientHndl[RCM_DEFAULT_CLIENT], pRetPacket);
EXIT:
DOMX_EXIT("");
return eRPCError;
}
OMX_ERRORTYPE GLUE_CameraSetParam(OMX_IN OMX_HANDLETYPE
hComponent, OMX_IN OMX_INDEXTYPE nParamIndex,
OMX_INOUT OMX_PTR pComponentParameterStructure)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
MEMPLUGIN_ERRORTYPE eMemError = MEMPLUGIN_ERROR_NONE;
MEMPLUGIN_BUFFER_PARAMS newBuffer_params,delBuffer_params;
MEMPLUGIN_BUFFER_PROPERTIES newBuffer_prop,delBuffer_prop;
OMX_S32 ret = 0;
PROXY_COMPONENT_PRIVATE *pCompPrv;
OMX_PROXY_CAM_PRIVATE* pCamPrv;
OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *)hComponent;
OMX_U32 stride_Y = 0;
OMX_TI_PARAM_COMPONENTBUFALLOCTYPE *bufferalloc = NULL;
int size = 0;
MEMPLUGIN_ION_PARAMS *pIonParams;
MEMPLUGIN_OBJECT *pMemPluginHdl;
DOMX_ENTER("%s: ENTERING",__FUNCTION__);
pCompPrv = (PROXY_COMPONENT_PRIVATE *)hComp->pComponentPrivate;
pCamPrv = (OMX_PROXY_CAM_PRIVATE*)pCompPrv->pCompProxyPrv;
pMemPluginHdl = ((MEMPLUGIN_OBJECT *)pCompPrv->pMemPluginHandle);
pIonParams = ((MEMPLUGIN_ION_PARAMS *)pMemPluginHdl->pPluginExtendedInfo);
MEMPLUGIN_BUFFER_PARAMS_INIT(newBuffer_params);
MEMPLUGIN_BUFFER_PARAMS_INIT(delBuffer_params);
switch (nParamIndex)
{
case OMX_TI_IndexParamComponentBufferAllocation: {
OMX_U32 port = 0, index = 0;
int fd;
bufferalloc = (OMX_TI_PARAM_COMPONENTBUFALLOCTYPE *)
pComponentParameterStructure;
port = bufferalloc->nPortIndex;
index = bufferalloc->nIndex;
newBuffer_params.nWidth = bufferalloc->nAllocWidth * bufferalloc->nAllocLines;
newBuffer_params.eBuffer_type = TILER1D;
newBuffer_params.eTiler_format = MEMPLUGIN_TILER_FORMAT_PAGE;
if(pIonParams == NULL)
{
pIonParams = TIMM_OSAL_MallocExtn(sizeof(MEMPLUGIN_ION_PARAMS), TIMM_OSAL_TRUE,
0, TIMMOSAL_MEM_SEGMENT_EXT, NULL);
if(pIonParams == NULL)
{
DOMX_ERROR("%s:Error allocating pPluginExtendedInfo",__FUNCTION__);
goto EXIT;
}
pMemPluginHdl->pPluginExtendedInfo = pIonParams;
}
MEMPLUGIN_ION_PARAMS_INIT(pIonParams);
//override alloc_flags for tiler 1d non secure
pIonParams->alloc_flags = OMAP_ION_HEAP_TILER_MASK;
eMemError = MemPlugin_Alloc(pCompPrv->pMemPluginHandle,pCompPrv->nMemmgrClientDesc,&newBuffer_params,&newBuffer_prop);
if(eMemError != MEMPLUGIN_ERROR_NONE)
{
DOMX_ERROR("%s:allocation failed size: %d",newBuffer_params.nWidth*newBuffer_params.nHeight);
eError = OMX_ErrorInsufficientResources;
goto EXIT;
}
bufferalloc->pBuf[0] = (OMX_PTR)newBuffer_prop.sBuffer_accessor.bufferFd;
eError = __PROXY_SetParameter(hComponent,
OMX_TI_IndexParamComponentBufferAllocation,
bufferalloc, &bufferalloc->pBuf[0], 1);
if (eError != OMX_ErrorNone) {
MemPlugin_Free(pCompPrv->pMemPluginHandle,pCompPrv->nMemmgrClientDesc, &newBuffer_params,&newBuffer_prop);
} else {
if (pCamPrv->gComponentBufferAllocation[port][index]) {
delBuffer_prop.sBuffer_accessor.pBufferHandle = pCamPrv->gComponentBufferAllocation[port][index];
MemPlugin_Free(pCompPrv->pMemPluginHandle,pCompPrv->nMemmgrClientDesc,&delBuffer_params,&delBuffer_prop);
}
pCamPrv->gComponentBufferAllocation[port][index] = newBuffer_prop.sBuffer_accessor.pBufferHandle;
}
close (newBuffer_prop.sBuffer_accessor.bufferFd);
newBuffer_prop.sBuffer_accessor.bufferFd = -1;
}
goto EXIT;
break;
default:
break;
}
EXIT:
pMemPluginHdl->pPluginExtendedInfo = NULL;
if (eError != OMX_ErrorNone) {
DOMX_ERROR("%s: Error 0x%x",__FUNCTION__, eError);
}
return eError;
}
