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