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

// mmfswaudioinput.cpp

// 

//

#include "mmfswaudioinput.h"

#include "mmfswaudioinputpriv.h"

#include <d32soundsc.h>

#include <e32debug.h>

#include "mmf/utils/rateconvert.h" // if we need to resample

_LIT(KPddFileName,"SOUNDSC.PDD");

_LIT(KLddFileName,"ESOUNDSC.LDD");

#ifdef SYMBIAN_SWCODEC_LOGGING

const TText* const KStateNames[] = // must agree with TState

            {

            _S("EStateCreated2"), 

            _S("EStateInitialized2"), 

            _S("EStateRecordWait2"), 

            _S("EStateRecordWaitAck2"), 

            };

static const TText* StateName(TInt aState)

    {

    return KStateNames[aState];

    }

const TText* const KRStateNames[] = // must agree with TRunningState

            {

            _S("ERStateRunning"), 

            _S("ERStatePaused"), 

            _S("ERStateFinishing"), 

            _S("ERStateFinished"), 

            _S("ERStateFailed"), 

            };

static const TText* RStateName(TInt aState)

    {

    return KRStateNames[aState];

    }

#endif // SYMBIAN_SWCODEC_LOGGING

#ifdef _DEBUG

static void Panic(TInt aPanic)

    {

    _LIT(KPanicString, "SwAudioInput");

    User::Panic(KPanicString, aPanic);

    }

void CAudioInput::CheckFullInvariant()

    {

    CheckInvariant();

    CheckActiveRecorders();

    }

void CAudioInput::CheckInvariant(TBool aKnownConstructed)

    {

    // full check would be that each recorder is in one, and only one, queue.

    // However, since the queues share the same infrastructure, checking the overall length of queues

    // is correct should suffice. During construction or deletion this may obviously vary

    TInt totalLength = QLength(iIdleQueue) + QLength(iRecordingQueue) + 

           QLength(iPendingQueue) + QLength(iBusyQueue);

    if (aKnownConstructed)

        {

        __ASSERT_DEBUG(totalLength==KNumRecorders, Panic(KPanicBadTotalQueueLength));

        }

    else

        {

        __ASSERT_DEBUG(totalLength<=KNumRecorders, Panic(KPanicBadTotalQueueLength2));        

        }

    __ASSERT_DEBUG(QLength(iBusyQueue)<=1, Panic(KPanicBadTotalQueueLength));

    }

#else // _DEBUG

// inline versions that do nothing...

inline void CAudioInput::CheckFullInvariant()

	{

	}

inline void CAudioInput::CheckInvariant(TBool /*aKnownConstructed*/)

	{

	}

#endif // _DEBUG

const TInt KMinBufferSize = 4; // assume a good default?

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

const TInt KMaxBufferSize = 0x4000;

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

const TUint8 KLinearToDbConstantLookup[] =

                        {

                            0,            // 0

                            158,

                            170,

                            177,

                            182,

                            186,

                            189,

                            192,

                            194,

                            196,

                            198,          // 10

                            200,

                            201,

                            203,

                            204,

                            205,

                            206,

                            207,

                            208,

                            209,

                            210,          // 20

                            211,

                            212,

                            213,

                            213,

                            214,

                            215,

                            215,

                            216,

                            217,

                            217,          // 30

                            218,

                            218,

                            219,

                            219,

                            220,

                            220,

                            221,

                            221,

                            222,

                            222,          // 40

                            223,

                            223,

                            224,

                            224,

                            224,

                            225,

                            225,

                            225,

                            226,

                            226,          // 50

                            226,

                            227,

                            227,

                            227,

                            228,

                            228,

                            228,

                            229,

                            229,

                            229,          // 60

                            230,

                            230,

                            230,

                            230,

                            231,

                            231,

                            231,

                            231,

                            232,

                            232,          // 70

                            232,

                            232,

                            233,

                            233,

                            233,

                            233,

                            234,

                            234,

                            234,

                            234,          // 80

                            235,

                            235,

                            235,

                            235,

                            235,

                            236,

                            236,

                            236,

                            236,

                            236,          // 90

                            237,

                            237,

                            237,

                            237,

                            237,

                            237,

                            238,

                            238,

                            238,

                            238,          // 100

                            238,

                            239,

                            239,

                            239,

                            239,

                            239,

                            239,

                            240,

                            240,

                            240,          // 110

                            240,

                            240,

                            240,

                            240,

                            241,

                            241,

                            241,

                            241,

                            241,

                            241,          // 120

                            241,

                            242,

                            242,

                            242,

                            242,

                            242,

                            242,

                            242,

                            243,

                            243,          // 130

                            243,

                            243,

                            243,

                            243,

                            243,

                            244,

                            244,

                            244,

                            244,

                            244,          // 140

                            244,

                            244,

                            244,

                            245,

                            245,

                            245,

                            245,

                            245,

                            245,

                            245,          // 150

                            245,

                            245,

                            246,

                            246,

                            246,

                            246,

                            246,

                            246,

                            246,

                            246,          // 160

                            246,

                            247,

                            247,

                            247,

                            247,

                            247,

                            247,

                            247,

                            247,

                            247,          // 170

                            247,

                            248,

                            248,

                            248,

                            248,

                            248,

                            248,

                            248,

                            248,

                            248,          // 180

                            248,

                            249,

                            249,

                            249,

                            249,

                            249,

                            249,

                            249,

                            249,

                            249,          // 190

                            249,

                            250,

                            250,

                            250,

                            250,

                            250,

                            250,

                            250,

                            250,

                            250,          // 200

                            250,

                            250,

                            250,

                            251,

                            251,

                            251,

                            251,

                            251,

                            251,

                            251,          // 210

                            251,

                            251,

                            251,

                            251,

                            251,

                            252,

                            252,

                            252,

                            252,

                            252,          // 220

                            252,

                            252,

                            252,

                            252,

                            252,

                            252,

                            252,

                            252,

                            253,

                            253,          // 230

                            253,

                            253,

                            253,

                            253,

                            253,

                            253,

                            253,

                            253,

                            253,

                            253,          // 240

                            253,

                            254,

                            254,

                            254,

                            254,

                            254,

                            254,

                            254,

                            254,

                            254,          // 250

                            254,

                            254,

                            254,

                            254,

                            254

                        };

