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