/*
* 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:   
*
*/




// INCLUDES

#include <e32base.h>
#include <e32std.h>

#include "rtpstppacket.h"

//
// RTPLite header
//
// ****************************************
// Extract from "PoC Core Network RTP RP01" 
// ****************************************
//                       1                   2                   3
//    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//   |F M R C S|  PT | Sequence nbr  |      Checksum (optional)      |
//   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
//  Full header indication (F)  1 bit
//                              If this bit is set to zero then header format
//                              is reduced (otherwise full)
//
//  Marker (M)                  1 bit
//                              Indication of the start of speech item (value 1).
//                              It is set on the Nth first RTP packets including 
//                              speech frames within the RTP payload. N is expected
//                              to have a constant value in the order of 3 to 5. 
//                              Note: M-bit is zero for all embedded control packets.
//
//  Reserved bit (R)            1 bit
//                              This bit is reserved for future use. Default value is 1. 
//
//  Checksum indication (C)     1 bit
//                              C-bit is an indication if header includes at the end an
//                              optional checksum field. Value 1 indicates that checksum
//                              field exist on the header.
//
//  Speech Item toggle indication (S)   1 bit
//                              S-bit is used as an indication (toggled value) that speech
//                              item has been changed (toggled between two speech items 
//                              from same source; toggled between two speech items from 
//                              different users; toggled between two speech items from 
//                              different groups 1-to-1 call). This bit is on the same
//                              position for the respective leader, speech and trailing
//                              packets.
//
//  Payload Type (PT)           3 bits
//                              PT-field indicates what kind of information
//                              is carried on the paylaod area. Only two codes
//                              (000 and 001) are reserved at the first phase, 
//                              other values are reserved for future use.000 is
//                              used to indicate that embedded control signal
//                              information is in payload area and 001 indicates
//                              that payload contains speech packets coded with
//                              IETF AMR speech coding 8. In case of embedded 
//                              control signal coding then the first byte on the payload
//                              area has special coding rules, which are defined on section 5.3.4.
//                              Note: GSM HR (HalfRate) will be used for 1st integration testing 
//                              and related PT is 010.
//                              Note: Standard RTP header uses 7 bits for the same indication.
//
// Sequence Nbr (SN)            8 bits
//                              The sequence nbr increments by one for each
//                              RTP data packet sent, and may be used by the
//                              receiver to detect packet loss and restore
//                              packet sequence. The initial value (when S 
//                              bit is toggled) of the sequence number is zero. 
//                              Note one exception: during talkspurt 
//                              (for 1-to-1 call or group call) if one/few 
//                              RTP packets are not sent (on N*20ms interval)
//                              due to DTX usage (silence periods not sent) 
//                              the sequency number at the originator side 
//                              is anyhow incremented by one with the N*20ms 
//                              frequency. The value for N is 3 by default. 
//                              Very probably RTP packets are always sent in
//                              GPRS terminals during talkspurt to avoid TBF
//                              drop. RTP packet payload contains during 
//                              silence periods three NO_DATA -indication
//                              bytes to AMR decoder. In the future extented
//                              TFB timer feature may change this behaviour, 
//                              i.e. the sending of NO_DATA -indication bytes
//                              might be dropped (over GPRS).Within standard
//                              version of RTP header the length of SN is 16
//                              bits , but within PoC application it is enough
//                              to have 8 bits; it provides 7.62s (127*3*20ms)
//                              jitter buffering without any special number wrap
//                              control tricks (shown values are valid with N=3). 
//                              Note: On the uplink direction on each speech item,
//                              the Sequency Nbr is zero for all leading packets
//                              (the first leading packet is replicated few times,
//                              but the replicated messages are identical 
//                              (even concerning the SN field)) and the first RTP
//                              packet containing speech has SN value one.
//                              Note: for all embedded control signals the SN
//                              is set to zero.
//
//  CheckSum (CS)               16 bits (optional)
//                              Checksum field is optional and the existence
//                              of this field is indicated on the first octet
//                              by C-bit.  Checksum will be needed with RP01
//                              interface if RLC/LLC/UDP checksums are not
//                              available/used. UDP checksum is optional 
//                              with IPv4. Further more by using RTP level
//                              CRC in combination of UDP-lite it would be 
//                              possible to implement more efficient unequal
//                              error protection on AMR bits than UDP-lite 
//                              alone would offer.If checksum error is detected
//                              then whole RTP packet is discarded.
//                              Note: Checksum information is not available 
//                              within standard RTP header.
//                              Note: Taking the other aspects (header compression
//                              with Degermark) into account it currently means 
//                              that if checksum is included on RTPLite header
//                              the whole packet does fit to 8 kbit/s channel
//                              on the AIR interface only with AMR 4.75 coding.

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

// ---------------------------------------------------------------------------
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
// 
CRtpStpPacket::CRtpStpPacket() :
    iSize( 0 ),
    iData( 0 ),
    iDataPtr( 0 ),
    iSessionId( 0 )
    {
    }

// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CRtpStpPacket::ConstructL( TUint aPacketSize, TRtpId aSessionId )
    {
    iBuf = HBufC8::NewL( aPacketSize );
    iData = ( TUint8* ) iBuf->Des().Ptr();
    iSize = 0;
    iDataPtr = iData;
    iSessionId = aSessionId;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
// 
CRtpStpPacket::~CRtpStpPacket()
    {
    delete iBuf;
    }

// ---------------------------------------------------------------------------
// CRtpStpPacket::Close()
// works as destructor
// ---------------------------------------------------------------------------
//
void CRtpStpPacket::Close()
    {
    delete this;
    }

// ---------------------------------------------------------------------------
// CRtpStpPacket::RtpPacketReset()
// 
// ---------------------------------------------------------------------------
//
void CRtpStpPacket::RtpPacketReset()
    {
    iSize = 0;
    iDataPtr = iData;
    }

// ---------------------------------------------------------------------------
// CRtpStpPacket::RtpPacketResetPtr()
// 
// ---------------------------------------------------------------------------
//
void CRtpStpPacket::RtpPacketResetPtr()
    {
    iDataPtr = iData;
    }

// ---------------------------------------------------------------------------
// TInt CRtpStpPacket::RtpPacketBuild()
// 
// ---------------------------------------------------------------------------
//
TInt CRtpStpPacket::RtpPacketBuild( const TRtpSendHeader& aHeader, const TDesC8& aPayloadData )
    {
    TUint8* dataP;

    dataP = iData;

    // build the packet content
    Mem::FillZ( dataP, 4 );

    // Full header indication (F)
    dataP[0] |= ( 0 << 7 );

    // Marker (M) 
    dataP[0] |= static_cast<TUint8>( aHeader.iMarker << 6 );

    // Padding bit (P) = 1
    dataP[0] |= static_cast<TUint8>( aHeader.iPadding << 5 );

    // Checksum indecation (C)  if checkSumInd == 1, need checksum in the header
    dataP[0] |= static_cast<TUint8>( aHeader.iChecksumInd << 4 );

    // Speech Item toggle indication (S)
    dataP[0] |= static_cast<TUint8>( aHeader.iSpeechItemToggle << 3 );

    // payload type
    dataP[0] |= ( aHeader.iPayloadType & 0x07 );

    // sequence number
    dataP[1] = aHeader.iSeqNum;
    dataP += 2;

    // Optinal checksum
    if ( aHeader.iChecksumInd == 1 )
        {
        write16( dataP, aHeader.iChecksum );
        dataP += 2;
        }

    // copy payload data 
    Mem::Copy( dataP, aPayloadData.Ptr(), aPayloadData.Length() );
    iSize = aPayloadData.Length() + ( dataP - iData );

    return 0;
    }

// ---------------------------------------------------------------------------
// CRtpStpPacket::RtpPacketProcess()
// Return Value:
//    KErrNone if STP packet has been processed OK, or
//    KErrCorrupt if packet is invalid or some other error has occured
// ---------------------------------------------------------------------------
//
TInt CRtpStpPacket::RtpPacketProcess( TUint8* aBuf, TInt* aLength )
    {
    TRtpRecvHeader header;
    TUint8* dataP;

    dataP = iData;

    // Full header indication (F) 
    if ( ( dataP[0] & 0x80 ) != 0 )
        return KErrCorrupt;

    // Marker (M)
    header.iMarker = ( TUint8 ) ( ( dataP[0] & 0x40 ) >> 6 );

    // Padding bit (P)
    header.iPadding = ( TUint8 ) ( ( dataP[0] & 0x20 ) >> 5 );

    // Checksum indication (C) 
    header.iChecksumInd = ( TUint8 ) ( ( dataP[0] & 0x10 ) >> 4 );

    // Speech item toggle indication (S) 
    header.iSpeechItemToggle = ( TUint8 ) ( ( dataP[0] & 0x08 ) >> 3 );

    // Payload type (PT)
    header.iPayloadType = ( TUint8 ) ( ( dataP[0] & 0x07 ) );

    // Sequence number
    header.iSeqNum = ( TUint8 ) ( dataP[1] );
    dataP += 2;

    // Optinal checksum
    if ( header.iChecksumInd == 1 )
        {
        header.iChecksum = ( TUint16 ) read16( dataP ); 
        dataP += 2;
        }

    *aLength = iSize - ( dataP - iData );
    aBuf = ( TUint8 * ) dataP;

    TPtrC8 buf( aBuf, *aLength );

    if ( iObserver )
        iObserver->RtpPacketReceived( iSessionId /* streamId */, header, buf );

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// Write a 16-bit value as 2 consecutive bytes in MSB order
// Memory (at least 2 bytes) must have been allocated to pointer
// before the function is called.
// ---------------------------------------------------------------------------
//
void CRtpStpPacket::write16( TUint8* const aPointer, TUint32 aValue )
    {
    // check value range (16 bits)
    aPointer[0] = ( TUint8 ) ( ( aValue & 0xFF00 ) >> 8 );
    aPointer[1] = ( TUint8 ) ( aValue & 0x00FF );
    }

// ---------------------------------------------------------------------------
// Read a 16-bit value given as 2 consecutive bytes in MSB order
// Memory (at least 2 bytes) must have been allocated to pointer
// before the function is called.
// ---------------------------------------------------------------------------
//
TUint32 CRtpStpPacket::read16( const TUint8* const aPointer )
    {
    return( aPointer[1] + ( ( TUint32 ) aPointer[0] << 8 ) );
    }


#if !defined ( EKA2 ) && !defined ( RTP_UNIT_TEST )
// The E32Dll() entry point function
GLDEF_C TInt E32Dll( TDllReason /*aReason*/ )
    {
    return( KErrNone );
    }
#endif // EKA2

// ---------------------------------------------------------------------------
// Function to construct a CRtpPacketExt object. Note that this function
// is exported at ordinal 1 and is not a member of any class.
// ---------------------------------------------------------------------------
//
EXPORT_C MRtpPacketExt* NewL()
    {
    return new ( ELeave ) CRtpStpPacket;
    }


// End of File