// Copyright (c) 2008-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:

//

#ifndef TSU_3GPLIBRARY_COMPOSER_API_H

#define TSU_3GPLIBRARY_COMPOSER_API_H

#include <test/testexecutestepbase.h>

#include <c3gplibrary.h>

class CActiveScheduler;

//

// Base class for testing composer.  Provides a framework for:

//

// 1. Setup

// 2. Add video/audio data

// 3. Add user data

//

class C3GPLibComposeBase : public CTestStep

	{

	public:

		C3GPLibComposeBase();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();

		TVerdict doTestStepL();

	protected:		

		virtual C3GPCompose* doTestStepCreateComposerL();

		virtual void doTestStepComposeOpenL(C3GPCompose& aComposer) = 0;

		// default to do nothing & return the current test result

		virtual void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);		

		virtual void doTestStepComposeSetUserDataL(C3GPCompose& aComposer);		

	private:

		CActiveScheduler* iScheduler;

	};

//

// Setup a composer via filepath supplied by the configuration file

// 

_LIT(K3GPComposeFilename, "3GPComposeFilename");

class C3GPLibComposeFilename : public C3GPLibComposeBase

	{

	public:

		C3GPLibComposeFilename();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	protected:

		virtual void doTestStepComposeOpenL(C3GPCompose& aComposer);

	protected:

		RBuf iFilename;

	};

//

// Class to test execution of composer APIs without any setup.

//

_LIT(K3GPComposeWithoutOpen, "3GPComposeWithoutOpen");

class C3GPLibComposeWithoutOpen : public C3GPLibComposeBase

	{

	public:

		C3GPLibComposeWithoutOpen();

	private:

		// virtual functions overriding base class implementations

		void doTestStepComposeOpenL(C3GPCompose& aComposer);		

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);		

		void doTestStepComposeSetUserDataL(C3GPCompose& aComposer);				

	};

//

// Class to test composer with video/audio properties supplied by 

// the configuration file.

//

_LIT(K3GPComposeFile, "3GPComposeFile");

class C3GPLibComposeFile : public C3GPLibComposeBase

	{

	public:

		C3GPLibComposeFile();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	protected:

		virtual void doTestStepComposeOpenL(C3GPCompose& aComposer);		

		virtual void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);

		T3GPVideoPropertiesBase* SetupVideoPropertiesL();

		virtual T3GPVideoPropertiesBase* SetupAvcVideoL();

		virtual T3GPVideoPropertiesBase* SetupH263VideoL();

		virtual T3GPVideoPropertiesBase* SetupMpeg4VideoL();

		T3GPAudioPropertiesBase* SetupAudioPropertiesL();

		virtual T3GPAudioPropertiesBase* SetupQcelpAudioL();

		virtual T3GPAudioPropertiesBase* SetupAmrAudioL();

		virtual T3GPAudioPropertiesBase* SetupMpeg4AudioL();		

	protected:

		T3GPFileFormatType iInputFileFormat;	// requested file format

		T3GPVideoType iVideoType;

		T3GPAudioType iAudioType;

		RFs iFs;

		RFile iFile;

		RBuf iFileName;

		RFile64 iFile64;		

	};

//

// Class to compose file conforms to the expected file format as supplied by 

// the test configuration.

//

_LIT(K3GPComposeFileWithFileFormatCheck, "3GPComposeFileWithFileFormatCheck");

class C3GPLibComposeFileWithFileFormatCheck : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeFileWithFileFormatCheck();

		TVerdict doTestStepPreambleL();		

		TVerdict doTestStepL();	

	private:

		TVerdict VerifyFileFormatL(const RFile& aFile);

	private:

		T3GPFileFormatType iOutputFileFormat;	// expected file format		

	};

//

// Class to compose file with video frames of all possible combinations of different 

// dependencies 

//

_LIT(K3GPComposeFrameDependency, "3GPComposeFrameDependency");

class C3GPLibComposeFrameDependency : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeFrameDependency();

	private:

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);

	};

//

// Class to compose file with video properties as specified in the test

// configuration

//

_LIT(K3GPComposeVideoProperties, "3GPComposeVideoProperties");

