// Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// TestDevVideoPlay.cpp

// 

//

#include "TestDevVideoPlay.h"

#include "TestDevVideoPlayTestData.h"

#include "TestDevVideoPlugins/decoder.h"

#include "TestDevVideoPlugins/postproc.h"

#include <e32math.h>

const TInt KTestScreenCount = 2;

// DevVideoPlay base class

const TUid KUidMDFVideoDecoderHwDeviceAdapter = { 0x102737ED };

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

	{

	// store the name of this test case

	// this is the name that is used by the script file

	// Each test step initialises it's own name

	iTestStepName = aTestName;		

	iTestType = aTestType;		// included in case needed in future

	}

CTestDevVideoPlayStep::~CTestDevVideoPlayStep() 

	{

	delete iDevVideoPlay;

	}

TVerdict CTestDevVideoPlayStep::DoTestStepL()

	{

	// construct DevVideoPlay object

	__UHEAP_MARK;

	TRAPD(err, iDevVideoPlay = CMMFDevVideoPlay::NewL(*this));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Could not create a CMMFDevVideoPlay class!"));

		return EInconclusive;

		}

	TVerdict ret = EFail;

	// call the test step

	ret = DoTestL(*iDevVideoPlay);

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

	delete iDevVideoPlay;

	iDevVideoPlay = NULL;

	__MM_HEAP_MARKEND;

	if(iError != KErrNone)

		ERR_PRINTF2( _L("CMMFDevVideoPlay failed with error %d"), iError );

	return ret;

	}

// MMMFDevVideoPlayObserver

void CTestDevVideoPlayStep::MdvpoNewBuffers()

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewBuffers()"));

	}

void CTestDevVideoPlayStep::MdvpoReturnPicture(TVideoPicture* /*aPicture*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReturnPicture()"));

	}

void CTestDevVideoPlayStep::MdvpoSupplementalInformation(const TDesC8& /*aData*/, 

								  const TTimeIntervalMicroSeconds& /*aTimestamp*/, 

								  const TPictureId& /*aPictureId*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSupplementalInformation()"));

	}

void CTestDevVideoPlayStep::MdvpoPictureLoss()

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss()"));

	}

void CTestDevVideoPlayStep::MdvpoPictureLoss(const TArray<TPictureId>& /*aPictures*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoPictureLoss(TArray)"));

	}

void CTestDevVideoPlayStep::MdvpoSliceLoss(TUint /*aFirstMacroblock*/, TUint /*aNumMacroblocks*/, const TPictureId& /*aPicture*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoSliceLoss()"));

	}

void CTestDevVideoPlayStep::MdvpoReferencePictureSelection(const TDesC8& /*aSelectionData*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoReferencePictureSelection()"));

	}

void CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete(TInt /*aError*/, 

								TPictureData* /*aPictureData*/, 

								const TTimeIntervalMicroSeconds& /*aPresentationTimestamp*/, 

								const TPictureId& /*aPictureId*/)

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoTimedSnapshotComplete()"));

	}

void CTestDevVideoPlayStep::MdvpoNewPictures()

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoNewPictures()"));

	}

void CTestDevVideoPlayStep::MdvpoFatalError(TInt aError)

	{

	iError = aError;

	INFO_PRINTF2(_L("CTestDevVideoPlayStep::MdvpoFatalError():  Error = %d"), aError);

	}

void CTestDevVideoPlayStep::MdvpoInitComplete(TInt aError)

	{

	iError = aError;

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

	}

