/* ========================================================================== */ 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; }