rtpsources.h

最新的jrtplib

/*

  This file is a part of JRTPLIB
  Copyright (c) 1999-2007 Jori Liesenborgs

  Contact: [e-mail]

  This library was developed at the "Expertisecentrum Digitale Media"
  (http://www.edm.uhasselt.be), a research center of the Hasselt University
  (http://www.uhasselt.be). The library is based upon work done for 
  my thesis at the School for Knowledge Technology (Belgium/The Netherlands).

  Permission is hereby granted, free of charge, to any person obtaining a
  copy of this software and associated documentation files (the "Software"),
  to deal in the Software without restriction, including without limitation
  the rights to use, copy, modify, merge, publish, distribute, sublicense,
  and/or sell copies of the Software, and to permit persons to whom the
  Software is furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included
  in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  IN THE SOFTWARE.

*/

/**
 * \file rtpsources.h
 */

#ifndef RTPSOURCES_H

#define RTPSOURCES_H

#include "rtpconfig.h"
#include "rtpkeyhashtable.h"
#include "rtcpsdespacket.h"
#include "rtptypes.h"
#include "rtpmemoryobject.h"

#define RTPSOURCES_HASHSIZE							8317

class RTPSources_GetHashIndex
{
public:
	static int GetIndex(const uint32_t &ssrc)				{ return ssrc%RTPSOURCES_HASHSIZE; }
};
	
class RTPNTPTime;
class RTPTransmitter;
class RTCPAPPPacket;
class RTPInternalSourceData;
class RTPRawPacket;
class RTPPacket;
class RTPTime;
class RTPAddress;
class RTPSourceData;

/** Represents a table in which information about the participating sources is kept.
 *  Represents a table in which information about the participating sources is kept. The class has member
 *  functions to process RTP and RTCP data and to iterate over the participants. Note that a NULL address 
 *  is used to identify packets from our own session. The class also provides some overridable functions 
 *  which can be used to catch certain events (new SSRC, SSRC collision, ...).
 */
class RTPSources : public RTPMemoryObject
{
public:
	/** Type of probation to use for new sources. */
	enum ProbationType 
	{ 
			NoProbation, 		/**< Don't use the probation algorithm; accept RTP packets immediately. */
			ProbationDiscard, 	/**< Discard incoming RTP packets originating from a source that's on probation. */
			ProbationStore 		/**< Store incoming RTP packet from a source that's on probation for later retrieval. */
	};
	
	/** In the constructor you can select the probation type you'd like to use and also a memory manager. */
	RTPSources(ProbationType = ProbationStore,RTPMemoryManager *mgr = 0);
	virtual ~RTPSources();

	/** Clears the source table. */
	void Clear();
#ifdef RTP_SUPPORT_PROBATION
	/** Changes the current probation type. */
	void SetProbationType(ProbationType probtype)							{ probationtype = probtype; }
#endif // RTP_SUPPORT_PROBATION

	/** Creates an entry for our own SSRC identifier. */
	int CreateOwnSSRC(uint32_t ssrc);

	/** Deletes the entry for our own SSRC identifier. */
	int DeleteOwnSSRC();

	/** This function should be called if our own session has sent an RTP packet. 
	 *  This function should be called if our own session has sent an RTP packet.
	 *  For our own SSRC entry, the sender flag is updated based upon outgoing packets instead of incoming packets.
	 */
	void SentRTPPacket();

	/** Processes a raw packet \c rawpack.
	 *  Processes a raw packet \c rawpack. The instance \c trans will be used to check if this
	 *  packet is one of our own packets. The flag \c acceptownpackets indicates whether own packets should be 
	 *  accepted or ignored.
	 */
	int ProcessRawPacket(RTPRawPacket *rawpack,RTPTransmitter *trans,bool acceptownpackets);

	/** Processes a raw packet \c rawpack.
	 *  Processes a raw packet \c rawpack. Every transmitter in the array \c trans of length \c numtrans
	 *  is used to check if the packet is from our own session. The flag \c acceptownpackets indicates
	 *  whether own packets should be accepted or ignored.
	 */
	int ProcessRawPacket(RTPRawPacket *rawpack,RTPTransmitter *trans[],int numtrans,bool acceptownpackets);

