/*

* Copyright (c) 2006 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:    

*

*/

// INCLUDE FILES

#include "mccvideosinkuser.h"

#include "mccvideosourcesinklogs.h"

#include "mccdef.h"

#include "mccinternaldef.h"

#include <CXPSPacketSink.h>

// CONSTANTS

const TUint32 KMccModifyMonitoringShortPeriodMicrosecs = 2000000;

const TUint32 KMccModifyMonitoringLongPeriodMicrosecs = 10000000;

const TUint32 KMccMaxDenyPeriodMicrosecs = 1000000;

const TReal KMccMonitoringShortPeriodTimestampIncreaseFactorDown = 0.6;

const TReal KMccMonitoringShortPeriodTimestampIncreaseFactorUp = 1.4;

const TReal KMccMonitoringLongPeriodTimestampIncreaseFactorDown = 0.8;

const TReal KMccMonitoringLongPeriodTimestampIncreaseFactorUp = 1.2;

const TInt KMccJitterBufferThresholdPacketTime = 20;

// Minimum times for preroll

const TInt KMccOneMediaMinPreroll = 1000;

const TInt KMccSeveralMediaMinPreroll = 2000;

// MACROS

#define MCC_CONVERT_TO_90KHZ_CLOCK( valInMicroSecs ) ( valInMicroSecs / 100 * 9 )

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

// TMccTimeStampEntry::TMccTimeStampEntry

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

//

TMccTimeStampEntry::TMccTimeStampEntry() : 

    iTime( 0 ), iSeq( 0 )

    {

    }

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

// TMccTimeStampEntry::TMccTimeStampEntry

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

//    

TMccTimeStampEntry::TMccTimeStampEntry( TInt64 aTime, TUint16 aSeq ) :

    iTime( aTime ), iSeq( aSeq )

    {

    }

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

// CMccVideoSinkUser::NewL

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

//

