/*

* Copyright (c) 2008-2009 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:

*

*/

#include "omxscripttest.h"

#include "paramconversion.h"

#include "statedes.h"

#include "omxutil.h"

#include "nontunneledhandler.h"

#include "log.h"

#include "omx_xml_script.h"

#include "transition.h"

#include "parsemap.h"

#include <uri8.h>

#include "baseprofilehandler.h"

#include "baseprofiletimestamping.h"

#include "windowmanager.h"

//Logical IL headers

//#include <openmax/logicalil/extensions/omxlilsymvidgraphicsinksurfaceidextns.h>

//#include <openmax/logicalil/extensions/omxlilsymaudpcmextns.h>

///////////////////////////////////////////////////////////////////////////////

// Temporary work-around for floating point issues on HREF 8500 ED hardware

// Using this macro, code that uses TReal will be #defined out if running on ED.

// TODO: Remove HREF_ED_WITHOUT_FLOATING_POINT and all of its conditional code

// once the floating point issue has been solved.

#if defined(NCP_COMMON_BRIDGE_FAMILY) && !defined(__WINSCW__)

#define HREF_ED_WITHOUT_FLOATING_POINT

#endif

DECL_PARSETYPE(OMX_EVENTTYPE);

_LIT8(KILTypeString, "LOGICAL");

static TInt StopScheduler(TAny* unused);

/**

 * Runs an OMX test specified in an XML file.

 * @param aScriptFilename path to XML file

 * @param aScriptSection section name in XML file

 */

void ROmxScriptTest::RunTestL(const TDesC& aScriptFilename, const TDesC& aScriptSection)

	{

	User::LeaveIfError(iEventHandler.Create());

	iStopSchedulerCallback = new(ELeave) CAsyncCallBack(StopScheduler, CActive::EPriorityHigh);

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	INFO_PRINTF3(_L("Executing test steps in section %S of %S"), &aScriptSection, &aScriptFilename);

	TPtrC filename;

	COmxScriptParser* parser = COmxScriptParser::NewL(fs, aScriptFilename, *this);

	CleanupStack::PushL(parser);

	// this drives the methods from MOmxScriptIf

	TBool success = parser->RunScriptL(aScriptSection);

	if(success)

		{

		StopTest(EPass);

		}

	else

		{

		ERR_PRINTF1(_L("Script did not complete"));

		StopTest(EFail);

		}

	CleanupStack::PopAndDestroy(2, &fs);	// fs, parser

	User::LeaveIfError(Reason());

	}

/**

 * Constructs an object to parse and execute an OMX test case specified in

 * an XML file.

 * @param reference to logger interface to receive test messages

 */

ROmxScriptTest::ROmxScriptTest(MOmxScriptTestLogger& aLogger):

	iCoreLoaded(EFalse),

	iEventHandler(*this),

	iState(OMX_StateLoaded),

	iWindowManager(NULL),

	iVideoFitMode(EVideoFitRotateScaleAndCentre),

	iTimer(NULL),

	iWaitingForEvents(EFalse),

	iNonTunneledHandler(NULL),

	iBufferHandler(NULL),

	iBufferSinkHandler(NULL),

	iReason(KErrNone),

	iVerdict(EPending),

	iLogger(aLogger),

	iStopSchedulerCallback(NULL),

    iPortBufferHandler(NULL)

	{

	}

/**

 * Destroys all resources created by this object. 

 */

void ROmxScriptTest::Close()

	{

	// release memory and unload components

	// ~CComponentInfo unloads component in correct thread

	iComponents.ResetAndDestroy();

	if(iCoreLoaded)

		{

		INFO_PRINTF1(_L("OMX_Deinit()"));

		iCoreLoaded = EFalse;

		OMX_ERRORTYPE error = OMX_Deinit();

		if(error)

			{

			FailWithOmxError(_L("OMX_Deinit"), error);

			}

		}

	REComSession::FinalClose();

	iEventHandler.Close();

	delete iWindowManager;

	iWindowManager = NULL;

	iState = OMX_StateLoaded;

	if (iTimer)

		{

		iTimer->Cancel();

		delete iTimer;

		iTimer = NULL;

		}

	iExpectedEvents.Close();

	iIgnoredEvents.Close();

	if (iNonTunneledHandler)

		{

		delete iNonTunneledHandler;

		iNonTunneledHandler = NULL;

		}

   if(iPortBufferHandler)

       {

       delete iPortBufferHandler;

       iPortBufferHandler = NULL;

       }

	delete iStopSchedulerCallback;

	iStopSchedulerCallback = NULL;

	iTunnels.Close();

	}

