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