iqueue.h
Go to the documentation of this file.
// 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.
//
#ifndef CCXX_RTP_IQUEUE_H_
#define CCXX_RTP_IQUEUE_H_
#include <ccrtp/queuebase.h>
#include <ccrtp/CryptoContext.h>
#include <list>
NAMESPACE_COMMONCPP
class __EXPORT Members
{
public:
inline void
setMembersCount(uint32 n)
{ members = n; }
inline void
increaseMembersCount()
{ members++; }
inline void
decreaseMembersCount()
{ members--; }
inline uint32
getMembersCount() const
{ return members; }
inline void
setSendersCount(uint32 n)
{ activeSenders = n; }
inline void
increaseSendersCount()
{ activeSenders++; }
inline void
decreaseSendersCount()
{ activeSenders--; }
inline uint32
getSendersCount() const
{ return activeSenders; }
protected:
Members() :
members(0),
activeSenders(0)
{ }
inline virtual ~Members()
{ }
private:
uint32 members;
uint32 activeSenders;
};
class __EXPORT SyncSourceHandler
{
public:
inline void*
getLink(const SyncSource& source) const
{ return source.getLink(); }
inline void
setLink(SyncSource& source, void* link)
{ source.setLink(link); }
inline void
setParticipant(SyncSource& source, Participant& p)
{ source.setParticipant(p); }
inline void
setState(SyncSource& source, SyncSource::State ns)
{ source.setState(ns); }
inline void
setSender(SyncSource& source, bool active)
{ source.setSender(active); }
inline void
setDataTransportPort(SyncSource& source, tpport_t p)
{ source.setDataTransportPort(p); }
inline void
setControlTransportPort(SyncSource& source, tpport_t p)
{ source.setControlTransportPort(p); }
inline void
setNetworkAddress(SyncSource& source, InetAddress addr)
{ source.setNetworkAddress(addr); }
protected:
SyncSourceHandler()
{ }
inline virtual ~SyncSourceHandler()
{ }
};
class __EXPORT ParticipantHandler
{
public:
inline void
setSDESItem(Participant* part, SDESItemType item,
const std::string& val)
{ part->setSDESItem(item,val); }
inline void
setPRIVPrefix(Participant* part, const std::string val)
{ part->setPRIVPrefix(val); }
protected:
ParticipantHandler()
{ }
inline virtual ~ParticipantHandler()
{ }
};
class __EXPORT ApplicationHandler
{
public:
inline void
addParticipant(RTPApplication& app, Participant& part)
{ app.addParticipant(part); }
inline void
removeParticipant(RTPApplication& app,
RTPApplication::ParticipantLink* pl)
{ app.removeParticipant(pl); }
protected:
ApplicationHandler()
{ }
inline virtual ~ApplicationHandler()
{ }
};
class __EXPORT ConflictHandler
{
public:
struct ConflictingTransportAddress
{
ConflictingTransportAddress(InetAddress na,
tpport_t dtp, tpport_t ctp);
void setNext(ConflictingTransportAddress* nc)
{ next = nc; }
inline const InetAddress& getNetworkAddress( ) const
{ return networkAddress; }
inline tpport_t getDataTransportPort() const
{ return dataTransportPort; }
inline tpport_t getControlTransportPort() const
{ return controlTransportPort; }
InetAddress networkAddress;
tpport_t dataTransportPort;
tpport_t controlTransportPort;
ConflictingTransportAddress* next;
// arrival time of last data or control packet.
timeval lastPacketTime;
};
ConflictingTransportAddress* searchDataConflict(InetAddress na,
tpport_t dtp);
ConflictingTransportAddress* searchControlConflict(InetAddress na,
tpport_t ctp);
void updateConflict(ConflictingTransportAddress& ca)
{ SysTime::gettimeofday(&(ca.lastPacketTime),NULL); }
void addConflict(const InetAddress& na, tpport_t dtp, tpport_t ctp);
protected:
ConflictHandler()
{ firstConflict = lastConflict = NULL; }
inline virtual ~ConflictHandler()
{ }
ConflictingTransportAddress* firstConflict, * lastConflict;
};
class __EXPORT MembershipBookkeeping :
public SyncSourceHandler,
public ParticipantHandler,
public ApplicationHandler,
public ConflictHandler,
private Members
{
public:
inline size_t getDefaultMembersHashSize()
{ return defaultMembersHashSize; }
protected:
MembershipBookkeeping(uint32 initialSize = defaultMembersHashSize);
inline virtual
~MembershipBookkeeping()
{ endMembers(); }
struct SyncSourceLink;
inline SyncSourceLink* getLink(const SyncSource& source) const
{ return static_cast<SyncSourceLink*>(SyncSourceHandler::getLink(source)); }
inline bool isMine(const SyncSource& source) const
{ return getLink(source)->getMembership() == this; }
struct IncomingRTPPktLink
{
IncomingRTPPktLink(IncomingRTPPkt* pkt, SyncSourceLink* sLink,
struct timeval& recv_ts,
uint32 shifted_ts,
IncomingRTPPktLink* sp,
IncomingRTPPktLink* sn,
IncomingRTPPktLink* p,
IncomingRTPPktLink* n) :
packet(pkt),
sourceLink(sLink),
prev(p), next(n),
srcPrev(sp), srcNext(sn),
receptionTime(recv_ts),
shiftedTimestamp(shifted_ts)
{ }
~IncomingRTPPktLink()
{ }
inline SyncSourceLink* getSourceLink() const
{ return sourceLink; }
inline void setSourceLink(SyncSourceLink* src)
{ sourceLink = src; }
inline IncomingRTPPktLink* getNext() const
{ return next; }
inline void setNext(IncomingRTPPktLink* nl)
{ next = nl; }
inline IncomingRTPPktLink* getPrev() const
{ return prev; }
inline void setPrev(IncomingRTPPktLink* pl)
{ prev = pl; }
inline IncomingRTPPktLink* getSrcNext() const
{ return srcNext; }
inline void setSrcNext(IncomingRTPPktLink* sn)
{ srcNext = sn; }
inline IncomingRTPPktLink* getSrcPrev() const
{ return srcPrev; }
inline void setSrcPrev(IncomingRTPPktLink* sp)
{ srcPrev = sp; }
inline IncomingRTPPkt* getPacket() const
{ return packet; }
inline void setPacket(IncomingRTPPkt* pkt)
{ packet = pkt; }
inline void setRecvTime(const timeval &t)
{ receptionTime = t; }
inline timeval getRecvTime() const
{ return receptionTime; }
inline uint32 getTimestamp() const
{ return shiftedTimestamp; }
inline void setTimestamp(uint32 ts)
{ shiftedTimestamp = ts;}
// the packet this link refers to.
IncomingRTPPkt* packet;
// the synchronization source this packet comes from.
SyncSourceLink* sourceLink;
// global incoming packet queue links.
IncomingRTPPktLink* prev, * next;
// source specific incoming packet queue links.
IncomingRTPPktLink* srcPrev, * srcNext;
// time this packet was received at
struct timeval receptionTime;
// timestamp of the packet in host order and after
// substracting the initial timestamp for its source
// (it is an increment from the initial timestamp).
uint32 shiftedTimestamp;
};
struct SyncSourceLink
{
// 2^16
static const uint32 SEQNUMMOD;
SyncSourceLink(MembershipBookkeeping* m,
SyncSource* s,
IncomingRTPPktLink* fp = NULL,
IncomingRTPPktLink* lp = NULL,
SyncSourceLink* ps = NULL,
SyncSourceLink* ns = NULL,
SyncSourceLink* ncollis = NULL) :
membership(m), source(s), first(fp), last(lp),
prev(ps), next(ns), nextCollis(ncollis),
prevConflict(NULL)
{ m->setLink(*s,this); // record that the source is associated
initStats(); // to this link.
}
~SyncSourceLink();
inline MembershipBookkeeping* getMembership()
{ return membership; }
inline SyncSource* getSource() { return source; }
inline IncomingRTPPktLink* getFirst()
{ return first; }
inline void setFirst(IncomingRTPPktLink* fp)
{ first = fp; }
inline IncomingRTPPktLink* getLast()
{ return last; }
inline void setLast(IncomingRTPPktLink* lp)
{ last = lp; }
inline SyncSourceLink* getPrev()
{ return prev; }
inline void setPrev(SyncSourceLink* ps)
{ prev = ps; }
inline SyncSourceLink* getNext()
{ return next; }
inline void setNext(SyncSourceLink *ns)
{ next = ns; }
inline SyncSourceLink* getNextCollis()
{ return nextCollis; }
inline void setNextCollis(SyncSourceLink* ns)
{ nextCollis = ns; }
inline ConflictingTransportAddress* getPrevConflict() const
{ return prevConflict; }
void setPrevConflict(InetAddress& addr, tpport_t dataPort,
tpport_t controlPort);
unsigned char* getSenderInfo()
{ return senderInfo; }
void setSenderInfo(unsigned char* si);
unsigned char* getReceiverInfo()
{ return receiverInfo; }
void setReceiverInfo(unsigned char* ri);
inline timeval getLastPacketTime() const
{ return lastPacketTime; }
inline timeval getLastRTCPPacketTime() const
{ return lastRTCPPacketTime; }
inline timeval getLastRTCPSRTime() const
{ return lastRTCPSRTime; }
inline uint32 getObservedPacketCount() const
{ return obsPacketCount; }
inline void incObservedPacketCount()
{ obsPacketCount++; }
inline uint32 getObservedOctetCount() const
{ return obsOctetCount; }
inline void incObservedOctetCount(uint32 n)
{ obsOctetCount += n; }
uint16
getMaxSeqNum() const
{ return maxSeqNum; }
void
setMaxSeqNum(uint16 max)
{ maxSeqNum = max; }
inline uint32
getExtendedMaxSeqNum() const
{ return extendedMaxSeqNum; }
inline void
setExtendedMaxSeqNum(uint32 seq)
{ extendedMaxSeqNum = seq; }
inline uint32 getCumulativePacketLost() const
{ return cumulativePacketLost; }
inline void setCumulativePacketLost(uint32 pl)
{ cumulativePacketLost = pl; }
inline uint8 getFractionLost() const
{ return fractionLost; }
inline void setFractionLost(uint8 fl)
{ fractionLost = fl; }
inline uint32 getLastPacketTransitTime()
{ return lastPacketTransitTime; }
inline void setLastPacketTransitTime(uint32 time)
{ lastPacketTransitTime = time; }
inline float getJitter() const
{ return jitter; }
inline void setJitter(float j)
{ jitter = j; }
inline uint32 getInitialDataTimestamp() const
{ return initialDataTimestamp; }
inline void setInitialDataTimestamp(uint32 ts)
{ initialDataTimestamp = ts; }
inline timeval getInitialDataTime() const
{ return initialDataTime; }
inline void setInitialDataTime(timeval it)
{ initialDataTime = it; }
bool getGoodbye()
{
if(!flag)
return false;
flag = false;
return true;
}
bool getHello() {
if(flag)
return false;
flag = true;
return true;
}
inline uint32 getBadSeqNum() const
{ return badSeqNum; }
inline void setBadSeqNum(uint32 seq)
{ badSeqNum = seq; }
uint8 getProbation() const
{ return probation; }
inline void setProbation(uint8 p)
{ probation = p; }
inline void decProbation()
{ --probation; }
bool isValid() const
{ return 0 == probation; }
inline uint16 getBaseSeqNum() const
{ return baseSeqNum; }
inline void setBaseSeqNum(uint16 seqnum)
{ baseSeqNum = seqnum; }
inline uint32 getSeqNumAccum() const
{ return seqNumAccum; }
inline void incSeqNumAccum()
{ seqNumAccum += SEQNUMMOD; }
inline void initSequence(uint16 seqnum)
{ maxSeqNum = seqNumAccum = seqnum; }
void recordInsertion(const IncomingRTPPktLink& pl);
void initStats();
void computeStats();
MembershipBookkeeping* membership;
// The source this link object refers to.
SyncSource* source;
// first/last packets from this source in the queue.
IncomingRTPPktLink* first, * last;
// Links for synchronization sources located before
// and after this one in the list of sources.
SyncSourceLink* prev, * next;
// Prev and next inside the hash table collision list.
SyncSourceLink* nextCollis;
ConflictingTransportAddress* prevConflict;
unsigned char* senderInfo;
unsigned char* receiverInfo;
// time the last RTP packet from this source was
// received at.
timeval lastPacketTime;
// time the last RTCP packet was received.
timeval lastRTCPPacketTime;
// time the lasrt RTCP SR was received. Required for
// DLSR computation.
timeval lastRTCPSRTime;
// for outgoing RR reports.
// number of packets received from this source.
uint32 obsPacketCount;
// number of octets received from this source.
uint32 obsOctetCount;
// the higher sequence number seen from this source
uint16 maxSeqNum;
uint32 extendedMaxSeqNum;
uint32 cumulativePacketLost;
uint8 fractionLost;
// for interarrivel jitter computation
uint32 lastPacketTransitTime;
// interarrival jitter of packets from this source.
float jitter;
uint32 initialDataTimestamp;
timeval initialDataTime;
// this flag assures we only call one gotHello and one
// gotGoodbye for this src.
bool flag;
// for source validation:
uint32 badSeqNum;
uint8 probation; // packets in sequence before valid.
uint16 baseSeqNum;
uint32 expectedPrior;
uint32 receivedPrior;
uint32 seqNumAccum;
};
bool
isRegistered(uint32 ssrc);
SyncSourceLink*
getSourceBySSRC(uint32 ssrc, bool& created);
bool
BYESource(uint32 ssrc);
bool
removeSource(uint32 ssrc);
inline SyncSourceLink* getFirst()
{ return first; }
inline SyncSourceLink* getLast()
{ return last; }
inline uint32
getMembersCount()
{ return Members::getMembersCount(); }
inline void
setMembersCount(uint32 n)
{ Members::setMembersCount(n); }
inline uint32
getSendersCount()
{ return Members::getSendersCount(); }
static const size_t defaultMembersHashSize;
static const uint32 SEQNUMMOD;
private:
MembershipBookkeeping(const MembershipBookkeeping &o);
MembershipBookkeeping&
operator=(const MembershipBookkeeping &o);
void
endMembers();
// Hash table with sources of RTP and RTCP packets
uint32 sourceBucketsNum;
SyncSourceLink** sourceLinks;
// List of sources, ordered from older to newer
SyncSourceLink* first, * last;
};
class __EXPORT IncomingDataQueue: public IncomingDataQueueBase,
protected MembershipBookkeeping
{
public:
class SyncSourcesIterator
{
public:
typedef std::forward_iterator_tag iterator_category;
typedef SyncSource value_type;
typedef std::ptrdiff_t difference_type;
typedef const SyncSource* pointer;
typedef const SyncSource& reference;
SyncSourcesIterator(SyncSourceLink* l = NULL) :
link(l)
{ }
SyncSourcesIterator(const SyncSourcesIterator& si) :
link(si.link)
{ }
reference operator*() const
{ return *(link->getSource()); }
pointer operator->() const
{ return link->getSource(); }
SyncSourcesIterator& operator++() {
link = link->getNext();
return *this;
}
SyncSourcesIterator operator++(int) {
SyncSourcesIterator result(*this);
++(*this);
return result;
}
friend bool operator==(const SyncSourcesIterator& l,
const SyncSourcesIterator& r)
{ return l.link == r.link; }
friend bool operator!=(const SyncSourcesIterator& l,
const SyncSourcesIterator& r)
{ return l.link != r.link; }
private:
SyncSourceLink *link;
};
SyncSourcesIterator begin()
{ return SyncSourcesIterator(MembershipBookkeeping::getFirst()); }
SyncSourcesIterator end()
{ return SyncSourcesIterator(NULL); }
const AppDataUnit*
getData(uint32 stamp, const SyncSource* src = NULL);
bool
isWaiting(const SyncSource* src = NULL) const;
uint32
getFirstTimestamp(const SyncSource* src = NULL) const;
void
setMinValidPacketSequence(uint8 packets)
{ minValidPacketSequence = packets; }
uint8
getDefaultMinValidPacketSequence() const
{ return defaultMinValidPacketSequence; }
uint8
getMinValidPacketSequence() const
{ return minValidPacketSequence; }
void
setMaxPacketMisorder(uint16 packets)
{ maxPacketMisorder = packets; }
uint16
getDefaultMaxPacketMisorder() const
{ return defaultMaxPacketMisorder; }
uint16
getMaxPacketMisorder() const
{ return maxPacketMisorder; }
void
setMaxPacketDropout(uint16 packets) // default: 3000.
{ maxPacketDropout = packets; }
uint16
getDefaultMaxPacketDropout() const
{ return defaultMaxPacketDropout; }
uint16
getMaxPacketDropout() const
{ return maxPacketDropout; }
// default value for constructors that allow to specify
// members table s\ize
inline static size_t
getDefaultMembersSize()
{ return defaultMembersSize; }
void
setInQueueCryptoContext(CryptoContext* cc);
void
removeInQueueCryptoContext(CryptoContext* cc);
CryptoContext*
getInQueueCryptoContext(uint32 ssrc);
protected:
IncomingDataQueue(uint32 size);
virtual ~IncomingDataQueue()
{ }
bool checkSSRCInIncomingRTPPkt(SyncSourceLink& sourceLink,
bool is_new, InetAddress& na,
tpport_t tp);
void setSourceExpirationPeriod(uint8 intervals)
{ sourceExpirationPeriod = intervals; }
virtual size_t
takeInDataPacket();
void renewLocalSSRC();
IncomingDataQueue::IncomingRTPPktLink*
getWaiting(uint32 timestamp, const SyncSource *src = NULL);
bool
recordReception(SyncSourceLink& srcLink, const IncomingRTPPkt& pkt,
const timeval recvtime);
void
recordExtraction(const IncomingRTPPkt& pkt);
void purgeIncomingQueue();
inline virtual void
onNewSyncSource(const SyncSource&)
{ }
protected:
inline virtual bool
onRTPPacketRecv(IncomingRTPPkt&)
{ return true; }
inline virtual void onExpireRecv(IncomingRTPPkt&)
{ return; }
inline virtual bool
onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode)
{ return false; }
inline virtual bool
end2EndDelayed(IncomingRTPPktLink&)
{ return false; }
bool
insertRecvPacket(IncomingRTPPktLink* packetLink);
virtual size_t
recvData(unsigned char* buffer, size_t length,
InetHostAddress& host, tpport_t& port) = 0;
virtual size_t
getNextDataPacketSize() const = 0;
mutable ThreadLock recvLock;
// reception queue
IncomingRTPPktLink* recvFirst, * recvLast;
// values for packet validation.
static const uint8 defaultMinValidPacketSequence;
static const uint16 defaultMaxPacketMisorder;
static const uint16 defaultMaxPacketDropout;
uint8 minValidPacketSequence;
uint16 maxPacketMisorder;
uint16 maxPacketDropout;
static const size_t defaultMembersSize;
uint8 sourceExpirationPeriod;
mutable Mutex cryptoMutex;
std::list<CryptoContext *> cryptoContexts;
};
// iqueue
END_NAMESPACE
#endif //CCXX_RTP_IQUEUE_H_
MembershipBookkeeping::SyncSourceLink::getMembership
MembershipBookkeeping * getMembership()
Definition: iqueue.h:494
RTPQueueBase::renewLocalSSRC
virtual void renewLocalSSRC()
Definition: queuebase.h:233
MembershipBookkeeping::SyncSourceLink::flag
bool flag
Definition: iqueue.h:785
MembershipBookkeeping::SyncSourceLink::getNext
SyncSourceLink * getNext()
Get the link object for the next RTP source.
Definition: iqueue.h:535
IncomingDataQueue::setMaxPacketDropout
void setMaxPacketDropout(uint16 packets)
It also prevents packets sent after a restart of the source being immediately accepted.
Definition: iqueue.h:1032
MembershipBookkeeping::SyncSourceLink::initSequence
void initSequence(uint16 seqnum)
Start a new sequence of received packets.
Definition: iqueue.h:721
MembershipBookkeeping::SyncSourceLink::prevConflict
ConflictingTransportAddress * prevConflict
Definition: iqueue.h:754
MembershipBookkeeping::SyncSourceLink::badSeqNum
uint32 badSeqNum
Definition: iqueue.h:788
SyncSourceHandler::setControlTransportPort
void setControlTransportPort(SyncSource &source, tpport_t p)
Definition: iqueue.h:159
MembershipBookkeeping::IncomingRTPPktLink::getTimestamp
uint32 getTimestamp() const
Get timestamp of this packet.
Definition: iqueue.h:432
MembershipBookkeeping::SyncSourceLink::setMaxSeqNum
void setMaxSeqNum(uint16 max)
Set the highest valid sequence number recived.
Definition: iqueue.h:613
Members::setMembersCount
void setMembersCount(uint32 n)
Definition: iqueue.h:72
MembershipBookkeeping::IncomingRTPPktLink::setPacket
void setPacket(IncomingRTPPkt *pkt)
Definition: iqueue.h:405
MembershipBookkeeping::SyncSourceLink::getObservedPacketCount
uint32 getObservedPacketCount() const
Get the total number of RTP packets received from this source.
Definition: iqueue.h:585
IncomingDataQueue::getDefaultMembersSize
static size_t getDefaultMembersSize()
Definition: iqueue.h:1046
MembershipBookkeeping::IncomingRTPPktLink::srcPrev
IncomingRTPPktLink * srcPrev
Definition: iqueue.h:445
MembershipBookkeeping::IncomingRTPPktLink::setSrcNext
void setSrcNext(IncomingRTPPktLink *sn)
Definition: iqueue.h:393
IncomingDataQueueBase
Definition: queuebase.h:295
CryptoContext
The implementation for a SRTP cryptographic context.
Definition: CryptoContext.h:83
MembershipBookkeeping::SyncSourceLink::getFractionLost
uint8 getFractionLost() const
Definition: iqueue.h:630
MembershipBookkeeping::SyncSourceLink::seqNumAccum
uint32 seqNumAccum
Definition: iqueue.h:793
MembershipBookkeeping::SyncSourceLink::lastRTCPPacketTime
timeval lastRTCPPacketTime
Definition: iqueue.h:761
IncomingDataQueue::~IncomingDataQueue
virtual ~IncomingDataQueue()
Definition: iqueue.h:1089
SyncSourceHandler::setLink
void setLink(SyncSource &source, void *link)
Definition: iqueue.h:139
MembershipBookkeeping::IncomingRTPPktLink::setPrev
void setPrev(IncomingRTPPktLink *pl)
Definition: iqueue.h:387
MembershipBookkeeping::SyncSourceLink::getLastRTCPSRTime
timeval getLastRTCPSRTime() const
Definition: iqueue.h:578
MembershipBookkeeping::SyncSourceLink::setBaseSeqNum
void setBaseSeqNum(uint16 seqnum)
Definition: iqueue.h:709
MembershipBookkeeping::IncomingRTPPktLink::setSrcPrev
void setSrcPrev(IncomingRTPPktLink *sp)
Definition: iqueue.h:399
MembershipBookkeeping::getLink
SyncSourceLink * getLink(const SyncSource &source) const
Definition: iqueue.h:337
SyncSourceHandler::setState
void setState(SyncSource &source, SyncSource::State ns)
Definition: iqueue.h:147
MembershipBookkeeping::SyncSourceLink::decProbation
void decProbation()
Definition: iqueue.h:700
IncomingDataQueue::setSourceExpirationPeriod
void setSourceExpirationPeriod(uint8 intervals)
Set the number of RTCP intervals that the stack will wait to change the state of a source from stateA...
Definition: iqueue.h:1123
SyncSourceHandler::setSender
void setSender(SyncSource &source, bool active)
Definition: iqueue.h:151
MembershipBookkeeping::SyncSourceLink::SEQNUMMOD
static const uint32 SEQNUMMOD
Definition: iqueue.h:473
MembershipBookkeeping::SyncSourceLink::getLastPacketTime
timeval getLastPacketTime() const
Definition: iqueue.h:572
MembershipBookkeeping::SyncSourceLink::setProbation
void setProbation(uint8 p)
Definition: iqueue.h:697
MembershipBookkeeping::SyncSourceLink::getLast
IncomingRTPPktLink * getLast()
Get last RTP (data) packet in the queue of packets received from this socket.
Definition: iqueue.h:517
MembershipBookkeeping::IncomingRTPPktLink::sourceLink
SyncSourceLink * sourceLink
Definition: iqueue.h:441
MembershipBookkeeping::SyncSourceLink::lastPacketTime
timeval lastPacketTime
Definition: iqueue.h:759
Members::increaseMembersCount
void increaseMembersCount()
Definition: iqueue.h:76
MembershipBookkeeping::SyncSourceLink::setCumulativePacketLost
void setCumulativePacketLost(uint32 pl)
Definition: iqueue.h:627
MembershipBookkeeping::SyncSourceLink::incSeqNumAccum
void incSeqNumAccum()
Definition: iqueue.h:715
MembershipBookkeeping::SyncSourceLink::getSeqNumAccum
uint32 getSeqNumAccum() const
Definition: iqueue.h:712
IncomingDataQueue::SyncSourcesIterator::operator!=
friend bool operator!=(const SyncSourcesIterator &l, const SyncSourcesIterator &r)
Definition: iqueue.h:931
ConflictHandler
To track addresses of sources conflicting with the local one.
Definition: iqueue.h:233
IncomingDataQueue::SyncSourcesIterator::iterator_category
std::forward_iterator_tag iterator_category
Definition: iqueue.h:896
ParticipantHandler::setPRIVPrefix
void setPRIVPrefix(Participant *part, const std::string val)
Definition: iqueue.h:189
MembershipBookkeeping::getDefaultMembersHashSize
size_t getDefaultMembersHashSize()
Definition: iqueue.h:307
IncomingDataQueue::end2EndDelayed
virtual bool end2EndDelayed(IncomingRTPPktLink &)
Definition: iqueue.h:1239
MembershipBookkeeping::SyncSourceLink::getJitter
float getJitter() const
Definition: iqueue.h:642
IncomingDataQueue::getMinValidPacketSequence
uint8 getMinValidPacketSequence() const
Get the minimun number of consecutive packets that must be received from a source before accepting it...
Definition: iqueue.h:1011
IncomingDataQueue::onRTPPacketRecv
virtual bool onRTPPacketRecv(IncomingRTPPkt &)
A virtual function to support parsing of arriving packets to determine if they should be kept in the ...
Definition: iqueue.h:1207
MembershipBookkeeping::IncomingRTPPktLink::setTimestamp
void setTimestamp(uint32 ts)
Definition: iqueue.h:435
SyncSourceHandler::getLink
void * getLink(const SyncSource &source) const
This requires SyncSource - SyncSourceHandler friendship.
Definition: iqueue.h:135
MembershipBookkeeping::SyncSourceLink::probation
uint8 probation
Definition: iqueue.h:789
MembershipBookkeeping::SyncSourceLink::setPrev
void setPrev(SyncSourceLink *ps)
Definition: iqueue.h:529
Members::decreaseSendersCount
void decreaseSendersCount()
Definition: iqueue.h:96
MembershipBookkeeping::SyncSourceLink::incObservedPacketCount
void incObservedPacketCount()
Definition: iqueue.h:588
MembershipBookkeeping::IncomingRTPPktLink::setSourceLink
void setSourceLink(SyncSourceLink *src)
Definition: iqueue.h:375
MembershipBookkeeping::IncomingRTPPktLink::getPacket
IncomingRTPPkt * getPacket() const
Definition: iqueue.h:402
IncomingDataQueue::onSRTPPacketError
virtual bool onSRTPPacketError(IncomingRTPPkt &pkt, int32 errorCode)
A hook that gets called if the decoding of an incoming SRTP was erroneous.
Definition: iqueue.h:1235
ConflictHandler::ConflictingTransportAddress::getDataTransportPort
tpport_t getDataTransportPort() const
Definition: iqueue.h:247
Members::Members
Members()
Definition: iqueue.h:104
IncomingDataQueue
Queue for incoming RTP data packets in an RTP session.
Definition: iqueue.h:884
MembershipBookkeeping::SyncSourceLink::receiverInfo
unsigned char * receiverInfo
Definition: iqueue.h:756
ConflictHandler::lastConflict
ConflictingTransportAddress * lastConflict
Definition: iqueue.h:286
IncomingDataQueue::getMaxPacketMisorder
uint16 getMaxPacketMisorder() const
Definition: iqueue.h:1023
Members::increaseSendersCount
void increaseSendersCount()
Definition: iqueue.h:92
MembershipBookkeeping::SyncSourceLink::nextCollis
SyncSourceLink * nextCollis
Definition: iqueue.h:753
MembershipBookkeeping::IncomingRTPPktLink::getSourceLink
SyncSourceLink * getSourceLink() const
Definition: iqueue.h:372
MembershipBookkeeping::IncomingRTPPktLink::getRecvTime
timeval getRecvTime() const
Get the time this packet was received at.
Definition: iqueue.h:421
IncomingDataQueue::getDefaultMaxPacketMisorder
uint16 getDefaultMaxPacketMisorder() const
Definition: iqueue.h:1019
MembershipBookkeeping::SyncSourceLink::membership
MembershipBookkeeping * membership
Definition: iqueue.h:744
IncomingDataQueue::SyncSourcesIterator::operator*
reference operator*() const
Definition: iqueue.h:910
SyncSourceHandler
SyncSource objects modification methods.
Definition: iqueue.h:125
MembershipBookkeeping::SyncSourceLink::lastRTCPSRTime
timeval lastRTCPSRTime
Definition: iqueue.h:764
SyncSource::State
State
Synchronization source states during an RTP session.
Definition: sources.h:227
MembershipBookkeeping::getMembersCount
uint32 getMembersCount()
Definition: iqueue.h:844
ConflictHandler::~ConflictHandler
virtual ~ConflictHandler()
Definition: iqueue.h:283
IncomingDataQueue::maxPacketMisorder
uint16 maxPacketMisorder
Definition: iqueue.h:1286
ConflictHandler::ConflictingTransportAddress::controlTransportPort
tpport_t controlTransportPort
Definition: iqueue.h:255
MembershipBookkeeping::SyncSourceLink::getReceiverInfo
unsigned char * getReceiverInfo()
Definition: iqueue.h:567
MembershipBookkeeping::SyncSourceLink::isValid
bool isValid() const
Definition: iqueue.h:703
MembershipBookkeeping::SyncSourceLink::incObservedOctetCount
void incObservedOctetCount(uint32 n)
Definition: iqueue.h:598
MembershipBookkeeping::SyncSourceLink::getNextCollis
SyncSourceLink * getNextCollis()
Get the link object for the next RTP source in the hash table entry collision list.
Definition: iqueue.h:547
MembershipBookkeeping::SyncSourceLink::source
SyncSource * source
Definition: iqueue.h:746
MembershipBookkeeping::IncomingRTPPktLink::getSrcNext
IncomingRTPPktLink * getSrcNext() const
Definition: iqueue.h:390
MembershipBookkeeping::IncomingRTPPktLink::IncomingRTPPktLink
IncomingRTPPktLink(IncomingRTPPkt *pkt, SyncSourceLink *sLink, struct timeval &recv_ts, uint32 shifted_ts, IncomingRTPPktLink *sp, IncomingRTPPktLink *sn, IncomingRTPPktLink *p, IncomingRTPPktLink *n)
Definition: iqueue.h:354
SyncSource
Synchronization source in an RTP session.
Definition: sources.h:194
MembershipBookkeeping::SyncSourceLink::setJitter
void setJitter(float j)
Definition: iqueue.h:645
MembershipBookkeeping::SyncSourceLink::setExtendedMaxSeqNum
void setExtendedMaxSeqNum(uint32 seq)
Definition: iqueue.h:621
MembershipBookkeeping::SyncSourceLink::getFirst
IncomingRTPPktLink * getFirst()
Get first RTP (data) packet in the queue of packets received from this socket.
Definition: iqueue.h:507
MembershipBookkeeping::SyncSourceLink::getExtendedMaxSeqNum
uint32 getExtendedMaxSeqNum() const
Definition: iqueue.h:617
MembershipBookkeeping::SyncSourceLink::baseSeqNum
uint16 baseSeqNum
Definition: iqueue.h:790
MembershipBookkeeping::SyncSourceLink::receivedPrior
uint32 receivedPrior
Definition: iqueue.h:792
SyncSourceHandler::setParticipant
void setParticipant(SyncSource &source, Participant &p)
Definition: iqueue.h:143
ParticipantHandler
Participant objects modification methods.
Definition: iqueue.h:180
IncomingDataQueue::recvLast
IncomingRTPPktLink * recvLast
Definition: iqueue.h:1280
MembershipBookkeeping::SyncSourceLink::setBadSeqNum
void setBadSeqNum(uint32 seq)
Definition: iqueue.h:691
MembershipBookkeeping::SyncSourceLink::setInitialDataTime
void setInitialDataTime(timeval it)
Definition: iqueue.h:657
IncomingDataQueue::end
SyncSourcesIterator end()
Definition: iqueue.h:942
IncomingDataQueue::SyncSourcesIterator::operator++
SyncSourcesIterator operator++(int)
Definition: iqueue.h:921
MembershipBookkeeping::SyncSourceLink::getProbation
uint8 getProbation() const
Definition: iqueue.h:694
AppDataUnit
Interface (envelope) to data received over RTP packets.
Definition: queuebase.h:69
IncomingDataQueue::getDefaultMaxPacketDropout
uint16 getDefaultMaxPacketDropout() const
Definition: iqueue.h:1036
MembershipBookkeeping::SyncSourceLink::prev
SyncSourceLink * prev
Definition: iqueue.h:751
Members::getSendersCount
uint32 getSendersCount() const
Definition: iqueue.h:100
IncomingDataQueue::SyncSourcesIterator::SyncSourcesIterator
SyncSourcesIterator(SyncSourceLink *l=NULL)
Definition: iqueue.h:902
MembershipBookkeeping::SyncSourceLink::senderInfo
unsigned char * senderInfo
Definition: iqueue.h:755
IncomingDataQueue::SyncSourcesIterator::operator==
friend bool operator==(const SyncSourcesIterator &l, const SyncSourcesIterator &r)
Definition: iqueue.h:927
SyncSourceHandler::setNetworkAddress
void setNetworkAddress(SyncSource &source, InetAddress addr)
Definition: iqueue.h:163
MembershipBookkeeping::SyncSourceLink::getPrev
SyncSourceLink * getPrev()
Get the link object for the previous RTP source.
Definition: iqueue.h:526
MembershipBookkeeping::SyncSourceLink::jitter
float jitter
Definition: iqueue.h:779
MembershipBookkeeping::IncomingRTPPktLink::shiftedTimestamp
uint32 shiftedTimestamp
Definition: iqueue.h:451
CryptoContext.h
MembershipBookkeeping::IncomingRTPPktLink::getSrcPrev
IncomingRTPPktLink * getSrcPrev() const
Definition: iqueue.h:396
MembershipBookkeeping::SyncSourceLink::getObservedOctetCount
uint32 getObservedOctetCount() const
Get the total number of payload octets received from this source.
Definition: iqueue.h:595
IncomingDataQueue::begin
SyncSourcesIterator begin()
Definition: iqueue.h:939
queuebase.h
Base classes for RTP queues.
IncomingDataQueue::defaultMembersSize
static const size_t defaultMembersSize
Definition: iqueue.h:1288
ApplicationHandler::addParticipant
void addParticipant(RTPApplication &app, Participant &part)
Definition: iqueue.h:210
Members::getMembersCount
uint32 getMembersCount() const
Definition: iqueue.h:84
IncomingDataQueue::maxPacketDropout
uint16 maxPacketDropout
Definition: iqueue.h:1287
IncomingDataQueue::getDefaultMinValidPacketSequence
uint8 getDefaultMinValidPacketSequence() const
Definition: iqueue.h:1003
SyncSourceHandler::SyncSourceHandler
SyncSourceHandler()
Definition: iqueue.h:167
MembershipBookkeeping::SyncSourceLink::getHello
bool getHello()
Mark this source as having sent some packet.
Definition: iqueue.h:681
MembershipBookkeeping::SyncSourceLink::getLastRTCPPacketTime
timeval getLastRTCPPacketTime() const
Definition: iqueue.h:575
IncomingDataQueue::minValidPacketSequence
uint8 minValidPacketSequence
Definition: iqueue.h:1285
MembershipBookkeeping::IncomingRTPPktLink::prev
IncomingRTPPktLink * prev
Definition: iqueue.h:443
ConflictHandler::ConflictingTransportAddress::dataTransportPort
tpport_t dataTransportPort
Definition: iqueue.h:254
MembershipBookkeeping::setMembersCount
void setMembersCount(uint32 n)
Definition: iqueue.h:848
ApplicationHandler::removeParticipant
void removeParticipant(RTPApplication &app, RTPApplication::ParticipantLink *pl)
Definition: iqueue.h:214
ApplicationHandler::ApplicationHandler
ApplicationHandler()
Definition: iqueue.h:219
MembershipBookkeeping::SyncSourceLink::getSenderInfo
unsigned char * getSenderInfo()
Definition: iqueue.h:562
MembershipBookkeeping::SyncSourceLink::setLast
void setLast(IncomingRTPPktLink *lp)
Definition: iqueue.h:520
SyncSourceHandler::setDataTransportPort
void setDataTransportPort(SyncSource &source, tpport_t p)
Definition: iqueue.h:155
RTPApplication
An RTP application, holding identifying RTCP SDES item values.
Definition: sources.h:366
MembershipBookkeeping::SEQNUMMOD
static const uint32 SEQNUMMOD
Definition: iqueue.h:856
Members::decreaseMembersCount
void decreaseMembersCount()
Definition: iqueue.h:80
IncomingDataQueue::defaultMinValidPacketSequence
static const uint8 defaultMinValidPacketSequence
Definition: iqueue.h:1282
ConflictHandler::ConflictingTransportAddress::setNext
void setNext(ConflictingTransportAddress *nc)
Definition: iqueue.h:241
MembershipBookkeeping::SyncSourceLink::getPrevConflict
ConflictingTransportAddress * getPrevConflict() const
Definition: iqueue.h:553
IncomingDataQueue::getMaxPacketDropout
uint16 getMaxPacketDropout() const
Definition: iqueue.h:1040
MembershipBookkeeping::SyncSourceLink::setLastPacketTransitTime
void setLastPacketTransitTime(uint32 time)
Definition: iqueue.h:639
MembershipBookkeeping::IncomingRTPPktLink
Incoming RTP data packets control structure within the incoming packet queue class.
Definition: iqueue.h:352
MembershipBookkeeping::SyncSourceLink::getInitialDataTime
timeval getInitialDataTime() const
Definition: iqueue.h:654
MembershipBookkeeping::SyncSourceLink::setNext
void setNext(SyncSourceLink *ns)
Definition: iqueue.h:538
ConflictHandler::ConflictingTransportAddress::getNetworkAddress
const InetAddress & getNetworkAddress() const
Definition: iqueue.h:244
MembershipBookkeeping::SyncSourceLink::getBadSeqNum
uint32 getBadSeqNum() const
Definition: iqueue.h:688
ConflictHandler::ConflictingTransportAddress
Definition: iqueue.h:236
MembershipBookkeeping::SyncSourceLink::obsPacketCount
uint32 obsPacketCount
Definition: iqueue.h:768
IncomingDataQueue::SyncSourcesIterator::difference_type
std::ptrdiff_t difference_type
Definition: iqueue.h:898
MembershipBookkeeping::SyncSourceLink::initialDataTime
timeval initialDataTime
Definition: iqueue.h:781
IncomingRTPPkt
RTP packets received from other participants.
Definition: rtppkt.h:705
MembershipBookkeeping::SyncSourceLink::initialDataTimestamp
uint32 initialDataTimestamp
Definition: iqueue.h:780
ParticipantHandler::ParticipantHandler
ParticipantHandler()
Definition: iqueue.h:193
IncomingDataQueue::SyncSourcesIterator
iterator through the list of synchronizations sources in this session
Definition: iqueue.h:893
ConflictHandler::ConflictHandler
ConflictHandler()
Definition: iqueue.h:280
IncomingDataQueue::recvLock
ThreadLock recvLock
Definition: iqueue.h:1278
ApplicationHandler::~ApplicationHandler
virtual ~ApplicationHandler()
Definition: iqueue.h:222
MembershipBookkeeping::defaultMembersHashSize
static const size_t defaultMembersHashSize
Definition: iqueue.h:855
MembershipBookkeeping::SyncSourceLink::last
IncomingRTPPktLink * last
Definition: iqueue.h:748
MembershipBookkeeping::SyncSourceLink::getLastPacketTransitTime
uint32 getLastPacketTransitTime()
Definition: iqueue.h:636
IncomingDataQueue::cryptoContexts
std::list< CryptoContext * > cryptoContexts
Definition: iqueue.h:1291
MembershipBookkeeping::SyncSourceLink::setFirst
void setFirst(IncomingRTPPktLink *fp)
Definition: iqueue.h:510
IncomingDataQueue::defaultMaxPacketMisorder
static const uint16 defaultMaxPacketMisorder
Definition: iqueue.h:1283
Members::~Members
virtual ~Members()
Definition: iqueue.h:109
MembershipBookkeeping::SyncSourceLink::getGoodbye
bool getGoodbye()
Mark this source as having sent a BYE control packet.
Definition: iqueue.h:667
MembershipBookkeeping::SyncSourceLink::getSource
SyncSource * getSource()
Get the synchronization source object this link objet holds information for.
Definition: iqueue.h:501
ConflictHandler::ConflictingTransportAddress::lastPacketTime
timeval lastPacketTime
Definition: iqueue.h:258
IncomingDataQueue::cryptoMutex
Mutex cryptoMutex
Definition: iqueue.h:1290
ConflictHandler::ConflictingTransportAddress::next
ConflictingTransportAddress * next
Definition: iqueue.h:256
IncomingDataQueue::SyncSourcesIterator::operator++
SyncSourcesIterator & operator++()
Definition: iqueue.h:916
MembershipBookkeeping::IncomingRTPPktLink::setNext
void setNext(IncomingRTPPktLink *nl)
Definition: iqueue.h:381
MembershipBookkeeping::IncomingRTPPktLink::setRecvTime
void setRecvTime(const timeval &t)
Set the time this packet was received at.
Definition: iqueue.h:415
MembershipBookkeeping::IncomingRTPPktLink::getNext
IncomingRTPPktLink * getNext() const
Definition: iqueue.h:378
IncomingDataQueue::SyncSourcesIterator::operator->
pointer operator->() const
Definition: iqueue.h:913
IncomingDataQueue::onExpireRecv
virtual void onExpireRecv(IncomingRTPPkt &)
A hook to filter packets in the receive queue that are being expired.
Definition: iqueue.h:1218
IncomingDataQueue::SyncSourcesIterator::reference
const SyncSource & reference
Definition: iqueue.h:900
MembershipBookkeeping::SyncSourceLink::setNextCollis
void setNextCollis(SyncSourceLink *ns)
Definition: iqueue.h:550
Members
members and senders accounting
Definition: iqueue.h:68
MembershipBookkeeping::SyncSourceLink::extendedMaxSeqNum
uint32 extendedMaxSeqNum
Definition: iqueue.h:773
IncomingDataQueue::onNewSyncSource
virtual void onNewSyncSource(const SyncSource &)
Virtual called when a new synchronization source has joined the session.
Definition: iqueue.h:1186
ConflictHandler::updateConflict
void updateConflict(ConflictingTransportAddress &ca)
Definition: iqueue.h:274
IncomingDataQueue::defaultMaxPacketDropout
static const uint16 defaultMaxPacketDropout
Definition: iqueue.h:1284
MembershipBookkeeping::SyncSourceLink::lastPacketTransitTime
uint32 lastPacketTransitTime
Definition: iqueue.h:777
MembershipBookkeeping::isMine
bool isMine(const SyncSource &source) const
Get whether a synchronization source is recorded in this membership controller.
Definition: iqueue.h:343
IncomingDataQueue::SyncSourcesIterator::SyncSourcesIterator
SyncSourcesIterator(const SyncSourcesIterator &si)
Definition: iqueue.h:906
IncomingDataQueue::sourceExpirationPeriod
uint8 sourceExpirationPeriod
Definition: iqueue.h:1289
IncomingDataQueue::setMinValidPacketSequence
void setMinValidPacketSequence(uint8 packets)
When receiving packets from a new source, it may be convenient to reject a first few packets before w...
Definition: iqueue.h:999
ParticipantHandler::setSDESItem
void setSDESItem(Participant *part, SDESItemType item, const std::string &val)
Definition: iqueue.h:184
MembershipBookkeeping::IncomingRTPPktLink::~IncomingRTPPktLink
~IncomingRTPPktLink()
Definition: iqueue.h:369
SyncSourceHandler::~SyncSourceHandler
virtual ~SyncSourceHandler()
Definition: iqueue.h:170
MembershipBookkeeping::SyncSourceLink::getInitialDataTimestamp
uint32 getInitialDataTimestamp() const
Definition: iqueue.h:648
IncomingDataQueue::SyncSourcesIterator::pointer
const SyncSource * pointer
Definition: iqueue.h:899
ApplicationHandler
Application objects modification methods.
Definition: iqueue.h:206
MembershipBookkeeping::SyncSourceLink::cumulativePacketLost
uint32 cumulativePacketLost
Definition: iqueue.h:774
MembershipBookkeeping::getLast
SyncSourceLink * getLast()
Definition: iqueue.h:840
MembershipBookkeeping::SyncSourceLink::fractionLost
uint8 fractionLost
Definition: iqueue.h:775
ConflictHandler::ConflictingTransportAddress::networkAddress
InetAddress networkAddress
Definition: iqueue.h:253
MembershipBookkeeping::IncomingRTPPktLink::packet
IncomingRTPPkt * packet
Definition: iqueue.h:439
IncomingDataQueue::SyncSourcesIterator::value_type
SyncSource value_type
Definition: iqueue.h:897
MembershipBookkeeping::SyncSourceLink::getMaxSeqNum
uint16 getMaxSeqNum() const
Get the highest valid sequence number received.
Definition: iqueue.h:605
Members::setSendersCount
void setSendersCount(uint32 n)
Definition: iqueue.h:88
MembershipBookkeeping::SyncSourceLink::setInitialDataTimestamp
void setInitialDataTimestamp(uint32 ts)
Definition: iqueue.h:651
MembershipBookkeeping::getSendersCount
uint32 getSendersCount()
Definition: iqueue.h:852
MembershipBookkeeping::SyncSourceLink::setFractionLost
void setFractionLost(uint8 fl)
Definition: iqueue.h:633
Participant
A class of objects representing remote participants (RTP applications) in a multimedia session...
Definition: sources.h:126
MembershipBookkeeping::SyncSourceLink::maxSeqNum
uint16 maxSeqNum
Definition: iqueue.h:772
MembershipBookkeeping::SyncSourceLink::getBaseSeqNum
uint16 getBaseSeqNum() const
Definition: iqueue.h:706
MembershipBookkeeping::~MembershipBookkeeping
virtual ~MembershipBookkeeping()
Purges all RTPSource structures created during the session, as well as the hash table and the list of...
Definition: iqueue.h:332
SDESItemType
SDESItemType
SDES items that may be carried in a Source DEScription RTCP packet.
Definition: rtcppkt.h:65
MembershipBookkeeping::SyncSourceLink::obsOctetCount
uint32 obsOctetCount
Definition: iqueue.h:770
MembershipBookkeeping
Controls the group membership in the current session.
Definition: iqueue.h:299
ParticipantHandler::~ParticipantHandler
virtual ~ParticipantHandler()
Definition: iqueue.h:196
MembershipBookkeeping::SyncSourceLink::SyncSourceLink
SyncSourceLink(MembershipBookkeeping *m, SyncSource *s, IncomingRTPPktLink *fp=NULL, IncomingRTPPktLink *lp=NULL, SyncSourceLink *ps=NULL, SyncSourceLink *ns=NULL, SyncSourceLink *ncollis=NULL)
Definition: iqueue.h:475
MembershipBookkeeping::SyncSourceLink
Synchronization Source internal handler within the incoming packets queue.
Definition: iqueue.h:470
ConflictHandler::ConflictingTransportAddress::getControlTransportPort
tpport_t getControlTransportPort() const
Definition: iqueue.h:250
MembershipBookkeeping::getFirst
SyncSourceLink * getFirst()
Definition: iqueue.h:837
IncomingDataQueue::setMaxPacketMisorder
void setMaxPacketMisorder(uint16 packets)
Definition: iqueue.h:1015
MembershipBookkeeping::SyncSourceLink::getCumulativePacketLost
uint32 getCumulativePacketLost() const
Definition: iqueue.h:624
MembershipBookkeeping::IncomingRTPPktLink::getPrev
IncomingRTPPktLink * getPrev() const
Definition: iqueue.h:384
MembershipBookkeeping::SyncSourceLink::expectedPrior
uint32 expectedPrior
Definition: iqueue.h:791