/*

* 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 <e32base.h>

#include <e32std.h>

#include "rtputil.h"

#include "rtpsdes.h"

#include "rtppacket.h"

#include "rtpmanager.h"

// CONSTANTS

const TInt KRtpVersion = 2;    // Current protocol version          

const TUint8 KNullTerm( '\0' );

const TUint KMinRtpHeaderLen( 12 );

const TUint KMinRtcpAppLen( 3 );

const TInt KCSRCListMax = 15;

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

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

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

// might leave.

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

//

CRtpPacket::CRtpPacket( const TUint32* aRtpTimeRates ) :

    iSize( 0 ),

    iProfileRTPTimeRates( aRtpTimeRates )

    {

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CRtpPacket::ConstructL( TUint aPacketSize )

    {

    iBuf = HBufC8::NewL( aPacketSize );

    iData = const_cast<TUint8*>( iBuf->Des().Ptr() );

    iDataPtr = iData;

    iExdataAlloc =EFalse;

	iCsrcAlloc= EFalse;

    }

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

// Two-phased constructor.

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

//

CRtpPacket* CRtpPacket::NewL( TUint aPacketSize, const TUint32* aRtpTimeRates )

    {

    CRtpPacket* self = new ( ELeave ) CRtpPacket( aRtpTimeRates );

    CleanupStack::PushL( self );

    self->ConstructL( aPacketSize );

    CleanupStack::Pop(); //self

    return self;

    }

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

// Destructor

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

//

CRtpPacket::~CRtpPacket()

    {

    delete iBuf; iBuf = NULL;

    }

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

// 

// 

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

//

void CRtpPacket::RtpPacketReset()

    {

    iSize = 0;

    iDataPtr = iData;

    }

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

// CRtpPacket::RtpPacketResetPtr()

// 

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

//

void CRtpPacket::RtpPacketResetPtr()

    {

    iDataPtr = iData;

    }

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

// CRtpPacket::RtpPacketBuildRtp()

// 

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

//

TInt CRtpPacket::RtpPacketBuildRtp( TRtpPacketStreamParam* aStreamParam, 

                                    TRtpPacketIOParam* aInitParam )

    {

    //Get a pointer to the beginning of iBuf

    TUint8* dataP = iData;

    //Fill dataP with binary zeroes (i.e. 0x00), replacing any existing content

    Mem::FillZ( dataP, KMinRtpHeaderLen );

    /****************************

     * dataP[0] = 8 bit         *

     *                          *

     *    2 bit = version       *

     *    1 bit = padding       *

     ****************************/

    //version (2 bit)

    // 0111001

    // 1100000

    // -------

    // 1111001

    dataP[0] |= ( KRtpVersion << 6 );

    // padding (1 bit)

    dataP[0] |= static_cast<TUint8>( ( aInitParam->TRTP.padding << 5 ) );

    // header extension (1 bit)

    if ( aInitParam->TRTP.fHeaderExtension)

        {

        dataP[0] |= ( 1 << 4 );

        }

    /****************************

     * dataP[1] = 8 bit         *

     *                          *

     *    1 bit = marker        *

     ****************************/

    // marker (1 bit)

    dataP[1] |= static_cast<TUint8>( aInitParam->TRTP.marker << 7 );

    // payload type (7 bit)

    // confirm that payload can fit the 7 bit (0 - 127)

    if(aStreamParam->TRTP.payload > KPayloadTypeMax )

    	{

    	return KErrTooBig;

    	}

    dataP[1] |= aStreamParam->TRTP.payload;

    //set the pointer to point at the beginning of the sequence number.

    dataP += 2;

    // sequence number (16 bit)

    Write16( dataP, aStreamParam->TRTP.seqNum );

    //set the pointer to point at the beginning of the time stamp.

    dataP += 2; 

    // RTP timestamp (32 bit)

    Write32( dataP, aStreamParam->TRTP.timeStamp );

    //set the pointer to point at the beginning of SSRC.

    dataP += 4;

    // SSRC (32 bit)

    Write32( dataP, aStreamParam->TRTP.SSRC );

    //set the pointer to point to the first bit after SSRC

    dataP += 4;

    if ( aInitParam->TRTP.fHeaderExtension )

        {

	    //calculate 8 bit values to 32 bit words

	    TInt16 length32 =

            static_cast<TInt16>( aInitParam->TRTP.extension.length / 4 );

        //if length mod 4 != 0, 

        if ( aInitParam->TRTP.extension.length % 4 )

	        {

    		length32++;

    		}

	    // header extension type defined by profile

        // aInitParam->TRTP.extension.type is 32-bit and part of the API

        // (i.e. unchangeable), so we have to extract the 16-LSB

	    Write16( dataP, aInitParam->TRTP.extension.type & 0xFFFF );

	    dataP += 2;

	    // header extension length in number of 32-bit words

	    Write16( dataP, length32 );

	    dataP += 2;

	    // header extension data

	    if (length32 && aInitParam->TRTP.extension.data )

		    {

		    Mem::FillZ( dataP, length32 * 4 );

		    for ( TInt i = 0; i < aInitParam->TRTP.extension.length; i++ )

		        {

	    		dataP[i] = aInitParam->TRTP.extension.data[i];

	    		}

		    dataP += ( length32 * 4 );	

		    }

	    }

    //Copy(Target, Source, Length)

    Mem::Copy( dataP, aInitParam->TRTP.payloadData,

               aInitParam->TRTP.payloadDataLen );

    iSize = aInitParam->TRTP.payloadDataLen + ( dataP - iData );

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildRtcp()

