/*

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

#include <xml/parser.h>

#include <utf.h>

#include "parsemap.h"

//#include <openmax/il/khronos/v1_x/OMX_CoreExt_Nokia.h>

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

// These definitions are from /epoc32/include/osi/video/VFM_Types.h

// We can't include the header itself because it does not obey symbian foundation

// rules on header file inclusion paths.

const TInt OMX_COLOR_FormatSTYUV420PackedSemiPlanarMB = (OMX_COLOR_FormatMax-1);

const TInt OMX_COLOR_FormatSTYUV422PackedSemiPlanarMB = (OMX_COLOR_FormatMax-2);

#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

using Xml::CParser;

COmxScriptParser* COmxScriptParser::NewL(RFs& aFs, const TDesC& aFilename, MOmxScriptIf& aCallback)

	{

	COmxScriptParser* self = new(ELeave) COmxScriptParser(aFs, aCallback);

	CleanupStack::PushL(self);

	self->ConstructL(aFilename);

	CleanupStack::Pop(self);

	return self;

	}

COmxScriptParser::~COmxScriptParser()

	{

	iFilename.Close();

	}

COmxScriptParser::COmxScriptParser(RFs& aFs, MOmxScriptIf& aCallback):

iFs(aFs), iCallback(aCallback)

	{

	}

void COmxScriptParser::ConstructL(const TDesC& aFilename)

	{

	User::LeaveIfError(iFilename.Create(aFilename.Length()));

	iFilename = aFilename;

	}

TBool COmxScriptParser::RunScriptL(const TDesC& aSectionName)

	{

	CParser* parser = CParser::NewLC(_L8("text/xml"), *this);

	iSectionName = &aSectionName;

	iInTest = EFalse;

	iFoundTest = EFalse;

	iCallbackAborted = EFalse;

	TInt error = KErrNone;

	TInt size = iFilename.Length();

	TRAP(error, Xml::ParseL(*parser, iFs, iFilename));

	CleanupStack::PopAndDestroy(parser);

	if(error == KErrAbort && iCallbackAborted)

		{		

		return EFalse;

		}

	User::LeaveIfError(error);

	if(!iFoundTest)

		{

		User::Leave(KErrNotFound);

		}

	return ETrue;

	}

void COmxScriptParser::OnStartDocumentL(const RDocumentParameters& /*aDocParam*/, TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnEndDocumentL(TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnContentL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnStartPrefixMappingL(const RString& /*aPrefix*/, const RString& /*aUri*/, 

		TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnEndPrefixMappingL(const RString& /*aPrefix*/, TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnIgnorableWhiteSpaceL(const TDesC8& /*aBytes*/, TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnSkippedEntityL(const RString& /*aName*/, TInt /*aErrorCode*/)

	{

	User::Invariant();

	}

void COmxScriptParser::OnProcessingInstructionL(const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, 

		TInt /*aErrorCode*/)

	{

	// do nothing

	}

void COmxScriptParser::OnError(TInt aErrorCode)

	{

	(void) aErrorCode;	// avoid unused parameter warning. useful to give parameter a name when debugging. 

	User::Invariant();

	}

TAny* COmxScriptParser::GetExtendedInterface(const TInt32 /*aUid*/)

	{

	return 0;

	}

void COmxScriptParser::OnStartElementL(const RTagInfo& aElement,

		                               const RAttributeArray& aAttributes, 

		                               TInt /*aErrorCode*/)

	{

	const TDesC8& elemName = aElement.LocalName().DesC();

	if(!iInTest)

		{

		if(elemName == _L8("Test"))

			{

			const TDesC8* testName8Bit = FindAttribute(aAttributes, _L8("name"));

			if(testName8Bit)

				{

				HBufC* testName = HBufC::NewLC(testName8Bit->Length());

				testName->Des().Copy(*testName8Bit);

				if(*testName == *iSectionName)

					{

					__ASSERT_ALWAYS(!iFoundTest, User::Invariant());

					iFoundTest = ETrue;

					iInTest = ETrue;

					}

				CleanupStack::PopAndDestroy(testName);

				}

			}

		}

	else

		{

			// to trace out which command has been passed from xml file

			TBuf<32> elemNameCopy;

			elemNameCopy.Copy(elemName);

			TBuf<44> message;

			message.Append(_L("command: "));

			message.Append(elemNameCopy);

			iCallback.MosParseError(message);

		if(elemName == _L8("LoadComponent"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			const TDesC8& name = FindAttributeL(aAttributes, _L8("name"));

			TBool baseEnabled = EFalse;

			const TDesC8* baseImpl = NULL;

			const TDesC8* baseEnabledAttr = FindAttribute(aAttributes, _L8("baseprofilesupport"));

			if (baseEnabledAttr != NULL)

			    {

			    baseEnabled = ParseBoolean(*baseEnabledAttr);

			    baseImpl = &(FindAttributeL(aAttributes, _L8("baseprofileimpl")));

			    }

			TBool loadInCoreServerThread = EFalse;

			const TDesC8* loadInCoreServerThreadAttr = FindAttribute(aAttributes, _L8("loadincoreserverthread"));

			if(loadInCoreServerThreadAttr != NULL)

			    {

			    loadInCoreServerThread = ParseBoolean(*loadInCoreServerThreadAttr);

			    }

			CheckForAbortL(iCallback.MosLoadComponentL(comp, name, baseEnabled, baseImpl, loadInCoreServerThread));

			}

		else if(elemName == _L8("LogAllEvents")) //utility

		    {

		    CheckForAbortL(iCallback.MosLogAllEventsL());

		    }

		else if(elemName == _L8("SetSensorModeType")) //camera

            {

            const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));

            TPtrC8 comp;

            TInt port = 0;

            ParseCompPortL(compPort, comp, port);

            TInt frameRate = ParseOptionalIntL(aAttributes, _L8("frameRate"), -1);

            const TDesC8& oneShotStr = FindAttributeL(aAttributes, _L8("oneShot"));

            TBool oneShot = ParseBooleanL(oneShotStr);

            TInt width = ParseOptionalIntL(aAttributes, _L8("width"), -1);

            TInt height = ParseOptionalIntL(aAttributes, _L8("height"), -1);

            CheckForAbortL(iCallback.MosSetSensorModeTypeL(comp, port, frameRate, oneShot, width, height));

            }

		else if(elemName == _L8("DeleteFile")) //utility

            {

			const TDesC8& fileName8 = FindAttributeL(aAttributes, _L8("filename"));

			HBufC* fileName = HBufC::NewLC(fileName8.Length() + 1);

			fileName->Des().Copy(fileName8);

			fileName->Des().ZeroTerminate();

			TBool fileMustExist = EFalse;

			const TDesC8* fileMustExistAttr = FindAttribute(aAttributes, _L8("fileMustExist"));

			if (fileMustExistAttr != NULL)

				{

				fileMustExist = ParseBoolean(*fileMustExistAttr);

				}

			CheckForAbortL(iCallback.MosDeleteFileL(*fileName, fileMustExist));

			CleanupStack::PopAndDestroy(fileName);

			}

		else if(elemName == _L8("SetupTunnel"))

			{

			const TDesC8& source = FindAttributeL(aAttributes, _L8("output"));

			const TDesC8& sink = FindAttributeL(aAttributes, _L8("input"));

			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));

		    OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			if (expectedError)

			    {

			    expectedErrorInt = ParseOmxErrorCode(*expectedError);

			    }

			TPtrC8 sourceComp;

			TPtrC8 sinkComp;

			TInt sourcePort = 0;

			TInt sinkPort = 0;

			_LIT8(KTemp, "");

			const TDesC8& temp = KTemp;

			if (source.Compare(temp))

			    {

			    ParseCompPortL(source, sourceComp, sourcePort);

			    }

			if(sink.Compare(temp))

			    {

			    ParseCompPortL(sink, sinkComp, sinkPort);

			    }			

			CheckForAbortL(iCallback.MosSetupTunnel(sourceComp, sourcePort, sinkComp, sinkPort, expectedErrorInt));

			}

		else if (elemName == _L8("SetupNonTunnel"))

			{

			const TDesC8& source = FindAttributeL(aAttributes, _L8("output"));

			const TDesC8& sink = FindAttributeL(aAttributes, _L8("input"));

			const TDesC8& supplierDes = FindAttributeL(aAttributes, _L8("supplier"));

			TPtrC8 sourceComp;

			TPtrC8 sinkComp;

			TInt sourcePort;

			TInt sinkPort;

			ParseCompPortL(source, sourceComp, sourcePort);

			ParseCompPortL(sink, sinkComp, sinkPort);

			OMX_BUFFERSUPPLIERTYPE supplier = ParseOmxSupplierL(supplierDes, ETrue);

			CheckForAbortL(iCallback.MosSetupNonTunnel(sourceComp, sourcePort, sinkComp, sinkPort, supplier));

			}

		else if (elemName == _L8("SetBufferForPort"))

		    {

		    const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));

            TPtrC8 comp;

            TInt port;

            ParseCompPortL(compPort, comp, port);

            const TDesC8& filename8Bit = FindAttributeL(aAttributes, _L8("filename"));

            HBufC* filename = HBufC::NewLC(filename8Bit.Length());

            filename->Des().Copy(filename8Bit);

            TInt headerlength = KErrNone;

            headerlength = ParseOptionalIntL(aAttributes, _L8("headerlength"), -1);

            const TDesC8* supplierDes = FindAttribute(aAttributes, _L8("supplier"));

            OMX_BUFFERSUPPLIERTYPE supplier = OMX_BufferSupplyUnspecified;

            if(supplierDes)

                {

                supplier = ParseOmxSupplierL(*supplierDes);

                }

            CheckForAbortL(iCallback.MosSetupBufferForPortL(comp,port,*filename,headerlength,supplier));

            CleanupStack::PopAndDestroy(filename);

		    }

		else if(elemName == _L8("SetWindow"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			CheckForAbortL(iCallback.MosSetWindowL(comp));

			}

		else if(elemName == _L8("AllTransition"))

			{

			const TDesC8& stateDes = FindAttributeL(aAttributes, _L8("state"));

			OMX_STATETYPE state = ParseOmxStateL(stateDes);

			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));

			OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			const TDesC8* orderDes = FindAttribute(aAttributes, _L8("order"));

			TTransitionOrder order = ELoadOrder;

			if(orderDes != NULL)

				{

				if(*orderDes == _L8("auto"))

					{

					order = EAutoOrder;

					}

				else

					{

					User::Leave(KErrArgument);

					}

				}

			if (expectedError)

				{

				expectedErrorInt = ParseOmxErrorCode(*expectedError);

				}

			CheckForAbortL(iCallback.MosAllTransitionL(state, expectedErrorInt, order));

			}

		else if(elemName == _L8("Transition"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			const TDesC8& stateDes = FindAttributeL(aAttributes, _L8("state"));

			TBool async_behaviour = ParseOptionalBooleanL(aAttributes, _L8("async"), EFalse);

			OMX_STATETYPE state = ParseOmxStateL(stateDes);

			CheckForAbortL(iCallback.MosTransition(comp, state, async_behaviour));

			}

		else if(elemName == _L8("FailingTransition"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			const TDesC8& stateDes = FindAttributeL(aAttributes, _L8("state"));

			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectederr"));

			OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			if (expectedError)

			    {

			    expectedErrorInt = ParseOmxErrorCode(*expectedError);

			    }

			OMX_STATETYPE state = ParseOmxStateL(stateDes);

			CheckForAbortL(iCallback.MosFailingTransition(comp, state, expectedErrorInt));

			}

		else if(elemName == _L8("WaitEOS"))

			{

			const TDesC8* comp = FindAttribute(aAttributes, _L8("comp"));

			if(comp == NULL)

				{

				CheckForAbortL(iCallback.MosWaitEOS());

				}

			else

				{

				CheckForAbortL(iCallback.MosWaitEOS(*comp));

				}

			}

		else if(elemName == _L8("Wait"))

			{

			const TDesC8& delay = FindAttributeL(aAttributes, _L8("delaytime"));

			TLex8 lex(delay);

			TInt delayInt;

			User::LeaveIfError(lex.Val(delayInt));			

			CheckForAbortL(iCallback.MosWaitL(delayInt));

			}

		else if(elemName == _L8("WaitForAllEvents"))

			{

			CheckForAbortL(iCallback.MosWaitForAllEventsL());

			}

		else if(elemName == _L8("SetFilename"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			const TDesC8& filename8Bit = FindAttributeL(aAttributes, _L8("filename"));

			HBufC* filename = HBufC::NewLC(filename8Bit.Length());

			filename->Des().Copy(filename8Bit);

			CheckForAbortL(iCallback.MosSetFilename(comp, *filename));

			CleanupStack::PopAndDestroy(filename);

			}

	   else if(elemName == _L8("SetFilename_Bellagio"))

        {

		   const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

           const TDesC8& filename8Bit = FindAttributeL(aAttributes, _L8("filename"));

           char filepath[100];

           int i;

           for(i=0;i<filename8Bit.Length();i++)

            filepath[i]=filename8Bit.Ptr()[i];

            filepath[i]='\0';

           CheckForAbortL(iCallback.MosSetFilename_bellagio(comp, filepath));

          //CleanupStack::PopAndDestroy(filename8Bit);

         }

		 else if(elemName == _L8("SetDroppedFrameEvent"))

		    {

		    const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

		    const TDesC8& action = FindAttributeL(aAttributes, _L8("action"));

		    CheckForAbortL(iCallback.MosSetDroppedFrameEvent(comp, action));

		    }

		else if(elemName == _L8("SetBadFilename"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));	

			CheckForAbortL(iCallback.MosSetBadFilename(comp));

			}

		else if(elemName == _L8("GetFilename"))

			{

			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

			const TDesC8& filename8Bit = FindAttributeL(aAttributes, _L8("filename"));

			HBufC* filename = HBufC::NewLC(filename8Bit.Length());

			filename->Des().Copy(filename8Bit);

			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));

			OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			if (expectedError)

			    {

			    expectedErrorInt = ParseOmxErrorCode(*expectedError);

			    }

			CheckForAbortL(iCallback.MosGetFilename(comp, *filename, expectedErrorInt));

			CleanupStack::PopAndDestroy(filename);

			}

		else if(elemName == _L8("SetBufferCount"))

			{

			const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));

			const TDesC8& count = FindAttributeL(aAttributes, _L8("count"));

			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));

		    OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			if (expectedError)

			    {

			    expectedErrorInt = ParseOmxErrorCode(*expectedError);

			    }

			TPtrC8 comp;

			TInt portIndex = 0;

			ParseCompPortL(port, comp, portIndex);

			TLex8 lex(count);

			TInt countInt;

			User::LeaveIfError(lex.Val(countInt));

			CheckForAbortL(iCallback.MosSetBufferCount(comp, portIndex, countInt, expectedErrorInt));

			}

		else if(elemName == _L8("CompareFiles"))

			{

			const TDesC8& file18Bit = FindAttributeL(aAttributes, _L8("file1"));

			const TDesC8& file28Bit = FindAttributeL(aAttributes, _L8("file2"));

			TBuf<64> file1, file2;

			file1.Copy(file18Bit);

			file2.Copy(file28Bit);

			CheckForAbortL(iCallback.MosCompareFilesL(file1, file2));

			}

        else if(elemName == _L8("FilterAndCompareFiles"))

            {

            const TDesC8& file18Bit = FindAttributeL(aAttributes, _L8("file1"));

            const TDesC8& file28Bit = FindAttributeL(aAttributes, _L8("file2"));

            TBuf<64> file1, file2;

            file1.Copy(file18Bit);

            file2.Copy(file28Bit);

            const TDesC8* f1filter1 = FindAttribute(aAttributes, _L8("file1filter1"));

            const TDesC8* f1filter2 = FindAttribute(aAttributes, _L8("file1filter2"));

            const TDesC8* f1filter3 = FindAttribute(aAttributes, _L8("file1filter3"));

            const TDesC8* f2filter1 = FindAttribute(aAttributes, _L8("file2filter1"));

            const TDesC8* f2filter2 = FindAttribute(aAttributes, _L8("file2filter2"));

            const TDesC8* f2filter3 = FindAttribute(aAttributes, _L8("file2filter3"));

            CheckForAbortL(

                    iCallback.MosFilterAndCompareFilesL(file1, f1filter1 ? *f1filter1 : KNullDesC8, f1filter2 ? *f1filter2 : KNullDesC8, f1filter3 ? *f1filter3 : KNullDesC8,

                                                file2, f2filter1 ? *f2filter1 : KNullDesC8, f2filter2 ? *f2filter2 : KNullDesC8, f2filter3 ? *f2filter3 : KNullDesC8)

                );

            }		

		else if(elemName == _L8("BufferSupplierOverride"))

			{

			const TDesC8& output = FindAttributeL(aAttributes, _L8("output"));

			const TDesC8& input = FindAttributeL(aAttributes, _L8("input"));

			const TDesC8& supplierDes = FindAttributeL(aAttributes, _L8("supplier"));

			const TDesC8* expectedError1 = FindAttribute(aAttributes, _L8("expectedomxerr1"));

		    OMX_ERRORTYPE expectedError1Int = OMX_ErrorNone;

			if (expectedError1)

			    {

			    expectedError1Int = ParseOmxErrorCode(*expectedError1);

			    }

			const TDesC8* expectedError2 = FindAttribute(aAttributes, _L8("expectedomxerr2"));

			OMX_ERRORTYPE expectedError2Int = OMX_ErrorNone;

			if (expectedError2)

			    {

			    expectedError2Int = ParseOmxErrorCode(*expectedError2);

			    }

			TPtrC8 sourceComp;

			TPtrC8 sinkComp;

			TInt sourcePort = 0;

			TInt sinkPort = 0;

			ParseCompPortL(output, sourceComp, sourcePort);

			ParseCompPortL(input, sinkComp, sinkPort);

			OMX_BUFFERSUPPLIERTYPE supplier = ParseOmxSupplierL(supplierDes);

			CheckForAbortL(iCallback.MosBufferSupplierOverrideL(sourceComp, sourcePort, sinkComp, sinkPort, supplier, expectedError1Int, expectedError2Int));

			}

        else if(elemName == _L8("SetCameraOneShot"))

            {

            //TODO DL

            const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

            TInt isOneShot = ParseOptionalIntL(aAttributes, _L8("isoneshot"), 1);

            OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

            CheckForAbortL(iCallback.MosSetCameraOneShotL(comp, isOneShot, expectedErrorInt));

            }

        else if(elemName == _L8("SetCameraCapture"))

            {

            //TODO DL

            const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));

            TInt isCapturing = ParseOptionalIntL(aAttributes, _L8("iscapturing"), 1);

            const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));

            TPtrC8 comp1;

            TInt portIndex = 0;

            ParseCompPortL(port, comp1, portIndex);