--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayOne.cpp	Thu Oct 07 22:34:12 2010 +0100
@@ -0,0 +1,2133 @@
+
+// Copyright (c) 2003-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:
+// TestDevVideoPlay.cpp
+// 
+//
+
+#include "TestDevVideoPlay.h"
+#include "TestDevVideoPlayTestData.h"
+#include "TestDevVideoPlugins/decoder.h"
+#include "TestDevVideoPlugins/postproc.h"
+#include <e32math.h>
+
+const TInt KTestScreenCount = 2;
+// DevVideoPlay base class
+
+const TUid KUidMDFVideoDecoderHwDeviceAdapter = { 0x102737ED };
+
+CTestDevVideoPlayStep::CTestDevVideoPlayStep(const TDesC& aTestName, TTestType aTestType)
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	// Each test step initialises it's own name
+	iTestStepName = aTestName;		
+	iTestType = aTestType;		// included in case needed in future
+	}
+	
+CTestDevVideoPlayStep::~CTestDevVideoPlayStep() 
+	{
+	delete iDevVideoPlay;
+	}
+
+TVerdict CTestDevVideoPlayStep::DoTestStepL()
+	{
+	// construct DevVideoPlay object
+	__UHEAP_MARK;
+	TRAPD(err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Could not create a CMMFDevVideoPlay class!"));
+		return EInconclusive;
+		}
+	
+	TVerdict ret = EFail;
+
+	// call the test step
+	ret = DoTestL(*iDevVideoPlay);
+		
+	INFO_PRINTF1(_L("CMMFDevVideoPlay: Destroying"));
+	delete iDevVideoPlay;
+	iDevVideoPlay = NULL;
+	__MM_HEAP_MARKEND;
+	if(iError != KErrNone)
+		ERR_PRINTF2( _L("CMMFDevVideoPlay failed with error %d"), iError );
+	
+	return ret;
+	}
+
+
+// MMMFDevVideoPlayObserver
+void CTestDevVideoPlayStep::MdvpoNewBuffers()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewBuffers()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoReturnPicture(TVideoPicture* /*aPicture*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReturnPicture()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoSupplementalInformation(const TDesC8& /*aData*/, 
+								  const TTimeIntervalMicroSeconds& /*aTimestamp*/, 
+								  const TPictureId& /*aPictureId*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSupplementalInformation()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoPictureLoss()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoPictureLoss(const TArray<TPictureId>& /*aPictures*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss(TArray)"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSliceLoss()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoReferencePictureSelection(const TDesC8& /*aSelectionData*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReferencePictureSelection()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete(TInt /*aError*/, 
+								TPictureData* /*aPictureData*/, 
+								const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, 
+								const TPictureId& /*aPictureId*/)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoNewPictures()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewPictures()"));
+	}
+
+void CTestDevVideoPlayStep::MdvpoFatalError(TInt aError)
+	{
+	iError = aError;
+	INFO_PRINTF2(_L("CTestDevVideoPlayStep::MdvpoFatalError():  Error = %d"), aError);
+	}
+
+void CTestDevVideoPlayStep::MdvpoInitComplete(TInt aError)
+	{
+	iError = aError;
+	INFO_PRINTF2(_L("CTestDevVideoPlayStep::MdvpoInitComplete():  Error = %d"), aError);
+	}
+
+void CTestDevVideoPlayStep::MdvpoStreamEnd()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoStreamEnd()"));
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayCommonFormat::CTestDevVideoPlayCommonFormat(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayCommonFormat* CTestDevVideoPlayCommonFormat::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayCommonFormat* self = new(ELeave) CTestDevVideoPlayCommonFormat(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayCommonFormat::DoTestL(CMMFDevVideoPlay& /*aDevVideoPlay*/)
+	{
+	TVerdict ret = EPass;
+	TBool expErr = ETrue;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Find common format"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	// make a fake list of formats
+	RArray<TUncompressedVideoFormat> vFormats1;
+	RArray<TUncompressedVideoFormat> vFormats2;
+
+	TUncompressedVideoFormat commonFormat;
+	TUncompressedVideoFormat otherFormat;
+
+	// push arrays to cleanup stack
+	CleanupClosePushL(vFormats1);
+	CleanupClosePushL(vFormats2);
+
+	// setup vFormats1 
+	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));
+	User::LeaveIfError(vFormats1.Append(KTestVidFormat2));
+
+	// setup vFormats2
+	User::LeaveIfError(vFormats2.Append(KTestVidFormat2));
+	User::LeaveIfError(vFormats2.Append(KTestVidFormat3));
+
+	TArray<TUncompressedVideoFormat> t1 = vFormats1.Array();
+	TArray<TUncompressedVideoFormat> t2 = vFormats2.Array();
+	TBool formatFound = EFalse;
+		
+	// attempt to find a common format
+	formatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, commonFormat);
+
+	// now attempt to find a common format that doesn't exist
+	vFormats1.Reset();
+	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));
+	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));
+	TBool otherFormatFound = ETrue;
+
+	// perform search for non-existent common format
+	t1 = vFormats1.Array();	// need to get Array class again
+	otherFormatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, otherFormat);
+
+	// close the arrays
+	CleanupStack::PopAndDestroy(2, &vFormats1);
+
+	// check format
+	if ( (!formatFound) || !(commonFormat == KTestVidFormat2) )
+		{
+		ret = EFail;
+		ERR_PRINTF1(_L("Error:  No common format found..."));
+		}
+	else if (otherFormatFound )
+		{
+		ret = EFail;
+		ERR_PRINTF1(_L("Error:  Found a common format when there wasn't one!"));
+		}
+	else
+		{
+		INFO_PRINTF3(_L("FindCommonFormat(), %d = %d"), formatFound, expErr);
+		}
+	return ret;
+	}
+
+
+//------------------------------------------------------------------
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayFindDecoders::CTestDevVideoPlayFindDecoders(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayFindDecoders* CTestDevVideoPlayFindDecoders::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayFindDecoders* self = new(ELeave) CTestDevVideoPlayFindDecoders(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayFindDecoders::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EFail;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  FindDecoders"));
+
+	RArray<TUid> foundDecoders;
+	CleanupClosePushL(foundDecoders);
+	RArray<TUid> expectedDecoders;
+	CleanupClosePushL(expectedDecoders);
+	RArray<TUid> unExpectedDecoders;
+	CleanupClosePushL(unExpectedDecoders);
+
+	TInt error = KErrNone;
+	TUint32 requestedPostProcType = 0;
+	
+	// Unsupported mime type
+	if (!error)
+		{
+		requestedPostProcType = 0;
+		_LIT8(KMimeType1, "VIDEO/mpeg21");
+		foundDecoders.Reset();
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType1(), requestedPostProcType, foundDecoders, EFalse));
+
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+		}
+
+	// Unsupported post proc type
+	if (!error)
+		{
+		requestedPostProcType = EPpOutputCrop|EPpInputCrop;
+		foundDecoders.Reset();
+		_LIT8(KMimeType2, "videO/duMMy");
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType2(), requestedPostProcType, foundDecoders, EFalse));
+		if (error == KErrNotFound)//we actually expect KErrNotFound here
+			error = KErrNone;
+		else
+			error = KErrGeneral;
+
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+		}
+
+	// Unsupported mime type (by exact match)
+	if (!error)
+		{
+		_LIT8(KMimeType3, "video/H263-2000; profile=45;level=40");
+		requestedPostProcType = 0;
+		foundDecoders.Reset();
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType3(), requestedPostProcType, foundDecoders, ETrue));
+		if (error == KErrNotFound)//we actually expect KErrNotFound here
+			error = KErrNone;
+		else
+			error = KErrGeneral;
+
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+		}
+	
+	// Supported mime type (by unexact match)
+	if (!error)
+		{
+		_LIT8(KMimeType4, "video/H263-2000; profile=1234;level=20");
+		requestedPostProcType = 0;
+		foundDecoders.Reset();
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType4(), requestedPostProcType, foundDecoders, EFalse));
+
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+		}
+	
+	// Supported mime type and post proc type (by exact match)
+	if (!error)
+		{
+		_LIT8(KMimeType5, "video/zippyvideo");
+		requestedPostProcType = EPpMirror|EPpInputCrop;
+		foundDecoders.Reset();
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType5(), requestedPostProcType, foundDecoders, ETrue));
+
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+		}
+	
+	//Added to check that the mimetype comparison is not case sensitive
+	if (!error)
+		{
+		_LIT8(KMimeType6, "VIDEO/ZIPPYvideo");
+		requestedPostProcType = EPpMirror|EPpInputCrop;
+		foundDecoders.Reset();
+		expectedDecoders.Reset();
+		unExpectedDecoders.Reset();
+		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+		INFO_PRINTF1(_L("To check that the mime type comparison is not case sensitive"));
+		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType6(), requestedPostProcType, foundDecoders, ETrue));
+		INFO_PRINTF2(_L("error = %d"),error);
+		if (!error)
+			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);
+	
+		}
+
+	CleanupStack::PopAndDestroy(3); //foundDecoders, expectedDecoders, unExpectedDecoders
+
+	if (!error)
+		ret = EPass;
+		
+	return ret;
+	}
+
+TInt CTestDevVideoPlayFindDecoders::CheckDecoders(const RArray<TUid>& aFoundDecoders, 
+												  const RArray<TUid>& aExpectedDecoders, 
+												  const RArray<TUid>& aUnExpectedDecoders)
+	{
+	TInt ret = KErrGeneral;
+
+	TBool foundUnExpected = EFalse;
+	TInt numberToBeFoundInExpectedDecoders = aExpectedDecoders.Count();
+
+	for (TInt i=0; i<aFoundDecoders.Count(); i++)
+		{
+		TUid uidToLookFor = aFoundDecoders[i];
+		for (TInt j=0; j<aExpectedDecoders.Count(); j++)
+			{
+			if (aExpectedDecoders[j] == uidToLookFor)
+				{
+				numberToBeFoundInExpectedDecoders--;
+				break;//j
+				}
+			}
+		for (TInt k=0; k<aUnExpectedDecoders.Count(); k++)
+			{
+			if (aUnExpectedDecoders[k] == uidToLookFor)
+				{
+				foundUnExpected = ETrue;
+				break;//k
+				}
+			}
+		}
+
+	if ((!foundUnExpected) && (numberToBeFoundInExpectedDecoders==0))
+		ret = KErrNone;
+
+	return ret;
+	}
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayFindPostProc::CTestDevVideoPlayFindPostProc(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayFindPostProc* CTestDevVideoPlayFindPostProc::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayFindPostProc* self = new(ELeave) CTestDevVideoPlayFindPostProc(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayFindPostProc::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EFail;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  FindPostProc"));
+
+	RArray<TUid> foundPostProx;
+	CleanupClosePushL(foundPostProx);
+	RArray<TUid> expectedPostProx;
+	CleanupClosePushL(expectedPostProx);
+	RArray<TUid> unExpectedPostProx;
+	CleanupClosePushL(unExpectedPostProx);
+
+	TInt error = KErrNone;
+	TUint32 requestedPostProcType = 0;	
+
+	// First ask for post processor isn't supported
+	if (!error)
+		{
+		requestedPostProcType = EPpInputCrop|EPpMirror|EPpScale|EPpOutputPad|EPpNoiseFilter;
+		foundPostProx.Reset();
+		expectedPostProx.Reset();
+		unExpectedPostProx.Reset();
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));
+		
+		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));
+		if (error == KErrNotFound)//we actually expect KErrNotFound here
+			error = KErrNone;
+		else
+			error = KErrGeneral;
+
+		if (!error)
+			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);
+		}
+
+	// Next ask for all post processors
+	if (!error)
+		{
+		requestedPostProcType = 0;
+		foundPostProx.Reset();
+		expectedPostProx.Reset();
+		unExpectedPostProx.Reset();
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));
+		if (!error)
+			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);
+		}
+
+	// Next ask for a specific subset of post processors
+	if (!error)
+		{
+		requestedPostProcType = EPpMirror;
+		foundPostProx.Reset();
+		expectedPostProx.Reset();
+		unExpectedPostProx.Reset();
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));
+		if (!error)
+			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);
+		}
+	
+	// Next ask for another specific subset of post processors
+	if (!error)
+		{
+		requestedPostProcType = EPpMirror|EPpInputCrop;
+		foundPostProx.Reset();
+		expectedPostProx.Reset();
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));
+		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));
+		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));
+
+		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));
+		if (!error)
+			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);
+		}
+
+	CleanupStack::PopAndDestroy(3);//foundPostProx, expectedPostProx, unExpectedPostProx
+	
+	if (!error)
+		ret = EPass;
+		
+	return ret;
+	}
+
+
+TInt CTestDevVideoPlayFindPostProc::CheckPostProx(const RArray<TUid>& aFoundPostProx, 
+												  const RArray<TUid>& aExpectedPostProx, 
+												  const RArray<TUid>& aUnExpectedPostProx)
+	{
+	TInt ret = KErrGeneral;
+
+	TBool foundUnExpected = EFalse;
+	TInt numberToBeFoundInExpectedPostProx = aExpectedPostProx.Count();
+
+	for (TInt i=0; i<aFoundPostProx.Count(); i++)
+		{
+		TUid uidToLookFor = aFoundPostProx[i];
+		for (TInt j=0; j<aExpectedPostProx.Count(); j++)
+			{
+			if (aExpectedPostProx[j] == uidToLookFor)
+				{
+				numberToBeFoundInExpectedPostProx--;
+				break;//j
+				}
+			}
+		for (TInt k=0; k<aUnExpectedPostProx.Count(); k++)
+			{
+			if (aUnExpectedPostProx[k] == uidToLookFor)
+				{
+				foundUnExpected = ETrue;
+				break;//k
+				}
+			}
+		}
+
+	if ((!foundUnExpected) && (numberToBeFoundInExpectedPostProx==0))
+		ret = KErrNone;
+
+	return ret;
+	}
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayListDecoders::CTestDevVideoPlayListDecoders(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayListDecoders* CTestDevVideoPlayListDecoders::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayListDecoders* self = new(ELeave) CTestDevVideoPlayListDecoders(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayListDecoders::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EFail;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ListDecoders"));
+		
+	RArray<TUid> foundDecoders;
+	CleanupClosePushL(foundDecoders);
+	RArray<TUid> expectedDecoders;
+	CleanupClosePushL(expectedDecoders);
+
+	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));
+	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));
+	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));
+	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));
+	User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));
+
+	TRAPD(err, aDevVideoPlay.GetDecoderListL(foundDecoders));
+
+	if (!err)
+		{		
+		// Make sure that the video hardware device adapter is NOT in the array
+		TBool foundAdapter = EFalse;
+		for (TInt j = 0; j < foundDecoders.Count(); j++)
+			{
+			if (foundDecoders[j] == KUidMDFVideoDecoderHwDeviceAdapter)
+				{
+				foundAdapter = ETrue;
+				break;
+				}
+			}
+
+		// Make sure that all the UIDs of the test plugins are in the array..
+		TInt numberToBeFound = expectedDecoders.Count();
+		for (TInt i=0; i<expectedDecoders.Count(); i++)
+			{
+			TUid uidToFind = expectedDecoders[i];
+			for (TInt j=0; j<foundDecoders.Count(); j++)
+				{
+				if (foundDecoders[j] == uidToFind)
+					{
+					numberToBeFound--;
+					break;//j
+					}
+				}
+			}
+		if ((numberToBeFound == 0) && (!foundAdapter))
+			{
+			ret = EPass;
+			}
+		}
+
+	CleanupStack::PopAndDestroy(2);
+	
+	return ret;
+	}
+
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayListPostProc::CTestDevVideoPlayListPostProc(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayListPostProc* CTestDevVideoPlayListPostProc::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayListPostProc* self = new(ELeave) CTestDevVideoPlayListPostProc(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayListPostProc::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EFail;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ListPostProc"));
+		
+	RArray<TUid> foundPostProx;
+	CleanupClosePushL(foundPostProx);
+	RArray<TUid> expectedPostProx;
+	CleanupClosePushL(expectedPostProx);
+
+	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));
+	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));
+	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));
+	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));
+	User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));
+
+	TRAPD(err, aDevVideoPlay.GetPostProcessorListL(foundPostProx));
+
+	if (!err)
+		{
+		// Make sure that all the UIDs of the test plugins are in the array..
+		TInt numberToBeFound = expectedPostProx.Count();
+		for (TInt i=0; i<expectedPostProx.Count(); i++)
+			{
+			TUid uidToFind = expectedPostProx[i];
+			for (TInt j=0; j<foundPostProx.Count(); j++)
+				{
+				if (foundPostProx[j] == uidToFind)
+					{
+					numberToBeFound--;
+					break;//j
+					}
+				}
+			}
+		if (numberToBeFound == 0)
+			ret = EPass;
+		}
+
+	CleanupStack::PopAndDestroy(2);
+
+	return ret;
+	}
+
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayGetDecoderInfo::CTestDevVideoPlayGetDecoderInfo(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetDecoderInfo* CTestDevVideoPlayGetDecoderInfo::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetDecoderInfo* self = new(ELeave) CTestDevVideoPlayGetDecoderInfo(aTestName, aTestType);
+	return self;
+	}
+
+TBool CTestDevVideoPlayGetDecoderInfo::ValidDecoderInfo(CVideoDecoderInfo* aInfo)
+	{
+	// do null pointer check
+	if (!aInfo) 
+		{
+		ERR_PRINTF1(_L("Error - Decoder Info is NULL!"));
+		return EFalse;
+		}
+	
+	// check the decoder against test data
+	// need to check every call so as to keep code coverage
+	// and prevent a situation where if the first test fails
+	// then subsequent tests will not be called
+	TBool ret = ETrue;
+
+	// UID check
+	if (aInfo->Uid() != KUidDevVideoTestDecodeHwDevice)
+		{
+		ERR_PRINTF1(_L("Error - Decoder UID is incorrect!"));
+		ret = EFalse;
+		}
+	// Manufacturer check
+	if (!(aInfo->Manufacturer() == KTestDecoderInfoManufacturer))
+		{
+		ERR_PRINTF1(_L("Error - Manufacturer is incorrect!"));
+		ret = EFalse;
+		}
+	// Identifier check
+	if (!(aInfo->Identifier() == KTestDecoderInfoIdentifier))
+		{
+		ERR_PRINTF1(_L("Error - Identifier is incorrect!"));
+		ret = EFalse;
+		}
+	// Version check
+	TVersion decVer = aInfo->Version();
+	if ( (decVer.iMajor != KTestDecoderInfoVersionMaj) ||
+		 (decVer.iMinor != KTestDecoderInfoVersionMin) ||
+		 (decVer.iBuild != KTestDecoderInfoVersionBuild) )
+		{
+		ERR_PRINTF1(_L("Error - Version is incorrect!"));
+		ret = EFalse;
+		}
+	// Accelerated check
+	if (!aInfo->Accelerated())
+		{
+		ERR_PRINTF1(_L("Error - Accelerated = EFalse!"));
+		ret = EFalse;
+		}
+	// Direct display check
+	if (!aInfo->SupportsDirectDisplay())
+		{
+		ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!"));
+		ret = EFalse;
+		}
+
+	// Max picture size
+	TSize maxSize = aInfo->MaxPictureSize();
+	if (maxSize.iWidth != KTestDecoderInfoMaxSizeX || maxSize.iHeight != KTestDecoderInfoMaxSizeY)
+		{
+		ERR_PRINTF1(_L("Error - Max Picture Size is wrong!"));
+		ret = EFalse;
+		}
+
+	// Max Bitrate
+	if (aInfo->MaxBitrate() != KMaxTUint)
+		{
+		ERR_PRINTF1(_L("Error - Max Bitrate is wrong!"));
+		ret = EFalse;
+		}
+	
+	// Supports picture loss
+	if (!aInfo->SupportsPictureLoss())
+		{
+		ERR_PRINTF1(_L("Error - Supports Picture Loss = EFalse!"));
+		ret = EFalse;
+		}
+
+	// Supports slice loss
+	if (aInfo->SupportsSliceLoss())
+		{
+		ERR_PRINTF1(_L("Error - Supports Slice Loss = ETrue!"));
+		ret = EFalse;
+		}
+
+	// Coding standard info
+	if (!(aInfo->CodingStandardSpecificInfo() == KTestDecoderInfoCSInfo))
+		{
+		ERR_PRINTF1(_L("Error - Coding standard specific info is incorrect!"));
+		ret = EFalse;
+		}
+	// Implementation info
+	if (!(aInfo->ImplementationSpecificInfo() == KTestDecoderInfoISInfo))
+		{
+		ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!"));
+		ret = EFalse;
+		}
+
+	if (!aInfo->SupportsContentProtected())//Check if flag is set indicating Content Protection is supported.
+		{
+		ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!"));
+		ret = EFalse;
+		}
+
+	// get some test compressed video formats
+	CCompressedVideoFormat* testFormat = NULL;
+	TInt err = KErrNone;
+
+	// get formats supported
+	const RPointerArray<CCompressedVideoFormat>& vidFormats = aInfo->SupportedFormats();
+
+	// get supported max picture rates
+	TPictureRateAndSize testRate;
+	const RArray<TPictureRateAndSize>& maxRates = aInfo->MaxPictureRates();
+
+	// test formats supported
+	for (TUint i = 0; i < KTestDecoderInfoCount; i++)
+		{
+		TPtrC8 mimeType = KTestDecoderInfoMimeArray[i];
+		TRAP(err, testFormat = GetTestCVFormatL(mimeType));
+		if (err != KErrNone)
+			{
+			ERR_PRINTF2(_L("Error - Failed to construct CCompressedVideoFormat: %d!"), i);
+			ret = EFalse;
+			if(testFormat != NULL)
+				{
+				delete testFormat;
+				testFormat=NULL;
+				}
+			break;
+			}
+
+		if (!(*testFormat == *(vidFormats[i])) || !(aInfo->SupportsFormat(*testFormat)))
+			{
+			ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i);
+			ret = EFalse;
+			}
+
+		delete testFormat; 
+		testFormat = NULL;
+
+		// Test supported max picture rates
+		GetTestEncoderInfoRate(i, testRate);
+		if (!(testRate.iPictureSize == maxRates[i].iPictureSize) || 
+			!(testRate.iPictureRate == maxRates[i].iPictureRate) )
+			{
+			ERR_PRINTF2(_L("Error - picture rate %d is corrupt!"), i);
+			ret = EFalse;
+			}
+		}
+	//Screen information check
+#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT
+	RArray<TInt> supportedScreens;
+	TRAP(err, aInfo->GetSupportedScreensL(supportedScreens));
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("GetSupportedScreensL leaves with %d"), err);
+		ret = EFalse;
+		}
+	if(supportedScreens.Count() != KTestScreenCount)
+		{
+		ERR_PRINTF1(_L("Error - Unexpected screen count"));
+		ret = EFalse;
+		}
+	err = supportedScreens.Find(KDecoderDefaultScreenNumber);
+	if(err == KErrNotFound)
+		{
+		ERR_PRINTF1(_L("Error - No support for primary screen"));
+		ret = EFalse;
+		}
+	err = supportedScreens.Find(KDecoderSecondaryScreenNumber);
+	if(err == KErrNotFound)
+		{
+		ERR_PRINTF1(_L("Error - No support for secondary screen"));
+		ret = EFalse;
+		}
+	supportedScreens.Close();
+#endif
+	// finally check a format which isn't supposed to be supported
+	TRAP(err, testFormat = GetTestCVFormatL(_L8("Frederick Bloggs and his amazing coloured dog")));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - Failed to construct final CCompressedVideoFormat!"));
+		ret = EFalse;
+		}
+	else 
+		{
+		if (aInfo->SupportsFormat(*testFormat))
+			{
+			ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!"));
+			ret = EFalse;
+			}
+		}
+
+	if(testFormat != NULL)
+		{
+		delete testFormat;
+		testFormat=NULL;
+		}
+	return ret;
+	}
+
+TVerdict CTestDevVideoPlayGetDecoderInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetDecoderInfo"));
+
+	// expected results		
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+	CVideoDecoderInfo *decInfo = NULL;
+	TBool valid = EFalse;
+	
+	// get decoder information from test decoder plugin
+	
+	TRAP(err, 
+		decInfo = aDevVideoPlay.VideoDecoderInfoLC(KUidDevVideoTestDecodeHwDevice); 
+		valid = ValidDecoderInfo(decInfo);
+		CleanupStack::PopAndDestroy(decInfo); );
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("VideoDecoderInfoLC() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	// check the Video Decoder
+	else if (!valid)
+		{
+		ERR_PRINTF1(_L("CVideoDecoderInfo class is corrupt!"));
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("CVideoDecoderInfo passed check successfully"));
+		INFO_PRINTF3(_L("VideoDecoderInfoLC(), %d = %d"), err, expErr);
+		}
+		
+	return ret;
+	}
+
+
+
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayGetPostProcInfo::CTestDevVideoPlayGetPostProcInfo(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetPostProcInfo* CTestDevVideoPlayGetPostProcInfo::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetPostProcInfo* self = new(ELeave) CTestDevVideoPlayGetPostProcInfo(aTestName, aTestType);
+	return self;
+	}
+
+TBool CTestDevVideoPlayGetPostProcInfo::ValidPostProcInfo(CPostProcessorInfo* aInfo)
+	{
+	// do null pointer check
+	if (!aInfo) 
+		{
+		ERR_PRINTF1(_L("Error - Post Processor Info is NULL!"));
+		return EFalse;
+		}
+	
+	// check the post processor against test data
+	// need to check every call so as to keep code coverage
+	// and prevent a situation where if the first test fails
+	// then subsequent tests will not be called
+	TBool ret = ETrue;
+
+	// UID check
+	if (aInfo->Uid() != KUidDevVideoTestPostProcHwDevice)
+		{
+		ERR_PRINTF1(_L("Error - Post Processor UID is incorrect!"));
+		ret = EFalse;
+		}
+	// Manufacturer check
+	if (!(aInfo->Manufacturer() == KTestPostProcInfoManufacturer))
+		{
+		ERR_PRINTF1(_L("Error - Manufacturer is incorrect!"));
+		ret = EFalse;
+		}
+	// Identifier check
+	if (!(aInfo->Identifier() == KTestPostProcInfoIdentifier))
+		{
+		ERR_PRINTF1(_L("Error - Identifier is incorrect!"));
+		ret = EFalse;
+		}
+	// Version check
+	TVersion posVer = aInfo->Version();
+	if ( (posVer.iMajor != KTestPostProcInfoVersionMaj) ||
+		 (posVer.iMinor != KTestPostProcInfoVersionMin) ||
+		 (posVer.iBuild != KTestPostProcInfoVersionBuild) )
+		{
+		ERR_PRINTF1(_L("Error - Version is incorrect!"));
+		ret = EFalse;
+		}
+	// Accelerated check
+	if (!aInfo->Accelerated())
+		{
+		ERR_PRINTF1(_L("Error - Accelerated = EFalse!"));
+		ret = EFalse;
+		}
+	// Direct display check
+	if (!aInfo->SupportsDirectDisplay())
+		{
+		ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!"));
+		ret = EFalse;
+		}
+	// YUVToRGB Capabilities
+	if (!CompareYuvRgbCaps(aInfo->YuvToRgbCapabilities(), KTestPostProcInfoYuvToRgbCaps))
+		{
+		ERR_PRINTF1(_L("Error - YUV To RGB capabilities is incorrect!"));
+		ret = EFalse;
+		}
+
+	// Supported rotations
+	if (aInfo->SupportedRotations() != KTestPostProcInfoRotations)
+		{
+		ERR_PRINTF1(_L("Error - Supported Rotations is incorrect!"));
+		ret = EFalse;
+		}
+
+	// Supports arbitrary scaling check
+	if (!aInfo->AntiAliasedScaling())
+		{
+		ERR_PRINTF1(_L("Error - Anti-Aliased Scaling = EFalse!"));
+		ret = EFalse;
+		}
+	// Supports anti-aliased scaling check
+	if (!aInfo->SupportsArbitraryScaling())
+		{
+		ERR_PRINTF1(_L("Error - Supports Arbitrary Scaling = EFalse!"));
+		ret = EFalse;
+		}
+	// Implementation info
+	if (!(aInfo->ImplementationSpecificInfo() == KTestPostProcInfoISInfo))
+		{
+		ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!"));
+		ret = EFalse;
+		}
+
+	// get some test compressed video formats
+	TUncompressedVideoFormat testFormat;
+	TUint32 testComb = 0;
+	TScaleFactor testFactor = {0, 0};
+
+	// get supported formats
+	const RArray<TUncompressedVideoFormat>& vidFormats = aInfo->SupportedFormats();
+	
+	// get supported combinations
+	const RArray<TUint32>& suppCombs = aInfo->SupportedCombinations();
+
+	// get supported scale factors
+	const RArray<TScaleFactor>& scaleFactors = aInfo->SupportedScaleFactors();
+
+	// test formats, combinations, and scale factors supported
+	for (TUint i = 0; i < KTestPostProcInfoCount; i++)
+		{
+		testFormat = KTestPostProcInfoFormatArray[i];
+		if (!(testFormat == (vidFormats[i])) || !(aInfo->SupportsFormat(testFormat)))
+			{
+			ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i);
+			ret = EFalse;
+			}
+
+		testComb = KTestPostProcInfoCombsArray[i];
+		if (!(testComb == (suppCombs[i])) || !(aInfo->SupportsCombination(testComb)))
+			{
+			ERR_PRINTF2(_L("Error - Combination %d is corrupt!"), i);
+			ret = EFalse;
+			}
+
+		testFactor = KTestPostProcInfoScaleFactorsArray[i];
+		if (!CompareScaleFactors(testFactor, scaleFactors[i]))
+			{
+			ERR_PRINTF2(_L("Error - Scale factor %d is corrupt!"), i);
+			ret = EFalse;
+			}
+		}
+
+	//Screen information check
+#ifdef SYMBIAN_ENABLE_MMF_MULTISCREEN_SUPPORT
+	RArray<TInt> supportedScreens;
+	TRAPD(err, aInfo->GetSupportedScreensL(supportedScreens));
+	if(err != KErrNone)
+		{
+		ERR_PRINTF2(_L("GetSupportedScreensL leaves with %d"), err);
+		ret = EFalse;
+		}
+	if(supportedScreens.Count() != KTestScreenCount)
+		{
+		ERR_PRINTF1(_L("Error - Unexpected screen count"));
+		ret = EFalse;
+		}
+	err = supportedScreens.Find(KPostProcDefaultScreenNumber);
+	if(err == KErrNotFound)
+		{
+		ERR_PRINTF1(_L("Error - No support for primary screen"));
+		ret = EFalse;
+		}
+	err = supportedScreens.Find(KPostProcSecondaryScreenNumber);
+	if(err == KErrNotFound)
+		{
+		ERR_PRINTF1(_L("Error - No support for secondary screen"));
+		ret = EFalse;
+		}
+	supportedScreens.Close();
+#endif
+	// check a format that isn't supposed to be supported
+	testFormat = KTestPostProcInfoNegativeFormat;
+	testFormat.iYuvFormat = KTestYuvFormat1;
+	if (aInfo->SupportsFormat(testFormat))
+		{
+		ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!"));
+		ret = EFalse;
+		}
+	
+	// finally check a combination that isn't supposed to be supported
+	testComb = KTestPostProcInfoNegativeComb;
+	if (aInfo->SupportsCombination(testComb))
+		{
+		ERR_PRINTF1(_L("Error - Failed negative SupportsCombination() check!"));
+		ret = EFalse;
+		}
+
+	if (!aInfo->SupportsContentProtected())//Check if flah is set indicating Content Protection is supported.
+		{
+		ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!"));
+		ret = EFalse;
+		}
+
+	return ret;
+	}
+
+TVerdict CTestDevVideoPlayGetPostProcInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetPostProcInfo"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+	CPostProcessorInfo *procInfo = NULL;
+	TBool valid = EFalse;
+	
+	// get decoder information from test decoder plugin
+	TRAP(err, 
+		procInfo = aDevVideoPlay.PostProcessorInfoLC(KUidDevVideoTestPostProcHwDevice);
+	        procInfo->SetSupportsContentProtected(ETrue);	
+		valid = ValidPostProcInfo(procInfo);
+		CleanupStack::PopAndDestroy(procInfo); );
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("PostProcessorInfoLC() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	// check the Video Post Processor
+	else if (!valid)
+		{
+		ERR_PRINTF1(_L("CPostProcessorInfo class is corrupt!"));
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("CPostProcessorInfo passed check successfully"));
+		INFO_PRINTF3(_L("PostProcessorInfoLC(), %d = %d"), err, expErr);
+		}
+
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySelectDecoder::CTestDevVideoPlaySelectDecoder(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySelectDecoder* CTestDevVideoPlaySelectDecoder::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySelectDecoder* self = new(ELeave) CTestDevVideoPlaySelectDecoder(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySelectDecoder::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SelectDecoder"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	iError = KErrNone;
+
+	// this will leave if an error occurs
+	TRAP( iError, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice) );
+
+	if (iError != expErr)
+		{
+		ERR_PRINTF3(_L("SelectDecoderL() gave error %d (expected %d)"),iError, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF3(_L("SelectDecoderL(), %d = %d"), iError, expErr);
+	
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySelectPostProc::CTestDevVideoPlaySelectPostProc(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySelectPostProc* CTestDevVideoPlaySelectPostProc::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySelectPostProc* self = new(ELeave) CTestDevVideoPlaySelectPostProc(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySelectPostProc::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SelectPostProc"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	iError = KErrNone;
+	
+	// this will leave if an error occurs
+	TRAP( iError, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice) );
+
+	if (iError != expErr)
+		{
+		ERR_PRINTF3(_L("SelectPostProcessorL() gave error %d (expected %d)"),iError, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF3(_L("SelectPostProcessorL(), %d = %d"), iError, expErr);
+	
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayGetHeaderInfo::CTestDevVideoPlayGetHeaderInfo(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetHeaderInfo* CTestDevVideoPlayGetHeaderInfo::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetHeaderInfo* self = new(ELeave) CTestDevVideoPlayGetHeaderInfo(aTestName, aTestType);
+	return self;
+	}
+
+TBool CTestDevVideoPlayGetHeaderInfo::ValidPictureHeader(const TVideoPictureHeader* aPictureHeader)
+	{
+	TBool ret = EFalse;
+
+	if (!aPictureHeader)
+		{
+		ERR_PRINTF1(_L("Error - Picture Header is NULL!"));
+		return EFalse;
+		}
+
+	TTimeIntervalMicroSeconds testTime(KTestInputBufferTimestamp);
+
+	// check the picture header
+	if (aPictureHeader->iOptions != KTestPictureHeaderOptions)
+		{
+		ERR_PRINTF1(_L("Error - Options are incorrect!"));
+		}
+
+	else if (!(aPictureHeader->iPresentationTimestamp == testTime))
+		{
+		ERR_PRINTF1(_L("Error - Timestamp is incorrect!"));
+		}
+	else if (!(*(aPictureHeader->iOptional) == KTestInputBufferData()))
+		{	
+		ERR_PRINTF1(_L("Error - Optional data is corrupt!"));
+		}
+	else 
+		{
+		INFO_PRINTF1(_L("Picture Header is valid"));
+		ret = ETrue;
+		}
+
+	return ret;
+	}
+
+TVerdict CTestDevVideoPlayGetHeaderInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetHeaderInfo"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+//	THwDeviceId hwDecoder = 0;
+
+	// select decoder
+//	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// construct a test video input buffer with a valid timestamp
+	TPtrC8 testInputBufferDataLitCPtr(KTestInputBufferData);
+	HBufC8* testInputBufferData = testInputBufferDataLitCPtr.AllocLC();
+
+	TVideoInputBuffer testBuffer;
+	testBuffer.iOptions = KTestInputBufferOptions;
+	testBuffer.iPresentationTimestamp = KTestInputBufferTimestamp;
+	testBuffer.iData.Set(testInputBufferData->Des());
+
+	TVideoPictureHeader* picHeader = NULL;
+	// get header information from test data unit
+	TRAP(err, picHeader = aDevVideoPlay.GetHeaderInformationL(KTestDataUnitType, KTestDataUnitEncap, &testBuffer) );
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("GetHeaderInformationL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else if (!ValidPictureHeader(picHeader))
+		{
+		ERR_PRINTF1(_L("Picture header corrupt!"));
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Header information retrieved successfully"));
+		INFO_PRINTF3(_L("GetHeaderInformationL(), %d = %d"), err, expErr);	
+		}
+
+	CleanupStack::PopAndDestroy(testInputBufferData);
+	
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayReturnHeader::CTestDevVideoPlayReturnHeader(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayReturnHeader* CTestDevVideoPlayReturnHeader::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayReturnHeader* self = new(ELeave) CTestDevVideoPlayReturnHeader(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayReturnHeader::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ReturnHeader"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+//	THwDeviceId hwDecoder = 0;
+
+	// select decoder
+//	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	TVideoPictureHeader picHeader;
+	picHeader.iOptions = KTestPictureHeaderOptions;
+	TTimeIntervalMicroSeconds testTime(KTestPictureHeaderTimestamp);
+	picHeader.iPresentationTimestamp = testTime;
+
+	// return picture header [can use a local TVideoPictureHeader because we
+	// are testing a fake plugin - normally this would be a header supplied by
+	// the video plugin].
+	aDevVideoPlay.ReturnHeader(&picHeader);
+	
+	// if plugin didn't PANIC then test has passed
+	INFO_PRINTF1(_L("Header information returned successfully"));
+			
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlayConfigureDecoder::CTestDevVideoPlayConfigureDecoder(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayConfigureDecoder* CTestDevVideoPlayConfigureDecoder::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayConfigureDecoder* self = new(ELeave) CTestDevVideoPlayConfigureDecoder(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayConfigureDecoder::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr;
+
+	expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ConfigureDecoderL"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	//construct a test picture header
+	TVideoPictureHeader pictureHeader;
+	pictureHeader.iOptions = KTestPictureHeaderOptions;
+	pictureHeader.iPresentationTimestamp = KTestInputBufferTimestamp;
+
+	TPtrC8 testInputBufferDataLitCPtr(KTestInputBufferData);
+	pictureHeader.iOptional = &testInputBufferDataLitCPtr;
+
+	// get header information from test data unit
+	TRAP(err, aDevVideoPlay.ConfigureDecoderL(pictureHeader));
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("ConfigureDecoderL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		if (err == KErrNone)
+			{
+			INFO_PRINTF1(_L("Header information successfully configured in Decoder"));
+			}
+		INFO_PRINTF3(_L("ConfigureDecoderL(), error %d = expected %d"), err, expErr);	
+		}
+	
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySetInputFormatUC::CTestDevVideoPlaySetInputFormatUC(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetInputFormatUC* CTestDevVideoPlaySetInputFormatUC::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetInputFormatUC* self = new(ELeave) CTestDevVideoPlaySetInputFormatUC(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetInputFormatUC::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetInputFormatUC"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+//	THwDeviceId hwDecoder = 0;
+	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+//	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	TRAP(err, aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// this will leave if an error occurs in either plugin
+	TRAP(err, aDevVideoPlay.SetInputFormatL(hwPostProc, KTestVidFormat2) );
+
+	if ( err != expErr )
+		{
+		ERR_PRINTF3(_L("SetInputFormatL() on Post-Processor gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF3(_L("SetInputFormat(), %d = %d"), err, expErr);
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySetInputFormat::CTestDevVideoPlaySetInputFormat(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetInputFormat* CTestDevVideoPlaySetInputFormat::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetInputFormat* self = new(ELeave) CTestDevVideoPlaySetInputFormat(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetInputFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetInputFormat"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+	THwDeviceId hwDecoder = 0;
+//	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+//	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// get a temporary compressed video class
+	CCompressedVideoFormat *tempCFormat = NULL;
+	TRAP(err, tempCFormat = GetTestCVFormatL(KTestMimeType1));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize compressed video class"));
+		return EInconclusive;
+		}
+
+	// this will leave if an error occurs
+	TRAP(err, aDevVideoPlay.SetInputFormatL(hwDecoder, *tempCFormat, KTestUnitType1, KTestEncapType1, ETrue) );
+
+	// delete compressed video class
+	delete tempCFormat;	
+	tempCFormat = NULL;
+
+	if ( err != expErr )
+		{
+		ERR_PRINTF3(_L("SetInputFormatL() on Decoder gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF3(_L("SetInputFormat(), %d = %d"), err, expErr);
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+CTestDevVideoPlayGetOutputFormatList::CTestDevVideoPlayGetOutputFormatList(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetOutputFormatList* CTestDevVideoPlayGetOutputFormatList::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetOutputFormatList* self = new(ELeave) CTestDevVideoPlayGetOutputFormatList(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayGetOutputFormatList::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetOutputFormatList"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+	TInt err2 = KErrNone;
+
+	THwDeviceId hwDecoder = 0;
+	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	RArray<TUncompressedVideoFormat> decodeList;
+	RArray<TUncompressedVideoFormat> postProcList;
+
+	// Get output format list for decoder
+	TRAP(err, aDevVideoPlay.GetOutputFormatListL(hwDecoder, decodeList));
+		
+	// Get output format list for post-processor
+	TRAP(err2, aDevVideoPlay.GetOutputFormatListL(hwPostProc, postProcList));
+	
+	if ((err != expErr) || (err2 != expErr))
+		{
+		ERR_PRINTF3(_L("GetOutputFormatListL() on Decoder gave error %d (expected %d)"),err, expErr);
+		ERR_PRINTF3(_L("GetOutputFormatListL() on Post-Processor gave error %d (expected %d)"),err2, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		TBool decPass = EFalse;
+		TBool posPass = EFalse;
+
+		// expecting KTestVidFormat1,2,3 - check
+		TInt count = decodeList.Count();
+		if (count == 3) 
+			{
+			if ((decodeList[0] == KTestVidFormat1) &&
+				(decodeList[1] == KTestVidFormat2) &&
+				(decodeList[2] == KTestVidFormat3) )
+				{
+				INFO_PRINTF1(_L("Decoder output list checks ok"));
+				decPass = ETrue;
+				}
+			}
+
+		// expecting KTestVidFormat3,2,1 - check
+		count = postProcList.Count();
+		if (count == 3) 
+			{
+			if ((postProcList[0] == KTestVidFormat3) &&
+				(postProcList[1] == KTestVidFormat2) &&
+				(postProcList[2] == KTestVidFormat1) )
+				{
+				INFO_PRINTF1(_L("Post-Processor output list checks ok"));
+				posPass = ETrue;
+				}
+			}
+		
+		if (!decPass)
+			{
+			ERR_PRINTF1(_L("Decoder output list corrupt!"));
+			ret = EFail;
+			}
+		
+		if (!posPass)
+			{
+			ERR_PRINTF1(_L("Post-Processor output list corrupt!"));
+			ret = EFail;
+			}
+	
+		INFO_PRINTF4(_L("GetOutputFormatListL(), %d, %d = %d"), err, err2, expErr);
+		}	
+
+	// close the arrays
+	decodeList.Reset();		
+	decodeList.Close();
+	
+	postProcList.Reset();	
+	postProcList.Close();
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySetOutputFormat::CTestDevVideoPlaySetOutputFormat(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetOutputFormat* CTestDevVideoPlaySetOutputFormat::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetOutputFormat* self = new(ELeave) CTestDevVideoPlaySetOutputFormat(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetOutputFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetOutputFormat"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+	TInt err2 = KErrNone;
+
+	THwDeviceId hwDecoder = 0;
+	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// set output format on decoder
+	TRAP(err, aDevVideoPlay.SetOutputFormatL(hwDecoder, KTestVidFormat1) )
+	
+	// set output format on post-processor
+	TRAP(err2, aDevVideoPlay.SetOutputFormatL(hwPostProc, KTestVidFormat2) )
+
+
+	if ((err != expErr) || (err2 != expErr))
+		{
+		ERR_PRINTF3(_L("SetOutputFormatL() on Decoder gave error %d (expected %d)"),err, expErr);
+		ERR_PRINTF3(_L("SetOutputFormatL() on Post-Processor gave error %d (expected %d)"),err2, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF4(_L("SetOutputFormat(), %d, %d= %d"), err, err2, expErr);
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+CTestDevVideoPlaySetPostProcTypes::CTestDevVideoPlaySetPostProcTypes(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetPostProcTypes* CTestDevVideoPlaySetPostProcTypes::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetPostProcTypes* self = new(ELeave) CTestDevVideoPlaySetPostProcTypes(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetPostProcTypes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetPostProcTypes"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+	TInt err2 = KErrNone;
+
+	THwDeviceId hwDecoder = 0;
+	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// set post-process types on decoder
+	TRAP(err, aDevVideoPlay.SetPostProcessTypesL(hwDecoder, KTestProcessType1) )
+	
+	// set post-process types on post-processor
+	TRAP(err2, aDevVideoPlay.SetPostProcessTypesL(hwPostProc, KTestProcessType2) )
+
+
+	if ((err != expErr) || (err2 != expErr))
+		{
+		ERR_PRINTF3(_L("SetPostProcessTypesL() on Decoder gave error %d (expected %d)"),err, expErr);
+		ERR_PRINTF3(_L("SetPostProcessTypesL() on Post-Processor gave error %d (expected %d)"),err2, expErr);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF4(_L("SetPostProcessTypes(), %d, %d= %d"), err, err2, expErr);
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+CTestDevVideoPlayGetDecoderPostProcInfo::CTestDevVideoPlayGetDecoderPostProcInfo(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetDecoderPostProcInfo* CTestDevVideoPlayGetDecoderPostProcInfo::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetDecoderPostProcInfo* self = new(ELeave) CTestDevVideoPlayGetDecoderPostProcInfo(aTestName, aTestType);
+	return self;
+	}
+
+TBool CTestDevVideoPlayGetDecoderPostProcInfo::ValidPostProcInfo(CPostProcessorInfo* aInfo)
+	{
+	// do null pointer check
+	if (!aInfo) 
+		{
+		ERR_PRINTF1(_L("Error - Post Processor Info is NULL!"));
+		return EFalse;
+		}
+	
+	// check the post processor against test data
+	// need to check every call so as to keep code coverage
+	// and prevent a situation where if the first test fails
+	// then subsequent tests will not be called
+	TBool ret = ETrue;
+
+	// UID check
+	if (aInfo->Uid() != KUidDevVideoTestDecodeHwDevice)
+		{
+		ERR_PRINTF1(_L("Error - Decoder UID is incorrect!"));
+		ret = EFalse;
+		}
+	// Manufacturer check
+	if (!(aInfo->Manufacturer() == KTestPostProcInfoManufacturer))
+		{
+		ERR_PRINTF1(_L("Error - Manufacturer is incorrect!"));
+		ret = EFalse;
+		}
+	// Identifier check
+	if (!(aInfo->Identifier() == KTestPostProcInfoIdentifier))
+		{
+		ERR_PRINTF1(_L("Error - Identifier is incorrect!"));
+		ret = EFalse;
+		}
+	// Version check
+	TVersion posVer = aInfo->Version();
+	if ( (posVer.iMajor != KTestPostProcInfoVersionMaj) ||
+		 (posVer.iMinor != KTestPostProcInfoVersionMin) ||
+		 (posVer.iBuild != KTestPostProcInfoVersionBuild) )
+		{
+		ERR_PRINTF1(_L("Error - Version is incorrect!"));
+		ret = EFalse;
+		}
+	// Accelerated check
+	if (!aInfo->Accelerated())
+		{
+		ERR_PRINTF1(_L("Error - Accelerated = EFalse!"));
+		ret = EFalse;
+		}
+	// Direct display check
+	if (!aInfo->SupportsDirectDisplay())
+		{
+		ERR_PRINTF1(_L("Error - Supports Direct Display = EFalse!"));
+		ret = EFalse;
+		}
+	// YUVToRGB Capabilities
+	if (!CompareYuvRgbCaps(aInfo->YuvToRgbCapabilities(), KTestPostProcInfoYuvToRgbCaps))
+		{
+		ERR_PRINTF1(_L("Error - YUV To RGB capabilities is incorrect!"));
+		ret = EFalse;
+		}
+	//Content Protection	
+	if (!aInfo->SupportsContentProtected())//Check if flag is set indicating Content Protection is supported.
+		{
+		ERR_PRINTF1(_L("Error - Failed To get flag indicating support of Content Protection!"));
+		ret = EFalse;
+		}
+
+	// Supported rotations
+	if (aInfo->SupportedRotations() != KTestPostProcInfoRotations)
+		{
+		ERR_PRINTF1(_L("Error - Supported Rotations is incorrect!"));
+		ret = EFalse;
+		}
+
+	// Supports arbitrary scaling check
+	if (!aInfo->AntiAliasedScaling())
+		{
+		ERR_PRINTF1(_L("Error - Anti-Aliased Scaling = EFalse!"));
+		ret = EFalse;
+		}
+	// Supports anti-aliased scaling check
+	if (!aInfo->SupportsArbitraryScaling())
+		{
+		ERR_PRINTF1(_L("Error - Supports Arbitrary Scaling = EFalse!"));
+		ret = EFalse;
+		}
+	// Implementation info
+	if (!(aInfo->ImplementationSpecificInfo() == KTestDecoderInfoISInfo))
+		{
+		ERR_PRINTF1(_L("Error - Implementation specific info is incorrect!"));
+		ret = EFalse;
+		}
+
+	// get some test compressed video formats
+	TUncompressedVideoFormat testFormat;
+	TUint32 testComb = 0;
+	TScaleFactor testFactor = {0, 0};
+
+	// get supported formats
+	const RArray<TUncompressedVideoFormat>& vidFormats = aInfo->SupportedFormats();
+	
+	// get supported combinations
+	const RArray<TUint32>& suppCombs = aInfo->SupportedCombinations();
+
+	// get supported scale factors
+	const RArray<TScaleFactor>& scaleFactors = aInfo->SupportedScaleFactors();
+
+	// test formats, combinations, and scale factors supported
+	for (TUint i = 0; i < KTestPostProcInfoCount; i++)
+		{
+		testFormat = KTestPostProcInfoFormatArray[i];
+		if (!(testFormat == (vidFormats[i])) || !(aInfo->SupportsFormat(testFormat)))
+			{
+			ERR_PRINTF2(_L("Error - Video Format %d is corrupt!"), i);
+			ret = EFalse;
+			}
+
+		testComb = KTestPostProcInfoCombsArray[i];
+		if (!(testComb == (suppCombs[i])) || !(aInfo->SupportsCombination(testComb)))
+			{
+			ERR_PRINTF2(_L("Error - Combination %d is corrupt!"), i);
+			ret = EFalse;
+			}
+
+		testFactor = KTestPostProcInfoScaleFactorsArray[i];
+		if (!CompareScaleFactors(testFactor, scaleFactors[i]))
+			{
+			ERR_PRINTF2(_L("Error - Scale factor %d is corrupt!"), i);
+			ret = EFalse;
+			}
+		}
+
+	// check a format that isn't supposed to be supported
+	testFormat = KTestPostProcInfoNegativeFormat;
+	testFormat.iYuvFormat = KTestYuvFormat1;
+	if (aInfo->SupportsFormat(testFormat))
+		{
+		ERR_PRINTF1(_L("Error - Failed negative SupportsFormat() check!"));
+		ret = EFalse;
+		}
+	
+	// finally check a combination that isn't supposed to be supported
+	testComb = KTestPostProcInfoNegativeComb;
+	if (aInfo->SupportsCombination(testComb))
+		{
+		ERR_PRINTF1(_L("Error - Failed negative SupportsCombination() check!"));
+		ret = EFalse;
+		}
+
+	if (!aInfo->SupportsContentProtected())
+		{
+		ERR_PRINTF1(_L("Error - Failed to Set Content Protected Support!"));
+		ret = EFalse;
+		}
+
+	return ret;
+	}
+
+TVerdict CTestDevVideoPlayGetDecoderPostProcInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetPostProcInfo"));
+	
+	// expected results
+	if (iTestType != ETestValid)
+		{
+		ERR_PRINTF1(_L("Error - invalid test step type"));
+		return EInconclusive;
+		}
+	
+	TInt err = KErrNone;
+	CPostProcessorInfo *procInfo = NULL;
+	TBool valid = EFalse;
+	
+	// get decoder information from test decoder plugin
+	TRAP(err, 
+		procInfo = aDevVideoPlay.PostProcessorInfoLC(KUidDevVideoTestDecodeHwDevice); 
+		procInfo->SetSupportsContentProtected(ETrue);
+		valid = ValidPostProcInfo(procInfo);
+		CleanupStack::PopAndDestroy(procInfo); );
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("PostProcessorInfoLC() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	// check the Video Decoder
+	else if (!valid)
+		{
+		ERR_PRINTF1(_L("CPostProcessorInfo class is corrupt!"));
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("CPostProcessorInfo passed check successfully"));
+		INFO_PRINTF3(_L("PostProcessorInfoLC(), %d = %d"), err, expErr);
+		}
+
+	return ret;
+	}