/* ========================================================================== */
static void writeMsg(TIMM_OSAL_PTR pBuffer, TIMM_OSAL_U32 nNumBytes)
{
static systemMessage_t* tmpMsg = NULL;
if (!pBuffer){
SCREXEC_DBG_PRINT("Invalid return buffer supplied!\n");
return TIMM_OSAL_ERR_PARAMETER;
}
if(nNumBytes == sizeof(systemMessage_t*)){
tmpMsg = TIMM_OSAL_MallocExtn(sizeof(systemMessage_t), TIMM_OSAL_TRUE, 32, 0, NULL);
TIMM_OSAL_Memcpy(tmpMsg, pBuffer, sizeof(systemMessage_t));
if(tmpMsg->nPayloadSize > 0){
tmpMsg->pPayload = TIMM_OSAL_MallocExtn(tmpMsg->nPayloadSize, TIMM_OSAL_TRUE, 32, 0, NULL);
TIMM_OSAL_Memcpy(tmpMsg->pPayload, ((systemMessage_t*)pBuffer)->pPayload, tmpMsg->nPayloadSize);
}else {
tmpMsg->pPayload = NULL;
}
if (TIMM_OSAL_ERR_NONE != TIMM_OSAL_WriteToPipe(STAND1_Script_Execution_PipeI, &tmpMsg, sizeof(systemMessage_t*), TIMM_OSAL_SUSPEND)){
SCREXEC_DBG_PRINT("TIMM_OSAL_WriteToPipe failed!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
SCREXEC_DBG_PRINT("Successful message write!\nSent %08X", &tmpMsg);
}else {
SCREXEC_DBG_PRINT("Out of sequence message!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
return TIMM_OSAL_ERR_NONE;
}
MEMPLUGIN_ERRORTYPE MemPlugin_ION_Init(void **pMemPluginHandle)
{
MEMPLUGIN_ERRORTYPE eError = MEMPLUGIN_ERROR_NONE;
MEMPLUGIN_OBJECT *pMemPluginHdl;
pMemPluginHdl = TIMM_OSAL_MallocExtn(sizeof(MEMPLUGIN_OBJECT), TIMM_OSAL_TRUE,
0, TIMMOSAL_MEM_SEGMENT_EXT, NULL);
if(pMemPluginHdl == NULL)
{
eError = MEMPLUGIN_ERROR_NORESOURCES;
DOMX_ERROR("%s: allocation failed",__FUNCTION__);
goto EXIT;
}
TIMM_OSAL_Memset(pMemPluginHdl, 0, sizeof(MEMPLUGIN_OBJECT));
pMemPluginHdl->fpOpen = MemPlugin_ION_Open;
pMemPluginHdl->fpClose = MemPlugin_ION_Close;
pMemPluginHdl->fpConfig = MemPlugin_ION_Configure;
pMemPluginHdl->fpAlloc = MemPlugin_ION_Alloc;
pMemPluginHdl->fpFree = MemPlugin_ION_Free;
pMemPluginHdl->fpDeInit = MemPlugin_ION_DeInit;
*pMemPluginHandle = pMemPluginHdl;
EXIT:
if(eError != MEMPLUGIN_ERROR_NONE)
{
DOMX_EXIT("%s: failed with error %d",__FUNCTION__,eError);
}
else
{
DOMX_EXIT("%s: executed successfully",__FUNCTION__);
}
return eError;
}
/* ========================================================================== */
static void readMsg(TIMM_OSAL_PTR pBuffer, TIMM_OSAL_U32 nNumBytes)
{
TIMM_OSAL_U32 actSizeRead = 0;
static systemMessage_t* tmpMsg = NULL;
if (!pBuffer){
SCREXEC_DBG_PRINT("Invalid return buffer supplied!\n");
return TIMM_OSAL_ERR_PARAMETER;
}
if(tmpMsg == NULL){
if (TIMM_OSAL_ERR_NONE != TIMM_OSAL_ReadFromPipe(STAND1_Script_Execution_PipeO, &tmpMsg, sizeof(systemMessage_t*), &actSizeRead, TIMM_OSAL_SUSPEND)) {
SCREXEC_DBG_PRINT("TIMM_OSAL_ReadFromPipe failed!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
}
if(actSizeRead != sizeof(systemMessage_t*)){
STAND1_DBG_PRINT("Requested %d bytes but read %d bytes\n", nNumBytes, actSizeRead);
return TIMM_OSAL_ERR_UNKNOWN;
}
if(tmpMsg == NULL){
SCREXEC_DBG_PRINT("Non-existent message!\n");
return TIMM_OSAL_ERR_UNKNOWN;
}
TIMM_OSAL_Memcpy(pBuffer, tmpMsg, sizeof(systemMessage_t));
if(tmpMsg->nPayloadSize == 0){
SCREXEC_DBG_PRINT("Successful message read!\nRead %08X", &tmpMsg);
TIMM_OSAL_Free(tmpMsg);
tmpMsg = NULL;
}else {
((systemMessage_t*)pBuffer)->pPayload = TIMM_OSAL_MallocExtn(tmpMsg->nPayloadSize, TIMM_OSAL_TRUE, 32, 0, NULL);
TIMM_OSAL_Memcpy(((systemMessage_t*)pBuffer)->pPayload, tmpMsg->pPayload, tmpMsg->nPayloadSize);
SCREXEC_DBG_PRINT("Successful message read!\nRead %08X", &tmpMsg);
TIMM_OSAL_Free(tmpMsg->pPayload);
TIMM_OSAL_Free(tmpMsg);
tmpMsg = NULL;
}
return TIMM_OSAL_ERR_NONE;
}
TIMM_OSAL_ERRORTYPE CCommunicationChannelImplementation::MsgReceive(TIMM_OSAL_PTR* pCurMessage)
{
TIMM_OSAL_ERRORTYPE error = TIMM_OSAL_ERR_NONE;
systemMessage_t* message;
TIMM_OSAL_U32 nMessageSize = 0;
// Allocate space for message header
message = (systemMessage_t*)TIMM_OSAL_MallocExtn(DEFAULT_MESSAGE_SIZE, TIMM_OSAL_TRUE, 32,
TIMMOSAL_MEM_SEGMENT_EXT, NULL);
//printf("internalMsgRecvThread: Allocate message\n");
if (!message)
{
printf("Cant allocate %d bytes form message header\n", DEFAULT_MESSAGE_SIZE);
return TIMM_OSAL_ERR_ALLOC;
}
*(systemMessage_t **)pCurMessage = message;
message->pPayload = NULL;
//TIMM_OSAL_ReadFromPipe doesn't support timeout
// printf("internalMsgRecvThread: Read from Pipe!\n");
error = TIMM_OSAL_ReadFromPipe(internalMsgPipe, message, DEFAULT_MESSAGE_SIZE, &nMessageSize,
TIMM_OSAL_SUSPEND);//inifinite timeout
if (TIMM_OSAL_ERR_NONE != error)
{
TIMM_OSAL_Free(message);
message = NULL;
printf("Can't read from message pipe\n");
return error;
} else if (nMessageSize < sizeof(systemMessage_t))
{
TIMM_OSAL_Free(message);
message = NULL;
printf("Read data is less than message header size\n");
return TIMM_OSAL_ERR_MSG_SIZE_MISMATCH;
}
return TIMM_OSAL_ERR_NONE;
}
/* Object__create__S */
xdc_Ptr OmxRpc_object_create (xdc_Ptr oa, xdc_SizeT osz,
const OmxRpc_Params *aa,
xdc_SizeT psz, xdc_runtime_Error_Block *eb)
{
OmxRpc_Object *obj;
DOMX_UTL_TRACE_FUNCTION_ENTRY_LEVEL1 ();
/* common instance initialization */
obj = TIMM_OSAL_MallocExtn (sizeof (OmxRpc_Object),
TIMM_OSAL_TRUE, 0,
TIMMOSAL_MEM_SEGMENT_EXT, NULL);
if (obj == NULL)
{
return NULL;
}
/* module-specific initialization */
OmxRpc_Instance_init (obj, aa, eb);
DOMX_UTL_TRACE_FUNCTION_EXIT_LEVEL1 (OMX_ErrorNone);
return obj;
}
TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateTaskExtn (TIMM_OSAL_PTR *pTask,
TIMM_OSAL_TaskProc pFunc,
TIMM_OSAL_U32 uArgc,
TIMM_OSAL_PTR pArgv,
TIMM_OSAL_U32 uStackSize,
TIMM_OSAL_U32 uPriority,
TIMM_OSAL_S8 *pName,
TIMM_OSAL_PTR hStackHeapHandle)
{
TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
TIMM_OSAL_TASK *pHandle = TIMM_OSAL_NULL;
Task_Params taskParams;
*pTask = TIMM_OSAL_NULL;
if((pFunc == NULL)|| (uPriority > 31))
{
bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
goto EXIT;
}
pHandle = (TIMM_OSAL_TASK *) TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_TASK),
TIMM_OSAL_TRUE, 0,
TIMMOSAL_MEM_SEGMENT_EXT);
if(TIMM_OSAL_NULL == pHandle)
{
bReturnStatus = TIMM_OSAL_ERR_ALLOC;
goto EXIT;
}
/* Initial cleaning of the task structure */
TIMM_OSAL_Memset((TIMM_OSAL_PTR)pHandle, 0, sizeof (TIMM_OSAL_TASK));
pHandle->isCreated = TIMM_OSAL_FALSE;
strncpy((TIMM_OSAL_CHAR *)pHandle->name, (TIMM_OSAL_CHAR *)pName, TASK_NAME_SIZE);
pHandle->name[TASK_NAME_SIZE] = '\000';
pHandle->stackSize = uStackSize;
pHandle->priority = uPriority;
/* Allocate memory for task stack */
pHandle->stackPtr = (TIMM_OSAL_PTR *)TIMM_OSAL_MallocExtn(pHandle->stackSize,
TIMM_OSAL_TRUE, 0,
TIMMOSAL_MEM_SEGMENT_EXT,
hStackHeapHandle);
if (TIMM_OSAL_NULL == pHandle->stackPtr)
{
TIMM_OSAL_Error("TIMM_OSAL_Malloc failed during task stack allocation");
bReturnStatus = TIMM_OSAL_ERR_ALLOC;
goto EXIT;
}
TIMM_OSAL_Memset(pHandle->stackPtr, 0xFE, pHandle->stackSize);
Task_Params_init(&taskParams);
taskParams.arg0 = uArgc;
taskParams.arg1 = (TIMM_OSAL_U32)pArgv;
taskParams.priority = uPriority;
taskParams.stack = pHandle->stackPtr;
taskParams.stackSize = uStackSize;
taskParams.instance->name = (xdc_String)pHandle->name;
/* Create the task */
pHandle->task = Task_create((Task_FuncPtr)pFunc, &taskParams, NULL);
if (pHandle->task == NULL)
{
bReturnStatus = (TIMM_OSAL_ERRORTYPE)TIMM_OSAL_ERR_CREATE
(TIMM_OSAL_ERR, TIMM_OSAL_COMP_TASK, FALSE);
goto EXIT;
}
/* Task was successfully created */
pHandle->isCreated = TIMM_OSAL_TRUE;
*pTask = (TIMM_OSAL_PTR *)pHandle;
EXIT:
if((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandle))
{
if(TIMM_OSAL_NULL != pHandle->stackPtr)
TIMM_OSAL_Free (pHandle->stackPtr);
TIMM_OSAL_Free (pHandle);
}
return bReturnStatus;
}
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;
}
OMX_ERRORTYPE GLUE_CameraVtcAllocateMemory(OMX_IN OMX_HANDLETYPE hComponent, OMX_TI_PARAM_VTCSLICE *pVtcConfig,
OMX_U32 nFrmWidth, OMX_U32 nFrmHeight)
{
OMX_U32 i;
OMX_ERRORTYPE eError = OMX_ErrorNone, eCompReturn = OMX_ErrorNone;
PROXY_COMPONENT_PRIVATE *pCompPrv;
OMX_PROXY_CAM_PRIVATE* pCamPrv;
OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent;
MEMPLUGIN_BUFFER_PARAMS newBuffer_params,delBuffer_params;
MEMPLUGIN_BUFFER_PROPERTIES newBuffer_prop,delBuffer_prop;
RPC_OMX_ERRORTYPE eRPCError = RPC_OMX_ErrorNone;
MEMPLUGIN_ERRORTYPE eMemError = MEMPLUGIN_ERROR_NONE;
MEMPLUGIN_ION_PARAMS *pIonParams;
MEMPLUGIN_OBJECT *pMemPluginHdl;
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);
for(i=0; i < MAX_NUM_INTERNAL_BUFFERS; i++) {
pVtcConfig->nInternalBuffers = i;
newBuffer_params.nWidth = nFrmWidth;
newBuffer_params.nHeight = nFrmHeight;
newBuffer_params.eBuffer_type = TILER1D;
newBuffer_params.eTiler_format = MEMPLUGIN_TILER_FORMAT_8BIT;
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;
}
eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, newBuffer_prop.sBuffer_accessor.bufferFd, -1,
&pCamPrv->sInternalBuffers[i][0].pRegBufferHandle, NULL, IONPointers);
PROXY_checkRpcError();
pVtcConfig->IonBufhdl[0] = (OMX_PTR)pCamPrv->sInternalBuffers[i][0].pRegBufferHandle;
pCamPrv->sInternalBuffers[i][0].pBufferHandle = newBuffer_prop.sBuffer_accessor.pBufferHandle;
close (newBuffer_prop.sBuffer_accessor.bufferFd);
newBuffer_prop.sBuffer_accessor.bufferFd = -1;
DOMX_DEBUG(" DOMX: ION Buffer#%d: Y: 0x%x, eError = 0x%x, eRPCError = 0x%x\n", i, pVtcConfig->IonBufhdl[0], eError, eRPCError);
MEMPLUGIN_BUFFER_PARAMS_INIT(newBuffer_params);
newBuffer_params.nWidth = nFrmWidth/2;
newBuffer_params.nHeight = nFrmHeight/2;
newBuffer_params.eBuffer_type = TILER1D;
newBuffer_params.eTiler_format = MEMPLUGIN_TILER_FORMAT_16BIT;
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;
if (pCamPrv->sInternalBuffers[i][0].pRegBufferHandle != NULL) {
eRPCError = RPC_UnRegisterBuffer(pCompPrv->hRemoteComp, pCamPrv->sInternalBuffers[i][0].pRegBufferHandle, NULL , IONPointers);
PROXY_checkRpcError();
}
MEMPLUGIN_BUFFER_PARAMS_INIT(delBuffer_params);
delBuffer_prop.sBuffer_accessor.pBufferHandle = pCamPrv->sInternalBuffers[i][0].pBufferHandle;
MemPlugin_Free(pCompPrv->pMemPluginHandle,pCompPrv->nMemmgrClientDesc,&delBuffer_params,&delBuffer_prop );
pCamPrv->sInternalBuffers[i][0].pBufferHandle = NULL;
goto EXIT;
}
eRPCError = RPC_RegisterBuffer(pCompPrv->hRemoteComp, newBuffer_prop.sBuffer_accessor.bufferFd,-1,
&pCamPrv->sInternalBuffers[i][1].pRegBufferHandle, NULL, IONPointers);
PROXY_checkRpcError();
pVtcConfig->IonBufhdl[1] = pCamPrv->sInternalBuffers[i][1].pRegBufferHandle;
pCamPrv->sInternalBuffers[i][1].pBufferHandle = newBuffer_prop.sBuffer_accessor.pBufferHandle;
close (newBuffer_prop.sBuffer_accessor.bufferFd);
DOMX_DEBUG("DOMX: ION Buffer#%d: UV: 0x%x, eError: 0x%x eRPCError: 0x%x\n", i, pVtcConfig->IonBufhdl[1],eError,eRPCError);
eError = __PROXY_SetParameter(hComponent,
OMX_TI_IndexParamVtcSlice,
pVtcConfig,
pVtcConfig->IonBufhdl, 2);
if (eError != OMX_ErrorNone) {
DOMX_ERROR("DOMX: PROXY_SetParameter for OMX_TI_IndexParamVtcSlice completed with error 0x%x\n", eError);
OMX_CameraVtcFreeMemory(hComponent);
goto EXIT;
}
}
EXIT:
pMemPluginHdl->pPluginExtendedInfo = NULL;
if (eError != OMX_ErrorNone) {
DOMX_ERROR("%s: Error 0x%x",__FUNCTION__, eError);
}
return eError;
}
