Ejemplo n.º 1
0
/* ========================================================================== */
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;
	}
Ejemplo n.º 4
0
/* ========================================================================== */
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;
	}
Ejemplo n.º 8
0
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);
}