ccRTP
iqueue.h
Go to the documentation of this file.
00001 // Copyright (C) 2001,2002,2004 Federico Montesino Pouzols <fedemp@altern.org>.
00002 //
00003 // This program is free software; you can redistribute it and/or modify
00004 // it under the terms of the GNU General Public License as published by
00005 // the Free Software Foundation; either version 2 of the License, or
00006 // (at your option) any later version.
00007 //
00008 // This program is distributed in the hope that it will be useful,
00009 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00010 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00011 // GNU General Public License for more details.
00012 //
00013 // You should have received a copy of the GNU General Public License
00014 // along with this program; if not, write to the Free Software
00015 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
00016 //
00017 // As a special exception, you may use this file as part of a free software
00018 // library without restriction.  Specifically, if other files instantiate
00019 // templates or use macros or inline functions from this file, or you compile
00020 // this file and link it with other files to produce an executable, this
00021 // file does not by itself cause the resulting executable to be covered by
00022 // the GNU General Public License.  This exception does not however
00023 // invalidate any other reasons why the executable file might be covered by
00024 // the GNU General Public License.
00025 //
00026 // This exception applies only to the code released under the name GNU
00027 // ccRTP.  If you copy code from other releases into a copy of GNU
00028 // ccRTP, as the General Public License permits, the exception does
00029 // not apply to the code that you add in this way.  To avoid misleading
00030 // anyone as to the status of such modified files, you must delete
00031 // this exception notice from them.
00032 //
00033 // If you write modifications of your own for GNU ccRTP, it is your choice
00034 // whether to permit this exception to apply to your modifications.
00035 // If you do not wish that, delete this exception notice.
00036 //
00037 
00044 #ifndef CCXX_RTP_IQUEUE_H_
00045 #define CCXX_RTP_IQUEUE_H_
00046 
00047 #include <ccrtp/queuebase.h>
00048 #include <ccrtp/CryptoContext.h>
00049 
00050 #include <list>
00051 
00052 NAMESPACE_COMMONCPP
00053 
00068 class __EXPORT Members
00069 {
00070 public:
00071     inline void
00072     setMembersCount(uint32 n)
00073     { members = n; }
00074 
00075     inline void
00076     increaseMembersCount()
00077     { members++; }
00078 
00079     inline void
00080     decreaseMembersCount()
00081     { members--; }
00082 
00083     inline uint32
00084     getMembersCount() const
00085     { return members; }
00086 
00087     inline void
00088     setSendersCount(uint32 n)
00089     { activeSenders = n; }
00090 
00091     inline void
00092     increaseSendersCount()
00093     { activeSenders++; }
00094 
00095     inline void
00096     decreaseSendersCount()
00097     { activeSenders--; }
00098 
00099     inline uint32
00100     getSendersCount() const
00101     { return activeSenders; }
00102 
00103 protected:
00104     Members() :
00105         members(0),
00106         activeSenders(0)
00107     { }
00108 
00109     inline virtual ~Members()
00110     { }
00111 
00112 private:
00114     uint32 members;
00116     uint32 activeSenders;
00117 };
00118 
00125 class __EXPORT SyncSourceHandler
00126 {
00127 public:
00134     inline void*
00135     getLink(const SyncSource& source) const
00136     { return source.getLink(); }
00137 
00138     inline void
00139     setLink(SyncSource& source, void* link)
00140     { source.setLink(link); }
00141 
00142     inline void
00143     setParticipant(SyncSource& source, Participant& p)
00144     { source.setParticipant(p); }
00145 
00146     inline void
00147     setState(SyncSource& source, SyncSource::State ns)
00148     { source.setState(ns); }
00149 
00150     inline void
00151     setSender(SyncSource& source, bool active)
00152     { source.setSender(active); }
00153 
00154     inline void
00155     setDataTransportPort(SyncSource& source, tpport_t p)
00156     { source.setDataTransportPort(p); }
00157 
00158     inline void
00159     setControlTransportPort(SyncSource& source, tpport_t p)
00160     { source.setControlTransportPort(p); }
00161 
00162     inline void
00163     setNetworkAddress(SyncSource& source, InetAddress addr)
00164     { source.setNetworkAddress(addr); }
00165 
00166 protected:
00167     SyncSourceHandler()
00168     { }
00169 
00170     inline virtual ~SyncSourceHandler()
00171     { }
00172 };
00173 
00180 class __EXPORT ParticipantHandler
00181 {
00182 public:
00183     inline void
00184     setSDESItem(Participant* part, SDESItemType item,
00185             const std::string& val)
00186     { part->setSDESItem(item,val); }
00187 
00188     inline void
00189     setPRIVPrefix(Participant* part, const std::string val)
00190     { part->setPRIVPrefix(val); }
00191 
00192 protected:
00193     ParticipantHandler()
00194     { }
00195 
00196     inline virtual ~ParticipantHandler()
00197     { }
00198 };
00199 
00206 class __EXPORT ApplicationHandler
00207 {
00208 public:
00209     inline void
00210     addParticipant(RTPApplication& app, Participant& part)
00211     { app.addParticipant(part); }
00212 
00213     inline void
00214     removeParticipant(RTPApplication& app,
00215               RTPApplication::ParticipantLink* pl)
00216     { app.removeParticipant(pl); }
00217 
00218 protected:
00219     ApplicationHandler()
00220     { }
00221 
00222     inline virtual ~ApplicationHandler()
00223     { }
00224 };
00225 
00233 class __EXPORT ConflictHandler
00234 {
00235 public:
00236     struct ConflictingTransportAddress
00237     {
00238         ConflictingTransportAddress(InetAddress na,
00239                         tpport_t dtp, tpport_t ctp);
00240 
00241         void setNext(ConflictingTransportAddress* nc)
00242         { next = nc; }
00243 
00244         inline const InetAddress& getNetworkAddress( ) const
00245         { return networkAddress; }
00246 
00247         inline tpport_t getDataTransportPort() const
00248         { return dataTransportPort; }
00249 
00250         inline tpport_t getControlTransportPort() const
00251         { return controlTransportPort; }
00252 
00253         InetAddress networkAddress;
00254         tpport_t dataTransportPort;
00255         tpport_t controlTransportPort;
00256         ConflictingTransportAddress* next;
00257         // arrival time of last data or control packet.
00258         timeval lastPacketTime;
00259     };
00260 
00265     ConflictingTransportAddress* searchDataConflict(InetAddress na,
00266                             tpport_t dtp);
00271     ConflictingTransportAddress* searchControlConflict(InetAddress na,
00272                                tpport_t ctp);
00273 
00274     void updateConflict(ConflictingTransportAddress& ca)
00275     { gettimeofday(&(ca.lastPacketTime),NULL); }
00276 
00277     void addConflict(const InetAddress& na, tpport_t dtp, tpport_t ctp);
00278 
00279 protected:
00280     ConflictHandler()
00281     { firstConflict = lastConflict = NULL; }
00282 
00283     inline virtual ~ConflictHandler()
00284     { }
00285 
00286     ConflictingTransportAddress* firstConflict, * lastConflict;
00287 };
00288 
00299 class __EXPORT MembershipBookkeeping :
00300     public SyncSourceHandler,
00301     public ParticipantHandler,
00302     public ApplicationHandler,
00303     public ConflictHandler,
00304     private Members
00305 {
00306 public:
00307     inline size_t getDefaultMembersHashSize()
00308     { return defaultMembersHashSize; }
00309 
00310 protected:
00311 
00325     MembershipBookkeeping(uint32 initialSize = defaultMembersHashSize);
00326 
00331     inline virtual
00332     ~MembershipBookkeeping()
00333     { endMembers(); }
00334 
00335     struct SyncSourceLink;
00336 
00337     inline SyncSourceLink* getLink(const SyncSource& source) const
00338     { return static_cast<SyncSourceLink*>(SyncSourceHandler::getLink(source)); }
00343     inline bool isMine(const SyncSource& source) const
00344     { return getLink(source)->getMembership() == this; }
00345 
00352     struct IncomingRTPPktLink
00353     {
00354         IncomingRTPPktLink(IncomingRTPPkt* pkt, SyncSourceLink* sLink,
00355                    struct timeval& recv_ts,
00356                    uint32 shifted_ts,
00357                    IncomingRTPPktLink* sp,
00358                    IncomingRTPPktLink* sn,
00359                    IncomingRTPPktLink* p,
00360                    IncomingRTPPktLink* n) :
00361             packet(pkt),
00362             sourceLink(sLink),
00363             prev(p), next(n),
00364             srcPrev(sp), srcNext(sn),
00365             receptionTime(recv_ts),
00366             shiftedTimestamp(shifted_ts)
00367         { }
00368 
00369         ~IncomingRTPPktLink()
00370         { }
00371 
00372         inline SyncSourceLink* getSourceLink() const
00373         { return sourceLink; }
00374 
00375         inline void setSourceLink(SyncSourceLink* src)
00376         { sourceLink = src; }
00377 
00378         inline IncomingRTPPktLink* getNext() const
00379         { return next; }
00380 
00381         inline void setNext(IncomingRTPPktLink* nl)
00382         { next = nl; }
00383 
00384         inline IncomingRTPPktLink* getPrev() const
00385         { return prev; }
00386 
00387         inline void setPrev(IncomingRTPPktLink* pl)
00388         { prev = pl; }
00389 
00390         inline IncomingRTPPktLink* getSrcNext() const
00391         { return srcNext; }
00392 
00393         inline void setSrcNext(IncomingRTPPktLink* sn)
00394         { srcNext = sn; }
00395 
00396         inline IncomingRTPPktLink* getSrcPrev() const
00397         { return srcPrev; }
00398 
00399         inline void setSrcPrev(IncomingRTPPktLink* sp)
00400         { srcPrev = sp; }
00401 
00402         inline IncomingRTPPkt* getPacket() const
00403         { return packet; }
00404 
00405         inline void setPacket(IncomingRTPPkt* pkt)
00406         { packet = pkt; }
00407 
00415         inline void setRecvTime(const timeval &t)
00416         { receptionTime = t; }
00417 
00421         inline timeval getRecvTime() const
00422         { return receptionTime; }
00423 
00432         inline uint32 getTimestamp() const
00433         { return shiftedTimestamp; }
00434 
00435         inline void setTimestamp(uint32 ts)
00436         { shiftedTimestamp = ts;}
00437 
00438         // the packet this link refers to.
00439         IncomingRTPPkt* packet;
00440         // the synchronization source this packet comes from.
00441         SyncSourceLink* sourceLink;
00442         // global incoming packet queue links.
00443         IncomingRTPPktLink* prev, * next;
00444         // source specific incoming packet queue links.
00445         IncomingRTPPktLink* srcPrev, * srcNext;
00446         // time this packet was received at
00447         struct timeval receptionTime;
00448         // timestamp of the packet in host order and after
00449         // substracting the initial timestamp for its source
00450         // (it is an increment from the initial timestamp).
00451         uint32 shiftedTimestamp;
00452     };
00453 
00470     struct SyncSourceLink
00471     {
00472         // 2^16
00473         static const uint32 SEQNUMMOD;
00474 
00475         SyncSourceLink(MembershipBookkeeping* m,
00476                    SyncSource* s,
00477                    IncomingRTPPktLink* fp = NULL,
00478                    IncomingRTPPktLink* lp = NULL,
00479                    SyncSourceLink* ps = NULL,
00480                    SyncSourceLink* ns = NULL,
00481                    SyncSourceLink* ncollis = NULL) :
00482             membership(m), source(s), first(fp), last(lp),
00483             prev(ps), next(ns), nextCollis(ncollis),
00484             prevConflict(NULL)
00485         { m->setLink(*s,this); // record that the source is associated
00486           initStats();         // to this link.
00487         }
00488 
00492         ~SyncSourceLink();
00493 
00494         inline MembershipBookkeeping* getMembership()
00495         { return membership; }
00496 
00501         inline SyncSource* getSource() { return source; }
00502 
00507         inline IncomingRTPPktLink* getFirst()
00508         { return first; }
00509 
00510         inline void setFirst(IncomingRTPPktLink* fp)
00511         { first = fp; }
00512 
00517         inline IncomingRTPPktLink* getLast()
00518         { return last; }
00519 
00520         inline void setLast(IncomingRTPPktLink* lp)
00521         { last = lp; }
00522 
00526         inline SyncSourceLink* getPrev()
00527         { return prev; }
00528 
00529         inline void setPrev(SyncSourceLink* ps)
00530         { prev = ps; }
00531 
00535         inline SyncSourceLink* getNext()
00536         { return next; }
00537 
00538         inline void setNext(SyncSourceLink *ns)
00539         { next = ns; }
00540 
00547         inline SyncSourceLink* getNextCollis()
00548         { return nextCollis; }
00549 
00550         inline void setNextCollis(SyncSourceLink* ns)
00551         { nextCollis = ns; }
00552 
00553         inline ConflictingTransportAddress* getPrevConflict() const
00554         { return prevConflict; }
00555 
00559         void setPrevConflict(InetAddress& addr, tpport_t dataPort,
00560                      tpport_t controlPort);
00561 
00562         unsigned char* getSenderInfo()
00563         { return senderInfo; }
00564 
00565         void setSenderInfo(unsigned char* si);
00566 
00567         unsigned char* getReceiverInfo()
00568         { return receiverInfo; }
00569 
00570         void setReceiverInfo(unsigned char* ri);
00571 
00572         inline timeval getLastPacketTime() const
00573         { return lastPacketTime; }
00574 
00575         inline timeval getLastRTCPPacketTime() const
00576         { return lastRTCPPacketTime; }
00577 
00578         inline timeval getLastRTCPSRTime() const
00579         { return lastRTCPSRTime; }
00580 
00585         inline uint32 getObservedPacketCount() const
00586         { return obsPacketCount; }
00587 
00588         inline void incObservedPacketCount()
00589         { obsPacketCount++; }
00590 
00595         inline uint32 getObservedOctetCount() const
00596         { return obsOctetCount; }
00597 
00598         inline void incObservedOctetCount(uint32 n)
00599         { obsOctetCount += n; }
00600 
00604         uint16
00605         getMaxSeqNum() const
00606         { return maxSeqNum; }
00607 
00612         void
00613         setMaxSeqNum(uint16 max)
00614         { maxSeqNum = max; }
00615 
00616         inline uint32
00617         getExtendedMaxSeqNum() const
00618         { return extendedMaxSeqNum; }
00619 
00620         inline void
00621         setExtendedMaxSeqNum(uint32 seq)
00622         { extendedMaxSeqNum = seq; }
00623 
00624         inline uint32 getCumulativePacketLost() const
00625         { return cumulativePacketLost; }
00626 
00627         inline void setCumulativePacketLost(uint32 pl)
00628         { cumulativePacketLost = pl; }
00629 
00630         inline uint8 getFractionLost() const
00631         { return fractionLost; }
00632 
00633         inline void setFractionLost(uint8 fl)
00634         { fractionLost = fl; }
00635 
00636         inline uint32 getLastPacketTransitTime()
00637         { return lastPacketTransitTime; }
00638 
00639         inline void setLastPacketTransitTime(uint32 time)
00640         { lastPacketTransitTime = time; }
00641 
00642         inline float getJitter() const
00643         { return jitter; }
00644 
00645         inline void setJitter(float j)
00646         { jitter = j; }
00647 
00648         inline uint32 getInitialDataTimestamp() const
00649         { return initialDataTimestamp; }
00650 
00651         inline void setInitialDataTimestamp(uint32 ts)
00652         { initialDataTimestamp = ts; }
00653 
00654         inline timeval getInitialDataTime() const
00655         { return initialDataTime; }
00656 
00657         inline void setInitialDataTime(timeval it)
00658         { initialDataTime = it; }
00659 
00667         bool getGoodbye()
00668         {
00669             if(!flag)
00670                 return false;
00671             flag = false;
00672             return true;
00673         }
00674 
00681         bool getHello() {
00682             if(flag)
00683                 return false;
00684             flag = true;
00685             return true;
00686         }
00687 
00688         inline uint32 getBadSeqNum() const
00689         { return badSeqNum; }
00690 
00691         inline void setBadSeqNum(uint32 seq)
00692         { badSeqNum = seq; }
00693 
00694         uint8 getProbation() const
00695         { return probation; }
00696 
00697         inline void setProbation(uint8 p)
00698         { probation = p; }
00699 
00700         inline void decProbation()
00701         { --probation; }
00702 
00703         bool isValid() const
00704         { return 0 == probation; }
00705 
00706         inline uint16 getBaseSeqNum() const
00707         { return baseSeqNum; }
00708 
00709         inline uint32 getSeqNumAccum() const
00710         { return seqNumAccum; }
00711 
00712         inline void incSeqNumAccum()
00713         { seqNumAccum += SEQNUMMOD; }
00714 
00718         inline void initSequence(uint16 seqnum)
00719         { maxSeqNum = seqNumAccum = seqnum; }
00720 
00731         void recordInsertion(const IncomingRTPPktLink& pl);
00732 
00733         void initStats();
00734 
00739         void computeStats();
00740 
00741         MembershipBookkeeping* membership;
00742         // The source this link object refers to.
00743         SyncSource* source;
00744         // first/last packets from this source in the queue.
00745         IncomingRTPPktLink* first, * last;
00746         // Links for synchronization sources located before
00747         // and after this one in the list of sources.
00748         SyncSourceLink* prev, * next;
00749         // Prev and next inside the hash table collision list.
00750         SyncSourceLink* nextCollis;
00751         ConflictingTransportAddress* prevConflict;
00752         unsigned char* senderInfo;
00753         unsigned char* receiverInfo;
00754         // time the last RTP packet from this source was
00755         // received at.
00756         timeval lastPacketTime;
00757         // time the last RTCP packet was received.
00758         timeval lastRTCPPacketTime;
00759         // time the lasrt RTCP SR was received. Required for
00760         // DLSR computation.
00761         timeval lastRTCPSRTime;
00762 
00763         // for outgoing RR reports.
00764         // number of packets received from this source.
00765         uint32 obsPacketCount;
00766         // number of octets received from this source.
00767         uint32 obsOctetCount;
00768         // the higher sequence number seen from this source
00769         uint16 maxSeqNum;
00770         uint32 extendedMaxSeqNum;
00771         uint32 cumulativePacketLost;
00772         uint8 fractionLost;
00773         // for interarrivel jitter computation
00774         uint32 lastPacketTransitTime;
00775         // interarrival jitter of packets from this source.
00776         float jitter;
00777         uint32 initialDataTimestamp;
00778         timeval initialDataTime;
00779 
00780         // this flag assures we only call one gotHello and one
00781         // gotGoodbye for this src.
00782         bool flag;
00783 
00784         // for source validation:
00785         uint32 badSeqNum;
00786         uint8 probation;  // packets in sequence before valid.
00787         uint16 baseSeqNum;
00788         uint32 expectedPrior;
00789         uint32 receivedPrior;
00790         uint32 seqNumAccum;
00791     };
00792 
00797     bool
00798     isRegistered(uint32 ssrc);
00799 
00808     SyncSourceLink*
00809     getSourceBySSRC(uint32 ssrc, bool& created);
00810 
00821     bool
00822     BYESource(uint32 ssrc);
00823 
00831     bool
00832     removeSource(uint32 ssrc);
00833 
00834     inline SyncSourceLink* getFirst()
00835     { return first; }
00836 
00837     inline SyncSourceLink* getLast()
00838     { return last; }
00839 
00840     inline uint32
00841     getMembersCount()
00842     { return Members::getMembersCount(); }
00843 
00844     inline void
00845     setMembersCount(uint32 n)
00846     { Members::setMembersCount(n); }
00847 
00848     inline uint32
00849     getSendersCount()
00850     { return Members::getSendersCount(); }
00851 
00852     static const size_t defaultMembersHashSize;
00853     static const uint32 SEQNUMMOD;
00854 
00855 private:
00856     MembershipBookkeeping(const MembershipBookkeeping &o);
00857 
00858     MembershipBookkeeping&
00859     operator=(const MembershipBookkeeping &o);
00860 
00865     void
00866     endMembers();
00867 
00868     // Hash table with sources of RTP and RTCP packets
00869     uint32 sourceBucketsNum;
00870     SyncSourceLink** sourceLinks;
00871     // List of sources, ordered from older to newer
00872     SyncSourceLink* first, * last;
00873 };
00874 
00881 class __EXPORT IncomingDataQueue: public IncomingDataQueueBase,
00882     protected MembershipBookkeeping
00883 {
00884 public:
00890     class SyncSourcesIterator
00891     {
00892     public:
00893         typedef std::forward_iterator_tag iterator_category;
00894         typedef SyncSource value_type;
00895         typedef std::ptrdiff_t difference_type;
00896         typedef const SyncSource* pointer;
00897         typedef const SyncSource& reference;
00898 
00899         SyncSourcesIterator(SyncSourceLink* l = NULL) :
00900             link(l)
00901         { }
00902 
00903         SyncSourcesIterator(const SyncSourcesIterator& si) :
00904             link(si.link)
00905         { }
00906 
00907         reference operator*() const
00908         { return *(link->getSource()); }
00909 
00910         pointer operator->() const
00911         { return link->getSource(); }
00912 
00913         SyncSourcesIterator& operator++() {
00914             link = link->getNext();
00915             return *this;
00916         }
00917 
00918         SyncSourcesIterator operator++(int) {
00919             SyncSourcesIterator result(*this);
00920             ++(*this);
00921             return result;
00922         }
00923 
00924         friend bool operator==(const SyncSourcesIterator& l,
00925                        const SyncSourcesIterator& r)
00926         { return l.link == r.link; }
00927 
00928         friend bool operator!=(const SyncSourcesIterator& l,
00929                        const SyncSourcesIterator& r)
00930         { return l.link != r.link; }
00931 
00932     private:
00933         SyncSourceLink *link;
00934     };
00935 
00936     SyncSourcesIterator begin()
00937     { return SyncSourcesIterator(MembershipBookkeeping::getFirst()); }
00938 
00939     SyncSourcesIterator end()
00940     { return SyncSourcesIterator(NULL); }
00941 
00951     const AppDataUnit*
00952     getData(uint32 stamp, const SyncSource* src = NULL);
00953 
00954 
00961     bool
00962     isWaiting(const SyncSource* src = NULL) const;
00963 
00970     uint32
00971     getFirstTimestamp(const SyncSource* src = NULL) const;
00972 
00995     void
00996     setMinValidPacketSequence(uint8 packets)
00997     { minValidPacketSequence = packets; }
00998 
00999     uint8
01000     getDefaultMinValidPacketSequence() const
01001     { return defaultMinValidPacketSequence; }
01002 
01007     uint8
01008     getMinValidPacketSequence() const
01009     { return minValidPacketSequence; }
01010 
01011     void
01012     setMaxPacketMisorder(uint16 packets)
01013     { maxPacketMisorder = packets; }
01014 
01015     uint16
01016     getDefaultMaxPacketMisorder() const
01017     { return defaultMaxPacketMisorder; }
01018 
01019     uint16
01020     getMaxPacketMisorder() const
01021     { return maxPacketMisorder; }
01022 
01028     void
01029     setMaxPacketDropout(uint16 packets) // default: 3000.
01030     { maxPacketDropout = packets; }
01031 
01032     uint16
01033     getDefaultMaxPacketDropout() const
01034     { return defaultMaxPacketDropout; }
01035 
01036     uint16
01037     getMaxPacketDropout() const
01038     { return maxPacketDropout; }
01039 
01040     // default value for constructors that allow to specify
01041     // members table s\ize
01042         inline static size_t
01043         getDefaultMembersSize()
01044         { return defaultMembersSize; }
01045 
01054         void
01055         setInQueueCryptoContext(CryptoContext* cc);
01056 
01067         void
01068         removeInQueueCryptoContext(CryptoContext* cc);
01069 
01077         CryptoContext*
01078         getInQueueCryptoContext(uint32 ssrc);
01079 
01080 protected:
01084     IncomingDataQueue(uint32 size);
01085 
01086     virtual ~IncomingDataQueue()
01087     { }
01088 
01101     bool checkSSRCInIncomingRTPPkt(SyncSourceLink& sourceLink,
01102                        bool is_new, InetAddress& na,
01103                        tpport_t tp);
01104 
01120     void setSourceExpirationPeriod(uint8 intervals)
01121     { sourceExpirationPeriod = intervals; }
01122 
01129     virtual size_t
01130     takeInDataPacket();
01131 
01132     void renewLocalSSRC();
01133 
01143     IncomingDataQueue::IncomingRTPPktLink*
01144     getWaiting(uint32 timestamp, const SyncSource *src = NULL);
01145 
01161     bool
01162     recordReception(SyncSourceLink& srcLink, const IncomingRTPPkt& pkt,
01163             const timeval recvtime);
01164 
01171     void
01172     recordExtraction(const IncomingRTPPkt& pkt);
01173 
01174     void purgeIncomingQueue();
01175 
01182     inline virtual void
01183     onNewSyncSource(const SyncSource&)
01184     { }
01185 
01186 protected:
01203     inline virtual bool
01204     onRTPPacketRecv(IncomingRTPPkt&)
01205     { return true; }
01206 
01215     inline virtual void onExpireRecv(IncomingRTPPkt&)
01216     { return; }
01217 
01231         inline virtual bool
01232         onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode)
01233         { return false; }
01234 
01235         inline virtual bool
01236     end2EndDelayed(IncomingRTPPktLink&)
01237     { return false; }
01238 
01254     bool
01255     insertRecvPacket(IncomingRTPPktLink* packetLink);
01256 
01268     virtual size_t
01269     recvData(unsigned char* buffer, size_t length,
01270          InetHostAddress& host, tpport_t& port) = 0;
01271 
01272     virtual size_t
01273     getNextDataPacketSize() const = 0;
01274 
01275     mutable ThreadLock recvLock;
01276     // reception queue
01277     IncomingRTPPktLink* recvFirst, * recvLast;
01278     // values for packet validation.
01279     static const uint8 defaultMinValidPacketSequence;
01280     static const uint16 defaultMaxPacketMisorder;
01281     static const uint16 defaultMaxPacketDropout;
01282     uint8 minValidPacketSequence;
01283     uint16 maxPacketMisorder;
01284     uint16 maxPacketDropout;
01285     static const size_t defaultMembersSize;
01286     uint8 sourceExpirationPeriod;
01287     mutable Mutex cryptoMutex;
01288         std::list<CryptoContext *> cryptoContexts;
01289 };
01290  // iqueue
01292 
01293 END_NAMESPACE
01294 
01295 #endif  //CCXX_RTP_IQUEUE_H_
01296