// allows OMX components to be placed on the cleanup stack

//void ROmxScriptTest::CleanupOmxComponent(TAny* aPtr)

//	{

//	OMX_COMPONENTTYPE* component = static_cast<OMX_COMPONENTTYPE*>(aPtr);

//	OMX_ERRORTYPE error = OMX_FreeHandle(component);

//	// if this method is called, we are already in an error condition,

//	// but OMX_FreeHandle should still succeed. Perhaps a cleaner way of

//	// reporting any error is desired, but this is a static method so we

//	// lack the context to call the standard logging mechanism.

//	__ASSERT_DEBUG(!error, User::Invariant());

//	}

TBool ROmxScriptTest::MosLoadComponentL(const TDesC8& aComp, const TDesC8& aName, TBool aBaseProfile, const TDesC8* aBaseImpl, TBool aLoadInCoreServerThread)

	{

	if(!iCoreLoaded)

		{

		INFO_PRINTF1(_L("OMX_Init()"));

		OMX_ERRORTYPE error = OMX_Init();

		if(error)

			{

			CleanupStack::PopAndDestroy(2);

			FailWithOmxError(_L("OMX_Init()"), error);

			return EFalse;

			}

		iCoreLoaded = ETrue;

		}

	// convert from 8-bit descriptor for logging

	TBuf<64> nameCopy;

	nameCopy.Copy(aName);

	INFO_PRINTF2(_L("Loading component %S"), &nameCopy);

	CComponentInfo* componentInfo = CComponentInfo::NewL(*this);

	CleanupStack::PushL(componentInfo);

	componentInfo->iShortName = HBufC8::NewL(aComp.Length());

	*(componentInfo->iShortName) = aComp;

	// allow room for the '\0' used in call to OMX_GetHandle

	componentInfo->iComponentName = HBufC8::NewL(aName.Length() + 1);

	*(componentInfo->iComponentName) = aName;

	OMX_ERRORTYPE error = OMX_ErrorNone;

	if (aBaseProfile)

	    {

	    if (*aBaseImpl == _L8("base"))

	        {

	        componentInfo->iBaseHandler = new (ELeave) CBaseProfileHandler(*this, iEventHandler);

	        componentInfo->iComponent = componentInfo->iBaseHandler->LoadComponentL(*componentInfo->iShortName, *componentInfo->iComponentName);

	        }

	    else if (*aBaseImpl == _L8("timestampcheck"))

            {

            componentInfo->iBaseHandler = new (ELeave) CBaseProfileTimestampHandling(*this, iEventHandler);

            componentInfo->iComponent = componentInfo->iBaseHandler->LoadComponentL(*componentInfo->iShortName, *componentInfo->iComponentName);

            }

	    }

	else

        {

        OMX_CALLBACKTYPE& callbacks = iEventHandler.CallbackStruct();

        // NOTE componentInfo.iShortName and componentInfo.iComponentName still on the cleanup stack

        if(aLoadInCoreServerThread)

            {

            INFO_PRINTF2(_L("Loading component %S in Core Server thread"), &nameCopy);

            if(componentInfo->iThreadRequest == NULL)

                {

                componentInfo->iThreadRequest = COmxThreadRequest::NewL();

                }

            error = componentInfo->iThreadRequest->GetHandle((TAny**) &(componentInfo->iComponent), (OMX_STRING) componentInfo->iComponentName->Des().PtrZ(), &iEventHandler, &callbacks);

            }

        else

            {

            INFO_PRINTF2(_L("Loading component %S in Client thread"), &nameCopy);

            error = OMX_GetHandle((TAny**) &(componentInfo->iComponent), (OMX_STRING) componentInfo->iComponentName->Des().PtrZ(), &iEventHandler, &callbacks);

            }

        }

	if(error || (componentInfo->iComponent == NULL))

		{

		CleanupStack::PopAndDestroy();	// delete component info

		FailWithOmxError(_L("OMX_GetHandle()"), error);

		return EFalse;

		}

	RDebug::Print(_L("OMX_GetHandle name=%S handle=0x%08X"), &nameCopy, componentInfo->iComponent);

	iEventHandler.AddComponentL(componentInfo->iComponent, nameCopy);

	iComponents.AppendL(componentInfo);

	CleanupStack::Pop(1, componentInfo);

	return ETrue;

	}

