/*

* 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 FILES

#include "rtpsession.h"

// CONSTANTS

const TInt TStream::iOffset = _FOFF( TStream, iMagicKey );

// Used to calculate the average size of an RTCP packet, this represents

// the fraction by which the most recent RTCP packet influences the average.

const TReal KRtcpSizeGain = ( 1.0 / 16.0 );

const TReal KRtcpSizeGainRemainder = 1 - KRtcpSizeGain;

const TInt  KRtpLimitNumberOfRecvStream=100;

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

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

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

// might leave.

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

//

CRtpSession::CRtpSession( const TRtpId aSessionId,

                          const TUint32* aProfileRTPTimeRates,

                          const TBool aStandardRtp,

                          MRtpErrNotify& aErrNotify,

                          const CRtpSDES* aSdesInfo , 

                          MRtpAsignUniqueID& aAssignUniqueID) 

    :

    iStandardRtp( aStandardRtp ),

    iSessionId( aSessionId ),

    iLocalSdes( aSdesInfo ),

    iNewSdes( NULL ),

    // Send one SDES packet after every KDES_SEND_PACKET SR or RR

    iSendSdesCounter( KSDES_SEND_PACKET ),

    iRtpRecvBuf( NULL, 0 ),

    iRtcpRecvBuf( NULL, 0 ),

    iRtcpEnabled( EFalse ),

    iFirstRTCPSent( EFalse ),

    iFPortsInit( EFalse ),

    iNumOfTxStreams( 0 ),

    iNumOfRxStreams( 0 ),

    iProfileRTPTimeRates( aProfileRTPTimeRates ),

    iAverageRtcpSize( static_cast<TReal>( KAverageRtcpPacketLength ) ),

    iRtcpTimeInterval( KMinRtcpTimeInterval ),

    // default: the session has one participant

    iTotalParticipantsSession( 1 ),

    iRtpObserver( NULL ),

    iRtcpObserver( NULL ),

    iNonRTPDataObserver( NULL ),

    iErrNotify( aErrNotify ),

    iAssignUniqueID( aAssignUniqueID),

    iSessionStarted( EFalse ),

    iSSRCJumps( 0 ),

    iRtcpErrors( 0 ),

    iRtcpSendingSuspended( EFalse ),

    iSeed( 0 )

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CRtpSession::ConstructL( const TCreateSessionParams& aParams,

                              TUint& aPort,

                              TBool aEnableRtcp,

                              const TRtcpParams* aRtcpParams,

                              RSocketServ& aSocketServ,

                              RConnection& aRConn,

                              const RLibrary& aLibrary,

                              MRtpErrNotify& aErrNotify )

    {

    RTP_DEBUG_DETAIL_DVALUE( "CRtpSession::ConstructL, socket size:", 

                             aParams.iSocketBufSize  );

    // Create at least packets of size KMaxRtpPacketSize. If client

    // wants to use bigger socket than that, also packets need to

    // have the same size.                         

    TInt packetSize = ( aParams.iSocketBufSize > KMaxRtpPacketSize ) ? 

            aParams.iSocketBufSize : KMaxRtpPacketSize;

    if ( iStandardRtp )

        {

        // allocate 1 packet to RTP sending 

        iPktSnd = CRtpPacket::NewL( packetSize, iProfileRTPTimeRates );

        iPktSnd->SetType( ERTP );

        // allocate 1 packet to RTP receiving

        iPktRcv = CRtpPacket::NewL( packetSize, iProfileRTPTimeRates );   

        iPktRcv->SetType( ERTP );

        TPtr8 aux1( iPktRcv->GetHBuf()->Des() );

        iRtpRecvBuf.Set( aux1 );

        }

    else

        {

        // Function at ordinal 1 creates new CRtpPacketExt

        TLibraryFunction entry = aLibrary.Lookup( 1 );

        iPktExtRcv = ( MRtpPacketExt * ) entry(); //NewL()

        iPktExtRcv->ConstructL( packetSize, iSessionId );

        TPtr8 aux1( iPktExtRcv->GetHBuf()->Des() );

        iRtpRecvBuf.Set( aux1 );

        iPktExtSnd = ( MRtpPacketExt * ) entry();  //NewL()

        iPktExtSnd->ConstructL( packetSize, iSessionId );

        }

    if ( aEnableRtcp )

        {

        iRtcpEnabled = ETrue;

        // allocate 1 packet for RTCP sending

        iPktRtcpSnd = CRtpPacket::NewL( KMaxRtcpPacketSize,

                                        iProfileRTPTimeRates );   

        // allocate 1 packet for RTCP receiving

        iPktRtcpRcv = CRtpPacket::NewL( KMaxRtcpPacketSize,

                                        iProfileRTPTimeRates );  

        TPtr8 aux2( iPktRtcpRcv->GetHBuf()->Des() );

        iRtcpRecvBuf.Set( aux2 );

        iSndRtcpTimer = CRtpTimer::NewL( CActive::EPriorityStandard, *this );

        InitialiseRtcp( aRtcpParams );

        }

    iCommNet = CRtpComm::NewL( aPort, aSocketServ, aRConn, aParams, aErrNotify,

                               aEnableRtcp );

    iCommNet->RegisterReceivedNotify( this );

    // instantiate RTP stream arrays

    iStreamTxArray = new ( ELeave ) CArrayFixFlat<TStream>( 2 );

    iStreamRxArray = new ( ELeave ) CArrayFixFlat<TStream>( 2 );

    iSdesArray = new ( ELeave ) CArrayPtrFlat<CRtpSDES>( 2 );

    // Assigned default SSRC     

    iDefaultSSRC = GenerateSSRC();

    iIsSrtp=EFalse;

    }

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

// Two-phased constructor.

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

//

CRtpSession* CRtpSession::NewL( const TCreateSessionParams& aParams,

                                TUint& aPort,

                                TBool aEnableRtcp,

                                const TRtcpParams* aRtcpParams,

                                RSocketServ& aSocketServ,

                                RConnection& aRConn,

                                const TRtpId aSessionId,

                                const CRtpSDES* aSdes, // application's SDES

                                const TUint32* aProfileRTPTimeRates,

                                const TBool aStandardRtp,

                                const RLibrary& aLibrary,

                                MRtpErrNotify& aErrNotify, 

                                MRtpAsignUniqueID& aAssignUniqueID )

    {

    CRtpSession* self = new ( ELeave ) CRtpSession( aSessionId, 

                                                    aProfileRTPTimeRates,

                                                    aStandardRtp, aErrNotify,

                                                    aSdes,aAssignUniqueID);

    CleanupStack::PushL( self );

    self->ConstructL( aParams, aPort, aEnableRtcp, aRtcpParams, aSocketServ, 

                      aRConn, aLibrary, aErrNotify );

    CleanupStack::Pop(); // self 

    return self;

    }

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

// Destructor

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

//

CRtpSession::~CRtpSession()

    {

    RemoveAllStreams();

    delete iStreamTxArray;

    delete iStreamRxArray;

    if (iSdesArray)

		{

	    iSdesArray->ResetAndDestroy();

	    }

    delete iSdesArray;

    delete iCommNet;

    if ( iRtcpEnabled )

        {

        delete iSndRtcpTimer;

        }

    if ( iNewSdes )

        {

        delete iNewSdes;

        }

    if ( iStandardRtp )

        {

        delete iPktSnd;

        delete iPktRcv;

        if ( iRtcpEnabled )

            {

            delete iPktRtcpSnd;

            delete iPktRtcpRcv;

            }

        }

    else

        {

        if (iPktExtSnd)

			{

        	iPktExtSnd->Close(); // delete iPktExtSnd;

        	}

        if (iPktExtRcv)

        	{

        	iPktExtRcv->Close(); // delete iPktExtRcv;

        	}

        }

    iRxSSRCArray.Close();

    }

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

// TInt CRtpSession::SetRemoteAddress()

// 

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

//

TInt CRtpSession::SetRemoteAddress( TInetAddr& aRemoteAddr )

    {

    if ( !iCommNet )

        {

        return KErrGeneral;

        }

    TInt error( KErrNone );

    if ( iSessionStarted )

        {

        ResetTxStreamStats();

        ResetRxStreamStats();

        }

    iRemoteAddr[ERTPPort].SetAddress( aRemoteAddr.Address() ); 

    iRemoteAddr[ERTPPort].SetPort( aRemoteAddr.Port() ); 

    error = iCommNet->SetToAddress( ERTPPort, aRemoteAddr );   

    if (aRemoteAddr.Family() == KAfInet6 )

    	{

    	iRemoteAddr[ERTPPort].SetAddress( aRemoteAddr.Ip6Address() ); 

    	}

    if ( error == KErrNone && iRtcpEnabled )

        {

        TInetAddr remoteAddr( aRemoteAddr );

         // Set RTCP port

        remoteAddr.SetPort( remoteAddr.Port() + 1 );

        iRemoteAddr[ERTCPPort].SetAddress( remoteAddr.Address() ); 

        iRemoteAddr[ERTCPPort].SetPort( remoteAddr.Port() ); 

        if (aRemoteAddr.Family() == KAfInet6 )

    		{

    		iRemoteAddr[ERTCPPort].SetAddress( aRemoteAddr.Ip6Address() ); 

    		}

        error = iCommNet->SetToAddress( ERTCPPort, remoteAddr );                                        

        }

    if ( error == KErrNone && !iSessionStarted )

        {

        iCommNet->RegisterReceivedNotify( this );

        }

    iRemoteAddrSet = ETrue;

    return error;

    } 

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

// TInt CRtpSession::SetRemoteRtcpAddress()

// 

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

//

TInt CRtpSession::SetRemoteRtcpAddress( TInetAddr& aRemoteAddr )

    {

    TInt error( KErrNone );

    if ( !iRtcpEnabled )

        {

        return KErrNotSupported;

        }

    else

        {

        iRemoteAddr[ERTCPPort].SetAddress( aRemoteAddr.Address() ); 

        iRemoteAddr[ERTCPPort].SetPort( aRemoteAddr.Port() ); 

		if (aRemoteAddr.Family() == KAfInet6 )

    		{

    		iRemoteAddr[ERTCPPort].SetAddress( aRemoteAddr.Ip6Address() ); 

    		}

        error = iCommNet->SetToAddress( ERTCPPort, aRemoteAddr );    

        }

    return error;

    }

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

// TInt CRtpSession::CreateReceiveStreamL()

// 

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

//

TInt CRtpSession::CreateReceiveStreamL( TRtpId aRcvStreamId,

                                        const TRtpPayloadType aPayloadType )

    {

    if ( iNumOfRxStreams == 0 )

        {

        // This is the first Rx stream

        iCommNet->ConstructReceiverL(iNonRTPDataObserver!=NULL);

        if (iRemoteAddrSet)

            {

            iCommNet->SetAcceptedFromAddress(iRemoteAddr[ERTPPort]);

            }

        }

    CRtpRecvStream* newReceiveStream =

        CRtpRecvStream::NewL( aPayloadType, iSessionId, aRcvStreamId,

                              &iRtpObserver, iRtcpObserver,

                              iProfileRTPTimeRates, this );

    // store new receive stream address in stream array 

    TStream arrayData( aRcvStreamId, ( TUint ) newReceiveStream );

    TInt err( AddStream( arrayData, ERxStream ) );

    if ( err == KErrNone )

        {

        iNumOfRxStreams++;

        }

    else

        {

        delete newReceiveStream;

        }

    return err;

    }

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

// TInt CRtpSession::GetUniqueSSRC()

// 

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

//

TRtpSSRC CRtpSession::GetUniqueSSRC()

    {

    TRtpSSRC ssrc( 0 );

    if ( iNumOfTxStreams != 0 )

        {

        ssrc = GenerateSSRC();

        // find if SSRC is already in use

        while ( FindStreamForSSRC( ssrc ) )

            {

            // if SSRC is already in use, create a new one    

            ssrc = GenerateSSRC();

            }

        }

    else // first TX stream, set transmit stream SSRC equal default SSRC

        {

        ssrc = iDefaultSSRC;

        }

    return ssrc;

    }

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

// TInt CRtpSession::CreateTransmitStreamL()

// 

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

//

TInt CRtpSession::CreateTransmitStreamL( TRtpId aTranStreamId, 

                                         const TRtpPayloadType aPayloadType,

                                         TRtpSSRC& aSSRC )

    {

    if ( iNumOfTxStreams == 0 )

        {

        // This is the first Tx stream

        iCommNet->ConstructSenderL(iRemoteAddr[ERTPPort], iRemoteAddr[ERTCPPort]);

        }

    aSSRC = GetUniqueSSRC();

    CRtpTranStream* newTranStream =

        CRtpTranStream::NewL( aPayloadType, iSessionId, aTranStreamId, aSSRC,

                              iRtcpObserver, iProfileRTPTimeRates );

    // store new transmit stream address in stream array 

    TStream arrayData( aTranStreamId, ( TUint ) newTranStream );

    TInt ret( AddStream( arrayData, ETxStream ) );

    if ( ret == KErrNone )

        {

        iNumOfTxStreams++;

        RedistributeBandwidth();

        }

    else

        {

        delete newTranStream;

        }

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream with Session ID = ", iSessionId );

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream ID = ", aTranStreamId );

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream SSRC = ", aSSRC );

    return ret;

    }

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

// TInt CRtpSession::CreateTransmitStreamExtL()

// 

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

//

TInt CRtpSession::CreateTransmitStreamExtL( TRtpId aTranStreamId, 

                                            const TRtpPayloadType aPayloadType, 

                                            const TRtpSSRC aSSRC )

    {

    if ( iNumOfTxStreams == 0 )

        {

        // This is the first Tx stream

        iCommNet->ConstructSenderL(iRemoteAddr[ERTPPort], iRemoteAddr[ERTCPPort]);

        }

    iDefaultSSRC = aSSRC;  // asigned this value to the default just in case

    CRtpTranStream* newTranStream =

        CRtpTranStream::NewL( aPayloadType, iSessionId, aTranStreamId, aSSRC,

                              iRtcpObserver, iProfileRTPTimeRates );

    // store new receive stream address in stream array 

    TStream arrayData( aTranStreamId, ( TUint ) newTranStream );

    TInt ret( AddStream( arrayData, ETxStream ) );

    if ( ret == KErrNone )

        {        

        iNumOfTxStreams++;

        RedistributeBandwidth();

        }

    else

        {

        delete newTranStream;

        }

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream with Session ID = ", iSessionId );

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream ID = ", aTranStreamId );

    RTP_DEBUG_DETAIL_DVALUE( "Created TX Stream SSRC = ", aSSRC );

    return ret;

    }

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

// CRtpSession::CloseStream()

// 

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

//

void CRtpSession::CloseStream( TRtpId aRcvStreamID )

    {

    TStreamType streamType;

    // remove stream

    TInt error( RemoveStream( aRcvStreamID, streamType ) );

    if ( error == KErrNone )

        {

        if ( streamType == ERxStream )

            {

            iNumOfRxStreams--;

            }

        else //ETxStream

            {

            iNumOfTxStreams--;

            RedistributeBandwidth();

            }

        }

    }

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

// CRtpSession::RedistributeBandwidths()

// 

// Calculate a new bandwidth for the TX streams.

//

// iFraction is the procent reserved for RTCP.

//

// Note, the bandwith is just the theoretical bandwidth which is used 

// for RTCP and has nothing to do with the real bandwith. 

// So if RTCP is not enabled, it will return (no calculation needed). 

// 

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

//

void CRtpSession::RedistributeBandwidth()

    {

    if ( iRtcpEnabled && ( iStreamTxArray != NULL ) )

       {

        CRtpTranStream* tempTxStream;

        TInt count = iStreamTxArray->Count();

        if ( count == 0 )

            {

            return;

            }

        TUint32 bandwidth = static_cast<TUint32>(

                                ( iBandWidth * ( 1 - iFraction )  ) / count );

        for( int index = 0; index < count; index++ )