/*

* Copyright (c) 2002-2003 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 "rtptranstream.h"

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

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

// might leave.

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

//

CRtpTranStream::CRtpTranStream( const TRtpPayloadType aPayloadType,

                                const TRtpId aSessionId,

                                const TRtpId aStreamId,

                                const TRtpSSRC aSSRC,

                                MRtcpObserver* aRtcpObserver,

                                const TUint32* aProfileRTPTimeRates )

    :

    CRtpStream( aStreamId,

                aSessionId,

                aProfileRTPTimeRates,

                aRtcpObserver,

                aPayloadType ),

    iFlagSentRTPPackets( EFalse ),

    iPreviousTime( 0 ),

    iPreviousRemoteSN( 0 ),

    iPrevRemoteTime( 0 ),

    iCumNumOctetsSent( 0 ),

    iCumNumOctetsReceived( 0 ),

    iCumNumOctetsSent_last( 0 ),

    iFSentRtcpReport( EFalse )

    {

    iLocalSSRC = aSSRC;

    iTimeStamp = 0;

    iSeqNumCycles = 0;

    for ( TUint i = 0; i < KSNMaxArray; i++ )

        {

        iSN_size[i] = 0;

        }

    // If the client application does not specify sequence numbers, we

    // randomize the first one.

    TTime tmp_time;

    tmp_time.HomeTime();

    TInt64 seed = tmp_time.Int64();

    iBaseSeqNum = static_cast<TRtpSequence>( TRtpUtil::Random( seed )

                                             & 0xFFFF ); // Use 16-LSB only

    iSeqNum = iBaseSeqNum;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CRtpTranStream::ConstructL()

    {

    }

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

// Two-phased constructor.

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

//

CRtpTranStream* CRtpTranStream::NewL( const TRtpPayloadType aPayloadType,

                                      const TRtpId aSessionId,

                                      const TRtpId aTranStreamId,

                                      const TRtpSSRC aSSRC,

                                      MRtcpObserver* aRtcpObserver,

                                      const TUint32* aProfileRTPTimeRates )

    {

    CRtpTranStream* self =

        new ( ELeave ) CRtpTranStream( aPayloadType,

                                       aSessionId,

                                       aTranStreamId,

                                       aSSRC,

                                       aRtcpObserver,

                                       aProfileRTPTimeRates );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self 

    return self;

    }

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

// Destructor

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

//

CRtpTranStream::~CRtpTranStream()

    {

    }

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

// TInt CRtpTranStream::ResetStreamStat()

// 

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

//

TInt CRtpTranStream::ResetStreamStat()

    {

    TRtcpStats rtcpStat;

    RtcpStats( rtcpStat );

    rtcpStat.iRtcpSenderStats.iNumPacketsSent = 0;

    rtcpStat.iRtcpSenderStats.iCumNumOctetsSent = 0;

    rtcpStat.iRtcpSenderStats.iNTPTimeStampSec = 0;    // NTP seconds

    rtcpStat.iRtcpSenderStats.iNTPTimeStampFrac = 0;   // NTPfraction

    rtcpStat.iRtcpSenderStats.iTimeStamp = 0; 

    // The receiver stats are updated when receiving RR packets, so reset

    rtcpStat.iRtcpReceiverStats.iChannelBufferSize = 0;

    rtcpStat.iRtcpReceiverStats.iRoundTripDelay = 0;

    rtcpStat.iRtcpReceiverStats.iFractionLost = 0; 

    rtcpStat.iRtcpReceiverStats.iCumNumPacketsLost = 0;

    rtcpStat.iRtcpReceiverStats.iSeqNumReceived = 0;

    rtcpStat.iRtcpReceiverStats.iSSRC = 0;

    iRtcpStats = rtcpStat;

    iFlagSentRTPPackets = EFalse;

    iFSentRtcpReport = EFalse;

    iCumNumOctetsSent = 0;

    iCumNumOctetsSent_last = 0;

    iPreviousTime = 0;

    iPreviousRemoteSN = 0;

    iSeqNumCycles = 0;

    for ( TUint i = 0; i < KSNMaxArray; i++ )

        {

        iSN_size[i] = 0;

        }

    return KErrNone;

    }

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

// TInt CRtpTranStream::GetStreamStat()

// 

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

//

TInt CRtpTranStream::GetStreamStat( TRtpPeerStat& aStat )

    {

    TRtcpStats rtcpStat;

    RtcpStats( rtcpStat );

    aStat.iCumNumOctetsSent = rtcpStat.iRtcpSenderStats.iCumNumOctetsSent;

    aStat.iNumPacketsSent = rtcpStat.iRtcpSenderStats.iNumPacketsSent;

    aStat.iTxBandwidth = rtcpStat.iRtcpReceiverStats.iTxBandwidth;

    aStat.iArrivalJitter = rtcpStat.iRtcpReceiverStats.iArrivalJitter;

    aStat.iCumNumPacketsLost = rtcpStat.iRtcpReceiverStats.iCumNumPacketsLost;

    aStat.iFractionLost = rtcpStat.iRtcpReceiverStats.iFractionLost;

    aStat.iRoundTripDelay = rtcpStat.iRtcpReceiverStats.iRoundTripDelay;

    aStat.iRxBandwidth = rtcpStat.iRtcpReceiverStats.iBandwidth;

    aStat.iChannelBufferSize = rtcpStat.iRtcpReceiverStats.iChannelBufferSize;

    aStat.iNTPTimeStampSec = rtcpStat.iRtcpSenderStats.iNTPTimeStampSec;

    aStat.iNTPTimeStampFrac = rtcpStat.iRtcpSenderStats.iNTPTimeStampFrac;

    aStat.iTimeStamp = rtcpStat.iRtcpSenderStats.iTimeStamp;

    return KErrNone;

    }

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

// TInt CRtpTranStream::BuildRtpPacket()

// 

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

//

TInt CRtpTranStream::BuildRtpPacket( const TRtpSendHeader& aHeaderInfo,

                                     const TDesC8& aPayloadData,

                                     TRtpSequence aSeqNum,

                                     TBool aSetSeqNum,

                                     CRtpPacket* aPktSnd )

    {

    TRtpPacketStreamParam streamParam;

    TRtpPacketIOParam inParam;

    if ( FirstPkg() )

        {

        RtpStreamSyncInit( aHeaderInfo.iTimestamp );

        SetFirstPkg( EFalse );

        }

    //

    // The interpretation of the marker is defined by a profile.

    // It is used for marking significant events such as frame boundaries or

    // talkspurts in the packet stream.

    // Timestamp

    // -- random initial value

    // -- monotonically increasing 

    // -- increases by one sampling period for fixed-rate audio

    // -- increases for every sample independent of whether the block is

    //    transmitted or dropped as silent.

    // -- used for playout and inter-media synchronization.

    //

    //

    // construct RTP packet

    //

    inParam.TRTP.padding = aHeaderInfo.iPadding;

    if ( aHeaderInfo.iHeaderExtension )

        {

        inParam.TRTP.fHeaderExtension = 1;

        inParam.TRTP.extension.type = aHeaderInfo.iHeaderExtension->iType;

        inParam.TRTP.extension.length = aHeaderInfo.iHeaderExtension->iLength;

        inParam.TRTP.extension.data = aHeaderInfo.iHeaderExtension->iData;

        }

    else

        {

        inParam.TRTP.extension.data = NULL;

        }

    inParam.TRTP.marker = aHeaderInfo.iMarker; 

    inParam.TRTP.payloadData = const_cast<TUint8*>( aPayloadData.Ptr() );

    inParam.TRTP.payloadDataLen = aPayloadData.Length();

    streamParam.TRTP.payload = aHeaderInfo.iPayloadType;

    if ( aSetSeqNum )

        {

        iSeqNum = aSeqNum;

        }

    streamParam.TRTP.seqNum = iSeqNum;

    streamParam.TRTP.SSRC = iLocalSSRC;

    streamParam.TRTP.timeStamp = aHeaderInfo.iTimestamp;

    //

    // build and send the packet

    //

    aPktSnd->RtpPacketBuild( &streamParam, &inParam ); 

    RTP_DEBUG_DETAIL_DVALUE( "CRtpTranStream::BuildRtpPacket, Stream ID = ",

                  iStreamId );

    RTP_DEBUG_DETAIL_DVALUE( "CRtpTranStream::BuildRtpPacket, SSRC = ",

                  streamParam.TRTP.SSRC );

    RTP_DEBUG_DETAIL_DVALUE( "CRtpTranStream::BuildRtpPacket, Seq Num = ",

                  static_cast<TInt>( streamParam.TRTP.seqNum ) );

    RTP_DEBUG_DETAIL_DVALUE( "CRtpTranStream::BuildRtpPacket, Time Stamp = ",

                  aHeaderInfo.iTimestamp );

    // update sent octets and remote bandwidth parameters 

    IncCumNumOctetsSent( aPayloadData.Length() );

    // update stream parameters

    iTimeStamp = aHeaderInfo.iTimestamp;

    iSeqNum++;

    if ( iSeqNum == 0 )

        {

        iSeqNumCycles++;

        }

    SetSentRTPPackets( ETrue );

    return KErrNone;

    }

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

// TInt CRtpTranStream::BuildRtcpBYEPacket()

// 

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

//

TInt CRtpTranStream::BuildRtcpBYEPacket( const TDesC8& aReason,

                                         CRtpPacket* aPktRtcpSnd )

    {

    TInt paddingSize = 0;

    TRtpPacketStreamParam streamParam;

    TRtpPacketIOParam initParam;

    TInt ret = KErrNone;

    TInt byeSize = aReason.Size();

    // build RTCP BYE packet header

    TInt sourceCount = 1; 

    TInt length = 0;

    initParam.TRTCP_HEADER.pt = ERTCP_BYE;

    if ( ( 1 + byeSize ) % 4 == 0 )

        {

        // multiples of 4 bytes, no padding is needed

        // calculate total number of 32 bit words in SDES packet

        length = ( 1 + byeSize ) / 4 + 1;   

        }

    else

        {

        // not multiples of 4 bytes, padding is needed

        paddingSize = 4 - ( 1 + byeSize ) % 4;

        length = ( 1 + byeSize ) / 4 + 2;

        }

    initParam.TRTCP_HEADER.sourceCount = sourceCount;

    initParam.TRTCP_HEADER.length = length;

    aPktRtcpSnd->SetType( ERTCP_HEADER );

    aPktRtcpSnd->RtpPacketBuild( &streamParam, &initParam );

    streamParam.TRTCP_BYE.SSRC = iLocalSSRC;

    initParam.TRTCP_BYE.reason = ( TUint8 * ) aReason.Ptr();

    initParam.TRTCP_BYE.reasonSize = byeSize;

    initParam.TRTCP_BYE.paddingSize = paddingSize;

    aPktRtcpSnd->SetType( ERTCP_BYE );

    aPktRtcpSnd->RtpPacketBuild( &streamParam, &initParam ); 

    RTCP_DEBUG_DETAIL_DVALUE( "SEND: Send BYE Packet TX Stream ID = ",

              iStreamId );

    RTCP_DEBUG_DETAIL_DVALUE( "SEND: Send BYE Packet SSRC = ",

              iLocalSSRC );

    RTCP_DEBUG_DETAIL( "SEND: Sending RTCP BYE message as" );

    RTCP_DEBUG_DETAIL( initParam.TRTCP_BYE.reason );

    return ret;

    }

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

// TInt CRtpTranStream::BuildRtcpAPPPacket()

// 

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

//

TInt CRtpTranStream::BuildRtcpAPPPacket( const TRtcpApp& aApp,

                                         CRtpPacket* aPktRtcpSnd )

    {

    TRtpPacketStreamParam streamParam;

    TRtpPacketIOParam initParam;

    initParam.TRTCP_HEADER.pt = ERTCP_APP;

    initParam.TRTCP_HEADER.sourceCount = aApp.iSubType;

    initParam.TRTCP_HEADER.length = aApp.iAppDataLen / 4 + 3 - 1;

    aPktRtcpSnd->SetType( ERTCP_HEADER );

    aPktRtcpSnd->RtpPacketBuild( &streamParam, &initParam );

    streamParam.TRTCP_APP.SSRC = iLocalSSRC;

    Mem::Copy( initParam.TRTCP_APP.name, aApp.iName, 4 );

    initParam.TRTCP_APP.appData = const_cast<TUint8*>( aApp.iAppData );

    initParam.TRTCP_APP.appDataLen = aApp.iAppDataLen;

    aPktRtcpSnd->SetType( ERTCP_APP );

    aPktRtcpSnd->RtpPacketBuild( &streamParam, &initParam ) ; 

    RTP_DEBUG_DETAIL_DVALUE( "SEND: Send APP Packet TX Stream ID = ", iStreamId );

    RTP_DEBUG_DETAIL_DVALUE( "SEND: Send APP Packet SSRC = " , iLocalSSRC );

    RTCP_DEBUG_DETAIL( "SEND: Sending RTCP APP packet as " );

    RTCP_DEBUG_DETAIL( "InitParam.TRTCP_APP.appData " );

    return KErrNone;

    }

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

// CRtpTranStream::RtpStreamSyncInit()

// For transmission stream, iSyncInfo is initialized by the

// first packet sent.

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

//

void CRtpTranStream::RtpStreamSyncInit( TRtpTimeStamp aInitTimeStamp )

    {

    TUint32 gtTime = TRtpUtil::GtGetTime();

    TTime time1;

    TTime time2;

    TTimeIntervalSeconds interval;

    time1.HomeTime();

    _LIT( KTime, "19700101:000000.000000" );

    time2.Set( KTime ); // microsecond from Jan. 1 1970

    time1.SecondsFrom( time2, interval );

    iSyncInfo.iNTPTimeStampSec = interval.Int() + KGetTimeOfDayToNTPOffset;

    iSyncInfo.iNTPTimeStampFrac = static_cast<TUint32>(

        ( ( ( ( TUint32 ) ( gtTime % KTenthOfmsPerSecond ) ) << 16 )

        / KTenthOfmsPerSecond ) << 16 );

    iSyncInfo.iTimeStamp = aInitTimeStamp;

    iSyncInfo.iLastUpdateLocalTime = gtTime;

    }

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

// CRtpTranStream::RtpStreamSyncCurrent()

// iSyncInfo : NTP timestamp of initialization as a reference

//             to update the current NTP timestamp

// aSyncInfoCurrent : Bring back current NTP Time stamp

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

//

void CRtpTranStream::RtpStreamSyncCurrent( TRtpTimeSync* aSyncInfoCurrent )

    {

    if ( !aSyncInfoCurrent )

        {

        return;

        }

    TUint32 gtTime = TRtpUtil::GtGetTime();

    TUint32 diffFraction = ( gtTime - iSyncInfo.iLastUpdateLocalTime )

                           % KTenthOfmsPerSecond;

    aSyncInfoCurrent->iNTPTimeStampSec = iSyncInfo.iNTPTimeStampSec +

          static_cast<TUint32>( gtTime - iSyncInfo.iLastUpdateLocalTime )

          / KTenthOfmsPerSecond;

    aSyncInfoCurrent->iNTPTimeStampFrac = ( static_cast<TUint32>(

        ( diffFraction << 16 ) / KTenthOfmsPerSecond ) << 16 );

    }

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

// CRtpTranStream::RtpStreamCreateRtcpReportSection()

// For transmission stream, it only generates SR packet.

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

//

void CRtpTranStream::RtpStreamCreateRtcpReportSection( CRtpPacket* aPkt )

    {

    TRtpPacketStreamParam streamParam;

    TRtpPacketIOParam inParam;

    TRtpTimeSync syncInfoCurrent;

    streamParam.TRTCP_SR.SSRC = iLocalSSRC;

    streamParam.TRTCP_SR.numPacketsSent = iSeqNum + ( iSeqNumCycles << 16 )

                                          - iBaseSeqNum;

    streamParam.TRTCP_SR.cumNumOctetsSent = iCumNumOctetsSent;

    iRtcpStats.iRtcpSenderStats.iNumPacketsSent =

        streamParam.TRTCP_SR.numPacketsSent;

    iRtcpStats.iRtcpSenderStats.iCumNumOctetsSent =

        streamParam.TRTCP_SR.cumNumOctetsSent;

    iRtcpStats.iRtcpSenderStats.iSSRC = streamParam.TRTCP_SR.SSRC;

    RtpStreamSyncCurrent( &syncInfoCurrent );

    inParam.TRTCP_SR.NTPTimeStampSec = syncInfoCurrent.iNTPTimeStampSec;

    inParam.TRTCP_SR.NTPTimeStampFrac = syncInfoCurrent.iNTPTimeStampFrac;

    inParam.TRTCP_SR.timeStamp = iTimeStamp;

    iRtcpStats.iRtcpSenderStats.iNTPTimeStampSec =

        inParam.TRTCP_SR.NTPTimeStampSec;

    iRtcpStats.iRtcpSenderStats.iNTPTimeStampFrac =

        inParam.TRTCP_SR.NTPTimeStampFrac;

    iRtcpStats.iRtcpSenderStats.iTimeStamp = inParam.TRTCP_SR.timeStamp;

    RTP_DEBUG_STAT( "----- TX: Create RTCP Report Statistics -----" );

    RTP_DEBUG_STAT_DVALUE( "TX: numPacketsSent = ",

              iRtcpStats.iRtcpSenderStats.iNumPacketsSent );

    RTP_DEBUG_STAT_DVALUE( "TX: cumNumOctetsSent = ",

              iRtcpStats.iRtcpSenderStats.iCumNumOctetsSent );

    RTP_DEBUG_STAT_DVALUE( "TX: SSRC (Tx) = ",

              iRtcpStats.iRtcpSenderStats.iSSRC );

    RTP_DEBUG_STAT_DVALUE( "TX: NTPTimeStampSec = ",

              iRtcpStats.iRtcpSenderStats.iNTPTimeStampSec );

    RTP_DEBUG_STAT_DVALUE( "TX: NTPTimeStampFrac = ",

              iRtcpStats.iRtcpSenderStats.iNTPTimeStampFrac );

    RTP_DEBUG_STAT_DVALUE( "TX: timeStamp = ",

              iRtcpStats.iRtcpSenderStats.iTimeStamp );

    // For transmission stream, it only generates SR packet.

    aPkt->SetType( ERTCP_SR );

    aPkt->RtpPacketBuild( &streamParam, &inParam );

    }

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

// TRtpRtcpEnum CRtpTranStream::RtpStreamProcessRtcpReportSectionL()

// For transmission stream, it only processes RR packet.

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

//

TRtpRtcpEnum CRtpTranStream::RtpStreamProcessRtcpReportSectionL(

                                 CRtpPacket* aPkt )

    {

    TRtpPacketStreamParam streamParam;

    TRtpPacketIOParam extractParam;

    TRtpRtcpEnum parseResult = ERTCP_NO_ERROR;

    TUint32 gtTime = TRtpUtil::GtGetTime();

    parseResult = aPkt->RtpPacketProcessL( &streamParam, &extractParam );

    if ( parseResult == ERTCP_PACKET_ERROR )

        {

        return ERTCP_PACKET_ERROR;

        }

    // For transmission stream, it only processes RR packet.

    if ( aPkt->Type() == ERTCP_RR )

        {

        TInt roundTripDelay;

        roundTripDelay = RtpStreamSyncGetRoundTripDelay(

                             extractParam.TRTCP_RR.lastSRTimeStamp,

                             extractParam.TRTCP_RR.delaySinceLSR );

        iCumNumOctetsReceived += iSN_size[streamParam.TRTCP_RR.seqNumReceived

                                     % KSNMaxArray] -

                                 iSN_size[iPreviousRemoteSN % KSNMaxArray];

        if ( iCumNumOctetsSent > iCumNumOctetsReceived )

            {

            iRtcpStats.iRtcpReceiverStats.iChannelBufferSize =

                8 * ( iCumNumOctetsSent - iCumNumOctetsReceived );

            }

        else