// Copyright (c) 2007-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 MDASOUNDADAPTERBODY_H

#define MDASOUNDADAPTERBODY_H

#include "mdasoundadapter.h"

#include <d32soundsc.h>

#include <e32base.h>

#include <e32std.h>

/** 

Panic category and codes for the mdasoundadapter

*/

_LIT(KSoundAdapterPanicCategory, "mdasoundadapter");

enum TSoundAdapterPanicCodes

	{

	EDeviceNotOpened,

	EPanicPartialBufferConverterNotSupported,

	EBadState,

	ENoClientPlayRequest,

	EFifoEmpty,

	EFifoFull

	};

//Structure used to map samples per second to the corresponding enums in RSoundSc

struct TSampleRateEnumTable

  	{

	TInt iRate;

	TSoundRate iRateEnum;

	TUint iRateConstant;

	};

//Table that maps given samples per second to the corresponding enums in RSoundSc

const TSampleRateEnumTable KRateEnumLookup[] =

								 {

									{48000,ESoundRate48000Hz,KSoundRate48000Hz},

			                   		{44100,ESoundRate44100Hz,KSoundRate44100Hz},

				                  	{32000,ESoundRate32000Hz,KSoundRate32000Hz},

									{24000,ESoundRate24000Hz,KSoundRate24000Hz},

				                  	{22050,ESoundRate22050Hz,KSoundRate22050Hz},

				                  	{16000,ESoundRate16000Hz,KSoundRate16000Hz},

				                  	{12000,ESoundRate12000Hz,KSoundRate12000Hz},

				                  	{11025,ESoundRate11025Hz,KSoundRate11025Hz},

				                  	{8000, ESoundRate8000Hz, KSoundRate8000Hz}

                   				 };

//Structure used to map linear value of the volume to the decibel value.

struct TLinearToDbTable

	{

	TInt iLiniearValue;

	TInt iDBValue;

	};

//Table that maps given linear value of volume to the corresponding decibel value.

const TLinearToDbTable KLinerToDbConstantLookup[] =

						{

							{0,0},

							{1,158},

							{2,170},

							{3,177},

							{4,182},

							{5,186},

							{6,189},

							{7,192},

							{8,194},

							{9,196},

							{10,198},

							{11,200},

							{12,201},

							{13,203},

							{14,204},

							{15,205},

							{16,206},

							{17,207},

							{18,208},

							{19,209},

							{20,210},

							{21,211},

							{22,212},

							{23,213},

							{24,213},

							{25,214},

							{26,215},

							{27,215},

							{28,216},

							{29,217},

							{30,217},

							{31,218},

							{32,218},

							{33,219},

							{34,219},

							{35,220},

							{36,220},

							{37,221},

							{38,221},

							{39,222},

							{40,222},

							{41,223},

							{42,223},

							{43,224},

							{44,224},

							{45,224},

							{46,225},

							{47,225},

							{48,225},

							{49,226},

							{50,226},

							{51,226},

							{52,227},

							{53,227},

							{54,227},

							{55,228},

							{56,228},

							{57,228},

							{58,229},

							{59,229},

							{60,229},

							{61,230},

							{62,230},

							{63,230},

							{64,230},

							{65,231},

							{66,231},

							{67,231},

							{68,231},

							{69,232},

							{70,232},

							{71,232},

							{72,232},

							{73,233},

							{74,233},

							{75,233},

							{76,233},

							{77,234},

							{78,234},

							{79,234},

							{80,234},

							{81,235},

							{82,235},

							{83,235},

							{84,235},

							{85,235},

							{86,236},

							{87,236},

							{88,236},

							{89,236},

							{90,236},

							{91,237},

							{92,237},

							{93,237},

							{94,237},

							{95,237},

							{96,237},

							{97,238},

							{98,238},

							{99,238},

							{100,238},

							{101,238},

							{102,239},

							{103,239},

							{104,239},

							{105,239},

							{106,239},

							{107,239},

							{108,240},

							{109,240},

							{110,240},

							{111,240},

							{112,240},

							{113,240},

							{114,240},

							{115,241},

							{116,241},

							{117,241},

							{118,241},

							{119,241},

							{120,241},

							{121,241},

							{122,242},

							{123,242},

							{124,242},

							{125,242},

							{126,242},

							{127,242},

							{128,242},

							{129,243},

							{130,243},

							{131,243},

							{132,243},

							{133,243},

							{134,243},

							{135,243},

							{136,244},

							{137,244},

							{138,244},

							{139,244},

							{140,244},

							{141,244},

							{142,244},

							{143,244},

							{144,245},

							{145,245},

							{146,245},

							{147,245},

							{148,245},

							{149,245},

							{150,245},

							{151,245},

							{152,245},

							{153,246},

							{154,246},

							{155,246},

							{156,246},

							{157,246},

							{158,246},

							{159,246},

							{160,246},

							{161,246},

							{162,247},

							{163,247},

							{164,247},

							{165,247},

							{166,247},

							{167,247},

							{168,247},

							{169,247},

							{170,247},

							{171,247},

							{172,248},

							{173,248},

							{174,248},

							{175,248},

							{176,248},

							{177,248},

							{178,248},

							{179,248},

							{180,248},

							{181,248},

							{182,249},

							{183,249},

							{184,249},

							{185,249},

							{186,249},

							{187,249},

							{188,249},

							{189,249},

							{190,249},

							{191,249},

							{192,250},

							{193,250},

							{194,250},

							{195,250},

							{196,250},

							{197,250},

							{198,250},

							{199,250},

							{200,250},

							{201,250},

							{202,250},

							{203,250},

							{204,251},

							{205,251},

							{206,251},

							{207,251},

							{208,251},

							{209,251},

							{210,251},

							{211,251},

							{212,251},

							{213,251},

							{214,251},

							{215,251},

							{216,252},

							{217,252},

							{218,252},

							{219,252},

							{220,252},

							{221,252},

							{222,252},

							{223,252},

							{224,252},

							{225,252},

							{226,252},

							{227,252},

							{228,252},

							{229,253},

							{230,253},

							{231,253},

							{232,253},

							{233,253},

							{234,253},

							{235,253},

							{236,253},

							{237,253},

							{238,253},

							{239,253},

							{240,253},

							{241,253},

							{242,254},

							{243,254},

							{244,254},

							{245,254},

							{246,254},

							{247,254},

							{248,254},

							{249,254},

							{250,254},

							{251,254},

							{252,254},

							{253,254},

							{254,254},

							{255,254}

						};

