ccRTP
|
00001 // Copyright (C) 2001-2015 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 Lesser General Public License 00014 // along with GNU ccRTP. If not, see <http://www.gnu.org/licenses/>. 00015 // 00016 // As a special exception, you may use this file as part of a free software 00017 // library without restriction. Specifically, if other files instantiate 00018 // templates or use macros or inline functions from this file, or you compile 00019 // this file and link it with other files to produce an executable, this 00020 // file does not by itself cause the resulting executable to be covered by 00021 // the GNU General Public License. This exception does not however 00022 // invalidate any other reasons why the executable file might be covered by 00023 // the GNU General Public License. 00024 // 00025 // This exception applies only to the code released under the name GNU 00026 // ccRTP. If you copy code from other releases into a copy of GNU 00027 // ccRTP, as the General Public License permits, the exception does 00028 // not apply to the code that you add in this way. To avoid misleading 00029 // anyone as to the status of such modified files, you must delete 00030 // this exception notice from them. 00031 // 00032 // If you write modifications of your own for GNU ccRTP, it is your choice 00033 // whether to permit this exception to apply to your modifications. 00034 // If you do not wish that, delete this exception notice. 00035 // 00036 00043 #ifndef CCXX_RTP_IQUEUE_H_ 00044 #define CCXX_RTP_IQUEUE_H_ 00045 00046 #include <ccrtp/queuebase.h> 00047 #include <ccrtp/CryptoContext.h> 00048 00049 #include <list> 00050 00051 NAMESPACE_COMMONCPP 00052 00067 class __EXPORT Members 00068 { 00069 public: 00070 inline void 00071 setMembersCount(uint32 n) 00072 { members = n; } 00073 00074 inline void 00075 increaseMembersCount() 00076 { members++; } 00077 00078 inline void 00079 decreaseMembersCount() 00080 { members--; } 00081 00082 inline uint32 00083 getMembersCount() const 00084 { return members; } 00085 00086 inline void 00087 setSendersCount(uint32 n) 00088 { activeSenders = n; } 00089 00090 inline void 00091 increaseSendersCount() 00092 { activeSenders++; } 00093 00094 inline void 00095 decreaseSendersCount() 00096 { activeSenders--; } 00097 00098 inline uint32 00099 getSendersCount() const 00100 { return activeSenders; } 00101 00102 protected: 00103 Members() : 00104 members(0), 00105 activeSenders(0) 00106 { } 00107 00108 inline virtual ~Members() 00109 { } 00110 00111 private: 00113 uint32 members; 00115 uint32 activeSenders; 00116 }; 00117 00124 class __EXPORT SyncSourceHandler 00125 { 00126 public: 00133 inline void* 00134 getLink(const SyncSource& source) const 00135 { return source.getLink(); } 00136 00137 inline void 00138 setLink(SyncSource& source, void* link) 00139 { source.setLink(link); } 00140 00141 inline void 00142 setParticipant(SyncSource& source, Participant& p) 00143 { source.setParticipant(p); } 00144 00145 inline void 00146 setState(SyncSource& source, SyncSource::State ns) 00147 { source.setState(ns); } 00148 00149 inline void 00150 setSender(SyncSource& source, bool active) 00151 { source.setSender(active); } 00152 00153 inline void 00154 setDataTransportPort(SyncSource& source, tpport_t p) 00155 { source.setDataTransportPort(p); } 00156 00157 inline void 00158 setControlTransportPort(SyncSource& source, tpport_t p) 00159 { source.setControlTransportPort(p); } 00160 00161 inline void 00162 setNetworkAddress(SyncSource& source, InetAddress addr) 00163 { source.setNetworkAddress(addr); } 00164 00165 protected: 00166 SyncSourceHandler() 00167 { } 00168 00169 inline virtual ~SyncSourceHandler() 00170 { } 00171 }; 00172 00179 class __EXPORT ParticipantHandler 00180 { 00181 public: 00182 inline void 00183 setSDESItem(Participant* part, SDESItemType item, 00184 const std::string& val) 00185 { part->setSDESItem(item,val); } 00186 00187 inline void 00188 setPRIVPrefix(Participant* part, const std::string val) 00189 { part->setPRIVPrefix(val); } 00190 00191 protected: 00192 ParticipantHandler() 00193 { } 00194 00195 inline virtual ~ParticipantHandler() 00196 { } 00197 }; 00198 00205 class __EXPORT ApplicationHandler 00206 { 00207 public: 00208 inline void 00209 addParticipant(RTPApplication& app, Participant& part) 00210 { app.addParticipant(part); } 00211 00212 inline void 00213 removeParticipant(RTPApplication& app, 00214 RTPApplication::ParticipantLink* pl) 00215 { app.removeParticipant(pl); } 00216 00217 protected: 00218 ApplicationHandler() 00219 { } 00220 00221 inline virtual ~ApplicationHandler() 00222 { } 00223 }; 00224 00232 class __EXPORT ConflictHandler 00233 { 00234 public: 00235 struct ConflictingTransportAddress 00236 { 00237 ConflictingTransportAddress(InetAddress na, 00238 tpport_t dtp, tpport_t ctp); 00239 00240 void setNext(ConflictingTransportAddress* nc) 00241 { next = nc; } 00242 00243 inline const InetAddress& getNetworkAddress( ) const 00244 { return networkAddress; } 00245 00246 inline tpport_t getDataTransportPort() const 00247 { return dataTransportPort; } 00248 00249 inline tpport_t getControlTransportPort() const 00250 { return controlTransportPort; } 00251 00252 InetAddress networkAddress; 00253 tpport_t dataTransportPort; 00254 tpport_t controlTransportPort; 00255 ConflictingTransportAddress* next; 00256 // arrival time of last data or control packet. 00257 timeval lastPacketTime; 00258 }; 00259 00264 ConflictingTransportAddress* searchDataConflict(InetAddress na, 00265 tpport_t dtp); 00270 ConflictingTransportAddress* searchControlConflict(InetAddress na, 00271 tpport_t ctp); 00272 00273 void updateConflict(ConflictingTransportAddress& ca) 00274 { SysTime::gettimeofday(&(ca.lastPacketTime),NULL); } 00275 00276 void addConflict(const InetAddress& na, tpport_t dtp, tpport_t ctp); 00277 00278 protected: 00279 ConflictHandler() 00280 { firstConflict = lastConflict = NULL; } 00281 00282 inline virtual ~ConflictHandler() 00283 { } 00284 00285 ConflictingTransportAddress* firstConflict, * lastConflict; 00286 }; 00287 00298 class __EXPORT MembershipBookkeeping : 00299 public SyncSourceHandler, 00300 public ParticipantHandler, 00301 public ApplicationHandler, 00302 public ConflictHandler, 00303 private Members 00304 { 00305 public: 00306 inline size_t getDefaultMembersHashSize() 00307 { return defaultMembersHashSize; } 00308 00309 protected: 00310 00324 MembershipBookkeeping(uint32 initialSize = defaultMembersHashSize); 00325 00330 inline virtual 00331 ~MembershipBookkeeping() 00332 { endMembers(); } 00333 00334 struct SyncSourceLink; 00335 00336 inline SyncSourceLink* getLink(const SyncSource& source) const 00337 { return static_cast<SyncSourceLink*>(SyncSourceHandler::getLink(source)); } 00342 inline bool isMine(const SyncSource& source) const 00343 { return getLink(source)->getMembership() == this; } 00344 00351 struct IncomingRTPPktLink 00352 { 00353 IncomingRTPPktLink(IncomingRTPPkt* pkt, SyncSourceLink* sLink, 00354 struct timeval& recv_ts, 00355 uint32 shifted_ts, 00356 IncomingRTPPktLink* sp, 00357 IncomingRTPPktLink* sn, 00358 IncomingRTPPktLink* p, 00359 IncomingRTPPktLink* n) : 00360 packet(pkt), 00361 sourceLink(sLink), 00362 prev(p), next(n), 00363 srcPrev(sp), srcNext(sn), 00364 receptionTime(recv_ts), 00365 shiftedTimestamp(shifted_ts) 00366 { } 00367 00368 ~IncomingRTPPktLink() 00369 { } 00370 00371 inline SyncSourceLink* getSourceLink() const 00372 { return sourceLink; } 00373 00374 inline void setSourceLink(SyncSourceLink* src) 00375 { sourceLink = src; } 00376 00377 inline IncomingRTPPktLink* getNext() const 00378 { return next; } 00379 00380 inline void setNext(IncomingRTPPktLink* nl) 00381 { next = nl; } 00382 00383 inline IncomingRTPPktLink* getPrev() const 00384 { return prev; } 00385 00386 inline void setPrev(IncomingRTPPktLink* pl) 00387 { prev = pl; } 00388 00389 inline IncomingRTPPktLink* getSrcNext() const 00390 { return srcNext; } 00391 00392 inline void setSrcNext(IncomingRTPPktLink* sn) 00393 { srcNext = sn; } 00394 00395 inline IncomingRTPPktLink* getSrcPrev() const 00396 { return srcPrev; } 00397 00398 inline void setSrcPrev(IncomingRTPPktLink* sp) 00399 { srcPrev = sp; } 00400 00401 inline IncomingRTPPkt* getPacket() const 00402 { return packet; } 00403 00404 inline void setPacket(IncomingRTPPkt* pkt) 00405 { packet = pkt; } 00406 00414 inline void setRecvTime(const timeval &t) 00415 { receptionTime = t; } 00416 00420 inline timeval getRecvTime() const 00421 { return receptionTime; } 00422 00431 inline uint32 getTimestamp() const 00432 { return shiftedTimestamp; } 00433 00434 inline void setTimestamp(uint32 ts) 00435 { shiftedTimestamp = ts;} 00436 00437 // the packet this link refers to. 00438 IncomingRTPPkt* packet; 00439 // the synchronization source this packet comes from. 00440 SyncSourceLink* sourceLink; 00441 // global incoming packet queue links. 00442 IncomingRTPPktLink* prev, * next; 00443 // source specific incoming packet queue links. 00444 IncomingRTPPktLink* srcPrev, * srcNext; 00445 // time this packet was received at 00446 struct timeval receptionTime; 00447 // timestamp of the packet in host order and after 00448 // substracting the initial timestamp for its source 00449 // (it is an increment from the initial timestamp). 00450 uint32 shiftedTimestamp; 00451 }; 00452 00469 struct SyncSourceLink 00470 { 00471 // 2^16 00472 static const uint32 SEQNUMMOD; 00473 00474 SyncSourceLink(MembershipBookkeeping* m, 00475 SyncSource* s, 00476 IncomingRTPPktLink* fp = NULL, 00477 IncomingRTPPktLink* lp = NULL, 00478 SyncSourceLink* ps = NULL, 00479 SyncSourceLink* ns = NULL, 00480 SyncSourceLink* ncollis = NULL) : 00481 membership(m), source(s), first(fp), last(lp), 00482 prev(ps), next(ns), nextCollis(ncollis), 00483 prevConflict(NULL) 00484 { m->setLink(*s,this); // record that the source is associated 00485 initStats(); // to this link. 00486 } 00487 00491 ~SyncSourceLink(); 00492 00493 inline MembershipBookkeeping* getMembership() 00494 { return membership; } 00495 00500 inline SyncSource* getSource() { return source; } 00501 00506 inline IncomingRTPPktLink* getFirst() 00507 { return first; } 00508 00509 inline void setFirst(IncomingRTPPktLink* fp) 00510 { first = fp; } 00511 00516 inline IncomingRTPPktLink* getLast() 00517 { return last; } 00518 00519 inline void setLast(IncomingRTPPktLink* lp) 00520 { last = lp; } 00521 00525 inline SyncSourceLink* getPrev() 00526 { return prev; } 00527 00528 inline void setPrev(SyncSourceLink* ps) 00529 { prev = ps; } 00530 00534 inline SyncSourceLink* getNext() 00535 { return next; } 00536 00537 inline void setNext(SyncSourceLink *ns) 00538 { next = ns; } 00539 00546 inline SyncSourceLink* getNextCollis() 00547 { return nextCollis; } 00548 00549 inline void setNextCollis(SyncSourceLink* ns) 00550 { nextCollis = ns; } 00551 00552 inline ConflictingTransportAddress* getPrevConflict() const 00553 { return prevConflict; } 00554 00558 void setPrevConflict(InetAddress& addr, tpport_t dataPort, 00559 tpport_t controlPort); 00560 00561 unsigned char* getSenderInfo() 00562 { return senderInfo; } 00563 00564 void setSenderInfo(unsigned char* si); 00565 00566 unsigned char* getReceiverInfo() 00567 { return receiverInfo; } 00568 00569 void setReceiverInfo(unsigned char* ri); 00570 00571 inline timeval getLastPacketTime() const 00572 { return lastPacketTime; } 00573 00574 inline timeval getLastRTCPPacketTime() const 00575 { return lastRTCPPacketTime; } 00576 00577 inline timeval getLastRTCPSRTime() const 00578 { return lastRTCPSRTime; } 00579 00584 inline uint32 getObservedPacketCount() const 00585 { return obsPacketCount; } 00586 00587 inline void incObservedPacketCount() 00588 { obsPacketCount++; } 00589 00594 inline uint32 getObservedOctetCount() const 00595 { return obsOctetCount; } 00596 00597 inline void incObservedOctetCount(uint32 n) 00598 { obsOctetCount += n; } 00599 00603 uint16 00604 getMaxSeqNum() const 00605 { return maxSeqNum; } 00606 00611 void 00612 setMaxSeqNum(uint16 max) 00613 { maxSeqNum = max; } 00614 00615 inline uint32 00616 getExtendedMaxSeqNum() const 00617 { return extendedMaxSeqNum; } 00618 00619 inline void 00620 setExtendedMaxSeqNum(uint32 seq) 00621 { extendedMaxSeqNum = seq; } 00622 00623 inline uint32 getCumulativePacketLost() const 00624 { return cumulativePacketLost; } 00625 00626 inline void setCumulativePacketLost(uint32 pl) 00627 { cumulativePacketLost = pl; } 00628 00629 inline uint8 getFractionLost() const 00630 { return fractionLost; } 00631 00632 inline void setFractionLost(uint8 fl) 00633 { fractionLost = fl; } 00634 00635 inline uint32 getLastPacketTransitTime() 00636 { return lastPacketTransitTime; } 00637 00638 inline void setLastPacketTransitTime(uint32 time) 00639 { lastPacketTransitTime = time; } 00640 00641 inline float getJitter() const 00642 { return jitter; } 00643 00644 inline void setJitter(float j) 00645 { jitter = j; } 00646 00647 inline uint32 getInitialDataTimestamp() const 00648 { return initialDataTimestamp; } 00649 00650 inline void setInitialDataTimestamp(uint32 ts) 00651 { initialDataTimestamp = ts; } 00652 00653 inline timeval getInitialDataTime() const 00654 { return initialDataTime; } 00655 00656 inline void setInitialDataTime(timeval it) 00657 { initialDataTime = it; } 00658 00666 bool getGoodbye() 00667 { 00668 if(!flag) 00669 return false; 00670 flag = false; 00671 return true; 00672 } 00673 00680 bool getHello() { 00681 if(flag) 00682 return false; 00683 flag = true; 00684 return true; 00685 } 00686 00687 inline uint32 getBadSeqNum() const 00688 { return badSeqNum; } 00689 00690 inline void setBadSeqNum(uint32 seq) 00691 { badSeqNum = seq; } 00692 00693 uint8 getProbation() const 00694 { return probation; } 00695 00696 inline void setProbation(uint8 p) 00697 { probation = p; } 00698 00699 inline void decProbation() 00700 { --probation; } 00701 00702 bool isValid() const 00703 { return 0 == probation; } 00704 00705 inline uint16 getBaseSeqNum() const 00706 { return baseSeqNum; } 00707 00708 inline void setBaseSeqNum(uint16 seqnum) 00709 { baseSeqNum = seqnum; } 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 std::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 END_NAMESPACE 01296 01297 #endif //CCXX_RTP_IQUEUE_H_ 01298