jni/ccrtp-android/src/ccrtp/rtcppkt.h

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

/** 
 * @file rtcppkt.h 
 *
 * @short RTCP packets handling.
 **/

/**
 * @defgroup rtcppacket RTCP compound packets manipulation.
 * @{
 **/

/** 
 * @enum SDESItemType
 * @short SDES items that may be carried in a Source DEScription RTCP packet.
 *
 * CNAME is mandatory in each RTCP compound packet (except when
 * splitted for partial encryption), the others are optional and have
 * different sending frequencies, though with recommended default
 * values.
 **/
typedef enum
{
	SDESItemTypeEND = 0,         ///< END of SDES item list.
	SDESItemTypeCNAME,           ///< Canonical end-point identifier.
	SDESItemTypeNAME,            ///< Personal NAME of the user.
	SDESItemTypeEMAIL,           ///< EMAIL address of the user.
	SDESItemTypePHONE,           ///< Phone number of the user.
	SDESItemTypeLOC,             ///< Location where the user is.
	SDESItemTypeTOOL,            ///< Application or tool.
	SDESItemTypeNOTE,            ///< Comment usually reporting state.
	SDESItemTypePRIV,            ///< Private extension.
	SDESItemTypeH323CADDR,       ///< H323 callable address.
	SDESItemTypeLast = SDESItemTypeH323CADDR ///< Last defined code.
}       SDESItemType;