// rate lookup table

const TInt KNumSampleRates = 9;

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}

    };

// TAudioInputParams

EXPORT_C TAudioInputParams::TAudioInputParams() :

    iSampleRate(0), iNominalBufferSize(0)

    {

    // none	

    }

// CAudioInput

EXPORT_C MAudioInput* MAudioInput::CreateL(MAudioInputObserver& aObserver)

    {

    MAudioInput* result = CAudioInput::NewL(aObserver);

    return result;

    }

CAudioInput* CAudioInput::NewL(MAudioInputObserver& aObserver)

    {

    CAudioInput* result = new CAudioInput(aObserver);

    CleanupStack::PushL(result);

    result->ConstructL();

    CleanupStack::Pop(result);

    return result;

    }

CAudioInput::CAudioInput(MAudioInputObserver& aObserver) :

    iObserver(aObserver),

    iIdleQueue(_FOFF(CRecorder,iLink)),

    iRecordingQueue(_FOFF(CRecorder,iLink)),

    iPendingQueue(_FOFF(CRecorder,iLink)),

    iBusyQueue(_FOFF(CRecorder,iLink))

    {

    ASSERT(iState == EStateCreated2); // assume zero'ing initialises correctly

    }

void CAudioInput::Release()

// effective destructor call

    {

    delete this;

    }

TAny* CAudioInput::Interface(TUid aInterfaceUid)

    {

    if (aInterfaceUid == KUidAIParamInterface)

        {

        MAIParamInterface* self = this;

        return self;

        }

    return NULL;

    }

RSoundSc& CAudioInput::RecordSoundDevice()

    {

    ASSERT(iRecordSoundDevice.Handle()!=0); // should be open

    return iRecordSoundDevice;

    }

CAudioInput::~CAudioInput()

    {

    CheckInvariant(EFalse); // may not be constructed

    Cancel();

    for (TInt i = 0; i < KNumRecorders; i++)

        {

        // just in case, call cancel directly from this point too

        // Cancel depends on the active queue, and might not be quite the same.

        CRecorder* recorder = iRecorders[i];

        if (recorder)

            {

            recorder->Cancel();

            }

        delete recorder;

        }

    delete iAsyncCallBack;

    iConvBuff.Close();

    iRecordSoundDevice.Close();

    iChunk.Close();

    }

void CAudioInput::Cancel()

    {

#ifdef SYMBIAN_SWCODEC_LOGGING

    RDebug::Print(_L("--->CAudioInput::Cancel()"));

#endif

    CancelRecorders();

    if (iAsyncCallBack)

        {

        iAsyncCallBack->Cancel();

        }

#ifdef SYMBIAN_SWCODEC_LOGGING

    RDebug::Print(_L("<---CAudioInput::Cancel()"));

#endif

    }

void CAudioInput::CancelRecorders()

// if a recorder is active, then cancel it. Also move the list if required.

    {

    CheckInvariant(); // semi-invariant check - this is called from destructor

    CRecorder* recorder;

    while (QPop(recorder, iRecordingQueue))

        {

        recorder->Cancel();

        iIdleQueue.AddLast(*recorder);

        }

    CheckFullInvariant();

    }

void CAudioInput::CancelPendingRecorders()

// take any recorder in the pending queue. ack the buffer and send to idle

    {

    CheckFullInvariant();

    CRecorder* recorder;

    while (QPop(recorder, iPendingQueue))

        {

        recorder->ReleaseBuffer();

        iIdleQueue.AddLast(*recorder);

        }

    CheckFullInvariant();

    }

void CAudioInput::CancelBusyRecorder()

// take busy recorder. ack the buffer and send to idle

    {

    CheckFullInvariant();

    CRecorder* recorder;

    if (QPop(recorder, iBusyQueue))

        {

        recorder->ReleaseBuffer();

        iIdleQueue.AddLast(*recorder);

        }

    CheckFullInvariant();

    }

void CAudioInput::RecordAllIdle()

// take any recorder in idle queue and set recording

    {