// Copyright (c) 2001-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: Basic  tests.
// 
//

/**
 @file TestConverter.h
*/


#ifndef TESTCONVERTER_H__
#define TESTCONVERTER_H__

#include "TSI_MMFACLNT.h"

//Original duration = 8359176 Us with 92160 bytes of 8bit per sample data + 44 header
//Window start = 2089794 Us, aligned to a frame = 1857596 Us
//Window end = 6269382 Us, aligned to a frame =6315828 Us
//Therefore window = 4179588, aligned to a frames =4458231 Us

//New file = 4458231/8359176 * 92160 * 16bits(2) + 44 = 98348
const TInt KConverterWindowFileSize = 98348;


//Add to KConverterWindowFileSize a full convert of the source file:-
//=92160 * 16bits(2) + KConverterWindowFileSize
const TInt KConverterWindowPlusNormalFileSize = 282668;


/**
 * Set config destination clip
 *
 * @class CTestMmfAclntConConfig
 *
 */
class CTestMmfAclntConConfig : public CTestMmfAclntCodecTest, public MMdaObjectStateChangeObserver 
	{
public:
	CTestMmfAclntConConfig(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative);
	static CTestMmfAclntConConfig* NewL(const TDesC& aTestName, const TTestFormat aFormat, const TBool aNegative = EFalse);
	virtual TVerdict DoTestStepL();
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	virtual TVerdict DoTestStepPreambleL();
	// from MMdaObjectStateChangeObserver
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

protected:
	virtual void GetKeyName(TDes& aDes);
protected:
	TInt iError;
	TBool iThisIsNegativeTest;
	};


/**
 * Convert WAV to AU.
 *
 * @class CTestMmfAclntDoConv
 *
 */
class CTestMmfAclntDoConv : public CTestMmfAclntStep, public MMdaObjectStateChangeObserver
	{
public:
	enum FormatSpec
	{
	MdaFormatSpec,
	MmfFormatSpec
	};



	CTestMmfAclntDoConv(const TDesC& aTestName, const TDesC& aSectName, 
		const TDesC& aKeyName, const TDesC& aSectName2, 
		const TDesC& aKeyName2, 
		TInt	aBits, FormatSpec aFormat);
	
	//aBits 0  = TMdaPcmWavCodec::E8BitPcm
	//		1  = TMdaPcmWavCodec::E16BitPcm
	//		-1  - UnsupportedCodec (negative test)
	static CTestMmfAclntDoConv* NewL(const TDesC& aTestName, 
		const TDesC& aSectName, const TDesC& aKeyName, 
		const TDesC& aSectName2, const TDesC& aKeyName2, 
		TInt aBits, FormatSpec aFormat);
	virtual TVerdict DoTestStepL();
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	// from MMdaObjectStateChangeObserver
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

protected:
	TInt iError;
	CBase* iObject;
	TInt iPreviousState;
	TInt iCurrentState;
	TBuf<KNameBufSize> iSectName;
	TBuf<KNameBufSize> iKeyName;
	TBuf<KNameBufSize> iSectName2;
	TBuf<KNameBufSize> iKeyName2;

	FormatSpec iFormat;
	TInt	iBits;
	};


/**
 * Closes an open file then opens a second file
 *
 * @class CTestMmfAclntConCloseOpen
 *
 */
class CTestMmfAclntConCloseOpen: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConCloseOpen(const TDesC& aTestName) ;
	~CTestMmfAclntConCloseOpen(){} ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConCloseOpen* NewL(const TDesC& aTestName);
	};

/**
 * Set convert window. Enquire window. Delete window
 *
 * @class CTestMmfAclntConWindow
 *
 */
class CTestMmfAclntConWindow: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConWindow(const TDesC& aTestName) ;
	~CTestMmfAclntConWindow(){} ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConWindow* NewL(const TDesC& aTestName);
protected:
	TVerdict CheckFileSize(const TDesC& aFilename, const TInt aExpectedSize);
	};


/**
 * Enquire duration
 *
 * @class CTestMmfAclntConDuration
 *
 */
