diff -r c1e808730d6c -r eedf2dcd43c6 omxil/xmltestharness/xmlclient/src/omxscriptparser.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/omxil/xmltestharness/xmlclient/src/omxscriptparser.cpp	Fri May 07 16:25:23 2010 +0100
@@ -0,0 +1,1951 @@
+/*
+* 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);
+			User::LeaveIfError(lex.Val(height));
+			const TDesC8& codingDes = FindAttributeL(aAttributes, _L8("coding"));
+			OMX_VIDEO_CODINGTYPE coding = ParseOmxVideoCodingL(codingDes);
+			const TDesC8& colorFormatDes = FindAttributeL(aAttributes, _L8("colorFormat"));
+			OMX_COLOR_FORMATTYPE colorFormat = ParseOmxColorFormatL(colorFormatDes);
+			CheckForAbortL(iCallback.MosCheckVideoPortDefL(comp, port, width, height, coding, colorFormat));
+			}
+		else if(elemName == _L8("CheckMetaData"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			const TDesC8& scopeDes = FindAttributeL(aAttributes, _L8("scope"));			
+			OMX_METADATASCOPETYPE scope = ParseOmxScopeTypeL(scopeDes);
+			const TDesC8& atomType = FindAttributeL(aAttributes, _L8("atomType"));						
+			const TDesC8& atomIndexDes = FindAttributeL(aAttributes, _L8("atomIndex"));
+			TLex8 lex(atomIndexDes);
+			TUint32 atomIndex = ParseUint32L(atomIndexDes);				
+			const TDesC8& data = FindAttributeL(aAttributes, _L8("data"));
+			CheckForAbortL(iCallback.MosCheckMetaDataL(comp, port, scope, atomType, atomIndex, data));			
+			}
+		else if(elemName == _L8("GetParameterUnknownType"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			const TDesC8& scopeDes = FindAttributeL(aAttributes, _L8("scope"));			
+			OMX_METADATASCOPETYPE scope = ParseOmxScopeTypeL(scopeDes);
+			const TDesC8& atomType = FindAttributeL(aAttributes, _L8("atomType"));						
+			const TDesC8& atomIndexDes = FindAttributeL(aAttributes, _L8("atomIndex"));
+			TLex8 lex(atomIndexDes);
+			TUint32 atomIndex = ParseUint32L(atomIndexDes);				
+			const TDesC8& data = FindAttributeL(aAttributes, _L8("data"));
+			CheckForAbortL(iCallback.MosGetParameterUnknownIndexTypeL(comp, port, scope, atomType, atomIndex, data));			
+			}		
+		else if(elemName == _L8("SetParameterUnknownType"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			const TDesC8& scopeDes = FindAttributeL(aAttributes, _L8("scope"));			
+			OMX_METADATASCOPETYPE scope = ParseOmxScopeTypeL(scopeDes);
+			const TDesC8& atomType = FindAttributeL(aAttributes, _L8("atomType"));						
+			const TDesC8& atomIndexDes = FindAttributeL(aAttributes, _L8("atomIndex"));
+			TLex8 lex(atomIndexDes);
+			TUint32 atomIndex = ParseUint32L(atomIndexDes);				
+			const TDesC8& data = FindAttributeL(aAttributes, _L8("data"));
+			CheckForAbortL(iCallback.MosSetParameterUnknownIndexTypeL(comp, port, scope, atomType, atomIndex, data));			
+			}						
+		else if(elemName == _L8("DisablePort"))
+			{
+			const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt portIndex;
+			ParseCompPortL(port, comp, portIndex);
+			CheckForAbortL(iCallback.MosDisablePort(comp, portIndex));
+			}
+		else if(elemName == _L8("EnablePort"))
+			{
+			const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt portIndex;
+			ParseCompPortL(port, comp, portIndex);
+			CheckForAbortL(iCallback.MosEnablePort(comp, portIndex));
+			}
+		else if(elemName == _L8("IgnoreEvent"))
+			{
+			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.MosIgnoreEventL(comp, event, nData1, nData2));
+			}
+		else if(elemName == _L8("SetAudioPortDef"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			OMX_AUDIO_CODINGTYPE codingType = OMX_AUDIO_CodingMax;
+			OMX_AUDIO_CODINGTYPE* codingTypePtr = NULL;
+			const TDesC8* codingDes = FindAttribute(aAttributes, _L8("codingType"));
+			if(codingDes)
+				{
+				codingType = ParseOmxAudioCodingL(*codingDes);
+				codingTypePtr = &codingType;
+				}
+			CheckForAbortL(iCallback.MosSetAudioPortDefL(comp, port, codingTypePtr));
+			}
+		else if(elemName == _L8("SetAACProfile"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			// TODO allow some values to be unspecified (preserved from existing settings)
+			TInt channels = ParseUint32L(FindAttributeL(aAttributes, _L8("channels")));
+			TInt samplingrate = ParseUint32L(FindAttributeL(aAttributes, _L8("samplingrate")));
+			TInt bitrate = ParseUint32L(FindAttributeL(aAttributes, _L8("bitrate")));
+			TInt audioBandwidth = ParseUint32L(FindAttributeL(aAttributes, _L8("bandwidth")));
+			TInt frameLength = ParseUint32L(FindAttributeL(aAttributes, _L8("frameLength")));
+			// TODO allow multiple flags in disjunctive form
+			TInt aacTools = ParseUint32L(FindAttributeL(aAttributes, _L8("aacTools")));
+			TInt aacerTools = ParseUint32L(FindAttributeL(aAttributes, _L8("aacerTools")));
+			OMX_AUDIO_AACPROFILETYPE profile = ParseOmxAACProfileL(FindAttributeL(aAttributes, _L8("profile")));
+			OMX_AUDIO_AACSTREAMFORMATTYPE streamFormat = ParseOmxAACStreamFormatL(FindAttributeL(aAttributes, _L8("streamFormat")));
+			OMX_AUDIO_CHANNELMODETYPE channelMode = ParseOmxAudioChannelModeL(FindAttributeL(aAttributes, _L8("channelMode")));
+			
+			CheckForAbortL(iCallback.MosSetAACProfileL(comp, port, channels, samplingrate, bitrate, audioBandwidth, frameLength, aacTools, aacerTools, profile, streamFormat, channelMode));
+			}
+		else if(elemName == _L8("SetPcmAudioPortDef"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			TInt channels = ParseOptionalIntL(aAttributes, _L8("channels"), -1);
+			TInt samplingrate = ParseOptionalIntL(aAttributes, _L8("samplingrate"), -1);
+			TInt bitspersample = ParseOptionalIntL(aAttributes, _L8("bitspersample"), -1);
+			OMX_NUMERICALDATATYPE numData = OMX_NumercialDataMax;
+ 			const TDesC8* des = FindAttribute(aAttributes, _L8("numericalData"));
+ 			if(des != NULL)
+ 				{
+ 				numData = ParseNumericalDataL(*des);
+ 				}
+			else
+			    {
+			    numData = static_cast<OMX_NUMERICALDATATYPE>(-1);
+			    }
+ 			OMX_ENDIANTYPE endian = OMX_EndianMax;
+ 			des = FindAttribute(aAttributes, _L8("endian"));
+ 			if(des != NULL)
+ 				{
+ 				endian = ParseEndianL(*des);
+			    }
+			else
+			   {
+			   endian = static_cast<OMX_ENDIANTYPE>(-1);
+ 				}
+ 			OMX_BOOL* interleaved = NULL;
+ 			OMX_BOOL interleavedData;
+ 			des = FindAttribute(aAttributes, _L8("interleaved"));
+ 			if(des != NULL)
+ 				{
+ 				interleavedData = ParseBoolL(*des);
+ 				interleaved = &interleavedData;
+ 				}
+            const TDesC8* encoding = FindAttribute(aAttributes, _L8("encoding"));
+ 			CheckForAbortL(iCallback.MosSetPcmAudioPortDefL(comp, port, channels, samplingrate, bitspersample, numData, endian, interleaved, encoding));
+			}
+		else if(elemName == _L8("SetAudioMute"))
+		    {
+		    const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+		    TPtrC8 comp;
+		    TInt port;
+		    ParseCompPortL(compPort, comp, port);
+		    TBool mute = EFalse;
+		    const TDesC8* muteAttr = FindAttribute(aAttributes, _L8("mute"));
+		    if (muteAttr != NULL)
+		        {
+		        mute = ParseBooleanL(*muteAttr);
+		        }
+		    else
+		        {
+		        User::Leave(KErrArgument);
+		        }
+		    CheckForAbortL(iCallback.MosSetConfigAudioMuteL(comp, port, mute));
+		    }
+		else if(elemName == _L8("CheckAudioMute"))
+		    {
+		    const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+		    TPtrC8 comp;
+		    TInt port;
+		    ParseCompPortL(compPort, comp, port);
+		    TBool mute = EFalse;
+		    const TDesC8* muteAttr = FindAttribute(aAttributes, _L8("mute"));
+		    if (muteAttr != NULL)
+		        {
+		        mute = ParseBooleanL(*muteAttr);
+		        }
+		    else
+		        {
+		        User::Leave(KErrArgument);
+		        }
+		    CheckForAbortL(iCallback.MosCheckConfigAudioMuteL(comp, port, mute));
+		    }   
+		else if(elemName == _L8("SetAudioVolume"))
+            {
+            const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt port;
+            ParseCompPortL(compPort, comp, port);
+            TBool linear = EFalse;
+            const TDesC8* linearScaleAttr = FindAttribute(aAttributes, _L8("linearscale"));
+            if (linearScaleAttr != NULL)
+                {
+                linear = ParseBooleanL(*linearScaleAttr);
+                }
+            TInt minVolume = ParseOptionalIntL(aAttributes, _L8("min"), -1);
+            TInt maxVolume = ParseOptionalIntL(aAttributes, _L8("max"), -1);
+            TInt volume = ParseOptionalIntL(aAttributes, _L8("volume"), -1);
+            const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));
+            OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;
+            if (expectedError)
+                {
+                expectedErrorInt = ParseOmxErrorCode(*expectedError);
+                }
+            
+            CheckForAbortL(iCallback.MosSetConfigAudioVolumeL(comp, port, linear, minVolume, maxVolume, volume, expectedErrorInt));
+            }
+		else if(elemName == _L8("CheckAudioVolume"))
+		    {
+		    const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+		    TPtrC8 comp;
+		    TInt port;
+		    ParseCompPortL(compPort, comp, port);
+		    TBool linear = EFalse;
+		    const TDesC8* linearScaleAttr = FindAttribute(aAttributes, _L8("linearscale"));
+		    if (linearScaleAttr != NULL)
+		        {
+		        linear = ParseBooleanL(*linearScaleAttr);
+		        }
+		    TInt minVolume = ParseOptionalIntL(aAttributes, _L8("min"), -1);
+		    TInt maxVolume = ParseOptionalIntL(aAttributes, _L8("max"), -1);
+		    TInt volume = ParseOptionalIntL(aAttributes, _L8("volume"), -1);
+		    CheckForAbortL(iCallback.MosCheckConfigAudioVolumeL(comp, port, linear, minVolume, maxVolume, volume));
+		    }
+		else if(elemName == _L8("SetAacAudioPortDef"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			TInt channels = ParseOptionalIntL(aAttributes, _L8("channels"), -1);
+			TInt samplingRate = ParseOptionalIntL(aAttributes, _L8("samplingrate"), -1);
+			TInt bitRate = ParseOptionalIntL(aAttributes, _L8("bitrate"), -1);
+			TInt audioBandwidth = ParseOptionalIntL(aAttributes, _L8("audiobandwidth"), -1);
+			TInt frameLength = ParseOptionalIntL(aAttributes, _L8("framelength"), -1);
+			TInt aacTools = ParseOptionalIntL(aAttributes, _L8("aactools"), -1);
+			TInt aacErTools = ParseOptionalIntL(aAttributes, _L8("aacertools"), -1);
+			
+			OMX_AUDIO_AACPROFILETYPE profile;
+			const TDesC8* attbval = FindAttribute(aAttributes, _L8("profile"));
+			            if ( NULL != attbval )
+			                {
+			                profile = ParseOmxAACProfileL( *attbval );
+			                }
+			            else
+			                {
+			                profile = static_cast <OMX_AUDIO_AACPROFILETYPE>(-1);
+			                }
+			OMX_AUDIO_AACSTREAMFORMATTYPE streamFormat = ParseOmxAACStreamFormatL(FindAttributeL(aAttributes, _L8("streamFormat")));
+			OMX_AUDIO_CHANNELMODETYPE channelMode = ParseOmxAudioChannelModeL(FindAttributeL(aAttributes, _L8("channelMode")));
+
+			CheckForAbortL(iCallback.MosSetAacAudioPortDefL(comp, port, channels, samplingRate, bitRate, audioBandwidth, frameLength, aacTools, aacErTools, profile, streamFormat, channelMode));
+			}
+		else if(elemName == _L8("SetClockReference"))
+			{
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+			const TDesC8& refDes = FindAttributeL(aAttributes, _L8("ref"));
+			OMX_TIME_REFCLOCKTYPE refClockType = ParseOmxRefClockTypeL(refDes);
+			CheckForAbortL(iCallback.MosSetRefClockTypeL(comp, refClockType));
+			}
+		else if(elemName == _L8("SetClockState"))
+			{
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+			const TDesC8& stateDes = FindAttributeL(aAttributes, _L8("state"));
+			OMX_TIME_CLOCKSTATE clockState = ParseOmxClockStateL(stateDes);
+			const TDesC8& maskDes = FindAttributeL(aAttributes, _L8("mask"));
+			TUint32 mask = ParseUint32L(maskDes);
+			TInt startTime = ParseOptionalIntL(aAttributes, _L8("start"), 0);
+			TInt offset = ParseOptionalIntL(aAttributes, _L8("offset"), 0);
+			CheckForAbortL(iCallback.MosSetClockStateL(comp, clockState, startTime, offset, mask));
+			}
+		else if(elemName == _L8("SetVideoFitMode"))
+			{
+			const TDesC8& modeDes = FindAttributeL(aAttributes, _L8("mode"));
+			TVideoFitMode mode = ParseVideoFitModeL(modeDes);
+			CheckForAbortL(iCallback.MosSetVideoFitModeL(mode));
+			}
+		else if(elemName == _L8("SetActiveStream"))
+			{
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+			const TDesC8& id = FindAttributeL(aAttributes, _L8("id"));
+			TLex8 lex(id);
+			TInt streamId;
+			User::LeaveIfError(lex.Val(streamId));
+			CheckForAbortL(iCallback.MosSetActiveStream(comp, streamId));
+			}
+		else if(elemName == _L8("GetActiveStream"))
+			{
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+			const TDesC8& id = FindAttributeL(aAttributes, _L8("id"));
+			TLex8 lex(id);
+			TInt streamId;
+			User::LeaveIfError(lex.Val(streamId));
+			CheckForAbortL(iCallback.MosGetActiveStream(comp, streamId));
+			}
+		else if(elemName == _L8("SetVideoEncQuant"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+		
+			TInt qpb = ParseOptionalIntL(aAttributes, _L8("qpb"), -1);
+			
+			CheckForAbortL(iCallback.MosSetVideoEncQuantL(comp, port,qpb));
+			}
+		else if(elemName == _L8("SetVideoEncMotionVect"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			
+			TInt accuracy = ParseOptionalIntL(aAttributes, _L8("accuracy"), -1);			
+			TInt sxsearchrange = ParseOptionalIntL(aAttributes, _L8("sxsearchrange"), -1);
+			TInt sysearchrange = ParseOptionalIntL(aAttributes, _L8("sysearchrange"), -1);
+			
+			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));
+		    OMX_ERRORTYPE expectedOmxError = OMX_ErrorNone;
+			if (expectedError)
+			    {
+			    expectedOmxError = ParseOmxErrorCode(*expectedError);
+			    }
+			    
+			CheckForAbortL(iCallback.MosSetVideoEncMotionVectL(comp, port, accuracy, sxsearchrange, sysearchrange, expectedOmxError));
+			}
+		else if(elemName == _L8("SetVideoEncMpeg4Type"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			const TDesC8* mpeg4Profile = FindAttribute(aAttributes, _L8("mpeg4profile"));
+			OMX_VIDEO_MPEG4PROFILETYPE profile = OMX_VIDEO_MPEG4ProfileMax;
+			if (mpeg4Profile)
+				{
+				profile = ParseOmxMpeg4ProfileL(*mpeg4Profile);
+				}
+			
+			OMX_VIDEO_MPEG4LEVELTYPE level = OMX_VIDEO_MPEG4LevelMax;
+			const TDesC8* mpeg4Level = FindAttribute(aAttributes, _L8("mpeg4level"));
+			if (mpeg4Level)
+				{
+				level = ParseOmxMpeg4LevelL(*mpeg4Level);
+				}
+			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));
+		    OMX_ERRORTYPE expectedOmxError = OMX_ErrorNone;
+			if (expectedError)
+			    {
+			    expectedOmxError = ParseOmxErrorCode(*expectedError);
+			    }
+
+			CheckForAbortL(iCallback.MosSetVideoEncMpeg4TypeL(comp, port, profile, level, expectedOmxError));
+			}
+		else if(elemName == _L8("SetVideoEncBitRate"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+			ParseCompPortL(compPort, comp, port);
+			
+			const TDesC8* controlRate = FindAttribute(aAttributes, _L8("controlrate"));
+			OMX_VIDEO_CONTROLRATETYPE omxControlRate = OMX_Video_ControlRateMax;
+			if (controlRate)
+				{
+				omxControlRate = ParseOmxControlRateL(*controlRate);
+				}
+			
+			TInt targetBitrate = ParseOptionalIntL(aAttributes, _L8("targetbitrate"), -1);
+			
+			const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));
+		    OMX_ERRORTYPE expectedOmxError = OMX_ErrorNone;
+			if (expectedError)
+			    {
+			    expectedOmxError = ParseOmxErrorCode(*expectedError);
+			    }
+
+			CheckForAbortL(iCallback.MosSetVideoEncBitRateL(comp, port, omxControlRate, targetBitrate, expectedOmxError));
+			}
+		else if(elemName == _L8("GetExtensionIndex"))
+		    {
+		    const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+		    const TDesC8& paramName = FindAttributeL(aAttributes, _L8("parametername"));
+		    
+		    const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr"));
+		    OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone;
+			if (expectedError)
+			    {
+			    expectedErrorInt = ParseOmxErrorCode(*expectedError);
+			    }
+            
+            CheckForAbortL(iCallback.MosGetExtensionIndex(comp, paramName, expectedErrorInt));
+		    }
+		else if(elemName == _L8("SetCaptureModeType"))
+		    {
+		    const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+		    
+		    TPtrC8 comp;
+		    TInt port = 0;
+		    ParseCompPortL(compPort, comp, port);
+		    
+		    const TDesC8& continuousStr = FindAttributeL(aAttributes, _L8("continuous"));
+		    TBool continuous = ParseBooleanL(continuousStr);
+		    const TDesC8& framelimitedStr = FindAttributeL(aAttributes, _L8("framelimited"));
+		    TBool framelimited = ParseBooleanL(framelimitedStr);
+		    TInt framelimit = ParseOptionalIntL(aAttributes, _L8("framelimit"), -1);
+		    
+		    CheckForAbortL(iCallback.MosSetCaptureModeTypeL(comp, port, continuous, framelimited, framelimit));
+		    }
+
+		else if(elemName == _L8("GetTimeClockState"))
+		    {
+		    const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+		    const TDesC8& expectedState = FindAttributeL(aAttributes, _L8("expectedstate"));
+		    OMX_TIME_CLOCKSTATE expectedStateInt = ParseOmxClockStateL(expectedState);
+
+		    CheckForAbortL(iCallback.MosCheckTimeClockState(comp, expectedStateInt));
+		    }
+		else if(elemName == _L8("CheckMediaTime"))
+			{
+			const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt port;
+	
+			ParseCompPortL(compPort, comp, port);
+	
+			TBool moreThan = ETrue;
+			const TDesC8* mediatime = FindAttribute(aAttributes, _L8("mediatimelessthan"));
+			
+			if (mediatime)
+			  {
+			    moreThan = EFalse;
+			  }
+			else
+			  {
+			    const TDesC8& mTime = FindAttributeL(aAttributes, _L8("mediatimemorethan"));
+			    mediatime = &mTime;
+			  }
+
+
+			OMX_TICKS mediatimeTick;
+			TLex8 lex(*mediatime);
+			User::LeaveIfError(lex.Val(mediatimeTick));		 
+			CheckForAbortL(iCallback.MosCheckMediaTime(comp, port, mediatimeTick, moreThan));
+			}
+		else if(elemName == _L8("SetClockTimeScale"))
+			{
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+			const TDesC8& scale = FindAttributeL(aAttributes, _L8("scale"));
+	
+			TReal32 xscale = ParseReal32L(scale);
+	
+			CheckForAbortL(iCallback.MosSetClockTimeScale(comp,xscale * 65536));
+			}
+		else if(elemName == _L8("Base_AddPortSupport"))
+		    {
+		    const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+		    TPtrC8 comp;
+		    TInt portIndex;
+		    ParseCompPortL(portValue, comp, portIndex);
+		    CheckForAbortL(iCallback.MosBaseSupportPortL(comp, portIndex));
+		    }
+        else if(elemName == _L8("Base_SetAutonomous"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+            const TDesC8& enabledValue = FindAttributeL(aAttributes, _L8("enabled"));
+            TBool enabled = ParseBooleanL(enabledValue);
+            CheckForAbortL(iCallback.MosBaseSetAutonomous(comp, portIndex, enabled));
+            }		
+        else if(elemName == _L8("Base_AllocateBuffers"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+            
+            const TDesC8& numberValue = FindAttributeL(aAttributes, _L8("number"));
+            TInt numberBuffs;
+            TLex8 lex(numberValue);
+            User::LeaveIfError(lex.Val(numberBuffs));
+            
+            CheckForAbortL(iCallback.MosBaseAllocateBuffersL(comp, portIndex, numberBuffs));
+            }
+        else if(elemName == _L8("Base_FreeAllocatedBuffers"))
+            {
+			const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+            
+            CheckForAbortL(iCallback.MosBaseFreeAllocatedBuffersL(comp));
+            }			
+        else if(elemName == _L8("Base_SetBufSupplierPref"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+            
+            const TDesC8& componentSupplierValue = FindAttributeL(aAttributes, _L8("iscomponentsupplier"));
+            TBool componentSupplier = ParseBooleanL(componentSupplierValue);
+            CheckForAbortL(iCallback.MosBaseSetBufSupplier(comp, portIndex, componentSupplier));
+            }
+        else if(elemName == _L8("Base_FillThisBuffer"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+            
+            const TDesC8& bufIndexValue = FindAttributeL(aAttributes, _L8("portrelativebufferindex"));
+            TInt bufIndex;
+            TLex8 lex(bufIndexValue);
+            User::LeaveIfError(lex.Val(bufIndex));
+            
+            CheckForAbortL(iCallback.MosBaseFillThisBuffer(comp, portIndex, bufIndex));         
+            }
+        else if(elemName == _L8("Base_EmptyThisBuffer"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+            
+            const TDesC8& bufIndexValue = FindAttributeL(aAttributes, _L8("portrelativebufferindex"));
+            TInt bufIndex;
+            TLex8 lex(bufIndexValue);
+            User::LeaveIfError(lex.Val(bufIndex));
+            
+            CheckForAbortL(iCallback.MosBaseEmptyThisBuffer(comp, portIndex, bufIndex));         
+            }   
+        else if(elemName == _L8("Base_WaitForBuffer"))
+            {            
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+
+            const TDesC8& bufIndexValue = FindAttributeL(aAttributes, _L8("bufferindexinport"));
+            TInt bufIndex;
+            TLex8 lex(bufIndexValue);
+            User::LeaveIfError(lex.Val(bufIndex));            
+            
+            CheckForAbortL(iCallback.MosBaseWaitForBuffer(comp, portIndex, bufIndex));         
+            }		
+        else if(elemName == _L8("BaseTimestamp_PassClockHandle"))
+            {
+            const TDesC8& receivingComp = FindAttributeL(aAttributes, _L8("receiver"));
+            const TDesC8& clockToPass = FindAttributeL(aAttributes, _L8("handle"));
+            
+            CheckForAbortL(iCallback.MosBaseTimestampPassClock(receivingComp, clockToPass));
+            }
+        else if(elemName == _L8("BaseTimestamp_CheckTimestamp"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+                        
+            const TDesC8& timeValue = FindAttributeL(aAttributes, _L8("time"));
+            TUint time;
+            TLex8 lex(timeValue);
+            User::LeaveIfError(lex.Val(time));
+                        
+            const TDesC8& toleranceValue = FindAttributeL(aAttributes, _L8("tolerance"));
+            TUint tolerance;
+            lex.Assign(toleranceValue);
+            User::LeaveIfError(lex.Val(tolerance));            
+            
+            CheckForAbortL(iCallback.MosBaseTimestampCheckTimestampL(comp, portIndex, time, tolerance));         
+            }
+        else if(elemName == _L8("BaseTimestamp_CompareWithRefClock"))
+            {
+            const TDesC8& portValue = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(portValue, comp, portIndex);
+                                    
+            const TDesC8& toleranceValue = FindAttributeL(aAttributes, _L8("tolerance"));
+            TUint tolerance;
+            TLex8 lex(toleranceValue);
+            User::LeaveIfError(lex.Val(tolerance));            
+                        
+            CheckForAbortL(iCallback.MosBaseTimestampCompareWithRefClockL(comp, portIndex, tolerance));             
+            }
+		else if(elemName == _L8("CheckClockState"))
+            {
+            const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp"));
+            const TDesC8& stateDes = FindAttributeL(aAttributes, _L8("clockstate"));
+            OMX_TIME_CLOCKSTATE clockState = ParseOmxClockStateL(stateDes);            
+            CheckForAbortL(iCallback.MosCheckClockStateL(comp, clockState));
+            }
+	      else if(elemName == _L8("CheckTimePosition"))
+            {
+			// Use with caution: increments position as a side-effect.
+            const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(port, comp, portIndex);
+            
+            TInt timestamp = ParseOptionalIntL(aAttributes, _L8("timestamp"), 0);
+            
+            CheckForAbortL(iCallback.MosCheckTimePositionL(comp, portIndex, timestamp));
+            }
+        else if(elemName == _L8("SetTimePosition"))
+            {
+            const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));
+            TPtrC8 comp;
+            TInt portIndex;
+            ParseCompPortL(port, comp, portIndex);
+            
+            TInt timestamp = ParseOptionalIntL(aAttributes, _L8("timestamp"), 0);
+            
+            CheckForAbortL(iCallback.MosSetTimePositionL(comp, portIndex, timestamp));
+			}
+		else if(elemName == _L8("StartBuffersforPort"))
+            {       
+            const TDesC8& compPort = FindAttributeL(aAttributes, _L8("port"));          
+            TPtrC8 comp;
+            TInt port;
+            ParseCompPortL(compPort, comp, port);
+
+            CheckForAbortL(iCallback.MosStartBuffersforPort( comp,port));
+		    }
+  
+		else if(elemName == _L8("MarkBuffer"))
+			{
+			const TDesC8& port = FindAttributeL(aAttributes, _L8("port"));
+			TPtrC8 comp;
+			TInt portIndex;
+			ParseCompPortL(port, comp, portIndex);
+			const TDesC8& targetComp = FindAttributeL(aAttributes, _L8("targetComp"));
+			TInt markData = ParseOptionalIntL(aAttributes, _L8("markData"), 0);
+			CheckForAbortL(iCallback.MosMarkBuffer(comp, portIndex, targetComp, markData));
+			}
+
+		else
+			{
+			// element name is not recognized
+			TBuf<32> elemNameCopy;
+			elemNameCopy.Copy(elemName);
+			TBuf<44> message;
+			message.Append(_L("Unrecognized command: "));
+			message.Append(elemNameCopy);
+			iCallback.MosParseError(message);
+			User::Leave(KErrArgument);
+			}
+		}
+	}
+	
+TInt COmxScriptParser::ParseSystemErrorCode(const TDesC8& aErrorCode)
+    {
+    TInt error = KErrNone;
+    
+    if (aErrorCode == _L8("KErrNotFound"))
+        {
+        error = KErrNotFound;
+        }
+    
+    // TODO: the other error code will be added in demand
+    
+    return error;
+    }
+
+// TODO duplication with ParseOmxErrorL
+OMX_ERRORTYPE COmxScriptParser::ParseOmxErrorCode(const TDesC8& aErrorCode)
+    {
+    OMX_ERRORTYPE error = OMX_ErrorMax;
+    
+    if (aErrorCode == _L8("OMX_ErrorNone"))
+        {
+        error = OMX_ErrorNone;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorBadPortIndex"))
+        {
+        error = OMX_ErrorBadPortIndex;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorBadParameter"))
+        {
+        error = OMX_ErrorBadParameter;
+        }
+	else if (aErrorCode == _L8("OMX_ErrorPortsNotCompatible"))
+		{
+		error = OMX_ErrorPortsNotCompatible;
+		}
+	else if (aErrorCode == _L8("OMX_ErrorUnsupportedSetting"))
+		{
+		error = OMX_ErrorUnsupportedSetting;
+		}
+    else if (aErrorCode == _L8("OMX_ErrorIncorrectStateOperation"))
+        {
+        error = OMX_ErrorIncorrectStateOperation;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorUnsupportedIndex"))
+        {
+        error = OMX_ErrorUnsupportedIndex;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorNotReady"))
+        {
+        error = OMX_ErrorNotReady;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorContentPipeOpenFailed"))
+        {
+        error = OMX_ErrorContentPipeOpenFailed;
+        }
+    else if (aErrorCode == _L8("OMX_ErrorNotImplemented"))
+        {
+        error = OMX_ErrorNotImplemented;
+        }
+
+    // TODO: the other error code will be added in demand
+    
+    return error;
+    }
+    
+void COmxScriptParser::OnEndElementL(const RTagInfo& aElement, TInt /*aErrorCode*/)
+	{
+	if(iInTest)
+		{
+		const TDesC8& elemName = aElement.LocalName().DesC();
+		if(elemName == _L8("Test"))
+			{
+			iInTest = EFalse;
+			}
+		}
+	}
+
+const TDesC8* COmxScriptParser::FindAttribute(const RArray<RAttribute>& aArray, const TDesC8& aAttribName)
+	{
+	for(TInt index = 0, count = aArray.Count(); index < count; index++)
+		{
+		const RAttribute& attribute = aArray[index];
+		const TDesC8& name = attribute.Attribute().LocalName().DesC();
+		if(name == aAttribName)
+			{
+			return &(attribute.Value().DesC());
+			}
+		}
+	return NULL;
+	}
+
+const TDesC8& COmxScriptParser::FindAttributeL(const RArray<RAttribute>& aArray, const TDesC8& aAttribName)
+	{
+	const TDesC8* result = FindAttribute(aArray, aAttribName);
+	if(!result)
+		{
+		TBuf<32> nameCopy;
+		nameCopy.Copy(aAttribName);
+		TBuf<52> msg;
+		msg.Append(_L("Attribute "));
+		msg.Append(nameCopy);
+		msg.Append(_L(" not found"));
+		iCallback.MosParseError(msg);
+		User::Leave(KErrNotFound);
+		}
+	return *result;
+	}
+
+void COmxScriptParser::ParseCompPortL(const TDesC8& aInput, TPtrC8& aNameOut, TInt& aPortOut)
+    {
+    TInt offset = aInput.Locate(':');
+    User::LeaveIfError(offset);
+    aNameOut.Set(aInput.Left(offset));
+    TPtrC8 port = aInput.Right(aInput.Length() - offset - 1);
+    if (port == _L8("all"))
+        {
+        aPortOut = static_cast<TInt>(OMX_ALL);
+        }
+    else
+        {
+        TLex8 lex(port);
+        User::LeaveIfError(lex.Val(aPortOut));
+        }
+    }
+
+
+// The order of these entries does not matter, but for clarity's sake please
+// maintain alphabetical order
+
+PARSE_MAP_START(OMX_AUDIO_AACPROFILETYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, ERLC),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, HE),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, HE_PS),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, LC),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, LD),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, LTP),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, Main),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, Null),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, Scalable),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACObject, SSR)    
+PARSE_MAP_END(OMX_AUDIO_AACPROFILETYPE)
+
+PARSE_MAP_START(OMX_AUDIO_AACSTREAMFORMATTYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, ADIF),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, MP2ADTS),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, MP4ADTS),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, MP4FF),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, MP4LATM),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, MP4LOAS),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_AACStreamFormat, RAW)
+PARSE_MAP_END(OMX_AUDIO_AACSTREAMFORMATTYPE)
+
+PARSE_MAP_START(OMX_AUDIO_CHANNELMODETYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_ChannelMode, Dual), 
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_ChannelMode, JointStereo), 
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_ChannelMode, Mono),
+	PARSE_MAP_PREFIXENTRY(OMX_AUDIO_ChannelMode, Stereo) 
+PARSE_MAP_END(OMX_AUDIO_CHANNELMODETYPE)
+
+PARSE_MAP_START(OMX_COMMANDTYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_Command, StateSet),
+	PARSE_MAP_PREFIXENTRY(OMX_Command, Flush),
+	PARSE_MAP_PREFIXENTRY(OMX_Command, PortDisable),
+	PARSE_MAP_PREFIXENTRY(OMX_Command, PortEnable),
+	PARSE_MAP_PREFIXENTRY(OMX_Command, MarkBuffer)
+PARSE_MAP_END(OMX_COMMANDTYPE)
+
+PARSE_MAP_START(OMX_COLOR_FORMATTYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, Unused),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, Max),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, 12bitRGB444),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, 16bitRGB565),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, 24bitBGR888),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, 32bitARGB8888),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, 32bitBGRA8888),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, CbYCrY),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YCbYCr),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YCrYCb),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YUV420PackedPlanar),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YUV422PackedPlanar),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YUV420Planar),
+#if defined(NCP_COMMON_BRIDGE_FAMILY) && !defined(__WINSCW__)
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YUV422Planar),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, STYUV420PackedSemiPlanarMB),
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, STYUV422PackedSemiPlanarMB)
+#else
+	PARSE_MAP_PREFIXENTRY(OMX_COLOR_Format, YUV422Planar)
+#endif //NCP_COMMON_BRIDGE_FAMILY	
+PARSE_MAP_END(OMX_COLOR_FORMATTYPE)
+
+PARSE_MAP_START(OMX_ERRORTYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_Error, BadParameter),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, BadPortIndex),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, ContentPipeOpenFailed),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, Hardware),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, IncorrectStateOperation),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, None),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, NotReady),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, PortsNotCompatible),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, Underflow),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, UnsupportedIndex),
+	PARSE_MAP_PREFIXENTRY(OMX_Error, UnsupportedSetting)
+PARSE_MAP_END(OMX_ERRORTYPE)
+
+PARSE_MAP_START(OMX_EVENTTYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_Event, BufferFlag),
+	PARSE_MAP_PREFIXENTRY(OMX_Event, CmdComplete),
+	PARSE_MAP_PREFIXENTRY(OMX_Event, Error),
+	PARSE_MAP_PREFIXENTRY(OMX_Event, Mark),
+	PARSE_MAP_PREFIXENTRY(OMX_Event, PortFormatDetected),
+	PARSE_MAP_PREFIXENTRY(OMX_Event, PortSettingsChanged),
+PARSE_MAP_END(OMX_EVENTTYPE)
+
+//	PARSE_MAP_PREFIXENTRY(OMX_EventNokia, FirstFrameDisplayed),
+//	PARSE_MAP_PREFIXENTRY(OMX_EventNokia, DroppedFrame)
+
+
+PARSE_MAP_START(OMX_STATETYPE)
+	PARSE_MAP_PREFIXENTRY(OMX_State, Loaded),
+	PARSE_MAP_PREFIXENTRY(OMX_State, Idle),
+	PARSE_MAP_PREFIXENTRY(OMX_State, Executing),
+	PARSE_MAP_PREFIXENTRY(OMX_State, Pause),
+	PARSE_MAP_PREFIXENTRY(OMX_State, WaitForResources),
+	PARSE_MAP_PREFIXENTRY(OMX_State, Invalid)
+PARSE_MAP_END(OMX_STATETYPE)
+
+/**
+ * Templated wrapper to a plain-C function generated by PARSE_MAP
+ * Accepts a descriptor as input and leaves with KErrArgument if parse fails.
+ */
+template<typename T> T ParseL(const TDesC8& aDes, TInt (*parseFunc)(const char*, T*))
+	{
+	if(aDes.Length() >= 64)
+		{
+		User::Leave(KErrArgument);
+		}
+	TBuf8<64> buf = aDes;
+	T result = (T) 0;
+	TInt success = parseFunc((char*) buf.PtrZ(), &result);
+	if(!success)
+		{
+		// value not recognized
+		// maybe add it to the PARSE_MAP ?
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+	return result;
+	}
+
+OMX_AUDIO_AACPROFILETYPE COmxScriptParser::ParseOmxAACProfileL(const TDesC8& aProfileDes)
+	{
+	return ParseL(aProfileDes, parse_OMX_AUDIO_AACPROFILETYPE);
+	}
+
+OMX_AUDIO_AACSTREAMFORMATTYPE COmxScriptParser::ParseOmxAACStreamFormatL(const TDesC8& aFormatDes)
+	{
+	return ParseL(aFormatDes, parse_OMX_AUDIO_AACSTREAMFORMATTYPE);
+	}
+
+OMX_AUDIO_CHANNELMODETYPE COmxScriptParser::ParseOmxAudioChannelModeL(const TDesC8& aChannelModeDes)
+	{
+	return ParseL(aChannelModeDes, parse_OMX_AUDIO_CHANNELMODETYPE);
+	}
+
+OMX_STATETYPE COmxScriptParser::ParseOmxStateL(const TDesC8& aStateDes)
+	{
+	return ParseL(aStateDes, parse_OMX_STATETYPE);
+	}
+
+OMX_METADATASCOPETYPE COmxScriptParser::ParseOmxScopeTypeL(const TDesC8& aScopeDes)
+	{
+	if(aScopeDes == _L8("all"))
+		{
+		return OMX_MetadataScopeAllLevels;
+		}
+	else if(aScopeDes == _L8("top"))
+		{
+		return OMX_MetadataScopeTopLevel;
+		}
+	else if(aScopeDes == _L8("port"))
+		{
+		return OMX_MetadataScopePortLevel;
+		}
+	else
+		{
+		User::Leave(KErrArgument);
+		return OMX_MetadataScopeTypeMax;	// unreachable, prevents compiler warning
+		}
+	}
+
+OMX_BUFFERSUPPLIERTYPE COmxScriptParser::ParseOmxSupplierL(const TDesC8& aSupplierDes, TBool aAllowUnspecified)
+	{
+	if(aSupplierDes == _L8("input"))
+		{
+		return OMX_BufferSupplyInput;
+		}
+	else if(aSupplierDes == _L8("output"))
+		{
+		return OMX_BufferSupplyOutput;
+		}
+	else if (aAllowUnspecified && aSupplierDes == _L8("unspecified"))
+		{
+		return OMX_BufferSupplyUnspecified;
+		}
+	else
+		{
+		User::Leave(KErrArgument);
+		return OMX_BufferSupplyInput;	// unreachable, prevents compiler warning
+		}
+	}
+
+void COmxScriptParser::CheckForAbortL(TBool success)
+	{
+	if(!success)
+		{
+		iCallbackAborted = ETrue;
+		User::Leave(KErrAbort);
+		}
+	}
+
+TInt COmxScriptParser::ParseOptionalIntL(const RArray<RAttribute>& aArray, const TDesC8& aAttribName, TInt aDefaultValue)
+	{
+	const TDesC8* des = FindAttribute(aArray, aAttribName);
+	if(des == NULL)
+		{
+		return aDefaultValue;
+		}
+	else
+		{
+		TInt result;
+		TLex8 lex(*des);
+		User::LeaveIfError(lex.Val(result));
+		return result;
+		}
+	}
+
+TReal COmxScriptParser::ParseOptionalRealL(const RArray<RAttribute>& aArray, const TDesC8& aAttribName, TReal aDefaultValue)
+	{
+	const TDesC8* des = FindAttribute(aArray, aAttribName);
+	if(des == NULL)
+		{
+		return aDefaultValue;
+		}
+	else
+		{
+		TReal result;
+		TLex8 lex(*des);
+		User::LeaveIfError(lex.Val(result));
+		return result;
+		}
+	}
+
+OMX_COLOR_FORMATTYPE COmxScriptParser::ParseOmxColorFormatL(const TDesC8& aDes)
+	{
+	return ParseL(aDes, parse_OMX_COLOR_FORMATTYPE);
+	}
+
+
+OMX_COMMANDTYPE COmxScriptParser::ParseOmxCommandL(const TDesC8& aDes)
+	{
+	return ParseL(aDes, parse_OMX_COMMANDTYPE);
+	}
+
+OMX_ERRORTYPE COmxScriptParser::ParseOmxErrorL(const TDesC8& aDes)
+	{
+	return ParseL(aDes, parse_OMX_ERRORTYPE);
+	}
+
+OMX_EVENTTYPE COmxScriptParser::ParseOmxEventL(const TDesC8& aDes)
+	{
+	return ParseL(aDes, parse_OMX_EVENTTYPE);
+	}
+
+TBool COmxScriptParser::ParseOptionalBooleanL(const RArray<RAttribute>& aArray, const TDesC8& aAttribName, TBool aDefaultValue)
+	{
+	const TDesC8* des = FindAttribute(aArray, aAttribName);
+	if(des == NULL)
+		{
+		return aDefaultValue;
+		}
+
+	return ParseBooleanL(*des);
+	}
+
+TBool COmxScriptParser::ParseBooleanL(const TDesC8& aBool)
+    {
+    if ((aBool == _L8("true")) ||
+        (aBool == _L8("yes")) ||
+        (aBool == _L8("1")) ||
+        (aBool == _L8("ETrue")) ||
+        (aBool == _L8("OMX_TRUE")))
+        {
+        return ETrue;
+        }
+        
+    if ((aBool == _L8("false")) ||
+        (aBool == _L8("no")) ||
+        (aBool == _L8("0")) ||
+        (aBool == _L8("EFalse")) ||
+        (aBool == _L8("OMX_FALSE")))
+        {
+        return EFalse;
+        }
+        
+    User::Leave(KErrArgument);
+    return EFalse;
+    }
+
+
+TUint32 COmxScriptParser::ParseUint32L(const TDesC8& aDes)
+	{
+	TUint32 result;
+	if(aDes.Find(_L8("0x")) == 0)
+		{
+		TLex8 lex(aDes.Mid(2));
+		User::LeaveIfError(lex.Val(result, EHex));
+		}
+	else
+		{
+		TLex8 lex(aDes);
+		User::LeaveIfError(lex.Val(result, EDecimal));
+		}
+	return result;
+	}
+	
+TBool COmxScriptParser::ParseBoolean(const TDesC8& aDes)
+	{
+	if (aDes == _L8("true"))
+		{
+		return ETrue;
+		}
+	return EFalse;	
+	}
+
+TReal32 COmxScriptParser::ParseReal32L(const TDesC8& aDes)
+	{
+	TReal32 result;
+	TLex8 lex(aDes);
+	User::LeaveIfError(lex.Val(result));
+	return result;
+	}	
+	
+OMX_VIDEO_CODINGTYPE COmxScriptParser::ParseOmxVideoCodingL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("unused"))
+		{
+		return OMX_VIDEO_CodingUnused;
+		}
+	else if (aDes == _L8("autodetect"))
+		{
+		return OMX_VIDEO_CodingAutoDetect;
+		}
+	else if(aDes == _L8("mpeg4"))
+		{
+		return OMX_VIDEO_CodingMPEG4;
+		}
+	else if(aDes == _L8("avc"))
+		{
+		return OMX_VIDEO_CodingAVC;
+		}
+	else if(aDes == _L8("max"))
+		{
+		return OMX_VIDEO_CodingMax;
+		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+
+	return OMX_VIDEO_CodingUnused;
+	}
+
+OMX_AUDIO_CODINGTYPE COmxScriptParser::ParseOmxAudioCodingL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("unused"))
+		{
+		return OMX_AUDIO_CodingUnused;
+		}
+	else if (aDes == _L8("autodetect"))
+		{
+		return OMX_AUDIO_CodingAutoDetect;
+		}
+	else if(aDes == _L8("pcm"))
+		{
+		return OMX_AUDIO_CodingPCM;
+		}
+	else if(aDes == _L8("aac"))
+		{
+		return OMX_AUDIO_CodingAAC;
+		}	
+	else if(aDes == _L8("max"))
+		{
+		return OMX_AUDIO_CodingMax;
+		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+
+	return OMX_AUDIO_CodingUnused;
+	}
+
+OMX_TIME_REFCLOCKTYPE COmxScriptParser::ParseOmxRefClockTypeL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("none"))
+		{
+		return OMX_TIME_RefClockNone;
+		}
+	else if (aDes == _L8("audio"))
+		{
+		return OMX_TIME_RefClockAudio;
+		}
+	else if(aDes == _L8("video"))
+		{
+		return OMX_TIME_RefClockVideo;
+		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+
+	return OMX_TIME_RefClockNone;
+	}
+
+OMX_TIME_CLOCKSTATE COmxScriptParser::ParseOmxClockStateL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("stopped"))
+		{
+		return OMX_TIME_ClockStateStopped;
+		}
+	else if (aDes == _L8("waiting"))
+		{
+		return OMX_TIME_ClockStateWaitingForStartTime;
+		}
+	else if(aDes == _L8("running"))
+		{
+		return OMX_TIME_ClockStateRunning;
+		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		return OMX_TIME_ClockStateMax;	// unreachable, to prevent compiler warning		
+		}
+	}
+
+TVideoFitMode COmxScriptParser::ParseVideoFitModeL(const TDesC8& aMode)
+	{
+	if(aMode == _L8("centre"))
+		{
+		return EVideoFitCentre;
+		}
+	else if(aMode == _L8("scaleAndCentre"))
+		{
+		return EVideoFitScaleAndCentre;
+		}
+	else if(aMode == _L8("rotateScaleAndCentre"))
+		{
+		return EVideoFitRotateScaleAndCentre;
+		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		return EVideoFitCentre;	// unreachable, prevent compiler warning
+		}
+	}
+
+OMX_VIDEO_MPEG4PROFILETYPE COmxScriptParser::ParseOmxMpeg4ProfileL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("simple"))
+		{
+		return OMX_VIDEO_MPEG4ProfileSimple;
+		}
+	else if(aDes == _L8("main"))
+		{
+		return OMX_VIDEO_MPEG4ProfileMain;
+		}
+	else if (aDes == _L8("advancedrealtime"))
+		{
+ 		return OMX_VIDEO_MPEG4ProfileAdvancedRealTime;
+ 		}
+ 	else if (aDes == _L8("advancedcoding"))
+ 		{
+ 		return OMX_VIDEO_MPEG4ProfileAdvancedCoding;
+ 		}
+ 	else if (aDes == _L8("core"))
+ 		{
+ 		return OMX_VIDEO_MPEG4ProfileCore;
+ 		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+	return OMX_VIDEO_MPEG4ProfileMax;	// unreachable, prevents compiler warning
+	}
+	
+OMX_VIDEO_MPEG4LEVELTYPE COmxScriptParser::ParseOmxMpeg4LevelL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("level0"))
+		{
+		return OMX_VIDEO_MPEG4Level0;
+		}
+	else if(aDes == _L8("level0b"))
+		{
+		return OMX_VIDEO_MPEG4Level0b;
+		}
+	else if (aDes == _L8("level1"))
+		{
+ 		return OMX_VIDEO_MPEG4Level1;
+ 		}
+ 	else if (aDes == _L8("level2"))
+ 		{
+ 		return OMX_VIDEO_MPEG4Level2;
+ 		}
+ 	else if (aDes == _L8("level3"))
+ 		{
+ 		return OMX_VIDEO_MPEG4Level3;
+ 		}
+	else if(aDes == _L8("level4"))
+		{
+		return OMX_VIDEO_MPEG4Level4;
+		}
+	else if (aDes == _L8("level5"))
+ 		{
+ 		return OMX_VIDEO_MPEG4Level5;
+ 		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+	return OMX_VIDEO_MPEG4LevelMax;	// unreachable, prevents compiler warning
+	}	
+
+OMX_VIDEO_CONTROLRATETYPE COmxScriptParser::ParseOmxControlRateL(const TDesC8& aDes)
+	{
+	if(aDes == _L8("disable"))
+		{
+		return OMX_Video_ControlRateDisable;
+		}
+	else if(aDes == _L8("variable"))
+		{
+		return OMX_Video_ControlRateVariable;
+		}
+	else if (aDes == _L8("constant"))
+		{
+ 		return OMX_Video_ControlRateConstant;
+ 		}
+	else
+		{
+		__BREAKPOINT();
+		User::Leave(KErrArgument);
+		}
+	return OMX_Video_ControlRateMax;	// unreachable, prevents compiler warning
+	}	
+	
+OMX_AUDIO_AACSTREAMFORMATTYPE COmxScriptParser::ParseAacStreamFormatL(const TDesC8& aStreamFormatStr)
+ 	{
+ 	if(aStreamFormatStr == _L8("mp2adts"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatMP2ADTS;
+ 		}
+ 	else if(aStreamFormatStr == _L8("mp4adts"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatMP4ADTS;
+		}
+ 	else if(aStreamFormatStr == _L8("mp4loas"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatMP4LOAS;
+ 		}
+ 	else if(aStreamFormatStr == _L8("mp4latm"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatMP4LATM;
+ 		}
+ 	else if(aStreamFormatStr == _L8("adif"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatADIF;
+ 		}
+ 	else if(aStreamFormatStr == _L8("mp4ff"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatMP4FF;
+ 		}
+ 	else if(aStreamFormatStr == _L8("raw"))
+ 		{
+ 		return OMX_AUDIO_AACStreamFormatRAW;
+ 		}
+ 	else
+ 		{
+ 		User::Leave(KErrArgument);
+ 		return OMX_AUDIO_AACStreamFormatMax;
+ 		}
+ 	}
+ 
+ OMX_NUMERICALDATATYPE COmxScriptParser::ParseNumericalDataL(const TDesC8& aDes)
+ 	{
+ 	if(aDes == _L8("signed"))
+ 		{
+ 		return OMX_NumericalDataSigned;
+ 		}
+ 	else if(aDes == _L8("unsigned"))
+ 		{
+ 		return OMX_NumericalDataUnsigned;
+ 		}
+ 	else
+ 		{
+ 		User::Leave(KErrArgument);
+ 		return OMX_NumercialDataMax;
+ 		}
+ 	}
+ 
+ OMX_ENDIANTYPE COmxScriptParser::ParseEndianL(const TDesC8& aDes)
+ 	{
+ 	if(aDes == _L8("big"))
+ 		{
+ 		return OMX_EndianBig;
+ 		}
+ 	else if(aDes == _L8("little"))
+ 		{
+ 		return OMX_EndianLittle;
+ 		}
+ 	else
+ 		{
+		User::Leave(KErrArgument);
+ 		return OMX_EndianMax;
+ 		}
+ 	}
+ 
+ OMX_BOOL COmxScriptParser::ParseBoolL(const TDesC8& aDes)
+ 	{
+ 	if(aDes == _L8("true"))
+ 		{
+ 		return OMX_TRUE;
+ 		}
+ 	else if(aDes == _L8("false"))
+ 		{
+ 		return OMX_FALSE;
+ 		}
+ 	else
+ 		{
+ 		User::Leave(KErrArgument);
+ 		return OMX_FALSE;
+ 		}
+ 	}
+