diff options
Diffstat (limited to 'domx/test/sample_proxy/test_sample_proxy.c')
| -rwxr-xr-x | domx/test/sample_proxy/test_sample_proxy.c | 1222 |
1 files changed, 1222 insertions, 0 deletions
diff --git a/domx/test/sample_proxy/test_sample_proxy.c b/domx/test/sample_proxy/test_sample_proxy.c new file mode 100755 index 0000000..59830a9 --- /dev/null +++ b/domx/test/sample_proxy/test_sample_proxy.c @@ -0,0 +1,1222 @@ +/* + * 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"); + } +} + |