class CTestMmfAclntConDuration: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConDuration(const TDesC& aTestName) ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, 
			TInt aCurrentState, TInt aErrorCode) ;
	static CTestMmfAclntConDuration* NewL(const TDesC& aTestName);
protected:
	virtual void GetKeyName(TDes& aDes);
	};

/**
 * Set position and enquire position
 *
 * @class CTestMmfAclntConPosition
 *
 */
class CTestMmfAclntConPosition: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConPosition(const TDesC& aTestName, const TTimeIntervalMicroSeconds aPosition);
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConPosition* NewL(const TDesC& aTestName, const	TTimeIntervalMicroSeconds aPosition);

protected:
	void GetKeyName(TDes& aDes);
private:
	TTimeIntervalMicroSeconds iPosition;
	};


/**
 * Set config destination clip
 *
 * @class CTestMmfAclntConQuery
 *
 */
class CTestMmfAclntConQuery: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConQuery(const TDesC& aTestName);
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConQuery* NewL(const TDesC& aTestName);
	TVerdict DoTestStepL();
protected:
	void GetKeyName(TDes& aDes);
	};

//
// NEGATIVE TESTS
//

/** 
 * Conversion utility - Delete object before conversion operation has completed.
 *
 * @class CTestMmfAclntDelete
 *
 */
class CTestMmfAclntDelete : public CTestMmfAclntStep, public MMdaObjectStateChangeObserver
	{
public:
	CTestMmfAclntDelete() ;
	virtual TVerdict DoTestStepL();
	// MMdaObjectStateChangeObserver
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);

private:
	TInt iError;	
	};


/** 
 * Open new file while audio converter is converting. Open a new audio file.
 *
 * @class CTestMmfAclntOpenWhileConvert
 *
 */
class CTestMmfAclntOpenWhileConvert : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntOpenWhileConvert(const TDesC& aTestName) ;
	static CTestMmfAclntOpenWhileConvert* NewL(const TDesC& aTestName);
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	} ;
/**
 * @class CTestMmfAclntConvertDestBitRate
 */

class CTestMmfAclntConvertDestBitRate : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertDestBitRate(const TDesC& aTestName, TBool aNegative) ;
        static	CTestMmfAclntConvertDestBitRate* NewL(const TDesC& aTestName, TBool aNegative) ;
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);

protected:
	void GetKeyName(TDes& aDes);
	};


/**
 * @class CTestMmfAclntConvertDestDataType
 */
class CTestMmfAclntConvertDestDataType : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertDestDataType(const TDesC& aTestName, TBool aNegative);
        static CTestMmfAclntConvertDestDataType* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
protected:
	void GetKeyName(TDes& aDes);
private:
	TFourCC iDataType ;
	} ;


/**
 * @class CTestMmfAclntConvertDestFormat
 */
class CTestMmfAclntConvertDestFormat : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertDestFormat(const TDesC& aTestName, TBool aNegative);
	static CTestMmfAclntConvertDestFormat* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
protected:
	void GetKeyName(TDes& aDes);
	};


/**
 * @class CTestMmfAclntConvertDestSampleRate
 */
class CTestMmfAclntConvertDestSampleRate : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertDestSampleRate(const TDesC& aTestName, TBool aNegative);
	static CTestMmfAclntConvertDestSampleRate* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	TVerdict DoTestStepL() ;

protected:
	void GetKeyName(TDes& aDes);
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState,	TInt aCurrentState,
								TInt aErrorCode) ;
	};

/**
 * @class CTestMmfAclntConvertDestNumberOfChannels
 */
class CTestMmfAclntConvertDestNumberOfChannels : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertDestNumberOfChannels(const TDesC& aTestName, TBool aNegative);
	static CTestMmfAclntConvertDestNumberOfChannels* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
protected:
	void GetKeyName(TDes& aDes);
	};

/**
 * @class CTestMmfAclntConvertSourceInfo
 */
class CTestMmfAclntConvertSourceInfo : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertSourceInfo(const TDesC& aTestName, TBool aNegative);
	static CTestMmfAclntConvertSourceInfo* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
protected:
	void GetKeyName(TDes& aDes);
	};
