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