/*

* Copyright (c) 2008 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:  Implementation of Mcc Jitterbuffer

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <mmcccodecinformation.h> //codec FourCC declarations

#include "debugtracemacros.h"

#include "CngGenerator.h"

#include "InternalDef.h"

#include "JitterBufferObserver.h"

#include "JitterBufferImpl.h"

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

// TJitterBufferElement::CompareSeqNum

// Compare SequenceNumber

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

//

TInt TJitterBufferElement::CompareSeqNum(const TJitterBufferElement& aElem1,

                                         const TJitterBufferElement& aElem2)

    {

    if (aElem1.iSequenceNumber > aElem2.iSequenceNumber)

        {

        return (-1);

        }

    else if (aElem1.iSequenceNumber < aElem2.iSequenceNumber)

        {

        return (1);

        }

    else

        {

        return (0);

        }

    }

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

// TJitterBufferElement::CompareStamp

// Compare Stamp

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

//

TInt TJitterBufferElement::CompareStamp(const TJitterBufferElement& aElem1,

                                        const TJitterBufferElement& aElem2)

    {

    if (aElem1.iTimeStamp > aElem2.iTimeStamp)

        {

        return (-1);

        }

    else if (aElem1.iTimeStamp < aElem2.iTimeStamp)

        {

        return (1);

        }

    else

        {

        return (0);

        }

    }

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

// CVoIPJitterBufferImpl::CVoIPJitterBufferImpl

// C++ default constructor can NOT contain any code, that might leave.

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

//

CVoIPJitterBufferImpl::CVoIPJitterBufferImpl(MJitterBufferObserver* aObserver) :

    iBufStampSorter(TLinearOrder<TJitterBufferElement>(

                    TJitterBufferElement::CompareStamp)),

    iBufSequenceSorter(TLinearOrder<TJitterBufferElement>(

                    TJitterBufferElement::CompareSeqNum))

    {

    iObserver = aObserver;

    iTonePlayTime.UniversalTime();

    iSampleRate = KDefaultSampleRateInkHz;

    iPlay = EFalse;

    iLastPlayedSeqNum = -1;

    }

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

// CVoIPJitterBufferImpl::NewL

// Static constructor.

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

//

CVoIPJitterBufferImpl* CVoIPJitterBufferImpl::NewL(

                                              MJitterBufferObserver* aObserver)

    {

    CVoIPJitterBufferImpl* self = new(ELeave) CVoIPJitterBufferImpl(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// CVoIPJitterBufferImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVoIPJitterBufferImpl::ConstructL()

    {

    }

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

// CVoIPJitterBufferImpl::~CVoIPJitterBufferImpl

// Destructor deallocate memory.

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

//

CVoIPJitterBufferImpl::~CVoIPJitterBufferImpl()

    {

    TRACE_PRN_FN_ENT;

    delete iCNGenerator;

    // Deallocate payload memory of jitter buffer elements.

    TInt count = iBuffer.Count();

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

        {

        if (iBuffer[i].iDataFrame)

            {

            delete iBuffer[i].iDataFrame;

            }

        }

    iBuffer.Close();

    TRACE_PRN_FN_EXT;

    }

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

// CVoIPJitterBufferImpl::SetupL

// Setup Jitter buffer

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

//

void CVoIPJitterBufferImpl::SetupL(const TFourCC aCodec,

                                   const TVoIPJBConfig& aJBConfig)

    {

    TRACE_PRN_FN_ENT;

    __ASSERT_ALWAYS(aJBConfig.iJitterLatency, User::Leave(KErrArgument));

    __ASSERT_ALWAYS(aJBConfig.iJBBufferLength, User::Leave(KErrArgument));

    __ASSERT_ALWAYS(aJBConfig.iSampleInterval, User::Leave(KErrArgument));

    // Save the original HW frame time because we may need it in case of

    // dynamic G.711 adjustment.

    const TUint8 origHwtime = iJBConfig.iSampleInterval;

    iJBConfig = aJBConfig;

    if (iJBConfig.iJBInactivityTimeOut)

        {

        if ((iJBConfig.iJBPlayToneFrequency > 0) &&

            (iJBConfig.iJBPlayToneDuration > 0))

            {

            iPlayToneInterval = iJBConfig.iJBPlayToneTimeout;

            iPlay = ETrue;

            }

        }

    TInt bufLenMultiplier = 1;

    if (aCodec == KMMFFourCCCodeAMR)

        {

        iFrameSize = KAMRNBFrameSize;

        iSampleInterval = KAMRNBFrameTime;

        }

    else if (aCodec == KMccFourCCIdG711)

        {

        // G.711 is configured dynamically. Take voip headerlength also into

        // account. G.711 hwframetime is in milliseconds, so need to multiply.

        iFrameSize = (iJBConfig.iSampleInterval * KDefaultSampleRateInkHz) +

                     KVoIPHeaderLength;

        iSampleInterval = 0;

        // In case of G.711 codec dynamic configuration, we may need to double

        // the jitter buffer length if HW frame time is changed from 20ms to

        // 10ms.

        if (origHwtime)

            {

            bufLenMultiplier = origHwtime / iJBConfig.iSampleInterval;

            if (!bufLenMultiplier)

                {

                bufLenMultiplier = 1;

                }

            }

        }

    else if (aCodec == KMccFourCCIdILBC)

        {

        iFrameSize = KILBCFrameSize;

        iSampleInterval = 0;

        }

    else if (aCodec == KMccFourCCIdG729)

        {

        iFrameSize = KG729FrameSize;

        iSampleInterval = 0;

        // Multiply G.729 also by two...

        bufLenMultiplier = 2;

        }

    else

        {

        TRACE_PRN_N(_L("JB-> Codec Not Supported"));

        User::Leave(KErrNotSupported);

        }

    // Delete and reset old buffer

    const TInt elems = iBuffer.Count();

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

        {

        if ((iBuffer[i].iDataFrame))

            {

            delete iBuffer[i].iDataFrame;

            iBuffer[i].iDataFrame = NULL;

            }

        }

    iBuffer.Reset();

    // Calculate needed elements

    iBufferLength = iJBConfig.iJBBufferLength * bufLenMultiplier;

    if (iJBConfig.iJBThreshold >= iBufferLength)

    	{

    	// adjust threshold size (no need to leave here)

    	iJBConfig.iJBThreshold = iBufferLength / 2;

    	}

    // If the difference between buffer length and threshold is less than 10

    // increase buffer length, so the differences is 10. This helps handle

    // buffer overflow more easily.

    CheckThresholdBufferLength(iBufferLength, iJBConfig.iJBThreshold);

    iCurrentPlayThreshold = iJBConfig.iJBThreshold;

    iOriginalPlayThreshold = iJBConfig.iJBThreshold;

    if (iCNGenerator)

        {

        delete iCNGenerator;

        iCNGenerator = NULL;

        }

    iCNGenerator = CVoIPCNGenerator::NewL(iObserver, aCodec);

    // Create the elements in the Buffer

    for (TInt k = 0; k < iBufferLength; k++)

        {

        CMMFDataBuffer* buf = CMMFDataBuffer::NewL(iFrameSize);

        CleanupStack::PushL(buf);

        TJitterBufferElement newElement;

        newElement.iDataFrame = buf;

        newElement.iSequenceNumber = -1;

        newElement.iTimeStamp = -1;

        iBuffer.AppendL(newElement);

        CleanupStack::Pop(buf);

        }

    // Reset statistics

    iFramesLost = 0;

    iFramesReceived = 0;

    iNumOfLateFrames = 0;

    iFramesRemoved = 0;

    iFramesPlayed = 0;

    iPacketsInBuffer = 0;

    // Calculate the sequence number increment

    iSeqNumIncrement = iSampleRate * iJBConfig.iSampleInterval;

    TRACE_PRN_FN_EXT;

    }

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

// CVoIPJitterBufferImpl::ResetBufferL

// Reset Jitter Buffer

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

//

void CVoIPJitterBufferImpl::ResetBuffer(TBool aPlayTone)

    {

    TRACE_PRN_FN_ENT;

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

        {

        iBuffer[i].iSequenceNumber = -1;

        iBuffer[i].iTimeStamp = -1;

        }

    iLastPlayedSeqNum = -1;

    iCurrentPlayThreshold = iOriginalPlayThreshold;

    iPacketsInBuffer = 0;

    iPlay = aPlayTone;

    TRACE_PRN_FN_EXT;

    }

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

// CVoIPJitterBufferImpl::DelayUpL

// Adds a buffer element into the jitter buffer

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

//

void CVoIPJitterBufferImpl::DelayUpL()

    {

    TRACE_PRN_FN_ENT;

    CMMFDataBuffer* buf = CMMFDataBuffer::NewL(iFrameSize);

    CleanupStack::PushL(buf);

    TJitterBufferElement newElement;

    newElement.iDataFrame = buf;

    newElement.iSequenceNumber = -1;

    newElement.iTimeStamp = -1;

    iBuffer.AppendL(newElement);

    CleanupStack::Pop(buf);

    iBufferLength++;

    // Insert one NO_DATA frame into the audio stream, so the jitterbuffer has

    // the possibility to grow at least one frame from the current size. If

    // the current playout threshold is zero, then there is ongoing playback or

    // a DTX period. This means that we should buffer at least one frame before

    // starting playback.

    if (iCurrentPlayThreshold == 0)

        {

        TRACE_PRN_N(_L("JB-> Adjusting Playback Threshold"));

        iCurrentPlayThreshold = iPacketsInBuffer + 1;

        }

    TRACE_PRN_N1(_L("JB-DelayUpL-> BUF_LEN [%d]"), iBufferLength);

    TRACE_PRN_N1(_L("JB-DelayUpL-> CUR_FRAMES [%d]"), iPacketsInBuffer);

    TRACE_PRN_N1(_L("JB-DelayUpL-> PLAY_TH [%d]"), iCurrentPlayThreshold);

    TRACE_PRN_FN_EXT;

    }

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

// CVoIPJitterBufferImpl::DelayDownL

// Removes an buffer element from the jitter buffer

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

//

void CVoIPJitterBufferImpl::DelayDownL()

    {

    TRACE_PRN_FN_ENT;

    // We need to remove one frame from the jitterbuffer. If currently we are

    // in a DTX period, we're in luck as we do not affect voice quality at all.

    // DURING DTX:

    // During DTX periods the jitterbuffer can be empty, so we cannot remove

    // anything from nothing. Then we basically can remove one element from the

    // buffer so it is shorter.

    // DURING SPEECH:

    // We'll need to remove one audio frame and mark the one preceding the

    // removed frame as bad. Then we'll continue as usual.

    TRACE_PRN_N1(_L("JB-DelayDownL-> BUF_LEN [%d]"), iBufferLength);

    TRACE_PRN_N1(_L("JB-DelayDownL-> CUR_FRAMES [%d]"), iPacketsInBuffer);

    if (IsEmpty())

        {

        // Cannot do anything for empty buffer

        if (KLowBufferLimit < iBufferLength)

            {

            TRACE_PRN_N(_L("JB-DelayDownL-> Empty buffer"));

            delete iBuffer[iBufferLength - 1].iDataFrame;

            iBuffer.Remove(iBufferLength - 1);

            iBufferLength--;

            }

        else if (iCurrentPlayThreshold > 0)

            {

            TRACE_PRN_N(_L("JB-DelayDownL-> Play threshold modification"));

            iCurrentPlayThreshold--;

            }

        else

            {

            // Cannot do anything currently

            TRACE_PRN_N(_L("JB-DelayDownL-> Buffer empty - Do nothing"));

            return;

            }

        }

    else if (IsFull())

        {

        // If there is sufficiently data in the buffer, then remove one

        // frame and mark the one preceding it bad

        if (KLowBufferLimit < iPacketsInBuffer)

            {

            TRACE_PRN_N(_L("JB-DelayDownL-> Buffer full - Removing"));

            // Remove the 2nd oldest frame and mark the oldest as bad

            delete iBuffer[1].iDataFrame;

            iBuffer.Remove(1);

            // MARK THE FIRST AS BAD FRAME!!!

            iBufferLength--;

            iPacketsInBuffer--;

            iFramesRemoved++;

            }

        else

            {

            // Cant do removing, see if playthreshold can be adjusted

            if (iCurrentPlayThreshold > 0)

                {

                TRACE_PRN_N(_L("JB-DelayDownL-> Buffer full - Do nothing"));

                iCurrentPlayThreshold--;

                }

            }

        }

    else

        {

        if (KLowBufferLimit < iBufferLength)

            {

            TRACE_PRN_N(_L("JB-DelayDownL-> Adjusting frame length"));

            // Adjust the length of the buffer

            delete iBuffer[iBufferLength - 1].iDataFrame;

            iBuffer.Remove(iBufferLength - 1);

            iBufferLength--;

            }

        else

            {

            TRACE_PRN_N(_L("JB-DelayDownL-> Buffer too small"));

            }

        }

    TRACE_PRN_FN_EXT;

    }

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

// CVoIPJitterBufferImpl::CalculateDelay

// Calculates the current jitter buffer playback

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

//

TTimeIntervalMicroSeconds32 CVoIPJitterBufferImpl::CalculateDelay() const

    {

    TTimeIntervalMicroSeconds32 delay =

                                iJBConfig.iJitterLatency * iPacketsInBuffer;

//    TRACE_PRN_N1(_L("JB-CalculateDelay-> Delay [%d]"), delay);

    return delay;

    }

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

// CVoIPJitterBufferImpl::AddDataFrame

// Adds audio frame into the jitter buffer

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

//

TInt CVoIPJitterBufferImpl::AddDataFrame(CMMFBuffer* aDataBuffer)

    {

    if (aDataBuffer == NULL)

        {

        return KErrNotReady;

        }

    iCurrentSeqNum = aDataBuffer->FrameNumber();

    iFramesReceived++;

    // TODO: && TBD: Playout threshold update & re-buffering when starting

    // a new talk-burst.

    //

    // 1. If sender does not use inbaund DTX signalling.

    //  1.1 We may start re-buffering and sender goes into DTX mode again

    //      => We may not reach the playout threshold if the talkspurt is short

    //      => Also some random babble noise may activate the sender temporarily

    //      => The babble noise frame never gets played or some of these frames

    //         never get played.

    //

    // 2. If sender does use inband DTX signalling

    //  2.1 We can see the start of the DTX period which is cheked in

    //      GetDataFrameL()

    //  2.2 During DTX period we may detect the end of the DTX period &

    //      updates during the DTX period.

    //

    // 3. Packet loss may affect in the DTX detection.

    //  3.1 DTX start packet may be lost

    //  3.2 DTX UPDATE packet may be lost (if used)

    //

    TUint index = FindLargestSeqNum();

    if (iLastPlayedSeqNum < KMaxSeqNumber - iSeqNumIncrement)

        {

        iIsWrappedAround = IsSeqNumWrappedAround(iLargestSeqNum,

                                                 iCurrentSeqNum);    

        }

    else

        {

        // If the last played frame was larger than the current largest

        // in JB we are most likely running in the wrap-around mode.

        iIsWrappedAround = IsSeqNumWrappedAround(iLastPlayedSeqNum,

                                                 iLargestSeqNum);

        }

    if (iIsWrappedAround)

        {

        iLastPlayedSeqNum = -1;

        }

    TRACE_PRN_N1(_L("JB-> [ADD] LARGEST IN  [%d]"), TInt32(iLargestSeqNum));

    TRACE_PRN_N1(_L("JB-> [ADD] THIS FRAME  [%d]"), TInt32(iCurrentSeqNum));

    TRACE_PRN_N1(_L("JB-> [ADD] LAST PLAYED [%d]"), TInt32(iLastPlayedSeqNum));

    TRACE_PRN_N1(_L("JB-> [ADD] PACKETS [%d]"), iPacketsInBuffer);

    iDataBuffer = static_cast<CMMFDataBuffer*>(aDataBuffer);

    if (iCurrentSeqNum > iLastPlayedSeqNum)

        {

        if (IsFull())

            {

            TRACE_PRN_N(_L("JB-> [ADD] BUFFER OVERFLOW"));

            // Remove the oldest frame from the buffer

            iLastPlayedSeqNum = iBuffer[iPacketsInBuffer - 1].iSequenceNumber;

            iBuffer[iPacketsInBuffer - 1].iSequenceNumber = -1;

            iBuffer[iPacketsInBuffer - 1].iTimeStamp = -1;

            iPacketsInBuffer--;