/**
 * Audio convert croping.
 *
 * @class CTestMmfAclntConvertCrop
 *
 */
class CTestMmfAclntConvertCrop : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertCrop(const TDesC& aTestName, const TBool aCropToEnd, TBool aNegative) ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConvertCrop* NewL(const TDesC& aTestName, const TBool aCropToEnd, TBool aNegative);
	virtual TVerdict DoTestStepL() ;
	virtual TVerdict DoTestStepPostambleL();
	// from MMdaObjectStateChangeObserver
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);
private:
	TBool iCropToEnd;
	TPtrC iToFilename;
	TPtrC iToFilename2;
	} ;


/**
 * Set maximum length of file in bytes and convert
 *
 * @class CTestMmfAclntConvertLength
 *
 */
class CTestMmfAclntConvertLength: public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertLength(const TDesC& aTestName, TBool aNegative) ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConvertUtil);
	static CTestMmfAclntConvertLength* NewL(const TDesC& aTestName, TBool aNegative);
	};

/**
 * Set repeats
 *
 * @class CTestMmfAclntConvertRepeat
 *
 */
class CTestMmfAclntConvertRepeat : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertRepeat(const TDesC& aTestName, TBool aNegative) ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConvertUtil);
	static CTestMmfAclntConvertRepeat* NewL(const TDesC& aTestName, TBool aNegative);
	};

/**
 * Audio convert Stoping.
 *
 * @class CTestMmfAclntConvertStop
 *
 */
class CTestMmfAclntConvertStop : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertStop(const TDesC& aTestName, TBool aNegative) ;
	virtual TVerdict DoTestL(CMdaAudioConvertUtility* aConverter);
	static CTestMmfAclntConvertStop* NewL(const TDesC& aTestName, TBool aNegative);
	TVerdict DoTestStepL() ;
	// from MMdaObjectStateChangeObserver
	void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);
	} ;

/**
 * Open a descriptor and convert
 *
 * @class CTestMmfAclntConvertDes
 *
 */
class CTestMmfAclntConvertDes : public CTestMmfAclntCodecTest, public MMdaObjectStateChangeObserver, public MMdaAudioPlayerCallback	
	{
public:
	CTestMmfAclntConvertDes(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse) ;
	virtual TVerdict DoTestStepL();
	static CTestMmfAclntConvertDes* NewL(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse);
	static CTestMmfAclntConvertDes* NewLC(const TDesC& aTestName, const TDesC& aSectName,const TDesC& aKeyName, const TTestFormat aFormat = ENone, const TBool aCreateDes = EFalse);
	virtual TVerdict DoTestStepPreambleL();
	virtual TVerdict DoTestStepPostambleL();
	// from MMdaObjectStateChangeObserver
	virtual void MoscoStateChangeEvent(CBase* aObject, TInt aPreviousState, TInt aCurrentState, TInt aErrorCode);
	
	// from MMdaAudioPlayerCallback
    virtual void MapcInitComplete(TInt aError, const TTimeIntervalMicroSeconds& aDuration);
    virtual void MapcPlayComplete(TInt aError);

private:
	HBufC8* iAudio;
	TInt iError;
	TInt iSize;
	TInt iFrameSize;
	TInt iHeaderSize;
	TBool iCreateDes;
	TBuf<32> iSectName;					// Section name for retrieving filename
	TBuf<32> iKeyName;					// Key name for retrieving filename
	TUint iDataLengthSource;			// source data length - not including header
	TUint iSamples;
	TUint iChannels;
	TUint iFileSizeSink;				// expected file size including header
	TTimeIntervalMicroSeconds iDuration;

	} ;

/**
 * Set Urls
 *
 * @class CTestMmfAclntConvertUrl
 *
 */
class CTestMmfAclntConvertUrl : public CTestMmfAclntConConfig
	{
public:
	CTestMmfAclntConvertUrl(const TDesC& aTestName, TBool aNegative) ;
	virtual TVerdict DoTestStepL();
	static CTestMmfAclntConvertUrl* NewL(const TDesC& aTestName, TBool aNegative);
	};

#endif