jni/ccrtp-1.8.0-android/src/ccrtp/cqueue.h - jami-client-android - Gitiles

 // Copyright (C) 2001,2002,2004 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.
 //

 /**
  * @file cqueue.h
  *
  * @short Generic RTCP control queues.
  **/

 #ifndef	CCXX_RTP_CQUEUE_H_
 #define CCXX_RTP_CQUEUE_H_

 #include <ccrtp/ioqueue.h>

 #ifdef	CCXX_NAMESPACES
 namespace ost {
 #endif

 /**
  * @defgroup cqueue Generic RTCP control queues.
  * @{
  **/

 /**
  * @class QueueRTCPManager
  * @short Adds generic management of RTCP functions to an RTP data
  * queue.
  *
  * Extends an RTP data i/o queue adding management of RTCP functions:
  *
  * Provide feedback on the quality of the data distribution.
  *
  * Convey the CNAME (persistent transport-level identifier) for every
  * RTP source.
  *
  * Control the sending rate of RTCP packets
  *
  * Convey minimal control information about the participants
  *
  * This class implements generic RTCP behaviour (as specified in RFC
  * 1889/draft-ietf-avt-rtp-new) and may be specialized for specific
  * profiles (see AVPQueue) or particular RTCP extensions.
  *
  * @author Federico Montesino Pouzols <fedemp@altern.org>
  **/
 class __EXPORT QueueRTCPManager : public RTPDataQueue,
 	protected RTCPCompoundHandler
 {
 public:
 	/**
 	 * Get the most recent sender report received from a
 	 * synchronization source.
 	 *
 	 * @param src Synchronization source of the sender info.
 	 * @return Most recent sender info received from src.
 	 * @retval NULL when no sender report has been received from
 	 * the specified source.
 	 **/
 	RTCPSenderInfo* getMRSenderInfo(SyncSource& src);

 	/**
 	 * Ask for the info in the most recent receiver report about
 	 * the local source received from the source given as
 	 * parameter.
 	 *
 	 * @param srcFrom Source of the receiver info.
 	 * @return most recent receiver info received from src.
 	 * @retval NULL when no receiver report has been received from
 	 * the specified source.
 	 */
 	RTCPReceiverInfo* getMRReceiverInfo(SyncSource& srcFrom);

 	/**
 	 * Set how much time the stack will wait before deleting a
 	 * synchronization source that has sent an RTCP BYE packet.
 	 *
 	 * @param delay delay in microseconds.
 	 *
 	 * @note The default delay is 1000000 microseconds
 	 **/
 	void setLeavingDelay(microtimeout_t delay)
 	{ leavingDelay = delay; }

 	/**
 	 * This method sets the maximum end to end delay allowed. If
 	 * the processing delay plus the trip time for a packet is
 	 * greater than the end to end delay, the packet is discarded,
 	 * and the application cannot get it.
 	 *
 	 * This is a way of setting an upper bound to the end to end
 	 * delay, computed as the elapsed time between the packet
 	 * timestamping at the sender side, and the picking of the
 	 * packet at the receiver side.
 	 *
 	 * @param t maximum end to end delay allowed. A value of 0
 	 * implies there is no limit and is the default
 	 */
 	inline void
 	setEnd2EndDelay(microtimeout_t t)
 		{ end2EndDelay = t; }

 	inline microtimeout_t
 	getDefaultEnd2EndDelay() const
 	{ return defaultEnd2EndDelay; }

 	inline microtimeout_t
 	getEnd2EndDelay() const
 	{ return end2EndDelay; }

 	/**
 	 * Specify the fraction of the total control bandwith to be
 	 * dedicated to senders reports.
 	 *
 	 * @param fraction fraction of bandwidth, must be between 0 an 1.
 	 *
 	 * This method sets the fraction of the global control
 	 * bandwidth that will be dedicated to senders reports. Of
 	 * course, <code>1 - fraction</code> will be dedicated to
 	 * receivers reports.
 	 *
 	 * @see setControlBandwidth
 	 */
 	inline void
 	setSendersControlFraction(float fraction)
 	{ sendControlBwFract = fraction; recvControlBwFract = 1 - fraction;}

 	/**
 	 * Manually set the minimum interval for sending RTP compound
 	 * packets
 	 *
 	 * @param interval minimum interval between RTCP packets, in
 	 * microseconds.
 	 *
 	 * @see computeRTCPInterval()
 	 **/
 	void
 	setMinRTCPInterval(microtimeout_t interval)
 	{ rtcpMinInterval = interval; }

 	/**
 	 * Get the total number of RTCP packets sent until now
 	 **/
 	inline uint32
 	getSendRTCPPacketCount() const
 	{ return ctrlSendCount; }

 protected:
 	QueueRTCPManager(uint32 size = RTPDataQueue::defaultMembersHashSize,
 			 RTPApplication& app = defaultApplication());

 	QueueRTCPManager(uint32 ssrc,
 			 uint32 size = RTPDataQueue::defaultMembersHashSize,
 			 RTPApplication& app = defaultApplication());

 	virtual
 	~QueueRTCPManager();

 	const RTPApplication&
 	getApplication()
 	{ return queueApplication; }

 	inline void
 	setControlBandwidth(float fraction)
 	{ controlBwFract = fraction; }

 	float
 	getControlBandwidth() const
 	{ return controlBwFract; }

 	/**
 	 * Build and send RTCP packets following timing rules
 	 * (including the "timer reconsideration" algorithm).
 	 **/
 	void
 	controlTransmissionService();

 	/**
 	 * Process incoming RTCP packets pending in the control
 	 * reception socket.
 	 **/
 	void
 	controlReceptionService();

 	/**
 	 * Appy collision and loop detection and correction algorithm
 	 * when receiving RTCP packets. Follows section 8.2 in
 	 * draft-ietf-avp-rtp-new.
 	 *
 	 * @param sourceLink link to the source object.
 	 * @param is_new whether the source has been just recorded.
 	 * @param na RTCP packet network address.
 	 * @param tp RTCP packet source transport port.
 	 *
 	 * @return whether the packet must not be discarded.
 	 **/
 	bool checkSSRCInRTCPPkt(SyncSourceLink& sourceLink, bool is_new,
 				InetAddress& na, tpport_t tp);

 	void
 	endQueueRTCPManager();

 	/**
 	 * Plug-in for processing (acquire information carried in) an
 	 * incoming RTCP Sender Report. The default implementation in
 	 * this class only processes the sender information and the
 	 * receiver report blocks about the local source.
 	 *
 	 * @param source Synchronization source this report comes from.
 	 * @param SR Sender report structure.
 	 * @param blocks Number of report blocks in the packet.
 	 **/
 	virtual void
 	onGotSR(SyncSource& source, SendReport& SR, uint8 blocks);

 	/**
 	 * Plug-in for processing (acquire information carried in) an
 	 * incoming RTCP Receiver Report. The default implementation
 	 * in this class only processes the receiver report blocks
 	 * about the local source.
 	 *
 	 * @param source Synchronization source this report comes from.
 	 * @param RR Receiver report structure
 	 * @param blocks Number of report blocks in the packet
 	 **/
 	virtual void
 	onGotRR(SyncSource& source, RecvReport& RR, uint8 blocks);

 	/**
 	 * @param source Synchronization source of SDES RTCP packet.
 	 * @param pkt SDES RTCP packet received.
 	 **/
 	bool
 	onGotSDES(SyncSource& source, RTCPPacket& pkt);

 	/**
 	 * Plug-in for handling of SDES chunks.
 	 *
 	 * @param source Synchronization source of SDES chunk.
 	 * @param chunk SDES chunk structure.
 	 * @param len Length of chunk, in octets.
 	 *
 	 * @return whether there was a CNAME.
 	 **/
 	virtual bool
 	onGotSDESChunk(SyncSource& source, SDESChunk& chunk, size_t len);

 	/**
 	 * Plug-in for handling of APP (application specific) RTCP
 	 * packets.
 	 *
 	 * @param - Synchronization source of this packet.
 	 * @param - RTCP APP packet struct.
 	 * @param - Length of the app data packet, including ssrc.
 	 * name and app. specific data.
 	 **/
 	inline virtual void
 	onGotAPP(SyncSource&, RTCPCompoundHandler::APPPacket&,
 		 size_t)
 	{ return; }

 	inline timeval
 	getRTCPCheckInterval()
 	{ return rtcpCheckInterval; }

 	/**
 	 * Get the number of data packets sent at the time the last SR
 	 * was generated.
 	 **/
 	uint32
 	getLastSendPacketCount() const
 	{ return lastSendPacketCount; }

 	/**
 	 * @param n Number of members.
 	 **/
 	inline void
 	setPrevMembersNum(uint32 n)
 	{ reconsInfo.rtcpPMembers = n; }

 	inline uint32
 	getPrevMembersCount() const
 	{ return reconsInfo.rtcpPMembers; }

 	/**
 	 * This method is used to send an RTCP BYE packet.  An RTCP
 	 * BYE packet is sent when one of the the following
 	 * circumstances occur:
 	 * - when leaving the session
 	 * - when we have detected that another synchronization source
 	 * in the same session is using the same SSRC identifier as
 	 * us.
 	 *
 	 * Try to post a BYE message. It will send a BYE packet as
 	 * long as at least one RTP or RTCP packet has been sent
 	 * before. If the number of members in the session is more
 	 * than 50, the algorithm described in section 6.3.7 of
 	 * RFC 3550 is applied in order to avoid a flood
 	 * of BYE messages.
 	 *
 	 * @param reason reason to specify in the BYE packet.
 	 **/
 	size_t
 	dispatchBYE(const std::string& reason);

 	size_t
 	sendControlToDestinations(unsigned char* buffer, size_t len);

 private:
 	QueueRTCPManager(const QueueRTCPManager &o);

 	QueueRTCPManager&
 	operator=(const QueueRTCPManager &o);

 	/**
 	 * Posting of RTCP messages.
 	 *
 	 * @return std::size_t number of octets sent
 	 */
 	size_t
 	dispatchControlPacket();

 	/**
 	 * For picking up incoming RTCP packets if they are waiting. A
 	 * timeout for the maximum interval since the last RTCP packet
 	 * had been received is also returned. This is checked every
 	 * rtcpCheckInterval seconds.
 	 *
 	 * This method decomposes all incoming RTCP compound packets
 	 * pending in the control socket and processes each RTCP
 	 * packet.
 	 *
 	 **/
 	void
 	takeInControlPacket();

 	/**
 	 * Computes the interval for sending RTCP compound packets,
 	 * based on the average size of RTCP packets sent and
 	 * received, and the current estimated number of participants
 	 * in the session.
 	 *
 	 * @note This currently follows the rules in section 6 of
 	 *       RFC 3550
 	 * @todo make it more flexible as recommended in the draft. For now,
 	 * we have setMinRTCPInterval.
 	 *
 	 * @return interval for sending RTCP compound packets
 	 **/
 	virtual timeval
 	computeRTCPInterval();

 	/**
 	 * Choose which should be the type of the next SDES item
 	 * sent. This method is called when packing SDES chunks in a
 	 * new RTCP packet.
 	 *
 	 * @return type of the next SDES item to be sent
 	 **/
 	virtual SDESItemType
 	scheduleSDESItem();

 	/**
 	 * Plug-in for SSRC collision handling.
 	 *
 	 * @param - previously identified source.
 	 **/
 	inline virtual void
 	onSSRCCollision(const SyncSource&)
 	{ }

 	/**
 	 * Virtual reimplemented from RTPDataQueue
 	 **/
 	virtual bool
 	end2EndDelayed(IncomingRTPPktLink& p);

 	/**
 	 * Plug-in for processing of SR/RR RTCP packet
 	 * profile-specific extensions (third part of SR reports or
 	 * second part of RR reports).
 	 *
 	 * @param - Content of the profile extension.
 	 * @param - Length of the extension, in octets.
 	 **/
 	inline virtual void
 	onGotRRSRExtension(unsigned char*, size_t)
 	{ return; }

  	/**
  	 * A plugin point for goodbye message.  Called when a BYE RTCP
  	 * packet has been received from a valid synchronization
  	 * source.
 	 *
 	 * @param - synchronization source from what a BYE RTCP
 	 * packet has been just received.
 	 * @param - reason string the source has provided.
  	 **/
  	inline virtual void
 	onGotGoodbye(const SyncSource&, const std::string&)
 	{ return; }

 	/**
 	 * Process a BYE packet just received and identified.
 	 *
 	 * @param pkt previously identified RTCP BYE packet
 	 * @param pointer octet number in the RTCP reception buffer
 	 *        where the packet is stored
 	 * @param len total length of the compount RTCP packet the BYE
 	 *        packet to process is contained
 	 *
 	 * @bug if the bye packet contains several SSRCs,
 	 *      eventSourceLeaving is only called for the last one
 	 **/
 	bool
 	getBYE(RTCPPacket &pkt, size_t &pointer, size_t len);

 	/**
 	 * @return number of Report Blocks packed
 	 **/
 	uint8
 	packReportBlocks(RRBlock* blocks, uint16& len, uint16& available);

 	/**
 	 * Builds an SDES RTCP packet. Each chunk is built following
 	 * appendix A.4 in draft-ietf-avt-rtp-new.
 	 *
 	 * @param len provisionary length of the RTCP compound packet
 	 *
 	 * @return
 	 **/
 	void
 	packSDES(uint16& len);

 	/**
 	 * This must be called in order to update the average RTCP compound
 	 * packet size estimation when:
 	 *
 	 * a compoung RTCP packet is received (6.3.3).
 	 *
 	 * a compound RTCP packet is transmitted (6.3.6).
 	 *
 	 * @param len length in octets of the compound RTCP packet
 	 * just received/transmitted.
 	 **/
 	void
 	updateAvgRTCPSize(size_t len);

 	/**
 	 * Apply reverse reconsideration adjustment to timing
 	 * parameters when receiving BYE packets and not waiting to
 	 * send a BYE.
 	 **/
 	void
 	reverseReconsideration();

 	bool
 	timerReconsideration();

 	/**
 	 * Purge sources that do not seem active any more.
 	 *
 	 * @note MUST be perform at least every RTCP transmission
 	 *       interval
 	 * @todo implement it. It may be dangerous and anyway should
 	 * be optional.
 	 **/
 	void
 	expireSSRCs();

 	/**
 	 * To be executed when whe are leaving the session.
 	 **/
 	void
 	getOnlyBye();

 	/**
 	 * Set item value from a string without null termination (as
 	 * it is transported in RTCP packets).
 	 **/
 	void
 	setSDESItem(Participant* part, SDESItemType type,
 		    const char* const value, size_t len);

 	/**
 	 * Set PRIV item previx value from a string without null
 	 * termination (as it is transported in RTCP packets).
 	 **/
 	void
 	setPRIVPrefix(Participant* part, const char* const value, size_t len);

 	/**
 	 * For certain control calculations in RTCP, the size of the
 	 * underlying network and transport protocols is needed. This
 	 * method provides the size of the network level header for
 	 * the default case of IP (20 octets). In case other protocol
 	 * with different header size is used, this method should be
 	 * redefined in a new specialized class.
 	 *
 	 * @return size of the headers of the network level. IP (20) by
 	 *        default.
 	 **/
 	inline virtual uint16
 	networkHeaderSize()
 	{ return 20; }

 	/**
 	 * For certain control calculations in RTCP, the size of the
 	 * underlying network and transport protocols is needed. This
 	 * method provides the size of the transport level header for
 	 * the default case of UDP (8 octets). In case other protocol
 	 * with different header size is used, this method should be
 	 * redefined in a new specialized class.
 	 *
 	 * return size of the headers of the transport level. UDP (8)
 	 *        by default
 	 **/
 	inline virtual uint16
 	transportHeaderSize()
 	{ return 8; }

 	SDESItemType
 	nextSDESType(SDESItemType t);

 	virtual size_t
 	sendControl(const unsigned char* const buffer, size_t len) = 0;

 	virtual size_t
 	recvControl(unsigned char* buffer, size_t len,
 		    InetHostAddress& na, tpport_t& tp) = 0;

 	virtual bool
 	isPendingControl(microtimeout_t timeout) = 0;

 	// whether the RTCP service is active
 	volatile bool controlServiceActive;
 	float controlBwFract, sendControlBwFract, recvControlBwFract;
 	// number of RTCP packets sent since the beginning
 	uint32 ctrlSendCount;

 	// Network + transport headers size, typically size of IP +
 	// UDP headers
 	uint16 lowerHeadersSize;

 	SDESItemType nextScheduledSDESItem;
 	static const SDESItemType firstSchedulable;
 	static const SDESItemType lastSchedulable;

 	// state for rtcp timing. Its meaning is defined in
 	// draft-ietf-avt-rtp-new, 6.3.

 	// Parameters for timer reconsideration algorithm
 	struct {
 		timeval rtcpTp, rtcpTc, rtcpTn;
 		uint32 rtcpPMembers;
 	} reconsInfo;
 	bool rtcpWeSent;
 	uint16 rtcpAvgSize;
 	bool rtcpInitial;
 	// last time we checked if there were incoming RTCP packets
 	timeval rtcpLastCheck;
 	// interval to check if there are incoming RTCP packets
 	timeval rtcpCheckInterval;
 	// next time to check if there are incoming RTCP packets
 	timeval rtcpNextCheck;

 	// number of RTP data packets sent at the time of the last
 	// RTCP packet transmission.
 	uint32 lastSendPacketCount;

 	// minimum interval for transmission of RTCP packets. The
 	// result of computeRTCPInterval will always be >= (times a
 	// random number between 0.5 and 1.5).
 	microtimeout_t rtcpMinInterval;

 	microtimeout_t leavingDelay;
 	static const microtimeout_t defaultEnd2EndDelay;
 	// Maximum delay allowed between packet timestamping and
 	// packet availability for the application.
 	microtimeout_t end2EndDelay;
 	// Application this queue is bound to.
 	RTPApplication& queueApplication;

 	// an empty RTPData
 	static const uint16 TIMEOUT_MULTIPLIER;
 	static const double RECONSIDERATION_COMPENSATION;
 };

 /**
  * This class, an RTP/RTCP queue, adds audio/video profile (AVP)
  * specific methods to the generic RTCP service queue
  * (QueueRTCPManager).
  *
  * @author Federico Montesino Pouzols <fedemp@altern.org>
  **/
 class AVPQueue : public QueueRTCPManager
 {
 public:
 	/**
 	 * Specify the bandwith available for control (RTCP) packets.
 	 * This method sets the global control bandwidth for both
 	 * sender and receiver reports. As recommended in RFC 1890,
 	 * 1/4 of the total control bandwidth is dedicated to senders,
 	 * whereas 3/4 are dedicated to receivers.
 	 *
 	 * @param fraction fraction of the session bandwidth, between
 	 * 0 and 1
 	 *
 	 * @note If this method is not called, it is assumed that the
 	 * control bandwidth is equal to 5% of the session
 	 * bandwidth. Note also that the RFC RECOMMENDS the 5%.
 	 *
 	 **/
 	inline void
 	setControlBandwidth(float fraction)
 	{ QueueRTCPManager::setControlBandwidth(fraction); }

 	float
 	getControlBandwidth() const
 	{ return QueueRTCPManager::getControlBandwidth(); }

 protected:
 	AVPQueue(uint32 size = RTPDataQueue::defaultMembersHashSize,
 		 RTPApplication& app = defaultApplication()) :
 		QueueRTCPManager(size,app)
 	{ }

 	/**
 	 * Local SSRC is given instead of computed by the queue.
 	 **/
 	AVPQueue(uint32 ssrc, uint32 size =
 		 RTPDataQueue::defaultMembersHashSize,
 		 RTPApplication& app = defaultApplication()) :
  		QueueRTCPManager(ssrc,size,app)
 	{ }
 	inline virtual ~AVPQueue()
 	{ }
 };

 /** @}*/ // cqueue

 #ifdef  CCXX_NAMESPACES
 }
 #endif

 #endif  //CCXX_RTP_CQUEUE_H_

 /** EMACS **
  * Local variables:
  * mode: c++
  * c-basic-offset: 8
  * End:
  */
	// Copyright (C) 2001,2002,2004 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.
	//

	/**
	* @file cqueue.h
	*
	* @short Generic RTCP control queues.
	**/

	#ifndef CCXX_RTP_CQUEUE_H_
	#define CCXX_RTP_CQUEUE_H_

	#include <ccrtp/ioqueue.h>

	#ifdef CCXX_NAMESPACES
	namespace ost {
	#endif

	/**
	* @defgroup cqueue Generic RTCP control queues.
	* @{
	**/

	/**
	* @class QueueRTCPManager
	* @short Adds generic management of RTCP functions to an RTP data
	* queue.
	*
	* Extends an RTP data i/o queue adding management of RTCP functions:
	*
	* Provide feedback on the quality of the data distribution.
	*
	* Convey the CNAME (persistent transport-level identifier) for every
	* RTP source.
	*
	* Control the sending rate of RTCP packets
	*
	* Convey minimal control information about the participants
	*
	* This class implements generic RTCP behaviour (as specified in RFC
	* 1889/draft-ietf-avt-rtp-new) and may be specialized for specific
	* profiles (see AVPQueue) or particular RTCP extensions.
	*
	* @author Federico Montesino Pouzols <fedemp@altern.org>
	**/
	class __EXPORT QueueRTCPManager : public RTPDataQueue,
	protected RTCPCompoundHandler
	{
	public:
	/**
	* Get the most recent sender report received from a
	* synchronization source.
	*
	* @param src Synchronization source of the sender info.
	* @return Most recent sender info received from src.
	* @retval NULL when no sender report has been received from
	* the specified source.
	**/
	RTCPSenderInfo* getMRSenderInfo(SyncSource& src);

	/**
	* Ask for the info in the most recent receiver report about
	* the local source received from the source given as
	* parameter.
	*
	* @param srcFrom Source of the receiver info.
	* @return most recent receiver info received from src.
	* @retval NULL when no receiver report has been received from
	* the specified source.
	*/
	RTCPReceiverInfo* getMRReceiverInfo(SyncSource& srcFrom);

	/**
	* Set how much time the stack will wait before deleting a
	* synchronization source that has sent an RTCP BYE packet.
	*
	* @param delay delay in microseconds.
	*
	* @note The default delay is 1000000 microseconds
	**/
	void setLeavingDelay(microtimeout_t delay)
	{ leavingDelay = delay; }

	/**
	* This method sets the maximum end to end delay allowed. If
	* the processing delay plus the trip time for a packet is
	* greater than the end to end delay, the packet is discarded,
	* and the application cannot get it.
	*
	* This is a way of setting an upper bound to the end to end
	* delay, computed as the elapsed time between the packet
	* timestamping at the sender side, and the picking of the
	* packet at the receiver side.
	*
	* @param t maximum end to end delay allowed. A value of 0
	* implies there is no limit and is the default
	*/
	inline void
	setEnd2EndDelay(microtimeout_t t)
	{ end2EndDelay = t; }

	inline microtimeout_t
	getDefaultEnd2EndDelay() const
	{ return defaultEnd2EndDelay; }

	inline microtimeout_t
	getEnd2EndDelay() const
	{ return end2EndDelay; }

	/**
	* Specify the fraction of the total control bandwith to be
	* dedicated to senders reports.
	*
	* @param fraction fraction of bandwidth, must be between 0 an 1.
	*
	* This method sets the fraction of the global control
	* bandwidth that will be dedicated to senders reports. Of
	* course, <code>1 - fraction</code> will be dedicated to
	* receivers reports.
	*
	* @see setControlBandwidth
	*/
	inline void
	setSendersControlFraction(float fraction)
	{ sendControlBwFract = fraction; recvControlBwFract = 1 - fraction;}

	/**
	* Manually set the minimum interval for sending RTP compound
	* packets
	*
	* @param interval minimum interval between RTCP packets, in
	* microseconds.
	*
	* @see computeRTCPInterval()
	**/
	void
	setMinRTCPInterval(microtimeout_t interval)
	{ rtcpMinInterval = interval; }

	/**
	* Get the total number of RTCP packets sent until now
	**/
	inline uint32
	getSendRTCPPacketCount() const
	{ return ctrlSendCount; }

	protected:
	QueueRTCPManager(uint32 size = RTPDataQueue::defaultMembersHashSize,
	RTPApplication& app = defaultApplication());

	QueueRTCPManager(uint32 ssrc,
	uint32 size = RTPDataQueue::defaultMembersHashSize,
	RTPApplication& app = defaultApplication());

	virtual
	~QueueRTCPManager();

	const RTPApplication&
	getApplication()
	{ return queueApplication; }

	inline void
	setControlBandwidth(float fraction)
	{ controlBwFract = fraction; }

	float
	getControlBandwidth() const
	{ return controlBwFract; }

	/**
	* Build and send RTCP packets following timing rules
	* (including the "timer reconsideration" algorithm).
	**/
	void
	controlTransmissionService();

	/**
	* Process incoming RTCP packets pending in the control
	* reception socket.
	**/
	void
	controlReceptionService();

	/**
	* Appy collision and loop detection and correction algorithm
	* when receiving RTCP packets. Follows section 8.2 in
	* draft-ietf-avp-rtp-new.
	*
	* @param sourceLink link to the source object.
	* @param is_new whether the source has been just recorded.
	* @param na RTCP packet network address.
	* @param tp RTCP packet source transport port.
	*
	* @return whether the packet must not be discarded.
	**/
	bool checkSSRCInRTCPPkt(SyncSourceLink& sourceLink, bool is_new,
	InetAddress& na, tpport_t tp);

	void
	endQueueRTCPManager();

	/**
	* Plug-in for processing (acquire information carried in) an
	* incoming RTCP Sender Report. The default implementation in
	* this class only processes the sender information and the
	* receiver report blocks about the local source.
	*
	* @param source Synchronization source this report comes from.
	* @param SR Sender report structure.
	* @param blocks Number of report blocks in the packet.
	**/
	virtual void
	onGotSR(SyncSource& source, SendReport& SR, uint8 blocks);

	/**
	* Plug-in for processing (acquire information carried in) an
	* incoming RTCP Receiver Report. The default implementation
	* in this class only processes the receiver report blocks
	* about the local source.
	*
	* @param source Synchronization source this report comes from.
	* @param RR Receiver report structure
	* @param blocks Number of report blocks in the packet
	**/
	virtual void
	onGotRR(SyncSource& source, RecvReport& RR, uint8 blocks);

	/**
	* @param source Synchronization source of SDES RTCP packet.
	* @param pkt SDES RTCP packet received.
	**/
	bool
	onGotSDES(SyncSource& source, RTCPPacket& pkt);

	/**
	* Plug-in for handling of SDES chunks.
	*
	* @param source Synchronization source of SDES chunk.
	* @param chunk SDES chunk structure.
	* @param len Length of chunk, in octets.
	*
	* @return whether there was a CNAME.
	**/
	virtual bool
	onGotSDESChunk(SyncSource& source, SDESChunk& chunk, size_t len);

	/**
	* Plug-in for handling of APP (application specific) RTCP
	* packets.
	*
	* @param - Synchronization source of this packet.
	* @param - RTCP APP packet struct.
	* @param - Length of the app data packet, including ssrc.
	* name and app. specific data.
	**/
	inline virtual void
	onGotAPP(SyncSource&, RTCPCompoundHandler::APPPacket&,
	size_t)
	{ return; }

	inline timeval
	getRTCPCheckInterval()
	{ return rtcpCheckInterval; }

	/**
	* Get the number of data packets sent at the time the last SR
	* was generated.
	**/
	uint32
	getLastSendPacketCount() const
	{ return lastSendPacketCount; }

	/**
	* @param n Number of members.
	**/
	inline void
	setPrevMembersNum(uint32 n)
	{ reconsInfo.rtcpPMembers = n; }

	inline uint32
	getPrevMembersCount() const
	{ return reconsInfo.rtcpPMembers; }

	/**
	* This method is used to send an RTCP BYE packet. An RTCP
	* BYE packet is sent when one of the the following
	* circumstances occur:
	* - when leaving the session
	* - when we have detected that another synchronization source
	* in the same session is using the same SSRC identifier as
	* us.
	*
	* Try to post a BYE message. It will send a BYE packet as
	* long as at least one RTP or RTCP packet has been sent
	* before. If the number of members in the session is more
	* than 50, the algorithm described in section 6.3.7 of
	* RFC 3550 is applied in order to avoid a flood
	* of BYE messages.
	*
	* @param reason reason to specify in the BYE packet.
	**/
	size_t
	dispatchBYE(const std::string& reason);

	size_t
	sendControlToDestinations(unsigned char* buffer, size_t len);

	private:
	QueueRTCPManager(const QueueRTCPManager &o);

	QueueRTCPManager&
	operator=(const QueueRTCPManager &o);

	/**
	* Posting of RTCP messages.
	*
	* @return std::size_t number of octets sent
	*/
	size_t
	dispatchControlPacket();

	/**
	* For picking up incoming RTCP packets if they are waiting. A
	* timeout for the maximum interval since the last RTCP packet
	* had been received is also returned. This is checked every
	* rtcpCheckInterval seconds.
	*
	* This method decomposes all incoming RTCP compound packets
	* pending in the control socket and processes each RTCP
	* packet.
	*
	**/
	void
	takeInControlPacket();

	/**
	* Computes the interval for sending RTCP compound packets,
	* based on the average size of RTCP packets sent and
	* received, and the current estimated number of participants
	* in the session.
	*
	* @note This currently follows the rules in section 6 of
	* RFC 3550
	* @todo make it more flexible as recommended in the draft. For now,
	* we have setMinRTCPInterval.
	*
	* @return interval for sending RTCP compound packets
	**/
	virtual timeval
	computeRTCPInterval();

	/**
	* Choose which should be the type of the next SDES item
	* sent. This method is called when packing SDES chunks in a
	* new RTCP packet.
	*
	* @return type of the next SDES item to be sent
	**/
	virtual SDESItemType
	scheduleSDESItem();

	/**
	* Plug-in for SSRC collision handling.
	*
	* @param - previously identified source.
	**/
	inline virtual void
	onSSRCCollision(const SyncSource&)
	{ }

	/**
	* Virtual reimplemented from RTPDataQueue
	**/
	virtual bool
	end2EndDelayed(IncomingRTPPktLink& p);

	/**
	* Plug-in for processing of SR/RR RTCP packet
	* profile-specific extensions (third part of SR reports or
	* second part of RR reports).
	*
	* @param - Content of the profile extension.
	* @param - Length of the extension, in octets.
	**/
	inline virtual void
	onGotRRSRExtension(unsigned char*, size_t)
	{ return; }

	/**
	* A plugin point for goodbye message. Called when a BYE RTCP
	* packet has been received from a valid synchronization
	* source.
	*
	* @param - synchronization source from what a BYE RTCP
	* packet has been just received.
	* @param - reason string the source has provided.
	**/
	inline virtual void
	onGotGoodbye(const SyncSource&, const std::string&)
	{ return; }

	/**
	* Process a BYE packet just received and identified.
	*
	* @param pkt previously identified RTCP BYE packet
	* @param pointer octet number in the RTCP reception buffer
	* where the packet is stored
	* @param len total length of the compount RTCP packet the BYE
	* packet to process is contained
	*
	* @bug if the bye packet contains several SSRCs,
	* eventSourceLeaving is only called for the last one
	**/
	bool
	getBYE(RTCPPacket &pkt, size_t &pointer, size_t len);

	/**
	* @return number of Report Blocks packed
	**/
	uint8
	packReportBlocks(RRBlock* blocks, uint16& len, uint16& available);

	/**
	* Builds an SDES RTCP packet. Each chunk is built following
	* appendix A.4 in draft-ietf-avt-rtp-new.
	*
	* @param len provisionary length of the RTCP compound packet
	*
	* @return
	**/
	void
	packSDES(uint16& len);

	/**
	* This must be called in order to update the average RTCP compound
	* packet size estimation when:
	*
	* a compoung RTCP packet is received (6.3.3).
	*
	* a compound RTCP packet is transmitted (6.3.6).
	*
	* @param len length in octets of the compound RTCP packet
	* just received/transmitted.
	**/
	void
	updateAvgRTCPSize(size_t len);

	/**
	* Apply reverse reconsideration adjustment to timing
	* parameters when receiving BYE packets and not waiting to
	* send a BYE.
	**/
	void
	reverseReconsideration();

	bool
	timerReconsideration();

	/**
	* Purge sources that do not seem active any more.
	*
	* @note MUST be perform at least every RTCP transmission
	* interval
	* @todo implement it. It may be dangerous and anyway should
	* be optional.
	**/
	void
	expireSSRCs();

	/**
	* To be executed when whe are leaving the session.
	**/
	void
	getOnlyBye();

	/**
	* Set item value from a string without null termination (as
	* it is transported in RTCP packets).
	**/
	void
	setSDESItem(Participant* part, SDESItemType type,
	const char* const value, size_t len);

	/**
	* Set PRIV item previx value from a string without null
	* termination (as it is transported in RTCP packets).
	**/
	void
	setPRIVPrefix(Participant* part, const char* const value, size_t len);

	/**
	* For certain control calculations in RTCP, the size of the
	* underlying network and transport protocols is needed. This
	* method provides the size of the network level header for
	* the default case of IP (20 octets). In case other protocol
	* with different header size is used, this method should be
	* redefined in a new specialized class.
	*
	* @return size of the headers of the network level. IP (20) by
	* default.
	**/
	inline virtual uint16
	networkHeaderSize()
	{ return 20; }

	/**
	* For certain control calculations in RTCP, the size of the
	* underlying network and transport protocols is needed. This
	* method provides the size of the transport level header for
	* the default case of UDP (8 octets). In case other protocol
	* with different header size is used, this method should be
	* redefined in a new specialized class.
	*
	* return size of the headers of the transport level. UDP (8)
	* by default
	**/
	inline virtual uint16
	transportHeaderSize()
	{ return 8; }

	SDESItemType
	nextSDESType(SDESItemType t);

	virtual size_t
	sendControl(const unsigned char* const buffer, size_t len) = 0;

	virtual size_t
	recvControl(unsigned char* buffer, size_t len,
	InetHostAddress& na, tpport_t& tp) = 0;

	virtual bool
	isPendingControl(microtimeout_t timeout) = 0;

	// whether the RTCP service is active
	volatile bool controlServiceActive;
	float controlBwFract, sendControlBwFract, recvControlBwFract;
	// number of RTCP packets sent since the beginning
	uint32 ctrlSendCount;

	// Network + transport headers size, typically size of IP +
	// UDP headers
	uint16 lowerHeadersSize;

	SDESItemType nextScheduledSDESItem;
	static const SDESItemType firstSchedulable;
	static const SDESItemType lastSchedulable;

	// state for rtcp timing. Its meaning is defined in
	// draft-ietf-avt-rtp-new, 6.3.

	// Parameters for timer reconsideration algorithm
	struct {
	timeval rtcpTp, rtcpTc, rtcpTn;
	uint32 rtcpPMembers;
	} reconsInfo;
	bool rtcpWeSent;
	uint16 rtcpAvgSize;
	bool rtcpInitial;
	// last time we checked if there were incoming RTCP packets
	timeval rtcpLastCheck;
	// interval to check if there are incoming RTCP packets
	timeval rtcpCheckInterval;
	// next time to check if there are incoming RTCP packets
	timeval rtcpNextCheck;

	// number of RTP data packets sent at the time of the last
	// RTCP packet transmission.
	uint32 lastSendPacketCount;

	// minimum interval for transmission of RTCP packets. The
	// result of computeRTCPInterval will always be >= (times a
	// random number between 0.5 and 1.5).
	microtimeout_t rtcpMinInterval;

	microtimeout_t leavingDelay;
	static const microtimeout_t defaultEnd2EndDelay;
	// Maximum delay allowed between packet timestamping and
	// packet availability for the application.
	microtimeout_t end2EndDelay;
	// Application this queue is bound to.
	RTPApplication& queueApplication;

	// an empty RTPData
	static const uint16 TIMEOUT_MULTIPLIER;
	static const double RECONSIDERATION_COMPENSATION;
	};

	/**
	* This class, an RTP/RTCP queue, adds audio/video profile (AVP)
	* specific methods to the generic RTCP service queue
	* (QueueRTCPManager).
	*
	* @author Federico Montesino Pouzols <fedemp@altern.org>
	**/
	class AVPQueue : public QueueRTCPManager
	{
	public:
	/**
	* Specify the bandwith available for control (RTCP) packets.
	* This method sets the global control bandwidth for both
	* sender and receiver reports. As recommended in RFC 1890,
	* 1/4 of the total control bandwidth is dedicated to senders,
	* whereas 3/4 are dedicated to receivers.
	*
	* @param fraction fraction of the session bandwidth, between
	* 0 and 1
	*
	* @note If this method is not called, it is assumed that the
	* control bandwidth is equal to 5% of the session
	* bandwidth. Note also that the RFC RECOMMENDS the 5%.
	*
	**/
	inline void
	setControlBandwidth(float fraction)
	{ QueueRTCPManager::setControlBandwidth(fraction); }

	float
	getControlBandwidth() const
	{ return QueueRTCPManager::getControlBandwidth(); }

	protected:
	AVPQueue(uint32 size = RTPDataQueue::defaultMembersHashSize,
	RTPApplication& app = defaultApplication()) :
	QueueRTCPManager(size,app)
	{ }

	/**
	* Local SSRC is given instead of computed by the queue.
	**/
	AVPQueue(uint32 ssrc, uint32 size =
	RTPDataQueue::defaultMembersHashSize,
	RTPApplication& app = defaultApplication()) :
	QueueRTCPManager(ssrc,size,app)
	{ }
	inline virtual ~AVPQueue()
	{ }
	};

	/** @}*/ // cqueue

	#ifdef CCXX_NAMESPACES
	}
	#endif

	#endif //CCXX_RTP_CQUEUE_H_

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