ilabs-flir 1.0.7 → 2.0.1

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

@@ -0,0 +1,50 @@
+/**********
+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.
+// Demultiplexer for a MPEG Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_DEMUX_HH
+#define _MPEG2_TRANSPORT_STREAM_DEMUX_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class MPEG2TransportStreamDemux: public Medium {
+public:
+  static MPEG2TransportStreamDemux* createNew(UsageEnvironment& env,
+					      FramedSource* inputSource,
+					      FramedSource::onCloseFunc* onCloseFunc,
+					      void* onCloseClientData);
+
+private:
+  MPEG2TransportStreamDemux(UsageEnvironment& env, FramedSource* inputSource,
+			    FramedSource::onCloseFunc* onCloseFunc, void* onCloseClientData);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamDemux();
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+private:
+  class MPEG2TransportStreamParser* fParser;
+  FramedSource::onCloseFunc* fOnCloseFunc;
+  void* fOnCloseClientData;
+};
+
+#endif

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

@@ -0,0 +1,78 @@
+/**********
+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.
+// A filter that passes through (unchanged) chunks that contain an integral number
+// of MPEG-2 Transport Stream packets, but returning (in "fDurationInMicroseconds")
+// an updated estimate of the time gap between chunks.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FRAMER_HH
+#define _MPEG2_TRANSPORT_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class LIVEMEDIA_API MPEG2TransportStreamFramer: public FramedFilter {
+public:
+  static MPEG2TransportStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+  u_int64_t tsPacketCount() const { return fTSPacketCount; }
+
+  void changeInputSource(FramedSource* newInputSource) { fInputSource = newInputSource; }
+
+  void clearPIDStatusTable();
+  void setNumTSPacketsToStream(unsigned long numTSRecordsToStream);
+  void setPCRLimit(float pcrLimit);
+
+protected:
+  MPEG2TransportStreamFramer(UsageEnvironment& env, FramedSource* inputSource);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFramer();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  struct timeval presentationTime);
+
+  Boolean updateTSPacketDurationEstimate(unsigned char* pkt, double timeNow);
+
+private:
+  u_int64_t fTSPacketCount;
+  double fTSPacketDurationEstimate;
+  HashTable* fPIDStatusTable;
+  u_int64_t fTSPCRCount;
+  Boolean fLimitNumTSPacketsToStream;
+  unsigned long fNumTSPacketsToStream; // used iff "fLimitNumTSPacketsToStream" is True
+  Boolean fLimitTSPacketsToStreamByPCR;
+  float fPCRLimit; // used iff "fLimitTSPacketsToStreamByPCR" is True
+};
+
+#endif

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

@@ -0,0 +1,66 @@
+/**********
+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.
+// A filter for converting one or more MPEG Elementary Streams
+// to a MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH
+#define _MPEG2_TRANSPORT_STREAM_FROM_ES_SOURCE_HH
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#include "MPEG2TransportStreamMultiplexor.hh"
+#endif
+
+class LIVEMEDIA_API MPEG2TransportStreamFromESSource: public MPEG2TransportStreamMultiplexor {
+public:
+  static MPEG2TransportStreamFromESSource* createNew(UsageEnvironment& env);
+
+  void addNewVideoSource(FramedSource* inputSource, int mpegVersion, int16_t PID = -1);
+      // Note: For MPEG-4 video, set "mpegVersion" to 4; for H.264 video, set "mpegVersion" to 5;
+      //     for H.265 video, set "mpegVersion" to 6
+  void addNewAudioSource(FramedSource* inputSource, int mpegVersion, int16_t PID = -1);
+      // Note: For Opus audio, set "mpegVersion" to 3
+  
+      // Note: In these functions, if "PID" is not -1, then it (currently, just the low 8 bits)
+      // is used as the stream's PID.  Otherwise (if "PID" is -1) the 'stream_id' is used as
+      // the PID.
+
+  static unsigned maxInputESFrameSize;
+
+protected:
+  MPEG2TransportStreamFromESSource(UsageEnvironment& env);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFromESSource();
+
+  void addNewInputSource(FramedSource* inputSource,
+			 u_int8_t streamId, int mpegVersion, int16_t PID = -1);
+  // used to implement addNew*Source() above
+
+private:
+  // Redefined virtual functions:
+  virtual void doStopGettingFrames();
+  virtual void awaitNewBuffer(unsigned char* oldBuffer);
+
+private:
+  friend class InputESSourceRecord;
+  class InputESSourceRecord* fInputSources;
+  unsigned fVideoSourceCounter, fAudioSourceCounter;
+  Boolean fAwaitingBackgroundDelivery;
+};
+
+#endif

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

@@ -0,0 +1,62 @@
+/**********
+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.
+// A filter for converting a stream of MPEG PES packets to a MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_FROM_PES_SOURCE_HH
+#define _MPEG2_TRANSPORT_STREAM_FROM_PES_SOURCE_HH
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#include "MPEG2TransportStreamMultiplexor.hh"
+#endif
+#ifndef _MPEG_1OR2_DEMUXED_ELEMENTARY_STREAM_HH
+#include "MPEG1or2DemuxedElementaryStream.hh"
+#endif
+
+class LIVEMEDIA_API MPEG2TransportStreamFromPESSource: public MPEG2TransportStreamMultiplexor {
+public:
+  static MPEG2TransportStreamFromPESSource*
+  createNew(UsageEnvironment& env, MPEG1or2DemuxedElementaryStream* inputSource);
+
+protected:
+  MPEG2TransportStreamFromPESSource(UsageEnvironment& env,
+				    MPEG1or2DemuxedElementaryStream* inputSource);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamFromPESSource();
+
+private:
+  // Redefined virtual functions:
+  virtual void doStopGettingFrames();
+  virtual void awaitNewBuffer(unsigned char* oldBuffer);
+
+private:
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize,
+			  unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+
+private:
+  MPEG1or2DemuxedElementaryStream* fInputSource;
+  unsigned char* fInputBuffer;
+};
+
+#endif

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

@@ -0,0 +1,96 @@
+/**********
+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.
+// A class that encapsulates MPEG-2 Transport Stream 'index files'/
+// These index files are used to implement 'trick play' operations
+// (seek-by-time, fast forward, reverse play) on Transport Stream files.
+//
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+#define _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+
+#define INDEX_RECORD_SIZE 11
+
+class LIVEMEDIA_API MPEG2TransportStreamIndexFile: public Medium {
+public:
+  static MPEG2TransportStreamIndexFile* createNew(UsageEnvironment& env,
+						  char const* indexFileName);
+
+  virtual ~MPEG2TransportStreamIndexFile();
+
+  // Functions that map between a playing time and a Transport packet number
+  // in the original Transport Stream file:
+
+  void lookupTSPacketNumFromNPT(float& npt, unsigned long& tsPacketNumber,
+			    unsigned long& indexRecordNumber);
+    // Looks up the Transport Stream Packet number corresponding to "npt".
+	// (This may modify "npt" to a more exact value.)
+        // (We also return the index record number that we looked up.)
+
+  void lookupPCRFromTSPacketNum(unsigned long& tsPacketNumber, Boolean reverseToPreviousCleanPoint,
+				float& pcr, unsigned long& indexRecordNumber);
+    // Looks up the PCR timestamp for the transport packet "tsPacketNumber".
+	// (Adjust "tsPacketNumber" only if "reverseToPreviousCleanPoint" is True.)
+        // (We also return the index record number that we looked up.)
+
+  // Miscellaneous functions used to implement 'trick play':
+  Boolean readIndexRecordValues(unsigned long indexRecordNum,
+				unsigned long& transportPacketNum, u_int8_t& offset,
+				u_int8_t& size, float& pcr, u_int8_t& recordType);
+  float getPlayingDuration();
+  void stopReading() { closeFid(); }
+
+  int mpegVersion();
+      // returns the best guess for the version of MPEG being used for data within the underlying Transport Stream file.
+      // (1,2,4, or 5 (representing H.264).  0 means 'don't know' (usually because the index file is empty))
+
+private:
+  MPEG2TransportStreamIndexFile(UsageEnvironment& env, char const* indexFileName);
+
+  Boolean openFid();
+  Boolean seekToIndexRecord(unsigned long indexRecordNumber);
+  Boolean readIndexRecord(unsigned long indexRecordNum); // into "fBuf"
+  Boolean readOneIndexRecord(unsigned long indexRecordNum); // closes "fFid" at end
+  void closeFid();
+
+  u_int8_t recordTypeFromBuf() { return fBuf[0]; }
+  u_int8_t offsetFromBuf() { return fBuf[1]; }
+  u_int8_t sizeFromBuf() { return fBuf[2]; }
+  float pcrFromBuf(); // after "fBuf" has been read
+  unsigned long tsPacketNumFromBuf();
+  void setMPEGVersionFromRecordType(u_int8_t recordType);
+
+  Boolean rewindToCleanPoint(unsigned long&ixFound);
+      // used to implement "lookupTSPacketNumber()"
+
+private:
+  char* fFileName;
+  FILE* fFid; // used internally when reading from the file
+  int fMPEGVersion;
+  unsigned long fCurrentIndexRecordNum; // within "fFid"
+  float fCachedPCR;
+  unsigned long fCachedTSPacketNumber, fCachedIndexRecordNumber;
+  unsigned long fNumIndexRecords;
+  unsigned char fBuf[INDEX_RECORD_SIZE]; // used for reading index records from file
+};
+
+#endif

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

@@ -0,0 +1,120 @@
+/**********
+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.
+// A class for generating MPEG-2 Transport Stream from one or more input
+// Elementary Stream data sources
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+#define _MPEG2_TRANSPORT_STREAM_MULTIPLEXOR_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+#ifndef _MPEG_1OR2_DEMUX_HH
+#include "MPEG1or2Demux.hh" // for SCR
+#endif
+
+#define PID_TABLE_SIZE 0x2000 // 2^13
+
+class LIVEMEDIA_API MPEG2TransportStreamMultiplexor: public FramedSource {
+public:
+  typedef void (onEndOfSegmentFunc)(void* clientData, double segmentDuration);
+  void setTimedSegmentation(unsigned segmentationDuration,
+			    onEndOfSegmentFunc* onEndOfSegmentFunc = NULL,
+			    void* onEndOfSegmentClientData = NULL);
+      // Specifies that PAT and PMT packets should be output every "segmentationDuration" seconds.
+      // (If "segmentationDuration" is 0 (the default value), then PAT and PMT packets are output
+      // at a preset frequency.)
+      // The optional function "onEndOfSegmentFunc" is called after each segment is output.
+  double currentSegmentDuration() const { return fCurrentSegmentDuration; }
+      // Valid only if "setTimedSegmentation()" was previously called with "segmentationDuration" > 0
+
+  Boolean canDeliverNewFrameImmediately() const { return fInputBufferBytesUsed < fInputBufferSize; }
+      // Can be used by a downstream reader to test whether the next call to "doGetNextFrame()"
+      // will deliver data immediately).
+
+protected:
+  MPEG2TransportStreamMultiplexor(UsageEnvironment& env);
+  virtual ~MPEG2TransportStreamMultiplexor();
+
+  virtual void awaitNewBuffer(unsigned char* oldBuffer) = 0;
+      // implemented by subclasses
+
+  void handleNewBuffer(unsigned char* buffer, unsigned bufferSize,
+		       int mpegVersion, MPEG1or2Demux::SCR scr, int16_t PID = -1);
+      // called by "awaitNewBuffer()"
+      // Note: For MPEG-4 video, set "mpegVersion" to 4; for H.264 video, set "mpegVersion" to 5;
+      //     for H.265 video, set "mpegVersion" to 6.
+      //     For Opus audio, set "mpegVersion" to 3.
+      // The buffer is assumed to be a PES packet, with a proper PES header.
+      // If "PID" is not -1, then it (currently, only the low 8 bits) is used as the stream's PID,
+      // otherwise the "stream_id" in the PES header is reused to be the stream's PID.
+
+private:
+  // Redefined virtual functions:
+  virtual Boolean isMPEG2TransportStreamMultiplexor() const;
+  virtual void doGetNextFrame();
+
+private:
+  void deliverDataToClient(u_int16_t pid, unsigned char* buffer, unsigned bufferSize,
+			   unsigned& startPositionInBuffer);
+
+  void deliverPATPacket();
+  void deliverPMTPacket(Boolean hasChanged);
+
+  void setProgramStreamMap(unsigned frameSize);
+
+protected:
+  Boolean fHaveVideoStreams;
+
+private:
+  unsigned fOutgoingPacketCounter;
+  unsigned fProgramMapVersion;
+  u_int8_t fPreviousInputProgramMapVersion, fCurrentInputProgramMapVersion;
+      // These two fields are used if we see "program_stream_map"s in the input.
+  struct {
+    unsigned counter;
+    u_int8_t streamType; // for use in Program Maps
+  } fPIDState[PID_TABLE_SIZE];
+  u_int16_t fPCR_PID, fCurrentPID; // only the low 13 bits are used
+  MPEG1or2Demux::SCR fPCR;
+  unsigned char* fInputBuffer;
+  unsigned fInputBufferSize, fInputBufferBytesUsed;
+  Boolean fIsFirstAdaptationField;
+  unsigned fSegmentationDuration;
+      // if nonzero, this is the number of seconds between successive 'segments'.  Each 'segment'
+      // begins with a PAT, followed by a PMT.
+      // if zero (the default value), then the frequency of PATs and PMTs depends on the constants
+      // PAT_PERIOD_IF_UNTIMED and PMT_PERIOD_IF_UNTIMED, defined in the .cpp file.
+  Boolean segmentationIsTimed() const { return fSegmentationDuration > 0; }
+  u_int8_t fSegmentationIndication;
+      // used only if fSegmentationDuration > 0:
+      // 1 if a segment has just ended and the next packet is to be a PAT
+      // 2 if a segment has just ended and the following PAT has been sent; a PMT is next
+      // 0 otherwise
+  double fCurrentSegmentDuration, fPreviousPTS; // used only if fSegmentationDuration > 0
+  onEndOfSegmentFunc* fOnEndOfSegmentFunc; // used only if fSegmentationDuration > 0
+  void* fOnEndOfSegmentClientData; // ditto
+};
+
+
+// The CRC calculation function that Transport Streams use.  We make this function public
+// here in case it's useful elsewhere:
+u_int32_t calculateCRC(u_int8_t const* data, unsigned dataLength, u_int32_t initialValue = 0xFFFFFFFF);
+
+#endif

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

@@ -0,0 +1,99 @@
+/**********
+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.// A filter that converts a MPEG Transport Stream file - with corresponding index file
+// - to a corresponding Video Elementary Stream.  It also uses a "scale" parameter
+// to implement 'trick mode' (fast forward or reverse play, using I-frames) on
+// the video stream.
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH
+#define _MPEG2_TRANSPORT_STREAM_TRICK_MODE_FILTER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+#ifndef _MPEG2_TRANSPORT_STREAM_INDEX_FILE_HH
+#include "MPEG2TransportStreamIndexFile.hh"
+#endif
+
+#ifndef TRANSPORT_PACKET_SIZE
+#define TRANSPORT_PACKET_SIZE 188
+#endif
+
+class LIVEMEDIA_API MPEG2TransportStreamTrickModeFilter: public FramedFilter {
+public:
+  static MPEG2TransportStreamTrickModeFilter*
+  createNew(UsageEnvironment& env, FramedSource* inputSource,
+	    MPEG2TransportStreamIndexFile* indexFile, int scale);
+
+  Boolean seekTo(unsigned long tsPacketNumber, unsigned long indexRecordNumber);
+
+  unsigned long nextIndexRecordNum() const { return fNextIndexRecordNum; }
+
+  void forgetInputSource() { fInputSource = NULL; }
+      // this lets us delete this without also deleting the input Transport Stream
+
+protected:
+  MPEG2TransportStreamTrickModeFilter(UsageEnvironment& env, FramedSource* inputSource,
+				      MPEG2TransportStreamIndexFile* indexFile, int scale);
+      // called only by createNew()
+  virtual ~MPEG2TransportStreamTrickModeFilter();
+
+private:
+  // Redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  void attemptDeliveryToClient();
+  void seekToTransportPacket(unsigned long tsPacketNum);
+  void readTransportPacket(unsigned long tsPacketNum); // asynchronously
+
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned frameSize);
+
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+
+private:
+  Boolean fHaveStarted;
+  MPEG2TransportStreamIndexFile* fIndexFile;
+  int fScale; // absolute value
+  int fDirection; // 1 => forward; -1 => reverse
+  enum {
+    SKIPPING_FRAME,
+    DELIVERING_SAVED_FRAME,
+    SAVING_AND_DELIVERING_FRAME
+  } fState;
+  unsigned fFrameCount;
+  unsigned long fNextIndexRecordNum; // next to be read from the index file
+  unsigned long fNextTSPacketNum; // next to be read from the transport stream file
+  unsigned char fInputBuffer[TRANSPORT_PACKET_SIZE];
+  unsigned long fCurrentTSPacketNum; // corresponding to data currently in the buffer
+  unsigned long fDesiredTSPacketNum;
+  u_int8_t fDesiredDataOffset, fDesiredDataSize;
+  float fDesiredDataPCR, fFirstPCR;
+  unsigned long fSavedFrameIndexRecordStart;
+  unsigned long fSavedSequentialIndexRecordNum;
+  Boolean fUseSavedFrameNextTime;
+};
+
+#endif

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

@@ -0,0 +1,55 @@
+/**********
+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.
+// A 'ServerMediaSubsession' object that creates new, unicast, "RTPSink"s
+// on demand, from an incoming UDP (or RTP/UDP) MPEG-2 Transport Stream
+// C++ header
+
+#ifndef _MPEG2_TRANSPORT_UDP_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG2_TRANSPORT_UDP_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#include "OnDemandServerMediaSubsession.hh"
+#endif
+
+class LIVEMEDIA_API MPEG2TransportUDPServerMediaSubsession: public OnDemandServerMediaSubsession {
+public:
+  static MPEG2TransportUDPServerMediaSubsession*
+  createNew(UsageEnvironment& env,
+	    char const* inputAddressStr, // An IP multicast address, or use "0.0.0.0" or NULL for unicast input
+	    Port const& inputPort,
+	    Boolean inputStreamIsRawUDP = False); // otherwise (default) the input stream is RTP/UDP
+protected:
+  MPEG2TransportUDPServerMediaSubsession(UsageEnvironment& env,
+					 char const* inputAddressStr, Port const& inputPort, Boolean inputStreamIsRawUDP);
+      // called only by createNew();
+  virtual ~MPEG2TransportUDPServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+				    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+protected:
+  char const* fInputAddressStr;
+  Port fInputPort;
+  Groupsock* fInputGroupsock;
+  Boolean fInputStreamIsRawUDP;
+};
+
+#endif