void CTestDevVideoPlayStep::MdvpoStreamEnd()

	{

	INFO_PRINTF1(_L("CTestDevVideoPlayStep::MdvpoStreamEnd()"));

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlayCommonFormat::DoTestL(CMMFDevVideoPlay& /*aDevVideoPlay*/)

	{

	TVerdict ret = EPass;

	TBool expErr = ETrue;

	INFO_PRINTF1(_L("CMMFDevVideoPlay:  Find common format"));

	// expected results

	if (iTestType != ETestValid)

		{

		ERR_PRINTF1(_L("Error - invalid test step type"));

		return EInconclusive;

		}

	// make a fake list of formats

	RArray<TUncompressedVideoFormat> vFormats1;

	RArray<TUncompressedVideoFormat> vFormats2;

	TUncompressedVideoFormat commonFormat;

	TUncompressedVideoFormat otherFormat;

	// push arrays to cleanup stack

	CleanupClosePushL(vFormats1);

	CleanupClosePushL(vFormats2);

	// setup vFormats1 

	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));

	User::LeaveIfError(vFormats1.Append(KTestVidFormat2));

	// setup vFormats2

	User::LeaveIfError(vFormats2.Append(KTestVidFormat2));

	User::LeaveIfError(vFormats2.Append(KTestVidFormat3));

	TArray<TUncompressedVideoFormat> t1 = vFormats1.Array();

	TArray<TUncompressedVideoFormat> t2 = vFormats2.Array();

	TBool formatFound = EFalse;

	// attempt to find a common format

	formatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, commonFormat);

	// now attempt to find a common format that doesn't exist

	vFormats1.Reset();

	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));

	User::LeaveIfError(vFormats1.Append(KTestVidFormat1));

	TBool otherFormatFound = ETrue;

	// perform search for non-existent common format

	t1 = vFormats1.Array();	// need to get Array class again

	otherFormatFound = CMMFDevVideoPlay::FindCommonFormat(t1, t2, otherFormat);

	// close the arrays

	CleanupStack::PopAndDestroy(2, &vFormats1);

	// check format

	if ( (!formatFound) || !(commonFormat == KTestVidFormat2) )

		{

		ret = EFail;

		ERR_PRINTF1(_L("Error:  No common format found..."));

		}

	else if (otherFormatFound )

		{

		ret = EFail;

		ERR_PRINTF1(_L("Error:  Found a common format when there wasn't one!"));

		}

	else

		{

		INFO_PRINTF3(_L("FindCommonFormat(), %d = %d"), formatFound, expErr);

		}

	return ret;

	}

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

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlayFindDecoders::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EFail;

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

	RArray<TUid> foundDecoders;

	CleanupClosePushL(foundDecoders);

	RArray<TUid> expectedDecoders;

	CleanupClosePushL(expectedDecoders);

	RArray<TUid> unExpectedDecoders;

	CleanupClosePushL(unExpectedDecoders);

	TInt error = KErrNone;

	TUint32 requestedPostProcType = 0;

	// Unsupported mime type

	if (!error)

		{

		requestedPostProcType = 0;

		_LIT8(KMimeType1, "VIDEO/mpeg21");

		foundDecoders.Reset();

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType1(), requestedPostProcType, foundDecoders, EFalse));

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	// Unsupported post proc type

	if (!error)

		{

		requestedPostProcType = EPpOutputCrop|EPpInputCrop;

		foundDecoders.Reset();

		_LIT8(KMimeType2, "videO/duMMy");

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType2(), requestedPostProcType, foundDecoders, EFalse));

		if (error == KErrNotFound)//we actually expect KErrNotFound here

			error = KErrNone;

		else

			error = KErrGeneral;

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	// Unsupported mime type (by exact match)

	if (!error)

		{

		_LIT8(KMimeType3, "video/H263-2000; profile=45;level=40");

		requestedPostProcType = 0;

		foundDecoders.Reset();

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType3(), requestedPostProcType, foundDecoders, ETrue));

		if (error == KErrNotFound)//we actually expect KErrNotFound here

			error = KErrNone;

		else

			error = KErrGeneral;

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	// Supported mime type (by unexact match)

	if (!error)

		{

		_LIT8(KMimeType4, "video/H263-2000; profile=1234;level=20");

		requestedPostProcType = 0;

		foundDecoders.Reset();

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType4(), requestedPostProcType, foundDecoders, EFalse));

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	// Supported mime type and post proc type (by exact match)

	if (!error)

		{

		_LIT8(KMimeType5, "video/zippyvideo");

		requestedPostProcType = EPpMirror|EPpInputCrop;

		foundDecoders.Reset();

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType5(), requestedPostProcType, foundDecoders, ETrue));

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	//Added to check that the mimetype comparison is not case sensitive

	if (!error)

		{

		_LIT8(KMimeType6, "VIDEO/ZIPPYvideo");

		requestedPostProcType = EPpMirror|EPpInputCrop;

		foundDecoders.Reset();

		expectedDecoders.Reset();

		unExpectedDecoders.Reset();

		User::LeaveIfError(expectedDecoders.Append(KUidDevVideoTestDecodeHwDevice1));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice2));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice3));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice4));

		User::LeaveIfError(unExpectedDecoders.Append(KUidDevVideoTestDecodeHwDevice5));

		INFO_PRINTF1(_L("To check that the mime type comparison is not case sensitive"));

		TRAP(error, aDevVideoPlay.FindDecodersL(KMimeType6(), requestedPostProcType, foundDecoders, ETrue));

		INFO_PRINTF2(_L("error = %d"),error);

		if (!error)

			error = CheckDecoders(foundDecoders, expectedDecoders, unExpectedDecoders);

		}

	CleanupStack::PopAndDestroy(3); //foundDecoders, expectedDecoders, unExpectedDecoders

	if (!error)

		ret = EPass;

	return ret;

	}

