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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetInputCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set input crop on decoder

	TRect testRect1(KTestInputCropRectA, KTestInputCropRectB, KTestInputCropRectC, KTestInputCropRectD);

	TRAP(err, aDevVideoPlay.SetInputCropOptionsL(hwDecoder, testRect1) )

	// set input crop on post-processor

	TRect testRect2(KTestInputCropRectD, KTestInputCropRectC, KTestInputCropRectB, KTestInputCropRectA);

	TRAP(err2, aDevVideoPlay.SetInputCropOptionsL(hwPostProc, testRect2) )

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetInputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetInputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetInputCropOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetYuvToRgbOptionsFormat::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set YUV to RGB options with formats on decoder

	TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1, KTestYuvFormat1, KTestRgbFormat1) );

	// set YUV to RGB options with formats on post-processor

	TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2, KTestYuvFormat2, KTestRgbFormat2) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetYuvToRgbOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set YUV to RGB options with formats on decoder

	TRAP(err, aDevVideoPlay.SetYuvToRgbOptionsL(hwDecoder, KTestYuvToRgb1) );

	// set YUV to RGB options with formats on post-processor

	TRAP(err2, aDevVideoPlay.SetYuvToRgbOptionsL(hwPostProc, KTestYuvToRgb2) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetYuvToRgbOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetYuvToRgbOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetRotate::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set rotate options on decoder

	TRAP(err, aDevVideoPlay.SetRotateOptionsL(hwDecoder, KTestRotate1) );

	// set rotate options on post-processor

	TRAP(err2, aDevVideoPlay.SetRotateOptionsL(hwPostProc, KTestRotate2) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetRotateOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetRotateOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetRotateOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetScale::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set scale options on decoder

	TSize testScale1(KTestScaleX, KTestScaleY);

	TRAP(err, aDevVideoPlay.SetScaleOptionsL(hwDecoder, testScale1, ETrue) );

	TSize testScale2(KTestScaleY, KTestScaleX);

	// set scale options on post-processor

	TRAP(err2, aDevVideoPlay.SetScaleOptionsL(hwPostProc, testScale2, ETrue) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetScaleOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetScaleOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetScaleOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetCrop::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set output crop options on decoder

	TRect testRect1(KTestOutputCropRectA, KTestOutputCropRectB, KTestOutputCropRectC, KTestOutputCropRectD);

	TRAP(err, aDevVideoPlay.SetOutputCropOptionsL(hwDecoder, testRect1) );

	// set output crop options on post-processor

	TRect testRect2(KTestOutputCropRectD, KTestOutputCropRectC, KTestOutputCropRectB, KTestOutputCropRectA);

	TRAP(err2, aDevVideoPlay.SetOutputCropOptionsL(hwPostProc, testRect2) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetOutputCropOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetOutputCropOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetOutputCropOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetPostProcOptions::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

	TInt expErr = KErrNone;

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

	// expected results

	if (iTestType != ETestValid)

		{

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

		return EInconclusive;

		}

	TInt err = KErrNone;

	TInt err2 = KErrNone;

	THwDeviceId hwDecoder = 0;

	THwDeviceId hwPostProc = 0;

	// select decoder

	TRAP(err, hwDecoder = aDevVideoPlay.SelectDecoderL(KUidDevVideoTestDecodeHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize decoder"));

			return EInconclusive;

		}

	// select post-processor

	TRAP(err, hwPostProc = aDevVideoPlay.SelectPostProcessorL(KUidDevVideoTestPostProcHwDevice));

	if (err != KErrNone)

		{

		ERR_PRINTF1(_L("Error - couldn't initialize post processor"));

			return EInconclusive;

		}

	// set post-processor options on decoder

	TRAP(err, aDevVideoPlay.SetPostProcSpecificOptionsL(hwDecoder, KTestPostProcOptions1) );

	// set post-processor options on post-processor

	TRAP(err2, aDevVideoPlay.SetPostProcSpecificOptionsL(hwPostProc, KTestPostProcOptions2) );

	if ((err != expErr) || (err2 != expErr))

		{

		ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Decoder gave error %d (expected %d)"),err, expErr);

		ERR_PRINTF3(_L("SetPostProcSpecificOptionsL() on Post-Processor gave error %d (expected %d)"),err2, expErr);

		ret = EFail;

		}

	else

		INFO_PRINTF4(_L("SetPostProcSpecificOptionsL(), %d, %d= %d"), err, err2, expErr);

	return ret;

	}

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

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

	:CTestDevVideoPlayStep(aTestName, aTestType)

	{

	}

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

	{

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

	return self;

	}

TVerdict CTestDevVideoPlaySetClockSource::DoTestL(CMMFDevVideoPlay& aDevVideoPlay)

	{

	TVerdict ret = EPass;

//	TInt expErr = KErrNone;

	TBool selDec = ETrue;

	TBool selPost = ETrue;

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

	// expected results

	switch(iTestType)

		{

		case ETestValid:

//			expErr = KErrNone;	// EABI warning removal

			break;

		case ETestDecoderOnly:

			selPost = EFalse;

			break;

		case ETestPostProcOnly: