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

// Header file: DevVideoPlay tests.

// 

//

/**

 @file TestDevVideoPlay.h

*/

#ifndef __TESTDEVVIDEOPLAY_H__

#define __TESTDEVVIDEOPLAY_H__

#include "TSU_MMF_DevVideo.h"

/**

 * DevVideoPlay test base class

 *

 * @class CTestDevVideoPlayStep

 *

 * Req. under test REQ1931.3

 */

class CTestDevVideoPlayStep : public CTestDevVideoStep, public MMMFDevVideoPlayObserver

	{

public:

	CTestDevVideoPlayStep(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayStep();

	virtual TVerdict DoTestStepL();

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay) = 0;

	// MMMFDevVideoPlayObserver

    virtual void MdvpoNewBuffers();

    virtual void MdvpoReturnPicture(TVideoPicture* aPicture);

    virtual void MdvpoSupplementalInformation(const TDesC8& aData, 

											  const TTimeIntervalMicroSeconds& aTimestamp, 

											  const TPictureId& aPictureId);

	virtual void MdvpoPictureLoss();

	virtual void MdvpoPictureLoss(const TArray<TPictureId>& aPictures);

	virtual void MdvpoSliceLoss(TUint aFirstMacroblock, TUint aNumMacroblocks, const TPictureId& aPicture);

	virtual void MdvpoReferencePictureSelection(const TDesC8& aSelectionData);

    virtual void MdvpoTimedSnapshotComplete(TInt aError, 

											TPictureData* aPictureData, 

											const TTimeIntervalMicroSeconds& aPresentationTimestamp, 

											const TPictureId& aPictureId);

    virtual void MdvpoNewPictures();

    virtual void MdvpoFatalError(TInt aError);

    virtual void MdvpoInitComplete(TInt aError);

    virtual void MdvpoStreamEnd();

protected:

	TInt iError;

	TTestType iTestType;					// Type of test

	CMMFDevVideoPlay* iDevVideoPlay;

	};

//

class CTestDevVideoPlayCommonFormat : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayCommonFormat(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayCommonFormat() {};

	};

//

class CTestDevVideoPlayFindDecoders : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayFindDecoders(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayFindDecoders() {};

	TInt CheckDecoders(const RArray<TUid>& aFoundDecoders, const RArray<TUid>& aExpectedDecoders, const RArray<TUid>& aUnExpectedDecoders);

	};

//

class CTestDevVideoPlayFindPostProc : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayFindPostProc(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayFindPostProc() {};

	TInt CheckPostProx(const RArray<TUid>& aFoundPostProx, const RArray<TUid>& aExpectedPostProx, const RArray<TUid>& aUnExpectedPostProx);

	};

//

class CTestDevVideoPlayListDecoders : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayListDecoders* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayListDecoders(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayListDecoders() {};

	};

//

class CTestDevVideoPlayListPostProc : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayListPostProc* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayListPostProc(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayListPostProc() {};

	};

//

class CTestDevVideoPlayGetDecoderInfo : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayGetDecoderInfo* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayGetDecoderInfo(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayGetDecoderInfo() {};

	TBool ValidDecoderInfo(CVideoDecoderInfo* aInfo);

	};

//

class CTestDevVideoPlayGetPostProcInfo : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayGetPostProcInfo* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayGetPostProcInfo(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayGetPostProcInfo() {};

	TBool ValidPostProcInfo(CPostProcessorInfo* aInfo);

	};

//

class CTestDevVideoPlaySelectDecoder : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySelectDecoder* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySelectDecoder(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySelectDecoder() {};

	};

//

class CTestDevVideoPlaySelectPostProc : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySelectPostProc* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySelectPostProc(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySelectPostProc() {};

	};

//

class CTestDevVideoPlayGetHeaderInfo : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayGetHeaderInfo* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayGetHeaderInfo(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayGetHeaderInfo() {};

	TBool ValidPictureHeader(const TVideoPictureHeader* aPictureHeader);

	};

//

class CTestDevVideoPlayReturnHeader : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayReturnHeader* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayReturnHeader(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayReturnHeader() {};

	};

//

class CTestDevVideoPlayConfigureDecoder: public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayConfigureDecoder* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayConfigureDecoder(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayConfigureDecoder() {};

	};

//

class CTestDevVideoPlaySetInputFormatUC : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetInputFormatUC* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetInputFormatUC(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetInputFormatUC() {};

	};

//

class CTestDevVideoPlaySetInputFormat : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetInputFormat* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetInputFormat(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetInputFormat() {};

	};

//

class CTestDevVideoPlayGetOutputFormatList : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayGetOutputFormatList* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayGetOutputFormatList(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayGetOutputFormatList() {};

	};

//

class CTestDevVideoPlaySetOutputFormat : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetOutputFormat* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetOutputFormat(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetOutputFormat() {};

	};

//

class CTestDevVideoPlaySetPostProcTypes : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetPostProcTypes* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetPostProcTypes(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetPostProcTypes() {};

	};

//

class CTestDevVideoPlaySetInputCrop : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetInputCrop(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetInputCrop() {};

	};

//

class CTestDevVideoPlaySetYuvToRgbOptionsFormat : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetYuvToRgbOptionsFormat(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetYuvToRgbOptionsFormat() {};

	};

//

class CTestDevVideoPlaySetYuvToRgbOptions : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetYuvToRgbOptions(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetYuvToRgbOptions() {};

	};

//

class CTestDevVideoPlaySetRotate : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetRotate(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetRotate() {};

	};

//

class CTestDevVideoPlaySetScale : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetScale(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetScale() {};

	};

//

class CTestDevVideoPlaySetCrop : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetCrop(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetCrop() {};

	};

//

class CTestDevVideoPlaySetPostProcOptions : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetPostProcOptions(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetPostProcOptions() {};

	};

//

class CTestDevVideoPlaySetClockSource : public CTestDevVideoPlayStep

	{

public:

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

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetClockSource(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetClockSource() {};

	};

//

class CTestDevVideoPlaySetVideoOutput : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetVideoOutput* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetVideoOutput(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetVideoOutput() {};

	};

//

class CTestDevVideoPlaySynchronizeDecoding : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySynchronizeDecoding* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySynchronizeDecoding(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySynchronizeDecoding() {};

	};

//

class CTestDevVideoPlaySetBufferOptions : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetBufferOptions* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetBufferOptions(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetBufferOptions() {};

	};

//

class CTestDevVideoPlayGetBufferOptions : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayGetBufferOptions* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlayGetBufferOptions(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayGetBufferOptions() {};

	};

//

class CTestDevVideoPlaySetHrdVbv : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetHrdVbv* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

private:

	CTestDevVideoPlaySetHrdVbv(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetHrdVbv() {};

	};

//

class CTestDevVideoPlayInit : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayInit* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlayInit(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayInit() {};

	};

//

class CTestDevVideoPlayStartDSA : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayStartDSA* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlayStartDSA(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayStartDSA() {};

	};

//

class CTestDevVideoPlaySetClipRegion : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetClipRegion* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlaySetClipRegion(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetClipRegion() {};

	};

//

class CTestDevVideoPlaySetPauseClipFail : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlaySetPauseClipFail* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlaySetPauseClipFail(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlaySetPauseClipFail() {};

	};

//

class CTestDevVideoPlayAbortDSA : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayAbortDSA* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlayAbortDSA(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayAbortDSA() {};

	};

//

class CTestDevVideoPlayIsPlaying : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayIsPlaying* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlayIsPlaying(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayIsPlaying() {};

	};

//

class CTestDevVideoPlayRedraw : public CTestDevVideoPlayStep

	{

public:

	static CTestDevVideoPlayRedraw* NewL(const TDesC& aTestName, TTestType aTestType);

	virtual TVerdict DoTestL(CMMFDevVideoPlay& aDevVideoPlay);

	virtual void MdvpoInitComplete(TInt aError);

private:

	CTestDevVideoPlayRedraw(const TDesC& aTestName, TTestType aTestType);

	~CTestDevVideoPlayRedraw() {};