--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mmdevicefw/mdfunittest/codecapi/video/src/videoplayfile_cov.cpp	Tue Feb 02 01:56:55 2010 +0200
@@ -0,0 +1,980 @@
+// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+//
+
+#include <mmf/devvideo/videoplayhwdevice.h>
+#include <mmf/server/mmfdatabuffer.h>
+#include "videoplayfile_cov.h"
+
+#include "../../PU/video/src/Plugin/VideoTestDecoderPU/videotestdecoderpu.hrh"
+#include "../../PU/video/src/Plugin/VideoTestEncoderPU/videotestencoderpu.hrh"
+
+const TInt KInputBufferSize = 8192;
+const TInt KFilePositionZero = 0;
+const TInt KTBufSize = 256;
+const TInt KTRegionFixSize = 1;
+const TInt64 KInterval=2184;
+const TInt KVideoDecoderMaxDataBufferSize = 0x40000;
+const TUint KMinInputBuffers=2;
+_LIT8(KMime,"video/x-symbiantest");
+_LIT8(KBlank,"");
+
+
+// **************************************************
+// instructs the Hw Device Adapter to play a file	
+// **************************************************
+CPlayVideoFileCov::CPlayVideoFileCov(RTestStepVideoCodecs* aParent) : 
+	CActive(EPriorityNormal),
+	iState(EHwDeviceInit),
+	iParent(aParent)
+	{
+	}
+
+void  CPlayVideoFileCov::ConstructL()
+	{
+	CActiveScheduler::Add(this);
+	User::LeaveIfError(RFbsSession::Connect());
+
+	TInt err = KErrNone;
+	TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor16MA));
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor16M));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor64K));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor4K));
+		}
+	if (err == KErrNotSupported)
+		{
+		TRAP(err, iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor256));
+		}
+	if (err == KErrNotSupported)
+		{
+		iScreenDevice = CFbsScreenDevice::NewL(_L(""),EColor16MAP);
+		}	
+	else
+		{
+		User::LeaveIfError(err);		
+		}
+	}
+
+CPlayVideoFileCov* CPlayVideoFileCov::NewL(RTestStepVideoCodecs* aParent)
+	{
+	CPlayVideoFileCov* self = new (ELeave) CPlayVideoFileCov(aParent);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+	
+void CPlayVideoFileCov::DoCancel()
+	{
+	}
+
+CPlayVideoFileCov::~CPlayVideoFileCov()
+	{
+	iFile.Close();
+	iFs.Close();
+	
+	delete iVideoHwDevice;
+	delete iScreenDevice;
+	RFbsSession::Disconnect();
+	}
+	
+	
+void CPlayVideoFileCov::LoadCodecL()	
+	{
+	iParent->InfoMessage(_L("Loading Hw Device Adapter and PU Codec"));
+
+	RImplInfoPtrArray array;
+	REComSession::ListImplementationsL(TUid::Uid(KUidMdfProcessingUnit), array);
+	TBool found = EFalse;
+	CImplementationInformation* info = NULL;
+	for (TInt i=0;i<array.Count() && !found;i++)
+		{
+		info = array[i];
+		if (info->ImplementationUid() == TUid::Uid(KUidVideoTestDecoderPu))
+			{
+			found = ETrue;
+			}
+		}
+	TInt err = KErrNotFound;
+	if (found)
+		{
+		TRAP(err, iVideoHwDevice = CMMFVideoDecodeHwDevice::NewPuAdapterL(*info,*this));
+		}
+	else
+		{
+		err = KErrNotFound;
+		}
+	CVideoDecoderInfo* vInfo=NULL;
+	iParent->InfoMessage(_L("VideoDecoderInfoLC"));
+	TRAP(iError, vInfo=iVideoHwDevice->VideoDecoderInfoLC(); CleanupStack::Pop(vInfo) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("VideoDecoderInfoLC Failed"));
+		SetState(EHwDeviceError);
+		}
+	delete vInfo;
+	CCompressedVideoFormat* format=CCompressedVideoFormat::NewL(KMime);
+	TVideoDataUnitType dataUnitType=EDuCodedPicture;
+	TVideoDataUnitEncapsulation encapsulation=EDuElementaryStream;
+	TBool dataInOrder=ETrue;
+	iParent->InfoMessage(_L("SetInputFormatL"));
+	TRAP(iError, iVideoHwDevice->SetInputFormatL(*format,dataUnitType,encapsulation,dataInOrder));
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetInputFormatL Failed"));
+		SetState(EHwDeviceError);
+		}
+	//Negative test case for  SetInputFormatL
+	CCompressedVideoFormat* format2=CCompressedVideoFormat::NewL(KBlank);
+	TRAP(iError, iVideoHwDevice->SetInputFormatL(*format2,dataUnitType,encapsulation,dataInOrder));
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetInputFormatL Failed"));
+		SetState(EHwDeviceError);
+		}
+	delete format2;
+	//Negative test case for SetInputFormatL
+	dataUnitType=EDuVideoSegment;
+	TRAP(iError, iVideoHwDevice->SetInputFormatL(*format,dataUnitType,encapsulation,dataInOrder));
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetInputFormatL Failed"));
+		SetState(EHwDeviceError);
+		}
+	//Negative test case for SetInputFormatL
+	dataUnitType=EDuCodedPicture;
+	encapsulation=EDuGenericPayload;
+	TRAP(iError, iVideoHwDevice->SetInputFormatL(*format,dataUnitType,encapsulation,dataInOrder));
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetInputFormatL Failed"));
+		SetState(EHwDeviceError);
+		}
+	//Negative test case for SetInputFormatL
+	encapsulation=EDuElementaryStream;
+	dataInOrder=EFalse;
+	TRAP(iError, iVideoHwDevice->SetInputFormatL(*format,dataUnitType,encapsulation,dataInOrder));
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetInputFormatL Failed"));
+		SetState(EHwDeviceError);
+		}
+	delete format;
+	array.ResetAndDestroy();
+	User::LeaveIfError(err);
+
+	}
+	
+void CPlayVideoFileCov::SetDSA(TBool aUseDSA)	
+	{
+	// Need new version of this to load from a PU based uid
+	iUseDSA = aUseDSA;
+	}
+	
+void CPlayVideoFileCov::StartPlaybackL()	
+	{
+	OpenTestFileL();
+	SetState(EHwDeviceInit);
+	CActiveScheduler::Start();
+	}
+
+void CPlayVideoFileCov::SetState(TPlayVideoFileState aState)
+	{
+	iState = aState;
+	SetActive();	
+	TRequestStatus* status = &iStatus;
+	User::RequestComplete(status, KErrNone);	
+	}
+
+void CPlayVideoFileCov::OpenTestFileL()
+	{
+	TBuf<KTBufSize> buf;
+	buf.Format(_L("Opening test input file %S"), &KTestPlaybackFile);
+	iParent->InfoMessage(buf);
+	User::LeaveIfError(iFs.Connect());
+	User::LeaveIfError(iFile.Open(iFs, KTestPlaybackFile, EFileRead));
+	}
+
+void CPlayVideoFileCov::RunL()
+ 	{
+	switch (iState)
+		{
+		case EHwDeviceInit:
+			{
+			iParent->InfoMessage(_L("State: EHwDeviceInit"));
+			TRAPD(err, InitializeL());
+			if (err != KErrNone)
+				{
+				CleanupAndSetDeviceError(_L("Cannot intialize HwDevice"));
+				break;
+				}
+			break;
+			}
+		case EHwDeviceStartDecode:
+			{
+			// if we are playing a file, first we have to open the file
+			iParent->InfoMessage(_L("State: EHwDeviceStartDecode"));
+			TRAPD(err, StartDecodeL());
+			if (err != KErrNone)
+				{
+				CleanupAndSetDeviceError(_L("Cannot start decoding"));
+				break;
+				}
+			break;
+			}
+		case EHwDeviceAllowToComplete:
+			iParent->InfoMessage(_L("State: EHwDeviceAllowToComplete"));
+			break;
+		case EHwDeviceDone:
+			{
+			iParent->InfoMessage(_L("State: EHwDeviceDeviceDone"));
+			Cancel();
+			CActiveScheduler::Stop();
+			break;
+			}				
+		case EHwDeviceError:
+			{
+			TBuf<KTBufSize> buf;
+			buf.Format(_L("State: EHwDeviceDeviceError %d"), iError);
+			iParent->SetVerdict(buf, EFail);
+			
+			CActiveScheduler::Stop();
+			break;
+			}
+		default:
+			{
+			CleanupAndSetDeviceError(_L("Unknown CPlayVideoFileCov iState"));
+			break;
+			}
+		}
+	}
+	
+	
+void CPlayVideoFileCov::InitializeL()
+	{
+	iParent->InfoMessage(_L("InitializeL()"));
+
+	CMMFDevVideoPlay::TBufferOptions bufferOptions;
+	bufferOptions.iMaxInputBufferSize=0x40000;
+	iVideoHwDevice->SetBufferOptionsL(bufferOptions);
+	
+	TTimeIntervalMicroSeconds Interval(KInterval);
+	iVideoHwDevice->SetPosition(Interval);
+	
+	CMMFDevVideoPlay::TBitstreamCounters bitstreamCounters;
+	iVideoHwDevice->GetBitstreamCounters(bitstreamCounters);
+
+	CMMFDevVideoPlay::TBufferOptions Options;
+	Options.iMaxInputBufferSize=0x40000;
+	iVideoHwDevice->SetBufferOptionsL(Options);
+	
+	CMMFDevVideoPlay::TBitstreamCounters Counters;
+	iVideoHwDevice->GetBitstreamCounters(Counters);
+	
+	TUint complexityLevel=1;
+	iParent->InfoMessage(_L("SetComplexityLevel"));
+	TRAP(iError, iVideoHwDevice->SetComplexityLevel(complexityLevel) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetComplexityLevel Failed"));
+		SetState(EHwDeviceError);
+		}
+	THrdVbvSpecification HrdVbvSpec=EHrdVbvNone;
+	iParent->InfoMessage(_L("SetHrdVbvSpec"));
+	TRAP(iError, iVideoHwDevice->SetHrdVbvSpec(HrdVbvSpec,KBlank) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetHrdVbvSpec Failed"));
+		SetState(EHwDeviceError);
+		}
+	TRect rect;
+	iParent->InfoMessage(_L("SetInputCropOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetInputCropOptionsL(rect) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetInputCropOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("SetOutputCropOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetOutputCropOptionsL(rect) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetOutputCropOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("SetPauseOnClipFail"));
+	TRAP(iError, iVideoHwDevice->SetPauseOnClipFail(ETrue) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetPauseOnClipFail Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("SetPostProcessTypesL"));
+	TRAP(iError, iVideoHwDevice->SetPostProcessTypesL(ETrue) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetPostProcessTypesL Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("SetPostProcSpecificOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetPostProcSpecificOptionsL(KBlank) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetPostProcSpecificOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TRotationType rotType=ERotate90Clockwise;
+	iParent->InfoMessage(_L("SetRotateOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetRotateOptionsL(rotType) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetRotateOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TSize size(12,30);
+	iParent->InfoMessage(_L("SetScaleOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetScaleOptionsL(size,ETrue) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetScaleOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TYuvToRgbOptions YuvOption;
+	
+	iParent->InfoMessage(_L("SetYuvToRgbOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetYuvToRgbOptionsL(YuvOption) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetYuvToRgbOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TYuvFormat YuvFormat;
+	TRgbFormat RgbFormat=ERgb16bit444;
+	iParent->InfoMessage(_L("SetYuvToRgbOptionsL"));
+	TRAP(iError, iVideoHwDevice->SetYuvToRgbOptionsL(YuvOption,YuvFormat,RgbFormat) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetYuvToRgbOptionsL Failed"));
+		SetState(EHwDeviceError);
+		}
+	CMMFVideoPostProcHwDevice *outDevice = NULL;
+	iParent->InfoMessage(_L("SetOutputDevice"));
+	TRAP(iError, iVideoHwDevice->SetOutputDevice(outDevice) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetOutputDevice Failed"));
+		SetState(EHwDeviceError);
+		}
+	
+	TVideoPictureHeader  videoPictureHeader;
+	iParent->InfoMessage(_L("ConfigureDecoderL"));
+	TRAP(iError, iVideoHwDevice->ConfigureDecoderL(videoPictureHeader) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("ConfigureDecoderL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TUncompressedVideoFormat reqFormat;
+		
+	reqFormat.iDataFormat = ERgbFbsBitmap;
+	reqFormat.iRgbFormat = EFbsBitmapColor16M;
+	
+	RArray<TUncompressedVideoFormat> decodeFormats;
+	iVideoHwDevice->GetOutputFormatListL(decodeFormats);
+	CleanupClosePushL(decodeFormats);
+	User::LeaveIfError(decodeFormats.Find(reqFormat));
+
+	iParent->InfoMessage(_L("Call VideoHwDevice->SetOutputFormat()"));
+	iVideoHwDevice->SetOutputFormatL(reqFormat);
+	CleanupStack::PopAndDestroy(&decodeFormats);	
+	
+	CMMFDescriptorBuffer* buffer = CMMFDescriptorBuffer::NewL(KInputBufferSize);
+	CleanupStack::PushL(buffer);
+	TVideoInputBuffer inputBuffer;
+	
+	TDes8& des = buffer->Data();
+	// read header data from file
+	User::LeaveIfError(iFile.Read(des));
+	TInt pos = KFilePositionZero;
+	// seek back to start
+	User::LeaveIfError(iFile.Seek(ESeekStart, pos));
+
+	TBuf<KTBufSize> buf;
+	buf.Format(_L("Read header of size %d"),inputBuffer.iData.Length());
+	iParent->InfoMessage(buf);
+	
+	if (des.Length()>0)
+		{
+		// Set the pointer
+		inputBuffer.iData.Set(&des[0],des.Length(),des.MaxLength());
+		
+		iParent->InfoMessage(_L("Call VideoHwDevice GetHeaderInformationL()"));
+		TVideoPictureHeader* header = iVideoHwDevice->GetHeaderInformationL(EDuArbitraryStreamSection, 
+												EDuElementaryStream,
+												&inputBuffer);
+		TVideoPictureHeader* header2 =NULL;
+		//Call ReturnHeader for negative test
+		iVideoHwDevice->ReturnHeader(header2);
+		iFrameSize = header->iSizeInMemory;
+		iVideoHwDevice->ReturnHeader(header);
+		}
+	else
+		{
+		// Cannot read any data from file, so no point in continuing
+		User::Leave(KErrCorrupt);
+		}
+		
+	CleanupStack::PopAndDestroy(buffer);	
+	
+	iParent->InfoMessage(_L("Call VideoHwDevice SetVideoDestScreenL()"));
+	iVideoHwDevice->SetVideoDestScreenL(iUseDSA);
+	
+	iParent->InfoMessage(_L("Call VideoHwDevice->Initialize()"));
+	iVideoHwDevice->Initialize();
+	}
+	
+	
+void CPlayVideoFileCov::StartDecodeL()
+	{
+	iParent->InfoMessage(_L("SynchronizeDecoding"));
+	TRAP(iError, iVideoHwDevice->SynchronizeDecoding(ETrue) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SynchronizeDecoding Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("StartDecodeL()"));
+
+	if (iUseDSA)
+		{
+		StartDirectScreenAccessL();
+		}
+	// tell the HwDeviceAdapter to play the file
+	iParent->InfoMessage(_L("Call VideoHwDevice->Start()"));
+	iVideoHwDevice->Start();
+	CSystemClockSource *time1= NULL;
+	
+	iParent->InfoMessage(_L("SetClockSource"));
+	TRAP(iError, iVideoHwDevice->SetClockSource(time1) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetClockSource Failed"));
+		SetState(EHwDeviceError);
+		}
+	
+	delete time1;
+	iVideoHwDevice->PictureBufferBytes();
+	CMMFDevVideoPlay::TComplexityLevelInfo aInfo;
+	iVideoHwDevice->GetComplexityLevelInfo(0,aInfo);
+	//Call GetComplexityLevelInfo for False condition coverage
+	iVideoHwDevice->GetComplexityLevelInfo(1,aInfo);
+	iVideoHwDevice->IsPlaying();
+	CMMFDevVideoPlay::TPictureCounters PictureCounters;
+	iParent->InfoMessage(_L("GetPictureCounters"));
+	TRAP(iError, iVideoHwDevice->GetPictureCounters(PictureCounters) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("GetPictureCounters Failed"));
+		SetState(EHwDeviceError);
+		}
+	TPictureData PictureData;
+	TUncompressedVideoFormat UncomprossedVideoFormat;
+	iParent->InfoMessage(_L("GetSnapshotL"));
+	TRAP(iError, iVideoHwDevice->GetSnapshotL(PictureData,UncomprossedVideoFormat) );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("GetSnapshotL Failed"));
+		SetState(EHwDeviceError);
+		}
+	CMMFDevVideoPlay::TBufferOptions bufferOptions;
+	iVideoHwDevice->GetBufferOptions(bufferOptions);
+	iVideoHwDevice->NumComplexityLevels();
+
+	iParent->InfoMessage(_L("NumFreeBuffers"));
+	TRAP(iError, iVideoHwDevice->NumFreeBuffers() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("NumFreeBuffers Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("PlaybackPosition"));
+	TRAP(iError, iVideoHwDevice->PlaybackPosition() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("PlaybackPosition Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("DecodingPosition"));
+	TRAP(iError, iVideoHwDevice->DecodingPosition() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("DecodingPosition Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("Redraw"));
+	TRAP(iError, iVideoHwDevice->Redraw() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("Redraw Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("AbortDirectScreenAccess"));
+	TRAP(iError, iVideoHwDevice->AbortDirectScreenAccess() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("AbortDirectScreenAccess Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("CommitL"));
+	TRAP(iError, iVideoHwDevice->CommitL() );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("CommitL Failed"));
+		SetState(EHwDeviceError);
+		}
+	TTimeIntervalMicroSeconds Timestamp;
+	iParent->InfoMessage(_L("FreezePicture"));
+	TRAP(iError, iVideoHwDevice->FreezePicture(Timestamp) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("FreezePicture Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("PostProcessorInfoLC"));
+	TRAP(iError, iVideoHwDevice->PostProcessorInfoLC() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("PostProcessorInfoLC Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("PreDecoderBufferBytes"));
+	TRAP(iError, iVideoHwDevice->PreDecoderBufferBytes() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("PreDecoderBufferBytes Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("ReleaseFreeze"));
+	TRAP(iError, iVideoHwDevice->ReleaseFreeze(Timestamp) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("ReleaseFreeze Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("Revert"));
+	TRAP(iError, iVideoHwDevice->Revert() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("Revert Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("Redraw"));
+	TRAP(iError, iVideoHwDevice->Redraw() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("Redraw Failed"));
+		SetState(EHwDeviceError);
+		}
+	
+	}
+	
+
+	
+void CPlayVideoFileCov::ReadNextBufferL()
+	{
+	// check that we aren't waiting for the input buffer to be returned
+	iParent->InfoMessage(_L("ReadNextBufferL()"));
+	TVideoInputBuffer* inputBuffer = iVideoHwDevice->GetBufferL(KInputBufferSize);	
+	CMMFDevVideoPlay::TBufferOptions aOptions;
+	iVideoHwDevice->GetBufferOptions(aOptions);
+	iVideoHwDevice->NumComplexityLevels();
+	
+	
+	if (inputBuffer)
+		{
+		TBuf<KTBufSize> buf;
+		buf.Format(_L("inputBuffer size %d"),inputBuffer->iData.Length());
+		iParent->InfoMessage(buf);
+		User::LeaveIfError(iFile.Read(inputBuffer->iData));
+		buf.Format(_L("Read from file %d bytes"),inputBuffer->iData.Length());
+		iParent->InfoMessage(buf);
+		if (inputBuffer->iData.Length()>0)
+			{
+			iParent->InfoMessage(_L("Call HwDevice->WriteCodedData()"));
+			
+			iVideoHwDevice->WriteCodedDataL(inputBuffer);
+			}
+		else
+			{
+			iParent->InfoMessage(_L("End of input stream"));
+			iParent->InfoMessage(_L("Call HwDevice->InputEnd()"));
+			iVideoHwDevice->InputEnd();
+			}
+		}
+	}
+		
+void CPlayVideoFileCov::CleanupAndSetDeviceError(TPtrC16 aText)
+	{
+	iParent->SetVerdict(aText, EFail);
+	delete iVideoHwDevice;
+	SetState(EHwDeviceError);
+	}
+	
+void CPlayVideoFileCov::MdvppNewPicture(TVideoPicture* aPicture)
+	{
+	iParent->InfoMessage(_L("MdvppNewPicture - Received Frame"));
+	iVideoHwDevice->ReturnPicture(aPicture);
+	iParent->InfoMessage(_L("MdvppNewPicture - finished returning Frame"));
+	}
+
+void CPlayVideoFileCov::MdvppNewBuffers()
+	{
+	iParent->InfoMessage(_L("MdvppNewBuffers()"));
+	TRAP(iError, ReadNextBufferL());
+	if (iError != KErrNone)
+		{
+		iParent->SetVerdict(_L("Error reading next buffer"),EFail);		
+		iVideoHwDevice->Stop();
+		SetState(EHwDeviceError);
+		}
+	}
+
+void CPlayVideoFileCov::MdvppReturnPicture(TVideoPicture* /*aPicture*/)
+	{
+	iParent->InfoMessage(_L("MdvppReturnPicture()"));
+	}
+	
+void CPlayVideoFileCov::MdvppSupplementalInformation(const TDesC8& /*aData*/, 
+	const TTimeIntervalMicroSeconds& /*aTimestamp*/, const TPictureId& /*aPictureId*/)
+	{
+	}
+	
+void CPlayVideoFileCov::MdvppPictureLoss()
+	{
+	iParent->InfoMessage(_L("MdvppPictureLoss()"));
+	}
+	
+void CPlayVideoFileCov::MdvppPictureLoss(const TArray<TPictureId>& /*aPictures*/)
+	{
+	iParent->InfoMessage(_L("MdvppPictureLoss()"));
+	}
+	
+void CPlayVideoFileCov::MdvppSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/)
+	{
+	iParent->InfoMessage(_L("MdvppSliceLoss()"));
+	}
+	
+void CPlayVideoFileCov::MdvppReferencePictureSelection(const TDesC8& /*aSelectionData*/)
+	{
+	}
+	
+void CPlayVideoFileCov::MdvppTimedSnapshotComplete(TInt /*aError*/, TPictureData* /*aPictureData*/, 
+	const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, const TPictureId& /*aPictureId*/)
+	{
+	}
+	
+void CPlayVideoFileCov::MdvppFatalError(CMMFVideoHwDevice* /*aDevice*/, TInt aError)
+	{
+	iError = aError;
+	iParent->InfoMessage(_L("MdvppFatalError()"));
+	SetState(EHwDeviceError);
+	}
+	
+void CPlayVideoFileCov::MdvppInitializeComplete(CMMFVideoHwDevice* /*aDevice*/, TInt aError)
+	{
+	iParent->InfoMessage(_L("MdvppInitializeComplete()"));
+	iError = aError;
+	if (iError == KErrNone)
+		{
+		iParent->InfoMessage(_L("The Hw Device Adapter initialised correctly"));
+		SetState(EHwDeviceStartDecode);
+		}
+	else
+		{
+		iParent->InfoMessage(_L("Failure intialising the hw device adapter"));
+		SetState(EHwDeviceError);
+		}
+	}
+	
+void CPlayVideoFileCov::MdvppStreamEnd()
+	{
+	iParent->InfoMessage(_L("MdvppStreamEnd()"));
+	SetState(EHwDeviceDone);
+	}
+
+void CPlayVideoFileCov::StartDirectScreenAccessL()
+	{
+	TRegionFix<KTRegionFixSize> reg;
+	TRect pos(iFrameSize);
+	reg.AddRect(pos);
+	iVideoHwDevice->StartDirectScreenAccessL(pos, *iScreenDevice, reg);
+	iParent->InfoMessage(_L("Pause"));
+	TRAP(iError, iVideoHwDevice->Pause() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("Pause Failed"));
+		SetState(EHwDeviceError);
+		}
+	iParent->InfoMessage(_L("Resume"));
+	TRAP(iError, iVideoHwDevice->Resume() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("Resume Failed"));
+		SetState(EHwDeviceError);
+		}
+	RRegion region;
+	iParent->InfoMessage(_L("SetScreenClipRegion"));
+	TRAP(iError, iVideoHwDevice->SetScreenClipRegion(region) );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("SetScreenClipRegion Failed"));
+		SetState(EHwDeviceError);
+		}
+	}
+void CPlayVideoFileCov::CancelTimedSnapshot()
+	{
+iParent->InfoMessage(_L("CancelTimedSnapshot"));
+TRAP(iError, iVideoHwDevice->CancelTimedSnapshot() );
+if (iError!=KErrNone)
+	{
+	iParent->InfoMessage(_L("CancelTimedSnapshot Failed"));
+	SetState(EHwDeviceError);
+	}
+}
+
+void CPlayVideoFileCov::GetTimedSnapshot1()
+	{
+TPictureData* pictureData=NULL;
+TUncompressedVideoFormat format;
+TTimeIntervalMicroSeconds presentationTimestamp;
+iParent->InfoMessage(_L("GetTimedSnapshotL"));
+TRAP(iError, iVideoHwDevice->GetTimedSnapshotL(pictureData,format,presentationTimestamp) );
+if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("GetTimedSnapshotL Failed"));
+		SetState(EHwDeviceError);
+		}
+
+	}
+
+void CPlayVideoFileCov::GetTimedSnapshot2()
+	{
+TPictureData* pictureData=NULL;
+TUncompressedVideoFormat format;
+TPictureId pictureId;
+iParent->InfoMessage(_L("GetTimedSnapshotL"));
+TRAP(iError, iVideoHwDevice->GetTimedSnapshotL(pictureData,format,pictureId) );
+if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("GetTimedSnapshotL Failed"));
+		SetState(EHwDeviceError);
+		}
+
+	}
+
+void CPlayVideoFileCov::GetSupportedSnapshotFormats()
+	{
+RArray<TUncompressedVideoFormat> formats;
+iParent->InfoMessage(_L("GetSupportedSnapshotFormatsL"));
+TRAP(iError, iVideoHwDevice->GetSupportedSnapshotFormatsL(formats) );
+if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("GetSupportedSnapshotFormatsL Failed"));
+		SetState(EHwDeviceError);
+		}
+
+	}
+
+
+
+void CPlayVideoFileCov::NegTests()
+	{
+	//call PlayBackPosition Before initializing iFrameRate
+	TRAP(iError, iVideoHwDevice->PlaybackPosition() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("PlaybackPosition Failed"));
+		
+		}
+	//call DecodingPosition Before initializing iFrameRate
+	TRAP(iError, iVideoHwDevice->DecodingPosition() );
+	if (iError!=KErrNone)
+		{
+		iParent->InfoMessage(_L("DecodingPosition Failed"));
+		
+		}
+	
+	//call StartDirectScreenAccess before DSA is enabled
+	TRegionFix<KTRegionFixSize> reg;
+	TRect pos(iFrameSize);
+	reg.AddRect(pos);
+	
+	TRAP(iError, iVideoHwDevice->StartDirectScreenAccessL(pos, *iScreenDevice, reg) );
+	if (iError!=KErrNotReady)
+		{
+		iParent->InfoMessage(_L("StartDirectScreenAccessL Failed"));
+		
+		}
+	TUncompressedVideoFormat reqFormat;
+	reqFormat.iDataFormat = ERgbFbsBitmap;
+	reqFormat.iRgbFormat = EFbsBitmapColor16M;
+	
+	
+	
+	iParent->InfoMessage(_L("Call VideoHwDevice->SetOutputFormat()"));
+	
+	TRAP(iError, iVideoHwDevice->SetOutputFormatL(reqFormat) );
+	if (iError!=KErrNotReady)
+		{
+		iParent->InfoMessage(_L("SetOutputFormatL Failed"));
+		
+		}
+	
+	
+	
+
+	//Call initialize without settting output format
+	//Negative Test to improve code coverage
+	iVideoHwDevice->Initialize();
+	iVideoHwDevice->IsPlaying();
+	Cancel(); //Cancel pending requests
+	
+	
+	
+
+	}
+
+void CPlayVideoFileCov::InitializeCov1()
+	{
+	
+	
+	//Negative test for Buffer Options
+	CMMFDevVideoPlay::TBufferOptions bufferOptions;
+	bufferOptions.iMaxInputBufferSize=0x40000;
+	bufferOptions.iPreDecoderBufferPeriod=1;
+	TRAP(iError, iVideoHwDevice->SetBufferOptionsL(bufferOptions); );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetBufferOptionsL Failed"));
+		
+		}
+	bufferOptions.iPreDecoderBufferPeriod=0;
+	bufferOptions.iMaxPostDecodeBufferSize=1;
+	TRAP(iError, iVideoHwDevice->SetBufferOptionsL(bufferOptions); );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetBufferOptionsL Failed"));
+		
+		}
+	bufferOptions.iMaxPostDecodeBufferSize=0;
+	bufferOptions.iPostDecoderBufferPeriod=1;
+	TRAP(iError, iVideoHwDevice->SetBufferOptionsL(bufferOptions); );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetBufferOptionsL Failed"));
+		
+		}
+	bufferOptions.iPostDecoderBufferPeriod=0;
+	bufferOptions.iMaxInputBufferSize=KVideoDecoderMaxDataBufferSize+1;
+	TRAP(iError, iVideoHwDevice->SetBufferOptionsL(bufferOptions); );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetBufferOptionsL Failed"));
+		
+		}
+	bufferOptions.iMaxInputBufferSize=0;
+	bufferOptions.iMinNumInputBuffers=KMinInputBuffers;
+	TRAP(iError, iVideoHwDevice->SetBufferOptionsL(bufferOptions); );
+	if (iError!=KErrNotSupported)
+		{
+		iParent->InfoMessage(_L("SetBufferOptionsL Failed"));
+		
+		}
+	//Call SetVideoDest before iFormat has been set
+	iParent->InfoMessage(_L("Call VideoHwDevice SetVideoDestScreenL()"));
+	TRAP(iError, iVideoHwDevice->SetVideoDestScreenL(ETrue); );
+	if (iError!=KErrNotReady)
+		{
+		iParent->InfoMessage(_L("SetVideoDestScreenL Failed"));
+		
+		}
+	
+	
+	//SetOutputFormat which is not supported
+	TUncompressedVideoFormat reqFormat;
+	reqFormat.iDataFormat = ERgbRawData;
+	reqFormat.iRgbFormat = EFbsBitmapColor16M;
+
+	RArray<TUncompressedVideoFormat> decodeFormats;
+	TRAP(iError,iVideoHwDevice->GetOutputFormatListL(decodeFormats));
+	CleanupClosePushL(decodeFormats);
+	User::LeaveIfError(decodeFormats.Find(reqFormat));
+
+	iParent->InfoMessage(_L("Call VideoHwDevice->SetOutputFormat()"));
+	TRAP(iError, iVideoHwDevice->SetOutputFormatL(reqFormat) );
+	if (iError!=KErrNotReady)
+		{
+		iParent->InfoMessage(_L("SetOutputFormatL Failed"));
+		
+		}
+	//Call WriteCodedDataL with a NULL buffer
+	TVideoInputBuffer* inputBuffer=NULL;
+	iParent->InfoMessage(_L("Call VideoHwDevice->WriteCodedDataL()"));
+	TRAP(iError, iVideoHwDevice->WriteCodedDataL(inputBuffer) );
+	if (iError!=KErrArgument)
+		{
+		iParent->InfoMessage(_L("WriteCodedDataL Failed"));
+		
+		}
+	CleanupStack::PopAndDestroy(&decodeFormats);	
+	
+	iVideoHwDevice->Initialize();
+	
+	Cancel();
+
+	}
+
+void CPlayVideoFileCov::InitializeCov2()
+	{
+	
+	
+	
+	TUncompressedVideoFormat reqFormat;
+	reqFormat.iDataFormat = ERgbRawData;
+	reqFormat.iRgbFormat = EFbsBitmapColor16M;
+	
+	RArray<TUncompressedVideoFormat> decodeFormats;
+	TRAP(iError,iVideoHwDevice->GetOutputFormatListL(decodeFormats));
+	CleanupClosePushL(decodeFormats);
+	User::LeaveIfError(decodeFormats.Find(reqFormat));
+
+	iParent->InfoMessage(_L("Call VideoHwDevice->SetOutputFormat()"));
+	iVideoHwDevice->SetOutputFormatL(reqFormat);
+	CleanupStack::PopAndDestroy(&decodeFormats);	
+	
+	iVideoHwDevice->Initialize();
+
+	}
+	
+
+