domx: create subdir for domx to merge into omap4-next

3 files changed, 1415 insertions, 0 deletions

diff --git a/domx/test/Makefile b/domx/test/Makefile
new file mode 100644
index 0000000..78c6f31
--- /dev/null
+++ b/domx/test/Makefile
@@ -0,0 +1,95 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  
+#        http://www.apache.org/licenses/LICENSE-2.0
+#  
+#   Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = 
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = 
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = 
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = 
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = sample_proxy \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+
+
+
+
+# Search path for include files
+
+INCLUDES    = 
+
+# Libraries needed for linking.
+
+#ST_LIBS        = omx_core omx_proxy_component mmplatform mm_osal domx 
+#SH_LIBS        = pthread rt utils procmgr ipc rcm notify
+#SH_LIBS        += sysmgr sysmemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/target/lib 
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
diff --git a/domx/test/sample_proxy/Makefile b/domx/test/sample_proxy/Makefile
new file mode 100644
index 0000000..02a3619
--- /dev/null
+++ b/domx/test/sample_proxy/Makefile
@@ -0,0 +1,98 @@
+#  
+#  Copyright (C) Texas Instruments - http://www.ti.com/
+#  
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#  
+#        http://www.apache.org/licenses/LICENSE-2.0
+#  
+#   Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#  
+#  ----------------------------------------------------------------------------
+#  Revision History
+#
+#
+#      REF=ORG
+#      Original version.
+#  ----------------------------------------------------------------------------
+
+
+
+include $(PROJROOT)/make/start.mk
+
+# Do not change above "include" line(s)
+
+# Arguments to tools, will move to make system once finalized.
+
+CFLAGS         = 
+CDEFS          = 
+ifeq ($(BUILD),udeb)
+CDEFS          += DEBUG 
+endif
+CDEFS          +=
+
+EXEC_ARGS      = 
+ST_LIB_ARGS    = 
+SH_LIB_ARGS    = 
+
+# Define this macro if target runs in kernel mode
+#__KERNEL__ = 1
+
+# Target name and extension
+# static library        (ST_LIB): filename.a
+# shared library soname (SH_LIB): filename.so.maj_ver.min_ver
+# executable            (EXEC)  : filename.out
+
+TARGETNAME  = sampletest
+
+
+# TARGETTYPE must be EXEC, ST_LIB or SH_LIB in upper case.
+
+TARGETTYPE  = EXEC
+
+# install directory relative to the HOSTTARGET directory
+HOSTRELEASE = binaries
+
+# install directory relative to the root filesystem
+ROOTFSRELEASE = binaries
+
+# Folders in which gmake will run before building current target
+
+SUBMODULES  = \
+
+# Filename must not begin with '.', '/' or '\'
+
+SOURCES     = \
+test_sample_proxy.c
+
+
+
+# Search path for include files
+
+INCLUDES    = \
+    $(PROJROOT)/omx_core/inc \
+    $(PROJROOT)/mm_osal/inc \
+    $(MEMMGRROOT)
+
+# Libraries needed for linking.
+
+ST_LIBS        =
+#omx_core omx_proxy_component domx mm_osal
+SH_LIBS        = pthread dl omx_core OMX.TI.DUCATI1.MISC.SAMPLE domx mm_osal timemmgr
+
+
+# Search path for library (and linker command) files.
+# Current folder and target folder are included by default.
+
+LIBINCLUDES = $(PROJROOT)/target/lib 
+
+
+# Do not change below "include" line(s)
+
+include $(PROJROOT)/make/build.mk
+
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");
+	}
+}
+