/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:    Class to RTP packet parsing.*

*/

// INCLUDE FILES

#include "CRtpPacket.h"

// CONSTANTS

const TInt KRtpPacketVersion( 2 );

const TInt KRtpMinHeaderLength( 12 );

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

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

// CRtpPacket::NewL

// Two-phased constructor.

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

//

EXPORT_C CRtpPacket* CRtpPacket::NewL()

    {

    CRtpPacket* self = CRtpPacket::NewLC();

    CleanupStack::Pop();

    return self;

    }

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

// CRtpPacket::NewLC

// Two-phased constructor.

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

//

EXPORT_C CRtpPacket* CRtpPacket::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CRtpPacket::CRtpPacket

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

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

//

CRtpPacket::CRtpPacket() : iPayload( NULL, 0 )

    {

    // None

    }

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

// CRtpPacket::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CRtpPacket::ConstructL()

    {

    // None

    }

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

// CRtpPacket::CRtpPacket

// Destructor.

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

//

EXPORT_C CRtpPacket::~CRtpPacket()

    {

    if ( iRtpRecvHeader.iHeaderExtension )

        {

        // Remove iData

        delete[] ( iRtpRecvHeader.iHeaderExtension )->iData;

        delete iRtpRecvHeader.iHeaderExtension;

        }

    if ( iRtpRecvHeader.iCsrcList )

        {

        delete[] iRtpRecvHeader.iCsrcList;

        }

    }

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

// CRtpPacket::ParseRtcp

// 

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

//

EXPORT_C TInt CRtpPacket::ParseRtp( const TDesC8& aPktBuf )

    {

    if ( aPktBuf.Length() < KRtpMinHeaderLength )

        {

        SetTimeStamp( 0 );

        iPayload.Set( NULL, 0 );

        return KErrUnderflow;

        }

    // 1st byte

    TInt byte( 0 );

    TUint8 version_flag( ( aPktBuf[byte] & 0xc0 ) >> 6 );

    // v=2 is mandatory 

    if ( version_flag != KRtpPacketVersion ) 

        {

        SetTimeStamp( 0 );

        iPayload.Set( NULL, 0 );

        return KErrNotSupported;

        } 

    iRtpRecvHeader.iPadding = ( aPktBuf[byte] >> 5 ) & 1;

    iRtpRecvHeader.iExtension = ( aPktBuf[byte] >> 4 ) & 1;

    iRtpRecvHeader.iCsrcCount = aPktBuf[byte++] & 0xf;

    // 2nd byte

    iRtpRecvHeader.iMarker = ( aPktBuf[byte] >> 7 ) & 1;

    iRtpRecvHeader.iPayloadType = aPktBuf[byte++] & 0x7f;

    // 3rd - 4th bytes

    TUint16 seq_no( aPktBuf[byte++] << 8 );

    seq_no |= aPktBuf[byte++];

    iRtpRecvHeader.iSeqNum = seq_no;

    // 5th - 8th bytes

    TUint32 timestamp( Read32Bits( aPktBuf, byte ) );

    iRtpRecvHeader.iTimestamp = timestamp;

    // 9th - 12th bytes

    TInt32 ssrc( Read32Bits( aPktBuf, byte ) );

    // 13th - bytes (optional)

    // total len = 4 * csrc_len (bytes)

    if ( iRtpRecvHeader.iCsrcCount > 0 )

        {

        iRtpRecvHeader.iCsrcList = new TUint32[iRtpRecvHeader.iCsrcCount];

        //TInt32* csrc = new TInt32[csrc_len];

        for ( TInt i( 0 ); i < iRtpRecvHeader.iCsrcCount; i++ )

            {

            iRtpRecvHeader.iCsrcList[i] = Read32Bits( aPktBuf, byte );

            }

        }

    // optional extension field

    if ( iRtpRecvHeader.iExtension == 1 )

        {

        /*

        iRtpRecvHeader.iHeaderExtension = new TRtpHeaderExtension();

        // 16 bits

        TInt16 op_code( aPktBuf[byte++] << 8 );

        op_code |= aPktBuf[byte++];

        iRtpRecvHeader.iHeaderExtension->iType = op_code;

        // 16 bits

        TInt16 op_code_data_length = aPktBuf[byte++] << 8;

        op_code_data_length |= aPktBuf[byte++];

        iRtpRecvHeader.iHeaderExtension->iLength = op_code_data_length;

        op_code_data_length * 4 bytes of extension data

        op_code_data = new TInt32[op_code_data_length];

        iRtpRecvHeader.iHeaderExtension->iData = new TInt32[op_code_data_length];

        for ( TInt i( 0 ); i < op_code_data_length; i++ )

            {

            iRtpRecvHeader.iHeaderExtension)->iData[i] = Read32Bits( aPktBuf, byte );

            }

        */

        }

    // The rest is payload data

    iPayload.Set( aPktBuf.Mid( byte ) );

    return KErrNone;

    }

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

// CRtpPacket::SetTimeStamp

// 

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

//

EXPORT_C void CRtpPacket::SetTimeStamp( const TUint32 aTs )

    {

    iRtpRecvHeader.iTimestamp = aTs;

    }

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

// CRtpPacket::Read32Bits

// 

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

//

TUint CRtpPacket::Read32Bits( const TPtrC8& aPktBuf, TInt& aByte )

    {

    TUint ret( ( ( TUint )( aPktBuf[aByte++] ) ) << 24 );

    ret |= ( ( TUint )( aPktBuf[aByte++] ) ) << 16;

    ret |= ( ( TUint )( aPktBuf[aByte++] ) ) << 8;

    ret |= ( ( TUint )( aPktBuf[aByte++] ) );

    return ret;

    }

// End of File