diff -r 000000000000 -r 5d29cba61097 omxilvideocomps/omxilgraphicsink/tsrc/src/omxilgraphicsinktestbase.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxilvideocomps/omxilgraphicsink/tsrc/src/omxilgraphicsinktestbase.cpp	Fri Oct 08 22:09:17 2010 +0100
@@ -0,0 +1,1276 @@
+/*
+* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: 
+*
+*/
+
+
+/**
+ * @file
+ * @internalTechnology
+ */
+
+#include "omxilgraphicsinktestbase.h"
+#include <mmf/server/mmfbuffer.h>
+#include <mmf/server/mmfdatabuffer.h>
+
+CCallbackHandler*
+CCallbackHandler::NewL(COmxGsTestBase& aCameraSourceTest)
+	{
+	CCallbackHandler* self = new (ELeave) CCallbackHandler(aCameraSourceTest);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+void
+CCallbackHandler::ConstructL()
+	{
+	OMX_CALLBACKTYPE h =
+			{
+			CCallbackHandler::EventHandler,
+			CCallbackHandler::EmptyBufferDone,
+			CCallbackHandler::FillBufferDone
+			};
+
+	iHandle = h;
+	CActiveScheduler::Add(this);
+
+	User::LeaveIfError(iMsgQueue.CreateLocal(KMaxMsgQueueEntries));
+	iMsgQueue.NotifyDataAvailable(iStatus);
+	SetActive();
+	}
+
+CCallbackHandler::CCallbackHandler(COmxGsTestBase& aCameraSourceTest)
+	: CActive(EPriorityStandard),
+	  iCameraSourceTest(aCameraSourceTest)
+	{
+	}
+
+
+CCallbackHandler::operator OMX_CALLBACKTYPE*()
+	{
+	return &iHandle;
+	}
+
+
+void
+CCallbackHandler::RunL()
+	{
+	TOmxMessage msg;
+	while (iMsgQueue.Receive(msg)==KErrNone)
+		{
+		switch (msg.iType)
+			{
+			case EEmptyBufferCallback:
+				{
+//				MOmxInputPortCallbacks* callback = msg.iBuffer->InputPortCallbacks();
+//				const CMMFBuffer* buffer = msg.iBuffer->MmfBuffer();
+//				callback->EmptyBufferDone(msg.iComponent, buffer);
+				iCameraSourceTest.DoEmptyBufferDone(msg.iComponent, static_cast<OMX_BUFFERHEADERTYPE*>(msg.iBuffer));
+				break;
+				}
+
+			case EFillBufferCallback:
+				{
+				//iCameraSourceTest.DoFillBufferDone(msg.iComponent,static_cast<CCameraBuffer*>(msg.iBuffer));
+				iCameraSourceTest.DoFillBufferDone(msg.iComponent, static_cast<OMX_BUFFERHEADERTYPE*>(msg.iBuffer));
+				break;
+				}
+			case EEventCallback:
+				{
+				iCameraSourceTest.DoEventHandler(msg.iComponent,
+											msg.iEventParams.iEvent,
+											msg.iEventParams.iData1,
+											msg.iEventParams.iData2,
+											msg.iEventParams.iExtra);
+				break;
+				}
+			default:
+				{
+				// This is an invalid state
+				ASSERT(EFalse);
+				}
+			}
+		}
+
+	// setup for next callbacks
+	iStatus = KRequestPending;
+	iMsgQueue.NotifyDataAvailable(iStatus);
+	SetActive();
+
+	}
+
+CCallbackHandler::~CCallbackHandler()
+	{
+	Cancel();
+	iMsgQueue.Close();
+	}
+
+
+void
+CCallbackHandler::DoCancel()
+	{
+	if (iMsgQueue.Handle())
+		{
+		iMsgQueue.CancelDataAvailable();
+		}
+	}
+
+OMX_ERRORTYPE
+CCallbackHandler::FillBufferDone(OMX_HANDLETYPE aComponent,
+									TAny* aAppData,
+									OMX_BUFFERHEADERTYPE* aBuffer)
+	{
+	ASSERT(aAppData);
+	//CCameraBuffer* pBuffer = static_cast<CCameraBuffer*>(aBuffer->pAppPrivate);
+	return static_cast<CCallbackHandler*>(aAppData)->DoFillBufferDone(aComponent, aBuffer);
+	}
+
+OMX_ERRORTYPE
+CCallbackHandler::EmptyBufferDone(OMX_HANDLETYPE aComponent,
+									 TAny* aAppData,
+									 OMX_BUFFERHEADERTYPE* aBuffer)
+	{
+	ASSERT(aAppData);
+	//CCameraBuffer* pBuffer = static_cast<CCameraBuffer*>(aBuffer->pAppPrivate);
+	return static_cast<CCallbackHandler*>(aAppData)->DoEmptyBufferDone(aComponent, aBuffer);
+
+	}
+
+OMX_ERRORTYPE
+CCallbackHandler::EventHandler(OMX_HANDLETYPE aComponent,
+								  TAny* aAppData,
+								  OMX_EVENTTYPE aEvent,
+								  TUint32 aData1,
+								  TUint32 aData2,
+								  TAny* aExtra)
+	{
+	ASSERT(aAppData);
+	CCallbackHandler::TEventParams eventParams;
+	eventParams.iEvent = aEvent;
+	eventParams.iData1 = aData1;
+	eventParams.iData2 = aData2;
+	eventParams.iExtra = aExtra;	
+	return static_cast<CCallbackHandler*>(aAppData)->DoEventHandler(aComponent, eventParams);
+	}
+
+OMX_ERRORTYPE CCallbackHandler::DoFillBufferDone(OMX_HANDLETYPE aComponent,
+								  OMX_BUFFERHEADERTYPE* aBufferHeader)
+	{
+	TOmxMessage message;
+	message.iType = EFillBufferCallback;
+	message.iComponent = aComponent;
+	message.iBuffer = static_cast <OMX_BUFFERHEADERTYPE*>(aBufferHeader);
+	TInt error = iMsgQueue.Send(message);
+	//RDebug::Printf("CCallbackHandler:: Error: %d",error);
+
+	return (error == KErrNone ? OMX_ErrorNone : OMX_ErrorUndefined);
+	}
+
+OMX_ERRORTYPE CCallbackHandler::DoEmptyBufferDone(OMX_HANDLETYPE aComponent,
+								   OMX_BUFFERHEADERTYPE* aBufferHeader)
+	{
+	TOmxMessage message;
+	message.iType = EEmptyBufferCallback;
+	message.iComponent = aComponent;
+	message.iBuffer = static_cast <OMX_BUFFERHEADERTYPE*> (aBufferHeader);
+	TInt error = iMsgQueue.Send(message);
+	//RDebug::Printf("CCallbackHandler:: Error: %d",error);
+
+	return (error == KErrNone ? OMX_ErrorNone : OMX_ErrorUndefined);
+	}
+
+
+OMX_ERRORTYPE CCallbackHandler::DoEventHandler(OMX_HANDLETYPE aComponent, TEventParams aEventParams)
+	{
+	TOmxMessage message;
+	message.iType = EEventCallback;
+	message.iComponent = aComponent;
+	message.iEventParams = aEventParams;
+
+	/*
+	OMX_EventCmdComplete,
+    OMX_EventError,
+    OMX_EventMark,
+    OMX_EventPortSettingsChanged,
+    OMX_EventBufferFlag,
+    OMX_EventResourcesAcquired,
+    OMX_EventComponentResumed,
+    OMX_EventDynamicResourcesAvailable,
+    OMX_EventPortFormatDetected,
+    OMX_EventMax = 0x7FFFFFFF
+	*/
+
+	// TO DO - Put in switch on OMX_EVENTTYPE iEvent and print out the event type and relevant error code in test logs
+	TInt error = iMsgQueue.Send(message);
+	//RDebug::Printf("CCallbackHandler:: Error: %d",error);
+
+	return (error == KErrNone ? OMX_ErrorNone : OMX_ErrorUndefined);
+	}
+
+//
+// COmxGsTestBase
+//
+
+// Device driver constants
+
+TVerdict COmxGsTestBase::doTestStepPreambleL()
+/**
+ * @return - TVerdict
+ * Implementation of CTestStep base class virtual
+ * It is used for doing all initialisation common to derived classes in here.
+ * Make it being able to leave if there are any errors here as there's no point in
+ * trying to run a test step if anything fails.
+ * The leave will be picked up by the framework.
+ */
+	{
+	// Here we check to see if there is already an active scheduler
+	// installed, as this function will receive multiple calls during
+	// Alloc testing of CS and GS components
+	__UHEAP_MARK;
+	if (!CActiveScheduler::Current())
+		{
+		iScheduler = new (ELeave) CActiveScheduler;
+		CActiveScheduler::Install(iScheduler);
+		}
+
+	// Make sure we are not running the Alloc tests, if we are
+	// then we will create these elsewhere.
+	if (TestStepName() != (_L("MMVIDEO-OMX-CS-004-HP")) &&
+		TestStepName() != (_L("MMVIDEO-OMX-GS-001-00-HP")) &&
+		TestStepName() != (_L("MMVIDEO-OMX-JP-001-00-HP")) &&
+		TestStepName() != (_L("MMVIDEO-OMX-FS-001-00-HP")) &&
+		TestStepName() != (_L("MMVIDEO-OMX-IW-001-00-HP")))
+		{
+		InitialiseOmxComponents();
+		if (TestStepResult() != EPass)
+			{
+			INFO_PRINTF1(_L("*** InitialiseOmxComponents() failed. No point running test case. ***"));
+
+			// If the preamble leaves then the postamble isn't called by TEF.
+			// We have to do it ourselves to ensure stuff is cleaned up.
+			TRAP_IGNORE(doTestStepPostambleL());
+			User::Leave(KErrGeneral);
+			}
+		}
+
+	return TestStepResult();
+	}
+
+TVerdict COmxGsTestBase::doTestStepPostambleL()
+/**
+ * @return - TVerdict
+ * Implementation of CTestStep base class virtual
+ * It is used for doing all after test treatment common to derived classes in here.
+ * Make it being able to leave
+ * The leave will be picked up by the framework.
+ */
+	{
+	CloseTestStep();
+
+	delete iScheduler;
+	__UHEAP_MARKEND;
+	return TestStepResult();
+	}
+
+COmxGsTestBase::~COmxGsTestBase()
+	{
+	}
+
+
+
+
+COmxGsTestBase::COmxGsTestBase() : iCamPrevState(OMX_StateInvalid),
+										iGphxPrevState(OMX_StateInvalid)
+	{
+	}
+
+
+void
+COmxGsTestBase::PrintOmxState(OMX_STATETYPE aOmxState)
+	{
+	switch(aOmxState)
+		{
+	    case OMX_StateInvalid:
+			{
+			INFO_PRINTF1(_L("OMX STATE : OMX_StateInvalid"));
+			}
+			break;
+	    case OMX_StateLoaded:
+			{
+			INFO_PRINTF1(_L("OMX STATE : OMX_StateLoaded"));
+			}
+			break;
+	    case OMX_StateIdle:
+			{
+			INFO_PRINTF1(_L("OMX STATE : OMX_StateIdle"));
+			}
+			break;
+	    case OMX_StateExecuting:
+			{
+			INFO_PRINTF1(_L("OMX STATE : OMX_StateExecuting"));
+			}
+			break;
+	    case OMX_StatePause:
+			{
+			INFO_PRINTF1(_L("OMX STATE : OMX_StatePause"));
+			}
+			break;
+	    case OMX_StateWaitForResources:
+			{
+			//INFO_PRINTF1(_L("OMX STATE : OMX_StateWaitForResources"));
+			}
+			break;
+		default:
+			{
+			//INFO_PRINTF1(_L("OMX STATE : Wrong state found"));
+			}
+		}
+	}
+
+TInt COmxGsTestBase::PrintOmxError(OMX_ERRORTYPE aOmxError)
+	{
+    switch(aOmxError)
+		{
+		case OMX_ErrorNone:
+			{
+			INFO_PRINTF1(_L("OMX ERROR : OMX_ErrorNone"));
+			return KErrNone;
+			}
+
+		case OMX_ErrorInsufficientResources:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorInsufficientResources"));
+			return KErrNoMemory; //KErrNotReady;
+			}
+
+		case OMX_ErrorUndefined:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorUndefined"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorInvalidComponentName:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorInvalidComponentName"));
+			return KErrBadName;
+			}
+
+		case OMX_ErrorComponentNotFound:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorComponentNotFound"));
+			return KErrNotFound;
+			}
+
+		case OMX_ErrorInvalidComponent:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorInvalidComponent"));
+			return KErrBadHandle;
+			}
+
+		case OMX_ErrorBadParameter:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorBadParameter"));
+			return KErrArgument;
+			}
+
+		case OMX_ErrorNotImplemented:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorNotImplemented"));
+			return KErrNotSupported;
+			}
+
+		case OMX_ErrorUnderflow:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorUnderflow"));
+			return KErrUnderflow;
+			}
+
+		case OMX_ErrorOverflow:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorOverflow"));
+			return KErrOverflow;
+			}
+
+		case OMX_ErrorHardware:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorHardware"));
+			return KErrUnknown;
+			}
+
+		case OMX_ErrorInvalidState:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorInvalidState"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorStreamCorrupt:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorStreamCorrupt"));
+			return KErrCorrupt;
+			}
+
+		case OMX_ErrorPortsNotCompatible:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorPortsNotCompatible"));
+			//ERR_PRINTF1(_L("Ports being connected are not compatible"));
+			return KErrUnknown;
+			}
+
+		case OMX_ErrorResourcesLost:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorResourcesLost"));
+			//ERR_PRINTF1(_L("Resources allocated to an idle component have been lost resulting in the component returning to the loaded state"));
+			return KErrNotReady;
+			}
+
+		case OMX_ErrorNoMore:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorNoMore"));
+			//ERR_PRINTF1(_L("No more indicies can be enumerated"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorVersionMismatch:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorVersionMismatch"));
+			//ERR_PRINTF1(_L("The component detected a version mismatch"));
+			return KErrArgument;
+			}
+
+		case OMX_ErrorNotReady:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorNotReady"));
+			//ERR_PRINTF1(_L("The component is not ready to return data at this time"));
+			return KErrNotReady;
+			}
+
+		case OMX_ErrorTimeout:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorTimeout"));
+			//ERR_PRINTF1(_L("There was a timeout that occurred"));
+			return KErrTimedOut;
+			}
+
+		case OMX_ErrorSameState:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorSameState"));
+			//ERR_PRINTF1(_L("This error occurs when trying to transition into the state you are already in"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorResourcesPreempted:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorResourcesPreempted"));
+			//ERR_PRINTF1(_L("Resources allocated to an executing or paused component have been preempted, causing the component to return to the idle state"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorPortUnresponsiveDuringAllocation:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorPortUnresponsiveDuringAllocation"));
+			//ERR_PRINTF1(_L("A non-supplier port sends this error to the IL client (via the EventHandler callback) during the allocation of buffers (on a transition from the LOADED to the IDLE state or on a port restart) when it deems that it has waited an unusually long time for the supplier to send it an allocated buffer via a UseBuffer call."));
+			return KErrGeneral; //KErrTimedOut
+			}
+
+		case OMX_ErrorPortUnresponsiveDuringDeallocation:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorPortUnresponsiveDuringDeallocation"));
+			//ERR_PRINTF1(_L("A non-supplier port sends this error to the IL client (via the EventHandler callback) during the deallocation of buffers (on a transition from the IDLE to LOADED state or on a port stop) when it deems that it has waited an unsually long time for the supplier to request the deallocation of a buffer header via a FreeBuffer call."));
+			return KErrGeneral; //KErrTimedOut
+			}
+
+		case OMX_ErrorPortUnresponsiveDuringStop:
+			{
+		ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorPortUnresponsiveDuringStop"));
+			//ERR_PRINTF1(_L("A supplier port sends this error to the IL client (via the EventHandler callback) during the stopping of a port (either on a transition from the IDLE to LOADED state or a port stop) when it deems that it has waited an unusually long time for the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call."));
+			return KErrGeneral; //KErrTimedOut
+			}
+
+		case OMX_ErrorIncorrectStateTransition:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorIncorrectStateTransition"));
+			//ERR_PRINTF1(_L("Attempting a state transtion that is not allowed"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorIncorrectStateOperation:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorIncorrectStateOperation"));
+			//ERR_PRINTF1(_L("Attempting a command that is not allowed during the present state."));
+			return KErrGeneral; //KErrNotSupported
+			}
+
+		case OMX_ErrorUnsupportedSetting:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorUnsupportedSetting"));
+			//ERR_PRINTF1(_L("The values encapsulated in the parameter or config structure are not supported."));
+			return KErrGeneral; //KErrNotSupported
+			}
+
+		case OMX_ErrorUnsupportedIndex:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorUnsupportedIndex"));
+			//ERR_PRINTF1(_L("The parameter or config indicated by the given index is not supported."));
+			return KErrNotSupported; //KErrTooBig or KErrGeneral
+			}
+
+		case OMX_ErrorBadPortIndex:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorBadPortIndex"));
+			//ERR_PRINTF1(_L("The port index supplied is incorrect."));
+			return KErrArgument; //KErrTooBig
+			}
+
+		case OMX_ErrorPortUnpopulated:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorPortUnpopulated"));
+			//ERR_PRINTF1(_L("The port has lost one or more of its buffers and it thus unpopulated."));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorComponentSuspended:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorComponentSuspended"));
+			//ERR_PRINTF1(_L("Component suspended due to temporary loss of resources"));
+			return KErrAbort;
+			}
+
+		case OMX_ErrorDynamicResourcesUnavailable:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorDynamicResourcesUnavailable"));
+			//ERR_PRINTF1(_L("Component suspended due to an inability to acquire dynamic resources"));
+			return KErrAbort; //KErrGeneral
+			}
+
+		case OMX_ErrorMbErrorsInFrame:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorMbErrorsInFrame"));
+			//ERR_PRINTF1(_L("When the macroblock error reporting is enabled the component returns new error for every frame that has errors"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorFormatNotDetected:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorFormatNotDetected"));
+			//ERR_PRINTF1(_L("A component reports this error when it cannot parse or determine the format of an input stream."));
+			return KErrCorrupt; //KErrGeneral
+			}
+
+		case OMX_ErrorContentPipeOpenFailed:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorContentPipeOpenFailed"));
+			//R//ERR_PRINTF1(_L("The content open operation failed."));
+			return KErrGeneral;
+			//break;
+			}
+
+		case OMX_ErrorContentPipeCreationFailed:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorContentPipeCreationFailed"));
+			//ERR_PRINTF1(_L("The content creation operation failed."));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorSeperateTablesUsed:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorSeperateTablesUsed"));
+			//ERR_PRINTF1(_L("Separate table information is being used"));
+			return KErrGeneral;
+			}
+
+		case OMX_ErrorTunnelingUnsupported:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorTunnelingUnsupported"));
+			//ERR_PRINTF1(_L("Tunneling is unsupported by the component"));
+			return KErrNotSupported;
+			}
+
+		case OMX_ErrorMax:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : OMX_ErrorMax"));
+			//ERR_PRINTF1(_L("OMX_ErrorMax"));
+			return KErrTooBig; // KErrGeneral
+			}
+
+		default:
+			{
+			ERR_PRINTF1(_L("OMX ERROR : Wrong error code found"));
+			return KErrGeneral;
+			}
+		}
+	}
+
+void COmxGsTestBase::InfoPrint1(const TDesC& aPrint)
+	{
+	INFO_PRINTF1(aPrint);
+	}
+
+OMX_ERRORTYPE COmxGsTestBase::ConvertSymbianErrorType(TInt aError)
+	{
+	OMX_ERRORTYPE err = OMX_ErrorNone;
+	switch (aError)
+		{
+	case KErrNone:
+		err = OMX_ErrorNone;
+		break;
+	case KErrNoMemory:
+		err = OMX_ErrorInsufficientResources;
+		break;
+	case KErrGeneral:
+		break;
+	default:
+		err = OMX_ErrorUndefined;
+		}
+	return err;
+	}
+
+
+void COmxGsTestBase::InitialiseOmxComponents()
+	{
+	iError = OMX_Init();
+
+	if (OMX_ErrorNone != iError)
+		{
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+
+	ASSERT(!iCallbackHandler);
+	TRAPD(error, iCallbackHandler = CCallbackHandler::NewL(*this));
+	OMX_CALLBACKTYPE* omxCallbacks = *iCallbackHandler;
+
+	if (error)
+		{
+		SetTestStepError(error);
+		return SetTestStepResult(EFail);
+		}
+
+	OMX_PTR appData = iCallbackHandler;
+
+	OMX_HANDLETYPE graphicsSinkHandle = NULL;
+	OMX_STRING graphicsSinkComponentName = "OMX.SYMBIAN.VIDEO.GRAPHICSINK";
+
+	iError = OMX_GetHandle(
+	    &graphicsSinkHandle,
+	    graphicsSinkComponentName,
+	    appData,
+	    omxCallbacks);
+
+	if (OMX_ErrorNone != iError)
+		{
+		INFO_PRINTF2(_L("Error %08X loading graphics sink"), iError);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+
+	iGraphicSinkCompHandle = (OMX_COMPONENTTYPE*) graphicsSinkHandle;
+	INFO_PRINTF2(_L("OMX.SYMBIAN.VIDEO.GRAPHICSINK: Handle: %X"), iGraphicSinkCompHandle);
+/*
+	OMX_HANDLETYPE cameraSourceHandle = NULL;
+	OMX_STRING cameraSourceComponentName = "OMX.SYMBIAN.VIDEO.CAMERASOURCE";
+
+	iError = OMX_GetHandle(
+	    &cameraSourceHandle,
+	    cameraSourceComponentName,
+	    appData,
+	    omxCallbacks);
+
+	if (OMX_ErrorNone != iError)
+		{
+		INFO_PRINTF2(_L("Error %08X loading camera source"), iError);
+		OMX_FreeHandle(iGraphicSinkCompHandle);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	iCameraSourceCompHandle = (OMX_COMPONENTTYPE*)cameraSourceHandle;
+	INFO_PRINTF2(_L("OMX.SYMBIAN.VIDEO.CAMERASOURCE: Handle: %X"), iCameraSourceCompHandle);
+	
+ 	OMX_HANDLETYPE fileSinkHandle = NULL;
+	OMX_STRING fileSinkComponentName = "OMX.SYMBIAN.OTHER.FILESINK";
+
+	iError = OMX_GetHandle(
+	    &fileSinkHandle,
+	    fileSinkComponentName,
+	    appData,
+	    omxCallbacks);
+
+	if (OMX_ErrorNone != iError)
+		{
+		INFO_PRINTF2(_L("Error %08X loading file sink"), iError);
+		OMX_FreeHandle(iGraphicSinkCompHandle);
+		OMX_FreeHandle(iCameraSourceCompHandle);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+
+	iFileSinkCompHandle = (OMX_COMPONENTTYPE*)fileSinkHandle;
+	INFO_PRINTF2(_L("OMX.SYMBIAN.OTHER.FILESINK: Handle: %X"), iFileSinkCompHandle);
+
+
+	OMX_HANDLETYPE jpegEncoderHandle = NULL;
+	OMX_STRING jpegEncoderComponentName = "OMX.SYMBIAN.IMAGE.ENCODER.JPEG";
+
+	iError = OMX_GetHandle(&jpegEncoderHandle,
+							jpegEncoderComponentName,
+							appData,
+							omxCallbacks);
+
+	if (OMX_ErrorNone != iError)
+		{
+		INFO_PRINTF2(_L("Error %08X loading jpeg encoder"), iError);
+		OMX_FreeHandle(iGraphicSinkCompHandle);
+		OMX_FreeHandle(iCameraSourceCompHandle);
+		OMX_FreeHandle(iFileSinkCompHandle);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+
+	iJpegEncoderCompHandle = (OMX_COMPONENTTYPE*) jpegEncoderHandle;
+	INFO_PRINTF2(_L("OMX.SYMBIAN.IMAGE.ENCODER.JPEG: Handle: %X"), iJpegEncoderCompHandle);
+	
+	
+    OMX_HANDLETYPE imageWriterHandle = NULL;
+    OMX_STRING imageWriterComponentName = "OMX.SYMBIAN.IMAGE.IMAGEWRITER";
+
+    iError = OMX_GetHandle(&imageWriterHandle,
+                            imageWriterComponentName,
+                            appData,
+                            omxCallbacks);
+
+    if (OMX_ErrorNone != iError)
+        {
+        INFO_PRINTF2(_L("Error %08X loading image writer"), iError);
+        OMX_FreeHandle(iGraphicSinkCompHandle);
+        OMX_FreeHandle(iCameraSourceCompHandle);
+        OMX_FreeHandle(iFileSinkCompHandle);
+        OMX_FreeHandle(iJpegEncoderCompHandle);
+        SetTestStepError(PrintOmxError(iError));
+        return SetTestStepResult(EFail);
+        }
+
+    iImageWriterCompHandle = (OMX_COMPONENTTYPE*) imageWriterHandle;
+    INFO_PRINTF2(_L("OMX.SYMBIAN.IMAGE.IMAGEWRITER: Handle: %X"), iImageWriterCompHandle);
+*/
+	InitialiseTestSpecificOmxComponents();
+	
+	SetTestStepResult(EPass);
+	}
+
+void COmxGsTestBase::InitialiseTestSpecificOmxComponents()
+    {
+    // Disable clock port in Camera Source
+//    INFO_PRINTF1(_L("send port 3 to disable"));
+//    SendCommand(iCameraSourceCompHandle, OMX_CommandPortDisable, KCameraClockPortIndex, 0);
+    
+    // Disable port VC in Camera Source
+//    INFO_PRINTF1(_L("send port 1 to disable"));
+//    SendCommand(iCameraSourceCompHandle, OMX_CommandPortDisable, KCameraVCPortIndex, 0);
+    }
+
+void COmxGsTestBase::CreateWindowL()
+	{
+	iSurfaceUpdateSession.Close();
+		iSurfaceManager.Close();iWindowHandle = 0;
+	// Connect to a WS Session.
+    User::LeaveIfError(iWsSession.Connect());
+
+    // Create a Window Group.
+    iWindowGroup = RWindowGroup(iWsSession);
+	User::LeaveIfError(iWindowGroup.Construct(iWindowHandle++));
+
+    // Create the Screen device for the WServ session.
+    iWsSd = new (ELeave) CWsScreenDevice(iWsSession);
+    User::LeaveIfError(iWsSd->Construct());
+
+    //Done in different class
+    iWindow = new (ELeave) RWindow(iWsSession);
+    User::LeaveIfError(iWindow->Construct(iWindowGroup, iWindowHandle++));
+
+    iWindow2 = new (ELeave) RWindow(iWsSession);
+    User::LeaveIfError(iWindow2->Construct(iWindowGroup, iWindowHandle));
+
+    //done in different class
+	iGc = new (ELeave) CWindowGc(iWsSd);
+    User::LeaveIfError(iGc->Construct());
+
+	iGc2 = new (ELeave) CWindowGc(iWsSd);
+    User::LeaveIfError(iGc2->Construct());
+
+    // Reset the screen mode.
+    if(iWsSd->CurrentScreenMode() != 0)
+	    {
+	    iWsSd->SetAppScreenMode(0);
+	    iWsSd->SetScreenMode(0);
+	    }
+
+	iWindow->Activate();
+	iGc->Activate(*iWindow);
+	iGc->Clear();
+	iWindow->SetVisible(ETrue);
+	iWsSession.Flush();
+	}
+
+void COmxGsTestBase::CloseTest()
+	{
+	delete iCallbackHandler;
+	iCallbackHandler = NULL;
+	if(iTestChunk.Handle())
+		{
+		iTestChunk.Close();
+		}
+
+	if (iGc)
+	    {
+	    delete iGc;
+	    iGc = NULL;
+	    }
+	if (iGc2)
+	    {
+	    delete iGc2;
+	    iGc2 = NULL;
+	    }
+	
+	if (iWsSd)
+	    {
+	    delete iWsSd;
+	    iWsSd = NULL;
+	    }
+	
+	iWsSession.Close();
+	
+	if (iWindow)
+	    {
+	    delete iWindow;
+	    iWindow = NULL;
+	    }
+	
+	if (iWindow2)
+	    {
+	    delete iWindow2;
+	    iWindow2 = NULL;
+	    }
+
+	if (iTestShutdown)
+	    {
+	    delete iTestShutdown;
+	    iTestShutdown = NULL;
+	    }
+	
+	if (iTestPause)
+	    {
+	    delete iTestPause;
+	    iTestPause = NULL;
+	    }
+	
+	if (iTestStateTransition)
+	    {
+	    delete iTestStateTransition;
+	    iTestStateTransition = NULL;	    
+	    }
+
+	iSurfaceUpdateSession.Close();
+	iSurfaceManager.Close();
+	// Make sure we are not running the Alloc tests, if we are
+	// then we have already cleaned up the OMX components and core.
+	if(TestStepName() != (_L("MMVIDEO-OMX-CS-004-HP")) && TestStepName() != (_L("MMVIDEO-OMX-GS-001-00-HP"))
+			&& TestStepName() != (_L("MMVIDEO-OMX-JP-001-00-HP")) && TestStepName() != (_L("MMVIDEO-OMX-FS-001-00-HP"))
+			&& TestStepName() != (_L("MMVIDEO-OMX-IW-001-00-HP")))
+		{
+		FreeHandles();
+		iError = OMX_Deinit();
+		}
+
+	REComSession::FinalClose();
+	}
+
+TInt COmxGsTestBase::InitialiseSurfaceManager()
+	{
+	TInt err = iSurfaceManager.Open();
+	if (err == KErrNone)
+		{
+		err = iSurfaceUpdateSession.Connect(3);
+		}
+
+	if (err == KErrNotFound)
+		{
+		INFO_PRINTF1(_L("Failed to find surfacemanger or surfaceupdatesession"));
+		INFO_PRINTF1(_L("Make sure 'SYMBIAN_GRAPHICS_USE_GCE ON' is specified in epoc.ini"));
+		}
+
+	return err;
+	}
+
+TInt COmxGsTestBase::CreateAndMapSurface(const RSurfaceManager::TSurfaceCreationAttributesBuf& aReqs, TSurfaceId& aSurfaceId)
+	{
+	TInt err = iSurfaceManager.CreateSurface(aReqs, aSurfaceId);
+	if (err)
+		{
+		ERR_PRINTF2(_L("RSurfaceManager::CreateSurface() failed with %d"), err);
+		return err;
+		}
+
+	err = iSurfaceManager.MapSurface(aSurfaceId, iTestChunk);
+	if (err)
+		{
+		ERR_PRINTF2(_L("RSurfaceManager::MapSurface() failed with %d"), err);
+		return err;
+		}
+
+	iSurfaceId = aSurfaceId;
+	return KErrNone;
+	}
+
+void COmxGsTestBase::SendCommand(
+			            OMX_HANDLETYPE aComponent,
+			            OMX_COMMANDTYPE aCmd,
+			            OMX_U32 aParam1,
+			            OMX_PTR aCmdData,
+			            OMX_ERRORTYPE aExpError)
+	{
+	iError = OMX_SendCommand(aComponent,aCmd,aParam1,aCmdData);
+
+	if (aExpError != iError)
+		{
+		ERR_PRINTF1(_L("SendCommandErr"));
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	}
+
+void COmxGsTestBase::GetState(OMX_HANDLETYPE aComponent,OMX_STATETYPE* aState,OMX_STATETYPE aExpectedState)
+	{
+	iError = OMX_GetState(aComponent,aState);
+	if (OMX_ErrorNone != iError)
+		{
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+
+	// PrintOmxState(*aState);
+	if (aExpectedState != OMX_StateMax)
+		{
+		if (aExpectedState != *aState)
+			{
+			ERR_PRINTF1(_L("Did not return expected state"));
+			PrintOmxState(*aState);
+			SetTestStepError(KErrGeneral);
+			return SetTestStepResult(EFail);
+			}
+		}
+
+	}
+
+void COmxGsTestBase::SetParameter(
+						OMX_HANDLETYPE aComponent,
+            			OMX_INDEXTYPE aIndex,
+            			OMX_PTR aComponentParameterStructure,
+            			OMX_ERRORTYPE aExpError)
+	{
+	iError = OMX_SetParameter(aComponent,
+										aIndex,
+										aComponentParameterStructure);
+	if (aExpError != iError)
+		{
+		INFO_PRINTF3(_L("SetParameter() returned %08X instead of %08X"), iError, aExpError);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	}
+
+void COmxGsTestBase::GetParameter(
+					OMX_HANDLETYPE aComponent,
+            		OMX_INDEXTYPE aIndex,
+            		OMX_PTR aComponentParameterStructure,
+            		OMX_ERRORTYPE aExpError)
+	{
+	iError = OMX_GetParameter(aComponent,
+										aIndex,
+										aComponentParameterStructure);
+	if (aExpError != iError)
+		{
+		ERR_PRINTF3(_L("COmxGsTestBase::GetParameter - expected: %08X got: %08X"), aExpError, iError);
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	}
+
+void COmxGsTestBase::SetConfig(
+						OMX_HANDLETYPE aComponent,
+            			OMX_INDEXTYPE aIndex,
+            			OMX_PTR aComponentParameterStructure,
+            			OMX_ERRORTYPE aExpError)
+	{
+	iError = OMX_SetConfig(aComponent,
+										aIndex,
+										aComponentParameterStructure);
+	if (aExpError != iError)
+		{
+		INFO_PRINTF1(_L("COmxGsTestBase::SetConfig fail"));
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	}
+
+void COmxGsTestBase::GetConfig(
+					OMX_HANDLETYPE aComponent,
+            		OMX_INDEXTYPE aIndex,
+            		OMX_PTR aComponentParameterStructure,
+            		OMX_ERRORTYPE aExpError)
+	{
+	iError = OMX_GetConfig(aComponent,
+										aIndex,
+										aComponentParameterStructure);
+	if (aExpError != iError)
+		{
+		INFO_PRINTF1(_L("COmxGsTestBase::GetConfig fail"));
+		SetTestStepError(PrintOmxError(iError));
+		return SetTestStepResult(EFail);
+		}
+	}
+
+void COmxGsTestBase::FreeBuffer(
+		OMX_HANDLETYPE aComponent,
+        OMX_U32 aPortIndex,
+        RPointerArray<OMX_BUFFERHEADERTYPE> aArrayBufferHeaderType,
+        OMX_ERRORTYPE aExpError)
+	{
+	TInt bufferCount = aArrayBufferHeaderType.Count();
+
+	for (TInt i =0; i < bufferCount ; ++i)
+		{
+		iError = OMX_FreeBuffer(aComponent,aPortIndex,aArrayBufferHeaderType[i]);
+		if (aExpError != iError)
+			{
+			SetTestStepError(PrintOmxError(iError));
+			return SetTestStepResult(EFail);
+			}
+		}
+	}
+
+void COmxGsTestBase::AllocateBuffer(
+		OMX_HANDLETYPE aComponent,
+		OMX_BUFFERHEADERTYPE** aBufferHeaderType,
+        OMX_U32 aPortIndex,
+        OMX_PTR aAppPrivate,
+        OMX_U32 aSizeBytes,
+        RPointerArray<OMX_BUFFERHEADERTYPE>* aArrayBufferHeaderType,
+        OMX_U32 aCount,
+        OMX_ERRORTYPE aExpError)
+	{
+	for(TInt i = 0 ; i < aCount; i++ )
+		{
+		iError = OMX_AllocateBuffer(aComponent,*&aBufferHeaderType,aPortIndex,aAppPrivate,aSizeBytes);
+		if (aExpError != iError)
+			{
+			SetTestStepError(PrintOmxError(iError));
+			return SetTestStepResult(EFail);
+			}
+
+		// Used for tracking
+		TInt err = aArrayBufferHeaderType->Append(*aBufferHeaderType);
+		if (err != KErrNone)
+			{
+			INFO_PRINTF2(_L("Append Buffer Failed %d"), err);
+			SetTestStepError(err);
+			return SetTestStepResult(EFail);
+			}
+		}
+	}
+
+void COmxGsTestBase::FreeHandles()
+	{
+	// Don't call this function after OMX_DeInit call
+	if (iGraphicSinkCompHandle)
+		{
+		INFO_PRINTF1(_L("FreeHandle for GFX ++"));
+		OMX_FreeHandle(iGraphicSinkCompHandle);
+		iGraphicSinkCompHandle = NULL;
+		}
+/*
+	if(iCameraSourceCompHandle)
+		{
+		INFO_PRINTF1(_L("FreeHandle for CAM ++"));
+		OMX_FreeHandle(iCameraSourceCompHandle);
+		iCameraSourceCompHandle = NULL;
+		}
+
+	if (iFileSinkCompHandle)
+		{
+		INFO_PRINTF1(_L("FreeHandle for FSK ++"));
+		OMX_FreeHandle(iFileSinkCompHandle);
+		iFileSinkCompHandle = NULL;
+		}
+
+	if(iJpegEncoderCompHandle)
+		{
+		INFO_PRINTF1(_L("FreeHandle for JPEG Encoder ++"));
+		OMX_FreeHandle(iJpegEncoderCompHandle);
+		iJpegEncoderCompHandle = NULL;
+		}
+	
+    if(iImageWriterCompHandle)
+        {
+        INFO_PRINTF1(_L("FreeHandle for Image Writer ++"));
+        OMX_FreeHandle(iImageWriterCompHandle);
+        iImageWriterCompHandle = NULL;
+        }
+	
+	if(iXvidEncoderCompHandle)
+        {
+        INFO_PRINTF1(_L("FreeHandle for Xvid Encoder ++"));
+        OMX_FreeHandle(iXvidEncoderCompHandle);
+        iXvidEncoderCompHandle = NULL;
+        }
+    
+    if(i3gpMuxerCompHandle)
+        {
+        INFO_PRINTF1(_L("FreeHandle for 3gp Muxer ++"));
+        OMX_FreeHandle(i3gpMuxerCompHandle);
+        i3gpMuxerCompHandle = NULL;
+        }
+    
+    if(iClockCompHandle)
+        {
+        INFO_PRINTF1(_L("FreeHandle for Clock ++"));
+        OMX_FreeHandle(iClockCompHandle);
+        iClockCompHandle = NULL;
+        }
+*/
+	}
+
+
+
+TInt COmxGsTestBase::StateTransition(const TDesC& /*aStateTransitionName*/)
+	{
+	return KErrNone;
+	}
+
+void COmxGsTestBase::StartTimer()
+	{
+	TRAPD(err, iTestShutdown = COmxGsTestShutdown::NewL(this,1));
+	if(err)
+		{
+		ERR_PRINTF1(_L("OOM ERROR"));
+		return SetTestStepError(err);
+		}
+	iInterval = KTSU_OMX_GS_Interval;
+	iTestShutdown->Start(iInterval,KErrNone, EPass);
+	CActiveScheduler::Start();
+	}
+
+void COmxGsTestBase::WaitForCallbacks()
+	{
+	TRAPD(error, iTestShutdown = COmxGsTestShutdown::NewL(this,2));
+	if(error)
+		{
+		ERR_PRINTF1(_L("OOM ERROR"));
+		return SetTestStepError(error);
+		}
+
+	iInterval = KTSU_OMX_GS_CALLBACK;
+	iTestShutdown->Start(iInterval,KErrGeneral, EPass);
+	CActiveScheduler::Start();
+	}
+
+void COmxGsTestBase::PauseTimer()
+	{
+	TRAPD(error, iTestPause = COmxGsTestShutdown::NewL(this,3));
+	if(error)
+		{
+		ERR_PRINTF1(_L("OOM ERROR"));
+		return SetTestStepError(error);
+		}
+
+	iInterval = KTSU_OMX_GS_Pause_Interval/2;
+	iTestPause->Start(iInterval,KErrGeneral, EPass);
+	}
+
+// ShutDown Class
+COmxGsTestShutdown* COmxGsTestShutdown::NewL(COmxGsTestBase* aOmxGsTest,TInt aTimerId)
+	{
+	COmxGsTestShutdown* self = new(ELeave) COmxGsTestShutdown(aOmxGsTest,aTimerId);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+	}
+
+COmxGsTestShutdown::COmxGsTestShutdown(COmxGsTestBase* aOmxGsTest,TInt aTimerId)
+: CTimer(EPriorityUserInput), iOmxGsTest(aOmxGsTest), iTimerId(aTimerId)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+COmxGsTestShutdown::~COmxGsTestShutdown()
+	{
+	Cancel();
+	}
+
+void COmxGsTestShutdown::ConstructL()
+	{
+	CTimer::ConstructL();
+	}
+
+void COmxGsTestShutdown::Start(TTimeIntervalMicroSeconds32 aInterval, TInt aReason, TVerdict aResult)
+	{
+	iReason = aReason;
+	iResult = aResult;
+	After(aInterval);
+	}
+
+void COmxGsTestShutdown::RunL()
+	{
+	iOmxGsTest->PostKickOffTestL(iTimerId);
+	}
+
+COmxGsTestStateTransition* COmxGsTestStateTransition::NewL(COmxGsTestBase* aOmxGsTest,TInt aPriority)
+	{
+	COmxGsTestStateTransition* self = new(ELeave) COmxGsTestStateTransition(aOmxGsTest,aPriority);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop();
+	return self;
+
+	}
+
+COmxGsTestStateTransition::COmxGsTestStateTransition(COmxGsTestBase* aOmxGsTest,TInt aPriority)
+: CTimer(aPriority), iOmxGsTest(aOmxGsTest)
+	{
+	CActiveScheduler::Add(this);
+	}
+
+COmxGsTestStateTransition::~COmxGsTestStateTransition()
+	{
+	Cancel();
+	}
+
+void COmxGsTestStateTransition::ConstructL()
+	{
+	CTimer::ConstructL();
+	}
+
+void COmxGsTestStateTransition::Start(TTimeIntervalMicroSeconds32 aInterval,const TDesC& aStateTransitionName)
+	{
+	iStateTransitionName = aStateTransitionName;
+	After(aInterval);
+	}
+
+void COmxGsTestStateTransition::RunL()
+	{
+	iOmxGsTest->StateTransition(iStateTransitionName);
+	}