class C3GPLibComposeVideoProperties : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeVideoProperties();		

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	private:

		virtual T3GPVideoPropertiesBase* SetupAvcVideoL();

		virtual T3GPVideoPropertiesBase* SetupH263VideoL();

		virtual T3GPVideoPropertiesBase* SetupMpeg4VideoL();

	private:

		TSize iSize;

		TUint iMaxBitRate;

		TUint iAvgBitRate;

		RBuf8 iDecoderSpecInfo;

		TUint iTimescale;

		TInt iVideoLevel;

	};

//

// Class to compose file with audio properties as specified in the test

// configuration

//

_LIT(K3GPComposeAudioProperties, "3GPComposeAudioProperties");

class C3GPLibComposeAudioProperties : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeAudioProperties();		

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	private:

		T3GPAudioPropertiesBase* SetupQcelpAudioL();

		T3GPAudioPropertiesBase* SetupAmrAudioL();

		T3GPAudioPropertiesBase* SetupMpeg4AudioL();		

	private:

		TInt iFps;

		RBuf8 iDecoderSpecInfo;

		TInt iTimescale;

		T3GPQcelpStorageMode iQCelpMode;

		TInt iModeSet;		

	};

//

// Class to create composer using buffer sizes and counts specified by test

// configuration

//

_LIT(K3GPComposeWithSpecificBufferSize, "3GPComposeWithSpecificBufferSize");

class C3GPLibComposeWithSpecificBufferSize : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeWithSpecificBufferSize();		

		TVerdict doTestStepPreambleL();		

	private:

		C3GPCompose* doTestStepCreateComposerL();

	private:

		TInt iBufferSize;

		TInt iBufferMaxCount;

	};

//

// Class to compose file with user data as specified by the test 

// configuration

//

_LIT(K3GPComposeUserData, "3GPComposeUserData");

class C3GPLibComposeUserData : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeUserData();	

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();

	private:	

		void doTestStepComposeSetUserDataL(C3GPCompose& aComposer);

	private:

		RBuf8 iUserData;		

		TBool iUdtaMoov;

		TBool iUdtaVideo;

		TBool iUdtaAudio;	

		TInt  iUdtaLocation;

	};

//

// Class to compose file using different composer flags as specified in the test 

// configuration

//

_LIT(K3GPComposeWithFlag, "3GPComposeWithFlag");

class C3GPLibComposeWithFlag : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeWithFlag();

		TVerdict doTestStepPreambleL();

	protected:	

		virtual void doTestStepComposeOpenL(C3GPCompose& aComposer);

	protected:

		TInt iComposeFlag;

	};

//

// Class to compose file specifying no video nor audio.

//

_LIT(K3GPComposeWithNoAudioVideo, "3GPComposeWithNoAudioVideo");

class C3GPLibComposeWithNoAudioVideo : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeWithNoAudioVideo();

		TVerdict doTestStepPreambleL();		

	};

//

// Class to compose file with audio frames of properties specified by test

// configuration

//

_LIT(K3GPComposeAudioFrames, "3GPComposeAudioFrames");

class C3GPLibComposeAudioFrames : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeAudioFrames();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	private:

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);		

	private:

		TInt iDuration;

		RBuf8 iAudioFrames;

	};

//

// Class to compose file with video frames of properties specified by test

// configuration

//

_LIT(K3GPComposeVideoFrame, "3GPComposeVideoFrame");

class C3GPLibComposeVideoFrame : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeVideoFrame();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	private:

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);		

	private:

		TBool iKeyFrame;

		TInt iDuration;

		RBuf8 iVideoFrame;

		T3GPFrameDependencies* iDependencies;

	};

//

// Class to open the composer again before closing it

//

_LIT(K3GPComposeOpenAgain, "3GPComposeOpenAgain");

class C3GPLibComposeOpenAgain: public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeOpenAgain();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to setup composer with a Read-Only file via file handle

//

_LIT(K3GPComposeOpenReadOnlyFile, "3GPComposeOpenReadOnlyFile");