TInt CTestDevVideoPlayFindDecoders::CheckDecoders(const RArray<TUid>& aFoundDecoders, 

												  const RArray<TUid>& aExpectedDecoders, 

												  const RArray<TUid>& aUnExpectedDecoders)

	{

	TInt ret = KErrGeneral;

	TBool foundUnExpected = EFalse;

	TInt numberToBeFoundInExpectedDecoders = aExpectedDecoders.Count();

	for (TInt i=0; i<aFoundDecoders.Count(); i++)

		{

		TUid uidToLookFor = aFoundDecoders[i];

		for (TInt j=0; j<aExpectedDecoders.Count(); j++)

			{

			if (aExpectedDecoders[j] == uidToLookFor)

				{

				numberToBeFoundInExpectedDecoders--;

				break;//j

				}

			}

		for (TInt k=0; k<aUnExpectedDecoders.Count(); k++)

			{

			if (aUnExpectedDecoders[k] == uidToLookFor)

				{

				foundUnExpected = ETrue;

				break;//k

				}

			}

		}

	if ((!foundUnExpected) && (numberToBeFoundInExpectedDecoders==0))

		ret = KErrNone;

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlayFindPostProc::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EFail;

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

	RArray<TUid> foundPostProx;

	CleanupClosePushL(foundPostProx);

	RArray<TUid> expectedPostProx;

	CleanupClosePushL(expectedPostProx);

	RArray<TUid> unExpectedPostProx;

	CleanupClosePushL(unExpectedPostProx);

	TInt error = KErrNone;

	TUint32 requestedPostProcType = 0;	

	// First ask for post processor isn't supported

	if (!error)

		{

		requestedPostProcType = EPpInputCrop|EPpMirror|EPpScale|EPpOutputPad|EPpNoiseFilter;

		foundPostProx.Reset();

		expectedPostProx.Reset();

		unExpectedPostProx.Reset();

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));

		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));

		if (error == KErrNotFound)//we actually expect KErrNotFound here

			error = KErrNone;

		else

			error = KErrGeneral;

		if (!error)

			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);

		}

	// Next ask for all post processors

	if (!error)

		{

		requestedPostProcType = 0;

		foundPostProx.Reset();

		expectedPostProx.Reset();

		unExpectedPostProx.Reset();

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));

		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));

		if (!error)

			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);

		}

	// Next ask for a specific subset of post processors

	if (!error)

		{

		requestedPostProcType = EPpMirror;

		foundPostProx.Reset();

		expectedPostProx.Reset();

		unExpectedPostProx.Reset();

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice4));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice5));

		TRAP(error, aDevVideoPlay.FindPostProcessorsL(requestedPostProcType, foundPostProx));

		if (!error)

			error = CheckPostProx(foundPostProx, expectedPostProx, unExpectedPostProx);

		}

	// Next ask for another specific subset of post processors

	if (!error)

		{

		requestedPostProcType = EPpMirror|EPpInputCrop;

		foundPostProx.Reset();

		expectedPostProx.Reset();

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice1));

		User::LeaveIfError(expectedPostProx.Append(KUidDevVideoTestPostProcHwDevice2));

		User::LeaveIfError(unExpectedPostProx.Append(KUidDevVideoTestPostProcHwDevice3));