\n")); + } + +LOCAL_C TInt ParseSize(const TDesC& aDes) + { + TLex lex(aDes); + TInt val; + if(lex.Val(val) != KErrNone || val < 0) + { + return KErrArgument; + } + switch(lex.Get()) + { + case 0: // no modifier + break; + case 'K': + val <<= 10; + break; + case 'M': + val <<= 20; + break; + default: // bad modifier + return KErrArgument; + } + if(lex.Get() != 0) + { + // trailing text + return KErrArgument; + } + return val; + } + +/** + * Extracts parameters from the command line. + * This method must not use the cleanup stack; there may not be one allocated since we may be switching heaps. + */ +LOCAL_C TInt ParseCommandLineArgs(TDes& commandLine, TPtrC& aFilename, TPtrC& aSection, TInt &aHeapSize) + { + // copy the command line + if(User::CommandLineLength() > commandLine.MaxLength()) + { + return KErrTooBig; + } + User::CommandLine(commandLine); + + // parse filename, section and other args from the command line + TInt heapSize = KErrNotFound; + TPtrC filename(KNullDesC); + TPtrC section(KNullDesC); + TLex lex(commandLine); + lex.SkipSpaceAndMark(); + while(!lex.Eos()) + { + lex.SkipCharacters(); + TPtrC arg = lex.MarkedToken(); + lex.SkipSpaceAndMark(); + if(arg == _L("-heap")) + { + if(lex.Eos()) + { + // no param following + return KErrArgument; + } + lex.SkipCharacters(); + TPtrC heapArg = lex.MarkedToken(); + lex.SkipSpaceAndMark(); + heapSize = ParseSize(heapArg); + if(heapSize == KErrArgument) + { + return KErrArgument; + } + } + else if(filename.Length() == 0) + { + filename.Set(arg); + } + else if(section.Length() == 0) + { + section.Set(arg); + } + else + { + // to many unnamed params + return KErrArgument; + } + } + if(section.Length() == 0) + { + return KErrArgument; + } + aHeapSize = heapSize; + aFilename.Set(filename); + aSection.Set(section); + return KErrNone; + } + +LOCAL_C void MainL() + { + RBuf commandLine; + commandLine.CreateL(User::CommandLineLength()); + CleanupClosePushL(commandLine); + TPtrC filename(KNullDesC); + TPtrC section(KNullDesC); + TInt heapSize = KErrNotFound; + TInt error = ParseCommandLineArgs(commandLine, filename, section, heapSize); + if(error) + { + ShowUsage(); + User::Leave(error); + } + + //logs script output to console and RDebug + TConsoleLogger logger; + + COmxXmlScript* script = COmxXmlScript::NewL(logger); + CleanupStack::PushL(script); + script->RunScriptL(filename, section); + CleanupStack::PopAndDestroy(2, &commandLine); + } + +LOCAL_C void DoStartL() + { + // Create active scheduler (to run active objects) + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler(); + CleanupStack::PushL(scheduler); + CActiveScheduler::Install(scheduler); + + MainL(); + + // Delete active scheduler + CleanupStack::PopAndDestroy(scheduler); + } + +/** + * Invokes ParseCommandLineArgs() to retrieve any heap size specified on the command line. + * The command line descriptor is allocated on the stack (since we are avoiding heap allocations at this point). + * The descriptors are then thrown away (to avoid consuming too much stack space). + * Later, the command line will be parsed again but on the heap. + */ +LOCAL_C TInt ParseHeapSize() + { + TInt heapSize = KErrNotFound; + TPtrC filename(KNullDesC); + TPtrC section(KNullDesC); + TBuf<255> commandLine; + // ignore error + ParseCommandLineArgs(commandLine, filename, section, heapSize); + return heapSize; + } + +// Global Functions + +GLDEF_C TInt E32Main() + { + + + TInt heapSize = ParseHeapSize(); + + + // switch heap if specified + RHeap* oldHeap = NULL; + RHeap* newHeap = NULL; + + if(heapSize != KErrNotFound) + { + const TInt KMinHeapGrowBy = 1; + const TInt KByteAlignment = 0; + const TBool KSingleThreaded = EFalse; + newHeap = User::ChunkHeap(NULL, heapSize, heapSize, KMinHeapGrowBy, KByteAlignment, KSingleThreaded); + if(newHeap == NULL) + { + return KErrNoMemory; + } + oldHeap = User::SwitchHeap(newHeap); + } + + // Create cleanup stack + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + + // Create output console + TRAPD(createError, console = Console::NewL(KTextConsoleTitle, TSize(KConsFullScreen,KConsFullScreen))); + if (createError) + return createError; + + // Run application code inside TRAP harness, wait keypress when terminated + TRAPD(mainError, DoStartL()); + + + if(mainError) + { + console->Printf(KTextFailed, mainError); + } + console->Printf(KTextPressAnyKey); + console->Getch(); + + delete console; + delete cleanup; + __UHEAP_MARKEND; + + if(newHeap != NULL) + { + User::SwitchHeap(oldHeap); + newHeap->Close(); + } + + return KErrNone; + } + diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxscriptparser.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxscriptparser.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,2236 @@ +/* +* 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 +#include +#include "parsemap.h" +//#include + +#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;iDes().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); + + OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone; + CheckForAbortL(iCallback.MosSetCameraCaptureL(comp, portIndex, isCapturing, expectedErrorInt)); + } + 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(ParseOmxErrorL(nData1Des)); + break; + case OMX_EventCmdComplete: + nData1 = static_cast(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(ParseOmxErrorL(nData1Des)); + break; + case OMX_EventCmdComplete: + nData1 = static_cast(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; + } + + const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone; + if (expectedError) + { + expectedErrorInt = ParseOmxErrorCode(*expectedError); + } + + CheckForAbortL(iCallback.MosSetAudioPortDefL(comp, port, codingTypePtr, expectedErrorInt)); + } + 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(-1); + } + OMX_ENDIANTYPE endian = OMX_EndianMax; + des = FindAttribute(aAttributes, _L8("endian")); + if(des != NULL) + { + endian = ParseEndianL(*des); + } + else + { + endian = static_cast(-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 (-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("LoadBufferHandler")) + { + // Load buffer component handler + // Buffer component tests + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + const TDesC8& filename = FindAttributeL(aAttributes, _L8("filename")); + const TDesC8* type = FindAttribute(aAttributes, _L8("type")); + TBuf name; + User::LeaveIfError(CnvUtfConverter::ConvertToUnicodeFromUtf8(name,filename)); + + // Call test script to create buffer handler + CheckForAbortL(iCallback.InitialiseBufferHandlerL(comp, name, type)); + } + else if(elemName == _L8("StartBufferHandler")) + { + iCallback.StartBufferHandler(); + } + else if (elemName == _L8("SendInvalidBufferId")) + { + const TDesC8& id = FindAttributeL(aAttributes, _L8("id")); + TInt idValue = ParseUint32L(id); + iCallback.SendInvalidBufferId(idValue); + } + else if(elemName == _L8("EndBufferHandler")) + { + iCallback.StopBufferHandler(); + } + else if(elemName == _L8("LoadBufferSinkHandler")) + { + // Load buffer component handler + // Buffer component tests + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + const TDesC8& filename = FindAttributeL(aAttributes, _L8("filename")); + TBuf name; + User::LeaveIfError(CnvUtfConverter::ConvertToUnicodeFromUtf8(name,filename)); + + // Call test script to create buffer handler + CheckForAbortL(iCallback.InitialiseBufferSinkHandlerL(comp, name)); + } + else if (elemName == _L8("StartBufferSinkHandler")) + { + iCallback.StartBufferSinkHandler(); + } + else if (elemName == _L8("EndBufferSinkHandler")) + { + iCallback.StopBufferSinkHandler(); + } + else if(elemName == _L8("NegativeSetDataChunk")) + { + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + + const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone; + if (expectedError) + { + expectedErrorInt = ParseOmxErrorCode(*expectedError); + } + + const TDesC8* expectedSystemError = FindAttribute(aAttributes, _L8("expectederror")); + TInt expectedSystemErrorInt = KErrNone; + if (expectedSystemError) + { + expectedSystemErrorInt = ParseSystemErrorCode(*expectedSystemError); + } + + CheckForAbortL(iCallback.MosNegativeSetDataChunk(comp, expectedErrorInt, expectedSystemErrorInt)); + } + else if(elemName == _L8("SetBufferSize")) + { + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + const TDesC8& value = FindAttributeL(aAttributes, _L8("size")); + const TDesC8* expectedError = FindAttribute(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = OMX_ErrorNone; + if (expectedError) + { + expectedErrorInt = ParseOmxErrorCode(*expectedError); + } + TInt portIndex = 0; + TPtrC8 comp; + ParseCompPortL(port, comp, portIndex); + TLex8 lex(value); + TInt valInt = 0; + User::LeaveIfError(lex.Val(valInt)); + CheckForAbortL(iCallback.MosSetBufferSize(comp, portIndex, valInt, expectedErrorInt)); + } + else if(elemName == _L8("GetAndCompareBufferCount")) + { + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + const TDesC8& value = FindAttributeL(aAttributes, _L8("count")); + TInt portIndex = 0; + TPtrC8 comp; + ParseCompPortL(port, comp, portIndex); + TLex8 lex(value); + TInt countInt = 0; + User::LeaveIfError(lex.Val(countInt)); + CheckForAbortL(iCallback.MosGetAndCompareBufferCount(comp, portIndex, countInt)); + } + else if(elemName == _L8("GetAndCompareBufferSize")) + { + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + const TDesC8& value = FindAttributeL(aAttributes, _L8("size")); + TInt portIndex = 0; + TPtrC8 comp; + ParseCompPortL(port, comp, portIndex); + TLex8 lex(value); + TInt valInt = 0; + User::LeaveIfError(lex.Val(valInt)); + CheckForAbortL(iCallback.MosGetAndCompareBufferSize(comp, portIndex, valInt)); + } + else if(elemName == _L8("FlushBuffer")) + { + const TDesC8& expectedError = FindAttributeL(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = ParseOmxErrorCode(expectedError); + + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + TPtrC8 comp; + TInt portIndex = 0; + ParseCompPortL(port, comp, portIndex); + CheckForAbortL(iCallback.MosFlushBuffer(comp, portIndex, expectedErrorInt)); + } + else if(elemName == _L8("ForceBufferSourceFlushBuffer")) + { + const TDesC8& expectedError = FindAttributeL(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = ParseOmxErrorCode(expectedError); + + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + TPtrC8 comp; + TInt portIndex = 0; + ParseCompPortL(port, comp, portIndex); + CheckForAbortL(iCallback.MosForceBufferSourceFlushBufferL(comp, portIndex, expectedErrorInt)); + } + else if(elemName == _L8("ForceBufferSinkFlushBuffer")) + { + const TDesC8& expectedError = FindAttributeL(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = ParseOmxErrorCode(expectedError); + + const TDesC8& port = FindAttributeL(aAttributes, _L8("port")); + TPtrC8 comp; + TInt portIndex = 0; + ParseCompPortL(port, comp, portIndex); + CheckForAbortL(iCallback.MosForceBufferSinkFlushBuffer(comp, portIndex, expectedErrorInt)); + } + 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("ChangeFilledBufferLength")) + { + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + const TDesC8& value = FindAttributeL(aAttributes, _L8("data")); + TLex8 lex(value); + TInt valInt = 0; + User::LeaveIfError(lex.Val(valInt)); + CheckForAbortL(iCallback.MosChangeFilledBufferLength(comp, valInt)); + } + else if(elemName == _L8("SetOMX_SymbianIndexParamBufferMsgQueueData")) + { + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + const TDesC8& expectedError = FindAttributeL(aAttributes, _L8("expectedomxerr")); + OMX_ERRORTYPE expectedErrorInt = ParseOmxErrorCode(expectedError); + + CheckForAbortL(iCallback.MosSetOMX_SymbianIndexParamBufferMsgQueueData(comp, expectedErrorInt)); + } + 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("CheckFrameCount")) + { + const TDesC8& fileName8 = FindAttributeL(aAttributes, _L8("filename")); + TInt count = ParseOptionalIntL(aAttributes, _L8("count"), 0); + + HBufC* fileName = HBufC::NewLC(fileName8.Length()); + fileName->Des().Copy(fileName8); + CheckForAbortL(iCallback.MosCheckFrameCountL(*fileName, count)); + CleanupStack::PopAndDestroy(fileName); + } + + 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)); + } +#ifdef OLD_ADPCM_EXTENSION + else if (elemName == _L8("SetAdPcmAudioPortDef")) + { + 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); + CheckForAbortL(iCallback.MosSetAdPcmAudioPortDefL(comp, port, channels, samplingrate, bitspersample)); + } + else if (elemName == _L8("SetAdPcmDecoderBlockAlign")) + { + const TDesC8& comp = FindAttributeL(aAttributes, _L8("comp")); + const TDesC8& blockAlign = FindAttributeL(aAttributes, _L8("blockalign")); + TLex8 lex(blockAlign); + TInt blockAlignValue; + User::LeaveIfError(lex.Val(blockAlignValue)); + CheckForAbortL(iCallback.MosConfigAdPcmDecoderBlockAlign(comp, blockAlignValue)); + } +#endif + 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) + { + #define DEFERR(e) if(aErrorCode == _L8(#e)) return e; + + DEFERR(OMX_ErrorNone); + DEFERR(OMX_ErrorInsufficientResources); + DEFERR(OMX_ErrorUndefined); + DEFERR(OMX_ErrorInvalidComponentName); + DEFERR(OMX_ErrorComponentNotFound); + DEFERR(OMX_ErrorInvalidComponent); + DEFERR(OMX_ErrorBadParameter); + DEFERR(OMX_ErrorNotImplemented); + DEFERR(OMX_ErrorUnderflow); + DEFERR(OMX_ErrorOverflow); + DEFERR(OMX_ErrorHardware); + DEFERR(OMX_ErrorInvalidState); + DEFERR(OMX_ErrorStreamCorrupt); + DEFERR(OMX_ErrorPortsNotCompatible); + DEFERR(OMX_ErrorResourcesLost); + DEFERR(OMX_ErrorNoMore); + DEFERR(OMX_ErrorVersionMismatch); + DEFERR(OMX_ErrorNotReady); + DEFERR(OMX_ErrorTimeout); + DEFERR(OMX_ErrorSameState); + DEFERR(OMX_ErrorResourcesPreempted); + DEFERR(OMX_ErrorPortUnresponsiveDuringAllocation); + DEFERR(OMX_ErrorPortUnresponsiveDuringDeallocation); + DEFERR(OMX_ErrorPortUnresponsiveDuringStop); + DEFERR(OMX_ErrorIncorrectStateTransition); + DEFERR(OMX_ErrorIncorrectStateOperation); + DEFERR(OMX_ErrorUnsupportedSetting); + DEFERR(OMX_ErrorUnsupportedIndex); + DEFERR(OMX_ErrorBadPortIndex); + DEFERR(OMX_ErrorPortUnpopulated); + DEFERR(OMX_ErrorComponentSuspended); + DEFERR(OMX_ErrorDynamicResourcesUnavailable); + DEFERR(OMX_ErrorMbErrorsInFrame); + DEFERR(OMX_ErrorFormatNotDetected); + DEFERR(OMX_ErrorContentPipeOpenFailed); + DEFERR(OMX_ErrorContentPipeCreationFailed); + DEFERR(OMX_ErrorSeperateTablesUsed); + DEFERR(OMX_ErrorTunnelingUnsupported); + DEFERR(OMX_ErrorKhronosExtensions); + DEFERR(OMX_ErrorVendorStartUnused); + #undef DEFERR + + return OMX_ErrorMax; + } + +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& 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& 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(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 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& 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& 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& 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; + } + } + diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxscriptparser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxscriptparser.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,262 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +#ifndef OMXSCRIPTPARSER_H_ +#define OMXSCRIPTPARSER_H_ + +#include +#include +#include + +#include + + +// a bit naughty, bit it will do for now +using namespace Xml; + +enum TVideoFitMode + { + EVideoFitCentre, + EVideoFitScaleAndCentre, + EVideoFitRotateScaleAndCentre + }; + +enum TTransitionOrder + { + ELoadOrder, + EAutoOrder + }; + +/** + * High-level elementary test actions. This interface can be driven by the COmxScriptParser. + */ +class MOmxScriptIf + { +public: + virtual TBool MosLoadComponentL(const TDesC8& aComp, const TDesC8& aName, TBool aBaseProfile, const TDesC8* aBaseImpl, TBool aLoadInCoreServerThread) = 0; + virtual TBool MosSetupTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetupNonTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier) = 0; + virtual TBool MosSetWindowL(const TDesC8& aComp) = 0; + virtual TBool MosAllTransitionL(OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError, TTransitionOrder order) = 0; + virtual TBool MosTransition(const TDesC8& aComp, OMX_STATETYPE aState, TBool aAsync) = 0; + virtual TBool MosFailingTransition(const TDesC8& aComp, OMX_STATETYPE aState, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosWaitEOS() = 0; + virtual TBool MosSetFilename(const TDesC8& aComp, const TDesC& aFilename) = 0; + //meena + virtual TBool MosSetFilename_bellagio(const TDesC8& aComp, char *aFilename) = 0; + + virtual TBool MosGetFilename(const TDesC8& aComp, TDesC& aFilename, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetBadFilename(const TDesC8& aComp) = 0; + + virtual TBool MosSetBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosCompareFilesL(const TDesC& aFileOne, const TDesC& aFileTwo) = 0; + virtual TBool MosFilterAndCompareFilesL(const TDesC& aFileOne, const TDesC8& aFile1Filter1, const TDesC8& aFile1Filter2, const TDesC8& aFile1Filter3, + const TDesC& aFileTwo, const TDesC8& aFile2Filter1, const TDesC8& aFile2Filter2, const TDesC8& aFile2Filter3) = 0; + virtual TBool MosBufferSupplierOverrideL(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_ERRORTYPE aExpectedSourceError, OMX_ERRORTYPE aExpectedSinkError) = 0; + virtual TBool MosSetVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_COLOR_FORMATTYPE* aColorFormat, OMX_VIDEO_CODINGTYPE* aCodingType, TInt aStride, TReal aFps, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetCameraOneShotL(const TDesC8& aComp, TInt aIsOneShot, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetCameraCaptureL(const TDesC8& aComp, TInt aPortIndex, TInt aIsCapturing, OMX_ERRORTYPE aExpectedError) = 0; + virtual void MosParseError(const TDesC& aError) = 0; + virtual TBool MosWaitL(TTimeIntervalMicroSeconds32 aDelay) = 0; + virtual TBool MosExpectEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2) = 0; + virtual TBool MosWaitForAllEventsL() = 0; + virtual TBool MosCheckStateL(const TDesC8& aComp, OMX_STATETYPE aState) = 0; + virtual TBool MosCheckVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_VIDEO_CODINGTYPE aCoding, OMX_COLOR_FORMATTYPE aColorFormat) = 0; + virtual TBool MosCheckMetaDataL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData) = 0; + virtual TBool MosGetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData) = 0; + virtual TBool MosSetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData) = 0; + + virtual TBool MosDisablePort(const TDesC8& aComp, TInt aPortIndex) = 0; + virtual TBool MosEnablePort(const TDesC8& aComp, TInt aPortIndex) = 0; + virtual TBool MosIgnoreEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2) = 0; + virtual TBool MosSetPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample, OMX_NUMERICALDATATYPE aNumData, OMX_ENDIANTYPE aEndian, OMX_BOOL* aInterleaved, const TDesC8* aEncoding) = 0; + virtual TBool MosSetConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosCheckConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume) = 0; + virtual TBool MosCheckConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute) = 0; + virtual TBool MosSetConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute) = 0; + virtual TBool MosSetAacAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAacTools, TInt aAacErTools, TInt aProfile, TInt aStreamFormat, TInt aChannelMode) = 0; + virtual TBool MosSetAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, OMX_AUDIO_CODINGTYPE* aCodingType, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetRefClockTypeL(const TDesC8& aComp, OMX_TIME_REFCLOCKTYPE aRefClockType) = 0; + virtual TBool MosSetClockTimeScale(const TDesC8& aComp, OMX_S32 aScale) = 0; + virtual TBool MosSetClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState, TInt aStartTime, TInt aOffset, TUint32 aWaitMask) = 0; + virtual TBool MosCheckClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState) = 0; + virtual TBool MosCheckTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) = 0; + virtual TBool MosSetTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) = 0; + virtual TBool MosSetClientStartTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) = 0; + virtual TBool MosSetCurrentAudioReferenceTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) = 0; + virtual TBool MosSetVideoFitModeL(TVideoFitMode aVideoFitMode) = 0; + virtual TBool MosNegativeSetDataChunk(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError, TInt aExpectedSystemError) = 0; + virtual TBool MosSetBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosGetAndCompareBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare) = 0; + virtual TBool MosGetAndCompareBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare) = 0; + virtual TBool MosFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosForceBufferSourceFlushBufferL(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosForceBufferSinkFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetActiveStream(const TDesC8& aComp, TUint32 aPortIndex)= 0; + virtual TBool MosGetActiveStream(const TDesC8& aComp, TUint32 aPortIndex) = 0; + virtual TBool MosSetDroppedFrameEvent(const TDesC8& aComp, const TDesC8& aAction) = 0; + virtual TBool MosCheckFrameCountL(const TDesC& aFilename, TInt aCount) = 0; + virtual TBool MosMarkBuffer(const TDesC8& aComp, TInt aPortIndex, const TDesC8& aTargetComp, TInt markData) = 0; + // mpeg4 encoder component + virtual TBool MosSetVideoEncQuantL(const TDesC8& aComp, TInt aPortIndex, TInt aQpb) = 0; + virtual TBool MosSetVideoEncMotionVectL(const TDesC8& aComp, TInt aPortIndex, TInt aAccuracy, TInt aSxSearchrange, TInt aSySearchrange, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetVideoEncMpeg4TypeL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_MPEG4PROFILETYPE aMpeg4Profile, OMX_VIDEO_MPEG4LEVELTYPE aMpeg4Level, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosSetVideoEncBitRateL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_CONTROLRATETYPE aControlRate, TInt aTargetBitrate, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosChangeFilledBufferLength(const TDesC8& aComp, TInt aValue) = 0; + virtual TBool MosSetOMX_SymbianIndexParamBufferMsgQueueData(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError) = 0; + virtual TBool MosGetExtensionIndex(const TDesC8& aComp, const TDesC8& aParameterName, OMX_ERRORTYPE aExpectedError) = 0; + + virtual TBool MosCheckTimeClockState(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aExpectedState) = 0; + virtual TBool MosCheckMediaTime(const TDesC8& aComp, TInt aPortIndex, OMX_TICKS aMediaTime, TBool aMoreThan) = 0; + + // Buffer component handler + virtual TBool InitialiseBufferHandlerL(const TDesC8& aComp, TDesC& aName, const TDesC8* aType) = 0; + virtual void StartBufferHandler() = 0; + virtual void StopBufferHandler() = 0; + virtual TBool InitialiseBufferSinkHandlerL(const TDesC8& aComp, TDesC& aName) = 0; + virtual void StartBufferSinkHandler() = 0; + virtual void StopBufferSinkHandler() = 0; + virtual void SendInvalidBufferId(TInt aInvalidId) = 0; + + virtual TBool MosWaitEOS(const TDesC8& aComp) = 0; + + virtual TBool MosSetAACProfileL(const TDesC8& aComp, TInt aPortIndex, TInt aChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAACTools, TInt aAACERTools, OMX_AUDIO_AACPROFILETYPE aProfile, OMX_AUDIO_AACSTREAMFORMATTYPE aStreamFormat, OMX_AUDIO_CHANNELMODETYPE aChannelMode) = 0; + virtual TBool MosSetupBufferForPortL(const TDesC8& comp,TInt aPortIndex, const TDesC& aFileName,TInt aHeaderLength,OMX_BUFFERSUPPLIERTYPE aSupplier) = 0; + + // Camera + + virtual TBool MosSetSensorModeTypeL(const TDesC8& aComp, TInt aPort, TInt aFrameRate, TBool aOneShot, TInt aWidth, TInt aHeight) = 0; + virtual TBool MosSetCaptureModeTypeL(const TDesC8& aComp, TInt aPort, TBool aContinuous, TBool aFrameLimited, TInt aFrameLimit) = 0; + + + // Debugging/Utility functions. + virtual TBool MosDeleteFileL(const TDesC& aFileName, TBool aFileMustExist) = 0; + virtual TBool MosLogAllEventsL() = 0; + + // Methods supporting generic Base Profile communications support with components + virtual TBool MosBaseSupportPortL(const TDesC8& aComp, TInt aPortIndex) = 0; + virtual TBool MosBaseSetAutonomous(const TDesC8& aComp, TInt aPortIndex, TBool aEnabled) = 0; + virtual TBool MosBaseAllocateBuffersL(const TDesC8& aComp, TInt aPortIndex, TInt aNumberBuffers) = 0; + virtual TBool MosBaseFreeAllocatedBuffersL(const TDesC8& aComp) = 0; + virtual TBool MosBaseSetBufSupplier(const TDesC8& aComp, TInt aPortIndex, TBool aComponentSupplier) = 0; + virtual TBool MosBaseFillThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) = 0; + virtual TBool MosBaseEmptyThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) = 0; + virtual TBool MosBaseWaitForBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) = 0; + + // Methods supporting the Timestamp checking implementation for Base Profile testing + virtual TBool MosBaseTimestampPassClock(const TDesC8& aCompReceiving, const TDesC8& aClockCompToPass) = 0; + virtual TBool MosBaseTimestampCheckTimestampL(const TDesC8& aComp, TInt aPortIndex, TUint aExpectedTime, TUint aTolerance) = 0; + virtual TBool MosBaseTimestampCompareWithRefClockL(const TDesC8& aComp, TInt aPortIndex, TUint aTolerance) = 0; + + virtual TBool MosStartBuffersforPort( const TDesC8& aComp, TInt aPortIndex) = 0; +#ifdef OLD_ADPCM_EXTENSION + virtual TBool MosSetAdPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample) = 0; + virtual TBool MosConfigAdPcmDecoderBlockAlign(const TDesC8& aComp, OMX_S32 aBlockAlign) = 0; +#endif + }; + +/** + * This parses an XML file to drive the operation of a MOmxScriptIf. + */ +NONSHARABLE_CLASS(COmxScriptParser) : public CBase, public Xml::MContentHandler + { +public: + static COmxScriptParser* NewL(RFs& aFs, const TDesC& aFilename, MOmxScriptIf& aCallback); + ~COmxScriptParser(); + + TBool RunScriptL(const TDesC& aSectionName); + + // Xml::MContentHandler interface + void OnStartDocumentL(const RDocumentParameters& aDocParam, TInt aErrorCode); + void OnEndDocumentL(TInt aErrorCode); + void OnStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes, + TInt aErrorCode); + void OnEndElementL(const RTagInfo& aElement, TInt aErrorCode); + void OnContentL(const TDesC8& aBytes, TInt aErrorCode); + void OnStartPrefixMappingL(const RString& aPrefix, const RString& aUri, + TInt aErrorCode); + void OnEndPrefixMappingL(const RString& aPrefix, TInt aErrorCode); + void OnIgnorableWhiteSpaceL(const TDesC8& aBytes, TInt aErrorCode); + void OnSkippedEntityL(const RString& aName, TInt aErrorCode); + void OnProcessingInstructionL(const TDesC8& aTarget, const TDesC8& aData, + TInt aErrorCode); + void OnError(TInt aErrorCode); + TAny* GetExtendedInterface(const TInt32 aUid); + +protected: + COmxScriptParser(RFs& aFs, MOmxScriptIf& aCallback); + void ConstructL(const TDesC& aFilename); + +private: + static const TDesC8* FindAttribute(const RArray& aArray, const TDesC8& aAttribName); + const TDesC8& FindAttributeL(const RArray& aArray, const TDesC8& aAttribName); + static void ParseCompPortL(const TDesC8& aInput, TPtrC8& aNameOut, TInt& aPortOut); + static OMX_STATETYPE ParseOmxStateL(const TDesC8& aStateDes); + static OMX_BUFFERSUPPLIERTYPE ParseOmxSupplierL(const TDesC8& aSupplierDes, TBool aAllowUnspecified = EFalse); + void CheckForAbortL(TBool success); + static TInt ParseOptionalIntL(const RArray& aArray, const TDesC8& aAttribName, TInt aDefaultValue); + static TReal ParseOptionalRealL(const RArray& aArray, const TDesC8& aAttribName, TReal aDefaultValue); + static OMX_COLOR_FORMATTYPE ParseOmxColorFormatL(const TDesC8& aDes); + static OMX_EVENTTYPE ParseOmxEventL(const TDesC8& aEventDes); + static TUint32 ParseUint32L(const TDesC8& aDes); + static TReal32 ParseReal32L(const TDesC8& aDes); + static OMX_VIDEO_CODINGTYPE ParseOmxVideoCodingL(const TDesC8& aDes); + static TBool ParseOptionalBooleanL(const RArray& aArray, const TDesC8& aAttribName, TBool aDefaultValue); + static TBool ParseBooleanL(const TDesC8& aBool); + + static OMX_METADATASCOPETYPE ParseOmxScopeTypeL(const TDesC8& aScopeDes); + static OMX_AUDIO_CODINGTYPE ParseOmxAudioCodingL(const TDesC8& aDes); + static OMX_TIME_REFCLOCKTYPE ParseOmxRefClockTypeL(const TDesC8& aDes); + static OMX_TIME_CLOCKSTATE ParseOmxClockStateL(const TDesC8& aDes); + static TVideoFitMode ParseVideoFitModeL(const TDesC8& aMode); + static OMX_COMMANDTYPE ParseOmxCommandL(const TDesC8& aDes); + static OMX_ERRORTYPE ParseOmxErrorL(const TDesC8& aDes); + static TBool ParseBoolean(const TDesC8& aDes); + + static OMX_ERRORTYPE ParseOmxErrorCode(const TDesC8& aErrorCode); + static OMX_VIDEO_MPEG4PROFILETYPE ParseOmxMpeg4ProfileL(const TDesC8& aDes); + static OMX_VIDEO_MPEG4LEVELTYPE ParseOmxMpeg4LevelL(const TDesC8& aDes); + static OMX_VIDEO_CONTROLRATETYPE ParseOmxControlRateL(const TDesC8& aDes); + static OMX_AUDIO_AACPROFILETYPE ParseOmxAACProfileL(const TDesC8& aProfileDes); + static OMX_AUDIO_AACSTREAMFORMATTYPE ParseOmxAACStreamFormatL(const TDesC8& aFormatDes); + static OMX_AUDIO_CHANNELMODETYPE ParseOmxAudioChannelModeL(const TDesC8& aChannelModeDes); + static TInt ParseSystemErrorCode(const TDesC8& aErrorCode); + static OMX_AUDIO_AACSTREAMFORMATTYPE ParseAacStreamFormatL(const TDesC8& aStreamFormatStr); + static OMX_NUMERICALDATATYPE ParseNumericalDataL(const TDesC8& aDes); + static OMX_ENDIANTYPE ParseEndianL(const TDesC8& aDes); + static OMX_BOOL ParseBoolL(const TDesC8& aDes); + +private: + RFs& iFs; + RBuf iFilename; + MOmxScriptIf& iCallback; + + // state to allow filtering for a specific section within the XML document + const TDesC* iSectionName; // not owned + TBool iInTest; + TBool iFoundTest; + TBool iCallbackAborted; + }; + +#endif /*OMXSCRIPTPARSER_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxscripttest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxscripttest.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,4118 @@ +/* +* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + +#include "omxscripttest.h" +#include "paramconversion.h" +#include "statedes.h" + +#include "omxilsymbianvideographicsinkextensions.h" +#include +#include +#include +#include "omxutil.h" +#include "nontunneledhandler.h" +#include "videobufferhandler.h" +#include "videobufferhandler_mpeg4.h" // for mpeg4 +#include "videobuffersinkhandler.h" +#include "log.h" +#include "omx_xml_script.h" +#include "transition.h" +#include "parsemap.h" +#include +#include "omxildroppedframeeventextension.h" +#include +#include "baseprofilehandler.h" +#include "baseprofiletimestamping.h" +#include "windowmanager.h" +#ifdef OLD_ADPCM_EXTENSION +#include +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Temporary work-around for floating point issues on HREF 8500 ED hardware +// Using this macro, code that uses TReal will be #defined out if running on ED. +// TODO: Remove HREF_ED_WITHOUT_FLOATING_POINT and all of its conditional code +// once the floating point issue has been solved. +#if defined(NCP_COMMON_BRIDGE_FAMILY) && !defined(__WINSCW__) +#define HREF_ED_WITHOUT_FLOATING_POINT +#endif + +DECL_PARSETYPE(OMX_EVENTTYPE); + +_LIT8(KILTypeString, "LOGICAL"); + +static TInt StopScheduler(TAny* unused); + +/** + * Runs an OMX test specified in an XML file. + * @param aScriptFilename path to XML file + * @param aScriptSection section name in XML file + */ +void ROmxScriptTest::RunTestL(const TDesC& aScriptFilename, const TDesC& aScriptSection) + { + User::LeaveIfError(iEventHandler.Create()); + iStopSchedulerCallback = new(ELeave) CAsyncCallBack(StopScheduler, CActive::EPriorityHigh); + + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + + INFO_PRINTF3(_L("Executing test steps in section %S of %S"), &aScriptSection, &aScriptFilename); + + TPtrC filename; + COmxScriptParser* parser = COmxScriptParser::NewL(fs, aScriptFilename, *this); + CleanupStack::PushL(parser); + + // this drives the methods from MOmxScriptIf + TBool success = parser->RunScriptL(aScriptSection); + if(success) + { + StopTest(EPass); + } + else + { + ERR_PRINTF1(_L("Script did not complete")); + StopTest(EFail); + } + + CleanupStack::PopAndDestroy(2, &fs); // fs, parser + + User::LeaveIfError(Reason()); + } + +/** + * Constructs an object to parse and execute an OMX test case specified in + * an XML file. + * @param reference to logger interface to receive test messages + */ +ROmxScriptTest::ROmxScriptTest(MOmxScriptTestLogger& aLogger): + iCoreLoaded(EFalse), + iEventHandler(*this), + iState(OMX_StateLoaded), + iWindowManager(NULL), + iVideoFitMode(EVideoFitRotateScaleAndCentre), + iTimer(NULL), + iWaitingForEvents(EFalse), + iNonTunneledHandler(NULL), + iBufferHandler(NULL), + iBufferSinkHandler(NULL), + iReason(KErrNone), + iVerdict(EPending), + iLogger(aLogger), + iStopSchedulerCallback(NULL), + iPortBufferHandler(NULL) + { + } + +/** + * Destroys all resources created by this object. + */ +void ROmxScriptTest::Close() + { + // release memory and unload components + // ~CComponentInfo unloads component in correct thread + iComponents.ResetAndDestroy(); + + if(iCoreLoaded) + { + INFO_PRINTF1(_L("OMX_Deinit()")); + iCoreLoaded = EFalse; + OMX_ERRORTYPE error = OMX_Deinit(); + if(error) + { + FailWithOmxError(_L("OMX_Deinit"), error); + } + } + REComSession::FinalClose(); + iEventHandler.Close(); + delete iWindowManager; + iWindowManager = NULL; + iState = OMX_StateLoaded; + + if (iTimer) + { + iTimer->Cancel(); + delete iTimer; + iTimer = NULL; + } + + iExpectedEvents.Close(); + iIgnoredEvents.Close(); + + if (iNonTunneledHandler) + { + delete iNonTunneledHandler; + iNonTunneledHandler = NULL; + } + + if(iPortBufferHandler) + { + delete iPortBufferHandler; + iPortBufferHandler = NULL; + } + + // Buffer component + delete iBufferHandler; + iBufferHandler = NULL; + + delete iBufferSinkHandler; + iBufferSinkHandler = NULL; + + delete iStopSchedulerCallback; + iStopSchedulerCallback = NULL; + + iTunnels.Close(); + } + +// allows OMX components to be placed on the cleanup stack +//void ROmxScriptTest::CleanupOmxComponent(TAny* aPtr) +// { +// OMX_COMPONENTTYPE* component = static_cast(aPtr); +// OMX_ERRORTYPE error = OMX_FreeHandle(component); +// // if this method is called, we are already in an error condition, +// // but OMX_FreeHandle should still succeed. Perhaps a cleaner way of +// // reporting any error is desired, but this is a static method so we +// // lack the context to call the standard logging mechanism. +// __ASSERT_DEBUG(!error, User::Invariant()); +// } + +TBool ROmxScriptTest::MosLoadComponentL(const TDesC8& aComp, const TDesC8& aName, TBool aBaseProfile, const TDesC8* aBaseImpl, TBool aLoadInCoreServerThread) + { + if(!iCoreLoaded) + { + INFO_PRINTF1(_L("OMX_Init()")); + OMX_ERRORTYPE error = OMX_Init(); + if(error) + { + CleanupStack::PopAndDestroy(2); + FailWithOmxError(_L("OMX_Init()"), error); + return EFalse; + } + iCoreLoaded = ETrue; + } + + // convert from 8-bit descriptor for logging + TBuf<64> nameCopy; + nameCopy.Copy(aName); + INFO_PRINTF2(_L("Loading component %S"), &nameCopy); + + CComponentInfo* componentInfo = CComponentInfo::NewL(*this); + CleanupStack::PushL(componentInfo); + componentInfo->iShortName = HBufC8::NewL(aComp.Length()); + *(componentInfo->iShortName) = aComp; + // allow room for the '\0' used in call to OMX_GetHandle + componentInfo->iComponentName = HBufC8::NewL(aName.Length() + 1); + *(componentInfo->iComponentName) = aName; + + + OMX_ERRORTYPE error = OMX_ErrorNone; + if (aBaseProfile) + { + if (*aBaseImpl == _L8("base")) + { + componentInfo->iBaseHandler = new (ELeave) CBaseProfileHandler(*this, iEventHandler); + componentInfo->iComponent = componentInfo->iBaseHandler->LoadComponentL(*componentInfo->iShortName, *componentInfo->iComponentName); + + } + else if (*aBaseImpl == _L8("timestampcheck")) + { + componentInfo->iBaseHandler = new (ELeave) CBaseProfileTimestampHandling(*this, iEventHandler); + componentInfo->iComponent = componentInfo->iBaseHandler->LoadComponentL(*componentInfo->iShortName, *componentInfo->iComponentName); + + } + + } + else + { + OMX_CALLBACKTYPE& callbacks = iEventHandler.CallbackStruct(); + // NOTE componentInfo.iShortName and componentInfo.iComponentName still on the cleanup stack + + if(aLoadInCoreServerThread) + { + INFO_PRINTF2(_L("Loading component %S in Core Server thread"), &nameCopy); + if(componentInfo->iThreadRequest == NULL) + { + componentInfo->iThreadRequest = COmxThreadRequest::NewL(); + } + error = componentInfo->iThreadRequest->GetHandle((TAny**) &(componentInfo->iComponent), (OMX_STRING) componentInfo->iComponentName->Des().PtrZ(), &iEventHandler, &callbacks); + } + else + { + INFO_PRINTF2(_L("Loading component %S in Client thread"), &nameCopy); + error = OMX_GetHandle((TAny**) &(componentInfo->iComponent), (OMX_STRING) componentInfo->iComponentName->Des().PtrZ(), &iEventHandler, &callbacks); + } + } + if(error || (componentInfo->iComponent == NULL)) + { + CleanupStack::PopAndDestroy(); // delete component info + FailWithOmxError(_L("OMX_GetHandle()"), error); + return EFalse; + } + + RDebug::Print(_L("OMX_GetHandle name=%S handle=0x%08X"), &nameCopy, componentInfo->iComponent); + iEventHandler.AddComponentL(componentInfo->iComponent, nameCopy); + iComponents.AppendL(componentInfo); + CleanupStack::Pop(1, componentInfo); + return ETrue; + } + +TBool ROmxScriptTest::MosSetupTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* source = NULL; + OMX_COMPONENTTYPE* sink = NULL; + if(aSourceComp!=KNullDesC8) + { + source = ComponentByName(aSourceComp); + } + + if(aSinkComp!=KNullDesC8) + { + sink = ComponentByName(aSinkComp); + } + + //support for testing tunnel breakup + if(source || sink) + { + OMX_ERRORTYPE error = OMX_SetupTunnel(source, aSourcePort, sink, aSinkPort); + // TODO check tunnel reconfiguration + if(error == OMX_ErrorNone) + { + RegisterTunnel(source, aSourcePort, sink, aSinkPort); + } + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosSetupTunnel OMX_SetupTunnel: Error 0x%X does not match expected error 0x%X"), error, aExpectedError); + TBuf8<64> msg8; + msg8.Format(_L8("source=%S:%d sink=%S:%d"), &aSourceComp, aSourcePort, &aSinkComp, aSinkPort); + TBuf<64> msg; + msg.Copy(msg8); + INFO_PRINTF1(msg); + return EFalse; + } + return ETrue; + } + else + { + // source or sink names not recognized + return EFalse; + } + } + +TBool ROmxScriptTest::MosSetupNonTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier) + { + OMX_COMPONENTTYPE* source = ComponentByName(aSourceComp); + OMX_COMPONENTTYPE* sink = ComponentByName(aSinkComp); + if(source && sink) + { + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = aSourcePort; + OMX_ERRORTYPE error = source->GetParameter(source, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + TInt numBufs = portDef.nBufferCountActual; + TInt bufSize = portDef.nBufferSize; + + portDef.nPortIndex = aSinkPort; + error = sink->GetParameter(sink, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + if (portDef.nBufferCountActual != numBufs) + { + ERR_PRINTF1(_L("Number of buffers does not match for non tunneled setup")); + return EFalse; + } + + if (portDef.nBufferSize > bufSize) + { + bufSize = portDef.nBufferSize; + } + + if (!iNonTunneledHandler) + { + iNonTunneledHandler = new CNonTunneledHandler(); + + if (!iNonTunneledHandler) + { + return EFalse; + } + } + + TRAPD(err, iNonTunneledHandler->AddLinkL(source, aSourcePort, sink, aSinkPort, aSupplier, numBufs, bufSize)); + if (err != KErrNone) + return EFalse; + + return ETrue; + } + else + { + // source or sink names not recognized + return EFalse; + } + } + + +TBool ROmxScriptTest::MosSetupBufferForPortL(const TDesC8& aComp,TInt aPortIndex, const TDesC& aFileName,TInt aHeaderLength,OMX_BUFFERSUPPLIERTYPE aSupplier) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF3(_L("MosSetupBufferForPort comp %S port %d"), &compConverted, aPortIndex); + OMX_COMPONENTTYPE* comp = ComponentByName(aComp); + + if(comp) + { + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = comp->GetParameter(comp, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + OMX_DIRTYPE portDirType = portDef.eDir; + + if(!iPortBufferHandler) + { + iPortBufferHandler = new (ELeave)CPortBufferHandler; + } + + iPortBufferHandler->AddPortL(comp,aPortIndex,aFileName,aSupplier,portDirType,iLogger,aHeaderLength); + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetWindowL(const TDesC8& aComp) + { + if(iWindowManager) + { + delete iWindowManager; + iWindowManager = NULL; + } + iWindowManager = CWindowManager::NewL(); + TSize screenSize = iWindowManager->ScreenSize(); + INFO_PRINTF3(_L("Screen size is %dx%d"), screenSize.iWidth, screenSize.iHeight); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + iGraphicSink = component; + + OMX_ERRORTYPE error = OMX_GetExtensionIndex(component, const_cast(sOmxSymbianGfxSurfaceConfig), &iExtSurfaceConfigIndex); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex(sOmxSymbianGfxSurfaceConfig)"), error); + return EFalse; + } + + //Temporary Hack: This is for Logical IL Video Tests: SurfaceId is supposed to be set in response to PortSettingsChanged event from + //MMHP. Currently, there is no support for it. Hence, we are temporarily setting here + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = 0; + error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + error = component->SetParameter(component, OMX_IndexParamPortDefinition, &portDef); + + if(error==OMX_ErrorIncorrectStateOperation) + { + OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION surfaceConfigParam; + surfaceConfigParam.nSize = sizeof(OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION); + surfaceConfigParam.nVersion = KOmxVersion; + surfaceConfigParam.nPortIndex = 0; + + // define must be removed when hack is removed - OMX_GetExtensionIndex() should be used but hack for when this + // returns an error + #define OMX_SymbianIndexParamVideoGFXSurfaceConfig 0x7F000011 + OMX_ERRORTYPE omxError = component->GetParameter(component, (OMX_INDEXTYPE) OMX_SymbianIndexParamVideoGFXSurfaceConfig, &surfaceConfigParam); + if(omxError != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter(OMX_SymbianIndexParamVideoGFXSurfaceConfig)"), omxError); + return EFalse; + } + + TSurfaceConfiguration& surfaceConfig = *reinterpret_cast(surfaceConfigParam.pSurfaceConfig); + + TRect rect(0,0,320,240); + TInt err = surfaceConfig.SetExtent(rect); + if (err == KErrNone) + { + err =iWindowManager->SetBackgroundSurface(surfaceConfig, ETrue); + } + + if(err) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + } + else if(error) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetDroppedFrameEvent(const TDesC8& aComp, const TDesC8& aAction) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + TBuf8<80> extension; + + if (aAction == _L8("invalidextension")) + { + extension.Append(_L8("OMX.NOKIA.INDEX.PARAM.INVALIDEXTENSION")); + } + else + { + extension.Append(_L8("OMX.NOKIA.INDEX.PARAM.DROPPEDFRAMEEVENT")); + } + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + + if (aAction == _L8("invalidextension")) + { + if (error != OMX_ErrorUnsupportedIndex) + { + ERR_PRINTF2(_L("GetExtensionIndex with invalid extension incorrectly returned error 0x%X"), error); + StopTest(EFail); + return EFalse; + } + return ETrue; + } + + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex"), error); + return EFalse; + } + + OMX_NOKIA_PARAM_DROPPEDFRAMEEVENT exten; + exten.nSize = sizeof(exten); + exten.nVersion = KOmxVersion; + exten.nPortIndex = 0; + + if(aAction == _L8("enable")) + { + exten.bEnabled = OMX_TRUE; + error = component->SetParameter(component, indexType, &exten); + if(error) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + return ETrue; + } + else + { + exten.bEnabled = OMX_FALSE; + error = component->SetParameter(component, indexType, &exten); + if(error) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + return ETrue; + } + } + +TBool ROmxScriptTest::MosAllTransitionL(OMX_STATETYPE aState, OMX_ERRORTYPE aExpectedError, TTransitionOrder aOrder) + { + INFO_PRINTF2(_L("Transitioning all components to %S"), StateDes(aState)); + if(aOrder == ELoadOrder && aState == OMX_StateIdle && iState == OMX_StateLoaded) + { + WARN_PRINTF1(_L("Using component load order for loaded -> idle transition order")); + } + iEventHandler.AwaitTransition(aState, iState); + RArray order; + CleanupClosePushL(order); + order.ReserveL(iComponents.Count()); + if(aOrder == ELoadOrder) + { + for(TInt index = 0; index < iComponents.Count(); index++) + { + order.Append(index); + } + } + else if(aOrder == EAutoOrder) + { + TRAPD(error, FindTransitionOrderL(iComponents, iTunnels, order)); + if(error != KErrNone) + { + ERR_PRINTF2(_L("Error determining transition order, error=%d"), error); + User::Leave(error); + } + } + + if(aState == OMX_StateIdle && iState == OMX_StateExecuting) + { + // use reverse order for Idle->Executing transition + TInt left = 0, right = order.Count() - 1; + while(left < right) + { + TInt tmp = order[left]; + order[left] = order[right]; + order[right] = tmp; + left++; + right--; + } + } + + if(aOrder == EAutoOrder) + { + TBuf<128> orderDes; + for(TInt index = 0, count = order.Count(); index < count; index++) + { + HBufC8* name8 = iComponents[order[index]]->iShortName; + TBuf<16> name; + name.Copy(*name8); + if(index > 0) + { + orderDes.Append(_L(", ")); + } + orderDes.Append(name); + } + INFO_PRINTF2(_L("Auto-detected transition order: %S"), &orderDes); + } + + TBool commandError = EFalse; + TBool ret = EFalse; + for(TInt orderIndex = 0, count = order.Count(); orderIndex < count; orderIndex++) + { + TInt index = order[orderIndex]; + CComponentInfo* compInfo = iComponents[index]; + OMX_COMPONENTTYPE* component = compInfo->iComponent; + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandStateSet, aState, NULL); + if(error) + { + TBuf<128> msg; + msg.Format(_L("SendCommand(OMX_CommandStateSet, %S)"), StateDes(aState)); + if(error != aExpectedError) + { + FailWithOmxError(compInfo->iShortName->Des(), msg, error); + ret = EFalse; + } + else //Need to stop the tests now be cause an error has occurred, even if it is expected. + { + StopTest(EPass); + ret = ETrue; + } + commandError = ETrue; + break; + } + + if (!HandleNonTunneledBuffers(aState, component)) + { + commandError = ETrue; + ret = EFalse; + break; + } + if(!HandlePortBufferHandler(aState, component)) + { + return EFalse; + } + } + CleanupStack::PopAndDestroy(&order); + if(commandError) + { + return ret; + } + + // wait for the transitions to complete + // use a nested loop of the active scheduler + // AllComponentsTransitioned() calls EndWait() + BeginWait(); + return Reason() == KErrNone; + } + +TBool ROmxScriptTest::MosTransition(const TDesC8& aComp, OMX_STATETYPE aState, TBool aAsync) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF3(_L("Transitioning %S component to %S"), &compConverted, StateDes(aState)); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + if (!aAsync) + { + iEventHandler.AwaitSingleTransition(component, aState, iState); + } + else + { + //Don't want to force a wait on this state transition so instead of using the event handler add the event to the expected list + TExpectedEvent event; + event.iComponent = component; + event.iEvent = OMX_EventCmdComplete; + event.iData1 = OMX_CommandStateSet; + event.iData2 = aState; + event.iEventData = NULL; + TRAPD(err, iExpectedEvents.AppendL(event)); + if (err != KErrNone) + return EFalse; + } + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandStateSet, aState, NULL); + if(error) + { + FailWithOmxError(_L("SendCommand(OMX_CommandStateSet)"), error); + return EFalse; + } + + if (!HandleNonTunneledBuffers(aState, component)) + { + return EFalse; + } + + if(!HandlePortBufferHandler(aState, component)) + { + return EFalse; + } + + if (!aAsync) + { + BeginWait(); + } + return Reason() == KErrNone; + } + +TBool ROmxScriptTest::MosFailingTransition(const TDesC8& aComp, OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF3(_L("Transitioning %S component to %S"), &compConverted, StateDes(aState)); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandStateSet, aState, NULL); + if(error == aExpectedError) + { + return ETrue; + } + else + { + return EFalse; + } + } + +TBool ROmxScriptTest::MosWaitEOS() + { + // AllComponentsEOS() calls EndWait() + INFO_PRINTF1(_L("Waiting for End of Stream from all components")); + iEventHandler.AwaitEOS(); + BeginWait(); + return ETrue; + } + +TBool ROmxScriptTest::MosWaitEOS(const TDesC8& aComp) + { + // AllComponentsEOS() calls EndWait() + TBuf<16> comp16; + comp16.Copy(aComp); + INFO_PRINTF2(_L("Waiting for End of Stream from component %S"), &comp16); + OMX_COMPONENTTYPE* compHandle = ComponentByName(aComp); + if(compHandle == NULL) + { + return EFalse; + } + iEventHandler.AwaitEOS(compHandle); + BeginWait(); + return ETrue; + } + +TBool ROmxScriptTest::MosWaitL(TTimeIntervalMicroSeconds32 aDelay) + { + if (iTimer) + { + iTimer->Cancel(); + } + else + { + iTimer = CVideoTestTimer::NewL(*this); + } + + iTimer->Start(aDelay); + BeginWait(); + return ETrue; + } + +TBool ROmxScriptTest::MosExpectEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + TExpectedEvent event; + event.iComponent = component; + event.iEvent = aEvent; + event.iData1 = aData1; + event.iData2 = aData2; + event.iEventData = NULL; + iExpectedEvents.AppendL(event); + + return ETrue; + } + +TBool ROmxScriptTest::MosWaitForAllEventsL() + { + if(iExpectedEvents.Count() > 0) + { + iWaitingForEvents = ETrue; + BeginWait(); + iWaitingForEvents = EFalse; + __ASSERT_ALWAYS(iExpectedEvents.Count() == 0, User::Invariant()); + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetFilename(const TDesC8& aComp, const TDesC& aFilename) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF3(_L("Setting filename on component %S to %S"), &compConverted, &aFilename); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_CONTENTURITYPE* contentURI = NULL; + TRAPD(err, contentURI = ParamConversion::FilenameAsContentUriStructV1_1L(aFilename)); + if(err==KErrBadName)//logical IL tests pass just the filename. so try adding the directory path + { + TBuf<64> fileName; + fileName.Copy(KPortDirectoryPath); + fileName.Append(aFilename); + err=KErrNone; + TRAP(err, contentURI = ParamConversion::FilenameAsContentUriStructV1_1L(fileName)); + } + if(err) + { + ERR_PRINTF2(_L("Error converting filename to OMX_CONTENTURI (%d)"), err); + return EFalse; + } + OMX_ERRORTYPE error = component->SetParameter(component, OMX_IndexParamContentURI, contentURI); + delete contentURI; + if(error) + { + FailWithOmxError(_L("SetParameter(OMX_IndexParamContentURI)"), error); + return EFalse; + } + else + { + return ETrue; + } + } + +TBool ROmxScriptTest::MosSetFilename_bellagio(const TDesC8& aComp, char *filepath) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + + //INFO_PRINTF3(_L("Setting filename on component %S to %S"), &compConverted, filepath); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + + if(!component) + { + return EFalse; + } + OMX_INDEXTYPE indexType; + OMX_ERRORTYPE omx_err; + + // Setting the input file name for File Source Component + omx_err = OMX_GetExtensionIndex(component, "OMX.Nokia.index.config.filename",&indexType); + + if(omx_err != OMX_ErrorNone) + { + return EFalse; + } + + OMX_ERRORTYPE error = OMX_SetConfig(component,indexType,filepath); + + if(error) + { + return EFalse; + } + else + { + return ETrue; + } + + } + +TBool ROmxScriptTest::MosSetBadFilename(const TDesC8& aComp) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF2(_L("Setting filename on component %S"), &compConverted); + + TText8 cstr[6] = {':', 'e' ,'l' ,'l' ,'o','\0'}; + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + OMX_PARAM_CONTENTURITYPE* contentURI = reinterpret_cast(new TUint8[15]); + if (!contentURI) + return EFalse; + + TPtr8 uriStructDes(contentURI->contentURI, sizeof(cstr)); + uriStructDes = cstr; + + OMX_ERRORTYPE error = component->SetParameter(component, OMX_IndexParamContentURI, contentURI); + delete contentURI; + + return ETrue; + + } + +TBool ROmxScriptTest::MosGetFilename(const TDesC8& aComp, TDesC& aFilename, OMX_ERRORTYPE aExpectedError) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF2(_L("Getting filename on component %S"), &compConverted); + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + OMX_PARAM_CONTENTURITYPE* contentURI = NULL; + TRAPD(err, contentURI = ParamConversion::FilenameAsContentUriStructV1_1L(aFilename)); + if(err) + { + ERR_PRINTF2(_L("Error converting filename to OMX_CONTENTURI (%d)"), err); + return EFalse; + } + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamContentURI, contentURI); + delete contentURI; + if((error != aExpectedError) && (error != OMX_ErrorOverflow) && (error != OMX_ErrorUnsupportedSetting)) + { + TBuf<64> errorDes; + OMXUtil::ErrorDes(error, errorDes); + TBuf<64> expectedErrorDes; + OMXUtil::ErrorDes(aExpectedError, expectedErrorDes); + ERR_PRINTF3(_L("GetParameter(OMX_IndexParamContentURI) returned %S but expected %S OMX_ErrorOverflow or OMX_ErrorUnsupportedSetting"), + &errorDes, &expectedErrorDes); + StopTest(EFail); + return EFalse; + } + else + { + return ETrue; + } + } + + +void ROmxScriptTest::FormatHex(const TDesC8& bin, TDes& hex) + { + __ASSERT_DEBUG(hex.MaxLength() == bin.Length() * 2, User::Invariant()); + hex.SetLength(0); + for(TInt index = 0, length = bin.Length(); index < length; index++) + { + TUint8 octet = bin[index]; + hex.AppendFormat(_L("%02X"), octet); + } + } + +TBool ROmxScriptTest::MosSetBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nVersion = KOmxVersion; + portDef.nSize = sizeof(portDef); + portDef.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter()"), error); + return EFalse; + } + + portDef.nBufferCountActual = aCount; + + INFO_PRINTF3(_L("MosSetBufferCount count %d; dir %d"), portDef.nBufferCountActual, portDef.eDir); + + error = component->SetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetBufferCount OMX_SetParameter() error 0x%X, expecting 0x%X"), error, aExpectedError); + return EFalse; + } + return ETrue; + } + + +TBool ROmxScriptTest::MosFilterAndCompareFilesL( + const TDesC& aFileOne, const TDesC8& aFile1Filter1, const TDesC8& aFile1Filter2, const TDesC8& aFile1Filter3, + const TDesC& aFileTwo, const TDesC8& aFile2Filter1, const TDesC8& aFile2Filter2, const TDesC8& aFile2Filter3) + { + TBuf8<16> aHashOne, aHashTwo; + + THashFilter f1filter1 = GetHashFilterByName(aFile1Filter1); + THashFilter f1filter2 = GetHashFilterByName(aFile1Filter2); + THashFilter f1filter3 = GetHashFilterByName(aFile1Filter3); + + THashFilter f2filter1 = GetHashFilterByName(aFile2Filter1); + THashFilter f2filter2 = GetHashFilterByName(aFile2Filter2); + THashFilter f2filter3 = GetHashFilterByName(aFile2Filter3); + + HashFileL(aFileOne, aHashOne, f1filter1, f1filter2, f1filter3 ); + HashFileL(aFileTwo, aHashTwo, f2filter1, f2filter2, f2filter3 ); + + if (aHashOne == aHashTwo) + { + INFO_PRINTF1(_L("Filter and compare files = MATCH")); + } + else + { + INFO_PRINTF1(_L("Filter and compare files = FAIL")); + } + + return aHashOne == aHashTwo; + } + +TBool ROmxScriptTest::MosCompareFilesL(const TDesC& aFileOne, const TDesC& aFileTwo) + { + TBuf8<16> aHashOne, aHashTwo; + HashFileL(aFileOne, aHashOne); + HashFileL(aFileTwo, aHashTwo); + return aHashOne == aHashTwo; + } + + +TBool ROmxScriptTest::MosBufferSupplierOverrideL( + const TDesC8& aSourceComp, + TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_ERRORTYPE aExpectedSourceError, + OMX_ERRORTYPE aExpectedSinkError + ) + { + OMX_COMPONENTTYPE* source = ComponentByName(aSourceComp); + OMX_COMPONENTTYPE* sink = ComponentByName(aSinkComp); + if(!source || !sink) + { + return EFalse; + } + + OMX_PARAM_BUFFERSUPPLIERTYPE param; + param.nSize = sizeof(param); + param.nVersion = KOmxVersion; + param.nPortIndex = aSourcePort; + param.eBufferSupplier = aSupplier; + OMX_ERRORTYPE error = source->SetParameter(source, OMX_IndexParamCompBufferSupplier, ¶m); + if(error != aExpectedSourceError) + { + ERR_PRINTF3(_L("MosBufferSupplierOverrideL source->SetParameter error 0x%X, expected 0x%X"), error, aExpectedSourceError); + return EFalse; + } + + param.nPortIndex = aSinkPort; + error = sink->SetParameter(sink, OMX_IndexParamCompBufferSupplier, ¶m); + if(error != aExpectedSinkError) + { + ERR_PRINTF3(_L("MosBufferSupplierOverrideL sink->SetParameter error 0x%X, expected 0x%X"), error, aExpectedSinkError); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetCameraOneShotL(const TDesC8& aComp, TInt aIsOneShot, OMX_ERRORTYPE aExpectedError) + { + //TODO DL + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_SENSORMODETYPE sensorModeType; + sensorModeType.nSize = sizeof(OMX_PARAM_SENSORMODETYPE); + sensorModeType.nVersion = KOmxVersion; + sensorModeType.nPortIndex = OMX_ALL; + OMX_ERRORTYPE error = component->GetParameter(component,OMX_IndexParamCommonSensorMode,&sensorModeType); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + + sensorModeType.bOneShot = aIsOneShot ? static_cast(ETrue) : static_cast(EFalse); + error = component->SetParameter(component,OMX_IndexParamCommonSensorMode,&sensorModeType); + + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosSetCameraOneShotL SetParameter() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetCameraCaptureL(const TDesC8& aComp, TInt aPortIndex, TInt aIsCapturing, OMX_ERRORTYPE aExpectedError) + { + //TODO DL + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_SYMBIAN_CONFIG_BOOLEANTYPE isCapturing; + isCapturing.nSize = sizeof(OMX_SYMBIAN_CONFIG_BOOLEANTYPE); + isCapturing.nVersion = KOmxVersion; + isCapturing.nPortIndex = aPortIndex; + OMX_INDEXTYPE index; + isCapturing.bEnabled = aIsCapturing ? OMX_TRUE : OMX_FALSE; + + OMX_ERRORTYPE check = OMX_GetExtensionIndex(component,"OMX.Symbian.Index.Config.Common.ExtCapturing",&index); + + if(check != OMX_ErrorNone) + { + return EFalse; + } + + OMX_ERRORTYPE error = component->SetConfig(component,/*(OMX_INDEXTYPE)*/index,&isCapturing); + + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosSetCameraCaptureL SetConfig() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_COLOR_FORMATTYPE* aColorFormat, OMX_VIDEO_CODINGTYPE* aCodingType, TInt aStride, TReal aFps, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + if(aWidth != -1) + { + portDef.format.video.nFrameWidth = aWidth; + } + if(aHeight != -1) + { + portDef.format.video.nFrameHeight = aHeight; + } + + if (aColorFormat) + { + portDef.format.video.eColorFormat = *aColorFormat; + } + + if (aCodingType) + { + portDef.format.video.eCompressionFormat = *aCodingType; + } + + if(aStride != -1) + { + portDef.format.video.nStride = aStride; + } +#ifndef HREF_ED_WITHOUT_FLOATING_POINT + if(aFps != -1) + { + //TODO Fixup by removing below camera case, once camera team make appropiate changes to validateframerate function. + //Currently the camera function only allows fps >=15 AND <=120 and it isnt in the Q16 format that is required. + //Leave in the next two lines uncommented. + //TUint32 fpsQ16 = (TUint32) (aFps * 65536 + 0.5); + //portDef.format.video.xFramerate = fpsQ16; + //Changed xml file from 10fps to 15fps due to camera constraint.Will need to be changed back also + //BEGIN HACK CODE + _LIT8(KCamera,"OMX.SYMBIAN.VIDEO.CAMERASOURCE"); + _LIT8(KLogicalILCamera,"OMX.SYMBIAN.LOGICAL.VIDEO.CAMERASOURCE"); + TBool cameraTest = EFalse; + for(TInt index = 0, count = iComponents.Count(); index < count; index++) + { + const CComponentInfo* componentInfo = iComponents[index]; + if(componentInfo->iComponent == component) + { + if((*(componentInfo->iComponentName) == KCamera)||(*(componentInfo->iComponentName) == KLogicalILCamera)) + { + portDef.format.video.xFramerate = aFps; + cameraTest = ETrue; + } + break; + } + } + if(cameraTest == EFalse) + { + TUint32 fpsQ16 = (TUint32) (aFps * 65536 + 0.5); + portDef.format.video.xFramerate = fpsQ16; + } + } + //END HACK CODE. +#else + portDef.format.video.xFramerate = 0; +#endif //HREF_ED_WITHOUT_FLOATING_POINT + error = component->SetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosSetVideoPortDefL SetParameter() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosCheckStateL(const TDesC8& aComp, OMX_STATETYPE aState) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + OMX_STATETYPE state; + OMX_ERRORTYPE error = component->GetState(component, &state); + if(error) + { + FailWithOmxError(_L("GetState()"), error); + return EFalse; + } + if(state != aState) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + ERR_PRINTF4(_L("Expected component %S to be in state %S, actually in %S"), &compConverted, StateDes(aState), StateDes(state)); + StopTest(EFail); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosCheckVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_VIDEO_CODINGTYPE aCoding, OMX_COLOR_FORMATTYPE aColorFormat) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + OMX_VIDEO_PORTDEFINITIONTYPE& vidDef = portDef.format.video; + if( vidDef.nFrameWidth == aWidth && + vidDef.nFrameHeight == aHeight && + vidDef.eCompressionFormat == aCoding && + vidDef.eColorFormat == aColorFormat) + { + return ETrue; + } + else + { + ERR_PRINTF1(_L("video port definition did not match expected values")); + StopTest(EFail); + return EFalse; + } + } + +TBool ROmxScriptTest::MosCheckMetaDataL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_CONFIG_METADATAITEMTYPE* metadata = reinterpret_cast(new(ELeave) TUint8[102400]); + CleanupStack::PushL(metadata); + + metadata->nSize = 102400; + metadata->nVersion = KOmxVersion; + metadata->eScopeMode = aScope; + metadata->nScopeSpecifier = aPortIndex; + metadata->nMetadataItemIndex = aAtomIndex; + metadata->nKeySizeUsed = aAtomType.Length(); + + TPtr8 keyDes(metadata->nKey, metadata->nKeySizeUsed); + keyDes = aAtomType; + + metadata->nValueMaxSize = metadata->nSize - _FOFF(OMX_CONFIG_METADATAITEMTYPE, nValue); + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexConfigMetadataItem, metadata); + if(error) + { + CleanupStack::PopAndDestroy(metadata); + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + + TPtrC8 valueDes(metadata->nValue, metadata->nValueSizeUsed); + if(valueDes.Compare(aData) == 0) + { + CleanupStack::PopAndDestroy(metadata); + return ETrue; + } + else + { + ERR_PRINTF1(_L("Did not read metedata")); + CleanupStack::PopAndDestroy(metadata); + StopTest(EFail); + return EFalse; + } + } + +TBool ROmxScriptTest::MosGetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& /*aData*/) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_CONFIG_METADATAITEMTYPE* metadata = reinterpret_cast(new(ELeave) TUint8[102400]); + CleanupStack::PushL(metadata); + + metadata->nSize = 102400; + metadata->nVersion = KOmxVersion; + metadata->eScopeMode = aScope; + metadata->nScopeSpecifier = aPortIndex; + metadata->nMetadataItemIndex = aAtomIndex; + metadata->nKeySizeUsed = aAtomType.Length(); + + TPtr8 keyDes(metadata->nKey, metadata->nKeySizeUsed); + keyDes = aAtomType; + + metadata->nValueMaxSize = metadata->nSize - _FOFF(OMX_CONFIG_METADATAITEMTYPE, nValue); + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamAudioG723, metadata); + INFO_PRINTF2(_L("MosGetParameterUnknownIndexTypeL: %d"), error); + + CleanupStack::PopAndDestroy(metadata); + + if(error) + { + // This is what we expected + return ETrue; + } + + ERR_PRINTF1(_L("MosGetParameterUnknownIndexTypeL unexpectedly received OMX_ErrorNone")); + StopTest(EFail); + return EFalse; + } + +TBool ROmxScriptTest::MosSetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& /*aData*/) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_CONFIG_METADATAITEMTYPE* metadata = reinterpret_cast(new(ELeave) TUint8[102400]); + CleanupStack::PushL(metadata); + + metadata->nSize = 102400; + metadata->nVersion = KOmxVersion; + metadata->eScopeMode = aScope; + metadata->nScopeSpecifier = aPortIndex; + metadata->nMetadataItemIndex = aAtomIndex; + metadata->nKeySizeUsed = aAtomType.Length(); + + TPtr8 keyDes(metadata->nKey, metadata->nKeySizeUsed); + keyDes = aAtomType; + + metadata->nValueMaxSize = metadata->nSize - _FOFF(OMX_CONFIG_METADATAITEMTYPE, nValue); + + OMX_ERRORTYPE error = component->SetParameter(component, OMX_IndexParamAudioG723, metadata); + + CleanupStack::PopAndDestroy(metadata); + + if(error) + { + // This is what we expected + return ETrue; + } + + ERR_PRINTF1(_L("MosSetParameterUnknownIndexTypeL unexpectedly received OMX_ErrorNone")); + StopTest(EFail); + return EFalse; + } +TBool ROmxScriptTest::MosDisablePort(const TDesC8& aComp, TInt aPortIndex) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandPortDisable, aPortIndex, NULL); + if(error) + { + FailWithOmxError(aComp, _L("OMX_SendCommand(OMX_CommandPortDisable)"), error); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosEnablePort(const TDesC8& aComp, TInt aPortIndex) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandPortEnable, aPortIndex, NULL); + if(error) + { + FailWithOmxError(aComp, _L("OMX_SendCommand(OMX_CommandPortEnable)"), error); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosIgnoreEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + TExpectedEvent event; + event.iComponent = component; + event.iEvent = aEvent; + event.iData1 = aData1; + event.iData2 = aData2; + event.iEventData = NULL; + iIgnoredEvents.AppendL(event); + + return ETrue; + } + +TBool ROmxScriptTest::MosSetPcmAudioPortDefL(const TDesC8& aComp, + TInt aPortIndex, + TInt aNumChannels, + TInt aSamplingRate, + TInt aBitsperSample, + OMX_NUMERICALDATATYPE aNumData, + OMX_ENDIANTYPE aEndian, + OMX_BOOL* aInterleaved, + const TDesC8* aEncoding ) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_PARAM_PCMMODETYPE pcmModeType; + pcmModeType.nSize = sizeof(pcmModeType); + pcmModeType.nVersion = KOmxVersion; + pcmModeType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamAudioPcm, &pcmModeType); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + if(aNumChannels != KErrNotFound) + { + pcmModeType.nChannels = aNumChannels; + } + if(aSamplingRate != KErrNotFound) + { + pcmModeType.nSamplingRate = aSamplingRate; + } + if(aBitsperSample != KErrNotFound) + { + pcmModeType.nBitPerSample = aBitsperSample; + } + if((aNumData != OMX_NumercialDataMax) && (aNumData != KErrNotFound)) + { + pcmModeType.eNumData = aNumData; + } + if((aEndian != OMX_EndianMax) && (aEndian != KErrNotFound)) + { + pcmModeType.eEndian = aEndian; + } + if(aInterleaved != NULL) + { + pcmModeType.bInterleaved = *aInterleaved; + } + if (aEncoding) + { + if (*aEncoding==_L8("linear")) pcmModeType.ePCMMode = OMX_AUDIO_PCMModeLinear; + else if (*aEncoding==_L8("alaw")) pcmModeType.ePCMMode = OMX_AUDIO_PCMModeALaw; + else if (*aEncoding==_L8("mulaw")) pcmModeType.ePCMMode = OMX_AUDIO_PCMModeMULaw; + else FailWithOmxError(_L("Invalid PCM encoding parameter"), OMX_ErrorBadParameter); + } + error = component->SetParameter(component, OMX_IndexParamAudioPcm, &pcmModeType); + if(error) + { + FailWithOmxError(_L("SetParameter()"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetConfigAudioMuteL(const TDesC8& aComp, + TInt aPortIndex, + TBool aMute) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_CONFIG_MUTETYPE audioMuteType; + audioMuteType.nSize = sizeof(audioMuteType); + audioMuteType.nVersion = KOmxVersion; + audioMuteType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigAudioMute, &audioMuteType); + if(error) + { + FailWithOmxError(_L("GetConfig()"), error); + return EFalse; + } + audioMuteType.bMute = (aMute ? OMX_TRUE : OMX_FALSE); + + error = component->SetConfig(component, OMX_IndexConfigAudioMute, &audioMuteType); + if(error) + { + FailWithOmxError(_L("SetConfig()"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosCheckConfigAudioMuteL(const TDesC8& aComp, + TInt aPortIndex, + TBool aMute) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + User::Leave(KErrGeneral); + } + + OMX_AUDIO_CONFIG_MUTETYPE audioMuteType; + audioMuteType.nSize = sizeof(audioMuteType); + audioMuteType.nVersion = KOmxVersion; + audioMuteType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigAudioMute, &audioMuteType); + if(error) + { + FailWithOmxError(_L("GetConfig()"), error); + return EFalse; + } + + if(audioMuteType.bMute != aMute) + { + ERR_PRINTF1(_L("Mute not what expected.")); + StopTest(KErrGeneral, EFail); + return EFalse; + } + return ETrue; + } + + + + +TBool ROmxScriptTest::MosSetConfigAudioVolumeL(const TDesC8& aComp, + TInt aPortIndex, + TBool aLinear, + TInt aMinVolume, + TInt aMaxVolume, + TInt aVolume, + OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_CONFIG_VOLUMETYPE audioVolumeType; + audioVolumeType.nSize = sizeof(audioVolumeType); + audioVolumeType.nVersion = KOmxVersion; + audioVolumeType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigAudioVolume, &audioVolumeType); + if(error) + { + FailWithOmxError(_L("GetConfig()"), error); + return EFalse; + } + if(aMinVolume != -1) + { + audioVolumeType.sVolume.nMin = aMinVolume; + } + if(aMaxVolume != -1) + { + audioVolumeType.sVolume.nMax = aMaxVolume; + } + if(aVolume != -1) + { + audioVolumeType.sVolume.nValue = aVolume; + } + audioVolumeType.bLinear = (aLinear ? OMX_TRUE : OMX_FALSE); + + error = component->SetConfig(component, OMX_IndexConfigAudioVolume, &audioVolumeType); + if(error != aExpectedError) + { + FailWithOmxError(_L("SetConfig()"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosCheckConfigAudioVolumeL(const TDesC8& aComp, + TInt aPortIndex, + TBool aLinear, + TInt aMinVolume, + TInt aMaxVolume, + TInt aVolume) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + User::Leave(KErrGeneral); + } + + OMX_AUDIO_CONFIG_VOLUMETYPE audioVolumeType; + audioVolumeType.nSize = sizeof(audioVolumeType); + audioVolumeType.nVersion = KOmxVersion; + audioVolumeType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigAudioVolume, &audioVolumeType); + if(error) + { + FailWithOmxError(_L("GetConfig()"), error); + User::Leave(KErrGeneral); + } + if(aMinVolume != -1) + { + if (audioVolumeType.sVolume.nMin != aMinVolume) + { + ERR_PRINTF1(_L("Min volume not what expected.")); + StopTest(KErrGeneral, EFail); + return EFalse; + } + } + if(aMaxVolume != -1) + { + if (audioVolumeType.sVolume.nMax != aMaxVolume) + { + ERR_PRINTF1(_L("Max volume not what expected.")); + StopTest(KErrGeneral, EFail); + return EFalse; + } + } + if(aVolume != -1) + { + if (audioVolumeType.sVolume.nValue != aVolume) + { + ERR_PRINTF1(_L("Volume not what expected.")); + StopTest(KErrGeneral, EFail); + return EFalse; + } + } + if(audioVolumeType.bLinear != aLinear) + { + ERR_PRINTF1(_L("Linear not what expected.")); + StopTest(KErrGeneral, EFail); + return EFalse; + } + return ETrue; + } + + +TBool ROmxScriptTest::MosSetAacAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAacTools, TInt aAacErTools, TInt aProfile, TInt aStreamFormat, TInt aChannelMode) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_PARAM_AACPROFILETYPE aacProfile; + aacProfile.nSize = sizeof(aacProfile); + aacProfile.nVersion = KOmxVersion; + aacProfile.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamAudioAac, &aacProfile); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + + if(aNumChannels != -1) + { + aacProfile.nChannels = aNumChannels; + } + if(aSamplingRate != -1) + { + aacProfile.nSampleRate = aSamplingRate; + } + if(aBitRate != -1) + { + aacProfile.nBitRate = aBitRate; + } + if(aAudioBandwidth != -1) + { + aacProfile.nAudioBandWidth = aAudioBandwidth; + } + if(aFrameLength != -1) + { + aacProfile.nFrameLength = aFrameLength; + } + if(aAacTools != -1) + { + aacProfile.nAACtools = aAacTools; + } + if(aAacErTools != -1) + { + aacProfile.nAACERtools = aAacErTools; + } + if(aProfile != -1) + { + aacProfile.eAACProfile = static_cast(aProfile); + } + if(aStreamFormat != -1) + { + aacProfile.eAACStreamFormat = static_cast(aStreamFormat); + } + if(aChannelMode != -1) + { + aacProfile.eChannelMode = static_cast(aChannelMode); + } + + error = component->SetParameter(component, OMX_IndexParamAudioAac, &aacProfile); + if(error) + { + FailWithOmxError(_L("SetParameter()"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, OMX_AUDIO_CODINGTYPE* aCodingType, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + if(aCodingType) + { + portDef.format.audio.eEncoding = *aCodingType; + } + error = component->SetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error != aExpectedError) + { + TBuf<64> errorDes; + OMXUtil::ErrorDes(error, errorDes); + TBuf<64> expectedErrorDes; + OMXUtil::ErrorDes(aExpectedError, expectedErrorDes); + ERR_PRINTF4(_L("SetParameter(OMX_IndexParamPortDefinition) portDef.format.audio.eEncoding %d returned %S but expected %S OMX_ErrorOverflow or OMX_ErrorUnsupportedSetting"), + portDef.format.audio.eEncoding, &errorDes, &expectedErrorDes); + StopTest(EFail); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetRefClockTypeL(const TDesC8& aComp, OMX_TIME_REFCLOCKTYPE aRefClockType) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.eClock = aRefClockType; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimeActiveRefClock, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimeActiveRefClock)"), error); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetClockTimeScale(const TDesC8& aComp, OMX_S32 aScale) +{ + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + INFO_PRINTF2(_L("MosSetClockTimeScale %d"), aScale); + + OMX_TIME_CONFIG_SCALETYPE conf; + conf.nSize = sizeof(conf); + conf.nVersion = KOmxVersion; + conf.xScale = aScale; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimeScale, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimeClockState)"), error); + return EFalse; + } + + return ETrue; +} + +TBool ROmxScriptTest::MosSetClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState, TInt aStartTime, TInt aOffset, TUint32 aWaitMask) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_CLOCKSTATETYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.eState = aClockState; + conf.nStartTime = aStartTime; + conf.nOffset = aOffset; + conf.nWaitMask = aWaitMask; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimeClockState, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimeClockState)"), error); + return EFalse; + } + + return ETrue; + } + +// Buffer component handler +TBool ROmxScriptTest::InitialiseBufferHandlerL(const TDesC8& aComp, TDesC& aName, const TDesC8* aType) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + // Buffer component + _LIT8(extensionBuf1, "OMX.SYMBIAN.INDEX.PARAM.BUFFERCHUNK"); + TBuf8<45> extension; + extension.Copy(extensionBuf1); + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA chunkData; + chunkData.nSize = sizeof(chunkData); + chunkData.nVersion = KOmxVersion; + chunkData.nPortIndex = 0; + error = component->GetParameter(component, indexType, &chunkData); + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = 0; + + error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_BUFFER_SIZE bufferSize; + bufferSize.nSize = sizeof(bufferSize); + bufferSize.nVersion = KOmxVersion; + bufferSize.nPortIndex = 0; + + error = component->GetParameter(component, static_cast(OMX_SymbianIndexParamBufferSize), &bufferSize); + + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + if ((aType != NULL) && (*aType == _L8("mpeg4"))) + { + iBufferHandler = CVideoBufferHandlerMPEG4::NewL(aName, chunkData, bufferSize, portDef); + } + else + { + iBufferHandler = CVideoBufferHandler::NewL(aName, chunkData, bufferSize, portDef); + } + + return ETrue; + } + +void ROmxScriptTest::StartBufferHandler() + { + if ( !iBufferHandler ) + { + ERR_PRINTF1(_L("ROmxScriptTest::StartBufferHander() Exception: Buffer handler not created")); + StopTest(EFail); + } + + iBufferHandler->Start(); + } + + +void ROmxScriptTest::SendInvalidBufferId(TInt aInvalidId) + { + if ( !iBufferHandler ) + { + ERR_PRINTF1(_L("ROmxScriptTest::SendInvalidBufferId() Exception: Buffer handler not created")); + StopTest(EFail); + } + + iBufferHandler->SetSendInvalidBufferId(aInvalidId); + iBufferHandler->Start(); + } + + + + +void ROmxScriptTest::StopBufferHandler() + { + if ( !iBufferHandler ) + { + ERR_PRINTF1(_L("ROmxScriptTest::StopBufferHandler() Exception: Buffer handler not stopped")); + StopTest(EFail); + } + + iBufferHandler->Cancel(); + } + +// Buffer sink component handler +TBool ROmxScriptTest::InitialiseBufferSinkHandlerL(const TDesC8& aComp, TDesC& aName) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + // Buffer component + _LIT8(extensionBuf1, "OMX.SYMBIAN.INDEX.PARAM.BUFFERCHUNK"); + TBuf8<45> extension; + extension.Copy(extensionBuf1); + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA chunkData; + chunkData.nSize = sizeof(chunkData); + chunkData.nVersion = KOmxVersion; + chunkData.nPortIndex = 0; + error = component->GetParameter(component, indexType, &chunkData); + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = 0; + + error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_BUFFER_SIZE bufferSize; + bufferSize.nSize = sizeof(bufferSize); + bufferSize.nVersion = KOmxVersion; + bufferSize.nPortIndex = 0; + + error = component->GetParameter(component, static_cast(OMX_SymbianIndexParamBufferSize), &bufferSize); + + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + iBufferSinkHandler = CVideoBufferSinkHandler::NewL(aName, chunkData, bufferSize, portDef); + + return ETrue; + } + +void ROmxScriptTest::StartBufferSinkHandler() + { + if ( !iBufferSinkHandler ) + { + ERR_PRINTF1(_L("ROmxScriptTest::StartBufferSinkHandler() Exception: Buffer sink handler not created")); + StopTest(EFail); + } + + iBufferSinkHandler->Start(); + } + +void ROmxScriptTest::StopBufferSinkHandler() + { + if ( !iBufferSinkHandler ) + { + ERR_PRINTF1(_L("ROmxScriptTest::StopBufferSinkHandler() Exception: Buffer sink handler not stopped")); + StopTest(EFail); + } + + iBufferSinkHandler->Cancel(); + } + +TBool ROmxScriptTest::MosNegativeSetDataChunk(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError, TInt /*aExpectedSystemError*/) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + // Buffer component + _LIT8(extensionBuf1, "OMX.SYMBIAN.INDEX.PARAM.BUFFERCHUNK"); + TBuf8<45> extension; + extension.Copy(extensionBuf1); + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA chunkData; + chunkData.nSize = sizeof(chunkData); + chunkData.nVersion = KOmxVersion; + chunkData.nPortIndex = 0; + error = component->GetParameter(component, indexType, &chunkData); + + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + if (NULL == chunkData.nChunk ) + { + FailWithOmxError(_L("NULL TBufSrcComponentHandles"), OMX_ErrorInvalidState); + return EFalse; + } + + chunkData.nChunk = 666; + error = component->SetParameter(component, indexType , &chunkData); + + if (aExpectedError != error) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosChangeFilledBufferLength(const TDesC8& aComp, TInt aValue) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + iBufferHandler->ChangeFilledBufferLength(aValue); + + return ETrue; + } + +TBool ROmxScriptTest::MosSetOMX_SymbianIndexParamBufferMsgQueueData(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_SYMBIAN_PARAM_BUFFER_MSGQUEUE bufferMsgQueue; + bufferMsgQueue.nSize = sizeof(bufferMsgQueue); + bufferMsgQueue.nVersion = KOmxVersion; + bufferMsgQueue.nPortIndex = 0; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_SymbianIndexParamBufferMsgQueueData), &bufferMsgQueue); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetOMX_SymbianIndexParamBufferMsgQueueData SetParameter() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aData, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + OMX_SYMBIAN_PARAM_BUFFER_SIZE bufferSize; + bufferSize.nSize = sizeof(bufferSize); + bufferSize.nVersion = KOmxVersion; + bufferSize.nPortIndex = aPortIndex; + bufferSize.nBufferSize = aData; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_SymbianIndexParamBufferSize), &bufferSize); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetBufferSize SetParameter() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + return ETrue; + } + + +TBool ROmxScriptTest::MosGetAndCompareBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nVersion = KOmxVersion; + portDef.nSize = sizeof(portDef); + portDef.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter()"), error); + return EFalse; + } + if (aDataToCompare != portDef.nBufferCountActual) + { + ERR_PRINTF3(_L("Compare buffer source count - expecting %d, actual %d"), aDataToCompare, portDef.nBufferCountActual); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosGetAndCompareBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_SYMBIAN_PARAM_BUFFER_SIZE bufferSize; + bufferSize.nSize = sizeof(bufferSize); + bufferSize.nVersion = KOmxVersion; + bufferSize.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = component->GetParameter(component, static_cast(OMX_SymbianIndexParamBufferSize), &bufferSize); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter()"), error); + return EFalse; + } + if (bufferSize.nBufferSize != aDataToCompare) + { + ERR_PRINTF3(_L("Compare buffer source size - expecting %d, actual %d"), aDataToCompare, bufferSize.nBufferSize); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetVideoEncQuantL(const TDesC8& aComp, TInt aPortIndex, TInt aQpb) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_VIDEO_PARAM_QUANTIZATIONTYPE videoQuantization; + videoQuantization.nSize = sizeof(videoQuantization); + videoQuantization.nVersion = KOmxVersion; + videoQuantization.nPortIndex = aPortIndex; + videoQuantization.nQpB = aQpb; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_IndexParamVideoQuantization), &videoQuantization); + if(error) + { + FailWithOmxError(_L("MosSetVideoEncQuantL SetParameter()"), error); + return EFalse; + } + + error = component->GetParameter(component, OMX_IndexParamVideoQuantization, &videoQuantization); + if(error) + { + FailWithOmxError(_L("MosSetVideoEncQuantL GetParameter()"), error); + return EFalse; + } + + if (videoQuantization.nQpB != aQpb) + { + ERR_PRINTF3(_L("MosSetVideoEncQuantL Compare QPB failed - Got %d, Expected %d"), videoQuantization.nQpB, aQpb); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetVideoEncMotionVectL(const TDesC8& aComp, TInt aPortIndex, + TInt aAccuracy, TInt aSxSearchrange, TInt aSySearchrange, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_VIDEO_PARAM_MOTIONVECTORTYPE motionVect; + motionVect.nSize = sizeof(motionVect); + motionVect.nVersion = KOmxVersion; + motionVect.nPortIndex = aPortIndex; + motionVect.eAccuracy = (OMX_VIDEO_MOTIONVECTORTYPE)aAccuracy; + motionVect.sXSearchRange = aSxSearchrange; + motionVect.sYSearchRange = aSySearchrange; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_IndexParamVideoMotionVector), &motionVect); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetVideoEncMotionVectL SetParameter() returned error 0x%X, expected error 0x%X"), error, aExpectedError); + return EFalse; + } + + if (aExpectedError) + { + return ETrue; + } + + error = component->GetParameter(component, OMX_IndexParamVideoMotionVector, &motionVect); + if(error) + { + FailWithOmxError(_L("MosSetVideoEncMotionVectL GetParameter()"), error); + return EFalse; + } + + if (motionVect.eAccuracy != aAccuracy || motionVect.sXSearchRange != aSxSearchrange || + motionVect.sYSearchRange != aSySearchrange) + { + ERR_PRINTF1(_L("MosSetVideoEncMotionVectL GetParameter() did not return expeccted value")); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosSetVideoEncMpeg4TypeL(const TDesC8& aComp, TInt aPortIndex, + OMX_VIDEO_MPEG4PROFILETYPE aMpeg4Profile, OMX_VIDEO_MPEG4LEVELTYPE aMpeg4Level, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_VIDEO_PARAM_MPEG4TYPE mpeg4; + mpeg4.nSize = sizeof(mpeg4); + mpeg4.nVersion = KOmxVersion; + mpeg4.nPortIndex = aPortIndex; + mpeg4.eProfile = aMpeg4Profile; + mpeg4.eLevel = aMpeg4Level; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_IndexParamVideoMpeg4), &mpeg4); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetVideoEncMpeg4TypeL SetParameter() returned error 0x%X, expected error 0x%X"), error, aExpectedError); + return EFalse; + } + if (aExpectedError) + { + return ETrue; + } + + error = component->GetParameter(component, OMX_IndexParamVideoMpeg4, &mpeg4); + if(error) + { + FailWithOmxError(_L("MosSetVideoEncMpeg4TypeL GetParameter()"), error); + return EFalse; + } + + if (mpeg4.eProfile != aMpeg4Profile || mpeg4.eLevel != aMpeg4Level) + { + ERR_PRINTF1(_L("MosSetVideoEncMpeg4TypeL GetParameter() did not return expeccted value")); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosSetVideoEncBitRateL(const TDesC8& aComp, TInt aPortIndex, + OMX_VIDEO_CONTROLRATETYPE aControlRate, TInt aTargetBitrate, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_VIDEO_PARAM_BITRATETYPE bitRate; + bitRate.nSize = sizeof(bitRate); + bitRate.nVersion = KOmxVersion; + bitRate.nPortIndex = aPortIndex; + bitRate.eControlRate = aControlRate; + bitRate.nTargetBitrate = aTargetBitrate; + + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_IndexParamVideoBitrate), &bitRate); + if(aExpectedError != error) + { + ERR_PRINTF3(_L("MosSetVideoEncBitRateL SetParameter() returned error 0x%X, expected error 0x%X"), error, aExpectedError); + return EFalse; + } + if (aExpectedError) + { + return ETrue; + } + + error = component->GetParameter(component, OMX_IndexParamVideoBitrate, &bitRate); + if(error) + { + FailWithOmxError(_L("MosSetVideoEncBitRateL GetParameter()"), error); + return EFalse; + } + + if (bitRate.eControlRate != aControlRate || bitRate.nTargetBitrate != aTargetBitrate) + { + ERR_PRINTF1(_L("MosSetVideoEncBitRateL GetParameter() did not return expeccted value")); + return EFalse; + } + return ETrue; + } + +void ROmxScriptTest::WriteInt32(TUint8* aPtr, TInt32 aData) + { + aPtr[0] = TUint8(aData>>24); + aPtr[1] = TUint8(aData>>16); + aPtr[2] = TUint8(aData>>8); + aPtr[3] = TUint8(aData); + } + + +TBool ROmxScriptTest::ShortNameMatchComparison(const TDesC8* aShortName, const CComponentInfo& aComponentInfo) + { + if (*aShortName == *aComponentInfo.iShortName) + { + return ETrue; + } + return EFalse; + } + +TBool ROmxScriptTest::ComponentLogicalIL(const TDesC8& aName) + { + for(TInt index = 0, count = iComponents.Count(); index < count; index++) + { + CComponentInfo* component = iComponents[index]; + if(*(component->iShortName) == aName) + { + if(component->iComponentName->FindC(KILTypeString()) == KErrNotFound) + { + // is not LIL + return EFalse; + } + else + { + // is LIL + return ETrue; + } + } + } + ERR_PRINTF1(_L("LogicalILComponent() - Component not found")); + StopTest(EFail); + + return EFalse; + } + +TBool ROmxScriptTest::ComponentPhysicalIL(const TDesC8& aName) + { + for(TInt index = 0, count = iComponents.Count(); index < count; index++) + { + CComponentInfo* component = iComponents[index]; + if(*(component->iShortName) == aName) + { + if(component->iComponentName->FindC(KILTypeString) == KErrNotFound) + { + // is PIL + return ETrue; + } + else + { + // is not PIL + return EFalse; + } + } + } + ERR_PRINTF1(_L("PhysicalILComponent() - Component not found")); + StopTest(EFail); + + return EFalse; + } + +OMX_COMPONENTTYPE* ROmxScriptTest::ComponentByName(const TDesC8& aName) + { + for(TInt index = 0, count = iComponents.Count(); index < count; index++) + { + CComponentInfo* component = iComponents[index]; + if(*(component->iShortName) == aName) + { + return component->iComponent; + } + } + HBufC* name = HBufC::New(aName.Length()); + if(!name) + { + ERR_PRINTF1(_L("Component not found")); + StopTest(EFail); + } + else + { + name->Des().Copy(aName); + ERR_PRINTF2(_L("Component %S not found"), name); + delete name; + StopTest(EFail); + } + return NULL; + } + + + +void ROmxScriptTest::GetComponentName(const OMX_COMPONENTTYPE* aHandle, TDes& aName) + { + for(TInt index = 0, count = iComponents.Count(); index < count; index++) + { + const CComponentInfo* component = iComponents[index]; + if(component->iComponent == aHandle) + { + aName.Copy(*(component->iShortName)); + return; + } + } + ERR_PRINTF1(_L("Invalid component handle")); + StopTest(EFail); + aName = _L(""); + } + +void ROmxScriptTest::FailWithOmxError(const TDesC& aOperation, OMX_ERRORTYPE aError) + { + if(aError != OMX_ErrorNone) + { + TBuf<64> errorDes; + OMXUtil::ErrorDes(aError, errorDes); + ERR_PRINTF3(_L("%S returned %S"), &aOperation, &errorDes); + StopTest(EFail); + } + } + +void ROmxScriptTest::FailWithOmxError(const TDesC8& aComponent, const TDesC& aOperation, OMX_ERRORTYPE aError) + { + if(aError != OMX_ErrorNone) + { + TBuf<64> errorDes; + TBuf<64> componentDes16; + componentDes16.Copy(aComponent); + OMXUtil::ErrorDes(aError, errorDes); + ERR_PRINTF4(_L("%S->%S returned %S"), &componentDes16, &aOperation, &errorDes); + StopTest(EFail); + } + } + +void ROmxScriptTest::AllComponentsEOS() + { + EndWait(); + } + +void ROmxScriptTest::AllComponentsTransitioned(OMX_STATETYPE aNewState, + OMX_STATETYPE aOldState) + { + __ASSERT_ALWAYS(aOldState == iState, User::Invariant()); + iState = aNewState; + EndWait(); + } + +void ROmxScriptTest::EventReceived(OMX_COMPONENTTYPE* aComponent, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2, TAny* aEventData) + { + + if ((iMsgQueue.Handle()) && (aEvent == OMX_EventCmdComplete)) + { + iMsgQueue.Close(); + } + + + // If the Graphic Sink has created a surface, assign it to the window + if(aEvent == OMX_EventPortSettingsChanged) + { + if(aComponent == iGraphicSink) + { + if (aData1 == iExtSurfaceConfigIndex || + aData1 == OMX_IndexConfigCommonScale || + aData1 == OMX_IndexConfigCommonOutputSize || + aData1 == OMX_IndexConfigCommonInputCrop || + aData1 == OMX_IndexConfigCommonOutputCrop || + aData1 == OMX_IndexConfigCommonExclusionRect) + { + INFO_PRINTF1(_L("Surface configuration changed")); + + OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION surfaceConfigParam; + surfaceConfigParam.nSize = sizeof(OMX_SYMBIAN_VIDEO_PARAM_SURFACECONFIGURATION); + surfaceConfigParam.nVersion = KOmxVersion; + surfaceConfigParam.nPortIndex = 0; + + OMX_ERRORTYPE omxError = aComponent->GetParameter(aComponent, iExtSurfaceConfigIndex, &surfaceConfigParam); + if(omxError != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter(OMX_SymbianIndexParamVideoGFXSurfaceConfig)"), omxError); + return; + } + TSurfaceConfiguration& surfaceConfig = *reinterpret_cast(surfaceConfigParam.pSurfaceConfig); + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE); + portDef.nVersion = KOmxVersion; + portDef.nPortIndex = 0; + omxError = aComponent->GetParameter(aComponent, OMX_IndexParamPortDefinition, &portDef); + if(omxError != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter(OMX_IndexParamPortDefinition)"), omxError); + return; + } + TSize inputSize(portDef.format.video.nFrameWidth, portDef.format.video.nFrameHeight); + INFO_PRINTF3(_L("Input size is %dx%d"), inputSize.iWidth, inputSize.iHeight); + + TSurfaceId surfaceId; + surfaceConfig.GetSurfaceId(surfaceId); + TInt err = iWindowManager->RegisterSurface(surfaceId); + if(KErrNone != err) + { + ERR_PRINTF1(_L("RegisterSurface failed")); + StopTest(err, EFail); + } + + // scale, rotate and centre to fit + // assumes square pixels + + TSize screenSize = iWindowManager->ScreenSize(); + + TBool iInputLandscape = inputSize.iWidth > inputSize.iHeight; + TBool iScreenLandscape = screenSize.iWidth > screenSize.iHeight; + + if (iVideoFitMode == EVideoFitRotateScaleAndCentre && + (iInputLandscape ^ iScreenLandscape)) + { + surfaceConfig.SetOrientation(CFbsBitGc::EGraphicsOrientationRotated270); + TInt tmp = inputSize.iWidth; + inputSize.iWidth = inputSize.iHeight; + inputSize.iHeight = tmp; + } + + TRect rect; + if( iVideoFitMode == EVideoFitScaleAndCentre || + iVideoFitMode == EVideoFitRotateScaleAndCentre) + { + if(!iScreenLandscape) + { + TInt displayHeight = screenSize.iWidth * inputSize.iHeight / inputSize.iWidth; + TInt top = screenSize.iHeight - displayHeight >> 1; + TInt bottom = top + displayHeight; + rect = TRect(0, top, screenSize.iWidth, bottom); + } + else + { + TInt displayWidth = screenSize.iHeight * inputSize.iWidth / inputSize.iHeight; + TInt left = screenSize.iWidth - displayWidth >> 1; + TInt right = left + displayWidth; + rect = TRect(left, 0, right, screenSize.iHeight); + } + } + else + { + TInt left = screenSize.iWidth - inputSize.iWidth >> 1; + TInt top = screenSize.iHeight - inputSize.iHeight >> 1; + rect = TRect(left, top, left + inputSize.iWidth, top + inputSize.iHeight); + } + + surfaceConfig.SetExtent(rect); + + err = iWindowManager->SetBackgroundSurface(surfaceConfig, ETrue); + if(KErrNone != err) + { + ERR_PRINTF2(_L("SetBackgroundSurface failed (%d)"), err); + StopTest(err, EFail); + return; + } + INFO_PRINTF1(_L("SetBackgroundSurface OK")); + iWindowManager->Flush(); + return; + } + } + } + + // ignore buffer flag events except EOS + if((aEvent == OMX_EventBufferFlag && (aData2 & OMX_BUFFERFLAG_EOS) == 0) /*|| (aEvent == OMX_EventNokiaFirstFrameDisplayed)*/) + { + return; + } + + TInt index = 0; + TInt count = iExpectedEvents.Count(); + for(; index < count; index++) + { + const TExpectedEvent& event = iExpectedEvents[index]; + if( event.iComponent == aComponent && + event.iEvent == aEvent && + event.iData1 == aData1 && + event.iData2 == aData2 && + event.iEventData == aEventData) + { + break; + } + } + if(index == count) + { + // event was not expected, see if we can ignore this event + TInt count1 = iIgnoredEvents.Count(); + TInt index1 = 0; + for(; index1 < count1; index1++) + { + const TExpectedEvent& event = iIgnoredEvents[index1]; + if( event.iComponent == aComponent && + event.iEvent == aEvent && + event.iData1 == aData1 && + event.iData2 == aData2 && + event.iEventData == aEventData) + { + return; + } + } + + // event was not expected and we can't ignore the event, so fail the test + TBuf<64> name; + GetComponentName(aComponent, name); + char hexBuf[11]; + TBuf<32> eventWideChar; + eventWideChar.Copy(TPtrC8((unsigned char*) format_OMX_EVENTTYPE(aEvent, hexBuf))); + ERR_PRINTF2(_L("Unexpected event received from component %S"), &name); + ERR_PRINTF5(_L("aEvent=%S aData1=0x%08X aData2=0x%08X, aEventData=0x%08X"), &eventWideChar, aData1, aData2, aEventData); + StopTest(EFail); + return; + } + iExpectedEvents.Remove(index); + if(iWaitingForEvents && iExpectedEvents.Count() == 0) + { + EndWait(); + } + } + +void ROmxScriptTest::ComponentTransitioned(OMX_STATETYPE aNewState, + OMX_STATETYPE aOldState) + { + __ASSERT_ALWAYS(aOldState == iState, User::Invariant()); + iState = aNewState; + EndWait(); + } + +void ROmxScriptTest::BufferDone(OMX_COMPONENTTYPE* aComponent, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource) + { + if (iNonTunneledHandler) + { + iNonTunneledHandler->BufferDone(aComponent, aBufHdr, aSource); + } + + if(iPortBufferHandler) + { + iPortBufferHandler->BufferDone(aComponent, aBufHdr, aSource); + } + + } + +void ROmxScriptTest::TimerExpired() + { + EndWait(); + } + +void ROmxScriptTest::HashFileL(const TDesC& aFileName, TDes8& aHash, void (*aFilter1)(RBuf8&), void (*aFilter2)(RBuf8&), void (*aFilter3)(RBuf8&)) + { + const TInt KBufferSize = 1024; + + RFs fs; + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + + RFile file; + User::LeaveIfError(file.Open(fs, aFileName, EFileRead | EFileShareReadersOnly)); + CleanupClosePushL(file); + + RBuf8 buf; + User::LeaveIfError(buf.Create(KBufferSize)); + CleanupClosePushL(buf); + + CMD5* md5 = CMD5::NewL(); + CleanupStack::PushL(md5); + + while(true) + { + User::LeaveIfError(file.Read(buf)); + if(buf.Length() == 0) + { + break; + } + + if (aFilter1) aFilter1(buf); + if (aFilter2) aFilter2(buf); + if (aFilter3) aFilter3(buf); + + md5->Hash(buf); + } + + aHash = md5->Final(); + + CleanupStack::PopAndDestroy(4); // fs, file, buf, md5 + } + + + +TBool ROmxScriptTest::HandleNonTunneledBuffers(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp) + { + if (iNonTunneledHandler) + { + if (iState == OMX_StateLoaded && aNewState == OMX_StateIdle) + { + TRAPD(err, iNonTunneledHandler->AllocateBuffersL(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Non-tunneled AllocateBuffersL failed (%d)"), err); + return EFalse; + } + } + else if (iState == OMX_StateIdle && aNewState == OMX_StateExecuting) + { + TRAPD(err, iNonTunneledHandler->FillBuffers(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Non-tunneled FillBuffersL failed (%d)"), err); + return EFalse; + } + } + else if (iState == OMX_StateExecuting && aNewState == OMX_StateIdle) + { + TRAPD(err, iNonTunneledHandler->HoldBuffers(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Non-tunneled HoldBuffersL failed (%d)"), err); + return EFalse; + } + } + else if (iState == OMX_StateIdle && aNewState == OMX_StateLoaded) + { + TRAPD(err, iNonTunneledHandler->FreeBuffers(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("Non-tunneled FreeBuffersL failed (%d)"), err); + return EFalse; + } + } + } + + return ETrue; + } + + +TBool ROmxScriptTest::HandlePortBufferHandler(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp) + { + if(iPortBufferHandler) + { + if (iState == OMX_StateLoaded && aNewState == OMX_StateIdle) + { + TRAPD(err, iPortBufferHandler->AllocateBuffersL(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("PortBufferHandler AllocateBuffersL failed (%d)"), err); + return EFalse; + } + } + else if (iState == OMX_StateIdle && aNewState == OMX_StateExecuting) + { + + } + else if (iState == OMX_StateExecuting && aNewState == OMX_StateIdle) + { + } + else if (iState == OMX_StateIdle && aNewState == OMX_StateLoaded) + { + TRAPD(err, iPortBufferHandler->FreeBuffers(aComp)); + if (err != KErrNone) + { + ERR_PRINTF2(_L("PortBufferHandler FreeBuffersL failed (%d)"), err); + return EFalse; + } + } + } + return ETrue; + } + +TBool ROmxScriptTest::MosFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandFlush, aPortIndex, NULL); + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosFlushBuffer SendCommand() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + + return ETrue; + } + +/* + * This is a test to force the buffer(s) to require being flushed. + */ +TBool ROmxScriptTest::MosForceBufferSourceFlushBufferL(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) + { + // setup the msg queue + TBuf<255> compWide; + compWide.Copy(aComp); + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + _LIT8(extensionBuf1, "OMX.SYMBIAN.INDEX.PARAM.BUFFERCHUNK"); + TBuf8<45> extension; + extension.Copy(extensionBuf1); + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetExtensionIndex"), error); + return EFalse; + } + + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA chunkData; + + chunkData.nSize = sizeof(chunkData); + chunkData.nVersion = KOmxVersion; + chunkData.nPortIndex = 0; + error = component->GetParameter(component, indexType, &chunkData); + + if (error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + if (NULL == chunkData.nChunk ) + { + FailWithOmxError(_L("NULL TBufSrcComponentHandles"), OMX_ErrorInvalidState); + return EFalse; + } + + OMX_SYMBIAN_PARAM_BUFFER_SIZE bufferSize; + bufferSize.nSize = sizeof(bufferSize); + bufferSize.nVersion = KOmxVersion; + bufferSize.nPortIndex = 0; + error = component->GetParameter(component, static_cast(OMX_SymbianIndexParamBufferSize), &bufferSize); + + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("GetParameter"), error); + return EFalse; + } + + RChunk msgsChunk; + msgsChunk.SetHandle(chunkData.nChunk); + CleanupClosePushL(msgsChunk); + User::LeaveIfError(msgsChunk.Duplicate(RThread())); + + iMsgQueue.SetHandle(chunkData.nFilledBufferQueue); + User::LeaveIfError(iMsgQueue.Duplicate(RThread())); + + // fill it up with 2 messages + TInt numMessages = 2; // change this to alter the number of buffers stacked up. + TInt message = 0; + TMMSharedChunkBufConfig bufConfig; + bufConfig.iNumBuffers = numMessages; + bufConfig.iBufferSizeInBytes = bufferSize.nBufferSize; //passed into ConstructL() + TUint8* chunkBase = msgsChunk.Base(); + __ASSERT_ALWAYS(message < numMessages, User::Invariant()); + + TUint8* bufBase1 = chunkBase + (message * (bufConfig.iBufferSizeInBytes)); + TFilledBufferHeaderV2 header1; + header1.iOffset = bufBase1 - chunkBase; + header1.iFilledLength = 3; + header1.iTimeStamp = 0; + header1.iFlags = ETrue ? OMX_BUFFERFLAG_STARTTIME : 0; //is the first buffer. + + TInt sendError = iMsgQueue.Send(header1); + + if (sendError != KErrNone) + { + ERR_PRINTF2(_L("MosForceBufferSourceFlushBuffer MsgQueue Send() error 0x%X"), sendError); + iMsgQueue.Close(); + CleanupStack::PopAndDestroy(); // msgsChunk + return EFalse; + } + + message++; + TUint8* bufBase2 = chunkBase + (message * (bufConfig.iBufferSizeInBytes)); + TFilledBufferHeaderV2 header2; + header2.iOffset = bufBase2 - chunkBase; + header2.iFilledLength = 3; + header2.iTimeStamp = 0; + header2.iFlags = EFalse ? OMX_BUFFERFLAG_STARTTIME : 0; //is NOT the first buffer. + User::LeaveIfError(iMsgQueue.Send(header2)); + + // flush them while they're still outstanding + error = component->SendCommand(component, OMX_CommandFlush, aPortIndex, NULL); + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosForceBufferSourceFlushBuffer SendCommand() error 0x%X, expected 0x%X"), error, aExpectedError); + iMsgQueue.Close(); + CleanupStack::PopAndDestroy(); // msgsChunk + return EFalse; + } + + CleanupStack::PopAndDestroy(); // msgsChunk + return ETrue; + } + + + +TBool ROmxScriptTest::MosForceBufferSinkFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError) + { + + + TBuf<255> compWide; + compWide.Copy(aComp); + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + + OMX_ERRORTYPE error = component->SendCommand(component, OMX_CommandFlush, aPortIndex, NULL); + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosForceFlushBufferSinkBuffer error 0x%X, expected 0x%X"), error, aExpectedError); + iMsgQueue.Close(); + return EFalse; + } + + return ETrue; + } + + + +TBool ROmxScriptTest::MosSetActiveStream(const TDesC8& aComp, TUint32 aPortIndex) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nVersion = KOmxVersion; + portDef.nSize = sizeof(portDef); + portDef.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamPortDefinition, &portDef); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter()"), error); + return EFalse; + } + + error = component->SetParameter(component, OMX_IndexParamActiveStream, &portDef); + if((error != OMX_ErrorNone) && (error != OMX_ErrorUnsupportedSetting)) + { + FailWithOmxError(_L("SetParameter"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosGetActiveStream(const TDesC8& aComp, TUint32 aPortIndex) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nVersion = KOmxVersion; + portDef.nSize = sizeof(portDef); + portDef.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamActiveStream, &portDef); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter()"), error); + return EFalse; + } + + return ETrue; + } + + +TBool ROmxScriptTest::MosSetVideoFitModeL(TVideoFitMode aVideoFitMode) + { + iVideoFitMode = aVideoFitMode; + return ETrue; + } + +// FIXME duplication with MosSetAacAudioPortDefL +TBool ROmxScriptTest::MosSetAACProfileL(const TDesC8& aComp, TInt aPortIndex, TInt aChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAACTools, TInt aAACERTools, OMX_AUDIO_AACPROFILETYPE aProfile, OMX_AUDIO_AACSTREAMFORMATTYPE aStreamFormat, OMX_AUDIO_CHANNELMODETYPE aChannelMode) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_PARAM_AACPROFILETYPE param; + param.nSize = sizeof(param); + param.nVersion = KOmxVersion; + param.nPortIndex = aPortIndex; + + OMX_ERRORTYPE error = OMX_GetParameter(component, OMX_IndexParamAudioAac, ¶m); + if(error) + { + FailWithOmxError(_L("OMX_GetParameter(AudioAAC)"), error); + return EFalse; + } + + // TODO don't overwrite unspecified values + param.nChannels = aChannels; + param.nSampleRate = aSamplingRate; + param.nBitRate = aBitRate; + param.nAudioBandWidth = aAudioBandwidth; + param.nFrameLength = aFrameLength; + param.nAACtools = aAACTools; + param.nAACERtools = aAACERTools; + param.eAACProfile = aProfile; + param.eAACStreamFormat = aStreamFormat; + param.eChannelMode = aChannelMode; + + error = OMX_SetParameter(component, OMX_IndexParamAudioAac, ¶m); + if(error) + { + FailWithOmxError(_L("OMX_SetParameter(AudioAAC)"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosGetExtensionIndex(const TDesC8& aComp, const TDesC8& aParameterName, OMX_ERRORTYPE aExpectedError) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + TBuf8<128> extension; + extension.Copy(aParameterName); + + OMX_INDEXTYPE indexType = OMX_IndexMax; + OMX_ERRORTYPE error = component->GetExtensionIndex(component, (OMX_STRING) extension.PtrZ(), &indexType); + if(error != aExpectedError) + { + ERR_PRINTF3(_L("MosGetExtensionIndex GetExtensionIndex() error 0x%X, expected 0x%X"), error, aExpectedError); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosCheckTimeClockState(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aExpectedState) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + + if (!component) + { + StopTest(EFail); + return EFalse; + } + + OMX_TIME_CONFIG_CLOCKSTATETYPE timeClockState; + timeClockState.nSize = sizeof(timeClockState); + timeClockState.nVersion = KOmxVersion; + + if(component->GetConfig(component, OMX_IndexConfigTimeClockState, &timeClockState) != OMX_ErrorNone) + { + StopTest(EFail); + return EFalse; + } + + if (timeClockState.eState != aExpectedState) + { + ERR_PRINTF3(_L("Clock state %d does not match expected %d"), timeClockState.eState, aExpectedState); + StopTest(EFail); + return EFalse; + } + + return ETrue; + } + +TBool ROmxScriptTest::MosCheckMediaTime(const TDesC8& aComp, TInt aPortIndex, OMX_TICKS aMediaTime, TBool aMoreThan) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + + if (!component) + { + StopTest(EFail); + return EFalse; + } + + OMX_TIME_CONFIG_TIMESTAMPTYPE timeInfo; + timeInfo.nSize = sizeof(timeInfo); + timeInfo.nVersion = KOmxVersion; + timeInfo.nPortIndex = aPortIndex; + + if (component->GetConfig(component, OMX_IndexConfigTimeCurrentMediaTime, &timeInfo) != OMX_ErrorNone) + { + StopTest(EFail); + return EFalse; + } + + if (aMoreThan) + { + INFO_PRINTF3(_L("MosCheckMediaTime() %ld > %ld"), timeInfo.nTimestamp, aMediaTime); + + if (timeInfo.nTimestamp < aMediaTime) + { + INFO_PRINTF3(_L("FAILED! MosCheckMediaTime() Expecting %ld > %ld"), timeInfo.nTimestamp, aMediaTime); + StopTest(EFail); + return EFalse; + } + } + else + { + INFO_PRINTF3(_L("MosCheckMediaTime() %ld < %ld"), timeInfo.nTimestamp, aMediaTime); + + if (timeInfo.nTimestamp > aMediaTime) + { + INFO_PRINTF3(_L("FAILED! MosCheckMediaTime() expecting %ld < %ld"), timeInfo.nTimestamp, aMediaTime); + StopTest(EFail); + return EFalse; + } + } + + return ETrue; + } + +TBool ROmxScriptTest::MosBaseSupportPortL(const TDesC8& aComp, TInt aPortIndex) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->AddPortSupportL(aPortIndex); + + return ETrue; + } + +TBool ROmxScriptTest::MosBaseSetAutonomous(const TDesC8& aComp, TInt aPortIndex, TBool aEnabled) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->SetAutoMode(aPortIndex, aEnabled); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseAllocateBuffersL(const TDesC8& aComp, TInt aPortIndex, TInt aNumberBuffers) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->SetupBuffersL(aPortIndex,aNumberBuffers); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseFreeAllocatedBuffersL(const TDesC8& aComp) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->FreeAllocatedBuffersL(); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseSetBufSupplier(const TDesC8& aComp, TInt aPortIndex, TBool aComponentSupplier) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->SetBufferSupplier(aPortIndex, aComponentSupplier); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseFillThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->FillThisBuffer(aPortIndex, aPortRelBufIndex); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseEmptyThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->EmptyThisBuffer(aPortIndex, aPortRelBufIndex); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseWaitForBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + iComponents[componentIndex]->iBaseHandler->WaitForBufferCompletion(aPortIndex, aPortRelBufIndex); + return ETrue; + } + +TBool ROmxScriptTest::MosBaseTimestampPassClock(const TDesC8& aCompReceiving, const TDesC8& aClockCompToPass) + { + TInt receiveCompIndex = iComponents.Find(aCompReceiving, ROmxScriptTest::ShortNameMatchComparison); + if (receiveCompIndex == KErrNotFound) + { + return EFalse; + } + + TInt clockCompIndex = iComponents.Find(aClockCompToPass, ROmxScriptTest::ShortNameMatchComparison); + if (clockCompIndex == KErrNotFound) + { + return EFalse; + } + + CBaseProfileTimestampHandling* timestampBaseHandler = static_cast(iComponents[receiveCompIndex]->iBaseHandler); + timestampBaseHandler->SetClockComponent(iComponents[clockCompIndex]->iComponent); + + return ETrue; + } + +TBool ROmxScriptTest::MosBaseTimestampCheckTimestampL(const TDesC8& aComp, TInt aPortIndex, TUint aExpectedTime, TUint aTolerance) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + + CBaseProfileTimestampHandling* timestampBaseHandler = static_cast(iComponents[componentIndex]->iBaseHandler); + timestampBaseHandler->QueueTimestampCheckL(aPortIndex, aExpectedTime, aTolerance); + + return ETrue; + } + +TBool ROmxScriptTest::MosBaseTimestampCompareWithRefClockL(const TDesC8& aComp, TInt aPortIndex, TUint aTolerance) + { + TInt componentIndex = iComponents.Find(aComp, ROmxScriptTest::ShortNameMatchComparison); + if (componentIndex == KErrNotFound) + { + return EFalse; + } + + CBaseProfileTimestampHandling* timestampBaseHandler = static_cast(iComponents[componentIndex]->iBaseHandler); + timestampBaseHandler->QueueCompareWithRefClockL(aPortIndex, aTolerance); + + return ETrue; + } + + +TBool ROmxScriptTest::MosStartBuffersforPort( const TDesC8& aComp, TInt aPortIndex) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + if(iPortBufferHandler) + { + iPortBufferHandler->Start(component,aPortIndex); + } + return ETrue; + } + +void ROmxScriptTest::BeginWait() + { + CActiveScheduler::Start(); + } + +void ROmxScriptTest::EndWait() + { + // use a CAsyncCallBack to call CActiveScheduler::Stop + // the main reason for doing this is to allow EndWait + // to be called from any thread but to stop the scheduler + // of the script parser thread. + iStopSchedulerCallback->CallBack(); + } + + + +// +TBool ROmxScriptTest::MosDeleteFileL(const TDesC& aFileName, TBool aFileMustExist) + { + RFs fs; + + User::LeaveIfError(fs.Connect()); + CleanupClosePushL(fs); + TInt err = fs.Delete(aFileName); + if (err != KErrNone) + { + if (err != KErrNotFound || aFileMustExist) + { + ERR_PRINTF3(_L("Error %d deleting file %S"), err, &aFileName); + User::Leave(err); + } + } + + INFO_PRINTF2(_L("Deleted file %S"), &aFileName); + + CleanupStack::PopAndDestroy(&fs); + return ETrue; + } + +// +// +// +TBool ROmxScriptTest::MosLogAllEventsL() + { + return ETrue; + } + +// +// +// +TBool ROmxScriptTest::MosSetSensorModeTypeL(const TDesC8& aComp, TInt aPort, TInt aFrameRate, TBool aOneShot, TInt aWidth, TInt aHeight) + { + OMX_COMPONENTTYPE* comp = ComponentByName(aComp); + if (!comp) + { + return EFalse; + } + + OMX_PARAM_SENSORMODETYPE sensor; + sensor.nVersion = KOmxVersion; + sensor.nSize = sizeof(OMX_PARAM_SENSORMODETYPE); + sensor.nPortIndex = aPort; + sensor.sFrameSize.nSize = sizeof(OMX_FRAMESIZETYPE); + sensor.sFrameSize.nVersion = KOmxVersion; + sensor.sFrameSize.nPortIndex = aPort; + + OMX_ERRORTYPE omxErr = comp->GetParameter(comp, OMX_IndexParamCommonSensorMode, &sensor); + if (omxErr != OMX_ErrorNone) + { + ERR_PRINTF2(_L("Error %08X returned from GetParameter"), omxErr); + return EFalse; + } + + sensor.bOneShot = (aOneShot ? OMX_TRUE : OMX_FALSE); + if (aFrameRate != -1) sensor.nFrameRate = aFrameRate; + if (aWidth != -1) sensor.sFrameSize.nWidth = aWidth; + if (aHeight != -1) sensor.sFrameSize.nHeight = aHeight; + + omxErr = comp->SetParameter(comp, OMX_IndexParamCommonSensorMode, &sensor); + if (omxErr != OMX_ErrorNone) + { + ERR_PRINTF2(_L("Error %08X returned from SetParameter"), omxErr); + } + + return (omxErr == OMX_ErrorNone); + } + +// +// +// +TBool ROmxScriptTest::MosSetCaptureModeTypeL(const TDesC8& aComp, TInt aPort, TBool aContinuous, TBool aFrameLimited, TInt aFrameLimit) + { + OMX_COMPONENTTYPE* comp = ComponentByName(aComp); + if (!comp) + { + return EFalse; + } + + OMX_CONFIG_CAPTUREMODETYPE captureModeType; + captureModeType.nSize = sizeof(OMX_CONFIG_CAPTUREMODETYPE); + captureModeType.nVersion = KOmxVersion; + captureModeType.nPortIndex = aPort; + captureModeType.bContinuous = (aContinuous ? OMX_TRUE : OMX_FALSE); + captureModeType.bFrameLimited = (aFrameLimited ? OMX_TRUE : OMX_FALSE); + captureModeType.nFrameLimit = aFrameLimit; + OMX_ERRORTYPE omxErr = comp->SetConfig(comp,OMX_IndexConfigCaptureMode,&captureModeType); + + if (omxErr != OMX_ErrorNone) + { + ERR_PRINTF2(_L("Error %08X returned from SetConfig"), omxErr); + } + + return (omxErr == OMX_ErrorNone); + } + +// + +static TInt StopScheduler(TAny* /*unused*/) + { + CActiveScheduler::Stop(); + return 0; + } + +void ROmxScriptTest::StopTest(TOmxScriptTestVerdict aVerdict) + { + switch(aVerdict) + { + case EPass: + StopTest(KErrNone, EPass); + break; + case EFail: + StopTest(KErrGeneral, EFail); + break; + default: + User::Invariant(); + } + } + +/** + * Stores the result of the test case. If called multiple times, the first + * case of EFail will persist. + * @param aError system-wide error code + * @param aVerdict either EPass or EFail + */ +void ROmxScriptTest::StopTest(TInt aError, TOmxScriptTestVerdict aVerdict) + { + __ASSERT_ALWAYS(aVerdict != EPending, User::Invariant()); + // first negative result persists + if(iVerdict != EFail) + { + iReason = aError; + iVerdict = aVerdict; + } + } + +void ROmxScriptTest::FailTest(const TDesC& aErrorMsg) + { + ERR_PRINTF1(aErrorMsg); + StopTest(EFail); + } + +/** + * @return the error code set via StopTest. Defaults to KErrNone. + */ +TInt ROmxScriptTest::Reason() const + { + return iReason; + } + +/** + * @return the verdict set via StopTest. Defaults to EPending. + */ +ROmxScriptTest::TOmxScriptTestVerdict ROmxScriptTest::Verdict() const + { + return iVerdict; + } + +/** + * Overflow handler to generate a warning message if a log line will not fit + * in the descriptor. + */ +class TOverflowHandler : public TDes16Overflow + { +public: + void Overflow(TDes& aDes) + { + _LIT(KWarning, "[truncated]"); + if(aDes.Length() + KWarning().Length() > aDes.MaxLength()) + { + aDes.SetLength(aDes.Length() - KWarning().Length()); + } + aDes.Append(KWarning); + } + }; + +/** + * Target of ERR_PRINTFx, INFO_PRINTFx, WARN_PRINTFx macros. + * Message is formatted then passed to the MOmxScriptTestLogger. + */ +void ROmxScriptTest::LogExtra(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, + TRefByValue aFmt,...) + { + VA_LIST aList; + VA_START(aList, aFmt); + + TOverflowHandler overflow; + TBuf<255> msg; + msg.AppendFormatList(aFmt, aList, &overflow); + + iLogger.Log(aFile, aLine, aSeverity, msg); + + VA_END(aList); + } + +void ROmxScriptTest::RegisterTunnel(OMX_COMPONENTTYPE* aSourceComp, TInt aSourcePort, OMX_COMPONENTTYPE* aSinkComp, TInt aSinkPort) + { + // delete previous registration + for(TInt index = 0, count = iTunnels.Count(); index < count; index++) + { + const TTunnelInfo& info = iTunnels[index]; + if(info.iSourceComponent == aSourceComp && info.iSourcePort == aSourcePort || + info.iSinkComponent == aSinkComp && info.iSinkPort == aSinkPort) + { + iTunnels.Remove(index); + index--; + count--; + } + } + + TTunnelInfo info; + info.iSourceComponent = aSourceComp; + info.iSourcePort = aSourcePort; + info.iSinkComponent = aSinkComp; + info.iSinkPort = aSinkPort; + TInt error = iTunnels.Append(info); + if(error) + { + User::Panic(_L("omxscript"), KErrNoMemory); + } + } + +void ROmxScriptTest::FindTransitionOrderL(const RPointerArray& aComponents, + const RTunnelRelations& aTunnelRelations, + RArray& aOrder) + { + RPointerArray componentsSimple; + CleanupClosePushL(componentsSimple); + componentsSimple.ReserveL(aComponents.Count()); + for(TInt index = 0, count = aComponents.Count(); index < count; index++) + { + componentsSimple.AppendL(aComponents[index]->iComponent); + } + RSupplierRelations supplierRelations; + CleanupStack::PushL(TCleanupItem(CloseSupplierRelations, &supplierRelations)); + TInt numComponents = aComponents.Count(); + supplierRelations.ReserveL(numComponents); + for(TInt index = 0; index < numComponents; index++) + { + supplierRelations.Append(RArray()); + } + TInt numTunnels = aTunnelRelations.Count(); + for(TInt index = 0; index < numTunnels; index++) + { + const TTunnelInfo& tunnelInfo = aTunnelRelations[index]; + TInt outputCompIndex = componentsSimple.Find(tunnelInfo.iSourceComponent); + User::LeaveIfError(outputCompIndex); + TInt inputCompIndex = componentsSimple.Find(tunnelInfo.iSinkComponent); + User::LeaveIfError(inputCompIndex); + + OMX_PARAM_BUFFERSUPPLIERTYPE supplier; + supplier.nSize = sizeof(supplier); + supplier.nVersion = KOmxVersion; + supplier.nPortIndex = tunnelInfo.iSourcePort; + OMX_ERRORTYPE error = OMX_GetParameter(tunnelInfo.iSourceComponent, + OMX_IndexParamCompBufferSupplier, + &supplier); + if(error != OMX_ErrorNone) + { + User::Leave(KErrGeneral); + } + if(supplier.eBufferSupplier == OMX_BufferSupplyInput) + { + supplierRelations[inputCompIndex].AppendL(outputCompIndex); + } + else if(supplier.eBufferSupplier == OMX_BufferSupplyOutput) + { + supplierRelations[outputCompIndex].AppendL(inputCompIndex); + } + else + { + User::Leave(KErrArgument); + } + } + + ::FindTransitionOrderL(supplierRelations, aOrder); + + CleanupStack::PopAndDestroy(2, &componentsSimple); + } + +TBool ROmxScriptTest::MosCheckClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState) + { + /* + TODO: Verify that this is a clock component? + */ + + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_CLOCKSTATETYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + /* + Completed by GetConfig() + + conf.eState + conf.nStartTime + conf.nOffset + conf.nWaitMask + */ + + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigTimeClockState, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_GetConfig(OMX_IndexConfigTimeClockState)"), error); + return EFalse; + } + + if(conf.eState != aClockState) + { +// TODO: What about the other values? + ERR_PRINTF3(_L("Clock component expected to be in clock state %S, is actually in %S"), ClockStateDes(aClockState), ClockStateDes(conf.eState)); + StopTest(EFail); + return EFalse; + } + + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF3(_L("State of %S is %S"), &compConverted, ClockStateDes(aClockState)); + + return ETrue; + } + +// for debugging... +TBool ROmxScriptTest::MosCheckTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_TIMESTAMPTYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.nPortIndex = aPortIndex; + /* + To be filled by GetConfig() + conf.nTimestamp; + */ + + OMX_ERRORTYPE error = component->GetConfig(component, OMX_IndexConfigTimePosition, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_GetConfig(OMX_IndexConfigTimePosition)"), error); + return EFalse; + } + if(conf.nTimestamp != aTimestamp) + { + TBuf<64> compConverted; + compConverted.Copy(aComp); + ERR_PRINTF5(_L("Port %d of component %S time position expected to be %d, but is actually %d"), aPortIndex, &compConverted, aTimestamp, conf.nTimestamp); + StopTest(EFail); + return EFalse; + } + + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF4(_L("Port %d of component %S time position verified to be %d"), aPortIndex, &compConverted, conf.nTimestamp); + + return ETrue; + } + +TBool ROmxScriptTest::MosSetTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_TIMESTAMPTYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.nPortIndex = aPortIndex; + conf.nTimestamp = aTimestamp; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimePosition, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimePosition)"), error); + return EFalse; + } + + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF4(_L("Port %d of component %S time position set to %d"), aPortIndex, &compConverted, aTimestamp); + + return ETrue; + } + +TBool ROmxScriptTest::MosCheckFrameCountL(const TDesC& aFilename, TInt aCount) + { + C3GPParse* parser = C3GPParse::NewL(); + CleanupStack::PushL(parser); + TInt err = parser->Open(aFilename); + if(err) + { + CleanupStack::PopAndDestroy(parser); + return EFalse; + } + else + { + TUint num; + err = parser->GetNumberOfVideoFrames(num); + CleanupStack::PopAndDestroy(parser); + if(err) + { + ERR_PRINTF1(_L("aParser->GetNumberOfVideoFrames() failed")); + return EFalse; + } + else + { + //assume 20 dropped frames is accepted normally + //if the frame count is smaller than 20, we just allow 10 dropped frames + TInt tmp = (aCount > 20) ? (aCount - 20): (aCount - 10); + if(num < tmp) + { + ERR_PRINTF1(_L("too many dropped frames, ROmxScriptTest->MosCheckFrameCountL() failed")); + return EFalse; + } + } + } + return ETrue; + } + +TBool ROmxScriptTest::MosMarkBuffer(const TDesC8& aComp, TInt aPortIndex, const TDesC8& aTargetComp, TInt markData) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + OMX_COMPONENTTYPE* targetComponent = ComponentByName(aTargetComp); + if(component == NULL || targetComponent == NULL) + { + return EFalse; + } + + OMX_MARKTYPE mark; + mark.hMarkTargetComponent = targetComponent; + mark.pMarkData = reinterpret_cast(markData); + + OMX_ERRORTYPE error = OMX_SendCommand(component, OMX_CommandMarkBuffer, aPortIndex, &mark); + if(error) + { + FailWithOmxError(aComp, _L("SendCommand(MarkBuffer)"), error); + return EFalse; + } + else + { + return ETrue; + } + } + +void ROmxScriptTest::MosParseError(const TDesC& aError) + { + ERR_PRINTF1(aError); + } + +ROmxScriptTest::CComponentInfo* ROmxScriptTest::CComponentInfo::NewL(ROmxScriptTest& aTestController) + { + CComponentInfo* self = new (ELeave) CComponentInfo(aTestController); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void ROmxScriptTest::CComponentInfo::ConstructL() + { + } + +TBool ROmxScriptTest::MosSetClientStartTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_TIMESTAMPTYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.nPortIndex = aPortIndex; + conf.nTimestamp = aTimestamp; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimeClientStartTime, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimeClientStartTime)"), error); + return EFalse; + } + + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF4(_L("Port %d of component %S time position set to %d"), aPortIndex, &compConverted, aTimestamp); + + return ETrue; + } + +TBool ROmxScriptTest::MosSetCurrentAudioReferenceTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_TIME_CONFIG_TIMESTAMPTYPE conf; + conf.nVersion = KOmxVersion; + conf.nSize = sizeof(conf); + conf.nPortIndex = aPortIndex; + conf.nTimestamp = aTimestamp; + + OMX_ERRORTYPE error = component->SetConfig(component, OMX_IndexConfigTimeCurrentAudioReference, &conf); + if(error != OMX_ErrorNone) + { + FailWithOmxError(_L("OMX_SetConfig(OMX_IndexConfigTimeCurrentAudioReference)"), error); + return EFalse; + } + + TBuf<64> compConverted; + compConverted.Copy(aComp); + INFO_PRINTF4(_L("Port %d of component %S time position set to %d"), aPortIndex, &compConverted, aTimestamp); + + return ETrue; + } +#ifdef OLD_ADPCM_EXTENSION +TBool ROmxScriptTest::MosSetAdPcmAudioPortDefL(const TDesC8& aComp, + TInt aPortIndex, + TInt aNumChannels, + TInt aSamplingRate, + TInt aBitsperSample) + { + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + if(!component) + { + return EFalse; + } + + OMX_AUDIO_PARAM_ADPCMTYPE pcmModeType; + pcmModeType.nSize = sizeof(pcmModeType); + pcmModeType.nVersion = KOmxVersion; + pcmModeType.nPortIndex = aPortIndex; + OMX_ERRORTYPE error = component->GetParameter(component, OMX_IndexParamAudioAdpcm, &pcmModeType); + if(error) + { + FailWithOmxError(_L("GetParameter()"), error); + return EFalse; + } + if(aNumChannels != -1) + { + pcmModeType.nChannels = aNumChannels; + } + if(aSamplingRate != -1) + { + pcmModeType.nSampleRate = aSamplingRate; + } + if(aBitsperSample != -1) + { + pcmModeType.nBitsPerSample = aBitsperSample; + } + error = component->SetParameter(component, OMX_IndexParamAudioAdpcm, &pcmModeType); + if(error) + { + FailWithOmxError(_L("SetParameter()"), error); + return EFalse; + } + return ETrue; + } + +TBool ROmxScriptTest::MosConfigAdPcmDecoderBlockAlign(const TDesC8& aComp, OMX_S32 aBlockAlign) + { + // Create param + OMX_SYMBIAN_AUDIO_PARAM_ADPCMDECODER_BLOCKALIGN param; + param.nSize = sizeof(param); + param.nVersion = KAdPcmDecoderConfigVersion; + param.nPortIndex = 0; + param.nBlockAlign = aBlockAlign; + + // Show debugging info + INFO_PRINTF2(_L("Setting the size of the AdPcm block to %d"), aBlockAlign); + + // Get component + OMX_COMPONENTTYPE* component = ComponentByName(aComp); + + // Check component + if(!component) + return EFalse; + + // Set the config + OMX_ERRORTYPE error = component->SetParameter(component, static_cast(OMX_SymbianIndexParamAudioAdPcmDecoderBlockAlign), ¶m); + if(error) + { + FailWithOmxError(_L("SetParameter(OMX_SymbianIndexParamAudioAdPcmDecoderBlockAlign)"), error); + return EFalse; + } + else + { + return ETrue; + } + } +#endif + +ROmxScriptTest::CComponentInfo::CComponentInfo(ROmxScriptTest& aTestController) +: iTestController(aTestController) + { + } + +ROmxScriptTest::CComponentInfo::~CComponentInfo() + { + // convert from 8-bit descriptors for logging + TBuf<64> shortName; + TBuf<64> compName; + shortName.Copy(*iShortName); + compName.Copy(*iComponentName); + OMX_ERRORTYPE error = OMX_ErrorNone; + if(iComponent != NULL) + { + iTestController.INFO_PRINTF3(_L("Unloading component %S (%S)"), &shortName, &compName); + if(iThreadRequest != NULL) + { + error = iThreadRequest->FreeHandle(iComponent); + delete iShortName; + delete iComponentName; + delete iBaseHandler; + } + else + { + delete iShortName; + delete iComponentName; + delete iBaseHandler; + error = OMX_FreeHandle(iComponent); + } + } + + if(error) + { + iTestController.FailWithOmxError(_L("OMX_FreeHandle()"), error); + } + delete iThreadRequest; + } +void HashFilter_16bit_EndianSwap(RBuf8& aBuf) + { + for (TInt i=0;i +#include "omxthreadrequest.h" +#include "omx_xml_script.h" +//#include +#include +#include +#include "portbufferhandler.h" + +class CNonTunneledHandler; +class CVideoBufferHandler; +class CVideoBufferSinkHandler; +class CBaseProfileHandler; +class CWindowManager; + +const OMX_VERSIONTYPE KOmxVersion = { OMX_VERSION_MAJOR, OMX_VERSION_MINOR, OMX_VERSION_REVISION, OMX_VERSION_STEP }; + +/** + * Class to parse and execute an OMX test case specified in + * an XML file. + */ +NONSHARABLE_CLASS(ROmxScriptTest) : public MOmxScriptIf, public MASBreakCallback, public MTimerObserver + { +public: + + NONSHARABLE_CLASS(CComponentInfo) : public CBase + { + public: + static CComponentInfo* NewL(ROmxScriptTest& aTestController); + ~CComponentInfo(); + + private: + CComponentInfo(ROmxScriptTest& aTestController); + void ConstructL(); + + public: + HBufC8* iShortName; + HBufC8* iComponentName; + OMX_COMPONENTTYPE* iComponent; + CBaseProfileHandler* iBaseHandler; //NULL if not being used via OMX IL Base Profile + COmxThreadRequest* iThreadRequest; + + private: + ROmxScriptTest& iTestController; + }; + + class TExpectedEvent + { + public: + OMX_COMPONENTTYPE* iComponent; + OMX_EVENTTYPE iEvent; + TUint32 iData1; + TUint32 iData2; + TAny* iEventData; + }; + typedef void (*THashFilter)(RBuf8&); + THashFilter GetHashFilterByName(const TDesC8& aName); + + ROmxScriptTest(MOmxScriptTestLogger& aLogger); + void Close(); + + void RunTestL(const TDesC& aScriptFilename, const TDesC& aScriptSection); + + // MOmxScriptIf + TBool MosLoadComponentL(const TDesC8& aComp, const TDesC8& aName, TBool aBaseProfile, const TDesC8* aBaseImpl, TBool aLoadInCoreServerThread); + TBool MosSetupTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, OMX_ERRORTYPE aExpectedError); + TBool MosSetupNonTunnel(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier); + TBool MosSetWindowL(const TDesC8& aComp); + TBool MosSetDroppedFrameEvent(const TDesC8& aComp, const TDesC8& aAction); + TBool MosAllTransitionL(OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError, TTransitionOrder aOrder); + TBool MosWaitEOS(); + TBool MosWaitEOS(const TDesC8& aComp); + TBool MosSetFilename(const TDesC8& aComp, const TDesC& aFilename); + + TBool MosSetFilename_bellagio(const TDesC8& aComp, char *filepath); + + TBool MosSetBadFilename(const TDesC8& aComp); + TBool MosGetFilename(const TDesC8& aComp, TDesC& aFilename, OMX_ERRORTYPE aExpectedError); + + TBool MosSetBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError); + TBool MosCompareFilesL(const TDesC& aFileOne, const TDesC& aFileTwo); + TBool MosFilterAndCompareFilesL( + const TDesC& aFileOne, const TDesC8& aFile1Filter1, const TDesC8& aFile1Filter2, const TDesC8& aFile1Filter3, + const TDesC& aFileTwo, const TDesC8& aFile2Filter1, const TDesC8& aFile2Filter2, const TDesC8& aFile2Filter3); + TBool MosBufferSupplierOverrideL(const TDesC8& aSourceComp, TInt aSourcePort, + const TDesC8& aSinkComp, TInt aSinkPort, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_ERRORTYPE aExpectedSourceError, OMX_ERRORTYPE aExpectedSinkError); + TBool MosSetVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_COLOR_FORMATTYPE* aColorFormat, OMX_VIDEO_CODINGTYPE* aCodingType, TInt aStride, TReal aFps, OMX_ERRORTYPE aExpectedError); + TBool MosSetCameraOneShotL(const TDesC8& aComp, TInt aIsOneShot, OMX_ERRORTYPE aExpectedError); + TBool MosSetCameraCaptureL(const TDesC8& aComp, TInt aPortIndex, TInt aIsCapturing, OMX_ERRORTYPE aExpectedError); + void MosParseError(const TDesC& aError); + TBool MosWaitL(TTimeIntervalMicroSeconds32 aDelay); + TBool MosExpectEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2); + TBool MosWaitForAllEventsL(); + TBool MosTransition(const TDesC8& aComp, OMX_STATETYPE aState, TBool aAsync); + TBool MosFailingTransition(const TDesC8& aComp, OMX_STATETYPE aState,OMX_ERRORTYPE aExpectedError); + TBool MosCheckStateL(const TDesC8& aComp, OMX_STATETYPE aState); + TBool MosCheckVideoPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aWidth, TInt aHeight, OMX_VIDEO_CODINGTYPE aCoding, OMX_COLOR_FORMATTYPE aColorFormat); + TBool MosCheckMetaDataL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData); + TBool MosGetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData); + TBool MosSetParameterUnknownIndexTypeL(const TDesC8& aComp, TInt aPortIndex, OMX_METADATASCOPETYPE aScope, const TDesC8& aAtomType, TUint32 aAtomIndex, const TDesC8& aData); + + TBool MosDisablePort(const TDesC8& aComp, TInt aPortIndex); + TBool MosEnablePort(const TDesC8& aComp, TInt aPortIndex); + TBool MosIgnoreEventL(const TDesC8& aComp, OMX_EVENTTYPE aEvent, TUint32 nData1, TUint32 nData2); + TBool MosSetPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample, OMX_NUMERICALDATATYPE aNumData, OMX_ENDIANTYPE aEndian, OMX_BOOL* aInterleaved, const TDesC8* aEncoding); + TBool MosSetConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume, OMX_ERRORTYPE aExpectedError); + TBool MosCheckConfigAudioVolumeL(const TDesC8& aComp, TInt aPortIndex, TBool aLinear, TInt aMinVolume, TInt aMaxVolume, TInt aVolume); + TBool MosCheckConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute); + TBool MosSetConfigAudioMuteL(const TDesC8& aComp, TInt aPortIndex, TBool aMute); + TBool MosSetAacAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAacTools, TInt aAacErTools, TInt aProfile, TInt aStreamFormat, TInt aChannelMode); + TBool MosSetAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, OMX_AUDIO_CODINGTYPE* aCodingType, OMX_ERRORTYPE aExpectedError); + TBool MosSetRefClockTypeL(const TDesC8& aComp, OMX_TIME_REFCLOCKTYPE aRefClockType); + TBool MosSetClockTimeScale(const TDesC8& aComp, OMX_S32 aScale); + TBool MosSetClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState, TInt aStartTime, TInt aOffset, TUint32 aWaitMask); + TBool MosCheckClockStateL(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aClockState); + TBool MosCheckTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp); + TBool MosSetTimePositionL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp); + TBool MosSetClientStartTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp); + TBool MosSetCurrentAudioReferenceTimeL(const TDesC8& aComp, TInt aPortIndex, TInt aTimestamp); + TBool MosSetVideoFitModeL(TVideoFitMode aVideoFitMode); + TBool MosNegativeSetDataChunk(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError, TInt aExpectedSystemError); + TBool MosCheckFrameCountL(const TDesC& aFilename, TInt aCount); + TBool InitialiseBufferHandlerL(const TDesC8& aComp, TDesC& aName, const TDesC8* aType); + void StartBufferHandler(); + void StopBufferHandler(); + void SendInvalidBufferId(TInt aInvalidId); + TBool InitialiseBufferSinkHandlerL(const TDesC8& aComp, TDesC& aName); + void StartBufferSinkHandler(); + void StopBufferSinkHandler(); + + TBool MosSetBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aCount, OMX_ERRORTYPE aExpectedError); + TBool MosGetAndCompareBufferCount(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare); + TBool MosGetAndCompareBufferSize(const TDesC8& aComp, TInt aPortIndex, TInt aDataToCompare); + TBool MosFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError); + TBool MosForceFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError); + TBool MosSetActiveStream(const TDesC8& aComp, TUint32 aPortIndex); + TBool MosGetActiveStream(const TDesC8& aComp, TUint32 aPortIndex); + TBool MosChangeFilledBufferLength(const TDesC8& aComp, TInt aValue); + TBool MosSetOMX_SymbianIndexParamBufferMsgQueueData(const TDesC8& aComp, OMX_ERRORTYPE aExpectedError); + TBool MosGetExtensionIndex(const TDesC8& aComp, const TDesC8& aParameterName, OMX_ERRORTYPE aExpectedError); + + TBool MosCheckTimeClockState(const TDesC8& aComp, OMX_TIME_CLOCKSTATE aExpectedState); + TBool MosCheckMediaTime(const TDesC8& aComp, TInt aPortIndex, OMX_TICKS aMediaTime, TBool aMoreThan); + TBool MosBaseSupportPortL(const TDesC8& aComp, TInt aPortIndex); + TBool MosBaseSetAutonomous(const TDesC8& aComp, TInt aPortIndex, TBool aEnabled); + TBool MosBaseAllocateBuffersL(const TDesC8& aComp, TInt aPortIndex, TInt aNumberBuffers); + TBool MosBaseFreeAllocatedBuffersL(const TDesC8& aComp); + TBool MosBaseSetBufSupplier(const TDesC8& aComp, TInt aPortIndex, TBool aComponentSupplier); + TBool MosBaseFillThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex); + TBool MosBaseEmptyThisBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex); + TBool MosBaseWaitForBuffer(const TDesC8& aComp, TInt aPortIndex, TInt aPortRelBufIndex); + TBool MosBaseTimestampPassClock(const TDesC8& aCompReceiving, const TDesC8& aClockCompToPass); + TBool MosBaseTimestampCheckTimestampL(const TDesC8& aComp, TInt aPortIndex, TUint aExpectedTime, TUint aTolerance); + TBool MosBaseTimestampCompareWithRefClockL(const TDesC8& aComp, TInt aPortIndex, TUint aTolerance); + TBool MosMarkBuffer(const TDesC8& aComp, TInt aPortIndex, const TDesC8& aTargetComp, TInt markData); + + // mpeg4 encoder component + TBool MosSetVideoEncQuantL(const TDesC8& aComp, TInt aPortIndex, TInt aQpb); + TBool MosSetVideoEncMotionVectL(const TDesC8& aComp, TInt aPortIndex, TInt aAccuracy, TInt aSxSearchrange, TInt aSySearchrange, OMX_ERRORTYPE aExpectedError); + TBool MosSetVideoEncMpeg4TypeL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_MPEG4PROFILETYPE aMpeg4Profile, OMX_VIDEO_MPEG4LEVELTYPE aMpeg4Level, OMX_ERRORTYPE aExpectedError); + TBool MosSetVideoEncBitRateL(const TDesC8& aComp, TInt aPortIndex, OMX_VIDEO_CONTROLRATETYPE aControlRate, TInt aTargetBitrate, OMX_ERRORTYPE aExpectedError); + + TBool MosSetAACProfileL(const TDesC8& aComp, TInt aPortIndex, TInt aChannels, TInt aSamplingRate, TInt aBitRate, TInt aAudioBandwidth, TInt aFrameLength, TInt aAACTools, TInt aAACERTools, OMX_AUDIO_AACPROFILETYPE aProfile, OMX_AUDIO_AACSTREAMFORMATTYPE aStreamFormat, OMX_AUDIO_CHANNELMODETYPE aChannelMode); + + // Camera + + TBool MosSetSensorModeTypeL(const TDesC8& aComp, TInt aPort, TInt aFrameRate, TBool aOneShot, TInt aWidth, TInt aHeight); + TBool MosSetCaptureModeTypeL(const TDesC8& aComp, TInt aPort, TBool aContinuous, TBool aFrameLimited, TInt aFrameLimit); + + + // Debugging/Utility functions. + TBool MosDeleteFileL(const TDesC& aFileName, TBool aFileMustExist); + TBool MosLogAllEventsL(); + + // MASBreakCallback + void AllComponentsEOS(); + void AllComponentsTransitioned(OMX_STATETYPE aNewState, + OMX_STATETYPE aOldState); + void EventReceived(OMX_COMPONENTTYPE* aComponent, OMX_EVENTTYPE aEvent, TUint32 aData1, TUint32 aData2, TAny* aEventData); + void ComponentTransitioned(OMX_STATETYPE aNewState, + OMX_STATETYPE aOldState); + void BufferDone(OMX_COMPONENTTYPE* aComponent, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource); + + // MTimerObserver + void TimerExpired(); + + TBool MosSetupBufferForPortL(const TDesC8& comp,TInt aPortIndex, const TDesC& aFileName,TInt aHeaderLength,OMX_BUFFERSUPPLIERTYPE aSupplier); + TBool MosStartBuffersforPort(const TDesC8& aComp, TInt aPortIndex); +#ifdef OLD_ADPCM_EXTENSION + TBool MosSetAdPcmAudioPortDefL(const TDesC8& aComp, TInt aPortIndex, TInt aNumChannels, TInt aSamplingRate, TInt aBitsperSample); + TBool MosConfigAdPcmDecoderBlockAlign(const TDesC8& aComp, OMX_S32 aBlockAlign); +#endif + +public: + enum TOmxScriptTestVerdict + { + EPass, EFail, EPending + }; + + TInt Reason() const; + TOmxScriptTestVerdict Verdict() const; + void FailWithOmxError(const TDesC& aOperation, OMX_ERRORTYPE aError); + void StopTest(TOmxScriptTestVerdict aVerdict); + void StopTest(TInt aError, TOmxScriptTestVerdict aVerdict); + void FailTest(const TDesC& aErrorMsg); + + TBool MosForceBufferSourceFlushBufferL(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError); + TBool MosForceBufferSinkFlushBuffer(const TDesC8& aComp, TInt aPortIndex, OMX_ERRORTYPE aExpectedError); + + static TBool ShortNameMatchComparison(const TDesC8* aShortName, const ROmxScriptTest::CComponentInfo& aComponentInfo); + + void BeginWait(); + void EndWait(); + +private: + TBool ComponentLogicalIL(const TDesC8& aName); + TBool ComponentPhysicalIL(const TDesC8& aName); + OMX_COMPONENTTYPE* ComponentByName(const TDesC8& aName); + void GetComponentName(const OMX_COMPONENTTYPE* aHandle, TDes& aName); + void FailWithOmxError(const TDesC8& aComponent, const TDesC& aOperation, OMX_ERRORTYPE aError); + // static void CleanupOmxComponent(TAny*); + static void FormatHex(const TDesC8& bin, TDes& hex); + void WriteInt32(TUint8* aPtr, TInt32 aData); + void HashFileL(const TDesC& aFileName, TDes8& aHash, void (*aFilter1)(RBuf8&) = NULL, void (*aFilter2)(RBuf8&) = NULL, void (*aFilter3)(RBuf8&) = NULL ); + TBool HandleNonTunneledBuffers(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp); + TBool HandlePortBufferHandler(OMX_STATETYPE aNewState, OMX_COMPONENTTYPE* aComp); + + void LogExtra(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, + TRefByValue aFmt,...); + void RegisterTunnel(OMX_COMPONENTTYPE* aSourceComp, TInt aSourcePort, OMX_COMPONENTTYPE* aSinkComp, TInt aSinkPort); + + class TComponentInfo + { + public: + HBufC8* iShortName; + HBufC8* iComponentName; + OMX_COMPONENTTYPE* iComponent; + }; +class TFilledBufferHeaderV2 + { +public: + /** Amount of buffer filled with actual data */ + TUint iFilledLength; + /** Any timestamp associated with the buffer */ + TInt64 iTimeStamp; + /** Combination of OMX_BUFFERFLAG_*, specified at page 68 in the OpenMAX spec. */ + TUint iFlags; + /** offset **/ + TUint32 iOffset; + }; + class TTunnelInfo + { + public: + OMX_COMPONENTTYPE* iSourceComponent; + TInt iSourcePort; + OMX_COMPONENTTYPE* iSinkComponent; + TInt iSinkPort; + }; + + RArray iTunnels; + typedef RArray RTunnelRelations; + void FindTransitionOrderL(const RPointerArray& aComponents, + const RTunnelRelations& aTunnelRelations, + RArray& aOrder); + +private: + TBool iCoreLoaded; + RPointerArray iComponents; + RASBreakEventHandler iEventHandler; + OMX_STATETYPE iState; + + // Symbian graphic sink specialisation + CWindowManager* iWindowManager; + TVideoFitMode iVideoFitMode; + OMX_INDEXTYPE iExtSurfaceConfigIndex; + OMX_COMPONENTTYPE* iGraphicSink; + + CVideoTestTimer *iTimer; + + RArray iExpectedEvents; + TBool iWaitingForEvents; + + CNonTunneledHandler* iNonTunneledHandler; + RArray iIgnoredEvents; + + // Buffer component handler + CVideoBufferHandler* iBufferHandler; + CVideoBufferSinkHandler* iBufferSinkHandler; + + TInt iReason; + TOmxScriptTestVerdict iVerdict; + MOmxScriptTestLogger& iLogger; + + CAsyncCallBack* iStopSchedulerCallback; + + RMsgQueue iMsgQueue; + CPortBufferHandler* iPortBufferHandler; + }; + +#endif /*OMXSCRIPTTEST_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxthreadrequest.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxthreadrequest.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,255 @@ +/* +* Copyright (c) 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#include "omxthreadrequest.h" + +COmxThreadRequest* COmxThreadRequest::NewL() + { + COmxThreadRequest* self = new (ELeave) COmxThreadRequest(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +COmxThreadRequest::COmxThreadRequest() + { + } + +void COmxThreadRequest::ConstructL() + { + //Parameters to send to the sub thread + TThreadParam param; + param.iThreadRequestObj = this; + + //Get a reference to this thread's heap + RHeap& thisHeap = User::Heap(); + + //Get the id of this thread + RThread thisThread; + TThreadId thisThreadId = thisThread.Id(); + param.iMainThreadId = thisThreadId; + + //Get a request to signal for setup completion + TRequestStatus setupComplete = KRequestPending; + param.iSetupComplete = &setupComplete; + + //current time and the "this" pointer for a unique key + _LIT(KFormatString,"%S.%020Lu.%08X"); + TName threadName; + TTime now; + now.UniversalTime(); + threadName.Format(KFormatString, &KXMLClientOMXThreadName, now.Int64(), reinterpret_cast(this)); + + //Create a new thread using the same heap as this thread + TInt result = iRequestThread.Create(threadName, + ThreadCreateFunction, + KDefaultStackSize, + &thisHeap, + ¶m); + User::LeaveIfError(result); + + //Run the thread under high priority + iRequestThread.SetPriority(EPriorityNormal); + + //Wait for thread startup to complete + TRequestStatus threadStatus = KRequestPending; + iRequestThread.Logon(threadStatus); + + //Start the thread + iRequestThread.Resume(); + User::WaitForRequest(threadStatus, setupComplete); + if(threadStatus != KRequestPending) + { + //Thread creation failed + TInt reason = iRequestThread.ExitReason(); + User::Leave(reason); + } + + // Thread creation was successfull + TInt error = iRequestThread.LogonCancel(threadStatus); + User::LeaveIfError(error); // There is no outstanding request + User::WaitForRequest(threadStatus); // Consume the signal + + iThreadCreated = ETrue; + User::LeaveIfError(setupComplete.Int()); + } + +/** +Main thread entry point for the omx sub-thread. +Create a cleanup stack for the thread and process the commands +inside a trap for cleanup behaviour. +@internalComponent + +@param aPtr Parameters to be used for creating the thread. +@return The error code for thread termination. +*/ +TInt COmxThreadRequest::ThreadCreateFunction(TAny* aPtr) + { + TInt error = KErrNone; + + // Create a cleanup stack for the thread + CTrapCleanup* cleanupStack = CTrapCleanup::New(); + if (cleanupStack) + { + if(error == KErrNone) + { + TRAP(error, ThreadTrapFunctionL(aPtr)); + } + } + else + { + error = KErrNoMemory; + } + + delete cleanupStack; + return error; + } + +/** +Function for thread execution. If the thread is successfully created signal +the main thread that the thread creation was successfull. Then enter OMX +request loop. + +@internalComponent + +@param aPtr A pointer to a TThreadParam object containing the startup parameters + for the thread. +*/ +void COmxThreadRequest::ThreadTrapFunctionL(TAny* aPtr) + { + TThreadParam* param = static_cast(aPtr); + COmxThreadRequest* iThreadRequestObj = param->iThreadRequestObj; + + // tell main thread that setup is complete + RThread mainThread; + mainThread.Open(param->iMainThreadId); + mainThread.RequestComplete(param->iSetupComplete, KErrNone); + mainThread.Close(); + + // loop to execute OMX commands in own thread + while(iThreadRequestObj->iFunction != EOMXFunctionCodeTerminate) + { + iThreadRequestObj->iRequestThreadStatus = KRequestPending; + + // block until client request is made + User::WaitForRequest(iThreadRequestObj->iRequestThreadStatus); + switch(iThreadRequestObj->iFunction) + { + case EOMXFunctionCodeGetHandle: + iThreadRequestObj->iErrorType = OMX_GetHandle( + iThreadRequestObj->ipHandle, + iThreadRequestObj->icComponentName, + iThreadRequestObj->ipAppData, + iThreadRequestObj->ipCallBacks); + break; + + case EOMXFunctionCodeFreeHandle: + iThreadRequestObj->iErrorType = OMX_FreeHandle( + iThreadRequestObj->ihComponent); + break; + + case EOMXFunctionCodeTerminate: + break; + + default: + // should never be reached + User::Panic(_L("COmxThreadRequest"), KErrNotSupported); + } + + // complete client request + TRequestStatus *status = iThreadRequestObj->iCallingStatus; + RThread callingThread; + callingThread.Open(iThreadRequestObj->iCallingThreadId); + callingThread.RequestComplete(status, KErrNone); + callingThread.Close(); + } + } + +COmxThreadRequest::~COmxThreadRequest() + { + if(iThreadCreated) + { + TRequestStatus status; + // Logon to ensure thread has completely terminated, not just broken out of message handling loop. + // In particular this ensures the cleanup stack is destroyed before the heap marks are inspected. + iRequestThread.Logon(status); + Terminate(); + User::WaitForRequest(status); + iThreadCreated = EFalse; + iRequestThread.Close(); + } + } + +OMX_ERRORTYPE COmxThreadRequest::GetHandle( + OMX_OUT OMX_HANDLETYPE* pHandle, + OMX_IN OMX_STRING cComponentName, + OMX_IN OMX_PTR pAppData, + OMX_IN OMX_CALLBACKTYPE* pCallBacks) + { + ipHandle = pHandle; + icComponentName = cComponentName; + ipAppData = pAppData; + ipCallBacks = pCallBacks; + + iFunction = EOMXFunctionCodeGetHandle; + DoRequest(); + + return iErrorType; + } + +OMX_ERRORTYPE COmxThreadRequest::FreeHandle( + OMX_IN OMX_HANDLETYPE hComponent) + { + ihComponent = hComponent; + + iFunction = EOMXFunctionCodeFreeHandle; + DoRequest(); + + return iErrorType; + } + +void COmxThreadRequest::Terminate() + { + iFunction = EOMXFunctionCodeTerminate; + DoRequest(); + } + +void COmxThreadRequest::DoRequest() + { + RThread me; + iCallingThreadId = me.Id(); + + TRequestStatus callingRequestStatus = KRequestPending; + iCallingStatus = &callingRequestStatus; + + // send request to request thread + RThread requestThread; + requestThread.Open(iRequestThread.Id()); + TRequestStatus* requestStatus = &iRequestThreadStatus; + requestThread.RequestComplete(requestStatus, KErrNone); + requestThread.Close(); + + // block calling request until OMX request completes + User::WaitForRequest(callingRequestStatus); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxthreadrequest.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxthreadrequest.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,94 @@ +/* +* Copyright (c) 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#include +#include + +#ifndef OMXTHREADREQUEST_H +#define OMXTHREADREQUEST_H + +_LIT(KXMLClientOMXThreadName, "XMLClientOMXThread"); + +NONSHARABLE_CLASS(COmxThreadRequest) : public CBase + { +public: + static COmxThreadRequest * NewL(); + ~COmxThreadRequest(); + + OMX_ERRORTYPE GetHandle( + OMX_OUT OMX_HANDLETYPE* pHandle, + OMX_IN OMX_STRING cComponentName, + OMX_IN OMX_PTR pAppData, + OMX_IN OMX_CALLBACKTYPE* pCallBacks); + + OMX_ERRORTYPE FreeHandle(OMX_IN OMX_HANDLETYPE hComponent); + +private: + enum TOMXCoreFunctionCode + { + EOMXFunctionCodeNone, + EOMXFunctionCodeGetHandle, + EOMXFunctionCodeFreeHandle, + EOMXFunctionCodeTerminate + + // ... more to be added when required + }; +private: + COmxThreadRequest(); + void ConstructL(); + void Terminate(); + void DoRequest(); + + static TInt ThreadCreateFunction(TAny* aPtr); + static void ThreadTrapFunctionL(TAny* aPtr); + +private: + + TOMXCoreFunctionCode iFunction; + + RThread iRequestThread; + TRequestStatus iRequestThreadStatus; + //TThreadId iRequestThreadId; + TBool iThreadCreated; + + TRequestStatus* iCallingStatus; // not owned + TThreadId iCallingThreadId; + + OMX_ERRORTYPE iErrorType; // not owned + OMX_HANDLETYPE* ipHandle; // not owned + OMX_STRING icComponentName; // not owned + OMX_PTR ipAppData; // not owned + OMX_CALLBACKTYPE* ipCallBacks; // not owned + OMX_HANDLETYPE ihComponent; // not owned + }; + +/** Internal class for passing parameter to OMX thread */ +class TThreadParam + { +public: + TThreadId iMainThreadId; + TRequestStatus* iSetupComplete; //Not owned + COmxThreadRequest* iThreadRequestObj; //Not owned + }; + +#endif //OMXTHREADREQUEST_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxutil.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxutil.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,71 @@ +/* +* Copyright (c) 2008 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 "omxutil.h" + +void OMXUtil::ErrorDes(OMX_ERRORTYPE aError, TBuf<64>& aErrorDes) + { + switch(aError) + { +#define DEFERR(x) case x: aErrorDes = _L(#x); break; + DEFERR(OMX_ErrorNone); + DEFERR(OMX_ErrorInsufficientResources); + DEFERR(OMX_ErrorUndefined); + DEFERR(OMX_ErrorInvalidComponentName); + DEFERR(OMX_ErrorComponentNotFound); + DEFERR(OMX_ErrorInvalidComponent); + DEFERR(OMX_ErrorBadParameter); + DEFERR(OMX_ErrorNotImplemented); + DEFERR(OMX_ErrorUnderflow); + DEFERR(OMX_ErrorOverflow); + DEFERR(OMX_ErrorHardware); + DEFERR(OMX_ErrorInvalidState); + DEFERR(OMX_ErrorStreamCorrupt); + DEFERR(OMX_ErrorPortsNotCompatible); + DEFERR(OMX_ErrorResourcesLost); + DEFERR(OMX_ErrorNoMore); + DEFERR(OMX_ErrorVersionMismatch); + DEFERR(OMX_ErrorNotReady); + DEFERR(OMX_ErrorTimeout); + DEFERR(OMX_ErrorSameState); + DEFERR(OMX_ErrorResourcesPreempted); + DEFERR(OMX_ErrorPortUnresponsiveDuringAllocation); + DEFERR(OMX_ErrorPortUnresponsiveDuringDeallocation); + DEFERR(OMX_ErrorPortUnresponsiveDuringStop); + DEFERR(OMX_ErrorIncorrectStateTransition); + DEFERR(OMX_ErrorIncorrectStateOperation); + DEFERR(OMX_ErrorUnsupportedSetting); + DEFERR(OMX_ErrorUnsupportedIndex); + DEFERR(OMX_ErrorBadPortIndex); + DEFERR(OMX_ErrorPortUnpopulated); + DEFERR(OMX_ErrorComponentSuspended); + DEFERR(OMX_ErrorDynamicResourcesUnavailable); + DEFERR(OMX_ErrorMbErrorsInFrame); + DEFERR(OMX_ErrorFormatNotDetected); + DEFERR(OMX_ErrorContentPipeOpenFailed); + DEFERR(OMX_ErrorContentPipeCreationFailed); + DEFERR(OMX_ErrorSeperateTablesUsed); + DEFERR(OMX_ErrorTunnelingUnsupported); + DEFERR(OMX_ErrorKhronosExtensions); + DEFERR(OMX_ErrorVendorStartUnused); +#undef DEFERR + default: + aErrorDes.Format(_L("%u"), aError); + break; + } + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/omxutil.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/omxutil.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,31 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +#ifndef OMXUTIL_H_ +#define OMXUTIL_H_ + +#include +#include + +class OMXUtil + { +public: + static void ErrorDes(OMX_ERRORTYPE aError, TBuf<64>& aErrorDes); + }; + +#endif /*OMXUTIL_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/paramconversion.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/paramconversion.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,69 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#include "paramconversion.h" +#include +#include + +OMX_PARAM_CONTENTURITYPE* ParamConversion::FilenameAsContentUriStructV1_0L(const TDesC& aFileName) + { + CUri8* aFileUri = CUri8::CreateFileUriL(aFileName); + CleanupStack::PushL(aFileUri); + const TDesC8& aUriDes = aFileUri->Uri().UriDes(); + if(aUriDes.Length() > 255) + { + User::Leave(KErrTooBig); + } + OMX_PARAM_CONTENTURITYPE* aUriStruct = reinterpret_cast(new(ELeave) TUint8[264]); + aUriStruct->nSize = 264; + aUriStruct->nVersion.s.nVersionMajor = 1; + aUriStruct->nVersion.s.nVersionMinor = 0; + aUriStruct->nVersion.s.nRevision = 0; + aUriStruct->nVersion.s.nStep = 0; + TPtr8 aUriStructDes(aUriStruct->contentURI, aUriDes.Length()+1); + aUriStructDes = aUriDes; + aUriStructDes.Append('\0'); + CleanupStack::PopAndDestroy(aFileUri); + return aUriStruct; + } + +OMX_PARAM_CONTENTURITYPE* ParamConversion::FilenameAsContentUriStructV1_1L(const TDesC& aFileName) + { + CUri8* aFileUri = CUri8::CreateFileUriL(aFileName); + CleanupStack::PushL(aFileUri); + const TDesC8& aUriDes = aFileUri->Uri().UriDes(); + // sizeof(OMX_PARAM_CONTENTURITYPE) includes 1 byte for the URI name. counting this as well leaves room for a null terminator. + TInt aStructSize = 9 + aUriDes.Length(); + TUint8* aUriBytes = new(ELeave) TUint8[aStructSize]; + OMX_PARAM_CONTENTURITYPE* aUriStruct = reinterpret_cast(aUriBytes); + aUriStruct->nSize = aStructSize; + aUriStruct->nVersion.s.nVersionMajor = OMX_VERSION_MAJOR; + aUriStruct->nVersion.s.nVersionMinor = OMX_VERSION_MINOR; + aUriStruct->nVersion.s.nRevision = OMX_VERSION_REVISION; + aUriStruct->nVersion.s.nStep = OMX_VERSION_STEP; + TPtr8 aUriStructDes(aUriStruct->contentURI, aUriDes.Length()+1); + aUriStructDes = aUriDes; + aUriStructDes.Append('\0'); + CleanupStack::PopAndDestroy(aFileUri); + return aUriStruct; + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/paramconversion.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/paramconversion.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,53 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#ifndef PARAMCONVERSION_H_ +#define PARAMCONVERSION_H_ + +#include + +struct OMX_PARAM_CONTENTURITYPE; + +class ParamConversion + { +public: + /** + * Converts a file name to a URI, then allocates and fills an + * OMX_PARAM_CONTENTURITYPE structure for OpenMAX IL v1.0. In OpenMax IL + * v1.0, this structure cannot contain URIs larger than 256 bytes + * (including the null terminator). If the converted URI exceeds this + * limit, this method leaves with KErrTooBig. + */ + static OMX_PARAM_CONTENTURITYPE* + FilenameAsContentUriStructV1_0L(const TDesC& aFileName); + + /** + * Converts a file name to a URI, then allocates and fills an + * OMX_PARAM_CONTENTURITYPE structure for OpenMAX IL v1.1. In OpenMax IL + * v1.1, this structure can contain URIs of arbitrary length. + */ + static OMX_PARAM_CONTENTURITYPE* + FilenameAsContentUriStructV1_1L(const TDesC& aFileName); + }; + +#endif /*PARAMCONVERSION_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/parsemap.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/parsemap.c Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,76 @@ +/* +* Copyright (c) 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 "parsemap.h" +#include +#include +#include +#include + +/* function that searches untyped parseMap_XXX tables. also performs literal integer parsing. */ +PARSEMAP_LINKAGE int ParseMapSearch(const char* text, int* result, ParseMapEntry* entries, int numEntries) +{ + int textlen = strlen(text); + int i; + char* endptr = 0; + + /* search the parse map for the matching string */ + for(i = 0; i < numEntries; i++) { + if(entries[i].length == textlen && strcasecmp(text, entries[i].text) == 0) { + *result = entries[i].value; + return 1; + } + } + /* match not found */ + + /* try to parse string as an integer */ + errno = 0; + i = strtol(text, &endptr, 0); + if(errno == ERANGE) + { + errno = 0; + i = (int) strtoul(text, &endptr, 0); + if(errno == ERANGE) + { + return 0; + } + } + if(endptr == (text + textlen)) /* all of string must be part of number */ + { + *result = i; + return 1; + } + + /* fail */ + return 0; +} + +PARSEMAP_LINKAGE const char* ParseMapSearchReverse(int value, char not_found_buf[11], ParseMapEntry* entries, int numEntries) { + int i; + + /* search the parse map for the matching value */ + for(i = 0; i < numEntries; i++) { + if(entries[i].value == value) { + return entries[i].text; + } + } + + /* value not found in table, format hex string */ + sprintf(not_found_buf, "0x%08X", value); + return not_found_buf; +} diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/parsemap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/parsemap.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,77 @@ +/* +* Copyright (c) 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: +* +*/ + + +#ifndef PARSEMAP_H_ +#define PARSEMAP_H_ + +/* define PARSEMAP_LINKAGE to prepend extern "C" in front of symbols if using a C++ compiler */ +#ifdef __cplusplus +#define PARSEMAP_LINKAGE extern "C" +#else +#define PARSEMAP_LINKAGE +#endif + +/* the structure used in the parseMap_XXX tables */ +typedef struct +{ + int value; /* numeric value */ + const char* text; /* textual equivalent of value */ + int length; /* length of text. avoids heavy use of strlen */ +} ParseMapEntry; + +/* function that searches untyped parseMap_XXX tables. also performs literal integer parsing. */ +PARSEMAP_LINKAGE int ParseMapSearch(const char* text, int* result, ParseMapEntry* entries, int numEntries); +PARSEMAP_LINKAGE const char* ParseMapSearchReverse(int value, char not_found_buf[11], ParseMapEntry* entries, int numEntries); + +/* macro to declare a parser function of type T */ +#define DECL_PARSETYPE(T) \ +PARSEMAP_LINKAGE int parse_##T(const char* text, T* result); \ +PARSEMAP_LINKAGE const char* format_##T(T value, char not_found_buf[11]) + +/* macro to begin a parseMap definition of type T */ +#define PARSE_MAP_START(T) \ +const ParseMapEntry parseMap_##T[] = { + +/* macro to add a ParseMapEntry struct to a parseMap table. preprocessor is used to generate text and length values. */ +#define PARSE_MAP_ENTRY(x) \ +{ x, #x, sizeof(#x)-1 } + +/* macro to create a ParseMapEntry where the text is not identical to the C identifier. */ +#define PARSE_MAP_ALIAS(val, alias) \ +{ val, alias, sizeof(alias)-1 } + +#define PARSE_MAP_PREFIXENTRY(prefix, tail) \ +PARSE_MAP_ENTRY(prefix##tail), \ +PARSE_MAP_ALIAS(prefix##tail, #tail) + +/* macro to end a parseMap definition. also defines the typed parser function */ +#define PARSE_MAP_END(T) \ +}; \ +\ +PARSEMAP_LINKAGE int parse_##T(const char* text, T* result) \ + { \ + return ParseMapSearch(text, (int*) result, (ParseMapEntry*) parseMap_##T, sizeof(parseMap_##T) / sizeof(ParseMapEntry)); \ + } \ +\ +PARSEMAP_LINKAGE const char* format_##T(T value, char not_found_buf[11]) \ + { \ + return ParseMapSearchReverse((int) value, not_found_buf, (ParseMapEntry*) parseMap_##T, sizeof(parseMap_##T) / sizeof(ParseMapEntry)); \ + } \ + + +#endif /* PARSEMAP_H_ */ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/portbufferhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/portbufferhandler.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,616 @@ +// 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 "portbufferhandler.h" +#include "log.h" // currently needed for INFO_PRINTF etc macros + +/** + * Overflow handler to generate a warning message if a log line will not fit + * in the descriptor. + */ +class TOverflowHandler : public TDes16Overflow + { +public: + void Overflow(TDes& aDes) + { + _LIT(KWarning, "[truncated]"); + if(aDes.Length() + KWarning().Length() > aDes.MaxLength()) + { + aDes.SetLength(aDes.Length() - KWarning().Length()); + } + aDes.Append(KWarning); + } + }; + +CPortBufferHandler::CPortBufferHandler() + { + } + +CPortBufferHandler::~CPortBufferHandler() + { + } + +void CPortBufferHandler::AddPortL(OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + const TDesC& aFileName, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength) + { + + CComponentInfo* compInfo = NULL; + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + compInfo = iComponents[pos]; + } + else + { + compInfo = new (ELeave) CComponentInfo(aComp); + CleanupStack::PushL(compInfo); + iComponents.AppendL(compInfo); + CleanupStack::Pop(compInfo); + } + + + CPortInfo* portInfo = compInfo->AddPortL(aPortNum,aFileName,aSupplier,aPortDir,aLogger,aHeaderLength); + } + +void CPortBufferHandler::AllocateBuffersL(OMX_COMPONENTTYPE* aComp) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->AllocateBuffersL(); + } + } + +void CPortBufferHandler::Start(OMX_COMPONENTTYPE* aComp, TInt aPortNum) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->Start(aPortNum); + } + } + +void CPortBufferHandler::Resume(OMX_COMPONENTTYPE* aComp, TInt aPortNum) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->Resume(aPortNum); + } + } + +void CPortBufferHandler::BufferDone(OMX_COMPONENTTYPE* aComp, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->BufferDone(aBufHdr, aSource); + } + } + +void CPortBufferHandler::Stop(OMX_COMPONENTTYPE* aComp, TInt aPortNum) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->Stop(aPortNum); + } + } + + +void CPortBufferHandler::Pause(OMX_COMPONENTTYPE* aComp, TInt aPortNum) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->Pause(aPortNum); + } + } + +void CPortBufferHandler::FreeBuffers(OMX_COMPONENTTYPE* aComp) + { + TInt pos = iComponents.Find(*aComp, CComponentInfo::CompareComp); + if (pos >= 0) + { + iComponents[pos]->FreeBuffers(); + } + } + +CPortBufferHandler::CComponentInfo::CComponentInfo(OMX_COMPONENTTYPE* aComp) : + iComp(aComp),iState(OMX_StateLoaded) + { + } + +CPortBufferHandler::CComponentInfo::~CComponentInfo() + { + iPorts.ResetAndDestroy(); + } + +CPortBufferHandler::CPortInfo* CPortBufferHandler::CComponentInfo::AddPortL(TInt aPortNum, const TDesC& aFileName,OMX_BUFFERSUPPLIERTYPE aSupplier, OMX_DIRTYPE aPortDir, MOmxScriptTestLogger& aLogger, TInt aHeaderLength) + { + __ASSERT_ALWAYS(iPorts.Find(aPortNum, CPortInfo::ComparePortNum) == KErrNotFound, User::Invariant()); + + CPortInfo* portInfo = CPortInfo::NewL(iComp, aPortNum, aFileName, aSupplier, aPortDir, aLogger, aHeaderLength); + CleanupStack::PushL(portInfo); + iPorts.AppendL(portInfo); + CleanupStack::Pop(portInfo); + + return portInfo; + } + +void CPortBufferHandler::CComponentInfo::AllocateBuffersL() + { + TInt numPorts = iPorts.Count(); + + for (TInt port = 0; port < numPorts; ++port) + { + iPorts[port]->AllocateBuffersL(); + } + iState = OMX_StateIdle; + } + +void CPortBufferHandler::CComponentInfo::Start(TInt aPortNum) + { + TInt numPorts = iPorts.Count(); + + if(aPortNum == -1) + { + for (TInt port = 0; port < numPorts; ++port) + { + iPorts[port]->Start(); + } + } + else + { + TInt pos = iPorts.Find(aPortNum, CPortInfo::ComparePortNum); + iPorts[pos]->Start(); + } + iState = OMX_StateExecuting; + } + +void CPortBufferHandler::CComponentInfo::Resume(TInt aPortNum) + { + if(aPortNum == -1) + { + TInt numPorts = iPorts.Count(); + + for (TInt port = 0; port < numPorts; ++port) + { + iPorts[port]->Resume(); + } + } + else + { + TInt pos = iPorts.Find(aPortNum, CPortInfo::ComparePortNum); + iPorts[pos]->Resume(); + } + iState = OMX_StateExecuting; + } + +void CPortBufferHandler::CComponentInfo::BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource) + { + TInt pos = KErrNotFound; + + if (aSource) + { + pos = iPorts.Find(static_cast(aBufHdr->nOutputPortIndex), CPortInfo::ComparePortNum); + } + else + { + pos = iPorts.Find(static_cast(aBufHdr->nInputPortIndex), CPortInfo::ComparePortNum); + } + + __ASSERT_ALWAYS(pos != KErrNotFound, User::Invariant()); + + iPorts[pos]->BufferDone(aBufHdr); + } + +void CPortBufferHandler::CComponentInfo::Stop(TInt aPortNum) + { + if(aPortNum == -1) + { + for (TInt port = 0; port < iPorts.Count(); ++port) + { + iPorts[port]->Stop(); + } + } + else + { + TInt pos = iPorts.Find(aPortNum, CPortInfo::ComparePortNum); + iPorts[pos]->Stop(); + } + iState = OMX_StateIdle; + } + +void CPortBufferHandler::CComponentInfo::Pause(TInt aPortNum) + { + if(aPortNum == -1) + { + for (TInt port = 0; port < iPorts.Count(); ++port) + { + iPorts[port]->Pause(); + } + } + else + { + TInt pos = iPorts.Find(aPortNum, CPortInfo::ComparePortNum); + iPorts[pos]->Pause(); + } + iState = OMX_StatePause; + } + +void CPortBufferHandler::CComponentInfo::FreeBuffers() + { + for (TInt port = 0; port < iPorts.Count(); ++port) + { + iPorts[port]->FreeBuffers(); + } + iState = OMX_StateLoaded; + } + +TBool CPortBufferHandler::CComponentInfo::CompareComp(const OMX_COMPONENTTYPE* aComp, const CComponentInfo& aComponentInfo) + { + return (aComp == aComponentInfo.iComp); + } + + +CPortBufferHandler::CPortInfo::CPortInfo( OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength): + iComp(aComp), + iPortNum(aPortNum), + iSupplier(aSupplier), + iPortDir(aPortDir), + iPosInputData(0), + iFileHeaderLength(0), + iFileFillingLength(0), + iLogger(aLogger), + iEOSReached(FALSE), + iTimeStamp(0) + { + if(aHeaderLength > -1) + { + iFileHeaderLength = aHeaderLength; + } + } + +CPortBufferHandler::CPortInfo* CPortBufferHandler::CPortInfo::NewL( OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + const TDesC& aFileName, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength) + { + CPortInfo* self = new (ELeave) CPortInfo(aComp,aPortNum,aSupplier,aPortDir,aLogger,aHeaderLength); + CleanupStack::PushL(self); + + self->iFileName.Copy(KPortDirectoryPath); + self->iFileName.Append(aFileName); + + User::LeaveIfError(self->iFs.Connect()); + if(self->iPortDir == OMX_DirInput) + { + User::LeaveIfError(self->iFileObject.Open(self->iFs, self->iFileName, EFileShareExclusive|EFileRead)); + } + else if(self->iPortDir == OMX_DirOutput) + { + User::LeaveIfError(self->iFileObject.Replace(self->iFs, self->iFileName, EFileWrite)); + } + else + { + User::LeaveIfError(KErrNotFound); + } + + CleanupStack::Pop(self); + return self; + } + +CPortBufferHandler::CPortInfo::~CPortInfo() + { + DeleteAllBuffers(); + iFileObject.Close(); + iFs.Close(); + } + +void CPortBufferHandler::CPortInfo::AllocateBuffersL() + { + OMX_BUFFERHEADERTYPE* bufHdr = NULL; + + if (iComp) + { + + OMX_PARAM_PORTDEFINITIONTYPE portDef; + portDef.nSize = sizeof(portDef); + portDef.nVersion = KOmxLILVersion; + portDef.nPortIndex = iPortNum; + OMX_ERRORTYPE error = iComp->GetParameter(iComp, OMX_IndexParamPortDefinition, &portDef); + if(error != OMX_ErrorNone) + { + User::Leave(error); + } + + iNumBufs = portDef.nBufferCountActual; + TInt bufSize = portDef.nBufferSize; + + if(iFileHeaderLength <=0) + { + iFileHeaderLength = bufSize; + } + + //fix for video partial tunnelling + //mpeg4decoder needs timestamp info in each frame. + //Buffer size approximately adjusted to framesize and timestamps added for each buffer + //this change is done for all video components(needed only for mpeg4decoder) + + if(portDef.eDomain == OMX_PortDomainVideo) + { + iFileFillingLength = 1600; //bufSize; + } + else + { + iFileFillingLength = bufSize; + } + + if (iSupplier == OMX_BufferSupplyInput) + { + for (TInt buf = 0; buf < iNumBufs; ++buf) + { + iComp->AllocateBuffer(iComp, &bufHdr, iPortNum, NULL, bufSize); + bufHdr->pAppPrivate = (OMX_PTR)EBufferFree; + iBufferHeaders.AppendL(bufHdr); + } + } + else + { + OMX_U8* newBuffer = NULL; + + for (TInt buf = 0; buf < iNumBufs; ++buf) + { + newBuffer = new (ELeave) OMX_U8[bufSize]; + CleanupStack::PushL(newBuffer); + iBuffers.AppendL(newBuffer); + CleanupStack::Pop(newBuffer); + + OMX_ERRORTYPE err = iComp->UseBuffer(iComp, &bufHdr, iPortNum, NULL, bufSize, newBuffer); + if(err != OMX_ErrorNone) + { + //error encountered in allocating. + } + bufHdr->pAppPrivate = (OMX_PTR)EBufferFree; + iBufferHeaders.AppendL(bufHdr); + } + } + } + } + +void CPortBufferHandler::CPortInfo::BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr) + { + for (TInt buf = 0; buf < iNumBufs; ++buf) + { + if (iBufferHeaders[buf] == aBufHdr) + { + aBufHdr->pAppPrivate = (OMX_PTR)EBufferFree; + if(iPortDir == OMX_DirInput) + { + TPtr8 data(aBufHdr->pBuffer,aBufHdr->nAllocLen); + Mem::FillZ(aBufHdr->pBuffer,aBufHdr->nAllocLen); + // Read data to this buffer. + TInt err = iFileObject.Read(iPosInputData,data,iFileFillingLength); + iPosInputData += iFileFillingLength; + if(err != KErrNone) + { + return; //error return. + } + + aBufHdr->nTimeStamp = iTimeStamp* 1000; + iTimeStamp += 100; + if(!iEOSReached) + { + aBufHdr->nFilledLen = data.Size(); + aBufHdr->nOffset = 0; + aBufHdr->nInputPortIndex = iPortNum; + aBufHdr->nOutputPortIndex = OMX_ErrorMax; + + //Send buffer to port and mark that it is under use. + aBufHdr->pAppPrivate = (OMX_PTR)EBufferUnderUse; + if((data.Size() < aBufHdr->nAllocLen)&&(data.Size() < iFileFillingLength)) + { + //INFO_PRINTF1(_L("EOS detected on Input Port")); + aBufHdr->nFlags |= OMX_BUFFERFLAG_EOS; + iEOSReached = ETrue; + } + iComp->EmptyThisBuffer(iComp, aBufHdr); + } + } + else + { + //create a pointer into buffer + // using ptr , write buffer data to File. + TPtr8 data( aBufHdr->pBuffer+aBufHdr->nOffset, aBufHdr->nFilledLen, aBufHdr->nAllocLen ); + TInt err = iFileObject.Write(data); + if(err != KErrNone) + { + return; //error return. + } + err = iFileObject.Flush(); + if(err != KErrNone) + { + return; //error return. + } + aBufHdr->pAppPrivate = (OMX_PTR)EBufferFree; + aBufHdr->nFilledLen = 0; + aBufHdr->nOffset = 0; + aBufHdr->nOutputPortIndex = iPortNum; + aBufHdr->nInputPortIndex = OMX_ErrorMax; + if(aBufHdr->nFlags & OMX_BUFFERFLAG_EOS) + { + // TODO Logic for EOS + return; + } + else + { + iComp->FillThisBuffer(iComp, aBufHdr); + } + + } + } + } + } +void CPortBufferHandler::CPortInfo::Start() + { + for (TInt buf = 0; buf < iNumBufs; ++buf) + { + OMX_BUFFERHEADERTYPE *bufferHdr = iBufferHeaders[buf]; + + if (bufferHdr->pAppPrivate == (OMX_PTR)EBufferFree) + { + if(iPortDir == OMX_DirInput) + { + TPtr8 data(bufferHdr->pBuffer,bufferHdr->nAllocLen); + // Read data to this buffer. + TInt err =0; + if(buf == 0) + { + err = iFileObject.Read(iPosInputData,data,iFileHeaderLength); + iPosInputData += iFileHeaderLength; + bufferHdr->nFlags |= OMX_BUFFERFLAG_STARTTIME; + } + else + { + err = iFileObject.Read(iPosInputData,data,iFileFillingLength); + iPosInputData += iFileFillingLength; + } + if(err != KErrNone) + { + return; //error return. + } + + bufferHdr->nTimeStamp = iTimeStamp * 1000; + iTimeStamp += 100; + if(data.Size()) + { + bufferHdr->nFilledLen = data.Size(); + bufferHdr->nOffset = 0; + + //Send buffer to port and mark that it is under use. + bufferHdr->pAppPrivate = (OMX_PTR)EBufferUnderUse; + //CHeck for EOF + if(buf > 0) + { + if(data.Size() < iFileFillingLength) + { + bufferHdr->nFlags |= OMX_BUFFERFLAG_EOS; + } + } + + if(buf == 0) + { + if(data.Size() < iFileHeaderLength) + { + ASSERT(0); + return; + } + } + + iComp->EmptyThisBuffer(iComp, bufferHdr); + } + } + else + { + bufferHdr->pAppPrivate = (OMX_PTR)EBufferUnderUse; + bufferHdr->nFilledLen = 0; + bufferHdr->nOffset = 0; + iComp->FillThisBuffer(iComp, bufferHdr); + } + } + + } + } + +void CPortBufferHandler::CPortInfo::Stop() + { +//Todo: implement any stop functionality required. + } + +void CPortBufferHandler::CPortInfo::Resume() + { +//Todo: implement any resume functionality required. + } + + +void CPortBufferHandler::CPortInfo::Pause() + { +//Todo: implement any resume functionality required. + } + +void CPortBufferHandler::CPortInfo::FreeBuffers() + { + for (TInt buf = 0; buf < iNumBufs; ++buf) + { + iComp->FreeBuffer(iComp, iPortNum, iBufferHeaders[buf]); + } + + DeleteAllBuffers(); + } + +void CPortBufferHandler::CPortInfo::DeleteAllBuffers() + { + iBufferHeaders.Reset(); + + if (iComp && iSupplier != OMX_BufferSupplyInput) + { + iBuffers.ResetAndDestroy(); + } + else + { + iBuffers.Reset(); + } + } + +TBool CPortBufferHandler::CPortInfo::ComparePortNum(const TInt* aPortNum, const CPortInfo& aPortInfo) + { + //return (aComp == aPortInfo.iComp); + return (*aPortNum == aPortInfo.iPortNum); + } + +OMX_DIRTYPE& CPortBufferHandler::CPortInfo::PortDir() + { + return iPortDir; + } + +void CPortBufferHandler::CPortInfo::LogExtra(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, + TRefByValue aFmt,...) + { + VA_LIST aList; + VA_START(aList, aFmt); + + TOverflowHandler overflow; + TBuf<255> msg; + msg.AppendFormatList(aFmt, aList, &overflow); + + iLogger.Log(aFile, aLine, aSeverity, msg); + + VA_END(aList); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/portbufferhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/portbufferhandler.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,143 @@ +// 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: +// + + +#ifndef PORTBUFFERHANDLER_H +#define PORTBUFFERHANDLER_H + +#include +#include +#include +#include +#include + +#include "omx_xml_script.h" + +#if defined(__WINSCW__) +_LIT(KPortDirectoryPath, "c:\\mm\\omxlogicalil\\"); +#else +_LIT(KPortDirectoryPath, "e:\\unittest\\mm\\omxlogicalil\\"); +#endif + +const OMX_VERSIONTYPE KOmxLILVersion = { 1, 1, 1, 0 }; + +NONSHARABLE_CLASS(CPortBufferHandler) : public CBase + { +public: + void AddPortL( OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + const TDesC& aFileName, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength); + + void AllocateBuffersL(OMX_COMPONENTTYPE* aComp); + void BufferDone(OMX_COMPONENTTYPE* aComp, OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource); + void FreeBuffers(OMX_COMPONENTTYPE* aComp); + void Start(OMX_COMPONENTTYPE* aComp, TInt aPortNum); + void Resume(OMX_COMPONENTTYPE* aComp, TInt aPortNum); + void Pause(OMX_COMPONENTTYPE* aComp, TInt aPortNum); + void Stop(OMX_COMPONENTTYPE* aComp, TInt aPortNum); + + CPortBufferHandler(); + ~CPortBufferHandler(); + +private: + NONSHARABLE_CLASS(CPortInfo) : public CBase + { + public: + static CPortInfo* NewL( OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + const TDesC& aFileName, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength); + + CPortInfo( OMX_COMPONENTTYPE* aComp, + TInt aPortNum, + OMX_BUFFERSUPPLIERTYPE aSupplier, + OMX_DIRTYPE aPortDir, + MOmxScriptTestLogger& aLogger, + TInt aHeaderLength); + ~CPortInfo(); + void AllocateBuffersL(); + void BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr); + void FreeBuffers(); + void DeleteAllBuffers(); + static TBool ComparePortNum(const TInt* aPortNum, const CPortInfo& aPortInfo); + void Start(); + void Stop(); + void Resume(); + void Pause(); + OMX_DIRTYPE& PortDir(); + void LogExtra(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, + TRefByValue aFmt,...); + + enum + { + EBufferFree, + EBufferUnderUse + }; + + private: + TBuf iFileName; + RFs iFs; + RFile iFileObject; + OMX_COMPONENTTYPE* iComp; + TInt iPortNum; + TInt iNumBufs; + OMX_BUFFERSUPPLIERTYPE iSupplier; + RPointerArray iBuffers; + RPointerArray iBufferHeaders; + OMX_DIRTYPE iPortDir; + TInt iPosInputData; + TInt iFileHeaderLength; + TInt iFileFillingLength; + MOmxScriptTestLogger& iLogger; + TBool iEOSReached; + TUint32 iTimeStamp; + }; + + NONSHARABLE_CLASS(CComponentInfo) : public CBase + { + public: + CComponentInfo(OMX_COMPONENTTYPE* aComp); + ~CComponentInfo(); + CPortInfo* AddPortL(TInt aPortNum, const TDesC& aFileName,OMX_BUFFERSUPPLIERTYPE aSupplier, OMX_DIRTYPE aPortDir, MOmxScriptTestLogger& aLogger, TInt aHeaderLength); + void AllocateBuffersL(); + void FillBuffers(); + void BufferDone(OMX_BUFFERHEADERTYPE* aBufHdr, TBool aSource); + void HoldBuffers(); + void FreeBuffers(); + static TBool CompareComp(const OMX_COMPONENTTYPE* aSource, const CComponentInfo& aComponentInfo); + + void Start(TInt aPortNum); + void Stop(TInt aPortNum); + void Resume(TInt aPortNum); + void Pause(TInt aPortNum); + + private: + OMX_COMPONENTTYPE* iComp; + RPointerArray iPorts; + OMX_STATETYPE iState; + }; + + + RPointerArray iComponents; + }; + +#endif // PORTBUFFERHANDLER_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/statedes.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/statedes.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,73 @@ +/* +* 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#include "statedes.h" + +_LIT(KStateLoaded, "LOADED"); +_LIT(KStateIdle, "IDLE"); +_LIT(KStateExecuting, "EXECUTING"); +_LIT(KStatePause, "PAUSE"); +_LIT(KStateWaitForResources, "WAIT_FOR_RESOURCES"); +_LIT(KStateStateInvalid, "STATEINVALID"); +_LIT(KBadState, "?"); + +_LIT(KClockStateRunning, "CLOCKSTATE_RUNNING"); +_LIT(KClockStateWaitingForStartTime, "CLOCKSTATE_WAITINGFORSTARTTIME"); +_LIT(KClockStateStopped, "CLOCKSTATE_STOPPED"); +_LIT(KClockStateUnknown, "CLOCKSTATE_UNKNOWN"); + +const TDesC* StateDes(OMX_STATETYPE aState) + { + switch(aState) + { + case OMX_StateLoaded: + return &KStateLoaded; + case OMX_StateIdle: + return &KStateIdle; + case OMX_StateExecuting: + return &KStateExecuting; + case OMX_StatePause: + return &KStatePause; + case OMX_StateWaitForResources: + return &KStateWaitForResources; + case OMX_StateInvalid: + return &KStateStateInvalid; + default: + return &KBadState; + } + } + +const TDesC* ClockStateDes(OMX_TIME_CLOCKSTATE aClockState) + { + switch(aClockState) + { + case OMX_TIME_ClockStateRunning: + return &KClockStateRunning; + case OMX_TIME_ClockStateWaitingForStartTime: + return &KClockStateWaitingForStartTime; + case OMX_TIME_ClockStateStopped: + return &KClockStateStopped; + default: + return &KClockStateUnknown; + } + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/statedes.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/statedes.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,34 @@ +/* +* 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#ifndef STATEDES_H_ +#define STATEDES_H_ + +#include +#include +#include + +const TDesC* StateDes(OMX_STATETYPE aState); +const TDesC* ClockStateDes(OMX_TIME_CLOCKSTATE aClockState); + +#endif /*STATEDES_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/threadedlogger.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/threadedlogger.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,104 @@ +/* +* Copyright (c) 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 "threadedlogger.h" + +CThreadedLogger* CThreadedLogger::NewLC(MOmxScriptTestLogger& aRealLogger) + { + CThreadedLogger* self = new(ELeave) CThreadedLogger(aRealLogger); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +CThreadedLogger::CThreadedLogger(MOmxScriptTestLogger& aRealLogger): +CActive(EPriorityHigh), +iRealLogger(aRealLogger) + { + iCreatorThreadId = iCreatorThread.Id(); + } + +void CThreadedLogger::ConstructL() + { + User::LeaveIfError(iCreatorThread.Open(iCreatorThreadId)); + User::LeaveIfError(iMutex.CreateLocal()); + User::LeaveIfError(iSemaphore.CreateLocal(0)); + CActiveScheduler::Add(this); + iStatus = KRequestPending; + SetActive(); + } + +CThreadedLogger::~CThreadedLogger() + { + Cancel(); + iSemaphore.Close(); + iMutex.Close(); + iCreatorThread.Close(); + } + +void CThreadedLogger::Log(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, const TDes& aMessage) + { + if(RThread().Id() == iCreatorThreadId) + { + iRealLogger.Log(aFile, aLine, aSeverity, aMessage); + } + else + { + // proxy the log to creator thread + + // mutex prevents multiple threads to proxy at the same time + iMutex.Wait(); + + // const_cast is regrettable but all we do is pass the params onto a another MOmxScriptTestLogger which will + // also treat the args as const + iFile = const_cast(aFile); + iLine = aLine; + iSeverity = aSeverity; + iMessage = &const_cast(aMessage); + + // signal the creator thread (waking the Active Object) + TRequestStatus* statusPtr = &iStatus; + iCreatorThread.RequestComplete(statusPtr, KErrNone); + + // wait for creator thread to signal back + + iSemaphore.Wait(); + iMutex.Signal(); + } + } + +void CThreadedLogger::RunL() + { + if(iStatus.Int() == KErrCancel) + { + return; + } + iRealLogger.Log(iFile, iLine, iSeverity, *iMessage); + iFile = NULL; + iLine = 0; + iSeverity = (TOmxScriptSeverity) 0; + iMessage = NULL; + iStatus = KRequestPending; + SetActive(); + iSemaphore.Signal(); // signal the requestor thread + } + +void CThreadedLogger::DoCancel() + { + TRequestStatus* statusPtr = &iStatus; + User::RequestComplete(statusPtr, KErrCancel); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/threadedlogger.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/threadedlogger.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,59 @@ +/* +* Copyright (c) 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: +* +*/ + +#ifndef THREADEDLOGGER_H_ +#define THREADEDLOGGER_H_ + +#include "omx_xml_script.h" + +/** + * Adapter class that serializes all Log() calls on the underlying logger into the same thread. + * That is, a call to Log() from a thread that did not create this AO will block until the AO has + * completed the log in the AS thread. + * + * This class is provided to allow the use of loggers that would otherwise KERN-EXEC 0 panic if + * used by multiple threads. + */ +class CThreadedLogger : public CActive, public MOmxScriptTestLogger + { +public: + static CThreadedLogger* NewLC(MOmxScriptTestLogger& aRealLogger); + ~CThreadedLogger(); + + void Log(const TText8* aFile, TInt aLine, TOmxScriptSeverity aSeverity, const TDes& aMessage); + +private: + CThreadedLogger(MOmxScriptTestLogger& aRealLogger); + void ConstructL(); + + void RunL(); + void DoCancel(); + +private: + MOmxScriptTestLogger& iRealLogger; + RThread iCreatorThread; + RMutex iMutex; + RSemaphore iSemaphore; + TThreadId iCreatorThreadId; + + TText8* iFile; + TInt iLine; + TOmxScriptSeverity iSeverity; + TDes* iMessage; + }; + +#endif /* THREADEDLOGGER_H_ */ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/transition.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/transition.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,94 @@ +/* +* Copyright (c) 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 "transition.h" +#include + +void CloseSupplierRelations(TAny* aPtr) + { + RSupplierRelations& links = *reinterpret_cast(aPtr); + for(TInt i = 0, count = links.Count(); i < count; i++) + { + links[i].Close(); + } + links.Close(); + } + +/** + * Finds a transition order in which no component is transitioned until all components it suppliers to have been transitioned. + * If no such order exists (this happens if and only if a cyclic buffer supply chain exists in the graph), this method leaves + * with KErrNotFound. + * + * The result of this algorithm is appropriate for transitioning components from the Loaded state to the Idle state without incurring + * errors calling OMX_UseBuffer. For transitions Executing->Idle and Executing->Paused, the reverse order can be used. + * + * @leave KErrNoMemory + * @leave KErrNotFound iff a transition order for the graph does not exist + * @leave KErrArgument if aOrder passed in is not empty + */ +void FindTransitionOrderL(const RSupplierRelations& aSupplierRelations, RArray& aOrder) + { + if(aOrder.Count() > 0) + { + User::Leave(KErrArgument); + } + + TInt numComponents = aSupplierRelations.Count(); + TInt numPendingComponents = numComponents; + RArray pendingComponents; + CleanupClosePushL(pendingComponents); + for(TInt i = 0; i < numComponents; i++) + { + pendingComponents.AppendL(ETrue); + } + + while(numPendingComponents > 0) + { + TInt nextComponent = KErrNotFound; + for(TInt i = 0; i < numComponents && nextComponent == KErrNotFound; i++) + { + // try each component not yet transitioned + if(pendingComponents[i]) + { + // have all this component's non-supplier peers been transitioned? + nextComponent = i; + for(TInt j = 0, numSupplied = aSupplierRelations[i].Count(); j < numSupplied && nextComponent != KErrNotFound; j++) + { + if(pendingComponents[aSupplierRelations[i][j]]) + { + // no, this component can't transition yet + nextComponent = KErrNotFound; + } + } + } + } + // couldn't find a component to transition? so no solution + if(nextComponent == KErrNotFound) + { + aOrder.Reset(); + User::Leave(KErrNotFound); + } + + // this component can transition + aOrder.AppendL(nextComponent); + pendingComponents[nextComponent] = EFalse; + numPendingComponents--; + } + + CleanupStack::PopAndDestroy(&pendingComponents); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/transition.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/transition.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,51 @@ +/* +* Copyright (c) 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: +* +*/ + + +#ifndef TRANSITION_H_ +#define TRANSITION_H_ + +#include + +/** RSupplierRelations represents the buffer supplier links in a graph */ +typedef RArray > RSupplierRelations; + +void CloseSupplierRelations(TAny* aPtr); + +/* + +For example, consider the following graph: (<-- indicates direction of buffer supply) + + | 0 | <-- 1 <-- 2 + | 0 | --> 3 <-- 4 --> 5 + + The supplier relations table is: + + 0: 3 + 1: 0 + 2: 1 + 3: + 4: 3, 5 + 5: + + A valid transition order for this graph is { 3, 0, 1, 2, 5, 4 } + +*/ + +void FindTransitionOrderL(const RSupplierRelations& aSupplierRelations, RArray& aOrder); + +#endif /*TRANSITION_H_*/ diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobufferhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobufferhandler.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,156 @@ +/* +* Copyright (c) 2008 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 +#include "videobufferhandler.h" +#include + +const TInt KDefaultTimeInterval = 100000; + +CVideoBufferHandler* CVideoBufferHandler::NewL( + TDesC& aFilename, + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, + const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, + OMX_PARAM_PORTDEFINITIONTYPE& portDef) + { + CVideoBufferHandler* handler = new (ELeave) CVideoBufferHandler(aFilename); + CleanupStack::PushL(handler); + handler->ConstructL(aChunkDataMsg, aBufferSize, portDef); + CleanupStack::Pop(handler); + + return handler; + } + +CVideoBufferHandler::~CVideoBufferHandler() + { + iReceiveBuffer.Close(); + iSendBuffer.Close(); + iBufferChunk.Close(); + iFileSource.Close(); + iFs.Close(); + } + +void CVideoBufferHandler::DoCancel() + { + iReceiveBuffer.CancelDataAvailable(); + } + +CVideoBufferHandler::CVideoBufferHandler(TDesC& aFilename): + CActive(EPriorityStandard), + iReadDes(NULL, 0, 0), + iFirstBuffer(ETrue) + { + CActiveScheduler::Add(this); + iFileName.Append(aFilename); + } + +void CVideoBufferHandler::ChangeFilledBufferLength(TInt aLength) + { + if (!iChangeFileBufferLength) + { + iChangeFileBufferLength = ETrue; + } + iFileBufferLengthTestValue = aLength; + } + + +void CVideoBufferHandler::SetSendInvalidBufferId(TInt aSendInvalidBufferId) + { + iSendInvalidBufferId = aSendInvalidBufferId; + } + +void CVideoBufferHandler::RunL() + { + // Timer has expired check for new messages... + TFilledBufferHeaderV2 header; + User::LeaveIfError(iReceiveBuffer.Receive(header)); + TUint8* chunkBase = iBufferChunk.Base(); + + TUint8* bufBase = chunkBase + header.iOffset; + + iReadDes.Set(bufBase, 0, iBufConfig.iBufferSizeInBytes); + iFileSource.Read(iReadDes); + + if (iChangeFileBufferLength) + { + // this is negative test case. COmxILCallbackManager::BufferDoneNotification() will panic + header.iFilledLength = iFileBufferLengthTestValue; + } + else + { + header.iFilledLength = iReadDes.Length(); + } + + iTimeStamp += KDefaultTimeInterval; + header.iTimeStamp = iTimeStamp; + + if (iReadDes.Length() != 0) + { + // there is more to read from file source, request for more buffer + header.iFlags = iFirstBuffer ? OMX_BUFFERFLAG_STARTTIME : 0; + iReceiveBuffer.NotifyDataAvailable(iStatus); + SetActive(); + } + else + { + header.iFlags = OMX_BUFFERFLAG_EOS; + } + + if (iSendInvalidBufferId) + { + header.iOffset=KMaxTUint32; + User::LeaveIfError(iSendBuffer.Send(header)); + iSendInvalidBufferId = 0; + } + else + User::LeaveIfError(iSendBuffer.Send(header)); + } + +void CVideoBufferHandler::ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef) + + { + iBufferChunk.SetHandle(aChunkDataMsg.nChunk); + User::LeaveIfError(iBufferChunk.Duplicate(RThread())); + + iReceiveBuffer.SetHandle(aChunkDataMsg.nAvailableBufferQueue ); + User::LeaveIfError(iReceiveBuffer.Duplicate(RThread())); + + iSendBuffer.SetHandle(aChunkDataMsg.nFilledBufferQueue); + User::LeaveIfError(iSendBuffer.Duplicate(RThread())); + + if (portDef.nBufferCountActual <= 0 || portDef.nBufferSize <= 0) + { + User::Leave(KErrArgument); + } + + iBufConfig.iNumBuffers = portDef.nBufferCountActual; + iBufConfig.iBufferSizeInBytes = aBufferSize.nBufferSize; + + // Open datafile + User::LeaveIfError(iFs.Connect()); + User::LeaveIfError(iFileSource.Open(iFs, iFileName, EFileShareExclusive|EFileRead)); + } + +void CVideoBufferHandler::Start() + { + // Start streaming + iFirstBuffer = ETrue; + iReceiveBuffer.NotifyDataAvailable(iStatus); + iTimeStamp = KDefaultTimeInterval; + SetActive(); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobufferhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobufferhandler.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,68 @@ +/* +* 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: +* +*/ + + + +#ifndef VIDEOBUFFERHANDLER_H +#define VIDEOBUFFERHANDLER_H + +#include +#include +#include +#include +#include +#include + +NONSHARABLE_CLASS(CVideoBufferHandler) : public CActive + { +public: + virtual ~CVideoBufferHandler(); + static CVideoBufferHandler* NewL(TDesC& aFilename, OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + +public: + void Start(); + void ChangeFilledBufferLength(TInt aLength); + void SetSendInvalidBufferId(TInt aSendInvalidBufferId); + +protected: + CVideoBufferHandler(TDesC& aFilename); + +private: + void ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + + // From CActive + void RunL(); + void DoCancel(); + +protected: + RMsgQueue iReceiveBuffer; + RMsgQueue iSendBuffer; + TMMSharedChunkBufConfig iBufConfig; + TPtr8 iReadDes; + + RChunk iBufferChunk; + TBuf iFileName; + RFile iFileSource; + RFs iFs; + TBool iFirstBuffer; + TBool iChangeFileBufferLength; + TInt iFileBufferLengthTestValue; + TInt iSendInvalidBufferId; + TInt iTimeStamp; + }; + +#endif // VIDEOBUFFERHANDLER_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobufferhandler_mpeg4.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobufferhandler_mpeg4.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,151 @@ +/* +* Copyright (c) 2008 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 +#include "videobufferhandler_mpeg4.h" +#include +#include + + +CVideoBufferHandlerMPEG4* CVideoBufferHandlerMPEG4::NewL( + TDesC& aFilename, + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, + const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, + OMX_PARAM_PORTDEFINITIONTYPE& portDef) + { + CVideoBufferHandlerMPEG4* handler = new (ELeave) CVideoBufferHandlerMPEG4(aFilename); + CleanupStack::PushL(handler); + handler->ConstructL(aChunkDataMsg, aBufferSize, portDef); + CleanupStack::Pop(handler); + + return handler; + } + +CVideoBufferHandlerMPEG4::~CVideoBufferHandlerMPEG4() + { + delete iFrameSupplier; + } + +CVideoBufferHandlerMPEG4::CVideoBufferHandlerMPEG4(TDesC& aFilename): + CVideoBufferHandler(aFilename) + { + } + +void CVideoBufferHandlerMPEG4::RunL() + { + // Timer has expired check for new messages... + TFilledBufferHeaderV2 header; + + User::LeaveIfError(iReceiveBuffer.Receive(header)); + TUint8* chunkBase = iBufferChunk.Base(); + //__ASSERT_ALWAYS(message < iBufConfig.iNumBuffers, User::Invariant()); + + TUint8* bufBase = chunkBase + header.iOffset; + + TInt frameLength = 0; + TInt err = iFrameSupplier->NextFrameData(bufBase, frameLength); + if (err != KErrNone) + { + User::Leave(err); + } + + if (iChangeFileBufferLength) + { + // this is negative test case. COmxILCallbackManager::BufferDoneNotification() will panic + header.iFilledLength = iFileBufferLengthTestValue; + } + else + { + header.iFilledLength = frameLength; + } + + if (!iFrameSupplier->IsLastFrame()) + { + // there is more to read from file source, request for more buffer + header.iTimeStamp = 0; + header.iFlags = (iFrameSupplier->CurrentFrame() == 0 ? OMX_BUFFERFLAG_STARTTIME : 0); + iReceiveBuffer.NotifyDataAvailable(iStatus); + SetActive(); + } + else + { + header.iFlags = OMX_BUFFERFLAG_EOS; + } + + if (iSendInvalidBufferId) + { + User::LeaveIfError(iSendBuffer.Send(header)); + iSendInvalidBufferId = 0; + } + else + { + User::LeaveIfError(iSendBuffer.Send(header)); + } + } + + +void CVideoBufferHandlerMPEG4::ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef) + { + RThread chunkOwnerThread; + + TInt error = chunkOwnerThread.Open(TThreadId(aChunkDataMsg.nThreadId)); + iBufferChunk.SetHandle(aChunkDataMsg.nChunk); + User::LeaveIfError(iBufferChunk.Duplicate(chunkOwnerThread)); + + iReceiveBuffer.SetHandle(aChunkDataMsg.nAvailableBufferQueue); + User::LeaveIfError(iReceiveBuffer.Duplicate(RThread())); + + iSendBuffer.SetHandle(aChunkDataMsg.nFilledBufferQueue); + User::LeaveIfError(iSendBuffer.Duplicate(RThread())); + + if ((portDef.nBufferCountActual <= 0) || (portDef.nBufferSize <= 0)) + { + User::Leave(KErrArgument); + } + + iFrameSupplier = CVideoFrameSupplier::NewL(iFileName, CVideoFrameSupplier::EVideoFileTypeMPEG4); + + iBufConfig.iNumBuffers = portDef.nBufferCountActual; + iBufConfig.iBufferSizeInBytes = aBufferSize.nBufferSize; + } + + +void CVideoBufferHandlerMPEG4::SetChunkDetailAndOpenL(TInt aChunkHandleId, TUint64 aThreadId) + { + RThread chunkOwnerThread; + + TInt err = chunkOwnerThread.Open(TThreadId(aThreadId)); + if (err != KErrNone) + { + User::LeaveIfError(err); + } + + CleanupClosePushL(chunkOwnerThread); + + iBufferChunk.SetHandle(aChunkHandleId); + err = iBufferChunk.Duplicate(chunkOwnerThread); + if (err != KErrNone) + { + User::LeaveIfError(err); + } + + CleanupStack::PopAndDestroy(&chunkOwnerThread); + } + + + diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobufferhandler_mpeg4.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobufferhandler_mpeg4.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,64 @@ +/* +* 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: +* +*/ + + + +#ifndef VIDEOBUFFERHANDLERMPEG4_H +#define VIDEOBUFFERHANDLERMPEG4_H + +#include +#include +#include +#include +#include +#include +#include +#include "videobufferhandler.h" + +const TInt KVideoBufferLength=102400; + +typedef struct + { + // Maybe these should be 64-bit variables for large video files. + TInt iPosition; + TInt iLength; + } +TFrameLocation; + +NONSHARABLE_CLASS(CVideoBufferHandlerMPEG4) : public CVideoBufferHandler + { +public: + + ~CVideoBufferHandlerMPEG4(); + static CVideoBufferHandlerMPEG4* NewL(TDesC& aFilename, OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + +private: + CVideoBufferHandlerMPEG4(TDesC& aFilename); + void ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + + void SetChunkDetailAndOpenL(TInt aChunkHandleId, TUint64 aThreadId); + + // From CActive + void RunL(); + +private: + CVideoFrameSupplier* iFrameSupplier; + + + }; + +#endif // VIDEOBUFFERHANDLERMPEG4_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobuffersinkhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobuffersinkhandler.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,116 @@ +/* +* Copyright (c) 2008 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 +#include "videobuffersinkhandler.h" +#include + +CVideoBufferSinkHandler* CVideoBufferSinkHandler::NewL( + TDesC& aFilename, + OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, + const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, + OMX_PARAM_PORTDEFINITIONTYPE& portDef) + { + CVideoBufferSinkHandler* handler = new (ELeave) CVideoBufferSinkHandler(aFilename); + CleanupStack::PushL(handler); + handler->ConstructL(aChunkDataMsg, aBufferSize, portDef); + CleanupStack::Pop(handler); + + return handler; + } + +CVideoBufferSinkHandler::~CVideoBufferSinkHandler() + { + iReceiveBuffer.Close(); + iSendBuffer.Close(); + iBufferChunk.Close(); + iFileSink.Close(); + iFs.Close(); + } + +CVideoBufferSinkHandler::CVideoBufferSinkHandler(TDesC& aFilename): + CActive(EPriorityStandard), + iWriteDes(NULL, 0, 0) + { + CActiveScheduler::Add(this); + iFileName.Append(aFilename); + } + +void CVideoBufferSinkHandler::ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef) + { + iBufferChunk.SetHandle(aChunkDataMsg.nChunk); + User::LeaveIfError(iBufferChunk.Duplicate(RThread())); + + iReceiveBuffer.SetHandle(aChunkDataMsg.nFilledBufferQueue ); + User::LeaveIfError(iReceiveBuffer.Duplicate(RThread())); + + iSendBuffer.SetHandle(aChunkDataMsg.nAvailableBufferQueue); + User::LeaveIfError(iSendBuffer.Duplicate(RThread())); + + if (portDef.nBufferCountActual <= 0 || portDef.nBufferSize <= 0) + { + User::Leave(KErrArgument); + } + + iBufConfig.iNumBuffers = portDef.nBufferCountActual; + iBufConfig.iBufferSizeInBytes = aBufferSize.nBufferSize; + + // Open datafile + User::LeaveIfError(iFs.Connect()); + User::LeaveIfError(iFileSink.Replace(iFs, iFileName, EFileShareExclusive|EFileWrite)); + } + +void CVideoBufferSinkHandler::Start() + { + // Start streaming + iReceiveBuffer.NotifyDataAvailable(iStatus); + SetActive(); + } + +void CVideoBufferSinkHandler::RunL() + { + TFilledBufferHeaderV2 header; + User::LeaveIfError(iReceiveBuffer.Receive(header)); + + TUint8* chunkBase = iBufferChunk.Base(); + + TUint8* bufBase = chunkBase + header.iOffset; + + iWriteDes.Set(bufBase, header.iFilledLength, iBufConfig.iBufferSizeInBytes); + + __ASSERT_ALWAYS(header.iFilledLength <= iWriteDes.Length(), User::Invariant()); + + iFileSink.Write(iWriteDes); + + if (header.iFlags != OMX_BUFFERFLAG_EOS) + { + // there is no more to read from file source, request for more buffer + iReceiveBuffer.NotifyDataAvailable(iStatus); + SetActive(); + } + + User::LeaveIfError(iSendBuffer.Send(header)); + } + +void CVideoBufferSinkHandler::DoCancel() + { + iReceiveBuffer.CancelDataAvailable(); + } + + + diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videobuffersinkhandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videobuffersinkhandler.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,61 @@ +/* +* 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: +* +*/ + + + +#ifndef VIDEOBUFFERSINKHANDLER_H +#define VIDEOBUFFERSINKHANDLER_H + +#include +#include +#include +#include +#include +#include + +NONSHARABLE_CLASS(CVideoBufferSinkHandler) : public CActive + { +public: + ~CVideoBufferSinkHandler(); + static CVideoBufferSinkHandler* NewL(TDesC& aFilename, OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + + +public: + void Start(); + +private: + CVideoBufferSinkHandler(TDesC& aFilename); + void ConstructL(OMX_SYMBIAN_PARAM_3PLANE_CHUNK_DATA& aChunkDataMsg, const OMX_SYMBIAN_PARAM_BUFFER_SIZE& aBufferSize, OMX_PARAM_PORTDEFINITIONTYPE& portDef); + + // From CActive + void RunL(); + void DoCancel(); + +private: + RMsgQueue iReceiveBuffer; + RMsgQueue iSendBuffer; + TMMSharedChunkBufConfig iBufConfig; + TPtr8 iWriteDes; + + + RChunk iBufferChunk; + TBuf iFileName; + RFile iFileSink; + RFs iFs; + }; + +#endif // VIDEOBUFFERSINKHANDLER_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videotesttimer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videotesttimer.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,56 @@ +/* +* Copyright (c) 2008 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 "videotesttimer.h" + + +CVideoTestTimer::CVideoTestTimer(MTimerObserver& aTimerObserver) +: CTimer(EPriorityHigh), iTimerObserver(aTimerObserver) + { + CActiveScheduler::Add(this); + } + +CVideoTestTimer* CVideoTestTimer::NewL(MTimerObserver& aTimerObserver) + { + CVideoTestTimer* self = new (ELeave) CVideoTestTimer(aTimerObserver); + CleanupStack::PushL(self); + self->ConstructL(); // this call CTimer::ConstructL + CleanupStack::Pop(self); + return self; + } + +CVideoTestTimer::~CVideoTestTimer() + { + // cancel is called by CTimer destructor + } + +/** Start the timer */ +void CVideoTestTimer::Start(TTimeIntervalMicroSeconds32 aDelay) + { + HighRes(aDelay); + } + +/** Handle completion */ +void CVideoTestTimer::RunL() + { + if (iStatus == KErrNone) + { + iTimerObserver.TimerExpired(); + } + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/videotesttimer.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/videotesttimer.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,49 @@ +/* +* 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: +* +*/ + + + +#ifndef VIDEOTESTTIMER_H +#define VIDEOTESTTIMER_H + +#include + + + + +class MTimerObserver + { +public: + virtual void TimerExpired() = 0; + }; + +NONSHARABLE_CLASS(CVideoTestTimer) : public CTimer + { +public: + ~CVideoTestTimer(); + static CVideoTestTimer* NewL(MTimerObserver& aTimerObserver); + void Start(TTimeIntervalMicroSeconds32 aDelay); + +private: + CVideoTestTimer(MTimerObserver& aTimerObserver); + void RunL(); + +private: + MTimerObserver& iTimerObserver; + }; + +#endif // VIDEOTESTTIMER_H diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/windowmanager.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/windowmanager.cpp Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,181 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#include "windowmanager.h" + +CWindowManager* CWindowManager::NewL() + { + CWindowManager* self = new(ELeave) CWindowManager(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CWindowManager::CWindowManager(): +CActive(EPriorityStandard) + { + CActiveScheduler::Add(this); + } + +void CWindowManager::ConstructL() + { + User::LeaveIfError(iMsgQueue.CreateLocal(1)); + User::LeaveIfError(iSemaphore.CreateLocal(0)); + + User::LeaveIfError(iWsSession.Connect()); + // Create the Screen device for the WServ session. + iWsSd = new (ELeave) CWsScreenDevice(iWsSession); + User::LeaveIfError(iWsSd->Construct()); + // Create a Window Group. + iWindowGroup = RWindowGroup(iWsSession); + User::LeaveIfError(iWindowGroup.Construct((TUint32)this, ETrue)); + iWindow = new (ELeave) RWindow(iWsSession); + User::LeaveIfError(iWindow->Construct(iWindowGroup, ((TUint32)(this)) + 1)); + + // Reset the screen mode. + if(iWsSd->CurrentScreenMode() != 0) + { + iWsSd->SetAppScreenMode(0); + iWsSd->SetScreenMode(0); + } + + iScreenSize = iWsSd->SizeInPixels(); + iWindow->SetExtent(TPoint(0,0), iScreenSize); + iWindow->SetVisible(ETrue); + iWindow->Activate(); + + User::LeaveIfError(iWindow->SetRequiredDisplayMode(EColor16MA)); + + // TODO - this forcing of transparency may not be needed, as there is + // a defect in the graphics component right now + // force the transparency change to take place + iWindow->SetBackgroundColor(TRgb(0x000000, 0)); + iWindow->BeginRedraw(); + iWindow->EndRedraw(); + iWsSession.Flush(); + + iCreatorThreadId = RThread().Id(); + + SetActive(); + iMsgQueue.NotifyDataAvailable(iStatus); + } + +CWindowManager::~CWindowManager() + { + Cancel(); + if(iWindow) + { + iWindow->Close(); + delete iWindow; + } + iWindowGroup.Close(); + delete iWsSd; + iWsSession.Close(); + + iSemaphore.Close(); + iMsgQueue.Close(); + } + +void CWindowManager::RunL() + { + TMessage msg; + TInt err = iMsgQueue.Receive(msg); + if(err != KErrNone && err != KErrUnderflow) + { + iReturnCode = err; + } + else + { + iReturnCode = DoCommand(msg.iCommand, msg.iParam1, msg.iParam2); + } + SetActive(); + iMsgQueue.NotifyDataAvailable(iStatus); + iSemaphore.Signal(); + } + +void CWindowManager::DoCancel() + { + iMsgQueue.CancelDataAvailable(); + } + +TInt CWindowManager::RegisterSurface(TSurfaceId& aSurfaceId) + { + return RunCommand(ERegisterSurface, &aSurfaceId); + } + +TInt CWindowManager::SetBackgroundSurface(TSurfaceConfiguration& aSurfaceConfig, TBool aTriggerRedraw) + { + return RunCommand(ESetBackgroundSurface, &aSurfaceConfig, aTriggerRedraw); + } + +TInt CWindowManager::RunCommand(TCommand aCommand, TAny* aParam1, TInt aParam2) + { + if(RThread().Id() == iCreatorThreadId) + { + return DoCommand(aCommand, aParam1, aParam2); + } + else + { + TMessage msg; + msg.iCommand = aCommand; + msg.iParam1 = aParam1; + msg.iParam2 = aParam2; + iMsgQueue.SendBlocking(msg); + iSemaphore.Wait(); + return iReturnCode; + } + } + +TInt CWindowManager::DoCommand(TCommand aCommand, TAny* aParam1, TInt aParam2) + { + switch(aCommand) + { + case ERegisterSurface: + { + TSurfaceId& surfaceId = *reinterpret_cast(aParam1); + return iWsSession.RegisterSurface(iWsSd->GetScreenNumber(), surfaceId); + } + case ESetBackgroundSurface: + { + TSurfaceConfiguration& surfaceConfig = *reinterpret_cast(aParam1); + TBool triggerRedraw = aParam2; + return iWindow->SetBackgroundSurface(surfaceConfig, triggerRedraw); + } + default: + { + User::Invariant(); + return KErrNone; + } + } + } + +TSize CWindowManager::ScreenSize() const + { + return iScreenSize; + } + +void CWindowManager::Flush() + { + iWsSession.Flush(); + } diff -r 000000000000 -r 0e4a32b9112d tsrc/xmltestharness/xmlclient/src/windowmanager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tsrc/xmltestharness/xmlclient/src/windowmanager.h Wed Aug 25 12:40:50 2010 +0300 @@ -0,0 +1,83 @@ +/* +* Copyright (c) 2008 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: +* +*/ + + +/** +@file +@internalComponent +*/ + +#ifndef WINDOWMANAGER_H_ +#define WINDOWMANAGER_H_ + +#include +#include + +/** + * Encapsulates the resources used to provide a window to render to via Graphic Surfaces. + * Proxies certain methods so that they can be used by arbitary threads. + */ +class CWindowManager : public CActive + { +private: + enum TCommand + { + ERegisterSurface, + ESetBackgroundSurface + }; + + struct TMessage + { + TCommand iCommand; + TAny* iParam1; + TInt iParam2; + }; + +public: + static CWindowManager* NewL(); + ~CWindowManager(); + + TSize ScreenSize() const; + + TInt RegisterSurface(TSurfaceId& aSurfaceId); + TInt SetBackgroundSurface(TSurfaceConfiguration& aSurfaceConfig, TBool aTriggerRedraw); + void Flush(); + +private: + CWindowManager(); + void ConstructL(); + + void RunL(); + void DoCancel(); + + TInt RunCommand(TCommand aCommand, TAny* aParam1, TInt aParam2 = 0); + TInt DoCommand(TCommand aCommand, TAny* aParam1, TInt aParam2); + +private: + RMsgQueue iMsgQueue; + RSemaphore iSemaphore; + TInt iReturnCode; + TThreadId iCreatorThreadId; + + RWsSession iWsSession; + CWsScreenDevice* iWsSd; // Screen Device for this WServ session. + RWindowGroup iWindowGroup; // Window group of the AO windows. + RWindow* iWindow; + TSize iScreenSize; + }; + +#endif /* WINDOWMANAGER_H_ */