rtcppkt.h

Go to the documentation of this file.

// Copyright (C) 2001,2002,2004,2007 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 General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// 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>

#ifdef CCXX_NAMESPACES
namespace ost {
#endif

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     __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

#ifdef  CCXX_NAMESPACES
}
#endif

#endif  // ndef CCXX_RTP_RTCPPKT_H_