--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmlibs/mmfw/tsrc/mmfunittest/DevVideo/src/TestDevVideoPlayThree.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,1998 @@
+
+// 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>
+
+void CTestDevVideoPlayResume::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayResume::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayResume::CTestDevVideoPlayResume(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayResume* CTestDevVideoPlayResume::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayResume* self = new(ELeave) CTestDevVideoPlayResume(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayResume::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+//	TInt expErr = KErrNone;
+	TBool selDec = ETrue;
+	TBool selPost = ETrue;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Resume"));
+	
+	// expected results
+	switch(iTestType)
+		{
+		case ETestValid:
+//			expErr = KErrNone;	// EABI warning removal
+			break;
+		case ETestDecoderOnly:
+			selPost = EFalse;
+			break;
+		case ETestPostProcOnly:
+			selDec = EFalse;
+			break;
+		default:
+			ERR_PRINTF1(_L("Error - invalid test step type"));
+			return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+//	THwDeviceId hwDecoder = 0;
+//	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	if (selDec)
+		{
+//		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
+	if (selPost)
+		{
+//		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;
+			}
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// check not already playing
+	TBool playing = aDevVideoPlay.IsPlaying();
+	if (playing)
+		{
+		ERR_PRINTF1(_L("Error - DevVideoPlay already playing!"));
+		return EInconclusive;
+		}
+
+	// call resume on DevVideoPlay then check IsPlaying()
+	aDevVideoPlay.Resume();
+	playing = aDevVideoPlay.IsPlaying();
+
+	if (!playing)
+		{
+		ERR_PRINTF1(_L("IsPlaying() returned EFalse - expected ETrue"));
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("Resume() called successfully"));
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlaySetPosition::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlaySetPosition::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlaySetPosition::CTestDevVideoPlaySetPosition(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetPosition* CTestDevVideoPlaySetPosition::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetPosition* self = new(ELeave) CTestDevVideoPlaySetPosition(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	TBool selDec = ETrue;
+	TBool selPost = ETrue;
+	TInt testPos = KTestPosition;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetPosition"));
+	
+	// expected results
+	switch(iTestType)
+		{
+		case ETestValid:
+			expErr = KErrNone;
+			break;
+		case ETestBothFatal:
+			expErr = KErrDied;
+			testPos = KTestPositionFatal;
+			break;
+		case ETestDecoderFatal:
+			expErr = KErrDied;
+			testPos = KTestPositionFatal;
+			// fall through to set post proc to false;
+		case ETestDecoderOnly:
+			selPost = EFalse;
+			break;
+		case ETestPostProcFatal:
+			expErr = KErrDied;
+			testPos = KTestPositionFatal;
+			// fall through to set decoder to false;
+		case ETestPostProcOnly:
+			selDec = EFalse;
+			break;
+		default:
+			ERR_PRINTF1(_L("Error - invalid test step type"));
+			return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+//	THwDeviceId hwDecoder = 0;
+//	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	if (selDec)
+		{
+//		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
+	if (selPost)
+		{
+//		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;
+			}
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	TTimeIntervalMicroSeconds pos(testPos);
+
+	// call SetPosition 
+	aDevVideoPlay.SetPosition(pos);
+
+	// if no PANIC and iError is as expected then test has passed
+	// if performing a fatal test then expect iError = KErrDied
+	if (iError == expErr)
+		{
+		ERR_PRINTF3(_L("SetPosition() got error %d;  Expected %d"), iError, expErr);
+		}
+	else
+		{
+		INFO_PRINTF1(_L("SetPosition() called successfully"));
+		}
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayFreezePicture::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayFreezePicture::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayFreezePicture::CTestDevVideoPlayFreezePicture(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayFreezePicture* CTestDevVideoPlayFreezePicture::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayFreezePicture* self = new(ELeave) CTestDevVideoPlayFreezePicture(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayFreezePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  FreezePicture"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	TTimeIntervalMicroSeconds pos(KTestPosition);
+
+	// call FreezePicture 
+	aDevVideoPlay.FreezePicture(pos);
+
+	// if no PANIC then test has passed
+
+	INFO_PRINTF1(_L("FreezePicture() called successfully"));
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayReleaseFreeze::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayReleaseFreeze::CTestDevVideoPlayReleaseFreeze(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayReleaseFreeze* CTestDevVideoPlayReleaseFreeze::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayReleaseFreeze* self = new(ELeave) CTestDevVideoPlayReleaseFreeze(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayReleaseFreeze::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  ReleaseFreeze"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	TTimeIntervalMicroSeconds pos(KTestPosition);
+
+	// call ReleaseFreeze 
+	aDevVideoPlay.ReleaseFreeze(pos);
+
+	// if no PANIC then test has passed
+
+	INFO_PRINTF1(_L("ReleaseFreeze() called successfully"));
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayDecodingPosition::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayDecodingPosition::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+		}
+
+CTestDevVideoPlayDecodingPosition::CTestDevVideoPlayDecodingPosition(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayDecodingPosition* CTestDevVideoPlayDecodingPosition::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayDecodingPosition* self = new(ELeave) CTestDevVideoPlayDecodingPosition(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayDecodingPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  DecodingPosition"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// get decoding position
+	TTimeIntervalMicroSeconds decPos = aDevVideoPlay.DecodingPosition();
+
+	// check against test data
+	TTimeIntervalMicroSeconds testTime(KTestDecodePosition);
+	if (decPos != testTime)
+		{
+		ERR_PRINTF3(_L("DecodingPosition() incorrect - gave %d (expected %d)"),
+			I64LOW(decPos.Int64()), KTestDecodePosition);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("DecodingPosition() called successfully"));
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayPlaybackPosition::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayPlaybackPosition::CTestDevVideoPlayPlaybackPosition(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayPlaybackPosition* CTestDevVideoPlayPlaybackPosition::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayPlaybackPosition* self = new(ELeave) CTestDevVideoPlayPlaybackPosition(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayPlaybackPosition::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PlaybackPosition"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// get playback position
+	TTimeIntervalMicroSeconds playPos = aDevVideoPlay.PlaybackPosition();
+
+	// check against test data
+	TTimeIntervalMicroSeconds testTime(KTestPlayPosition);
+	if (playPos != testTime)
+		{
+		ERR_PRINTF3(_L("PlaybackPosition() incorrect - gave %d (expected %d)"),
+			I64LOW(playPos.Int64()), KTestPlayPosition);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("PlaybackPosition() called successfully"));
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayPreDecoderBufferBytes::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayPreDecoderBufferBytes::CTestDevVideoPlayPreDecoderBufferBytes(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayPreDecoderBufferBytes* CTestDevVideoPlayPreDecoderBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayPreDecoderBufferBytes* self = new(ELeave) CTestDevVideoPlayPreDecoderBufferBytes(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayPreDecoderBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PreDecoderBufferBytes"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// get pre-decoder buffer bytes
+	TUint decBytes = aDevVideoPlay.PreDecoderBufferBytes();
+
+	// check against test data
+	if (decBytes != KTestPreDecoderBytes)
+		{
+		ERR_PRINTF3(_L("PreDecoderBufferBytes() incorrect - gave %d (expected %d)"),
+			decBytes, KTestPreDecoderBytes);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("PreDecoderBufferBytes() called successfully"));
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayPictureBufferBytes::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayPictureBufferBytes::CTestDevVideoPlayPictureBufferBytes(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayPictureBufferBytes* CTestDevVideoPlayPictureBufferBytes::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayPictureBufferBytes* self = new(ELeave) CTestDevVideoPlayPictureBufferBytes(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayPictureBufferBytes::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  PictureBufferBytes"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice)); // EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// get picture buffer bytes
+	TUint picBytes = aDevVideoPlay.PictureBufferBytes();
+
+	// check against test data
+	if (picBytes != KTestPictureBytes)
+		{
+		ERR_PRINTF3(_L("PictureBufferBytes() incorrect - gave %d (expected %d)"),
+			picBytes, KTestPictureBytes);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("PictureBufferBytes() called successfully"));
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayGetPictureCounters::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayGetPictureCounters::CTestDevVideoPlayGetPictureCounters(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetPictureCounters* CTestDevVideoPlayGetPictureCounters::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetPictureCounters* self = new(ELeave) CTestDevVideoPlayGetPictureCounters(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayGetPictureCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	TBool selDec = ETrue;
+	TBool selPost = ETrue;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetPictureCounters"));
+	
+	// expected results
+	switch(iTestType)
+		{
+		case ETestValid:
+			expErr = KErrNone;
+			break;
+		case ETestDecoderOnly:
+			selPost = EFalse;
+			break;
+		case ETestPostProcOnly:
+			selDec = EFalse;
+			break;
+		default:
+			ERR_PRINTF1(_L("Error - invalid test step type"));
+			return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+	THwDeviceId hwDecoder = 0;
+	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	if (selDec)
+		{
+		TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));
+		if (err != KErrNone)
+			{
+			ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+			return EInconclusive;
+			}
+		}
+
+	// select post-processor
+	if (selPost)
+		{
+		TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+		if (err != KErrNone)
+			{
+			ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+			return EInconclusive;
+			}
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	CMMFDevVideoPlay::TPictureCounters picCounts;
+
+	// get picture counters from DevVideoPlay
+	aDevVideoPlay.GetPictureCounters(picCounts);
+
+	// N.B. PicturesSkipped is sum of decoder and post processor so
+	// we have to add these
+	CMMFDevVideoPlay::TPictureCounters testCounts = GetTestPictureCounters();
+	if (hwDecoder && hwPostProc)
+		{
+		// account for both decoder and post processor
+		testCounts.iPicturesSkipped *= 2; 
+		}
+	else if (hwPostProc)
+		{
+		// no decoded samples from a post processor
+		testCounts.iPicturesDecoded = 0;
+		}
+
+	if (!ComparePictureCounters(picCounts, testCounts))
+		{
+		ERR_PRINTF1(_L("GetPictureCounters() comparison with test data failed!"));
+		ret = EFail;
+		}
+	else 
+		{
+		INFO_PRINTF1(_L("GetPictureCounters() comparison with test data passed."));
+		INFO_PRINTF3(_L("GetPictureCounters(), %d = %d"), err, expErr);
+		}
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayGetBitstreamCounters::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayGetBitstreamCounters::CTestDevVideoPlayGetBitstreamCounters(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetBitstreamCounters* CTestDevVideoPlayGetBitstreamCounters::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetBitstreamCounters* self = new(ELeave) CTestDevVideoPlayGetBitstreamCounters(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayGetBitstreamCounters::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBitstreamCounters"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	CMMFDevVideoPlay::TBitstreamCounters bitCounts;
+
+	// get bitstream counters from DevVideoPlay
+	aDevVideoPlay.GetBitstreamCounters(bitCounts);
+
+	if (!CompareBitstreamCounters(bitCounts, GetTestBitstreamCounters()))
+		{
+		ERR_PRINTF1(_L("GetBitstreamCounters() comparison with test data failed!"));
+		ret = EFail;
+		}
+	else 
+		{
+		INFO_PRINTF1(_L("GetBitstreamCounters() comparison with test data passed."));
+		INFO_PRINTF3(_L("GetBitstreamCounters(), %d = %d"), err, expErr);
+		}
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayNumFreeBuffers::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayNumFreeBuffers::CTestDevVideoPlayNumFreeBuffers(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayNumFreeBuffers* CTestDevVideoPlayNumFreeBuffers::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayNumFreeBuffers* self = new(ELeave) CTestDevVideoPlayNumFreeBuffers(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayNumFreeBuffers::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  NumFreeBuffers"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	TUint numBuffers = 0;
+
+	// get number of free buffers from DevVideoPlay
+	numBuffers = aDevVideoPlay.NumFreeBuffers();
+
+	if (numBuffers != KTestNumFreeBuffers)
+		{
+		ERR_PRINTF1(_L("NumFreeBuffers() comparison with test data failed!"));
+		ret = EFail;
+		}
+	else 
+		{
+		INFO_PRINTF1(_L("NumFreeBuffers() comparison with test data passed."));
+		INFO_PRINTF3(_L("NumFreeBuffers(), %d = %d"), numBuffers, KTestNumFreeBuffers);
+		}
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlaySetComplexityLevel::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlaySetComplexityLevel::CTestDevVideoPlaySetComplexityLevel(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlaySetComplexityLevel* CTestDevVideoPlaySetComplexityLevel::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlaySetComplexityLevel* self = new(ELeave) CTestDevVideoPlaySetComplexityLevel(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlaySetComplexityLevel::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  SetComplexityLevel"));
+	
+	// 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));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// set complexity level on decoder
+	aDevVideoPlay.SetComplexityLevel(hwDecoder, KTestComplexityLevel1);
+	
+	// set complexity level on post-processor
+	aDevVideoPlay.SetComplexityLevel(hwPostProc, KTestComplexityLevel2);
+
+	// if no PANIC then test has passed
+	INFO_PRINTF3(_L("SetComplexityLevel(), %d, %d"), KTestComplexityLevel1, KTestComplexityLevel2);
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayNumComplexityLevels::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayNumComplexityLevels::CTestDevVideoPlayNumComplexityLevels(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayNumComplexityLevels* CTestDevVideoPlayNumComplexityLevels::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayNumComplexityLevels* self = new(ELeave) CTestDevVideoPlayNumComplexityLevels(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayNumComplexityLevels::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  NumComplexityLevels"));
+	
+	// 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));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// get num complexity levels on decoder
+	TUint levs1 = aDevVideoPlay.NumComplexityLevels(hwDecoder);
+	
+	// get num complexity levels on post-processor
+	TUint levs2 = aDevVideoPlay.NumComplexityLevels(hwPostProc);
+
+	// check return values against test data
+	if (levs1 != KTestNumComplexityLevels1 || levs2 != KTestNumComplexityLevels2)
+		{
+		ERR_PRINTF3(_L("Error - comparison against test data failed! (%d, %d)"), levs1, levs2);
+		}
+	else
+		{
+		INFO_PRINTF3(_L("NumComplexityLevels(), %d, %d"), levs1, levs2);
+		}
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayGetComplexityLevelInfo::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayGetComplexityLevelInfo::CTestDevVideoPlayGetComplexityLevelInfo(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetComplexityLevelInfo* CTestDevVideoPlayGetComplexityLevelInfo::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetComplexityLevelInfo* self = new(ELeave) CTestDevVideoPlayGetComplexityLevelInfo(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayGetComplexityLevelInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetComplexityLevelInfo"));
+	
+	// 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));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	CMMFDevVideoPlay::TComplexityLevelInfo levInfo1;
+	CMMFDevVideoPlay::TComplexityLevelInfo levInfo2;
+
+	// get complexity level info on decoder
+	aDevVideoPlay.GetComplexityLevelInfo(hwDecoder, KTestComplexityLevel1, levInfo1);
+	
+	// get complexity level info on post-processor
+	aDevVideoPlay.GetComplexityLevelInfo(hwPostProc, KTestComplexityLevel2, levInfo2);
+
+	CMMFDevVideoPlay::TComplexityLevelInfo testInfo1 = GetTestLevelInfo(KTestComplexityLevel1);
+	CMMFDevVideoPlay::TComplexityLevelInfo testInfo2 = GetTestLevelInfo(KTestComplexityLevel2);
+
+	// check return values against test data
+	if (!CompareLevelInfos(levInfo1, testInfo1) || !CompareLevelInfos(levInfo2, testInfo2))
+		{
+		ERR_PRINTF1(_L("Error - comparison against test data failed!"));
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Comparison against test data passed ok."));
+		INFO_PRINTF1(_L("GetComplexityLevelInfo() called successfully"));
+		}
+
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayGetBuffer::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayGetBuffer::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+void CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayGetBuffer::MdvpoNewBuffers()"));
+	iCalledBack = ETrue;
+	}
+
+CTestDevVideoPlayGetBuffer::CTestDevVideoPlayGetBuffer(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayGetBuffer* CTestDevVideoPlayGetBuffer::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayGetBuffer* self = new(ELeave) CTestDevVideoPlayGetBuffer(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayGetBuffer::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBuffer"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	TVideoInputBuffer* newBuff = NULL;
+
+	// get a buffer of a certain size from DevVideoPlay
+	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) );
+	// callback will occur and newBuff will be set to new buffer
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		TBool buffSuccess = EFalse;
+
+		// check callback has been called and buffer is correct
+		if (newBuff && iCalledBack)
+			{
+			TTimeIntervalMicroSeconds testTime(KTestBufferSize);
+			if ( (newBuff->iDecodingTimestamp == testTime) &&
+				 (newBuff->iOptions == KTestBufferOptions) &&
+				 (newBuff->iData == KTestBufferString) )
+				{
+				buffSuccess = ETrue;
+				}
+			}
+		
+		if (!buffSuccess)
+			{
+			ERR_PRINTF1(_L("Received buffer is corrupt!"));
+			ret = EFail;
+			}
+		else
+			{
+			INFO_PRINTF1(_L("Buffer received correctly"));
+			INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr);	
+			}
+		}
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayWriteCodedData::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayWriteCodedData::CTestDevVideoPlayWriteCodedData(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayWriteCodedData* CTestDevVideoPlayWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayWriteCodedData* self = new(ELeave) CTestDevVideoPlayWriteCodedData(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  WriteCodedData"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// construct a video input buffer structure with a valid timestamp and
+	// write this DevVideoPlay.  Call will leave on error.
+	TVideoInputBuffer* newBuff = NULL;
+	TPtrC8 testBufferStringPtr(KTestBufferString);
+	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));
+	if (err)
+		{
+		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));
+		return EInconclusive;
+		}
+	
+	// initialize newBuff with test data
+	newBuff->iOptions = KTestBufferOptions;
+	newBuff->iDecodingTimestamp = KTestBufferSize;
+	newBuff->iData.Zero();
+	newBuff->iData.Append(testBufferStringPtr);
+	
+	// write buffer to DevVideoPlay
+	TRAP(err, aDevVideoPlay.WriteCodedDataL(newBuff) )
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Coded data sent successfully"));
+		INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr);	
+		}
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayScanAndCopyCodedData::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayScanAndCopyCodedData::CTestDevVideoPlayScanAndCopyCodedData(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}	
+
+CTestDevVideoPlayScanAndCopyCodedData* CTestDevVideoPlayScanAndCopyCodedData::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayScanAndCopyCodedData* self = new(ELeave) CTestDevVideoPlayScanAndCopyCodedData(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayScanAndCopyCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy:  ScanAndCopyCodedDataL"));
+	
+	// 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));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+
+	// construct a video input buffer structure with a valid timestamp and
+	// write this DevVideoPlay.  Call will leave on error.
+	TVideoInputBuffer* newBuff = NULL;
+	TPtrC8 testBufferStringPtr(KTestBufferString);
+	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));
+	if (err)
+		{
+		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	//clean out pre-set stuff from buffer
+	newBuff->iData.Zero();
+	//set ptr to test data
+	TPtrC8 testBufferString(KTestBufferString);
+	HBufC8* bufferDataArea = testBufferString.AllocL();
+	CleanupStack::PushL(bufferDataArea);
+	TPtr8 dataAreaPtr = bufferDataArea->Des();
+	TFramePortion framePortion = EFramePortionEndFragment;
+	
+	MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy));
+
+	TInt consumed = 0;
+	// write buffer to DevVideoPlay using new interface
+	TRAP(err, ciOne->ScanAndCopyCodedDataL(dataAreaPtr, newBuff, consumed, framePortion));
+
+	//compare buffer to test data
+	if ((newBuff->iData != KTestBufferString) || consumed != newBuff->iData.Length())
+		{
+		err = KErrCorrupt;
+		}
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("ScanAndCopyCodedDataL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Coded data sent successfully"));
+		INFO_PRINTF3(_L("ScanAndCopyCodedDataL(), %d = %d"), err, expErr);	
+		}
+	CleanupStack::PopAndDestroy(bufferDataArea);	
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayExtensionWriteCodedData::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayWriteCodedData::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+CTestDevVideoPlayExtensionWriteCodedData::CTestDevVideoPlayExtensionWriteCodedData(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayExtensionWriteCodedData* CTestDevVideoPlayExtensionWriteCodedData::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayExtensionWriteCodedData* self = new(ELeave) CTestDevVideoPlayExtensionWriteCodedData(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayExtensionWriteCodedData::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("MMMFVideoPlayHwDeviceExtensionScanCopy:  WriteCodedData"));
+	
+	// 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));
+
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));
+		return EInconclusive;
+		}
+
+	// select post-processor
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// construct a video input buffer structure with a valid timestamp and
+	// write this DevVideoPlay.  Call will leave on error.
+	TVideoInputBuffer* newBuff = NULL;
+	TPtrC8 testBufferStringPtr(KTestBufferString);
+	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(testBufferStringPtr.Length()));
+	if (err)
+		{
+		ERR_PRINTF1(_L("Error - couldn't get buffer from DevVideoPlay"));
+		return EInconclusive;
+		}
+	
+	// initialize newBuff with test data
+	newBuff->iOptions = KTestBufferOptions;
+	newBuff->iDecodingTimestamp = KTestBufferSize;
+	newBuff->iData.Zero();
+	newBuff->iData.Append(testBufferStringPtr);
+
+	TFramePortion framePortion = EFramePortionEndFragment;
+	
+	MMMFVideoPlayHwDeviceExtensionScanCopy* ciOne = static_cast<MMMFVideoPlayHwDeviceExtensionScanCopy*>(aDevVideoPlay.CustomInterface(hwDecoder, KUidDevVideoPlayHwDeviceExtensionScanCopy));
+
+	// write buffer to DevVideoPlay using new interface
+	TRAP(err, ciOne->WriteCodedDataL(newBuff, framePortion));
+	
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("WriteCodedDataL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		INFO_PRINTF1(_L("Coded data sent successfully"));
+		INFO_PRINTF3(_L("WriteCodedDataL(), %d = %d"), err, expErr);	
+		}
+	return ret;
+	}
+
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayWritePicture::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayWritePicture::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+void CTestDevVideoPlayWritePicture::MdvpoReturnPicture(TVideoPicture* aPicture)
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayWritePicture::MdvpoReturnPicture()"));
+
+	iPicture = aPicture;
+	}
+
+CTestDevVideoPlayWritePicture::CTestDevVideoPlayWritePicture(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayWritePicture* CTestDevVideoPlayWritePicture::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayWritePicture* self = new(ELeave) CTestDevVideoPlayWritePicture(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayWritePicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  WritePicture"));
+	
+	// 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));
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// construct a video picture structure with a valid timestamp and
+	// write this DevVideoPlay.  If the same picture comes back through the
+	// MdvpoReturnPicture() callback then test has passed.
+	TVideoPicture picture;
+	TTimeIntervalMicroSeconds picTime(KTestPictureTimestamp);
+	picture.iTimestamp = picTime;
+	picture.iOptions = TVideoPicture::ETimestamp;
+	
+	// write picture to DevVideoPlay
+	TRAP(err, aDevVideoPlay.WritePictureL(&picture) )
+
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("WritePicture() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		TBool picSuccess = EFalse;
+
+		// check callback has been called and picture is correct
+		if (iPicture)
+			{
+			if ( (iPicture->iTimestamp == picTime) &&
+				 (iPicture->iOptions == TVideoPicture::ETimestamp) )
+				{
+				picSuccess = ETrue;
+				}
+			}
+		
+		if (!picSuccess)
+			{
+			ERR_PRINTF1(_L("Received picture is corrupt!"));
+			ret = EFail;
+			}
+		else
+			{
+			INFO_PRINTF1(_L("Original picture received correctly"));
+			INFO_PRINTF3(_L("WritePicture(), %d = %d"), err, expErr);	
+			}
+		}
+	
+	return ret;
+	}
+//------------------------------------------------------------------
+
+void CTestDevVideoPlayInputEnd::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestDevVideoPlayInputEnd::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+void CTestDevVideoPlayInputEnd::MdvpoStreamEnd()
+	{
+	INFO_PRINTF1(_L("CTestDevVideoPlayInputEnd::MdvpoStreamEnd()"));
+	
+	// keep track on number of times this callback is called
+	iEndCount++;
+	}
+
+CTestDevVideoPlayInputEnd::CTestDevVideoPlayInputEnd(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoPlayInputEnd* CTestDevVideoPlayInputEnd::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoPlayInputEnd* self = new(ELeave) CTestDevVideoPlayInputEnd(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoPlayInputEnd::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+//	TInt expErr = KErrNone;
+	TBool selDec = ETrue;
+	TBool selPost = ETrue;
+
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  InputEnd"));
+	
+	// expected results
+	switch(iTestType)
+		{
+		case ETestValid:
+//			expErr = KErrNone;	// EABI warning removal
+			break;
+		case ETestDecoderOnly:
+			selPost = EFalse;
+			break;
+		case ETestPostProcOnly:
+			selDec = EFalse;
+			break;
+		default:
+			ERR_PRINTF1(_L("Error - invalid test step type"));
+			return EInconclusive;
+		}
+
+	TInt err = KErrNone;
+
+//	THwDeviceId hwDecoder = 0;
+//	THwDeviceId hwPostProc = 0;
+
+	// select decoder
+	if (selDec)
+		{
+//		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
+	if (selPost)
+		{
+//		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;
+			}
+		}
+	// initialize CDevVideoPlay and wait for response
+	// iError is set by the MdvpoInitComplete callback
+	aDevVideoPlay.Initialize();
+	
+	if (iError != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize DevVideoPlay"));
+		return EInconclusive;
+		}
+
+	// call input end on DevVideoPlay and check callback counter == 1
+	aDevVideoPlay.InputEnd();
+
+	if (iEndCount != 1)
+		{
+		ERR_PRINTF2(_L("Error - MdvpoStreamEnd only called %d times!"), iEndCount);
+		ret = EFail;
+		}
+	else
+		INFO_PRINTF1(_L("InputEnd() called successfully"));
+	
+	return ret;
+	}
+//-------------------------------------------------------------------
+
+void CTestDevVideoGetBufferWithoutInitialize::MdvpoInitComplete(TInt aError)
+	{
+	INFO_PRINTF2(_L("CTestGetBufferWithoutInitialize::MdvpoInitComplete():  Error = %d"), aError);
+	
+	iError = aError;
+	}
+
+void CTestDevVideoGetBufferWithoutInitialize::MdvpoNewBuffers()
+	{
+	INFO_PRINTF1(_L("CTestGetBufferWithoutInitialize::MdvpoNewBuffers()"));
+	iCalledBack = ETrue;
+	}
+
+CTestDevVideoGetBufferWithoutInitialize::CTestDevVideoGetBufferWithoutInitialize(const TDesC& aTestName, TTestType aTestType)
+	:CTestDevVideoPlayStep(aTestName, aTestType)
+	{
+	}
+
+CTestDevVideoGetBufferWithoutInitialize* CTestDevVideoGetBufferWithoutInitialize::NewL(const TDesC& aTestName, TTestType aTestType)
+	{
+	CTestDevVideoGetBufferWithoutInitialize* self = new(ELeave) CTestDevVideoGetBufferWithoutInitialize(aTestName, aTestType);
+	return self;
+	}
+
+TVerdict CTestDevVideoGetBufferWithoutInitialize::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)
+	{
+	TVerdict ret = EPass;
+	TInt expErr = KErrNone;
+	
+	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetBuffer"));
+	INFO_PRINTF1(_L("To test the scenario wherein GetBufferL is called without calling initialize"));
+	// 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;
+		}
+
+	// select post-processor
+	TRAP(err, aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));	// EABI warning removal
+	if (err != KErrNone)
+		{
+		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));
+		return EInconclusive;
+		}
+	TVideoInputBuffer* newBuff = NULL;
+	// iError is set by the MdvpoInitComplete callback
+	TRAP(err, newBuff = aDevVideoPlay.GetBufferL(KTestBufferSize) );
+	// callback will occur and newBuff will be set to new buffer
+	if (err != expErr)
+		{
+		ERR_PRINTF3(_L("GetBufferL() gave error %d (expected %d)"),err, expErr);
+		ret = EFail;
+		}
+	else
+		{
+		TBool buffSuccess = EFalse;
+
+		// check callback has been called and buffer is correct
+		if (newBuff && iCalledBack)
+			{
+			TTimeIntervalMicroSeconds testTime(KTestBufferSize);
+			if ( (newBuff->iDecodingTimestamp == testTime) &&
+				 (newBuff->iOptions == KTestBufferOptions) &&
+				 (newBuff->iData == KTestBufferString) )
+				{
+				buffSuccess = ETrue;
+				}
+			}
+		
+		if (!buffSuccess)
+			{
+			ERR_PRINTF1(_L("Received buffer is corrupt!"));
+			ret = EFail;
+			}
+		else
+			{
+			INFO_PRINTF1(_L("Buffer received correctly"));
+			INFO_PRINTF3(_L("GetBuffer(), %d = %d"), err, expErr);	
+			}
+		}
+	
+	return ret;
+	}
+//-----------------------------------------------------------------------
+