/*

* 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 "omxilsymbianvideographicsinkextensions.h"

#include <openmax/il/shai/OMX_Symbian_IVCommonExt.h>

#include <graphics/surfaceconfiguration.h>

#include <hash.h>

#include "omxutil.h"

#include "nontunneledhandler.h"

#include "videobufferhandler.h"

#include "videobufferhandler_mpeg4.h" // for mpeg4

#include "videobuffersinkhandler.h"

#include "log.h"

#include "omx_xml_script.h"

#include "transition.h"

#include "parsemap.h"

#include <uri8.h>

#include "omxildroppedframeeventextension.h"

#include <c3gplibrary.h>

#include "baseprofilehandler.h"

#include "baseprofiletimestamping.h"

#include "windowmanager.h"

#ifdef OLD_ADPCM_EXTENSION

#include <openmax/il/extensions/omxilsymbianadpcmdecoderextensions.h>

#endif

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

// 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;

       }

   // Buffer component

	delete iBufferHandler;

	iBufferHandler = NULL;

	delete iBufferSinkHandler;

	iBufferSinkHandler = 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::MosSetWindowL(const TDesC8& aComp)

	{

	if(iWindowManager)

		{

		delete iWindowManager;

		iWindowManager = NULL;

		}

	iWindowManager = CWindowManager::NewL();

	TSize screenSize = iWindowManager->ScreenSize();

	INFO_PRINTF3(_L("Screen size is %dx%d"), screenSize.iWidth, screenSize.iHeight);

	OMX_COMPONENTTYPE* component = ComponentByName(aComp);

	if(!component)

		{

		return EFalse;

		}

	iGraphicSink = component;

	OMX_ERRORTYPE error = OMX_GetExtensionIndex(component, const_cast<char*>(sOmxSymbianGfxSurfaceConfig), &iExtSurfaceConfigIndex);

	if(error != OMX_ErrorNone)

		{

		FailWithOmxError(_L("GetExtensionIndex(sOmxSymbianGfxSurfaceConfig)"), error);

		return EFalse;

		}

	//Temporary Hack: This is for Logical IL Video Tests: SurfaceId is supposed to be set in response to PortSettingsChanged event from 

	//MMHP. Currently, there is no support for it. Hence, we are temporarily setting here

	OMX_PARAM_PORTDEFINITIONTYPE portDef;

	portDef.nSize = sizeof(portDef);

	portDef.nVersion = KOmxVersion;

	portDef.nPortIndex = 0;

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

	if(error)

		{

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

		return EFalse;

		}

	error = component->SetParameter(component, OMX_IndexParamPortDefinition, &portDef);

	if(error==OMX_ErrorIncorrectStateOperation)

		{

		OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION surfaceConfigParam;

		surfaceConfigParam.nSize = sizeof(OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION);

		surfaceConfigParam.nVersion = KOmxVersion;

		surfaceConfigParam.nPortIndex = 0;

		// define must be removed when hack is removed - OMX_GetExtensionIndex() should be used but hack for when this

		// returns an error

        #define OMX_SymbianIndexParamVideoGFXSurfaceConfig 0x7F000011

		OMX_ERRORTYPE omxError = component->GetParameter(component, (OMX_INDEXTYPE) OMX_SymbianIndexParamVideoGFXSurfaceConfig, &surfaceConfigParam);

		if(omxError != OMX_ErrorNone)

		    {

		    FailWithOmxError(_L("GetParameter(OMX_SymbianIndexParamVideoGFXSurfaceConfig)"), omxError);

		    return EFalse;

		    }

		TSurfaceConfiguration& surfaceConfig = *reinterpret_cast<TSurfaceConfiguration*>(surfaceConfigParam.pSurfaceConfig);

		TRect rect(0,0,320,240);

		TInt err = surfaceConfig.SetExtent(rect);

		if (err == KErrNone)

		    {

		      err =iWindowManager->SetBackgroundSurface(surfaceConfig, ETrue);

		    }

		if(err)

		    {

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

		    return EFalse;

		    }

		}

	else if(error)

	    {

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

	    return EFalse;

	    }

	return ETrue;

	}

TBool ROmxScriptTest::MosSetDroppedFrameEvent(const TDesC8& aComp, const TDesC8& aAction)

	{

	OMX_COMPONENTTYPE* component = ComponentByName(aComp);

	if(!component)

		{

		return EFalse;

		}

	TBuf8<80> extension;

	if (aAction == _L8("invalidextension"))

		{

		extension.Append(_L8("OMX.NOKIA.INDEX.PARAM.INVALIDEXTENSION"));

		}

	else

		{

		extension.Append(_L8("OMX.NOKIA.INDEX.PARAM.DROPPEDFRAMEEVENT"));

		}

	OMX_INDEXTYPE indexType = OMX_IndexMax;

	OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType);

	if (aAction == _L8("invalidextension"))

		{

		if (error != OMX_ErrorUnsupportedIndex)

			{

			ERR_PRINTF2(_L("GetExtensionIndex with invalid extension incorrectly returned error 0x%X"), error);

			StopTest(EFail);

			return EFalse;

			}

		return ETrue;

		}

	if (error != OMX_ErrorNone)

		{

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

		return EFalse;