/**
 * @class RTCPCompoundHandler
 * @short low level structs and RTCP packet parsing and building
 * methods.
 *
 * Intended to be used, through inheritance, in RTCP management
 * classes, such as QueueRTCPManager.
 *
 * @author Federico Montesino Pouzols <fedemp@altern.org> 
 **/
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
	 *
	 * Struct for the data contained in a receiver info
	 * block. Receiver info blocks can be found in SR (sender
	 * report) or RR (receiver report) RTCP packets.
	 **/
	struct ReceiverInfo
	{
		uint8 fractionLost;      ///< packet fraction lost.
		uint8 lostMSB;           ///< cumulative lost MSB of 3 octets.
		uint16 lostLSW;          ///< cumulative lost two LSB.
		uint32 highestSeqNum;    ///< highest sequence number.
		uint32 jitter;           ///< arrival jitter.
		uint32 lsr;              ///< last sender report timestamp.
		uint32 dlsr;             ///< delay since last sender report.
	};
	
	/**
	 * @struct RRBlock
	 *
	 * Struct for a receiver info block in a SR (sender report) or an RR
	 * (receiver report) RTCP packet.
	 **/
	struct RRBlock
	{
		uint32 ssrc;                   ///< source identifier.
		ReceiverInfo rinfo;            ///< info about the source.
	};
	
	/**
	 * @struct RecvReport
	 *
	 * @short raw structure of the source and every receiver report in an
	 * SR or RR RTCP packet.  
	 **/
	struct RecvReport
	{
		uint32 ssrc;                 ///< source identifier.
		RRBlock blocks[1];           ///< receiver report blocks.
	};
	
	/**
	 * @struct SenderInfo
	 *
	 * Struct for the sender info block in a SR (sender report)
	 * RTCP packet.
	 **/
	struct SenderInfo
	{
		uint32 NTPMSW;              ///< NTP timestamp higher octets.
		uint32 NTPLSW;              ///< NTP timestamp lower octets.
		uint32 RTPTimestamp;        ///< RTP timestamp.
		uint32 packetCount;         ///< cumulative packet counter.
		uint32 octetCount;          ///< cumulative octet counter.
	};
	
	/**
	 * @struct SendReport
	 *
	 * Struct for SR (sender report) RTCP packets. 
	 **/
	struct SendReport
	{
		uint32 ssrc;       ///< source identifier.
		SenderInfo sinfo;  ///< actual sender info.
		RRBlock blocks[1]; ///< possibly several receiver info blocks.
	};
	
	/**
	 * @struct SDESItem
	 *
	 * Struct for an item description of a SDES packet.
	 **/
	struct SDESItem 
	{
		uint8 type;       ///< item identifier.
		uint8 len;        ///< item len in octets.
		char data[1];     ///< item content.
	};

	/**
	 * @struct SDESChunk
	 *
	 * Struct for a chunk of items in a SDES RTCP packet.
	 **/
	struct SDESChunk 
	{
		uint32 getSSRC() const
		{ return (ntohl(ssrc)); }

		uint32 ssrc;      ///< SSRC identifer from sender.
		SDESItem item;    ///< SDES item from sender.		
	};

	/**
	 * @struct BYEPacket
	 *
	 * @short Struct for BYE (leaving session) RTCP packets.
	 **/
	struct BYEPacket 
	{
		uint32 ssrc;          ///< ssrc identifier of source leaving.
		uint8 length;         ///< [optional] length of reason.
	};
	
	/**
	 * @struct APPPacket
	 *
	 * @short Struct for APP (application specific) RTCP packets.
	 **/
	struct APPPacket
	{
		uint32 ssrc;           ///< ssrc identifier of source.
		char name [4];         ///< Name of the APP packet,
				       ///interpreted as a sequence of
				       ///four characters.
		unsigned char data[1]; ///< application dependent data.
	};

	/**
	 * @struct FIRPacket
	 *
	 * @short Struct for Full Intra-frame Request (FIR) RTCP
	 * packet. Specific for H.261 sessions (see RFC 2032).
	 **/
	struct FIRPacket
	{
		uint32 ssrc;           ///< ssrc identifier of source.
	};

	/**
	 * @struct NACKPacket
	 *
	 * @short Struct for Negative ACKnowledgements (NACK) RTCP
	 * packet. Specific for H.261 sessions (see RFC 2032).
	 **/
	struct NACKPacket
	{
		uint32 ssrc;           ///< ssrc identifier of source.
		uint16 fsn;            ///< First Sequence Number lost.
		uint16 blp;            ///< Bitmask of following Lost Packets.
	};

	/**
	 * @struct RTCPFixedHeader
	 * Fixed RTCP packet header. First 32-bit word in any RTCP
	 * packet.
	 */
	struct RTCPFixedHeader
	{
#if	__BYTE_ORDER == __BIG_ENDIAN
		///< For big endian boxes
		unsigned char version:2;      ///< Version, currently 2.
		unsigned char padding:1;      ///< Padding bit.
		unsigned char block_count:5;  ///< Number of RR, SR, or SDES chunks.
#else
		///< For little endian boxes
		unsigned char block_count:5;  ///< Number of RR, SR, or SDES chunks. 
		unsigned char padding:1;      ///< Padding bit.
		unsigned char version:2;      ///< Version, currently 2.
#endif
		uint8 type;    ///< type of RTCP packet.
		uint16 length; ///< number of 32-bit words in the packet (*minus one*).
	};

	/**
	 * @struct RTCPPacket 
	 *
	 * @short Struct representing general RTCP packet headers as they are
	 * sent through the network.
	 * 
	 * This struct consists of a fixed header, always at the
	 * beginning of any RTCP packet, and a union for all the RTCP
	 * packet types supported.
	 **/
	struct RTCPPacket
	{
		/**
		 * @enum Type rtp.h cc++/rtp.h
		 * 
		 * RTCP packet types. They are registered with IANA.
		 */
		typedef enum {
			tSR = 200,      ///< Sender Report.
			tRR,            ///< Receiver Report.
			tSDES,          ///< Source DEScription.
			tBYE,           ///< End of participation.
			tAPP,           ///< APPlication specific.
			tFIR   = 192,   ///< Full Intra-frame request.
			tNACK  = 193,   ///< Negative ACK.
			tXR             ///< Extended Report.
		}       Type;
		
		/**
		 * Get the packet length specified in its header, in
		 * octets and in host order.
		 **/
		uint32 getLength() const
		{ return ((ntohs(fh.length) + 1) << 2); }

		/**
		 * Get the SSRC identifier specified in the packet
		 * header, in host order.
		 **/
		uint32 getSSRC()  const			
		{ return (ntohl(info.RR.ssrc)); } // SSRC is always the first
						  // word after fh.

		RTCPFixedHeader fh;           ///< Fixed RTCP header.

		// 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;        ///< Union for SR, RR, SDES, BYE and APP
	};
#ifdef	CCXX_PACKED
#pragma pack()
#endif

