// Copyright (c) 2003-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:

 // mmfswaudioinputpriv.h

 // 

 //

 #ifndef SWAUDIOINPUTPRIV_H

 #define SWAUDIOINPUTPRIV_H

 #include <e32def.h>

 #include "mmfswaudioinput.h"

 #include <d32soundsc.h>

 #include <e32base.h>

 #include <e32std.h>

 #define KNumRecorders (2) // 2 for double buffering, 4 quadruple etc

 enum TPanicCodes

     {

     KPanicBadTotalQueueLength=1,    // once constructed, total queue length should be KNumRecorders

     KPanicBadTotalQueueLength2,     // during construction or delation, total queue length should be <= KNumRecorders

     KPanicBadBusyQueueLength,       // Busy queue should never exceed length of 1

     EPanicBusyRecorderNotActive,    // If in the busy queue, should be active

     EPanicNonBusyRecorderActive,    // opposite

     };

 //Total Number of sample rates

 class CChannelAndSampleRateConverter;  // forward dec

 class TRecordSharedChunkBufConfig : public TSharedChunkBufConfigBase

 	{

 public:

 	TInt iBufferOffsetList[3];

 	};

 NONSHARABLE_CLASS(CAudioInput) : public CBase, 

 					public MAudioInput,

 					public MAIParamInterface

 	{

 	NONSHARABLE_CLASS( CRecorder ) : public CActive

 		{

 	public:

 		CRecorder(CAudioInput& aParent, TInt aIndex);

 		~CRecorder();

 		void Cancel();

 		void RecordData();

 		TInt Index() const;

 		void ReleaseBuffer(TBool aDoAnyway=EFalse);

 		TBool IsBusy() const;

 		TBool BufferHeld() const;

 		TInt Length() const; 

 		TInt Offset() const;

 		TInt StatusOrOffset() const;

 		TSglQueLink iLink; // used to form queues. Treat as private.

 		// from CActive

 		void RunL();

 		void DoCancel(); 

 	private:

 		CAudioInput& iParent;

 		const TInt iIndex;

 		TInt iLength;

 		TBool iBufferHeld;

 		};

 private:

 	class TFormatData

 		{

 	public:

 		inline TFormatData():

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

 			{

 			}

 	public:

 		TInt iSampleRate;

 		TInt iActualRate;

 		TInt iRequestedChannels;

 		TInt iActualChannels;			

 		};

 public:

 	static CAudioInput* NewL(MAudioInputObserver& aObserver);

 	~CAudioInput();

 	// from MAudioInput

 	void Release();

 	TInt Initialize(const TAudioInputParams& aParams);

 	void Close();

 	TInt Start();

 	void BufferAck();

 	TInt Pause();

 	TInt Resume();

 	TInt Flush();

 	void Stop();

 	TAny* Interface(TUid aInterfaceUid);

 	// from MAIParamInterface

 	TInt SetGain(TInt aGain);

 	TInt GetBufferSizes(TInt& aMinSize, TInt& aMaxSize);

 	TInt GetSupportedSampleRates(RArray<TInt>& aSupportedSampleRates);

 	RSoundSc& RecordSoundDevice();

 	void BufferArrives(CRecorder* aRecorder);

 	void BufferError(CRecorder* aRecorder, TInt aError);

 	TInt SetFormat(const TAudioInputParams& aFormat);

 	TInt NegotiateFormat(const TAudioInputParams& aFormat, TFormatData &aFormatData);

 	TInt GetSupportedSampleRates(RArray<TInt>& aSupportedSampleRates, RSoundSc& aSoundDevice);

 private:

 	CAudioInput(MAudioInputObserver& aObserver);

 	void ConstructL();

 	void Cancel();

 	static TInt Callback(TAny* aPtr);

 	void AsyncCallbackL();

     void RequestCallback();

 	void CancelRecorders();

     void CancelPendingRecorders();

     void CancelBusyRecorder();

 	void InternalStop();

 	void InternalFlush();

 	void RecordAllIdle();

 	void UseBuffer(CRecorder* aRecorder);

 	void HandleBufferAck();

 	void CheckFullInvariant();

 	void CheckInvariant(TBool aKnownConstructed=ETrue);

 #ifdef _DEBUG

     void CheckActiveRecorders();

     void CheckActiveRecorders(TSglQue<CRecorder>& aQueue, TBool aExpected, TInt aPanicCode);

 #endif

 	static TInt QLength(TSglQue<CRecorder>& aQueue);

 	CRecorder* QPop(TSglQue<CRecorder>& aQueue);

 	TBool QPop(CRecorder*& aRecorder, TSglQue<CRecorder>& aQueue);

 	inline TInt BufferLength() const { return iBufferLength; } // TODO required?

 private:

 	MAudioInputObserver& iObserver;

 	enum TState

 		{

 		EStateCreated2,

 		EStateInitialized2,

 		EStateRecordWait2,

 		EStateRecordWaitAck2,

 		};

 	enum TRunningState // when in RecordWait2 or RecordWaitAck2

 	    {

 	    ERStateRunning,        // recording

 	    ERStatePaused,         // paused state

 	    ERStateFinishing,      // look to do InputFinished() on next tick

 	    ERStateFinished,       // InputFinished() sent

 	    ERStateFailed,         // InputError() sent 

 	    };

 	TState iState;

 	TRunningState iRState;

 	TRecordSharedChunkBufConfig iRecordBufferConfig;

 	RSoundSc iRecordSoundDevice;

 	RChunk iChunk;

 	CRecorder* iRecorders[KNumRecorders];

 	CAsyncCallBack* iAsyncCallBack;

 	TInt iBufferLength;	// this is the length of buffers we request

     CChannelAndSampleRateConverter* iConverter;

     TPtrC8 iBufPtr;     // this is usually the descriptor sent to the observer

     RBuf8 iConvBuff;    // extra buffer from when we use a converter

     TSglQue<CRecorder> iIdleQueue;        // just sitting there

     TSglQue<CRecorder> iRecordingQueue;   // record operation outstanding

     TSglQue<CRecorder> iPendingQueue;     // buffer has been recorded, waiting to be processed

     TSglQue<CRecorder> iBusyQueue;        // mid InputAvailable()/BufferAck() cycle. Length <= 1

 	};

 inline TBool CAudioInput::QPop(CRecorder*& aRecorder, TSglQue<CRecorder>& aQueue)

 // overload of QPop(), since "while (recorder = QPop(...))" etc gives warnings

 // This allows "while (QPop(recorder, ...))" instead

 	{

 	CRecorder* recorder = QPop(aQueue);

 	if (recorder)

 		{

 		aRecorder = recorder;

 		return ETrue;

 		}

 	return EFalse;

 	}

 #endif // SWAUDIOINPUTPRIV_H