// Total Number of sample rates

const TUint KNumSampleRates = 9;

// Number of shared chunk buffers used for playing

// Each buffer is permanently mapped, via an index number, to a particular buffer in the chunk

// The esoundsc.ldd can only handle a max of 8 pending play requests, therefore no point in having

// more than 8 play buffers...

const TUint KPlaySharedChunkBuffers = 8;

// Size of RSoundSc play buffers

const TUint KPlaySharedChunkBufferSize = 4096;

//Number of shared chunk buffers used for recording

const TUint KRecordMaxSharedChunkBuffers = 8;

// Size of RSoundSc record buffers

const TUint KRecordSharedChunkBufferSize = 4096;

//Shared chunk driver does not support max. buffer size. 16K is given in order to simulate the old driver behavior.

const TUint KMaxBufferSize = 0x4000;

class TPlaySharedChunkBufConfig : public TSharedChunkBufConfigBase

	{

public:

	TInt iBufferOffsetList[KPlaySharedChunkBuffers];

	};

class TRecordSharedChunkBufConfig : public TSharedChunkBufConfigBase

	{

public:

	TInt iBufferOffsetList[KRecordMaxSharedChunkBuffers];

	};

class CChannelAndSampleRateConverter; // forward dec

GLDEF_C void Panic(TSoundAdapterPanicCodes aPanicCode);//forward declaration

// RFifo class which manages a fifo of up to COUNT items of type T

