ilabs-flir 1.0.7 → 2.0.1

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64/liblive666.dylib.framework/Headers/liveMedia/RTPSink.hh

@@ -0,0 +1,250 @@
+/**********
+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-2023 Live Networks, Inc.  All rights reserved.
+// RTP Sinks
+// C++ header
+
+#ifndef _RTP_SINK_HH
+#define _RTP_SINK_HH
+
+#ifndef _MEDIA_SINK_HH
+#include "MediaSink.hh"
+#endif
+#ifndef _RTP_INTERFACE_HH
+#include "RTPInterface.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class RTPTransmissionStatsDB; // forward
+
+class LIVEMEDIA_API RTPSink: public MediaSink {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sinkName,
+			      RTPSink*& resultSink);
+
+  // used by RTSP servers:
+  Groupsock const& groupsockBeingUsed() const { return *(fRTPInterface.gs()); }
+  Groupsock& groupsockBeingUsed() { return *(fRTPInterface.gs()); }
+
+  unsigned char rtpPayloadType() const { return fRTPPayloadType; }
+  unsigned rtpTimestampFrequency() const { return fTimestampFrequency; }
+  void setRTPTimestampFrequency(unsigned freq) {
+    fTimestampFrequency = freq;
+  }
+  char const* rtpPayloadFormatName() const {return fRTPPayloadFormatName;}
+
+  unsigned numChannels() const { return fNumChannels; }
+
+  void setupForSRTP(Boolean useEncryption);
+      // sets up keying/encryption state for streaming via SRTP, using default values.
+  u_int8_t* setupForSRTP(Boolean useEncryption, unsigned& resultMIKEYStateMessageSize);
+      // as above, but returns the binary MIKEY state
+  void setupForSRTP(u_int8_t const* MIKEYStateMessage, unsigned MIKEYStateMessageSize);
+      // as above, but takes a MIKEY state message as parameter
+
+  virtual char const* sdpMediaType() const; // for use in SDP m= lines
+  virtual char* rtpmapLine() const; // returns a string to be delete[]d
+  virtual char* keyMgmtLine(); // returns a string to be delete[]d
+  virtual char const* auxSDPLine();
+      // optional SDP line (e.g. a=fmtp:...)
+
+  u_int16_t currentSeqNo() const { return fSeqNo; }
+  u_int32_t presetNextTimestamp();
+      // ensures that the next timestamp to be used will correspond to
+      // the current 'wall clock' time.
+
+  RTPTransmissionStatsDB& transmissionStatsDB() const {
+    return *fTransmissionStatsDB;
+  }
+
+  Boolean nextTimestampHasBeenPreset() const { return fNextTimestampHasBeenPreset; }
+  Boolean& enableRTCPReports() { return fEnableRTCPReports; }
+
+  void getTotalBitrate(unsigned& outNumBytes, double& outElapsedTime);
+      // returns the number of bytes sent since the last time that we
+      // were called, and resets the counter.
+
+  struct timeval const& creationTime() const { return fCreationTime; }
+  struct timeval const& initialPresentationTime() const { return fInitialPresentationTime; }
+  struct timeval const& mostRecentPresentationTime() const { return fMostRecentPresentationTime; }
+  void resetPresentationTimes();
+
+  // Hacks to allow sending RTP over TCP (RFC 2236, section 10.12):
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState) {
+    fRTPInterface.setStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState) {
+    fRTPInterface.addStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+    fRTPInterface.removeStreamSocket(sockNum, streamChannelId);
+  }
+  unsigned& estimatedBitrate() { return fEstimatedBitrate; } // kbps; usually 0 (i.e., unset)
+
+  u_int32_t SSRC() const {return fSSRC;}
+     // later need a means of changing the SSRC if there's a collision #####
+
+  SRTPCryptographicContext* getCrypto() const { return fCrypto; }
+
+protected:
+  RTPSink(UsageEnvironment& env,
+	  Groupsock* rtpGS, unsigned char rtpPayloadType,
+	  u_int32_t rtpTimestampFrequency,
+	  char const* rtpPayloadFormatName,
+	  unsigned numChannels);
+	// abstract base class
+
+  virtual ~RTPSink();
+
+  // used by RTCP:
+  friend class RTCPInstance;
+  friend class RTPTransmissionStats;
+  u_int32_t convertToRTPTimestamp(struct timeval tv);
+  unsigned packetCount() const {return fPacketCount;}
+  unsigned octetCount() const {return fOctetCount;}
+
+protected:
+  RTPInterface fRTPInterface;
+  unsigned char fRTPPayloadType;
+  unsigned fPacketCount, fOctetCount, fTotalOctetCount /*incl RTP hdr*/;
+  struct timeval fTotalOctetCountStartTime, fInitialPresentationTime, fMostRecentPresentationTime;
+  u_int32_t fCurrentTimestamp;
+  u_int16_t fSeqNo;
+
+  // Optional key management and crypto state; used if we are streaming SRTP
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isRTPSink() const;
+
+private:
+  u_int32_t fSSRC, fTimestampBase;
+  unsigned fTimestampFrequency;
+  Boolean fNextTimestampHasBeenPreset;
+  Boolean fEnableRTCPReports; // whether RTCP "SR" reports should be sent for this sink (default: True)
+  char const* fRTPPayloadFormatName;
+  unsigned fNumChannels;
+  struct timeval fCreationTime;
+  unsigned fEstimatedBitrate; // set on creation if known; otherwise 0
+
+  RTPTransmissionStatsDB* fTransmissionStatsDB;
+};
+
+
+class RTPTransmissionStats; // forward
+
+class LIVEMEDIA_API RTPTransmissionStatsDB {
+public:
+  unsigned numReceivers() const { return fNumReceivers; }
+
+  class Iterator {
+  public:
+    Iterator(RTPTransmissionStatsDB& receptionStatsDB);
+    virtual ~Iterator();
+
+    RTPTransmissionStats* next();
+        // NULL if none
+
+  private:
+    HashTable::Iterator* fIter;
+  };
+
+  // The following is called whenever a RTCP RR packet is received:
+  void noteIncomingRR(u_int32_t SSRC, struct sockaddr_storage const& lastFromAddress,
+                      unsigned lossStats, unsigned lastPacketNumReceived,
+                      unsigned jitter, unsigned lastSRTime, unsigned diffSR_RRTime);
+
+  // The following is called when a RTCP BYE packet is received:
+  void removeRecord(u_int32_t SSRC);
+
+  RTPTransmissionStats* lookup(u_int32_t SSRC) const;
+
+private: // constructor and destructor, called only by RTPSink:
+  friend class RTPSink;
+  RTPTransmissionStatsDB(RTPSink& rtpSink);
+  virtual ~RTPTransmissionStatsDB();
+
+private:
+  void add(u_int32_t SSRC, RTPTransmissionStats* stats);
+
+private:
+  friend class Iterator;
+  unsigned fNumReceivers;
+  RTPSink& fOurRTPSink;
+  HashTable* fTable;
+};
+
+class LIVEMEDIA_API RTPTransmissionStats {
+public:
+  u_int32_t SSRC() const {return fSSRC;}
+  struct sockaddr_storage const& lastFromAddress() const {return fLastFromAddress;}
+  unsigned lastPacketNumReceived() const {return fLastPacketNumReceived;}
+  unsigned firstPacketNumReported() const {return fFirstPacketNumReported;}
+  unsigned totNumPacketsLost() const {return fTotNumPacketsLost;}
+  unsigned jitter() const {return fJitter;}
+  unsigned lastSRTime() const { return fLastSRTime; }
+  unsigned diffSR_RRTime() const { return fDiffSR_RRTime; }
+  unsigned roundTripDelay() const;
+      // The round-trip delay (in units of 1/65536 seconds) computed from
+      // the most recently-received RTCP RR packet.
+  struct timeval const& timeCreated() const {return fTimeCreated;}
+  struct timeval const& lastTimeReceived() const {return fTimeReceived;}
+  void getTotalOctetCount(u_int32_t& hi, u_int32_t& lo);
+  void getTotalPacketCount(u_int32_t& hi, u_int32_t& lo);
+
+  // Information which requires at least two RRs to have been received:
+  unsigned packetsReceivedSinceLastRR() const;
+  u_int8_t packetLossRatio() const { return fPacketLossRatio; }
+     // as an 8-bit fixed-point number
+  int packetsLostBetweenRR() const;
+
+private:
+  // called only by RTPTransmissionStatsDB:
+  friend class RTPTransmissionStatsDB;
+  RTPTransmissionStats(RTPSink& rtpSink, u_int32_t SSRC);
+  virtual ~RTPTransmissionStats();
+
+  void noteIncomingRR(struct sockaddr_storage const& lastFromAddress,
+		      unsigned lossStats, unsigned lastPacketNumReceived,
+                      unsigned jitter,
+		      unsigned lastSRTime, unsigned diffSR_RRTime);
+
+private:
+  RTPSink& fOurRTPSink;
+  u_int32_t fSSRC;
+  struct sockaddr_storage fLastFromAddress;
+  unsigned fLastPacketNumReceived;
+  u_int8_t fPacketLossRatio;
+  unsigned fTotNumPacketsLost;
+  unsigned fJitter;
+  unsigned fLastSRTime;
+  unsigned fDiffSR_RRTime;
+  struct timeval fTimeCreated, fTimeReceived;
+  Boolean fAtLeastTwoRRsHaveBeenReceived;
+  unsigned fOldLastPacketNumReceived;
+  unsigned fOldTotNumPacketsLost;
+  Boolean fFirstPacket;
+  unsigned fFirstPacketNumReported;
+  u_int32_t fLastOctetCount, fTotalOctetCount_hi, fTotalOctetCount_lo;
+  u_int32_t fLastPacketCount, fTotalPacketCount_hi, fTotalPacketCount_lo;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64/liblive666.dylib.framework/Headers/liveMedia/RTPSource.hh

@@ -0,0 +1,281 @@
+/**********
+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-2023 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 LIVEMEDIA_API 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, TLSState* tlsState) {
+    // hack to allow sending RTP over TCP (RFC 2236, section 10.12)
+    fRTPInterface.setStreamSocket(sockNum, streamChannelId, tlsState);
+  }
+
+  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; }
+
+  // Taken from: http://lists.live555.com/pipermail/live-devel/2009-April/010424.html
+  // This is used to set a callback to retrieve the RTP Header Extension data
+  typedef void (*RtpExtHdrCallback_t)(unsigned definedByProfile, unsigned char* extHdrData, unsigned extHdrDataLen, struct timeval& presentationTime, unsigned short rtpSeqNo, unsigned rtpTimestamp, bool rtpMarkerBitSet, void* pPriv);
+  void setRtpExtHdrCallback( RtpExtHdrCallback_t callback, void* pPriv ) { fRtpExtHdrCallback = callback; fRtpExtHdrCallbackPrivData = pPriv;}
+
+private: friend class MediaSubsession; // "MediaSubsession" is the only outside class that ever needs to see RTP timestamps!
+  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;
+
+  RtpExtHdrCallback_t fRtpExtHdrCallback;
+  void* fRtpExtHdrCallbackPrivData;
+
+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 LIVEMEDIA_API 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 LIVEMEDIA_API 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 LIVEMEDIA_API 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;
+};
+
+
+LIVEMEDIA_API Boolean seqNumLT(u_int16_t s1, u_int16_t s2);
+  // a 'less-than' on 16-bit sequence numbers
+
+#endif