/*

* 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 ),

    {

    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 ) );

    } 

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

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

    }        

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