rtcppkt.h

Go to the documentation of this file.

// Copyright (C) 2001-2015 Federico Montesino Pouzols <fedemp@altern.org>.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU ccRTP.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccRTP.  If you copy code from other releases into a copy of GNU
// ccRTP, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccRTP, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef CCXX_RTP_RTCPPKT_H_
#define CCXX_RTP_RTCPPKT_H_

#include <ccrtp/base.h>

NAMESPACE_COMMONCPP

typedef enum
{
    SDESItemTypeEND = 0,         
    SDESItemTypeCNAME,           
    SDESItemTypeNAME,            
    SDESItemTypeEMAIL,           
    SDESItemTypePHONE,           
    SDESItemTypeLOC,             
    SDESItemTypeTOOL,            
    SDESItemTypeNOTE,            
    SDESItemTypePRIV,            
    SDESItemTypeH323CADDR,       
    SDESItemTypeLast = SDESItemTypeH323CADDR 
}       SDESItemType;

class __EXPORT RTCPCompoundHandler
{
public:
    inline void setPathMTU(uint16 mtu)
    { pathMTU = mtu; }

    inline uint16 getPathMTU()
    { return pathMTU; }

#ifdef  CCXX_PACKED
#pragma pack(1)
#endif

    struct ReceiverInfo
    {
        uint8 fractionLost;      
        uint8 lostMSB;           
        uint16 lostLSW;          
        uint32 highestSeqNum;    
        uint32 jitter;           
        uint32 lsr;              
        uint32 dlsr;             
    };

    struct RRBlock
    {
        uint32 ssrc;                   
        ReceiverInfo rinfo;            
    };

    struct RecvReport
    {
        uint32 ssrc;                 
        RRBlock blocks[1];           
    };

    struct SenderInfo
    {
        uint32 NTPMSW;              
        uint32 NTPLSW;              
        uint32 RTPTimestamp;        
        uint32 packetCount;         
        uint32 octetCount;          
    };

    struct SendReport
    {
        uint32 ssrc;       
        SenderInfo sinfo;  
        RRBlock blocks[1]; 
    };

    struct SDESItem
    {
        uint8 type;       
        uint8 len;        
        char data[1];     
    };

    struct SDESChunk
    {
        uint32 getSSRC() const
        { return (ntohl(ssrc)); }

        uint32 ssrc;      
        SDESItem item;    
    };

    struct BYEPacket
    {
        uint32 ssrc;          
        uint8 length;         
    };

    struct APPPacket
    {
        uint32 ssrc;           
        char name [4];         
        unsigned char data[1]; 
    };

    struct FIRPacket
    {
        uint32 ssrc;           
    };

    struct NACKPacket
    {
        uint32 ssrc;           
        uint16 fsn;            
        uint16 blp;            
    };

    struct RTCPFixedHeader
    {
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN
        unsigned char version:2;      
        unsigned char padding:1;      
        unsigned char block_count:5;  
#else
        unsigned char block_count:5;  
        unsigned char padding:1;      
        unsigned char version:2;      
#endif
        uint8 type;    
        uint16 length; 
    };

    struct RTCPPacket
    {
        typedef enum {
            tSR = 200,      
            tRR,            
            tSDES,          
            tBYE,           
            tAPP,           
            tFIR   = 192,   
            tNACK  = 193,   
            tXR             
        }       Type;

        uint32 getLength() const
        { return ((ntohs(fh.length) + 1) << 2); }

        uint32 getSSRC()  const
        { return (ntohl(info.RR.ssrc)); } // SSRC is always the first
                          // word after fh.

        RTCPFixedHeader fh;           

        // An RTCP packet may be of any of the types defined
        // above, including APP specific ones.
        union
        {
            SendReport SR;
            RecvReport RR;
            SDESChunk SDES;
            BYEPacket BYE;
            APPPacket APP;
            NACKPacket NACK;
            FIRPacket FIR;
        }       info;        
    };
#ifdef  CCXX_PACKED
#pragma pack()
#endif

protected:
    enum { defaultPathMTU = 1500 };

    RTCPCompoundHandler(uint16 mtu = defaultPathMTU);

    ~RTCPCompoundHandler();

    bool
    checkCompoundRTCPHeader(size_t len);

    // buffer to hold RTCP compound packets being sent. Allocated
    // in construction time
    unsigned char* rtcpSendBuffer;
    // buffer to hold RTCP compound packets being
    // received. Allocated at construction time
    unsigned char* rtcpRecvBuffer;

    friend class RTCPSenderInfo;
    friend class RTCPReceiverInfo;
private:
    // path MTU. RTCP packets should not be greater than this
    uint16 pathMTU;
    // masks for RTCP header validation;
    static const uint16 RTCP_VALID_MASK;
    static const uint16 RTCP_VALID_VALUE;
};

class __EXPORT RTCPReceiverInfo
{
public:
    RTCPReceiverInfo(void* ri)
    { memcpy(&receiverInfo,&ri,
         sizeof(RTCPCompoundHandler::ReceiverInfo));}

        RTCPReceiverInfo(RTCPCompoundHandler::ReceiverInfo& si)
        : receiverInfo( si )
        {
        }

    ~RTCPReceiverInfo()
    { }

    inline uint8
    getFractionLost() const
    { return receiverInfo.fractionLost; }

    inline uint32
    getCumulativePacketLost() const
    { return ( ((uint32)ntohs(receiverInfo.lostLSW)) +
           (((uint32)receiverInfo.lostMSB) << 16) ); }

    inline uint32
    getExtendedSeqNum() const
    { return ntohl(receiverInfo.highestSeqNum); }

    uint32
    getJitter() const
    { return ntohl(receiverInfo.jitter); }

    uint16
    getLastSRNTPTimestampInt() const
    { return (uint16)((ntohl(receiverInfo.lsr) & 0xFFFF0000) >> 16); }

    uint16
    getLastSRNTPTimestampFrac() const
    { return (uint16)(ntohl(receiverInfo.lsr) & 0xFFFF); }

    uint32
    getDelayLastSR() const
    { return ntohl(receiverInfo.dlsr); }

private:
    RTCPCompoundHandler::ReceiverInfo receiverInfo;
};

class __EXPORT RTCPSenderInfo
{
public:
    RTCPSenderInfo(void* si)
    { memcpy(&senderInfo,&si,
         sizeof(RTCPCompoundHandler::SenderInfo));}

        RTCPSenderInfo(RTCPCompoundHandler::SenderInfo& si)
        : senderInfo( si )
        {
        }

    ~RTCPSenderInfo()
    { }

    uint32
    getNTPTimestampInt() const
    { return ntohl(senderInfo.NTPMSW); }

    uint32
    getNTPTimestampFrac() const
    { return ntohl(senderInfo.NTPLSW); }

    inline uint32
    getRTPTimestamp() const
    { return ntohl(senderInfo.RTPTimestamp); }

    inline uint32
    getPacketCount() const
    { return ntohl(senderInfo.packetCount); }

    inline uint32
    getOctetCount() const
    { return ntohl(senderInfo.octetCount); }

private:
    RTCPCompoundHandler::SenderInfo senderInfo;
};

timeval
NTP2Timeval(uint32 msw, uint32 lsw);

uint32
timevalIntervalTo65536(timeval& t);
 // rtcppacket

END_NAMESPACE

#endif  // ndef CCXX_RTP_RTCPPKT_H_