/*

 * Copyright (c) 2006-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 C_TONEHWDEVICE_H

 #define C_TONEHWDEVICE_H

 //  INCLUDES

 #include <mmf/server/mmfhwdevice.h>

 #include <mmf/server/sounddevice.h>

 #include <mmf/server/mmfhwdevicesetup.h>

 #include <mmf/server/mmfswcodecwrappercustominterfacesuids.hrh>

 #include <a3f/a3f_trace_utils.h>

 #include "mdasoundadapter.h"

 #include "ToneGenerator.h"

 #include "tonedatapath.h"

 #include <a3f/tonedata.h>

 //note we need to keep this buffer at 8K as the tone utility expects 8K

 const TInt KPCM16ToPCM16BufferSize = 0x2000;

 //controlls buffer sizes

 const TInt KDevSoundDefaultFrameSize = 0x1000;

 const TInt KDevSoundMinFrameSize = 0x800; //2K

 const TInt KDevSoundMaxFrameSize = 0x4000;  //16K

 const TInt KDevSoundDeltaFrameSize = 0x800; //2K

 const TInt KDevSoundFramesPerSecond = 4;

 // FORWARD DECLARATIONS

 class CToneDataPath;

 // CLASS DECLARATION

 /**

  * Implementation of custom interface class for tone play functionality created by the

  * CToneCodec::CustomInterface() method.  It provides

  * access to miscellaneous functionality such as volume settings

  */

 class TToneCustomInterface : public MPlayCustomInterface

 	{

 public:

 	TToneCustomInterface() : iVolume(0),iBytesPlayed(0),iDevice(NULL),iRampDuration(0) {}

 	void SetVolume(TUint aVolume);

 	TUint Volume();

 	TUint BytesPlayed();

 	void SetVolumeRamp(const TTimeIntervalMicroSeconds& aRampDuration);

 	TTimeIntervalMicroSeconds& VolumeRamp();

 	void SetDevice(RMdaDevSound* iDevice);

 private:

 	TUint iVolume;

 	TUint iBytesPlayed;

 	RMdaDevSound* iDevice;

 	TTimeIntervalMicroSeconds iRampDuration;

 	};

 /*

 * Codec Implementation

 */

 class CToneCodec : public CBase

 	{

 public:

 	/**

 	Indicates the result of processing data from the source buffer to a destination buffer

 	and provides functions to compare the result code.

 	The CToneCodec buffer sizes should be set to return EProcessComplete

 	The other return codes are to keep the ProcessL method compatible with

 	the 7.0s CMMFCodec API.

 	*/

 	class TCodecProcessResult

 		{

 	public:

 		/**

 		Flag to track the codec's processing status.

 		*/

 		enum TCodecProcessResultStatus

 			{

 			/** The codec has successfully completed its processing. */

 			EProcessComplete,

 			/** Could not empty the source buffer because the destination buffer became full. */

 			EProcessIncomplete,

 			/** Codec came across an end of data. */

 			EEndOfData,

 			/** Could not fill the destination buffer because the source buffer has been emptied. */

 			EDstNotFilled,

 			/** An error occured. */

 			EProcessError

 			};

 		/** Overloaded operator to test equality. */

 		TBool operator==(const TCodecProcessResultStatus aStatus) const {return (iCodecProcessStatus == aStatus);}

 		/** Overloaded operator to test inequality. */

 		TBool operator!=(const TCodecProcessResultStatus aStatus) const {return (iCodecProcessStatus != aStatus);}

 		/**

 		Default constructor.

 		*/

 		TCodecProcessResult()

 			:iCodecProcessStatus(EProcessError), iSrcBytesProcessed(0), iDstBytesAdded(0) {};

 		public:

 		/**

 		The codec's processing status

 		@see enum TCodecProcessResultStatus

 		*/

 		TCodecProcessResultStatus iCodecProcessStatus;

 		/** The number of source bytes processed */

 		TUint iSrcBytesProcessed;

 		/** The number of bytes added to the destination buffer */

 		TUint iDstBytesAdded;

 		};

 public:

 	CToneCodec();

 	~CToneCodec();

 	void ConstructL();

 	/**

 	Processes the data in the specified source buffer and writes the processed data to

 	the specified destination buffer.

 	This function is synchronous, when the function returns the data has been processed.

 	@param	aSource

 			The source buffer containing data to encode or decode.

 	@param	aDest

 	 		The destination buffer to hold the data after encoding or decoding.

 	@return	The result of the processing.

 	@see    TCodecProcessResult

 	*/

 	TCodecProcessResult ProcessL(const CMMFBuffer& aSource, CMMFBuffer& aDest);

 	/**

 	Gets the max size of the source buffer passed into the

 	CToneCodec::ProcessL function.

 	Note that this means that this is the Max size of each buffer passed to the codec.  The actual

 	size of the data could be less than the max size.

 	@return The max size of the source buffer in bytes.

 	*/

 	TUint SourceBufferSize();

 	/**

 	Gets the max size of the sink (destination) buffer passed into the

 	CToneCodec::ProcessL method.

 	Note that this means that this is the Max size of each buffer passed to the codec.  The actual

 	size of the data written to this buffer could be less than the max size.

 	@return The max size of the sink buffer in bytes.

 	*/

 	TUint SinkBufferSize();

 	TBool IsNullCodec() {return ETrue;};

 	private:

 	TUint iBufferSize;

 	};

 class CToneHwDevice : public CMMFHwDevice,

 					  public MMMFHwDeviceObserver

 	{

 	public:  // Constructors and destructor

 	static CToneHwDevice* NewL();

 	~CToneHwDevice();

 	public: // New functions

 	public: // Functions from base classes

 	TInt Init(THwDeviceInitParams& aDevInfo);

 	TInt Start(TDeviceFunc /*aFuncCmd*/, TDeviceFlow /*aFlowCmd*/);

 	TInt Stop();

 	/* This function is not used in tone playback*/

 	TInt Pause();

 	TAny* CustomInterface(TUid aInterfaceUid);

 	TInt FillThisHwBuffer(CMMFBuffer& aHwBuffer);

 	TInt ThisHwBufferFilled(CMMFBuffer& aMmfBuffer);

 	/*From MMMFHwDeviceObserver*/

 	/* This function is not used in tone playback*/

 	TInt ThisHwBufferEmptied(CMMFBuffer& aMmfBuffer);

 	/*From MMMFHwDeviceObserver*/

 	/* This function is not used in tone playback*/

 	TInt EmptyThisHwBuffer(CMMFBuffer& aMmfBuffer);

 	/*From MMMFHwDeviceObserver*/

 	TInt MsgFromHwDevice(TUid aMessageType, const TDesC8 &aMsg);

 	/*From MMMFHwDeviceObserver*/

 	void Stopped();

 	/*From MMMFHwDeviceObserver*/

 	void Error(TInt aError);

 	TInt SetConfig(TTaskConfig& aConfig);

 	/* This function is not used in tone playback*/

 	TInt StopAndDeleteCodec();

 	/* This function is not used in tone playback*/

 	TInt DeleteCodec();

 	CToneCodec& Codec();

 	TInt GenerateBufferData();

 	void SetActiveToneBuffer();

 	TInt SamplingFrequency();

 	TInt NumberOfChannels();

 	TInt FillFreeToneBuffer();

 	TInt ReadToneData();

 	void FreeBuffers();

 	TBool ValidDTMFString(const TDesC& aDTMFString);

 	TBool RecognizeSequence(const TDesC8& aData);

 	protected:  // New functions

 	protected:  // Functions from base classes

 	private:

 	CToneHwDevice();

 	void ConstructL();

 	public:		// Data

 	protected:	// Data

 	private:	// Data

 	/**

 	* Pointer to the buffer that was last sent to the observer to be filled.

 	* Own pointer.

 	*/

 	CMMFDataBuffer* iHwDataBufferFill;

 	/**

 	* Hwdevice observer. Information is send to upper level by using this pointer.

 	*/

 	MMMFHwDeviceObserver* iHwDeviceObserver;

 	/**

 	The datapath used to transfer the data

 	*/

 	CToneDataPath* iDataPath;

 	MPlayCustomInterface* iPlayCustomInterface;

 	/**

 	* Initialize status of the tone

 	*/

 	TBool iToneInitialized;

 	/**

 	* Playback status of the tone

 	*/

 	TBool iTonePlaying;

 	/**

 	* Pointer to information about hwdevice initializing parameters.

 	*/

 	//TSizeHwDeviceInitArgs* iSizeHwDeviceInitArgs;

 	/**

 	* Type of the tone

 	*/

 	TToneData::TToneType iToneType;

 	/**

 	* Tone Data

 	*/

 	TToneData myToneData;

 	/**

 	* Tone Codec

 	*/

 	CToneCodec *iCodec;

 	/**

 	The buffer size of the sound device

 	*/

 	TUint iDeviceBufferSize;

 	/**

 	The sample rate of the sound device

 	*/

 	TInt iSampleRate;

 	/**

 	The number of channels of the sound device

 	*/

 	TInt iChannels;

 	TBool iLastBuffer;

 	TTimeIntervalMicroSeconds iRampDuration;

 	//WINS Sound Device Structures

 	RMdaDevSound::TCurrentSoundFormatBuf soundDeviceSettings;

 	// Double buffer tone playing

 	CMMFDataBuffer*				iToneBuffer1;

 	CMMFDataBuffer*				iToneBuffer2;

 	// Reference to current tone buffer playing

 	CMMFDataBuffer*				iActiveToneBuffer;

 	TBool						iFirstCallFromHwDevice;

 	//Tone Stuff:

 	MMdaToneSynthesis*			iCurrentGenerator;

 	TMdaSimpleToneGenerator		iToneGen;

 	TMdaDualToneGenerator		iDualToneGen;

 	TMdaDTMFGenerator			iDTMFGen;

 	TMdaSequenceGenerator		iSequenceGen; // Not Supported

 	TInt						iRepeatCount;

 	TInt						iFrequency1;

 	TInt						iFrequency2;

 	TTimeIntervalMicroSeconds	iRepeatTrailingSilence;

 	TTimeIntervalMicroSeconds	iDuration;

 	TTimeIntervalMicroSeconds32 myToneOnLength;

 	TTimeIntervalMicroSeconds32 myToneOffLength;

 	TTimeIntervalMicroSeconds32 myPauseLength;

 	TDesC *iDTMFString;

 	TDesC8 *iSequenceData;

 	};

 	#include "tonehwdevice.inl"

 #endif

 // End of File