CMccVideoSinkUser* CMccVideoSinkUser::NewL( 

    MAsyncEventHandler* aAsyncEventHandler, 

    TUid aMediaType,

    TUint aStreamId,

    TReal aFrameRate,

    CXPSPacketSink& aPacketSink )

    {

    CMccVideoSinkUser* self = 

        CMccVideoSinkUser::NewLC( aAsyncEventHandler,

                                  aMediaType,

                                  aStreamId,

                                  aFrameRate,

                                  aPacketSink );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMccVideoSinkUser::NewLC

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

//

CMccVideoSinkUser* CMccVideoSinkUser::NewLC( 

    MAsyncEventHandler* aAsyncEventHandler, 

    TUid aMediaType,

    TUint aStreamId,

    TReal aFrameRate,

    CXPSPacketSink& aPacketSink )

    {

    CMccVideoSinkUser* self = 

        new ( ELeave ) CMccVideoSinkUser( 

            aAsyncEventHandler, aMediaType, aStreamId, aFrameRate, aPacketSink );

    CleanupStack::PushL( self );

    return self;

    }

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

// CMccVideoSinkUser::~CMccVideoSinkUser

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

//        

CMccVideoSinkUser::~CMccVideoSinkUser()

    {

    delete iJitterBuf;

    }

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

// CMccVideoSinkUser::CMccVideoSinkUser

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

//

CMccVideoSinkUser::CMccVideoSinkUser( 

    MAsyncEventHandler* aAsyncEventHandler, 

    TUid aMediaType,

    TUint aStreamId,

    TReal aFrameRate,

    CXPSPacketSink& aPacketSink ) :

    iAsyncEventHandler( aAsyncEventHandler ),

    iMediaType( aMediaType ),

    iStreamId( aStreamId ),

    iStartedOnce( EFalse ),

    iFrameRate( aFrameRate ),

    iPacketSink( aPacketSink ),

    iPacketOverflowState( ENormal ),

    iNumTimeStamps( 0 ),

    iAverageTimeStampDifference( 0 ),

    iResetNeeded( EFalse ),

    iModifyMode( EModifyInit ),

    iFirstModifyCheck( 0 ),

    iFirstModifyCheckTimestamp( 0 ),

    iFirstTimestamp( 0 ),

    iAllowFrame( ETrue ),

    iDenyFramesStarted( 0 ),

    iMultipleMediaTypes( EFalse ),

    iPreviousPacketOriginalTimeStamp( KMaxTUint32 ),

    iPreviousPacketModifiedTimeStamp( 0 ),

    iPreviousPacketTime( 0 ),

    iCurrentMonitoringPeriod( KMccModifyMonitoringShortPeriodMicrosecs ),

    iTimestampIncreaseFactorDown( KMccMonitoringShortPeriodTimestampIncreaseFactorDown ),

    iTimestampIncreaseFactorUp( KMccMonitoringShortPeriodTimestampIncreaseFactorUp )

    {

    } 

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

// CMccVideoSinkUser::EnqueueL

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

//

CMccVideoJitterBuffer::TMccPacketBufferingStatus CMccVideoSinkUser::EnqueueL( 

    const TRtpRecvHeader& aHeaderInfo, const TDesC8& aPayloadData )

    {

    CMccVideoJitterBuffer::TMccPacketBufferingStatus 

        bufferingStatus( CMccVideoJitterBuffer::EPlaying );

    if ( aPayloadData.Length() > GetPayloadSize() )

        {

        // Too big buffer causes playback to stop at Helix, drop the packet

        // silently

        __V_SOURCESINK_CONTROLL( 

            "CMccVideoSinkUser::EnqueueL, Too big packet dropped" ) 

        }

    else if ( iJitterBuf )

        {

        TBool importantPacket = CodecSpecificDataHandling( aPayloadData );

        bufferingStatus = iJitterBuf->EnqueueL( iStreamId, 

                                                aHeaderInfo, 

                                                aPayloadData, 

                                                importantPacket );

        }

    else

        {

        TInt err = iPacketSink.Enqueue( iStreamId, aHeaderInfo, aPayloadData );

        if ( err )

            {

            CheckErrorL( err );

            }

        }

    return bufferingStatus;

    }

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

// CMccVideoSinkUser::Set

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

//

void CMccVideoSinkUser::Set( 

    MAsyncEventHandler* aAsyncEventHandler, 

    TUid aMediaType,

    TUint aStreamId )

    {

    iAsyncEventHandler = aAsyncEventHandler;

    iMediaType = aMediaType;

    iStreamId = aStreamId;

    }

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

// CMccVideoSinkUser::SetFrameRateL

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

//    

void CMccVideoSinkUser::SetFrameRateL( TReal aFrameRate )

    {

    if ( aFrameRate != iFrameRate )

        {

        if ( iJitterBuf )

            {

            __V_SOURCESINK_CONTROLL( 

            "CMccVideoSinkUser::SetFrameRateL, configure jitterbuffer" ) 

            iJitterBuf->ConfigureL( KMccJitterBufferDefaultLowLimit, 

                                    KMccJitterBufferDefaultHighLimit, 

                                    KMccJitterBufferDefaultPlayThreshold,

                                    KMccJitterBufferDefaultMaxSize,

                                    aFrameRate );

            }

        iFrameRate = aFrameRate;

        }

    }

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

// CMccVideoSinkUser::GetPreroll

// Helix does not restrict min preroll (buffering time) but it is safer to

// have some  restriction as otherwise continuous buffering may occur if

// Helix side buffering is used. If we are on real time mode, buffering

// is handled at MCC side (this is indicated with preroll value zero).

// Especially when two or more media types are used, data may not be received

// in sync and longer buffering guards against running out of data of certain

// media type.

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

//    

TInt CMccVideoSinkUser::GetPreroll()

    {

    TInt preroll = iCodecInfo.iJitterBufThreshold * KMccJitterBufferThresholdPacketTime;

    __V_SOURCESINK_CONTROLL_INT1( 

                "CMccVideoSinkUser::GetPreroll, preroll before adjust:", preroll )

    if ( iMultipleMediaTypes || preroll > KMccOneMediaMinPreroll )

        {    

        TInt minPreroll = iMultipleMediaTypes ? KMccSeveralMediaMinPreroll : 

                                                KMccOneMediaMinPreroll;           

        if ( preroll < minPreroll )

            {

            preroll = minPreroll;

            }

        }

    else

        {

        // Real time mode enabled as client set jitter buffer threshold

        // value to small enough and only one media type is used.

        preroll = 0;

        }

    __V_SOURCESINK_CONTROLL_INT1( 

            "CMccVideoSinkUserImpl::GetPreroll, preroll:", preroll )   

    return preroll;

    }

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

// CMccVideoSinkUser::GetActualPreroll

// In case of real-time mode, actual preroll value is defined by jitterbuffer

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

// 

TInt CMccVideoSinkUser::GetActualPreroll()

    {      

    TInt preroll( 0 );

    if ( iJitterBuf )

        {

        preroll = iJitterBuf->PlayThresholdInMs();

        }

    else

        {

        preroll = GetPreroll();

        }

     __V_SOURCESINK_CONTROLL_INT1( "CMccVideoSinkUser::GetActualPreroll, preroll:", 

                                   preroll )

    return preroll;

    }

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

// CMccVideoSinkUser::Play

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

// 

void CMccVideoSinkUser::Play()

    {

    if ( iJitterBuf )

        {

        iJitterBuf->Play();

        }

    }

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

// CMccVideoSinkUser::Pause

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

//         

void CMccVideoSinkUser::Pause()

    {

    if ( iJitterBuf )

        {

        iJitterBuf->Pause();

        }

    }

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

// CMccVideoSinkUser::IsQueueSizeDefined

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

//                           

TBool CMccVideoSinkUser::IsQueueSizeDefined() const

    {

    return ( iCodecInfo.iJitterBufBufferLength > 0 );

    }

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

// CMccVideoSinkUser::QueueSize

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

//    

TUint CMccVideoSinkUser::QueueSize() const

    {

    TInt queueSize = 

        ( iCodecInfo.iJitterBufBufferLength < KMccMinXPSQueueSize ) ?

            KMccMinXPSQueueSize : iCodecInfo.iJitterBufBufferLength;

    return queueSize;

    }

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

// CMccVideoSinkUser::PacketOverflowState

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

//

CMccVideoSinkUser::TMccPacketOverflowState 

    CMccVideoSinkUser::PacketOverflowState() const

    {

    return iPacketOverflowState;

    }

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

// CMccVideoSinkUser::SetPacketOverflow

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

//

void CMccVideoSinkUser::SetPacketOverflow( TMccPacketOverflowState aState )

    {

    iPacketOverflowState = aState;

    }

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

// CMccVideoSinkUser::AddTimeStamp

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

//   

void CMccVideoSinkUser::AddTimeStamp( TInt64 aTimeStamp, TUint16 aSeq )

    {

    if ( iResetNeeded )

        {

        return;

        }

    UpdateFirstTimestamp( aTimeStamp );

    TInt lastTimeStamp = iNumTimeStamps - 1;

    if ( lastTimeStamp >= 0 && iTimeStamps[ lastTimeStamp ].iTime == aTimeStamp )

        {

        // Do not allow subsequent same timestamps, update sequence number

        iTimeStamps[ lastTimeStamp ].iSeq = aSeq;

        return;

        }

    if ( iNumTimeStamps >= KMccTimeStampArraySize )

        {

        RemoveFirstTimeStamp();

        }

    iNumTimeStamps++;

    TInt lastIndex = iNumTimeStamps - 1;

    iTimeStamps[ lastIndex ].iTime = aTimeStamp;

    iTimeStamps[ lastIndex ].iSeq = aSeq;

    }

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

// CMccVideoSinkUser::RemoveFirstTimeStamp

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

//   

void CMccVideoSinkUser::RemoveFirstTimeStamp()

    {

    for ( TInt i = 1; i < iNumTimeStamps; i++ )

        {

        iTimeStamps[ i - 1 ] = iTimeStamps[ i ];

        }

    if ( iNumTimeStamps > 0 )

        {

        iNumTimeStamps--;

        }

    }

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

// CMccVideoSinkUser::RemoveAllTimeStamps

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

//    

void CMccVideoSinkUser::RemoveAllTimeStamps()

    {

    iNumTimeStamps = 0;

    }

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

// CMccVideoSinkUser::NumTimeStamps

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

//   

TInt CMccVideoSinkUser::NumTimeStamps() const

    {

    return iNumTimeStamps;

    }

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

// CMccVideoSinkUser::Reset

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

//     

void CMccVideoSinkUser::Reset( TBool aFullReset )

    {

    __V_SOURCESINK_CONTROLL_INT1( 

        "CMccVideoSinkUser::Reset, fullreset:", aFullReset )

    if ( aFullReset )

        {

        SetPacketOverflow( ENormal );

        RemoveAllTimeStamps();

        iAverageTimeStampDifference = 0;

        iResetNeeded = EFalse;

        SetModifyingState( EModifyInit );

        iFirstModifyCheck = 0;

        iFirstModifyCheckTimestamp = 0;

        iFirstTimestamp = 0;

        iAllowFrame = ETrue;

        iDenyFramesStarted = TTime( 0 );

        iPreviousPacketOriginalTimeStamp = KMaxTUint32;

        iPreviousPacketModifiedTimeStamp = 0;

        iPreviousPacketTime = TTime( 0 );

        iCurrentMonitoringPeriod = KMccModifyMonitoringShortPeriodMicrosecs;

        iTimestampIncreaseFactorDown = 

            KMccMonitoringShortPeriodTimestampIncreaseFactorDown;

        iTimestampIncreaseFactorUp = 

            KMccMonitoringShortPeriodTimestampIncreaseFactorUp;

        }

    }

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

// CMccVideoSinkUser::CalculateAverageTimeStampDifference

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

//   

void CMccVideoSinkUser::CalculateAverageTimeStampDifference()

    {

    CheckDenyFramesMaxPeriod();

    // Calculate difference only if there's enough timestamps and average

    // difference has not been yet calculated

    if ( !iResetNeeded &&

         !iAverageTimeStampDifference &&

         iNumTimeStamps == KMccTimeStampArraySize )

        {

        TInt lastTimeStamp( iNumTimeStamps - 1 );

        // Calculate first the average timestamp difference between last N packets

        TInt seqNumDif( 0 );

        for ( TInt i = lastTimeStamp; i > 0; i-- )

            {

            seqNumDif = iTimeStamps[ i ].iSeq - iTimeStamps[ i - 1 ].iSeq;

            seqNumDif = Abs( seqNumDif );

            seqNumDif = ( seqNumDif == 0 ) ? 1 : seqNumDif;

            iAverageTimeStampDifference += (TUint32)(

                ( iTimeStamps[ i ].iTime - iTimeStamps[ i - 1 ].iTime ) / seqNumDif );

            }

        iAverageTimeStampDifference = 

            iAverageTimeStampDifference / ( KMccTimeStampArraySize - 1 ); 

        __V_SOURCESINK_CONTROLL_INT1( 

            "CMccVideoSinkUser::CalculateAverageTimeStampDifference, average dif:", 

            iAverageTimeStampDifference )

        }

    }

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

// CMccVideoSinkUser::IsResetNeeded

// If there's big gap in timestamps, videoplayer needs to be resetted to

// succesfully continue playback. If modifying is in use, gaps are ignored.

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

//    

TBool CMccVideoSinkUser::IsResetNeeded( TRtpRecvHeader& aHeaderInfo )

    {

    if ( !iResetNeeded )

        {

        if ( RealTimeUser() )

            {

            iResetNeeded = IsResetNeededRealTimeMode( aHeaderInfo );

            }

        else

            {

            iResetNeeded = IsResetNeededNormalMode( aHeaderInfo );

            }

        }    

    return iResetNeeded;

    }

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

// CMccVideoSinkUser::IsResetNeeded

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

// 

TBool CMccVideoSinkUser::IsResetNeeded() const

    {

    return iResetNeeded;

    }

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

// CMccVideoSinkUser::IsModifyNeeded

// Check if other end is using video timestamps incorrectly and modify

// them to be as correct as possible as Helix cannot deal with incorrect

// timestamps. Modify check is not used in audio+video scenario as packet

// flow is not as stable in that case.

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

//

TBool CMccVideoSinkUser::IsModifyNeeded( TRtpRecvHeader& aHeaderInfo )

    {