	/** Processes an RTPPacket instance \c rtppack which was received at time \c receivetime and 
	 *  which originated from \c senderaddres.
	 *  Processes an RTPPacket instance \c rtppack which was received at time \c receivetime and 
	 *  which originated from \c senderaddres. The \c senderaddress parameter must be NULL if
	 *  the packet was sent by the local participant. The flag \c stored indicates whether the packet 
	 *  was stored in the table or not.  If so, the \c rtppack instance may not be deleted.
	 */
	int ProcessRTPPacket(RTPPacket *rtppack,const RTPTime &receivetime,const RTPAddress *senderaddress,bool *stored);

	/** Processes the RTCP compound packet \c rtcpcomppack which was received at time \c receivetime from \c senderaddress.
	 *  Processes the RTCP compound packet \c rtcpcomppack which was received at time \c receivetime from \c senderaddress.
	 *  The \c senderaddress parameter must be NULL if the packet was sent by the local participant.
	 */
	int ProcessRTCPCompoundPacket(RTCPCompoundPacket *rtcpcomppack,const RTPTime &receivetime,
	                              const RTPAddress *senderaddress);
	
	/** Process the sender information of SSRC \c ssrc into the source table. 
	 *  Process the sender information of SSRC \c ssrc into the source table. The information was received
	 *  at time \c receivetime from address \c senderaddress. The \c senderaddress} parameter must be NULL 
	 *  if the packet was sent by the local participant.
	 */
	int ProcessRTCPSenderInfo(uint32_t ssrc,const RTPNTPTime &ntptime,uint32_t rtptime,
	                          uint32_t packetcount,uint32_t octetcount,const RTPTime &receivetime,
				  const RTPAddress *senderaddress);

    /** Processes the report block information which was sent by participant \c ssrc into the source table.
	 *  Processes the report block information which was sent by participant \c ssrc into the source table.
	 *  The information was received at time \c receivetime from address \c senderaddress The \c senderaddress
	 *  parameter must be NULL if the packet was sent by the local participant.
	 */
	int ProcessRTCPReportBlock(uint32_t ssrc,uint8_t fractionlost,int32_t lostpackets,
	                           uint32_t exthighseqnr,uint32_t jitter,uint32_t lsr,
	                           uint32_t dlsr,const RTPTime &receivetime,const RTPAddress *senderaddress);

	/** Processes the non-private SDES item from source \c ssrc into the source table. 
	 *  Processes the non-private SDES item from source \c ssrc into the source table. The information was
	 *  received at time \c receivetime from address \c senderaddress. The \c senderaddress parameter must
	 *  be NULL if the packet was sent by the local participant.
	 */
	int ProcessSDESNormalItem(uint32_t ssrc,RTCPSDESPacket::ItemType t,size_t itemlength,
	                          const void *itemdata,const RTPTime &receivetime,const RTPAddress *senderaddress);
#ifdef RTP_SUPPORT_SDESPRIV
	/** Processes the SDES private item from source \c ssrc into the source table. 
	 *  Processes the SDES private item from source \c ssrc into the source table. The information was 
	 *  received at time \c receivetime from address \c senderaddress. The \c senderaddress 
	 *  parameter must be NULL if the packet was sent by the local participant.
	 */
	int ProcessSDESPrivateItem(uint32_t ssrc,size_t prefixlen,const void *prefixdata,
	                           size_t valuelen,const void *valuedata,const RTPTime &receivetime,
	                           const RTPAddress *senderaddress);
#endif //RTP_SUPPORT_SDESPRIV
	/** Processes the BYE message for SSRC \c ssrc. 
	 *  Processes the BYE message for SSRC \c ssrc. The information was received at time \c receivetime from
	 *  address \c senderaddress. The \c senderaddress parameter must be NULL if the packet was sent by the
	 *  local participant.
	 */
	int ProcessBYE(uint32_t ssrc,size_t reasonlength,const void *reasondata,const RTPTime &receivetime,
	               const RTPAddress *senderaddress);

	/** If we heard from source \c ssrc, but no actual data was added to the source table (for example, if
	 *  no report block was meant for us), this function can e used to indicate that something was received from
	 *  this source. 
	 *  If we heard from source \c ssrc, but no actual data was added to the source table (for example, if