TBool ROmxScriptTest::MosSetupTunnel(const TDesC8& aSourceComp, TInt aSourcePort,

                                     const TDesC8& aSinkComp, TInt aSinkPort, OMX_ERRORTYPE aExpectedError)

	{

	OMX_COMPONENTTYPE* source = NULL;

	OMX_COMPONENTTYPE* sink = NULL;

	if(aSourceComp!=KNullDesC8)

		{

		source = ComponentByName(aSourceComp);

		}

	if(aSinkComp!=KNullDesC8)

		{

		sink = ComponentByName(aSinkComp);

		}

	//support for testing tunnel breakup

	if(source || sink)

		{

		OMX_ERRORTYPE error = OMX_SetupTunnel(source, aSourcePort, sink, aSinkPort);

		// TODO check tunnel reconfiguration

		if(error == OMX_ErrorNone)

			{

			RegisterTunnel(source, aSourcePort, sink, aSinkPort);

			}

		if(error != aExpectedError)

			{

			ERR_PRINTF3(_L("MosSetupTunnel OMX_SetupTunnel: Error 0x%X does not match expected error 0x%X"), error, aExpectedError);

			TBuf8<64> msg8;

			msg8.Format(_L8("source=%S:%d sink=%S:%d"), &aSourceComp, aSourcePort, &aSinkComp, aSinkPort);

			TBuf<64> msg;

			msg.Copy(msg8);

			INFO_PRINTF1(msg);

			return EFalse;

			}

		return ETrue;

		}

	else

		{

		// source or sink names not recognized

		return EFalse;

		}

	}

TBool ROmxScriptTest::MosSetupNonTunnel(const TDesC8& aSourceComp, TInt aSourcePort,

                                        const TDesC8& aSinkComp, TInt aSinkPort,

                                        OMX_BUFFERSUPPLIERTYPE aSupplier)

	{

	OMX_COMPONENTTYPE* source = ComponentByName(aSourceComp);

	OMX_COMPONENTTYPE* sink = ComponentByName(aSinkComp);

	if(source && sink)

		{

		OMX_PARAM_PORTDEFINITIONTYPE portDef;

		portDef.nSize = sizeof(portDef);

		portDef.nVersion = KOmxVersion;

		portDef.nPortIndex = aSourcePort;

		OMX_ERRORTYPE error = source->GetParameter(source, OMX_IndexParamPortDefinition, &portDef);

		if(error != OMX_ErrorNone)

			{

			FailWithOmxError(_L("GetParameter"), error);

			return EFalse;

			}

		TInt numBufs = portDef.nBufferCountActual;

		TInt bufSize = portDef.nBufferSize;

		portDef.nPortIndex = aSinkPort;

		error = sink->GetParameter(sink, OMX_IndexParamPortDefinition, &portDef);

		if(error != OMX_ErrorNone)

			{

			FailWithOmxError(_L("GetParameter"), error);

			return EFalse;

			}

		if (portDef.nBufferCountActual != numBufs)

			{

			ERR_PRINTF1(_L("Number of buffers does not match for non tunneled setup"));

			return EFalse;

			}

		if (portDef.nBufferSize > bufSize)

			{

			bufSize = portDef.nBufferSize;

			}

		if (!iNonTunneledHandler)

			{

			iNonTunneledHandler = new CNonTunneledHandler();

			if (!iNonTunneledHandler)

				{

				return EFalse;

				}

			}

		TRAPD(err, iNonTunneledHandler->AddLinkL(source, aSourcePort, sink, aSinkPort, aSupplier, numBufs, bufSize));

		if (err != KErrNone)

			return EFalse;

		return ETrue;

		}

	else

		{

		// source or sink names not recognized

		return EFalse;

		}

	}

TBool ROmxScriptTest::MosSetupBufferForPortL(const TDesC8& aComp,TInt aPortIndex, const TDesC& aFileName,TInt aHeaderLength,OMX_BUFFERSUPPLIERTYPE aSupplier)

    {

    TBuf<64> compConverted;

    compConverted.Copy(aComp);

    INFO_PRINTF3(_L("MosSetupBufferForPort comp %S port %d"), &compConverted, aPortIndex);

    OMX_COMPONENTTYPE* comp = ComponentByName(aComp);

    if(comp)

        {

        OMX_PARAM_PORTDEFINITIONTYPE portDef;

        portDef.nSize = sizeof(portDef);

        portDef.nVersion = KOmxVersion;

        portDef.nPortIndex = aPortIndex;

        OMX_ERRORTYPE error = comp->GetParameter(comp, OMX_IndexParamPortDefinition, &portDef);

        if(error != OMX_ErrorNone)

            {

            FailWithOmxError(_L("GetParameter"), error);

            return EFalse;

            }

        OMX_DIRTYPE portDirType = portDef.eDir;

        if(!iPortBufferHandler)

            {

            iPortBufferHandler = new (ELeave)CPortBufferHandler;

            }

        iPortBufferHandler->AddPortL(comp,aPortIndex,aFileName,aSupplier,portDirType,iLogger,aHeaderLength);

        }

    return ETrue;    

    }

