| /********** |
| This library is free software; you can redistribute it and/or modify it under |
| the terms of the GNU Lesser General Public License as published by the |
| Free Software Foundation; either version 3 of the License, or (at your |
| option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.) |
| |
| This library 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 Lesser General Public License for |
| more details. |
| |
| You should have received a copy of the GNU Lesser General Public License |
| along with this library; if not, write to the Free Software Foundation, Inc., |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| **********/ |
| // "liveMedia" |
| // Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved. |
| // RTP Sources |
| // C++ header |
| |
| #ifndef _RTP_SOURCE_HH |
| #define _RTP_SOURCE_HH |
| |
| #ifndef _FRAMED_SOURCE_HH |
| #include "FramedSource.hh" |
| #endif |
| #ifndef _RTP_INTERFACE_HH |
| #include "RTPInterface.hh" |
| #endif |
| #ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH |
| #include "SRTPCryptographicContext.hh" |
| #endif |
| |
| class RTPReceptionStatsDB; // forward |
| |
| class RTPSource: public FramedSource { |
| public: |
| static Boolean lookupByName(UsageEnvironment& env, char const* sourceName, |
| RTPSource*& resultSource); |
| |
| Boolean curPacketMarkerBit() const { return fCurPacketMarkerBit; } |
| |
| unsigned char rtpPayloadFormat() const { return fRTPPayloadFormat; } |
| |
| virtual Boolean hasBeenSynchronizedUsingRTCP(); |
| |
| Groupsock* RTPgs() const { return fRTPInterface.gs(); } |
| |
| virtual void setPacketReorderingThresholdTime(unsigned uSeconds) = 0; |
| |
| void setCrypto(SRTPCryptographicContext* crypto) { fCrypto = crypto; } |
| |
| // used by RTCP: |
| u_int32_t SSRC() const { return fSSRC; } |
| // Note: This is *our* SSRC, not the SSRC in incoming RTP packets. |
| // later need a means of changing the SSRC if there's a collision ##### |
| void registerForMultiplexedRTCPPackets(class RTCPInstance* rtcpInstance) { |
| fRTCPInstanceForMultiplexedRTCPPackets = rtcpInstance; |
| } |
| void deregisterForMultiplexedRTCPPackets() { registerForMultiplexedRTCPPackets(NULL); } |
| |
| unsigned timestampFrequency() const {return fTimestampFrequency;} |
| |
| RTPReceptionStatsDB& receptionStatsDB() const { |
| return *fReceptionStatsDB; |
| } |
| |
| u_int32_t lastReceivedSSRC() const { return fLastReceivedSSRC; } |
| // Note: This is the SSRC in the most recently received RTP packet; not *our* SSRC |
| |
| Boolean& enableRTCPReports() { return fEnableRTCPReports; } |
| Boolean const& enableRTCPReports() const { return fEnableRTCPReports; } |
| |
| void setStreamSocket(int sockNum, unsigned char streamChannelId) { |
| // hack to allow sending RTP over TCP (RFC 2236, section 10.12) |
| fRTPInterface.setStreamSocket(sockNum, streamChannelId); |
| } |
| |
| void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc, |
| void* handlerClientData) { |
| fRTPInterface.setAuxilliaryReadHandler(handlerFunc, |
| handlerClientData); |
| } |
| |
| // Note that RTP receivers will usually not need to call either of the following two functions, because |
| // RTP sequence numbers and timestamps are usually not useful to receivers. |
| // (Our implementation of RTP reception already does all needed handling of RTP sequence numbers and timestamps.) |
| u_int16_t curPacketRTPSeqNum() const { return fCurPacketRTPSeqNum; } |
| u_int32_t curPacketRTPTimestamp() const { return fCurPacketRTPTimestamp; } |
| |
| protected: |
| RTPSource(UsageEnvironment& env, Groupsock* RTPgs, |
| unsigned char rtpPayloadFormat, u_int32_t rtpTimestampFrequency); |
| // abstract base class |
| virtual ~RTPSource(); |
| |
| protected: |
| RTPInterface fRTPInterface; |
| u_int16_t fCurPacketRTPSeqNum; |
| u_int32_t fCurPacketRTPTimestamp; |
| Boolean fCurPacketMarkerBit; |
| Boolean fCurPacketHasBeenSynchronizedUsingRTCP; |
| u_int32_t fLastReceivedSSRC; |
| class RTCPInstance* fRTCPInstanceForMultiplexedRTCPPackets; |
| SRTPCryptographicContext* fCrypto; |
| |
| private: |
| // redefined virtual functions: |
| virtual Boolean isRTPSource() const; |
| virtual void getAttributes() const; |
| |
| private: |
| unsigned char fRTPPayloadFormat; |
| unsigned fTimestampFrequency; |
| u_int32_t fSSRC; |
| Boolean fEnableRTCPReports; // whether RTCP "RR" reports should be sent for this source (default: True) |
| |
| RTPReceptionStatsDB* fReceptionStatsDB; |
| }; |
| |
| |
| class RTPReceptionStats; // forward |
| |
| class RTPReceptionStatsDB { |
| public: |
| unsigned totNumPacketsReceived() const { return fTotNumPacketsReceived; } |
| unsigned numActiveSourcesSinceLastReset() const { |
| return fNumActiveSourcesSinceLastReset; |
| } |
| |
| void reset(); |
| // resets periodic stats (called each time they're used to |
| // generate a reception report) |
| |
| class Iterator { |
| public: |
| Iterator(RTPReceptionStatsDB& receptionStatsDB); |
| virtual ~Iterator(); |
| |
| RTPReceptionStats* next(Boolean includeInactiveSources = False); |
| // NULL if none |
| |
| private: |
| HashTable::Iterator* fIter; |
| }; |
| |
| // The following is called whenever a RTP packet is received: |
| void noteIncomingPacket(u_int32_t SSRC, u_int16_t seqNum, |
| u_int32_t rtpTimestamp, |
| unsigned timestampFrequency, |
| Boolean useForJitterCalculation, |
| struct timeval& resultPresentationTime, |
| Boolean& resultHasBeenSyncedUsingRTCP, |
| unsigned packetSize /* payload only */); |
| |
| // The following is called whenever a RTCP SR packet is received: |
| void noteIncomingSR(u_int32_t SSRC, |
| u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW, |
| u_int32_t rtpTimestamp); |
| |
| // The following is called when a RTCP BYE packet is received: |
| void removeRecord(u_int32_t SSRC); |
| |
| RTPReceptionStats* lookup(u_int32_t SSRC) const; |
| |
| protected: // constructor and destructor, called only by RTPSource: |
| friend class RTPSource; |
| RTPReceptionStatsDB(); |
| virtual ~RTPReceptionStatsDB(); |
| |
| protected: |
| void add(u_int32_t SSRC, RTPReceptionStats* stats); |
| |
| protected: |
| friend class Iterator; |
| unsigned fNumActiveSourcesSinceLastReset; |
| |
| private: |
| HashTable* fTable; |
| unsigned fTotNumPacketsReceived; // for all SSRCs |
| }; |
| |
| class RTPReceptionStats { |
| public: |
| u_int32_t SSRC() const { return fSSRC; } |
| unsigned numPacketsReceivedSinceLastReset() const { |
| return fNumPacketsReceivedSinceLastReset; |
| } |
| unsigned totNumPacketsReceived() const { return fTotNumPacketsReceived; } |
| double totNumKBytesReceived() const; |
| |
| unsigned totNumPacketsExpected() const { |
| return (fHighestExtSeqNumReceived - fBaseExtSeqNumReceived) + 1; |
| } |
| |
| unsigned baseExtSeqNumReceived() const { return fBaseExtSeqNumReceived; } |
| unsigned lastResetExtSeqNumReceived() const { |
| return fLastResetExtSeqNumReceived; |
| } |
| unsigned highestExtSeqNumReceived() const { |
| return fHighestExtSeqNumReceived; |
| } |
| |
| unsigned jitter() const; |
| |
| unsigned lastReceivedSR_NTPmsw() const { return fLastReceivedSR_NTPmsw; } |
| unsigned lastReceivedSR_NTPlsw() const { return fLastReceivedSR_NTPlsw; } |
| struct timeval const& lastReceivedSR_time() const { |
| return fLastReceivedSR_time; |
| } |
| |
| unsigned minInterPacketGapUS() const { return fMinInterPacketGapUS; } |
| unsigned maxInterPacketGapUS() const { return fMaxInterPacketGapUS; } |
| struct timeval const& totalInterPacketGaps() const { |
| return fTotalInterPacketGaps; |
| } |
| |
| protected: |
| // called only by RTPReceptionStatsDB: |
| friend class RTPReceptionStatsDB; |
| RTPReceptionStats(u_int32_t SSRC, u_int16_t initialSeqNum); |
| RTPReceptionStats(u_int32_t SSRC); |
| virtual ~RTPReceptionStats(); |
| |
| private: |
| void noteIncomingPacket(u_int16_t seqNum, u_int32_t rtpTimestamp, |
| unsigned timestampFrequency, |
| Boolean useForJitterCalculation, |
| struct timeval& resultPresentationTime, |
| Boolean& resultHasBeenSyncedUsingRTCP, |
| unsigned packetSize /* payload only */); |
| void noteIncomingSR(u_int32_t ntpTimestampMSW, u_int32_t ntpTimestampLSW, |
| u_int32_t rtpTimestamp); |
| void init(u_int32_t SSRC); |
| void initSeqNum(u_int16_t initialSeqNum); |
| void reset(); |
| // resets periodic stats (called each time they're used to |
| // generate a reception report) |
| |
| protected: |
| u_int32_t fSSRC; |
| unsigned fNumPacketsReceivedSinceLastReset; |
| unsigned fTotNumPacketsReceived; |
| u_int32_t fTotBytesReceived_hi, fTotBytesReceived_lo; |
| Boolean fHaveSeenInitialSequenceNumber; |
| unsigned fBaseExtSeqNumReceived; |
| unsigned fLastResetExtSeqNumReceived; |
| unsigned fHighestExtSeqNumReceived; |
| int fLastTransit; // used in the jitter calculation |
| u_int32_t fPreviousPacketRTPTimestamp; |
| double fJitter; |
| // The following are recorded whenever we receive a RTCP SR for this SSRC: |
| unsigned fLastReceivedSR_NTPmsw; // NTP timestamp (from SR), most-signif |
| unsigned fLastReceivedSR_NTPlsw; // NTP timestamp (from SR), least-signif |
| struct timeval fLastReceivedSR_time; |
| struct timeval fLastPacketReceptionTime; |
| unsigned fMinInterPacketGapUS, fMaxInterPacketGapUS; |
| struct timeval fTotalInterPacketGaps; |
| |
| private: |
| // Used to convert from RTP timestamp to 'wall clock' time: |
| Boolean fHasBeenSynchronized; |
| u_int32_t fSyncTimestamp; |
| struct timeval fSyncTime; |
| }; |
| |
| |
| Boolean seqNumLT(u_int16_t s1, u_int16_t s2); |
| // a 'less-than' on 16-bit sequence numbers |
| |
| #endif |