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;
}
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;
}
TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreateTask (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_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
TIMM_OSAL_TASK *pHandle = TIMM_OSAL_NULL;
struct sched_param sched;
size_t stackSize;
*pTask = TIMM_OSAL_NULL;
unsigned int temp = (unsigned int)pFunc;
/*Task structure allocation*/
pHandle = (TIMM_OSAL_TASK *) TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_TASK), 0, 0, 0);
if(pHandle == TIMM_OSAL_NULL) {
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));
/*Arguments for task*/
pHandle->uArgc = uArgc;
pHandle->pArgv = pArgv;
pHandle->isCreated = TIMM_OSAL_FALSE;
if(SUCCESS != pthread_attr_init(&pHandle->ThreadAttr)){
/*TIMM_OSAL_Error("Task Init Attr Init failed!");*/
goto EXIT;
}
/* Updation of the priority and the stack size*/
if(SUCCESS != pthread_attr_getschedparam(&pHandle->ThreadAttr, &sched)){
/*TIMM_OSAL_Error("Task Init Get Sched Params failed!");*/
goto EXIT;
}
sched.sched_priority = uPriority; /* relative to the default priority */
if(SUCCESS != pthread_attr_setschedparam(&pHandle->ThreadAttr, &sched)){
/*TIMM_OSAL_Error("Task Init Set Sched Paramsfailed!");*/
goto EXIT;
}
/*First get the default stack size*/
if(SUCCESS != pthread_attr_getstacksize(&pHandle->ThreadAttr, &stackSize)){
/*TIMM_OSAL_Error("Task Init Set Stack Size failed!");*/
goto EXIT;
}
/*Check if requested stack size is larger than the current default stack size*/
if(uStackSize > stackSize) {
stackSize = uStackSize;
if(SUCCESS != pthread_attr_setstacksize(&pHandle->ThreadAttr, stackSize)){
/*TIMM_OSAL_Error("Task Init Set Stack Size failed!");*/
goto EXIT;
}
}
if (SUCCESS != pthread_create(&pHandle->threadID, &pHandle->ThreadAttr, pFunc, pArgv)) {
/*TIMM_OSAL_Error ("Create_Task failed !");*/
goto EXIT;
}
/* Task was successfully created */
pHandle->isCreated = TIMM_OSAL_TRUE;
*pTask = (TIMM_OSAL_PTR )pHandle;
bReturnStatus = TIMM_OSAL_ERR_NONE;
/**pTask = (TIMM_OSAL_PTR *)pHandle;*/
EXIT:
/* if((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandle)) {
TIMM_OSAL_Free (pHandle->stackPtr);*/
if((TIMM_OSAL_ERR_NONE != bReturnStatus)) {
TIMM_OSAL_Free(pHandle);
}
return bReturnStatus;
}
TIMM_OSAL_ERRORTYPE TIMM_OSAL_CreatePipe (TIMM_OSAL_PTR *pPipe,
TIMM_OSAL_U32 pipeSize,
TIMM_OSAL_U32 messageSize,
TIMM_OSAL_U8 isFixedMessage)
{
TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
TIMM_OSAL_PIPE *pHandle = TIMM_OSAL_NULL;
TIMM_OSAL_PIPE *pHandleBackup = TIMM_OSAL_NULL;
pHandle = (TIMM_OSAL_PIPE *)TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_PIPE), 0, 0, 0);
TIMM_OSAL_Memset(pHandle, 0x0, sizeof(TIMM_OSAL_PIPE));
if (TIMM_OSAL_NULL == pHandle) {
bReturnStatus = TIMM_OSAL_ERR_ALLOC;
goto EXIT;
}
if (SUCCESS != pipe(pHandle->pfd)) {
/*TIMM_OSAL_Error ("Create_Pipe failed!!!");*/
goto EXIT;
}
/*AD - This ensures that file descriptors for stdin/out/err are not assigned to
component pipes incase those file descriptors are free Normally this if
condition will not be true and we'll go directly to the else part*/
if(pHandle->pfd[0] == 0 || pHandle->pfd[0] == 1 || pHandle->pfd[0] == 2 ||
pHandle->pfd[1] == 0 || pHandle->pfd[1] == 1 || pHandle->pfd[1] == 2)
{
pHandleBackup = (TIMM_OSAL_PIPE *)TIMM_OSAL_Malloc(sizeof(TIMM_OSAL_PIPE), 0, 0, 0);
TIMM_OSAL_Memset(pHandleBackup, 0x0, sizeof(TIMM_OSAL_PIPE));
if (TIMM_OSAL_NULL == pHandleBackup)
{
bReturnStatus = TIMM_OSAL_ERR_ALLOC;
goto EXIT;
}
/*Allocating the new pipe*/
if (SUCCESS != pipe(pHandleBackup->pfd))
{
goto EXIT;
}
/*Really crazy case if all 3 reserved file descriptors have been freed up!!
Should never happen normally*/
if(pHandleBackup->pfd[0] == 2 || pHandleBackup->pfd[1] == 2)
{
int pfdDummy[2];
if (SUCCESS != close(pHandleBackup->pfd[0]))
{
goto EXIT;
}
if (SUCCESS != close(pHandleBackup->pfd[1]))
{
goto EXIT;
}
/*Allocating the reserved file descriptor to dummy*/
if(SUCCESS != pipe(pfdDummy))
{
goto EXIT;
}
/*Now the backup pfd will not get a reserved value*/
if (SUCCESS != pipe(pHandleBackup->pfd))
{
goto EXIT;
}
/*Closing the dummy pfd*/
if (SUCCESS != close(pfdDummy[0]))
{
goto EXIT;
}
if (SUCCESS != close(pfdDummy[1]))
{
goto EXIT;
}
}
/*Closing the previous pipe*/
if (SUCCESS != close(pHandle->pfd[0]))
{
goto EXIT;
}
if (SUCCESS != close(pHandle->pfd[1]))
{
goto EXIT;
}
TIMM_OSAL_Free(pHandle);
pHandleBackup->pipeSize = pipeSize;
pHandleBackup->messageSize = messageSize;
pHandleBackup->isFixedMessage = isFixedMessage;
pHandleBackup->messageCount = 0;
pHandleBackup->totalBytesInPipe = 0;
*pPipe = (TIMM_OSAL_PTR ) pHandleBackup ;
}
/*This is the normal case when a reserved file descriptor is not assigned to our pipe*/
else
{
pHandle->pipeSize = pipeSize;
pHandle->messageSize = messageSize;
pHandle->isFixedMessage = isFixedMessage;
pHandle->messageCount = 0;
pHandle->totalBytesInPipe = 0;
*pPipe = (TIMM_OSAL_PTR ) pHandle ;
}
bReturnStatus = TIMM_OSAL_ERR_NONE;
EXIT:
if ((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandle)) {
TIMM_OSAL_Free(pHandle);
}
if ((TIMM_OSAL_ERR_NONE != bReturnStatus) && (TIMM_OSAL_NULL != pHandleBackup)) {
TIMM_OSAL_Free(pHandleBackup);
}
return bReturnStatus;
}
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 SampleTest_AllocateBuffers(SampleCompTestCtxt * pContext,
OMX_PARAM_PORTDEFINITIONTYPE * pPortDef)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_U8 *pBuffer = NULL;
BufferList *pBufferList;
BufferList *pTemp;
OMX_BUFFERHEADERTYPE *pBufferHdr;
OMX_U32 i = 100;
OMX_COMPONENTTYPE *pComp;
#ifdef OMX_SAMPLE_TILER_TEST
MemAllocBlock *pBlock = NULL;
OMX_U32 nNumBlocks = 1;
/*For i/p port allocate 2D packed buffer, for o/p port allocate 1D buffer.
Ideally client should get this from GetParams but this is just a sample test so
values are hardcoded*/
if (pPortDef->nPortIndex == OMX_SAMPLE_INPUT_PORT)
{
nNumBlocks = 2;
pBlock =
TIMM_OSAL_Malloc(sizeof(MemAllocBlock) * nNumBlocks, 0, 0,
0);
TIMM_OSAL_Memset(pBlock, 0, sizeof(MemAllocBlock) * nNumBlocks);
pBlock[0].dim.area.width = OMX_SAMPLE_IN_2DYWIDTH;
pBlock[0].dim.area.height = OMX_SAMPLE_IN_2DYHEIGHT;
pBlock[0].pixelFormat = PIXEL_FMT_8BIT;
pBlock[1].dim.area.width = OMX_SAMPLE_IN_2DUVWIDTH;
pBlock[1].dim.area.height = OMX_SAMPLE_IN_2DUVHEIGHT;
pBlock[1].pixelFormat = PIXEL_FMT_16BIT;
} else
{
nNumBlocks = 1;
pBlock =
TIMM_OSAL_Malloc(sizeof(MemAllocBlock) * nNumBlocks, 0, 0,
0);
TIMM_OSAL_Memset(pBlock, 0, sizeof(MemAllocBlock) * nNumBlocks);
pBlock[0].dim.len = OMX_SAMPLE_BUFFER_SIZE;
pBlock[0].pixelFormat = PIXEL_FMT_PAGE;
}
#endif
for (i = 0; i < pPortDef->nBufferCountActual; i++)
{
pBufferList =
(BufferList *) TIMM_OSAL_Malloc(sizeof(BufferList),
TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT);
if (!pBufferList)
{
OMX_TEST_SET_ERROR_BAIL
(OMX_ErrorInsufficientResources,
"malloc failed \n");
}
if (pContext->bClientAllocBuf)
{
#ifdef OMX_SAMPLE_TILER_TEST
/*For i/p port allocate 2D packed buffer, for o/p port allocate 1D buffer.
Ideally client should get this from GetParams but this is just a sample test so
values are hardcoded*/
pBuffer = MemMgr_Alloc(pBlock, nNumBlocks);
printf("\nMemMgr allocated buffer = 0x%x\n", pBuffer);
#else
pBuffer =
(OMX_U8 *) TIMM_OSAL_MallocaBuffer(pPortDef->
nBufferSize, pPortDef->bBuffersContiguous,
pPortDef->nBufferAlignment);
#endif
if (!pBufferList)
{
OMX_TEST_SET_ERROR_BAIL
(OMX_ErrorInsufficientResources,
"malloc failed \n");
}
printf("\nCalling UseBuf on port %d\n",
pPortDef->nPortIndex);
eError =
OMX_UseBuffer(pContext->hComp, &pBufferHdr,
pPortDef->nPortIndex, 0, pPortDef->nBufferSize,
pBuffer);
OMX_TEST_BAIL_IF_ERROR(eError);
} else
{
pComp = (OMX_COMPONENTTYPE *) pContext->hComp;
printf("\nCalling allocate buffer\n");
eError =
OMX_AllocateBuffer(pContext->hComp, &pBufferHdr,
pPortDef->nPortIndex, 0, pPortDef->nBufferSize);
OMX_TEST_BAIL_IF_ERROR(eError);
}
printf("\npBufferHdr->nOutputPortIndex = %d\n",
pBufferHdr->nOutputPortIndex);
printf("\npBufferHdr->nInputPortIndex = %d\n",
pBufferHdr->nInputPortIndex);
pBufferList->pNextBuf = NULL;
pBufferList->pBufHdr = pBufferHdr;
pBufferList->pOrigBufHdr = pBufferHdr;
if (pPortDef->eDir == OMX_DirInput)
{
printf("\npBufferHdr->nOutputPortIndex = %d\n",
pBufferHdr->nOutputPortIndex);
printf("\npBufferHdr->nInputPortIndex = %d\n",
pBufferHdr->nInputPortIndex);
pBufferHdr->nOutputPortIndex = OMX_NOPORT;
if (pContext->pInBufferList == NULL)
{
pContext->pInBufferList = pBufferList;
} else
{
pTemp = pContext->pInBufferList;
while (pTemp->pNextBuf)
pTemp = pTemp->pNextBuf;
pTemp->pNextBuf = pBufferList;
}
} else
{
pBufferHdr->nInputPortIndex = OMX_NOPORT;
printf("\npBufferHdr->nOutputPortIndex = %d\n",
pBufferHdr->nOutputPortIndex);
printf("\npBufferHdr->nInputPortIndex = %d\n",
pBufferHdr->nInputPortIndex);
if (pContext->pOutBufferList == NULL)
{
pContext->pOutBufferList = pBufferList;
} else
{
pTemp = pContext->pOutBufferList;
while (pTemp->pNextBuf)
pTemp = pTemp->pNextBuf;
pTemp->pNextBuf = pBufferList;
}
}
}
OMX_TEST_BAIL:
#ifdef OMX_SAMPLE_TILER_TEST
if (pBlock != NULL)
TIMM_OSAL_Free(pBlock);
#endif
if (eError != OMX_ErrorNone)
{
if (pBufferList)
{
TIMM_OSAL_Free(pBufferList);
}
}
return eError;
}
