/* ========================================================================== */ 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; }
void Test_Util_Memcpy_1Dto2D(TIMM_OSAL_PTR pDst2D, TIMM_OSAL_PTR pSrc1D, TIMM_OSAL_U32 nSize1D, TIMM_OSAL_U32 nHeight2D, TIMM_OSAL_U32 nWidth2D, TIMM_OSAL_U32 nStride2D) { TIMM_OSAL_U8 *pInBuffer; TIMM_OSAL_U8 *pOutBuffer; TIMM_OSAL_U32 nSizeLeft, i; nSizeLeft = nSize1D; pInBuffer = (TIMM_OSAL_U8 *) pSrc1D; pOutBuffer = (TIMM_OSAL_U8 *) pDst2D; //The lower limit is copied. If nSize1D < H*W then 1Dsize is copied else H*W is copied for (i = 0; i < nHeight2D; i++) { if (nSizeLeft >= nWidth2D) { TIMM_OSAL_Memcpy(pOutBuffer, pInBuffer, nWidth2D); } else { TIMM_OSAL_Memcpy(pOutBuffer, pInBuffer, nSizeLeft); break; } nSizeLeft -= nWidth2D; pInBuffer = (TIMM_OSAL_U8 *) ((TIMM_OSAL_U32) pInBuffer + nWidth2D); pOutBuffer = (TIMM_OSAL_U8 *) ((TIMM_OSAL_U32) pOutBuffer + nStride2D); } }
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; }
/* ========================================================================== */ 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; }
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_COMPONENTTYPE *pHandle = NULL; PROXY_COMPONENT_PRIVATE *pComponentPrivate; pHandle = (OMX_COMPONENTTYPE *) hComponent; DOMX_DEBUG("___INSISDE VIDEO DECODER 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_DEBUG (" ERROR IN ALLOCATING PROXY COMPONENT PRIVATE STRUCTURE"); eError = OMX_ErrorInsufficientResources; goto EXIT; } pComponentPrivate->cCompName = (OMX_U8 *) TIMM_OSAL_Malloc(MAX_COMPONENT_NAME_LENGTH * sizeof(OMX_U8), TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); if (pComponentPrivate->cCompName == NULL) { DOMX_DEBUG (" ERROR IN ALLOCATING PROXY COMPONENT NAME STRUCTURE"); TIMM_OSAL_Free(pComponentPrivate); eError = OMX_ErrorInsufficientResources; goto EXIT; } // 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); eError = OMX_ProxyCommonInit(hComponent); // Calling Proxy Common Init() if (eError != OMX_ErrorNone) { DOMX_DEBUG("Error in Initializing Proxy"); TIMM_OSAL_Free(pComponentPrivate->cCompName); TIMM_OSAL_Free(pComponentPrivate); } // Make sure private function to component is always assigned // after component init. #ifdef _OPENCORE pHandle->GetParameter = ComponentPrivateGetParameters; #endif pHandle->EmptyThisBuffer = PrearrageEmptyThisBuffer; EXIT: return eError; }
OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComponent) { OMX_ERRORTYPE eError = OMX_ErrorNone; OMX_COMPONENTTYPE *pHandle = NULL; PROXY_COMPONENT_PRIVATE *pComponentPrivate; pHandle = (OMX_COMPONENTTYPE *) hComponent; DOMX_DEBUG("__INSIDE VP6 VIDEO DECODER 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_DEBUG(" 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); if (pComponentPrivate->cCompName == NULL) { DOMX_DEBUG(" ERROR IN ALLOCATING PROXY " "COMPONENT NAME"); eError = OMX_ErrorInsufficientResources; goto EXIT; } /*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); printf("pComponentPrivate->cCompName : %s \n", pComponentPrivate->cCompName); eError = OMX_ProxyCommonInit(hComponent); EXIT: if (eError != OMX_ErrorNone) { DOMX_DEBUG("Error in Initializing Proxy"); if (pComponentPrivate) { if (pComponentPrivate->cCompName) TIMM_OSAL_Free(pComponentPrivate->cCompName); TIMM_OSAL_Free(pComponentPrivate); } } return eError; }
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; }
void TIMM_OSAL_Free (TIMM_OSAL_PTR pData) { TIMM_OSAL_U32 *pIntPtr = NULL, total_alloc_size; TIMM_OSAL_U32 bytes_to_skip; xdc_runtime_IHeap_Handle hHeap = NULL; if (TIMM_OSAL_NULL == pData) { TIMM_OSAL_Error("TIMM_OSAL_Free called on NULL pointer"); goto EXIT; } pIntPtr = (TIMM_OSAL_U32 *)pData; pIntPtr--; total_alloc_size = *pIntPtr--; if((*pIntPtr & MEM_CORRUPT_MASK) != MEM_CORRUPT_CHECK_VAL) { TIMM_OSAL_Error("TIMM_OSAL_Free called with Corrupted pointer"); goto EXIT; } bytes_to_skip = (*pIntPtr & MEM_SIZE_MASK); pIntPtr--; TIMM_OSAL_Memcpy(&hHeap, pIntPtr, sizeof(TIMM_OSAL_U32)); pIntPtr--; pData = pIntPtr - bytes_to_skip/sizeof(TIMM_OSAL_U32); Memory_free(hHeap, pData, total_alloc_size); /* Memory free was successfull */ gMallocCounter--; gSizeCounter -= total_alloc_size; EXIT: return; }
static OMX_ERRORTYPE PrearrageEmptyThisBuffer(OMX_HANDLETYPE hComponent, OMX_BUFFERHEADERTYPE * pBufferHdr) { LOGV("Inside PrearrageEmptyThisBuffer"); OMX_ERRORTYPE eError = OMX_ErrorNone; PROXY_COMPONENT_PRIVATE *pCompPrv = NULL; OMX_COMPONENTTYPE *hComp = (OMX_COMPONENTTYPE *) hComponent; OMX_U8* pBuffer = NULL; OMX_U8* pData = NULL; OMX_U32 nValue = 0; OMX_U32 nWidth = 0; OMX_U32 nHeight = 0; OMX_U32 nActualCompression = 0; OMX_U8* pCSD = NULL; OMX_U32 nSize_CSD = 0; PROXY_assert(pBufferHdr != NULL, OMX_ErrorBadParameter, NULL); if (pBufferHdr->nFlags & OMX_BUFFERFLAG_CODECCONFIG){ PROXY_assert(hComp->pComponentPrivate != NULL, OMX_ErrorBadParameter, NULL); pCompPrv = (PROXY_COMPONENT_PRIVATE *) hComp->pComponentPrivate; pBuffer = pBufferHdr->pBuffer; VIDDEC_WMV_RCV_header hBufferRCV; VIDDEC_WMV_VC1_header hBufferVC1; LOGV("nFlags: %x", pBufferHdr->nFlags); pData = pBufferHdr->pBuffer + 15; /*Position to Width & Height*/ VIDDEC_LoadDWORD(nValue, pData); nWidth = nValue; VIDDEC_LoadDWORD(nValue, pData); nHeight = nValue; pData += 4; /*Position to compression type*/ VIDDEC_LoadDWORD(nValue, pData); nActualCompression = nValue; /*Seting pCSD to proper position*/ pCSD = pBufferHdr->pBuffer; pCSD += CSD_POSITION; nSize_CSD = pBufferHdr->nFilledLen - CSD_POSITION; if(nActualCompression == FOURCC_WMV3){ hBufferRCV.sStructRCV = (VIDDEC_WMV_RCV_struct *) TIMM_OSAL_Malloc(sizeof(VIDDEC_WMV_RCV_struct), TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); PROXY_assert(hBufferRCV.sStructRCV != NULL, OMX_ErrorInsufficientResources, "Malloc failed"); //From VC-1 spec: Table 265: Sequence Layer Data Structure hBufferRCV.sStructRCV->nNumFrames = 0xFFFFFF; /*Infinite frame number*/ hBufferRCV.sStructRCV->nFrameType = 0xc5; /*0x85 is the value given by ASF to rcv converter*/ hBufferRCV.sStructRCV->nID = 0x04; /*WMV3*/ hBufferRCV.sStructRCV->nStructData = 0x018a3106; /*0x06318a01zero fill 0x018a3106*/ hBufferRCV.sStructRCV->nVertSize = nHeight; hBufferRCV.sStructRCV->nHorizSize = nWidth; hBufferRCV.sStructRCV->nID2 = 0x0c; /* Fix value */ hBufferRCV.sStructRCV->nSequenceHdr = 0x00002a9f; /* This value is not provided by parser, so giving a value from a video*/ LOGV("initial: nStructData: %x", hBufferRCV.sStructRCV->nStructData); LOGV("pCSD = %x", (OMX_U32)*pCSD); hBufferRCV.sStructRCV->nStructData = (OMX_U32)pCSD[0] << 0 | pCSD[1] << 8 | pCSD[2] << 16 | pCSD[3] << 24; LOGV("FINAL: nStructData: %x", hBufferRCV.sStructRCV->nStructData); //Copy RCV structure to actual buffer assert(pBufferHdr->nFilledLen < pBufferHdr->nAllocLen); pBufferHdr->nFilledLen = sizeof(VIDDEC_WMV_RCV_struct); TIMM_OSAL_Memcpy(pBufferHdr->pBuffer, (OMX_U8*)hBufferRCV.pBuffer, pBufferHdr->nFilledLen); //Free aloocated memory TIMM_OSAL_Free(hBufferRCV.sStructRCV); } else if (nActualCompression == FOURCC_WVC1){ LOGV("VC-1 Advance Profile prearrange"); OMX_U8* pTempBuf = (OMX_U8 *) TIMM_OSAL_Malloc(pBufferHdr->nFilledLen, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_INT); PROXY_assert(pTempBuf != NULL, OMX_ErrorInsufficientResources, "Malloc failed"); TIMM_OSAL_Memcpy(pTempBuf, pBufferHdr->pBuffer+52, pBufferHdr->nFilledLen-52); TIMM_OSAL_Memcpy(pBufferHdr->pBuffer, pTempBuf, pBufferHdr->nFilledLen-52); pBufferHdr->nFilledLen -= 52; TIMM_OSAL_Free(pTempBuf); } } EXIT: LOGV("Redirection from PrearrageEmptyThisBuffer to PROXY_EmptyThisBuffer, nFilledLen=%d, nAllocLen=%d", pBufferHdr->nFilledLen, pBufferHdr->nAllocLen); return PROXY_EmptyThisBuffer(hComponent, pBufferHdr); }