// 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 CTestDevVideoPlayGetNewPictureInfo::MdvpoInitComplete(TInt aError)

	{

	INFO_PRINTF2(_L("CTestDevVideoPlayGetNewPictureInfo::MdvpoInitComplete():  Error = %d"), aError);

	iError = aError;

	}

CTestDevVideoPlayGetNewPictureInfo::CTestDevVideoPlayGetNewPictureInfo(const TDesC& aTestName, TTestType aTestType)

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

CTestDevVideoPlayGetNewPictureInfo* CTestDevVideoPlayGetNewPictureInfo::NewL(const TDesC& aTestName, TTestType aTestType)

	{

	CTestDevVideoPlayGetNewPictureInfo* self = new(ELeave) CTestDevVideoPlayGetNewPictureInfo(aTestName, aTestType);

	return self;

	}

TVerdict CTestDevVideoPlayGetNewPictureInfo::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EFail;

	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetNewPictureInfo"));

	// 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;

		}

	//Tell plugin to start creating pictures.

	TRAP(iError, aDevVideoPlay.SetVideoDestScreenL(EFalse));

	if (iError != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't SetVideoDestScreen"));

			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;

		}

	aDevVideoPlay.Start();

	TUint numPictures = 0;

	TTimeIntervalMicroSeconds earliestTimeStamp(0);

	TTimeIntervalMicroSeconds latestTimeStamp(0);

	aDevVideoPlay.GetNewPictureInfo(numPictures, earliestTimeStamp, latestTimeStamp);

	if ((numPictures == 1)

		&& (earliestTimeStamp == TTimeIntervalMicroSeconds(0))

		&& (latestTimeStamp == TTimeIntervalMicroSeconds(0)))

		{

		ret = EPass;

		}

	return ret;

	}

//------------------------------------------------------------------

void CTestDevVideoPlayNextPicture::MdvpoInitComplete(TInt aError)

	{

	INFO_PRINTF2(_L("CTestDevVideoPlayNextPicture::MdvpoInitComplete():  Error = %d"), aError);

	iError = aError;

	}

CTestDevVideoPlayNextPicture::CTestDevVideoPlayNextPicture(const TDesC& aTestName, TTestType aTestType)

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

CTestDevVideoPlayNextPicture* CTestDevVideoPlayNextPicture::NewL(const TDesC& aTestName, TTestType aTestType)

	{

	CTestDevVideoPlayNextPicture* self = new(ELeave) CTestDevVideoPlayNextPicture(aTestName, aTestType);

	return self;

	}

TVerdict CTestDevVideoPlayNextPicture::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	INFO_PRINTF1(_L("CMMFDevVideoPlay:  NextPicture"));

	// 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;

		}

	//Tell plugin to start creating pictures.

	TRAP(iError, aDevVideoPlay.SetVideoDestScreenL(EFalse));

	if (iError != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't SetVideoDestScreen"));

			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;

		}

	iDevVideoPlay = &aDevVideoPlay;

	aDevVideoPlay.Start();//Tell plugin to start creating pictures.

	// We should now get a series of NewPicture() callbacks.

	if (iError == KErrNone)

		{

		ret = EPass;

		}

	else

		{

		ERR_PRINTF2(_L("Error - picture processing failed with error %d"), iError);

		}

	return ret;

	}

void CTestDevVideoPlayNextPicture::MdvpoNewPictures()

	{

	TRAP(iError, DoNewPicturesL());

	}

void CTestDevVideoPlayNextPicture::CheckNewPictureInfoL(TUint aNumPictures, const TTimeIntervalMicroSeconds& aFirst, const TTimeIntervalMicroSeconds& aLast)

	{

	TUint numPictures = 0;

	TTimeIntervalMicroSeconds first(0);

	TTimeIntervalMicroSeconds last(0);

	iDevVideoPlay->GetNewPictureInfo(numPictures, first, last);

	if ((numPictures!=aNumPictures) || (first!=aFirst) || (last!=aLast))

		{

		User::Leave(KErrGeneral);

		}

	}

void CTestDevVideoPlayNextPicture::DoNewPicturesL()

	{

	User::LeaveIfError(iError);//Don't go any further if we have an error

	switch (iCurrentPictureNumber)

		{

		case 0:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 1:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(1), TTimeIntervalMicroSeconds(1));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 2:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(2), TTimeIntervalMicroSeconds(2));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 3:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(3), TTimeIntervalMicroSeconds(3));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 4:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(4), TTimeIntervalMicroSeconds(4));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 5:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(5), TTimeIntervalMicroSeconds(5));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			break;

			}

		case 6:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(6));

			break;

			}

		case 7:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(2, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(7));

			break;

			}

		case 8:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(3, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(8));

			break;

			}

		case 9:

			{

			iCurrentPictureNumber++;

			CheckNewPictureInfoL(4, TTimeIntervalMicroSeconds(6), TTimeIntervalMicroSeconds(9));

			TVideoPicture* picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			CheckNewPictureInfoL(3, TTimeIntervalMicroSeconds(7), TTimeIntervalMicroSeconds(9));

			picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			CheckNewPictureInfoL(2, TTimeIntervalMicroSeconds(8), TTimeIntervalMicroSeconds(9));

			picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			CheckNewPictureInfoL(1, TTimeIntervalMicroSeconds(9), TTimeIntervalMicroSeconds(9));

			picture = iDevVideoPlay->NextPictureL();

			iDevVideoPlay->ReturnPicture(picture);

			CheckNewPictureInfoL(0, TTimeIntervalMicroSeconds(0), TTimeIntervalMicroSeconds(0));

			break;

			}

		default:

			User::Leave(KErrGeneral);

			break;

		};

	}