class C3GPLibComposeOpenReadOnlyFile: public C3GPLibComposeWithFlag

	{

	public:

		C3GPLibComposeOpenReadOnlyFile();		

		TVerdict doTestStepL();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to setup composer using file path of an opened file using 

// ShareAny and then ShareReadersOrWriters mode.

//

_LIT(K3GPComposeOpenedFile, "3GPComposeOpenedFile");

class C3GPLibComposeOpenedFile: public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeOpenedFile();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to use 2 composer opening the same file 

//

_LIT(K3GPComposeMultiComposeOnSameFile, "3GPComposeMultiComposeOnSameFile");

class C3GPLibComposeMultiComposeOnSameFile : public C3GPLibComposeFilename

	{

	public:

		C3GPLibComposeMultiComposeOnSameFile();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to have multiple composers / parser working at the same time 

//

_LIT(K3GPComposeMultiComposers, "3GPComposeMultiComposers");

class C3GPLibComposeMultiComposers : public C3GPLibComposeFilename

	{

	public:

		C3GPLibComposeMultiComposers();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to compose file without calling complete first 

//

_LIT(K3GPComposeCloseComposerWithoutComplete, "3GPComposeCloseComposerWithoutComplete");

class C3GPLibComposeCloseComposerWithoutComplete : public C3GPLibComposeFilename

	{

	public:

		C3GPLibComposeCloseComposerWithoutComplete();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	};

//

// Class to test cleanup of temporary files when composer panics    

//

_LIT(K3GPComposePanic, "3GPComposePanic");

class C3GPLibComposePanic : public C3GPLibComposeFilename

	{

	public:

		C3GPLibComposePanic();

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();

	private:

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

	private:

		TBool iPanic;

		RBuf iDir;

	};

//

// Class to compose a large file >2GB

//

_LIT(K3GPComposeLargeFile, "3GPComposeLargeFile");

class C3GPLibComposeLargeFile : public C3GPLibComposeFile

	{

	public:

		C3GPLibComposeLargeFile();		

		TVerdict doTestStepPreambleL();

		TVerdict doTestStepPostambleL();	

	private:

		C3GPCompose* doTestStepCreateComposerL();

		void doTestStepComposeOpenL(C3GPCompose& aComposer);

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);	

	private:

		TInt iComposeFlag;

	};

//

// Class to compose a large file >2GB with user data

//

_LIT(K3GPComposeLargeFileUserData, "3GPComposeLargeFileUserData");

class C3GPLibComposeLargeFileUserData : public C3GPLibComposeLargeFile

	{

	public:

		C3GPLibComposeLargeFileUserData();		

	private:

		void doTestStepComposeSetUserDataL(C3GPCompose& aComposer);

		void WriteInt32(TUint8* aPtr, TInt32 aData);	

	private:

	};

//

// Class to compose a large file >2GB using 32bit APIs

//

_LIT(K3GPComposeLargeFile32bitAPI, "3GPComposeLargeFile32bitAPI");

class C3GPLibComposeLargeFile32bitAPI : public C3GPLibComposeWithFlag

	{

	public:

		C3GPLibComposeLargeFile32bitAPI();		

	private:

		C3GPCompose* doTestStepCreateComposerL();

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);	

	private:

	};

//

// Class to compose a large file on an mmc card until the disk is full

//

_LIT(K3GPComposeLargeFileDiskFull, "3GPComposeLargeFileDiskFull");

class C3GPLibComposeLargeFileDiskFull : public C3GPLibComposeLargeFile

	{

	public:

		C3GPLibComposeLargeFileDiskFull();		

	private:

		void doTestStepComposeWriteVideoAudioL(C3GPCompose& aComposer);

	private:

	};

//

// Class to compose file with AVC video that conforms to the expected AVC profile.

//

_LIT(K3GPComposeFileWithAvcProfileCheck, "3GPComposeFileWithAvcProfileCheck");

class C3GPLibComposeFileWithAvcProfileCheck : public C3GPLibComposeFile

    {

    public:

        C3GPLibComposeFileWithAvcProfileCheck();

        virtual T3GPVideoPropertiesBase* SetupAvcVideoL();

        TVerdict doTestStepL(); 

    private:

        TVerdict VerifyAvcProfileL(const RFile& aFile);

    private:

        TBuf8<7> iAvcDecoderConfigRecord;

    };

#endif // TSU_3GPLIBRARY_COMPOSER_API_H