// 

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

//

TInt CRtpPacket::RtpPacketBuildRtcp( TRtpPacketStreamParam* aStreamParam, 

                                     TRtpPacketIOParam* aInitParam )

    {

    Mem::FillZ( iDataPtr, 4 );

    // version

    iDataPtr[0] |= ( KRtpVersion << 6 );

    // padding = 0

    iDataPtr[0] |= ( 0 << 5 );

    // source count

    iDataPtr[0] |= static_cast<TUint8>( aInitParam->TRTCP_HEADER.sourceCount );

    // packet type

    iDataPtr[1] = static_cast<TUint8>( aInitParam->TRTCP_HEADER.pt );

    iDataPtr += 2;

    // length of RTCP packet

    // aInitParam->TRTCP_HEADER.length is 32-bit and part of the API

    // (i.e. unchangeable), so we have to extract the 16-LSB

    Write16( iDataPtr, aInitParam->TRTCP_HEADER.length & 0xFFFF );

    iDataPtr += 2;

    // SSRC of sender in case of RR

    if ( aInitParam->TRTCP_HEADER.pt == ERTCP_RR )

        {

	    Write32( iDataPtr, aStreamParam->TRTCP_HEADER.SSRC );

	    iDataPtr += 4;

	    }

    iSize += ( aInitParam->TRTCP_HEADER.length + 1 ) * 4;

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildApp()

// 

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

//

TInt CRtpPacket::RtpPacketBuildApp( TRtpPacketStreamParam* aStreamParam, 

                                    TRtpPacketIOParam* aInitParam )

    {

    // SSRC

    Write32( iDataPtr, aStreamParam->TRTCP_APP.SSRC );

    iDataPtr += 4;

    // name

    Mem::Copy( iDataPtr, aInitParam->TRTCP_APP.name, 4 );

    iDataPtr += 4;

    // application data

    Mem::Copy( iDataPtr, aInitParam->TRTCP_APP.appData,

               aInitParam->TRTCP_APP.appDataLen );

    iDataPtr += aInitParam->TRTCP_APP.appDataLen;

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildBye()

// 

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

//

TInt CRtpPacket::RtpPacketBuildBye( TRtpPacketStreamParam* aStreamParam, 

                                    TRtpPacketIOParam* aInitParam )

    {

    TUint8 theIndex( 0 );

    // SSRC

    Write32( iDataPtr, aStreamParam->TRTCP_BYE.SSRC );

    iDataPtr += 4;

    // reason

    iDataPtr[0] = static_cast<TUint8>( aInitParam->TRTCP_BYE.reasonSize );

    iDataPtr += 1;

    Mem::Copy( iDataPtr, aInitParam->TRTCP_BYE.reason,

               aInitParam->TRTCP_BYE.reasonSize );

    iDataPtr += aInitParam->TRTCP_BYE.reasonSize;

    // padding

    if ( aInitParam->TRTCP_BYE.paddingSize != 0 )

        {

	    for ( theIndex = 0; theIndex < aInitParam->TRTCP_BYE.paddingSize;

              theIndex++ )

	        {

    		iDataPtr[theIndex] = KNullTerm;

    		}

	    iDataPtr += aInitParam->TRTCP_BYE.paddingSize;

	    }

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildRr()

// 

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

//

TInt CRtpPacket::RtpPacketBuildRr( TRtpPacketStreamParam* aStreamParam, 

                                   TRtpPacketIOParam* aInitParam )

    {

    // SSRC

    Write32( iDataPtr, aStreamParam->TRTCP_RR.SSRC );

    iDataPtr += 4;

    // fraction lost

    iDataPtr[0] = aStreamParam->TRTCP_RR.fractionLost;

    iDataPtr++;

    // cumulative number of packets lost

    Write24( iDataPtr, aStreamParam->TRTCP_RR.cumNumPacketsLost );

    iDataPtr += 3;

    // extended highest sequence number received

    Write32( iDataPtr, aStreamParam->TRTCP_RR.seqNumReceived );

    iDataPtr += 4;

    // interarrival jitter

    Write32( iDataPtr, aStreamParam->TRTCP_RR.arrivalJitter );

    iDataPtr += 4;

    // last SR timestamp

    Write32( iDataPtr, aInitParam->TRTCP_RR.lastSRTimeStamp );

    iDataPtr += 4;

    // delay since last SR timestamp

    Write32( iDataPtr, aInitParam->TRTCP_RR.delaySinceLSR );

    iDataPtr += 4;

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildSr()

// 

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

//

TInt CRtpPacket::RtpPacketBuildSr( TRtpPacketStreamParam* aStreamParam, 

                                   TRtpPacketIOParam* aInitParam )

    {

    // SSRC

    Write32( iDataPtr, aStreamParam->TRTCP_SR.SSRC );

    iDataPtr += 4;

    // NTP timestamp (seconds)

    Write32( iDataPtr, aInitParam->TRTCP_SR.NTPTimeStampSec );

    iDataPtr += 4;

    // NTP timestamp (fraction)

    Write32( iDataPtr, aInitParam->TRTCP_SR.NTPTimeStampFrac );

    iDataPtr += 4;

    // RTP timestamp

    Write32( iDataPtr, aInitParam->TRTCP_SR.timeStamp );

    iDataPtr += 4;

    // sender's packet count

    Write32( iDataPtr, aStreamParam->TRTCP_SR.numPacketsSent );

    iDataPtr += 4;

    // sender's octet count

    Write32( iDataPtr, aStreamParam->TRTCP_SR.cumNumOctetsSent );

    iDataPtr += 4;

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuildSdes()

// 

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

//

TInt CRtpPacket::RtpPacketBuildSdes( TRtpPacketStreamParam* aStreamParam, 

                                     TRtpPacketIOParam* aInitParam )

    {

    TUint8 theIndex( 0 );

    // SSRC

    Write32( iDataPtr, aStreamParam->TRTCP_SDES.SSRC );

    iDataPtr += 4;

    // SDES items

    for ( theIndex = 0; theIndex < ERTCP_NUM_OF_SDES_ITEMS; theIndex++ )

        {

        if ( aInitParam->TRTCP_SDES.sdesItemsSize[theIndex] != 0 )

            {

            iDataPtr[0] = static_cast<TUint8>( theIndex + 1 );

            iDataPtr[1] = static_cast<TUint8>(

                              aInitParam->TRTCP_SDES.sdesItemsSize[theIndex] );

            iDataPtr += 2;

            Mem::Copy( iDataPtr,

            		 aInitParam->TRTCP_SDES.sdesItems[theIndex],

            		 aInitParam->TRTCP_SDES.sdesItemsSize[theIndex] );

            iDataPtr += aInitParam->TRTCP_SDES.sdesItemsSize[theIndex];

            }

        }

    // include end of list null octet

    iDataPtr[0] = KNullTerm;

    iDataPtr++;

    // padding

    if ( aInitParam->TRTCP_SDES.paddingSize != 0 )

        {

	    for ( theIndex = 0; theIndex < aInitParam->TRTCP_SDES.paddingSize;

              theIndex++ )

	        {

    		iDataPtr[theIndex] = KNullTerm;

    		}

	    iDataPtr += aInitParam->TRTCP_SDES.paddingSize;

	    }

    return KErrNone;

    }

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

// TInt CRtpPacket::RtpPacketBuild()

// 

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

//

TInt CRtpPacket::RtpPacketBuild( TRtpPacketStreamParam* aStreamParam, 

                                 TRtpPacketIOParam* aInitParam )

    {

    TInt result( KErrNone );

    if ( !aStreamParam || !aInitParam )

        {

        return KErrUnderflow;

        }

    // build the packet content

    switch ( iType )

        {

        case ERTP:

            result = RtpPacketBuildRtp( aStreamParam, aInitParam );

            break;

        case ERTCP_HEADER:

            result = RtpPacketBuildRtcp( aStreamParam, aInitParam );

            break;

        case ERTCP_SR:

            result = RtpPacketBuildSr( aStreamParam, aInitParam );

            break;

        case ERTCP_RR:

            result = RtpPacketBuildRr( aStreamParam, aInitParam );

            break;

        case ERTCP_SDES:

            result = RtpPacketBuildSdes( aStreamParam, aInitParam );

            break;

        case ERTCP_BYE:

            result = RtpPacketBuildBye( aStreamParam, aInitParam );

            break;

        case ERTCP_APP:

            result = RtpPacketBuildApp( aStreamParam, aInitParam );

            break;

        default:

            result = ERTCP_PACKET_ERROR; //unknown packet type

            break; 

        }

    return result;

    }

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

// TRtpSSRC CRtpPacket::RtpPacketGetSSRC()

// assumed to be called for an RTCP packet only after 

// RTCP_HEADER has determined the packet type

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

TRtpSSRC CRtpPacket::RtpPacketGetSSRC()

    {

    TUint8* dataP;

    // parse the packet content

    switch ( iType )

        {

        case ERTP:

            {

            dataP = iData + 8;

            return ( Read32( dataP ) );

            }