template<typename T, TUint32 COUNT> class RFifo

	{

public:

	RFifo()

		: iWriteIndex(0), iReadIndex(0)

		{}

	TBool IsEmpty() const

		{

		return iWriteIndex == iReadIndex;

		}

	TBool IsFull() const

		{

		// Full if writing one more item would make iWriteIndex equal to iReadIndex

		TUint32 next = NextIndex(iWriteIndex);

		return next == iReadIndex;

		}

	/// Push item into FIFO. Does not take ownership. Will PANIC with EFifoFull if full.

	void Push(const T &aItem)

		{

		if(IsFull())

			{

			Panic(EFifoFull);

			}

		iFifo[iWriteIndex] = aItem;

		iWriteIndex = NextIndex(iWriteIndex);

		}

    /// Pop item from FIFO. Will PANIC with EFifoEmpty if empty 

	T Pop()

		{

		if(IsEmpty())

			{

			Panic(EFifoEmpty);

			}

		TUint32 tmp = iReadIndex;

		iReadIndex = NextIndex(iReadIndex);

		return iFifo[tmp];

		}

    /// Peek first item from FIFO. Will PANIC with EFifoEmpty if empty 

	T Peek()

		{

		if(IsEmpty())

			{

			Panic(EFifoEmpty);

			}

		return iFifo[iReadIndex];

		}

	TUint Length() const

		{

		TUint len;

		if(iWriteIndex >= iReadIndex)

			{

			len = iWriteIndex - iReadIndex;

			}

		else

			{

			len =  COUNT+1 - (iReadIndex - iWriteIndex);

			}

		return len;

		}

private:

	TUint32 NextIndex(TUint32 aIndex) const

		{

		++aIndex;

		aIndex %= (COUNT+1);

		return aIndex;

		}

	T iFifo[COUNT+1];

	TUint32 iWriteIndex;

	TUint32 iReadIndex;

	};

//Body class for the adapter

NONSHARABLE_CLASS( RMdaDevSound::CBody ): public CBase

	{

public:

	//This class handles the play/record completions from the new sound driver

	NONSHARABLE_CLASS( CPlayer ) : public CActive

		{

	public:

		explicit CPlayer(TInt aPriority, RMdaDevSound::CBody& aParent, TInt aIndex);

		~CPlayer();

		void RunL();

		TInt RunError(TInt aError);

		void DoCancel();

		void PlayData(TUint aChunkOffset, TInt aLength);

		TUint GetPlayerIndex() const;

	private:		

		RMdaDevSound::CBody& iParent;

		const TUint iIndex; // index of this object in parent

		TInt iBufferOffset;

		TInt iBufferLength;

		};

	NONSHARABLE_CLASS( CRecorder ) : public CActive

		{

	public:

		explicit CRecorder(TInt aPriority, RMdaDevSound::CBody& aParent);

		~CRecorder();

		void RunL();

		TInt RunError(TInt aError);

		void DoCancel();

		void RecordData(TInt& aLength);

	private:		

		RMdaDevSound::CBody& iParent;

		TInt iBufferOffset;

		TInt iBufferLength;

		};

	enum TStateEnum

		{

		ENotReady,

		EStopped,

		ERecording,

		ERecordingPausedInHw,

		ERecordingPausedInSw,

		EPlaying,

		EPlayingPausedInHw, // ie. Play request pending on h/w and paused

		EPlayingPausedInSw, // ie. Driver not playing or paused

		EPlayingUnderrun

		};

	NONSHARABLE_CLASS( TState )

		{

		public:

			TState(TStateEnum aState) : iState(aState) {}

			const TText8 *Name() const;

			TState &operator=(TStateEnum aNewState);

			operator TStateEnum() const { return iState; }

		private:

			TStateEnum iState;

		};

	class TFormatData

		{

	public:

		inline TFormatData():

			iSampleRate(8000), iRequestedChannels(1) // default

			{

			}

	public:

		CChannelAndSampleRateConverter* iConverter;

		TInt iSampleRate;

		TInt iActualRate;

		TInt iRequestedChannels;

		TInt iActualChannels;			

		};

public:

	~CBody();

	static CBody* NewL();

	TInt Open(TInt aUnit=KNullUnit);

	TVersion VersionRequired() const;

	TInt IsMdaSound();

	void PlayFormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported);

	void GetPlayFormat(TCurrentSoundFormatBuf& aFormat);

	TInt SetPlayFormat(const TCurrentSoundFormatBuf& aFormat);

	TInt PlayVolume();

	void SetPlayVolume(TInt aVolume);

	void SetVolume(TInt aLogarithmicVolume);

	void CancelPlayData();

	void RecordFormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported);

	void GetRecordFormat(TCurrentSoundFormatBuf& aFormat);

	TInt SetRecordFormat(const TCurrentSoundFormatBuf& aFormat);

	TInt RecordLevel();

	void SetRecordLevel(TInt aLevel);

	void CancelRecordData();

	void FlushRecordBuffer();

	TInt BytesPlayed();

	void ResetBytesPlayed();

	void PausePlayBuffer();

	void ResumePlaying();

	void PauseRecordBuffer();

	void ResumeRecording();

	TInt GetTimePlayed(TTimeIntervalMicroSeconds& aTimePlayed);

	void Close();

	TInt Handle();

	void PlayData(TRequestStatus& aStatus,const TDesC8& aData);

	void RecordData(TRequestStatus& aStatus,TDes8& aData);

	void NotifyRecordError(TRequestStatus& aStatus);

	void NotifyPlayError(TRequestStatus& aStatus);

	void CancelNotifyPlayError();

	void CancelNotifyRecordError();

	void FlushPlayBuffer();

	//internal methods added to reduce the code

	void FormatsSupported(TSoundFormatsSupportedBuf& aFormatsSupported, RSoundSc& aDevice);

	void GetFormat(TCurrentSoundFormatBuf& aFormat, RSoundSc& aDevice, const TFormatData &aFormatData);

	TInt SetFormat(const TCurrentSoundFormatBuf& aFormat, RSoundSc& aDevice, TFormatData &aFormatData);

	//for players

	void SoundDeviceError(TInt aError);

	RSoundSc& PlaySoundDevice();

	RSoundSc& RecordSoundDevice();

	const TState &State() const;

	void BufferFilled(TInt aError);

	// Called whenever a player becomes inactive.

	// This includes driver request ok, driver request failed, CPlayer:::RunError invoked.

	void PlayRequestHasCompleted(CPlayer *aPlayer, TInt aStatus, TBool aDueToCancelCommand);

