/*
* Copyright (c) 2010, Texas Instruments Incorporated
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of Texas Instruments Incorporated nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define COMPONENT_NAME "OMX.TI.DUCATI1.MISC.SAMPLE" // needs to be specific for every configuration wrapper
#define OMX_SAMPLE_USEBUF OMX_TRUE
/****************************************************************
* INCLUDE FILES
****************************************************************/
/* ----- system and platform files ----------------------------*/
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
/*-------program files ----------------------------------------*/
#include <OMX_Core.h>
#include <OMX_Component.h>
#include "timm_osal_interfaces.h"
#define OMX_SAMPLE_TILER_TEST
#ifdef OMX_SAMPLE_TILER_TEST
#include "memmgr.h"
#endif
#define OMX_SAMPLE_INPUT_PORT 0
#define OMX_SAMPLE_OUTPUT_PORT 1
#ifdef OMX_SAMPLE_TILER_TEST
#define OMX_SAMPLE_IN_2DYHEIGHT 4
#define OMX_SAMPLE_IN_2DYWIDTH 8
#define OMX_SAMPLE_IN_2DUVHEIGHT 2
#define OMX_SAMPLE_IN_2DUVWIDTH 4
/*
#define STRIDE_8BIT (16 * 1024)
#define STRIDE_16BIT (32 * 1024)
*/
#define OMX_SAMPLE_IN_HEIGHT 6
#define OMX_SAMPLE_IN_WIDTH 8
#define STRIDE_LINUX (4 * 1024)
#define OMX_SAMPLE_BUFFER_SIZE 48
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);
}
}
#endif
/****************************************************************
* EXTERNAL REFERENCES NOTE : only use if not found in header file
****************************************************************/
/*--------data declarations -----------------------------------*/
/*--------function prototypes ---------------------------------*/
/****************************************************************
* PRIVATE DECLARATIONS Defined and used only here
****************************************************************/
/*--------function declarations -------------------------------*/
/*--------data declarations -----------------------------------*/
#define NUM_DOMAINS 0x4
#define OMX_NOPORT 0xfffffffe
//#define INPUT_FILE "../../omx/omx_il_1_x/omx_base/test/patterns/chikita.mp3"
#define INPUT_FILE "sample_input.mp3"
#define NON_TUN_OUTPUT_FILE "nt_output.mp3"
static int gTest = 1;
#define TIMM_OSAL_MallocaBuffer(_size, bContigous, nBlockAlignment) \
TIMM_OSAL_Malloc (_size, TIMM_OSAL_TRUE, 0, TIMMOSAL_MEM_SEGMENT_EXT)
#define OMX_TEST_BUFFERS_OF_TRAFFIC 20
#define OMX_TEST_BAIL_IF_ERROR(_eError) \
if(OMX_ErrorNone != (eError = _eError)){ \
goto OMX_TEST_BAIL; \
}
#define OMX_TEST_SET_ERROR_BAIL(_eCode, _desc) \
{ \
eError = _eCode; \
printf(_desc);\
goto OMX_TEST_BAIL; \
}
#define OMX_TEST_INIT_STRUCT(_s_, _name_) \
memset(&(_s_), 0x0, sizeof(_name_)); \
(_s_).nSize = sizeof(_name_); \
(_s_).nVersion.s.nVersionMajor = 0x1; \
(_s_).nVersion.s.nVersionMinor = 0x1; \
(_s_).nVersion.s.nRevision = 0x0; \
(_s_).nVersion.s.nStep = 0x0
#define BUFFER_LIST_CLEAR_ENTRY(_pL, _pB)\
_pB = _pL->pBufHdr; \
_pL->pBufHdr = NULL; \
_pL = _pL->pNextBuf;
#define BUFFER_LIST_SET_ENTRY(_pL, _pB) \
{ \
BufferList *_pT = _pL; \
while(_pT && _pT->pBufHdr){ \
_pT = _pT->pNextBuf; \
} \
if(_pT) \
_pT->pBufHdr = _pB; \
}
#define BUFFERLIST_CLEAR_ENTRY(_pL, _pB)\
_pB = _pL->pBufHdr; \
_pL->pBufHdr = NULL; \
_pL = _pL->pNextBuf;
typedef struct _BufferList BufferList;
struct _BufferList
{
OMX_BUFFERHEADERTYPE *pBufHdr;
OMX_BUFFERHEADERTYPE *pOrigBufHdr;
BufferList *pNextBuf;
};
typedef struct SampleCompTestCtxt
{
OMX_HANDLETYPE hComp;
OMX_STATETYPE eState;
OMX_U32 nPorts;
OMX_HANDLETYPE hStateSetEvent;
OMX_HANDLETYPE hPortDisableEvent;
OMX_HANDLETYPE hPortEnableEvent;
OMX_STRING inFilePath;
OMX_STRING outFilePath;
FILE *pOutputFile;
FILE *pInputfile;
OMX_BOOL bEOS;
BufferList *pInBufferList;
BufferList *pOutBufferList;
OMX_BOOL bClientAllocBuf;
OMX_U32 nBufDoneCalls;
OMX_PORT_PARAM_TYPE sPortParam[NUM_DOMAINS];
} SampleCompTestCtxt;
//this test compiles only for ducati SYS
typedef struct TestCtxt
{
OMX_HANDLETYPE hComp;
OMX_STATETYPE eState;
OMX_U32 nPorts;
OMX_HANDLETYPE hStateSetEvent;
OMX_HANDLETYPE hPortDisableEvent;
OMX_HANDLETYPE hPortEnableEvent;
OMX_STRING inFilePath;
OMX_STRING outFilePath;
FILE *pOutputFile;
FILE *pInputfile;
OMX_BOOL bEOS;
BufferList *pInBufferList;
BufferList *pOutBufferList;
OMX_BOOL bClientAllocBuf;
OMX_U32 nBufDoneCalls;
//OMX_PORT_PARAM_TYPE sPortParam[NUM_DOMAINS];
} TestCtxt;
static OMX_U32 nInBufCount = 0;
static OMX_U32 nOutBufCount = 0;
//Semaphore_Handle EBDSem;
//Semaphore_Params EBDsemParams;
//Semaphore_Handle FBDSem;
//Semaphore_Params FBDsemParams;
/*========================================================*/
/* @ fn OMX_TEST_ErrorToString :: ERROR to STRING */
/*========================================================*/
OMX_STRING OMX_TEST_ErrorToString(OMX_ERRORTYPE eError)
{
OMX_STRING errorString;
switch (eError)
{
case OMX_ErrorNone:
errorString = "ErrorNone";
break;
case OMX_ErrorInsufficientResources:
errorString = "ErrorInsufficientResources";
break;
case OMX_ErrorUndefined:
errorString = "ErrorUndefined";
break;
case OMX_ErrorInvalidComponentName:
errorString = "ErrorInvalidComponentName";
break;
case OMX_ErrorComponentNotFound:
errorString = "ErrorComponentNotFound";
break;
case OMX_ErrorInvalidComponent:
errorString = "ErrorInvalidComponent";
break;
case OMX_ErrorBadParameter:
errorString = "ErrorBadParameter";
break;
case OMX_ErrorNotImplemented:
errorString = "ErrorNotImplemented";
break;
case OMX_ErrorUnderflow:
errorString = "ErrorUnderflow";
break;
case OMX_ErrorOverflow:
errorString = "ErrorOverflow";
break;
case OMX_ErrorHardware:
errorString = "ErrorHardware";
break;
case OMX_ErrorInvalidState:
errorString = "ErrorInvalidState";
break;
case OMX_ErrorStreamCorrupt:
errorString = "ErrorStreamCorrupt";
break;
case OMX_ErrorPortsNotCompatible:
errorString = "ErrorPortsNotCompatible";
break;
case OMX_ErrorResourcesLost:
errorString = "ErrorResourcesLost";
break;
case OMX_ErrorNoMore:
errorString = "ErrorNoMore";
break;
case OMX_ErrorVersionMismatch:
errorString = "ErrorVersionMismatch";
break;
case OMX_ErrorNotReady:
errorString = "ErrorNotReady";
break;
case OMX_ErrorTimeout:
errorString = "ErrorTimeout";
break;
case OMX_ErrorSameState:
errorString = "ErrorSameState";
break;
case OMX_ErrorResourcesPreempted:
errorString = "ErrorResourcesPreempted";
break;
case OMX_ErrorPortUnresponsiveDuringAllocation:
errorString = "ErrorPortUnresponsiveDuringAllocation";
break;
case OMX_ErrorPortUnresponsiveDuringDeallocation:
errorString = "ErrorPortUnresponsiveDuringDeallocation";
break;
case OMX_ErrorPortUnresponsiveDuringStop:
errorString = "ErrorPortUnresponsiveDuringStop";
break;
case OMX_ErrorIncorrectStateTransition:
errorString = "ErrorIncorrectStateTransition";
break;
case OMX_ErrorIncorrectStateOperation:
errorString = "ErrorIncorrectStateOperation";
break;
case OMX_ErrorUnsupportedSetting:
errorString = "ErrorUnsupportedSetting";
break;
case OMX_ErrorUnsupportedIndex:
errorString = "ErrorUnsupportedIndex";
break;
case OMX_ErrorBadPortIndex:
errorString = "ErrorBadPortIndex";
break;
case OMX_ErrorPortUnpopulated:
errorString = "ErrorPortUnpopulated";
break;
case OMX_ErrorComponentSuspended:
errorString = "ErrorComponentSuspended";
break;
case OMX_ErrorDynamicResourcesUnavailable:
errorString = "ErrorDynamicResourcesUnavailable";
break;
case OMX_ErrorMbErrorsInFrame:
errorString = "ErrorMbErrorsInFrame";
break;
case OMX_ErrorFormatNotDetected:
errorString = "ErrorFormatNotDetected";
break;
case OMX_ErrorContentPipeOpenFailed:
errorString = "ErrorContentPipeOpenFailed";
break;
case OMX_ErrorContentPipeCreationFailed:
errorString = "ErrorContentPipeCreationFailed";
break;
case OMX_ErrorSeperateTablesUsed:
errorString = "ErrorSeperateTablesUsed";
break;
case OMX_ErrorTunnelingUnsupported:
errorString = "ErrorTunnelingUnsupported";
break;
default:
errorString = "<unknown>";
break;
}
return errorString;
}
/*========================================================*/
/* @ fn OMX_TEST_StateToString :: STATE to STRING */
/*========================================================*/
OMX_STRING OMX_TEST_StateToString(OMX_STATETYPE eState)
{
OMX_STRING StateString;
switch (eState)
{
case OMX_StateInvalid:
StateString = "Invalid";
break;
case OMX_StateLoaded:
StateString = "Loaded";
break;
case OMX_StateIdle:
StateString = "Idle";
break;
case OMX_StateExecuting:
StateString = "Executing";
break;
case OMX_StatePause:
StateString = "Pause";
break;
case OMX_StateWaitForResources:
StateString = "WaitForResources ";
break;
default:
StateString = "<unknown>";
break;
}
return StateString;
}
/* Application callback Functions */
/*========================================================*/
/* @ fn SampleTest_EventHandler :: Application callback */
/*========================================================*/
OMX_ERRORTYPE SampleTest_EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData,
OMX_IN OMX_EVENTTYPE eEvent,
OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2, OMX_IN OMX_PTR pEventData)
{
SampleCompTestCtxt *pContext;
printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
if (pAppData == NULL)
return OMX_ErrorNone;
pContext = (SampleCompTestCtxt *) pAppData;
switch (eEvent)
{
case OMX_EventCmdComplete:
printf("\n OMX_EventCmdComplete case: \n");
if (OMX_CommandStateSet == nData1)
{
printf(" Component Transitioned to %s state \n",
OMX_TEST_StateToString((OMX_STATETYPE) nData2));
pContext->eState = (OMX_STATETYPE) nData2;
TIMM_OSAL_SemaphoreRelease(pContext->hStateSetEvent);
} else if (OMX_CommandFlush == nData1)
{
/* Nothing to do over here */
} else if (OMX_CommandPortDisable == nData1)
{
/* Nothing to do over here */
TIMM_OSAL_SemaphoreRelease(pContext->
hPortDisableEvent);
} else if (OMX_CommandPortEnable == nData1)
{
/* Nothing to do over here */
} else if (OMX_CommandMarkBuffer == nData1)
{
/* Nothing to do over here */
}
break;
case OMX_EventError:
printf("\nOMX EVENT ERROR!!!!!! \n");
break;
case OMX_EventMark:
break;
case OMX_EventPortSettingsChanged:
break;
case OMX_EventBufferFlag:
break;
case OMX_EventResourcesAcquired:
break;
case OMX_EventComponentResumed:
break;
case OMX_EventDynamicResourcesAvailable:
break;
case OMX_EventPortFormatDetected:
break;
default:
break;
}
goto OMX_TEST_BAIL;
OMX_TEST_BAIL:
return OMX_ErrorNone;
}
/*========================================================*/
/* @ fn SampleTest_EmptyBufferDone :: Application callback */
/*========================================================*/
OMX_ERRORTYPE SampleTest_EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)
{
SampleCompTestCtxt *pContext;
printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
if (pAppData == NULL)
return OMX_ErrorNone;
pContext = (SampleCompTestCtxt *) pAppData;
pContext->nBufDoneCalls++;
BUFFER_LIST_SET_ENTRY(pContext->pInBufferList, pBuffer);
//Semaphore_post(EBDSem);
goto OMX_TEST_BAIL;
OMX_TEST_BAIL:
printf("\nEBD done\n");
return OMX_ErrorNone;
}
/*========================================================*/
/* @ fn SampleTest_FillBufferDone :: Application callback */
/*========================================================*/
OMX_ERRORTYPE SampleTest_FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
OMX_IN OMX_PTR pAppData, OMX_IN OMX_BUFFERHEADERTYPE * pBuffHeader)
{
SampleCompTestCtxt *pContext;
printf("\n___________ ENTERED CLIENT CALLBACK:%s", __FUNCTION__);
if (pAppData == NULL)
return OMX_ErrorNone;
pContext = (SampleCompTestCtxt *) pAppData;
pContext->nBufDoneCalls++;
if (pContext->pOutputFile && gTest)
{
printf(" writing to output file :: buffer cnt : %d\n",
nOutBufCount);
nOutBufCount++;
fwrite(pBuffHeader->pBuffer, 1, pBuffHeader->nFilledLen,
pContext->pOutputFile);
}
BUFFER_LIST_SET_ENTRY(pContext->pOutBufferList, pBuffHeader);
//Semaphore_post(FBDSem);
goto OMX_TEST_BAIL;
OMX_TEST_BAIL:
printf("\nFBD done\n");
return OMX_ErrorNone;
}
static void SampleTest_ReadInputFile(SampleCompTestCtxt * pContext,
OMX_PTR pData, OMX_U32 nBytes, FILE * fp)
{
OMX_U32 nReadSize = 0;
printf("\nIn read i/p file\n");
if (pData == NULL)
printf("\npData is NULL\n");
else
printf("\npData = %x\n", pData);
printf("\nnBytes = %d\n", nBytes);
if (fp == NULL)
printf("\nfp is NULL\n");
else
printf("\nfp = %x\n", fp);
nReadSize = fread(pData, 1, nBytes, fp);
if (nReadSize != nBytes)
{
pContext->bEOS = OMX_TRUE;
}
printf(" Reading from file :: Buffer cont : %d \n", nInBufCount);
nInBufCount++;
}
/*========================================================*/
/* @ fn SampleTest_WriteInBuffers :: Reads a buffer from a file and send to Comp */
/*========================================================*/
OMX_ERRORTYPE SampleTest_WriteInBuffers(SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
BufferList *pList;
OMX_BUFFERHEADERTYPE *pBufHeader;
#ifdef OMX_SAMPLE_TILER_TEST
OMX_U8 *pTmpBuffer = NULL, *pOrigTmpBuffer = NULL;
#endif
pList = pContext->pInBufferList;
while (pList && pList->pBufHdr)
{
BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
printf("\nAbout to read from input file\n");
#if defined(OMX_SAMPLE_TILER_TEST)
//OMX_SAMPLE_BUFFER_SIZE is the total amt of data to be sent in the buffer
pTmpBuffer =
TIMM_OSAL_Malloc(OMX_SAMPLE_BUFFER_SIZE, 0, 0, 0);
if (pTmpBuffer == NULL)
OMX_TEST_SET_ERROR_BAIL
(OMX_ErrorInsufficientResources,
"malloc failed \n");
pOrigTmpBuffer = pTmpBuffer;
SampleTest_ReadInputFile(pContext, pTmpBuffer,
OMX_SAMPLE_BUFFER_SIZE, pContext->pInputfile);
Test_Util_Memcpy_1Dto2D(pBufHeader->pBuffer, pTmpBuffer,
OMX_SAMPLE_BUFFER_SIZE, OMX_SAMPLE_IN_HEIGHT,
OMX_SAMPLE_IN_WIDTH, STRIDE_LINUX);
pBufHeader->nFilledLen = OMX_SAMPLE_BUFFER_SIZE;
printf("\nBefore ETB pBufHeader->nInputPortIndex = %d\n",
pBufHeader->nInputPortIndex);
TIMM_OSAL_Free(pOrigTmpBuffer);
#else
SampleTest_ReadInputFile(pContext, pBufHeader->pBuffer,
pBufHeader->nAllocLen, pContext->pInputfile);
pBufHeader->nFilledLen = pBufHeader->nAllocLen;
#endif
if (pContext->bEOS == OMX_TRUE)
{
pBufHeader->nFlags |= OMX_BUFFERFLAG_EOS;
}
eError = OMX_EmptyThisBuffer(pContext->hComp, pBufHeader);
OMX_TEST_BAIL_IF_ERROR(eError);
}
OMX_TEST_BAIL:
return eError;
}
/*========================================================*/
/* @ fn SampleTest_ReadOutBuffers :: Send out buffers */
/*========================================================*/
OMX_ERRORTYPE SampleTest_ReadOutBuffers(SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
BufferList *pList;
OMX_BUFFERHEADERTYPE *pBufHeader;
pList = pContext->pOutBufferList;
while (pList && pList->pBufHdr)
{
printf("\nAbout to do FTB\n");
BUFFERLIST_CLEAR_ENTRY(pList, pBufHeader);
eError = OMX_FillThisBuffer(pContext->hComp, pBufHeader);
OMX_TEST_BAIL_IF_ERROR(eError);
if (pBufHeader->nFlags == OMX_BUFFERFLAG_EOS)
{
pContext->nBufDoneCalls = OMX_TEST_BUFFERS_OF_TRAFFIC;
}
}
OMX_TEST_BAIL:
return eError;
}
/*========================================================*/
/* @ fn SampleTest_AllocateBuffers :: Allocates the Resources on the available ports */
/*========================================================*/
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;
}
/*========================================================*/
/* @ fn SampleTest_DeInitBuffers :: Destroy the resources */
/*========================================================*/
OMX_ERRORTYPE SampleTest_DeInitBuffers(SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_U8 *pBuffer;
BufferList *pBufferList;
BufferList *pTemp;
OMX_U32 nRetVal = 0;
pTemp = pContext->pInBufferList;
while (pTemp)
{
pBufferList = (BufferList *) pTemp;
pBuffer = (OMX_U8 *) pTemp->pOrigBufHdr->pBuffer;
printf("\nCalling Free Buffer on port no. %d\n",
pTemp->pOrigBufHdr->nInputPortIndex);
eError =
OMX_FreeBuffer(pContext->hComp,
pTemp->pOrigBufHdr->nInputPortIndex, pTemp->pOrigBufHdr);
OMX_TEST_BAIL_IF_ERROR(eError);
if (pContext->bClientAllocBuf)
{
#ifdef OMX_SAMPLE_TILER_TEST
nRetVal = MemMgr_Free(pBuffer);
if (nRetVal)
{
printf("\nError in MemMgr free\n");
}
#else
TIMM_OSAL_Free(pBuffer);
#endif
}
pTemp = pTemp->pNextBuf;
if (pBufferList)
TIMM_OSAL_Free(pBufferList);
}
pContext->pInBufferList = NULL;
pTemp = pContext->pOutBufferList;
while (pTemp)
{
pBufferList = (BufferList *) pTemp;
pBuffer = (OMX_U8 *) pTemp->pOrigBufHdr->pBuffer;
printf("\nCalling Free Buffer on port no. %d\n",
pTemp->pOrigBufHdr->nOutputPortIndex);
eError =
OMX_FreeBuffer(pContext->hComp,
pTemp->pOrigBufHdr->nOutputPortIndex, pTemp->pOrigBufHdr);
OMX_TEST_BAIL_IF_ERROR(eError);
if (pContext->bClientAllocBuf)
{
#ifdef OMX_SAMPLE_TILER_TEST
nRetVal = MemMgr_Free(pBuffer);
if (nRetVal)
{
printf("\nError in MemMgr free\n");
}
#else
TIMM_OSAL_Free(pBuffer);
#endif
}
pTemp = pTemp->pNextBuf;
if (pBufferList)
TIMM_OSAL_Free(pBufferList);
}
pContext->pOutBufferList = NULL;
OMX_TEST_BAIL:
return eError;
}
/*========================================================*/
/* @ fn SampleTest_TransitionWait :: Waits for the transition to be completed ,
* incase of loaded to idle Allocates the Resources and while idle to loaded
* destroys the resources */
/*========================================================*/
OMX_ERRORTYPE SampleTest_TransitionWait(OMX_STATETYPE eToState,
SampleCompTestCtxt * pContext)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_PARAM_PORTDEFINITIONTYPE tPortDef;
OMX_U32 i, j;
eError = OMX_SendCommand(pContext->hComp, OMX_CommandStateSet,
eToState, NULL);
OMX_TEST_BAIL_IF_ERROR(eError);
if ((eToState == OMX_StateIdle) &&
(pContext->eState == OMX_StateLoaded))
{
for (i = 0; i < NUM_DOMAINS; i++)
{
for (j = pContext->sPortParam[i].nStartPortNumber;
j < pContext->sPortParam[i].nStartPortNumber
+ pContext->sPortParam[i].nPorts; j++)
{
OMX_TEST_INIT_STRUCT(tPortDef,
OMX_PARAM_PORTDEFINITIONTYPE);
tPortDef.nPortIndex = j;
//printf("\nCalling GetParam before UseBuf on port %d\n",j);
eError = OMX_GetParameter(pContext->hComp,
OMX_IndexParamPortDefinition,
(OMX_PTR) & tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
// if(tPortDef.bEnabled)//AD
eError =
SampleTest_AllocateBuffers(pContext,
&tPortDef);
OMX_TEST_BAIL_IF_ERROR(eError);
}
}
} else if ((eToState == OMX_StateLoaded) &&
(pContext->eState == OMX_StateIdle))
{
eError = SampleTest_DeInitBuffers(pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
}
printf("\nWaiting for state set event\n");
TIMM_OSAL_SemaphoreObtain(pContext->hStateSetEvent,
TIMM_OSAL_SUSPEND);
printf("\nState set event recd.\n");
if (pContext->eState != eToState)
OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
" InComplete Transition \n");
OMX_TEST_BAIL:
return eError;
}
/*========================================================*/
/* @ fn OMX_Sample_UT0001 :: Initializes, move to Idle and then to executing, process
* buffers and then destroy the component by moving back to idle, loaded, invalid */
/*========================================================*/
void main(void)
{
OMX_ERRORTYPE eError = OMX_ErrorNone;
OMX_HANDLETYPE hComp = NULL;
OMX_CALLBACKTYPE oCallbacks;
SampleCompTestCtxt *pContext;
SampleCompTestCtxt oAppData;
int ch1, ch2;
int pass;
int while_pass = 0, loc_diff = 0;
pContext = &oAppData;
printf(" Entering : %s \n", __FUNCTION__);
memset(pContext, 0x0, sizeof(SampleCompTestCtxt));
oCallbacks.EventHandler = SampleTest_EventHandler;
oCallbacks.EmptyBufferDone = SampleTest_EmptyBufferDone;
oCallbacks.FillBufferDone = SampleTest_FillBufferDone;
printf("\nCalling sem create\n");
/* Initialize Events to Track callbacks */
TIMM_OSAL_SemaphoreCreate(&pContext->hStateSetEvent, 0);
TIMM_OSAL_SemaphoreCreate(&pContext->hPortDisableEvent, 0);
//TIMM_OSAL_MutexObtain(pContext->hStateSetEvent, TIMM_OSAL_SUSPEND);
printf("\nSem created\n");
pContext->pInputfile = fopen(INPUT_FILE, "rb");
if (NULL == pContext->pInputfile)
{
eError = OMX_ErrorInsufficientResources;
//goto OMX_TEST_BAIL;
}
printf("\nInput file opened\n");
pContext->pOutputFile = fopen(NON_TUN_OUTPUT_FILE, "wb");
if (NULL == pContext->pOutputFile)
{
eError = OMX_ErrorInsufficientResources;
//goto OMX_TEST_BAIL;
}
/* Initialize OpenMAX */
printf("\nInitialize OpenMAX\n");
eError = OMX_Init();
OMX_TEST_BAIL_IF_ERROR(eError);
/* Load a component */
printf("\nLoad a component\n");
eError =
OMX_GetHandle(&hComp, (OMX_STRING) "OMX.TI.DUCATI1.MISC.SAMPLE",
pContext, &oCallbacks);
OMX_TEST_BAIL_IF_ERROR(eError);
pContext->hComp = hComp;
printf ("\neError = 0x%x\n", eError);
if(hComp)
printf("\nhComp = 0x%x\n", hComp);
/* Verify that the component is in Loaded state */
printf("\nVerify that the component is in Loaded state\n");
eError = OMX_GetState(pContext->hComp, &pContext->eState);
OMX_TEST_BAIL_IF_ERROR(eError);
if (OMX_StateLoaded != pContext->eState)
{
OMX_TEST_SET_ERROR_BAIL(OMX_ErrorUndefined,
"not in loaded state \n");
}
/* detect all Audio ports on the component */
OMX_TEST_INIT_STRUCT(pContext->sPortParam[0], OMX_PORT_PARAM_TYPE);
eError = OMX_GetParameter(hComp, OMX_IndexParamAudioInit,
(OMX_PTR) & pContext->sPortParam[0]);
OMX_TEST_BAIL_IF_ERROR(eError);
/* detect all video ports on the component */
OMX_TEST_INIT_STRUCT(pContext->sPortParam[1], OMX_PORT_PARAM_TYPE);
eError = OMX_GetParameter(hComp, OMX_IndexParamVideoInit,
(OMX_PTR) & pContext->sPortParam[1]);
OMX_TEST_BAIL_IF_ERROR(eError);
/* detect all image ports on the component */
OMX_TEST_INIT_STRUCT(pContext->sPortParam[2], OMX_PORT_PARAM_TYPE);
eError = OMX_GetParameter(hComp, OMX_IndexParamImageInit,
(OMX_PTR) & pContext->sPortParam[2]);
OMX_TEST_BAIL_IF_ERROR(eError);
/* detect all other ports on the component */
OMX_TEST_INIT_STRUCT(pContext->sPortParam[3], OMX_PORT_PARAM_TYPE);
eError = OMX_GetParameter(hComp, OMX_IndexParamOtherInit,
(OMX_PTR) & pContext->sPortParam[3]);
OMX_TEST_BAIL_IF_ERROR(eError);
pContext->nPorts = pContext->sPortParam[0].nPorts +
pContext->sPortParam[1].nPorts +
pContext->sPortParam[2].nPorts + pContext->sPortParam[3].nPorts;
pContext->bClientAllocBuf = OMX_SAMPLE_USEBUF;
if (pContext->bClientAllocBuf == OMX_TRUE)
{
printf(" Client does Allocation of buffers \n");
} else
{
printf(" Component does Allocation of buffers \n");
}
/* Transition to Idle state */
eError = SampleTest_TransitionWait(OMX_StateIdle, pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
/* Transition to Executing state */
eError = SampleTest_TransitionWait(OMX_StateExecuting, pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
printf("\nAbout to start processing buffers\n");
/* process buffers */
while (pContext->nBufDoneCalls < OMX_TEST_BUFFERS_OF_TRAFFIC)
{
eError = SampleTest_WriteInBuffers(pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
eError = SampleTest_ReadOutBuffers(pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
while_pass++;
//printf("\n WHILE PROCESS LOOP COUNT: BufDoneCount = %d %d",
// while_pass, pContext->nBufDoneCalls);
//printf("\n Waiting on Sample component to respond");
}
gTest = 0;
/* Transition back to Idle state */
eError = SampleTest_TransitionWait(OMX_StateIdle, pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
/* Trasnition back to Loaded state */
eError = SampleTest_TransitionWait(OMX_StateLoaded, pContext);
OMX_TEST_BAIL_IF_ERROR(eError);
OMX_TEST_BAIL:
fclose(pContext->pInputfile);
fclose(pContext->pOutputFile);
if (eError == OMX_ErrorNone)
{
eError = OMX_FreeHandle(pContext->hComp);
eError = OMX_Deinit();
} else
{
SampleTest_TransitionWait(OMX_StateInvalid, pContext);
SampleTest_DeInitBuffers(pContext);
OMX_FreeHandle(pContext->hComp);
OMX_Deinit();
}
TIMM_OSAL_SemaphoreDelete(pContext->hStateSetEvent);
TIMM_OSAL_SemaphoreDelete(pContext->hPortDisableEvent);
/* emit the Test Result */
if (OMX_ErrorNone != eError)
{
printf(" TestCase Failed and returned an error:: %s \n",
OMX_TEST_ErrorToString(eError));
} else
{
printf
("\nTest case has ended, now comparing input and output files\n");
pContext->pInputfile = fopen(INPUT_FILE, "rb");
if (NULL == pContext->pInputfile)
{
printf("\n Error in opening INPUT_FILE");
eError = OMX_ErrorInsufficientResources;
}
pContext->pOutputFile = fopen(NON_TUN_OUTPUT_FILE, "rb");
if (NULL == pContext->pOutputFile)
{
printf("\n Error in opening NON_TUN_OUTPUT_FILE");
eError = OMX_ErrorInsufficientResources;
}
pass = 1;
while (1)
{
if (eError != OMX_ErrorNone)
{
pass = 0;
break;
}
ch1 = fgetc(pContext->pInputfile);
ch2 = fgetc(pContext->pOutputFile);
loc_diff++;
if (ch1 == EOF || ch2 == EOF)
{
break;
}
if (ch1 != ch2)
{
pass = 0;
printf("\n \n");
printf
("\n FILE SIZE = 320 KB - NUMBER OF ITERATIONS = 20 (10 for INPUT AND 10 FOR OUTPUT buffers\n");
printf
("\n ################### LOCATION OF DIFFERENCE: %d ################### \n",
loc_diff);
break;
}
}
fclose(pContext->pInputfile);
fclose(pContext->pOutputFile);
if (pass == 1)
printf(" Test Case has Passed\n");
else
{
printf("\nTest case has failed. (EOF not reached)\n");
eError = OMX_ErrorUndefined;
}
}
if (eError == OMX_ErrorNone)
{
printf(" Test Case has Passed :) \n");
} else
{
printf("\nTest case has failed.(OMX Error)\n");
}
}