protected:
	enum { defaultPathMTU = 1500 };

	RTCPCompoundHandler(uint16 mtu = defaultPathMTU);

	~RTCPCompoundHandler();

	/**
	 * Perform RTCP compound packet header validity check as
	 * specified in draft-ietv-avt-rtp-new. This method follows
	 * appendix A.2. Correct version, payload type, padding bit
	 * and length of every RTCP packet in the compound are
	 * verified.
	 *
	 * @param len length of the RTCP compound packet in 
	 *        the reception buffer
	 * @return whether the header is valid.
	 */
	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 RTCPReceiverInfo
 * @short Report block information of SR/RR RTCP reports.
 *
 * @author Federico Montesino Pouzols <fedemp@altern.org> 
 **/
class __EXPORT RTCPReceiverInfo
{
public:
	RTCPReceiverInfo(void* ri)
	{ memcpy(&receiverInfo,&ri,
		 sizeof(RTCPCompoundHandler::ReceiverInfo));}

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

	~RTCPReceiverInfo()
	{ }

	/**
	 * Get fraction of lost packets, as a number between 0 and
	 * 255.
	 **/
	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); }

	/**
	* Get the statistical variance of the RTP data packets
	* interarrival time.
	*
	* @return Interarrival jitter, in timestamp units.
	**/
	uint32
	getJitter() const
	{ return ntohl(receiverInfo.jitter); }

	/**
	 * Get the integer part of the NTP timestamp of the last SR
	 * RTCP packet received from the source this receiver report
	 * refers to.
	 **/
	uint16
	getLastSRNTPTimestampInt() const
	{ return (uint16)((ntohl(receiverInfo.lsr) & 0xFFFF0000) >> 16); }

	/**
	 * Get the fractional part of the NTP timestamp of the last SR
	 * RTCP packet received from the source this receiver report
	 * refers to.
	 **/
	uint16
	getLastSRNTPTimestampFrac() const
	{ return (uint16)(ntohl(receiverInfo.lsr) & 0xFFFF); }

	/**
	 * Get the delay between the last SR packet received and the
	 * transmission of this report.
	 *
	 * @return Delay, in units of 1/65536 seconds
	 **/
	uint32
	getDelayLastSR() const
	{ return ntohl(receiverInfo.dlsr); }	

private:
	RTCPCompoundHandler::ReceiverInfo receiverInfo;
};

/**
 * @class RTCPSenderInfo
 * @short Sender block information of SR RTCP reports.
 *
 * @author Federico Montesino Pouzols <fedemp@altern.org> 
 **/
class __EXPORT RTCPSenderInfo
{
public:
	RTCPSenderInfo(void* si)
	{ memcpy(&senderInfo,&si,
		 sizeof(RTCPCompoundHandler::SenderInfo));}

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

	~RTCPSenderInfo()
	{ }

	/**
	 * Get integer part of the NTP timestamp of this packet.
	 * @see NTP2Timeval
	 **/
	uint32
	getNTPTimestampInt() const
	{ return ntohl(senderInfo.NTPMSW); }

	/**
	 * Get fractional part of the NTP timestamp of this packet.
	 * @see NTP2Timeval
	 **/
	uint32
	getNTPTimestampFrac() const
	{ return ntohl(senderInfo.NTPLSW); }

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

	/**
	 * Get count of sent data packets.
	 **/
	inline uint32
	getPacketCount() const
	{ return ntohl(senderInfo.packetCount); }
	
	inline uint32
	getOctetCount() const
	{ return ntohl(senderInfo.octetCount); }

private:
	RTCPCompoundHandler::SenderInfo senderInfo;
};

/**
 * Convert a NTP timestamp, expressed as two 32-bit long words, into a
 * timeval value.
 *
 * @param msw Integer part of NTP timestamp.
 * @param lsw Fractional part of NTP timestamp.
 * @return timeval value corresponding to the given NTP timestamp.
 **/
timeval
NTP2Timeval(uint32 msw, uint32 lsw);

/**
 * Convert a time interval, expressed as a timeval, into a 32-bit time
 * interval expressed in units of 1/65536 seconds.
 *
 * @param t Timeval interval.
 * @return 32-bit value corresponding to the given timeval interval.
 **/
uint32
timevalIntervalTo65536(timeval& t);

/** @}*/ // rtcppacket

#ifdef  CCXX_NAMESPACES
}
#endif

#endif  // ndef CCXX_RTP_RTCPPKT_H_

/** EMACS **
 * Local variables:
 * mode: c++
 * c-basic-offset: 8
 * End:
 */