private:

	CBody();

	void ConstructL();

	TInt NegotiateFormat(const TCurrentSoundFormatBuf& aFormat, RSoundSc& aDevice, TFormatData &aFormatData);

	void StartPlayersAndUpdateState();

	void StartRecordRequest();

	const char *StateName() const;

	TBool InRecordMode() const;

	TBool InPlayMode() const;

	TUint32 CurrentTimeInMsec() const;

	TUint64 BytesPlayed64();

private:

	RSoundSc iPlaySoundDevice;

	RChunk iPlayChunk;//handle to the shared chunk

	RSoundSc iRecordSoundDevice;

	RChunk iRecordChunk;//handle to the shared chunk

	TState iState;

	//Playing Properties

	TPlaySharedChunkBufConfig iPlayBufferConfig;

	TInt iDeviceBufferLength;

	//Stores the status of CDataPathPlayer

	TRequestStatus* iClientPlayStatus;

	TPtrC8 iClientPlayData;

	//Stores the status of CSoundDevPlayErrorReceiver

	TRequestStatus* iClientPlayErrorStatus;

	RBuf8 iConvertedPlayData;

	RBuf8 iSavedTrailingData;

	CPlayer* iPlayers[KPlaySharedChunkBuffers];

	RFifo<CPlayer *, KPlaySharedChunkBuffers> iFreePlayers;

	RFifo<TUint32, KPlaySharedChunkBuffers> iActivePlayRequestSizes;

	TInt iRequestMinSize;

	TUint iRequestMinMask;

	//Recording Properties

	TRecordSharedChunkBufConfig iRecordBufferConfig;

	TInt iBufferOffset;

	TInt iBufferLength;

	//Stores the status of CDataPathRecorder

	TRequestStatus* iClientRecordStatus;

	//Stores the status of CSoundDevRecordErrorReceiver

	TRequestStatus* iClientRecordErrorStatus;

	TDes8* iClientRecordData;//stores the data pointer from datapath recorder

	RBuf8 iBufferedRecordData; // Used if RSoundSc returns more data than current client request requires.

	CRecorder* iRecorder; // We only need one recorder. The driver will buffer data for us.

	TBool iUnderFlowReportedSinceLastPlayOrRecordRequest;

	TUint64 iBytesPlayed;

	TUint32 iNTickPeriodInUsec;

	TUint32 iStartTime; // Time when previous driver PlayData completed (or first was issued) in msec

	TUint32 iPauseTime; // Time when pause started in msec

	TUint64 iPausedBytesPlayed;

	TFormatData iPlayFormatData;

	TFormatData iRecordFormatData;

	};

#endif