ccRTP
|
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 #ifdef CCXX_NAMESPACES 00053 namespace ost { 00054 #endif 00055 00070 class __EXPORT Members 00071 { 00072 public: 00073 inline void 00074 setMembersCount(uint32 n) 00075 { members = n; } 00076 00077 inline void 00078 increaseMembersCount() 00079 { members++; } 00080 00081 inline void 00082 decreaseMembersCount() 00083 { members--; } 00084 00085 inline uint32 00086 getMembersCount() const 00087 { return members; } 00088 00089 inline void 00090 setSendersCount(uint32 n) 00091 { activeSenders = n; } 00092 00093 inline void 00094 increaseSendersCount() 00095 { activeSenders++; } 00096 00097 inline void 00098 decreaseSendersCount() 00099 { activeSenders--; } 00100 00101 inline uint32 00102 getSendersCount() const 00103 { return activeSenders; } 00104 00105 protected: 00106 Members() : 00107 members(0), 00108 activeSenders(0) 00109 { } 00110 00111 inline virtual ~Members() 00112 { } 00113 00114 private: 00116 uint32 members; 00118 uint32 activeSenders; 00119 }; 00120 00127 class __EXPORT SyncSourceHandler 00128 { 00129 public: 00136 inline void* 00137 getLink(const SyncSource& source) const 00138 { return source.getLink(); } 00139 00140 inline void 00141 setLink(SyncSource& source, void* link) 00142 { source.setLink(link); } 00143 00144 inline void 00145 setParticipant(SyncSource& source, Participant& p) 00146 { source.setParticipant(p); } 00147 00148 inline void 00149 setState(SyncSource& source, SyncSource::State ns) 00150 { source.setState(ns); } 00151 00152 inline void 00153 setSender(SyncSource& source, bool active) 00154 { source.setSender(active); } 00155 00156 inline void 00157 setDataTransportPort(SyncSource& source, tpport_t p) 00158 { source.setDataTransportPort(p); } 00159 00160 inline void 00161 setControlTransportPort(SyncSource& source, tpport_t p) 00162 { source.setControlTransportPort(p); } 00163 00164 inline void 00165 setNetworkAddress(SyncSource& source, InetAddress addr) 00166 { source.setNetworkAddress(addr); } 00167 00168 protected: 00169 SyncSourceHandler() 00170 { } 00171 00172 inline virtual ~SyncSourceHandler() 00173 { } 00174 }; 00175 00182 class __EXPORT ParticipantHandler 00183 { 00184 public: 00185 inline void 00186 setSDESItem(Participant* part, SDESItemType item, 00187 const std::string& val) 00188 { part->setSDESItem(item,val); } 00189 00190 inline void 00191 setPRIVPrefix(Participant* part, const std::string val) 00192 { part->setPRIVPrefix(val); } 00193 00194 protected: 00195 ParticipantHandler() 00196 { } 00197 00198 inline virtual ~ParticipantHandler() 00199 { } 00200 }; 00201 00208 class __EXPORT ApplicationHandler 00209 { 00210 public: 00211 inline void 00212 addParticipant(RTPApplication& app, Participant& part) 00213 { app.addParticipant(part); } 00214 00215 inline void 00216 removeParticipant(RTPApplication& app, 00217 RTPApplication::ParticipantLink* pl) 00218 { app.removeParticipant(pl); } 00219 00220 protected: 00221 ApplicationHandler() 00222 { } 00223 00224 inline virtual ~ApplicationHandler() 00225 { } 00226 }; 00227 00235 class __EXPORT ConflictHandler 00236 { 00237 public: 00238 struct ConflictingTransportAddress 00239 { 00240 ConflictingTransportAddress(InetAddress na, 00241 tpport_t dtp, tpport_t ctp); 00242 00243 void setNext(ConflictingTransportAddress* nc) 00244 { next = nc; } 00245 00246 inline const InetAddress& getNetworkAddress( ) const 00247 { return networkAddress; } 00248 00249 inline tpport_t getDataTransportPort() const 00250 { return dataTransportPort; } 00251 00252 inline tpport_t getControlTransportPort() const 00253 { return controlTransportPort; } 00254 00255 InetAddress networkAddress; 00256 tpport_t dataTransportPort; 00257 tpport_t controlTransportPort; 00258 ConflictingTransportAddress* next; 00259 // arrival time of last data or control packet. 00260 timeval lastPacketTime; 00261 }; 00262 00267 ConflictingTransportAddress* searchDataConflict(InetAddress na, 00268 tpport_t dtp); 00273 ConflictingTransportAddress* searchControlConflict(InetAddress na, 00274 tpport_t ctp); 00275 00276 void updateConflict(ConflictingTransportAddress& ca) 00277 { gettimeofday(&(ca.lastPacketTime),NULL); } 00278 00279 void addConflict(const InetAddress& na, tpport_t dtp, tpport_t ctp); 00280 00281 protected: 00282 ConflictHandler() 00283 { firstConflict = lastConflict = NULL; } 00284 00285 inline virtual ~ConflictHandler() 00286 { } 00287 00288 ConflictingTransportAddress* firstConflict, * lastConflict; 00289 }; 00290 00301 class __EXPORT MembershipBookkeeping : 00302 public SyncSourceHandler, 00303 public ParticipantHandler, 00304 public ApplicationHandler, 00305 public ConflictHandler, 00306 private Members 00307 { 00308 public: 00309 inline size_t getDefaultMembersHashSize() 00310 { return defaultMembersHashSize; } 00311 00312 protected: 00313 00327 MembershipBookkeeping(uint32 initialSize = defaultMembersHashSize); 00328 00333 inline virtual 00334 ~MembershipBookkeeping() 00335 { endMembers(); } 00336 00337 struct SyncSourceLink; 00338 00339 inline SyncSourceLink* getLink(const SyncSource& source) const 00340 { return static_cast<SyncSourceLink*>(SyncSourceHandler::getLink(source)); } 00345 inline bool isMine(const SyncSource& source) const 00346 { return getLink(source)->getMembership() == this; } 00347 00354 struct IncomingRTPPktLink 00355 { 00356 IncomingRTPPktLink(IncomingRTPPkt* pkt, SyncSourceLink* sLink, 00357 struct timeval& recv_ts, 00358 uint32 shifted_ts, 00359 IncomingRTPPktLink* sp, 00360 IncomingRTPPktLink* sn, 00361 IncomingRTPPktLink* p, 00362 IncomingRTPPktLink* n) : 00363 packet(pkt), 00364 sourceLink(sLink), 00365 prev(p), next(n), 00366 srcPrev(sp), srcNext(sn), 00367 receptionTime(recv_ts), 00368 shiftedTimestamp(shifted_ts) 00369 { } 00370 00371 ~IncomingRTPPktLink() 00372 { } 00373 00374 inline SyncSourceLink* getSourceLink() const 00375 { return sourceLink; } 00376 00377 inline void setSourceLink(SyncSourceLink* src) 00378 { sourceLink = src; } 00379 00380 inline IncomingRTPPktLink* getNext() const 00381 { return next; } 00382 00383 inline void setNext(IncomingRTPPktLink* nl) 00384 { next = nl; } 00385 00386 inline IncomingRTPPktLink* getPrev() const 00387 { return prev; } 00388 00389 inline void setPrev(IncomingRTPPktLink* pl) 00390 { prev = pl; } 00391 00392 inline IncomingRTPPktLink* getSrcNext() const 00393 { return srcNext; } 00394 00395 inline void setSrcNext(IncomingRTPPktLink* sn) 00396 { srcNext = sn; } 00397 00398 inline IncomingRTPPktLink* getSrcPrev() const 00399 { return srcPrev; } 00400 00401 inline void setSrcPrev(IncomingRTPPktLink* sp) 00402 { srcPrev = sp; } 00403 00404 inline IncomingRTPPkt* getPacket() const 00405 { return packet; } 00406 00407 inline void setPacket(IncomingRTPPkt* pkt) 00408 { packet = pkt; } 00409 00417 inline void setRecvTime(const timeval &t) 00418 { receptionTime = t; } 00419 00423 inline timeval getRecvTime() const 00424 { return receptionTime; } 00425 00434 inline uint32 getTimestamp() const 00435 { return shiftedTimestamp; } 00436 00437 inline void setTimestamp(uint32 ts) 00438 { shiftedTimestamp = ts;} 00439 00440 // the packet this link refers to. 00441 IncomingRTPPkt* packet; 00442 // the synchronization source this packet comes from. 00443 SyncSourceLink* sourceLink; 00444 // global incoming packet queue links. 00445 IncomingRTPPktLink* prev, * next; 00446 // source specific incoming packet queue links. 00447 IncomingRTPPktLink* srcPrev, * srcNext; 00448 // time this packet was received at 00449 struct timeval receptionTime; 00450 // timestamp of the packet in host order and after 00451 // substracting the initial timestamp for its source 00452 // (it is an increment from the initial timestamp). 00453 uint32 shiftedTimestamp; 00454 }; 00455 00472 struct SyncSourceLink 00473 { 00474 // 2^16 00475 static const uint32 SEQNUMMOD; 00476 00477 SyncSourceLink(MembershipBookkeeping* m, 00478 SyncSource* s, 00479 IncomingRTPPktLink* fp = NULL, 00480 IncomingRTPPktLink* lp = NULL, 00481 SyncSourceLink* ps = NULL, 00482 SyncSourceLink* ns = NULL, 00483 SyncSourceLink* ncollis = NULL) : 00484 membership(m), source(s), first(fp), last(lp), 00485 prev(ps), next(ns), nextCollis(ncollis), 00486 prevConflict(NULL) 00487 { m->setLink(*s,this); // record that the source is associated 00488 initStats(); // to this link. 00489 } 00490 00494 ~SyncSourceLink(); 00495 00496 inline MembershipBookkeeping* getMembership() 00497 { return membership; } 00498 00503 inline SyncSource* getSource() { return source; } 00504 00509 inline IncomingRTPPktLink* getFirst() 00510 { return first; } 00511 00512 inline void setFirst(IncomingRTPPktLink* fp) 00513 { first = fp; } 00514 00519 inline IncomingRTPPktLink* getLast() 00520 { return last; } 00521 00522 inline void setLast(IncomingRTPPktLink* lp) 00523 { last = lp; } 00524 00528 inline SyncSourceLink* getPrev() 00529 { return prev; } 00530 00531 inline void setPrev(SyncSourceLink* ps) 00532 { prev = ps; } 00533 00537 inline SyncSourceLink* getNext() 00538 { return next; } 00539 00540 inline void setNext(SyncSourceLink *ns) 00541 { next = ns; } 00542 00549 inline SyncSourceLink* getNextCollis() 00550 { return nextCollis; } 00551 00552 inline void setNextCollis(SyncSourceLink* ns) 00553 { nextCollis = ns; } 00554 00555 inline ConflictingTransportAddress* getPrevConflict() const 00556 { return prevConflict; } 00557 00561 void setPrevConflict(InetAddress& addr, tpport_t dataPort, 00562 tpport_t controlPort); 00563 00564 unsigned char* getSenderInfo() 00565 { return senderInfo; } 00566 00567 void setSenderInfo(unsigned char* si); 00568 00569 unsigned char* getReceiverInfo() 00570 { return receiverInfo; } 00571 00572 void setReceiverInfo(unsigned char* ri); 00573 00574 inline timeval getLastPacketTime() const 00575 { return lastPacketTime; } 00576 00577 inline timeval getLastRTCPPacketTime() const 00578 { return lastRTCPPacketTime; } 00579 00580 inline timeval getLastRTCPSRTime() const 00581 { return lastRTCPSRTime; } 00582 00587 inline uint32 getObservedPacketCount() const 00588 { return obsPacketCount; } 00589 00590 inline void incObservedPacketCount() 00591 { obsPacketCount++; } 00592 00597 inline uint32 getObservedOctetCount() const 00598 { return obsOctetCount; } 00599 00600 inline void incObservedOctetCount(uint32 n) 00601 { obsOctetCount += n; } 00602 00606 uint16 00607 getMaxSeqNum() const 00608 { return maxSeqNum; } 00609 00614 void 00615 setMaxSeqNum(uint16 max) 00616 { maxSeqNum = max; } 00617 00618 inline uint32 00619 getExtendedMaxSeqNum() const 00620 { return extendedMaxSeqNum; } 00621 00622 inline void 00623 setExtendedMaxSeqNum(uint32 seq) 00624 { extendedMaxSeqNum = seq; } 00625 00626 inline uint32 getCumulativePacketLost() const 00627 { return cumulativePacketLost; } 00628 00629 inline void setCumulativePacketLost(uint32 pl) 00630 { cumulativePacketLost = pl; } 00631 00632 inline uint8 getFractionLost() const 00633 { return fractionLost; } 00634 00635 inline void setFractionLost(uint8 fl) 00636 { fractionLost = fl; } 00637 00638 inline uint32 getLastPacketTransitTime() 00639 { return lastPacketTransitTime; } 00640 00641 inline void setLastPacketTransitTime(uint32 time) 00642 { lastPacketTransitTime = time; } 00643 00644 inline float getJitter() const 00645 { return jitter; } 00646 00647 inline void setJitter(float j) 00648 { jitter = j; } 00649 00650 inline uint32 getInitialDataTimestamp() const 00651 { return initialDataTimestamp; } 00652 00653 inline void setInitialDataTimestamp(uint32 ts) 00654 { initialDataTimestamp = ts; } 00655 00656 inline timeval getInitialDataTime() const 00657 { return initialDataTime; } 00658 00659 inline void setInitialDataTime(timeval it) 00660 { initialDataTime = it; } 00661 00669 bool getGoodbye() 00670 { 00671 if(!flag) 00672 return false; 00673 flag = false; 00674 return true; 00675 } 00676 00683 bool getHello() { 00684 if(flag) 00685 return false; 00686 flag = true; 00687 return true; 00688 } 00689 00690 inline uint32 getBadSeqNum() const 00691 { return badSeqNum; } 00692 00693 inline void setBadSeqNum(uint32 seq) 00694 { badSeqNum = seq; } 00695 00696 uint8 getProbation() const 00697 { return probation; } 00698 00699 inline void setProbation(uint8 p) 00700 { probation = p; } 00701 00702 inline void decProbation() 00703 { --probation; } 00704 00705 bool isValid() const 00706 { return 0 == probation; } 00707 00708 inline uint16 getBaseSeqNum() const 00709 { return baseSeqNum; } 00710 00711 inline uint32 getSeqNumAccum() const 00712 { return seqNumAccum; } 00713 00714 inline void incSeqNumAccum() 00715 { seqNumAccum += SEQNUMMOD; } 00716 00720 inline void initSequence(uint16 seqnum) 00721 { maxSeqNum = seqNumAccum = seqnum; } 00722 00733 void recordInsertion(const IncomingRTPPktLink& pl); 00734 00735 void initStats(); 00736 00741 void computeStats(); 00742 00743 MembershipBookkeeping* membership; 00744 // The source this link object refers to. 00745 SyncSource* source; 00746 // first/last packets from this source in the queue. 00747 IncomingRTPPktLink* first, * last; 00748 // Links for synchronization sources located before 00749 // and after this one in the list of sources. 00750 SyncSourceLink* prev, * next; 00751 // Prev and next inside the hash table collision list. 00752 SyncSourceLink* nextCollis; 00753 ConflictingTransportAddress* prevConflict; 00754 unsigned char* senderInfo; 00755 unsigned char* receiverInfo; 00756 // time the last RTP packet from this source was 00757 // received at. 00758 timeval lastPacketTime; 00759 // time the last RTCP packet was received. 00760 timeval lastRTCPPacketTime; 00761 // time the lasrt RTCP SR was received. Required for 00762 // DLSR computation. 00763 timeval lastRTCPSRTime; 00764 00765 // for outgoing RR reports. 00766 // number of packets received from this source. 00767 uint32 obsPacketCount; 00768 // number of octets received from this source. 00769 uint32 obsOctetCount; 00770 // the higher sequence number seen from this source 00771 uint16 maxSeqNum; 00772 uint32 extendedMaxSeqNum; 00773 uint32 cumulativePacketLost; 00774 uint8 fractionLost; 00775 // for interarrivel jitter computation 00776 uint32 lastPacketTransitTime; 00777 // interarrival jitter of packets from this source. 00778 float jitter; 00779 uint32 initialDataTimestamp; 00780 timeval initialDataTime; 00781 00782 // this flag assures we only call one gotHello and one 00783 // gotGoodbye for this src. 00784 bool flag; 00785 00786 // for source validation: 00787 uint32 badSeqNum; 00788 uint8 probation; // packets in sequence before valid. 00789 uint16 baseSeqNum; 00790 uint32 expectedPrior; 00791 uint32 receivedPrior; 00792 uint32 seqNumAccum; 00793 }; 00794 00799 bool 00800 isRegistered(uint32 ssrc); 00801 00810 SyncSourceLink* 00811 getSourceBySSRC(uint32 ssrc, bool& created); 00812 00823 bool 00824 BYESource(uint32 ssrc); 00825 00833 bool 00834 removeSource(uint32 ssrc); 00835 00836 inline SyncSourceLink* getFirst() 00837 { return first; } 00838 00839 inline SyncSourceLink* getLast() 00840 { return last; } 00841 00842 inline uint32 00843 getMembersCount() 00844 { return Members::getMembersCount(); } 00845 00846 inline void 00847 setMembersCount(uint32 n) 00848 { Members::setMembersCount(n); } 00849 00850 inline uint32 00851 getSendersCount() 00852 { return Members::getSendersCount(); } 00853 00854 static const size_t defaultMembersHashSize; 00855 static const uint32 SEQNUMMOD; 00856 00857 private: 00858 MembershipBookkeeping(const MembershipBookkeeping &o); 00859 00860 MembershipBookkeeping& 00861 operator=(const MembershipBookkeeping &o); 00862 00867 void 00868 endMembers(); 00869 00870 // Hash table with sources of RTP and RTCP packets 00871 uint32 sourceBucketsNum; 00872 SyncSourceLink** sourceLinks; 00873 // List of sources, ordered from older to newer 00874 SyncSourceLink* first, * last; 00875 }; 00876 00883 class __EXPORT IncomingDataQueue: public IncomingDataQueueBase, 00884 protected MembershipBookkeeping 00885 { 00886 public: 00892 class SyncSourcesIterator 00893 { 00894 public: 00895 typedef std::forward_iterator_tag iterator_category; 00896 typedef SyncSource value_type; 00897 typedef ptrdiff_t difference_type; 00898 typedef const SyncSource* pointer; 00899 typedef const SyncSource& reference; 00900 00901 SyncSourcesIterator(SyncSourceLink* l = NULL) : 00902 link(l) 00903 { } 00904 00905 SyncSourcesIterator(const SyncSourcesIterator& si) : 00906 link(si.link) 00907 { } 00908 00909 reference operator*() const 00910 { return *(link->getSource()); } 00911 00912 pointer operator->() const 00913 { return link->getSource(); } 00914 00915 SyncSourcesIterator& operator++() { 00916 link = link->getNext(); 00917 return *this; 00918 } 00919 00920 SyncSourcesIterator operator++(int) { 00921 SyncSourcesIterator result(*this); 00922 ++(*this); 00923 return result; 00924 } 00925 00926 friend bool operator==(const SyncSourcesIterator& l, 00927 const SyncSourcesIterator& r) 00928 { return l.link == r.link; } 00929 00930 friend bool operator!=(const SyncSourcesIterator& l, 00931 const SyncSourcesIterator& r) 00932 { return l.link != r.link; } 00933 00934 private: 00935 SyncSourceLink *link; 00936 }; 00937 00938 SyncSourcesIterator begin() 00939 { return SyncSourcesIterator(MembershipBookkeeping::getFirst()); } 00940 00941 SyncSourcesIterator end() 00942 { return SyncSourcesIterator(NULL); } 00943 00953 const AppDataUnit* 00954 getData(uint32 stamp, const SyncSource* src = NULL); 00955 00956 00963 bool 00964 isWaiting(const SyncSource* src = NULL) const; 00965 00972 uint32 00973 getFirstTimestamp(const SyncSource* src = NULL) const; 00974 00997 void 00998 setMinValidPacketSequence(uint8 packets) 00999 { minValidPacketSequence = packets; } 01000 01001 uint8 01002 getDefaultMinValidPacketSequence() const 01003 { return defaultMinValidPacketSequence; } 01004 01009 uint8 01010 getMinValidPacketSequence() const 01011 { return minValidPacketSequence; } 01012 01013 void 01014 setMaxPacketMisorder(uint16 packets) 01015 { maxPacketMisorder = packets; } 01016 01017 uint16 01018 getDefaultMaxPacketMisorder() const 01019 { return defaultMaxPacketMisorder; } 01020 01021 uint16 01022 getMaxPacketMisorder() const 01023 { return maxPacketMisorder; } 01024 01030 void 01031 setMaxPacketDropout(uint16 packets) // default: 3000. 01032 { maxPacketDropout = packets; } 01033 01034 uint16 01035 getDefaultMaxPacketDropout() const 01036 { return defaultMaxPacketDropout; } 01037 01038 uint16 01039 getMaxPacketDropout() const 01040 { return maxPacketDropout; } 01041 01042 // default value for constructors that allow to specify 01043 // members table s\ize 01044 inline static size_t 01045 getDefaultMembersSize() 01046 { return defaultMembersSize; } 01047 01056 void 01057 setInQueueCryptoContext(CryptoContext* cc); 01058 01069 void 01070 removeInQueueCryptoContext(CryptoContext* cc); 01071 01079 CryptoContext* 01080 getInQueueCryptoContext(uint32 ssrc); 01081 01082 protected: 01086 IncomingDataQueue(uint32 size); 01087 01088 virtual ~IncomingDataQueue() 01089 { } 01090 01103 bool checkSSRCInIncomingRTPPkt(SyncSourceLink& sourceLink, 01104 bool is_new, InetAddress& na, 01105 tpport_t tp); 01106 01122 void setSourceExpirationPeriod(uint8 intervals) 01123 { sourceExpirationPeriod = intervals; } 01124 01131 virtual size_t 01132 takeInDataPacket(); 01133 01134 void renewLocalSSRC(); 01135 01145 IncomingDataQueue::IncomingRTPPktLink* 01146 getWaiting(uint32 timestamp, const SyncSource *src = NULL); 01147 01163 bool 01164 recordReception(SyncSourceLink& srcLink, const IncomingRTPPkt& pkt, 01165 const timeval recvtime); 01166 01173 void 01174 recordExtraction(const IncomingRTPPkt& pkt); 01175 01176 void purgeIncomingQueue(); 01177 01184 inline virtual void 01185 onNewSyncSource(const SyncSource&) 01186 { } 01187 01188 protected: 01205 inline virtual bool 01206 onRTPPacketRecv(IncomingRTPPkt&) 01207 { return true; } 01208 01217 inline virtual void onExpireRecv(IncomingRTPPkt&) 01218 { return; } 01219 01233 inline virtual bool 01234 onSRTPPacketError(IncomingRTPPkt& pkt, int32 errorCode) 01235 { return false; } 01236 01237 inline virtual bool 01238 end2EndDelayed(IncomingRTPPktLink&) 01239 { return false; } 01240 01256 bool 01257 insertRecvPacket(IncomingRTPPktLink* packetLink); 01258 01270 virtual size_t 01271 recvData(unsigned char* buffer, size_t length, 01272 InetHostAddress& host, tpport_t& port) = 0; 01273 01274 virtual size_t 01275 getNextDataPacketSize() const = 0; 01276 01277 mutable ThreadLock recvLock; 01278 // reception queue 01279 IncomingRTPPktLink* recvFirst, * recvLast; 01280 // values for packet validation. 01281 static const uint8 defaultMinValidPacketSequence; 01282 static const uint16 defaultMaxPacketMisorder; 01283 static const uint16 defaultMaxPacketDropout; 01284 uint8 minValidPacketSequence; 01285 uint16 maxPacketMisorder; 01286 uint16 maxPacketDropout; 01287 static const size_t defaultMembersSize; 01288 uint8 sourceExpirationPeriod; 01289 mutable Mutex cryptoMutex; 01290 std::list<CryptoContext *> cryptoContexts; 01291 }; 01292 // iqueue 01294 01295 #ifdef CCXX_NAMESPACES 01296 } 01297 #endif 01298 01299 #endif //CCXX_RTP_IQUEUE_H_ 01300