/*

* 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

		{

		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("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("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);

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

			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("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("SetVideoPortDef"))

			{

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

			TPtrC8 comp;

			TInt port;

			ParseCompPortL(compPort, comp, port);

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

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

			OMX_COLOR_FORMATTYPE colorFormat = OMX_COLOR_FormatMax;

			OMX_COLOR_FORMATTYPE* colorFormatPtr = NULL;

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

			if(colorFormatDes)

				{

				colorFormat = ParseOmxColorFormatL(*colorFormatDes);

				colorFormatPtr = &colorFormat;

				}

			OMX_VIDEO_CODINGTYPE codingType = OMX_VIDEO_CodingMax;

			OMX_VIDEO_CODINGTYPE* codingTypePtr = NULL;

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

			if(codingDes)

				{

				codingType = ParseOmxVideoCodingL(*codingDes);

				codingTypePtr = &codingType;

				}

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

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

		    OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;

			if (expectedError)

			    {

			    expectedErrorInt = ParseOmxErrorCode(*expectedError);

			    }

#ifdef HREF_ED_WITHOUT_FLOATING_POINT

			CheckForAbortL(iCallback.MosSetVideoPortDefL(comp, port, width, height, colorFormatPtr, codingTypePtr, stride, 0, expectedErrorInt));

#else

			TReal32 fps = ParseOptionalRealL(aAttributes, _L8("fps"), -1);

			CheckForAbortL(iCallback.MosSetVideoPortDefL(comp, port, width, height, colorFormatPtr, codingTypePtr, stride, fps, expectedErrorInt));

#endif //HREF_ED_WITHOUT_FLOATING_POINT

			}

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

			{

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

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

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

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

			TLex8 lex(nData1Des);

			TUint32 nData1;

			OMX_EVENTTYPE event = ParseOmxEventL(eventDes);

			switch(event)

				{

			// ParseOmxErrorL and ParseOmxCommandL will also parse literal integers

			case OMX_EventError:

				nData1 = static_cast<TUint32>(ParseOmxErrorL(nData1Des));

				break;

			case OMX_EventCmdComplete:

				nData1 = static_cast<TUint32>(ParseOmxCommandL(nData1Des));

				break;

			default:

				nData1 = ParseUint32L(nData1Des);

				break;

				}

			TUint32 nData2 = ParseUint32L(nData2Des);

			CheckForAbortL(iCallback.MosExpectEventL(comp, event, nData1, nData2));

			}

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

			{

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

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

			OMX_STATETYPE state = ParseOmxStateL(stateDes);

			CheckForAbortL(iCallback.MosCheckStateL(comp, state));

			}

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

			{

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

			TPtrC8 comp;

			TInt port;

			ParseCompPortL(compPort, comp, port);

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

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

			TInt width;

			TInt height;

			TLex8 lex(widthDes);

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

			lex = TLex8(heightDes);