/*

* Copyright (c) 2004-2007 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 "mmcccodecinformation.h"

#include "mccjitterbufferimpl.h"

#include "mcccngenerator.h"

#include "mccinternalevents.h"

#include "mccinternaldef.h"

#include "mccjitterbufferlogs.h"

#include "mccjitterbufferobserver.h"

// LOCAL CONSTANTS

const TInt KDefaultSampleRateInkHz = 8;

const TInt KWbSampleRateInkHz = 16;

const TInt KLowBufferLimit = 2;

const TInt KOverflowAlarmLimit = 20;

const TInt KSequentialLateFramesLimit = 20;

// Codec frame sizes

const TInt KAMRNBFrameSize = 32;

const TInt KAMRWBFrameSize = 64;

const TInt KILBCFrameSize = 52;

const TInt KG729FrameSize = 24; // 10 octets + 2 for header

// Maximum possible sequence number of RTP packet with standard RTP header.

const TInt KMaxSeqNumber = 65535;        // 16-bit value

// Codec frame times

const TInt KAMRNBFrameTime = 20;

// ============================= LOCAL FUNCTIONS ===============================

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

// 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.iStamp > aElem2.iStamp )

        {

        return (-1);

        }

    else if ( aElem1.iStamp < aElem2.iStamp )

        {

        return (1);

        }

    else

        {

        return (0);

        }

    }

// ============================ MEMBER FUNCTIONS ===============================

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

// CMccJitterBufferImpl::CMccJitterBufferImpl

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

// might leave.

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

//

CMccJitterBufferImpl::CMccJitterBufferImpl( MJitterBufferObserver* aObserver): 

		iPacketsInBuffer( 0 ), 

        iLastGetSeqNum( -1 ), 

        iBufStampSorter( 

            TLinearOrder<TJitterBufferElement>( TJitterBufferElement::CompareStamp ) 

            ),

        iBufSequenceSorter( 

            TLinearOrder<TJitterBufferElement>( TJitterBufferElement::CompareSeqNum ) 

            ),

        iSeqNumIncrement( 0 ),

        iPlay( EFalse ),

        iObserver( aObserver ),

        iOverflowCounter( 0 ),

        iPlayToneInterval( 0 ),

        iNotifyUser( ETrue ),

        iLatestNotifiedEvent( KMccEventNone ),

        iSampleRate( KDefaultSampleRateInkHz )

    {

    iTonePlayTime.UniversalTime();

    }

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

// CMccJitterBufferImpl::NewL

// Static constructor.

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

//

CMccJitterBufferImpl* CMccJitterBufferImpl::NewL( MJitterBufferObserver* aObserver )

    {

    __JITTER_BUFFER( "CMccJitterBufferImpl::NewL 64bit version" )

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccJitterBufferImpl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMccJitterBufferImpl::ConstructL()

    {

    SetBufferState( EIdle );

    SendStreamEventToClient( KMccStreamIdle, ETrue );

    }

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

// CMccJitterBufferImpl::~CMccJitterBufferImpl

// Destructor deallocate memory.

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

//

CMccJitterBufferImpl::~CMccJitterBufferImpl()

    {

    __JITTER_BUFFER( "CMccJitterBufferImpl::~CMccJitterBufferImpl entry" )

    delete iCnGenerator;    

    // Deallocate payload memory of jitter buffer elements.

    const TInt count = iBuffer.Count();

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

        {

        delete iBuffer[i].iDataFrame;

        } 

    iBuffer.Close();

    iObserver = NULL;

    __JITTER_BUFFER( "CMccJitterBufferImpl::~CMccJitterBufferImpl exit" )

    }

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

// CMccJitterBufferImpl::SetupL

// Setup Jitterbuffer

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

//

void CMccJitterBufferImpl::SetupL( 

    TInt aPlayoutThreshold, 

    const TMccCodecInfo& aCInfo, 

    CMMFDevSound& aDevSound, 

    MAsyncEventHandler* aEventHandler,

    TUint32 aEndpointId )

    {

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iJitterBufBufferLength:",

                          aCInfo.iJitterBufBufferLength )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aPlayoutThreshold:",

                          aPlayoutThreshold )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iJitterBufInactivityTimeOut:",

                          aCInfo.iJitterBufInactivityTimeOut )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iJitterBufPlayToneTimeout:",

                          aCInfo.iJitterBufPlayToneTimeout )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iJitterBufPlayToneFrequency:",

                          aCInfo.iJitterBufPlayToneFrequency )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iJitterBufPlayToneDuration:",

                          aCInfo.iJitterBufPlayToneDuration )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iHwFrameTime:",

                          aCInfo.iHwFrameTime )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL aCInfo.iPtime:",

                          aCInfo.iPtime )

    // Changed if-statement to asserts. Added also check agains 0 hwframetime

    __ASSERT_ALWAYS( aCInfo.iPtime, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( aCInfo.iJitterBufBufferLength, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( aCInfo.iHwFrameTime, User::Leave( KErrArgument ) );

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

    // dynamic G.711 adjustment.

    const TUint8 origHwtime = iCInfo.iHwFrameTime;

    iCInfo = aCInfo;

    iEventHandler = aEventHandler;

    iEndpointId = aEndpointId;

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL origHwtime:", origHwtime )

    if( iCInfo.iJitterBufInactivityTimeOut )

        {

        if( ( iCInfo.iJitterBufPlayToneFrequency > 0 ) && 

            ( iCInfo.iJitterBufPlayToneDuration > 0 ) )

            {

            iPlayToneInterval = iCInfo.iJitterBufPlayToneTimeout;            

            iPlay = ETrue;

            }

        }

    TInt bufLenMultiplier = 1;

    if ( iCInfo.iFourCC == KMMFFourCCCodeAMR )

        {

        iFrameSize = KAMRNBFrameSize;

        iFrameTime = KAMRNBFrameTime;

        }

    else if ( iCInfo.iFourCC == KMMFFourCCCodeAWB )

        {   

        iFrameSize = KAMRWBFrameSize;

        iFrameTime = KAMRNBFrameTime;

        iSampleRate = KWbSampleRateInkHz;

        }

    else if( iCInfo.iFourCC == KMccFourCCIdG711 )

        {

        // G.711 is configured dynamically. Take voip headerlength also in to

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

        iFrameSize = ( iCInfo.iHwFrameTime * KDefaultSampleRateInkHz )

            + KVoIPHeaderLength;

        iFrameTime = 0;

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

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

        // 10ms. 

        if ( origHwtime )

            {

            bufLenMultiplier = origHwtime / iCInfo.iHwFrameTime;

            if ( !bufLenMultiplier )

                {

                bufLenMultiplier = 1;

                }

            }

        }

    else if( iCInfo.iFourCC == KMccFourCCIdILBC )

        {

        iFrameSize = KILBCFrameSize;

        iFrameTime = 0;

        }

    else if( iCInfo.iFourCC == KMccFourCCIdG729 )

        {

        iFrameSize = KG729FrameSize;

        iFrameTime = 0;

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

        bufLenMultiplier = 2;

        }

    else

        {

        __JITTER_BUFFER( "CMccJitterBufferImpl::SetupL KErrNotSupported" )

        User::Leave( KErrNotSupported );

        }

    // Delete old buffer & reset it

    const TInt elems = iBuffer.Count();

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

        {

        delete iBuffer[i].iDataFrame;

        iBuffer[i].iDataFrame = NULL;

        }

    iBuffer.Reset();

    // Calculate needed elements

    TInt bufLen = iCInfo.iJitterBufBufferLength * bufLenMultiplier;

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL G.711 bufLenMultiplier ",

        bufLenMultiplier )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::SetupL iBufferLength: ",

        bufLen )

    __ASSERT_ALWAYS( aPlayoutThreshold < bufLen, User::Leave( KErrTooBig ) );

    // if differences between bufferlength and treshold set by client

    // is less than 10, increase bufferlength so the differences is 10

    // this is to help buffer goes to overflow easily.

    // Also possible G.711/729 multiplier needs to be taken care of.

    CheckThresholdBufferLength( bufLen, aPlayoutThreshold );

    iCurrentPlayThreshold = aPlayoutThreshold * bufLenMultiplier;

    iOriginalPlayThreshold = aPlayoutThreshold * bufLenMultiplier;

    if( iCnGenerator )

        {

        delete iCnGenerator;

        iCnGenerator = NULL;

        }

    iCnGenerator = CMccCnGenerator::NewL( iCInfo.iFourCC, aDevSound );

    // Create the elements in the Buffer

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

        {

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

        CleanupStack::PushL( buf );

        TJitterBufferElement newElement;

        newElement.iDataFrame = buf;

        newElement.iSequenceNumber = -1;

        newElement.iStamp = -1;

        iBuffer.AppendL( newElement );

        CleanupStack::Pop( buf );

        }

    // Zero the statistic members

    iFramesLost = 0;

    iFramesReceived = 0;

    iNumOfLateFrames = 0;

    iFramesRemoved = 0;

    iFramesPlayed = 0;

    iPacketsInBuffer = 0;

    // Calculate the sequence number increment

    iSeqNumIncrement = iSampleRate * iCInfo.iHwFrameTime;

    } 

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

// CMccJitterBufferImpl::ResetBufferL

// Reset Jitterbuffer

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

//

void CMccJitterBufferImpl::ResetBuffer( TBool aPlayTone, TBool aNotifyUser )

    {

    const TInt bufLen = BufferLength();

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::ResetBuffer bufLen: ", bufLen )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::ResetBuffer pktsIn: ", iPacketsInBuffer )

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

        {

        iBuffer[i].iSequenceNumber = -1;

        iBuffer[i].iStamp = -1;

        }

    iLastGetSeqNum = -1;

    iCurrentPlayThreshold = iOriginalPlayThreshold;

    iPacketsInBuffer = 0; 

    iPlay = aPlayTone; 

    if ( BufferState() != EIdle && 

         aNotifyUser && 

         iLatestNotifiedEvent != KMccStreamIdle )

        {

        SendStreamEventToClient( KMccStreamIdle, ETrue );

        }

    SetBufferState( EIdle );

    iDropNextFrame = EFalse;

    }

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

// CMccJitterBufferImpl::CurrentCodec

// Return current codec.

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

//

TFourCC CMccJitterBufferImpl::CurrentCodec() const

    {

    return iCInfo.iFourCC;

    }

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

// CMccJitterBufferImpl::DelayUpL

// Adds a buffer element into the jitter buffer

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

//

void CMccJitterBufferImpl::DelayUpL()

    {

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

    CleanupStack::PushL( buf );

    TJitterBufferElement newElement;

    newElement.iDataFrame = buf;

    newElement.iSequenceNumber = -1;

    newElement.iStamp = -1;

    iBuffer.AppendL( newElement );

    CleanupStack::Pop( buf );

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

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

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

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

    // starting playout.

    if( 0 == iCurrentPlayThreshold )

        {

        __JITTER_BUFFER( "CMccJitterBufferImpl::DelayUpL Adjusting Playout Threshold" )

        iCurrentPlayThreshold = iPacketsInBuffer + 1;

        }

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::DelayUpL BUF_LEN:", BufferLength() )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::DelayUpL CUR_FRAMES:", iPacketsInBuffer )

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::DelayUpL PLAY_TH:", iCurrentPlayThreshold )

    }

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

// CMccJitterBufferImpl::DelayDownL

// Removes an buffer element from the jitter buffer

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

//

void CMccJitterBufferImpl::DelayDownL()

    {

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

    const TInt bufLen = BufferLength();

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::DelayDownL BUF_LEN:", bufLen )

    __JITTER_BUFFER_INT1("CMccJitterBufferImpl::DelayDownL CUR_FRAMES:", iPacketsInBuffer )

    if( this->IsEmpty() )

        {

        // Cannot do anything for empty buffer

        if( KLowBufferLimit < bufLen )

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Empty buffer" )

            delete iBuffer[bufLen - 1].iDataFrame;

            iBuffer.Remove( bufLen - 1 );

            }

        else if( 0 < iCurrentPlayThreshold )

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Playthreshold modification" )

            iCurrentPlayThreshold--;

            }

        else

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Buffer empty, cant do anything" )

            // Cannot do anything currently

            return;

            }

        }

    else if( this->IsFull() )

        {

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

        // frame and mark the one preceding it bad

        if( KLowBufferLimit < iPacketsInBuffer )

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Buffer full, doing removal" )

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

            delete iBuffer[1].iDataFrame;

            iBuffer.Remove( 1 );

            // MARK THE FIRST AS BAD FRAME!!!

            iPacketsInBuffer--;

            iFramesRemoved++;

            }

        else

            {

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

            if( 0 < iCurrentPlayThreshold )

                {

                __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Buffer full, cant do anything" )

                iCurrentPlayThreshold--;

                }

            }

        }

    else

        {

        if( KLowBufferLimit < bufLen )

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Some frames, adjusting length" )

            // Adjust the length of the buffer

            delete iBuffer[bufLen - 1].iDataFrame;

            iBuffer.Remove( bufLen - 1 );

            }

        else

            {

            __JITTER_BUFFER( "CMccJitterBufferImpl::DelayDownL Some frames, too small buffer" )

            }

        }

    }

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

// CMccJitterBufferImpl::CalculateDelay

// Calculates the current delay that jitterbuffer has in the playback

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

//

TTimeIntervalMicroSeconds32 CMccJitterBufferImpl::CalculateDelay() const

    {

    __JITTER_BUFFER_INT1( "CMccJitterBufferImpl::CalculateDelay:", iCInfo.iPtime * iPacketsInBuffer )

    return iCInfo.iPtime * iPacketsInBuffer;

    }        

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

// CMccJitterBufferImpl::AddDataFrameL

// Adds a audio frame into the jitterbuffer passed in the aDataBuffer

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

//

void CMccJitterBufferImpl::AddDataFrameL( CMMFBuffer* aDataBuffer )

    {

    User::LeaveIfNull( aDataBuffer );

    const TInt64 seqNum = aDataBuffer->FrameNumber();

    iFramesReceived++;