//------------------------------------------------------------------

void CTestDevVideoPlayGetSnapshot::MdvpoInitComplete(TInt aError)

	{

	INFO_PRINTF2(_L("CTestDevVideoPlayGetSnapshot::MdvpoInitComplete():  Error = %d"), aError);

	iError = aError;

	}

CTestDevVideoPlayGetSnapshot::CTestDevVideoPlayGetSnapshot(const TDesC& aTestName, TTestType aTestType)

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

CTestDevVideoPlayGetSnapshot* CTestDevVideoPlayGetSnapshot::NewL(const TDesC& aTestName, TTestType aTestType)

	{

	CTestDevVideoPlayGetSnapshot* self = new(ELeave) CTestDevVideoPlayGetSnapshot(aTestName, aTestType);

	return self;

	}

TVerdict CTestDevVideoPlayGetSnapshot::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EFail;

	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetSnapshot"));

	// 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;

		}

	TBool result = EFalse;

	TPictureData pictureData;

	TUncompressedVideoFormat format;

	format.iDataFormat = EYuvRawData;

	format.iYuvFormat = KTestYuvFormat1;

	TRAP(err, result = aDevVideoPlay.GetSnapshotL(pictureData, format));

	if (err == KErrNone)

		{

		if (result)

			{

			if ((pictureData.iDataFormat == EYuvRawData) &&

				(pictureData.iDataSize == TSize(KTestPictureDataSizeX, KTestPictureDataSizeY)) && 

				(pictureData.iRawData == NULL))

				{

				ret = EPass;

				}

			}

		}

	return ret;

	}

//------------------------------------------------------------------

void CTestDevVideoPlayGetTimedSnapshotTimestamp::MdvpoInitComplete(TInt aError)

	{

	INFO_PRINTF2(_L("CTestDevVideoPlayGetTimedSnapshotTimestamp::MdvpoInitComplete():  Error = %d"), aError);

	iError = aError;

	}

void CTestDevVideoPlayGetTimedSnapshotTimestamp::MdvpoTimedSnapshotComplete(TInt aError, 

											TPictureData* aPictureData, 

											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

											const TPictureId& /*aPictureId*/)

	{

	INFO_PRINTF2(_L("CTestDevVideoPlayGetTimedSnapshotTimestamp::MdvpoTimedSnapshotComplete():  Error = %d"), aError);

	iError = aError;

	iTimestamp = aPresentationTimestamp;

	iPictureData = aPictureData;

	}

CTestDevVideoPlayGetTimedSnapshotTimestamp::CTestDevVideoPlayGetTimedSnapshotTimestamp(const TDesC& aTestName, TTestType aTestType)

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

CTestDevVideoPlayGetTimedSnapshotTimestamp* CTestDevVideoPlayGetTimedSnapshotTimestamp::NewL(const TDesC& aTestName, TTestType aTestType)

	{

	CTestDevVideoPlayGetTimedSnapshotTimestamp* self = new(ELeave) CTestDevVideoPlayGetTimedSnapshotTimestamp(aTestName, aTestType);

	return self;

	}

TVerdict CTestDevVideoPlayGetTimedSnapshotTimestamp::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EFail;

	TInt expErr = KErrNone;

	INFO_PRINTF1(_L("CMMFDevVideoPlay:  GetTimedSnapshotTimestamp"));

	// 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;

		}

	TPictureData pictureData;

	TUncompressedVideoFormat format;

	format.iDataFormat = EYuvRawData;

	format.iYuvFormat = KTestYuvFormat1;

	TTimeIntervalMicroSeconds snapTime(KTestSnapshotTimestamp);

	// get a timed snapshot from the post processor

	TRAP(err, aDevVideoPlay.GetTimedSnapshotL(&pictureData, format, snapTime));

	// check picture and timestamp from callback

	if ((err == KErrNone) && (iError == KErrNone))

		{

		if ((iPictureData) && (iTimestamp == TTimeIntervalMicroSeconds(KTestSnapshotTimestamp)))

			{

			if ((iPictureData->iDataFormat == EYuvRawData) &&

				(iPictureData->iDataSize == TSize(KTestPictureDataSizeX, KTestPictureDataSizeY)) && 

				(iPictureData->iRawData == NULL))

				{

				ret = EPass;

				}

			else

				{

				ERR_PRINTF1(_L("Error - PictureData is corrupt!"));

				}

			}

		}

	else

		{

		ERR_PRINTF3(_L("GetTimedSnapshotL() gave error %d (expected %d)"),err, expErr);

		}

	return ret;

	}

//------------------------------------------------------------------

void CTestDevVideoPlayGetTimedSnapshotID::MdvpoInitComplete(TInt aError)