diff -r 000000000000 -r 40261b775718 mmhais/refacladapt/src/tonehwdevice/tonehwdevice.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mmhais/refacladapt/src/tonehwdevice/tonehwdevice.h Tue Feb 02 01:56:55 2010 +0200 @@ -0,0 +1,378 @@ +/* +* 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 +#include +#include +#include +#include +#include "mdasoundadapter.h" +#include "ToneGenerator.h" +#include "tonedatapath.h" +#include + + +//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