/*

 * 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:  VoIP Audio Services

 *               Implements downlink thread object.

 *

 */

#include <AudioOutput.h>

#include <IlbcDecoderIntfc.h>

#include <G711DecoderIntfc.h>

#include <G729DecoderIntfc.h>

#include <ErrorConcealmentIntfc.h>

#include <voipdownlinkstream.h>

#include "debugtracemacros.h"

#include "VoIPSharedData.h"

#include "VoIPServerThread.h"

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::CVoIPDownlinkThread

// Standard Constructor

// -----------------------------------------------------------------------------

//

CVoIPDownlinkThread::CVoIPDownlinkThread(TSharedData& aData) :

    iShared(aData)

    {

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::~CVoIPDownlinkThread

// Standard Constructor

// -----------------------------------------------------------------------------

//

CVoIPDownlinkThread::~CVoIPDownlinkThread()

    {

    TRACE_PRN_FN_ENT;

    Stop();

    delete iJitterBuffer;

    delete iAddJBuffer;

    delete iGetJBuffer;

    delete iAudioOutput;

    delete iErrConcealmentIntfc;

    delete iG711DecoderIntfc;

    delete iG729DecoderIntfc;

    delete iIlbcDecoderIntfc;

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::NewL

// Symbian two-phase constructor

// -----------------------------------------------------------------------------

//

CVoIPDownlinkThread* CVoIPDownlinkThread::NewL(TSharedData& aData)

    {

    CVoIPDownlinkThread* self = new (ELeave) CVoIPDownlinkThread(aData);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::ConstructL

// Part two of Symbian two phase construction

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::ConstructL()

    {

    TRACE_PRN_FN_ENT;

    InitThreadL();

    iCodecID = iShared.iCodecSettings.iFourCC;

    InitMsgQueuesL(KDnLinkQueue, KDnLinkThreadComQueue);

    iShared.iMutex.Wait();

    TRAPD(err, InitDevSoundL(EMMFStatePlaying, iShared.iPriority,

            iShared.iPreference));

    iShared.iMutex.Signal();

    if (err != KErrNone)

        {

        SendCmd(ECmdDnLinkError, err);

        }

    iMaxBufLen = DetermineMaxBufferLen(iShared.iCodecSettings.iG711FrameRate);

    // Client must set these before querying!

    iG711CodecMode = CVoIPFormatIntfc::EG711ALaw;

    iILBCCodecMode = CVoIPFormatIntfc::EiLBC20mSecFrame;

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::ThreadFunction

// Thread Startup function

// -----------------------------------------------------------------------------

//

TInt CVoIPDownlinkThread::ThreadFunction(TAny* aData)

    {

    // get a pointer to the shared data object

    TSharedData& shared = *((TSharedData*) aData);

    // we can set the sync flag here

    shared.iMutex.Wait();

    // create a cleanup stack

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (!cleanupStack)

        {

        return KErrNoMemory;

        }

    CVoIPDownlinkThread* thread = 0;

    TRAPD(err, thread = CVoIPDownlinkThread::NewL(shared));

    if (err != KErrNone)

        {

        return err;

        }

    shared.iMutex.Signal();

    // if we're still here, active scheduler has been constructed

    // start wait loop which runs until it's time to end the thread

    CActiveScheduler::Start();

    // Termination cleanup

    delete thread;

    delete cleanupStack;

    TRACE_PRN_N(_L("VoIP Downlink Thread CLOSED"));

    return KErrNone;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::Start

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::Start()

    {

    TRACE_PRN_FN_ENT;

    TInt err = KErrNotReady;

    if (iStatus == EReady)

        {

        TRAP(err, iDevSound->PlayInitL());

        TRACE_PRN_IF_ERR(err);

#ifdef _DEBUG

        iSamplesPlayedCount = 0;

#endif

        if (err != KErrNone)

            {

            SendCmd(ECmdDnLinkError, err);

            iStatus = EReady;

            }

        else

            {

            if (iJitterBuffer && iCodecID != KMMFFourCCCodePCM16)

                {

                iJitterBuffer->Play();

                }

            }

        }

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::Stop

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::Stop()

    {

    TRACE_PRN_FN_ENT;

    if (iStatus == EStreaming)

        {

        if (iJitterBuffer && iCodecID != KMMFFourCCCodePCM16)

            {

            iJitterBuffer->Stop();

            }

        iDevSound->Stop();

        iStatus = EReady;

        }

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::InitializeComplete

// A callback from the DevSound indicating completion of the initialization.

// It will send config data to the D/S and configure the encoder via CI.

// If everything goes well, the state of the thread is set EReady.

// The initialization completion message is sent back to the main thread.

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::InitializeComplete(TInt aError)

    {

    TRACE_PRN_FN_ENT;

    TInt err = aError;

    if (iDevSound && err == KErrNone)

        {

        TMMFCapabilities conf;

        conf = iDevSound->Config();

        conf.iRate = EMMFSampleRate8000Hz;

        conf.iChannels = EMMFMono;

        TRAP(err, iDevSound->SetConfigL(conf));

        if (err == KErrNone)

            {

            // We are ready to stream even in case of later CI setting failure

            iStatus = EReady;

            TInt vol = iDevSound->MaxVolume();

            iShared.iMutex.Wait();

            iShared.iMaxVolume = vol;

            iShared.iMutex.Signal();

            }

        // Init Custom Interface API to the decoder

        TRAPD(err0, SetCodecCiL());

        if (err0 != KErrNone)

            {

            // DEBUG only

            // Can ignore error - the decoder is not fully configured but

            // can still run in the default mode.

            TRACE_PRN_IF_ERR(err0);

            }

        }

    // Notify the main thread

    SendCmd(ECmdDownlinkInitComplete, err);

    TRACE_PRN_IF_ERR(err);

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::BufferToBeFilled

// A reference to the buffer delivered from the DevSound is stored locally

// for later use. It will be filled with the data passed from the client

// when it calls BufferFilled.

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::BufferToBeFilled(CMMFBuffer* aBuffer)

    {

    //TRACE_PRN_FN_ENT;

    // Store pointer to the received buffer

    iDevSoundBufPtr = static_cast<CMMFDataBuffer*> (aBuffer);

    iBufLen = iDevSoundBufPtr->RequestSize();

    TRACE_PRN_N1(_L("VoIP->DNL->BTBF:LEN[%d]"), iBufLen);

#ifndef __WINSCW__

    // The first AMR buffer returns 1 for no data frame.

    if (iCodecID == KMccFourCCIdAMRNB)

        {

        iBufLen = iMaxBufLen;

        }

#else  //__WINSCW__

    // Don't care about full 4k data buffer in WINS

    iBufLen = iMaxBufLen;

#endif //__WINSCW__

    // Create or adjust the chunk

    TInt err = DoChunk(KChunkDNL, iBufLen, iMaxBufLen);

    if (iJitterBuffer && iCodecID != KMMFFourCCCodePCM16)

        {

        // Note: Do not send ECmdFillBuffer to the client except if error

        if (err != KErrNone)

            {

            Stop();

            iMsgBuffer.iStatus = err;

            iMsgBuffer.iRequest = ECmdFillBuffer;

            iMsgQueue.Send(iMsgBuffer);

            }

        else

            {

            // If JB below threshold, it will generate and return SID frames.

            TRAP(err, iGetJBuffer->SetRequestSizeL(iBufLen)); // for CNG

            // Use current buf to play (if data available)

            err = iJitterBuffer->FillBuffer(iGetJBuffer);

            iStatus = EStreaming;

            }

        }

    else // non-JB case

        {

        if (err != KErrNone)

            {

            Stop();

            iMsgBuffer.iStatus = err;

            }

        else

            {

            // Notify client there is buffer ready to be filled

            iMsgBuffer.iStatus = iChunk.Handle();

            iMsgBuffer.iInt = iBufLen;

            iStatus = EStreaming;

            }

        iMsgBuffer.iRequest = ECmdFillBuffer;

        iMsgQueue.Send(iMsgBuffer);

        }

    TRACE_PRN_IF_ERR(err);

    //TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::BufferFilled

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::BufferFilled()

    {

    // TODO: Check D/S status to protect from call to PlayData prior to

    // PlayInitL, the case when D/S is stopped either by the user or due to

    // an error.

    TUint seqNum;

    TBool badFrame = EFalse;

    iShared.iMutex.Wait();

    iBufLen = iShared.iBufferSize; //length of data in the buffer

    seqNum = iShared.iSequenceNum;

    iShared.iMutex.Signal();

    TRACE_PRN_N1(_L("VoIP->DNL->BF: LEN[%d]"), iBufLen);

    if (iBufLen > iMaxBufLen)

        {

        iBufLen = iMaxBufLen;

        badFrame = ETrue;

        TRACE_PRN_N(_L("VoIP->DNL: BAD FRAME"));

        }

    // Copy data over from chunk

    TPtr8 dataPtr(iChunk.Base(), iBufLen, iMaxBufLen);

    if (iJitterBuffer && iCodecID != KMMFFourCCCodePCM16)

        {

        if (badFrame)

            {

            dataPtr.FillZ(); // JB will throw it away

            }

        // Send data to JB. When ready to play JB will call back via EventJB().

        iAddJBuffer->Data() = dataPtr;

        iAddJBuffer->SetFrameNumber(seqNum);

        iJitterBuffer->EmptyBuffer(iAddJBuffer);

        }

    else

        {

        if (iStatus == EStreaming)

            {

            if (badFrame)

                {

                ConcealErrorForNextBuffer();

                }

            // Fill D/S buffer and send it for playback

            iDevSoundBufPtr->Data() = dataPtr;

            iDevSound->PlayData();

            //TRACE_PRN_N1(_L("SAMPLES-PLAYED [%d]"), iSamplesPlayedCount++);

            }

        }

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::PlayError

// From MDevSoundObserver

// Record error is send to client over comm channel.

// The state of recorder is rolled back to EReady.

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::PlayError(TInt aError)

    {

    TRACE_PRN_IF_ERR(aError);

#ifdef _DEBUG

    iSamplesPlayedCount = 0;

#endif

    iStatus = EReady;

    SendCmd(ECmdDnLinkError, aError);

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::SetCodecCiL

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::SetCodecCiL()

    {

    TRACE_PRN_FN_ENT;

    if (iCodecID == KMccFourCCIdG711 ||

        iCodecID == KMccFourCCIdG729 ||

        iCodecID == KMccFourCCIdILBC ||

        iCodecID == KMccFourCCIdAMRNB)

        {

        if (!iErrConcealmentIntfc)

            {

            iErrConcealmentIntfc = CErrorConcealmentIntfc::NewL(*iDevSound);

            }

        }

    switch (iCodecID)

        {

        case KMccFourCCIdG711:

            {

            if (!iG711DecoderIntfc)

                {

                iG711DecoderIntfc = CG711DecoderIntfc::NewL(*iDevSound);

                }

            break;

            }

        case KMccFourCCIdG729:

            {

            if (!iG729DecoderIntfc)

                {

                iG729DecoderIntfc = CG729DecoderIntfc::NewL(*iDevSound);

                }

            break;

            }

        case KMccFourCCIdILBC:

            {

            if (!iIlbcDecoderIntfc)

                {

                iIlbcDecoderIntfc = CIlbcDecoderIntfc::NewL(*iDevSound);

                }

            break;

            }

        case KMccFourCCIdAMRNB:

        case KMMFFourCCCodePCM16:

        default:

            {

            break;

            }

        }

    TRACE_PRN_FN_EXT;

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::SetVolume

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::SetVolume()

    {

    iShared.iMutex.Wait();

    TInt vol = iShared.iInt;

    iShared.iMutex.Signal();

    iDevSound->SetVolume(vol);

    TRACE_PRN_N1(_L("VoIP->DNL: SetVolume [%d]"), vol);

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::GetVolume

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::GetVolume()

    {

    TInt vol = iDevSound->Volume();

    iShared.iMutex.Wait();

    iShared.iInt = vol;

    iShared.iMutex.Signal();

    SendCmd(ECmdGetVolumeComplete);

    }

// -----------------------------------------------------------------------------

// CVoIPDownlinkThread::SetAudioDeviceL

//

// -----------------------------------------------------------------------------

//

void CVoIPDownlinkThread::SetAudioDeviceL()

    {

    TRACE_PRN_FN_ENT;

    iShared.iMutex.Wait();

    TUint device = iShared.iAudioDevice;

    iShared.iMutex.Signal();

    if (!iAudioOutput)

        {

        iAudioOutput = CAudioOutput::NewL(*iDevSound);

        }

    if (iAudioOutput)

        {

        // ENoPreference=0, EAll=1, ENoOutput=2, EPrivate=3, EPublic=4

        CAudioOutput::TAudioOutputPreference outputDev;

        if (CVoIPAudioDownlinkStream::TVoIPOutputDevice(device) ==

                CVoIPAudioDownlinkStream::EHandset)

            {

            outputDev = CAudioOutput::EPrivate;

            }

        else if (CVoIPAudioDownlinkStream::TVoIPOutputDevice(device) ==

                CVoIPAudioDownlinkStream::ELoudSpeaker)

            {

            outputDev = CAudioOutput::EPublic;

            }

        else // Use default device routing

            {