TBool ROmxScriptTest::MosAllTransitionL(OMX_STATETYPE aState, OMX_ERRORTYPE aExpectedError, TTransitionOrder aOrder)

	{

	INFO_PRINTF2(_L("Transitioning all components to %S"), StateDes(aState));

	if(aOrder == ELoadOrder && aState == OMX_StateIdle && iState == OMX_StateLoaded)

		{

		WARN_PRINTF1(_L("Using component load order for loaded -> idle transition order"));

		}

	iEventHandler.AwaitTransition(aState, iState);

	RArray<TInt> order;

	CleanupClosePushL(order);

	order.ReserveL(iComponents.Count());

	if(aOrder == ELoadOrder)

		{

		for(TInt index = 0; index < iComponents.Count(); index++)

			{

			order.Append(index);

			}

		}

	else if(aOrder == EAutoOrder)

		{

		TRAPD(error, FindTransitionOrderL(iComponents, iTunnels, order));

		if(error != KErrNone)

			{

			ERR_PRINTF2(_L("Error determining transition order, error=%d"), error);

			User::Leave(error);

			}

		}

	if(aState == OMX_StateIdle && iState == OMX_StateExecuting)

		{

		// use reverse order for Idle->Executing transition

		TInt left = 0, right = order.Count() - 1;

		while(left < right)

			{

			TInt tmp = order[left];

			order[left] = order[right];

			order[right] = tmp;

			left++;

			right--;

			}

		}

	if(aOrder == EAutoOrder)

		{

		TBuf<128> orderDes;

		for(TInt index = 0, count = order.Count(); index < count; index++)

			{

			HBufC8* name8 = iComponents[order[index]]->iShortName;

			TBuf<16> name;

			name.Copy(*name8);

			if(index > 0)

				{

				orderDes.Append(_L(", "));

				}

			orderDes.Append(name);

			}

		INFO_PRINTF2(_L("Auto-detected transition order: %S"), &orderDes);

		}

	TBool commandError = EFalse;

	TBool ret = EFalse;

	for(TInt orderIndex = 0, count = order.Count(); orderIndex < count; orderIndex++)

		{

		TInt index = order[orderIndex];

		CComponentInfo* compInfo = iComponents[index];

		OMX_COMPONENTTYPE* component = compInfo->iComponent;

		OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandStateSet, aState, NULL);

		if(error)

			{

			TBuf<128> msg;

			msg.Format(_L("SendCommand(OMX_CommandStateSet, %S)"), StateDes(aState));

			if(error != aExpectedError)

				{

				FailWithOmxError(compInfo->iShortName->Des(), msg, error);

				ret = EFalse;

				}

			else //Need to stop the tests now be cause an error has occurred, even if it is expected.

				{

				StopTest(EPass);

				ret = ETrue;

				}

			commandError = ETrue;

			break;

			}

		if (!HandleNonTunneledBuffers(aState, component))

			{

			commandError = ETrue;

			ret = EFalse;

			break;

			}

	if(!HandlePortBufferHandler(aState, component))

		    {

		    return EFalse;

		    }

		}

	CleanupStack::PopAndDestroy(&order);

	if(commandError)

		{

		return ret;

		}

	// wait for the transitions to complete

	// use a nested loop of the active scheduler

	// AllComponentsTransitioned() calls EndWait() 

	BeginWait();

	return Reason() == KErrNone;

	}

TBool ROmxScriptTest::MosTransition(const TDesC8& aComp, OMX_STATETYPE aState, TBool aAsync)

	{

	TBuf<64> compConverted;

	compConverted.Copy(aComp);

	INFO_PRINTF3(_L("Transitioning %S component to %S"), &compConverted, StateDes(aState));

	OMX_COMPONENTTYPE* component = ComponentByName(aComp);

	if(!component)

		{

		return EFalse;

		}

	if (!aAsync)

		{

		iEventHandler.AwaitSingleTransition(component, aState, iState);

		}

	else

		{

		//Don't want to force a wait on this state transition so instead of using the event handler add the event to the expected list

		TExpectedEvent event;