ilabs-flir 1.0.6 → 2.0.1

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/OggFile.hh

@@ -0,0 +1,179 @@
+/**********
+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 an Ogg file
+// C++ header
+
+#ifndef _OGG_FILE_HH
+#define _OGG_FILE_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class OggTrack; // forward
+class OggDemux; // forward
+
+typedef void OggDemuxOnDeletionFunc(void* objectToNotify, OggDemux* demuxBeingDeleted);
+
+class LIVEMEDIA_API OggFile: public Medium {
+public:
+  typedef void (onCreationFunc)(OggFile* newFile, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName,
+			onCreationFunc* onCreation, void* onCreationClientData);
+      // Note: Unlike most "createNew()" functions, this one doesn't return a new object
+      // immediately.  Instead, because this class requires file reading (to parse the
+      // Ogg track headers) before a new object can be initialized, the creation of a new object
+      // is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as
+      // a parameter to "createNew()".
+
+  OggTrack* lookup(u_int32_t trackNumber);
+
+  OggDemux* newDemux(OggDemuxOnDeletionFunc* onDeletionFunc = NULL, void* objectToNotify = NULL);
+      // Creates a demultiplexor for extracting tracks from this file.
+      // (Separate clients will typically have separate demultiplexors.)
+
+  char const* fileName() const { return fFileName; }
+  unsigned numTracks() const;
+
+  FramedSource*
+  createSourceForStreaming(FramedSource* baseSource, u_int32_t trackNumber,
+                           unsigned& estBitrate, unsigned& numFiltersInFrontOfTrack);
+    // Takes a data source (which must be a demultiplexed track from this file) and returns
+    // a (possibly modified) data source that can be used for streaming.
+
+  RTPSink* createRTPSinkForTrackNumber(u_int32_t trackNumber, Groupsock* rtpGroupsock,
+                                       unsigned char rtpPayloadTypeIfDynamic);
+    // Creates a "RTPSink" object that would be appropriate for streaming the specified track,
+    // or NULL if no appropriate "RTPSink" exists
+
+  class OggTrackTable& trackTable() { return *fTrackTable; }
+
+private:
+  OggFile(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData);
+    // called only by createNew()
+  virtual ~OggFile();
+
+  static void handleEndOfBosPageParsing(void* clientData);
+  void handleEndOfBosPageParsing();
+
+  void addTrack(OggTrack* newTrack);
+  void removeDemux(OggDemux* demux);
+
+private:
+  friend class OggFileParser;
+  friend class OggDemux;
+  char const* fFileName;
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+
+  class OggTrackTable* fTrackTable;
+  HashTable* fDemuxesTable;
+  class OggFileParser* fParserForInitialization;
+};
+
+class LIVEMEDIA_API OggTrack {
+public:
+  OggTrack();
+  virtual ~OggTrack();
+
+  // track parameters
+  u_int32_t trackNumber; // bitstream serial number
+  char const* mimeType; // NULL if not known
+
+  unsigned samplingFrequency, numChannels; // for audio tracks
+  unsigned estBitrate; // estimate, in kbps (for RTCP)
+
+  // Special headers for Vorbis audio, Theora video, and Opus audio tracks:
+  struct _vtoHdrs {
+    u_int8_t* header[3]; // "identification", "comment", "setup"
+    unsigned headerSize[3];
+
+    // Fields specific to Vorbis audio:
+    unsigned blocksize[2]; // samples per frame (packet)
+    unsigned uSecsPerPacket[2]; // computed as (blocksize[i]*1000000)/samplingFrequency
+    unsigned vorbis_mode_count;
+    unsigned ilog_vorbis_mode_count_minus_1;
+    u_int8_t* vorbis_mode_blockflag;
+        // an array (of size "vorbis_mode_count") of indexes into the (2-entry) "blocksize" array
+
+    // Fields specific to Theora video:
+    u_int8_t KFGSHIFT;
+    unsigned uSecsPerFrame;
+
+  } vtoHdrs;
+
+  Boolean weNeedHeaders() const {
+    return
+      vtoHdrs.header[0] == NULL ||
+      vtoHdrs.header[1] == NULL ||
+      (vtoHdrs.header[2] == NULL && strcmp(mimeType, "audio/OPUS") != 0);
+    }
+};
+
+class LIVEMEDIA_API OggTrackTableIterator {
+public:
+  OggTrackTableIterator(class OggTrackTable& ourTable);
+  virtual ~OggTrackTableIterator();
+
+  OggTrack* next();
+
+private:
+  HashTable::Iterator* fIter;
+};
+
+class LIVEMEDIA_API OggDemux: public Medium {
+public:
+  FramedSource* newDemuxedTrack(u_int32_t& resultTrackNumber);
+    // Returns a new stream ("FramedSource" subclass) that represents the next media track
+    // from the file.  This function returns NULL when no more media tracks exist.
+
+  FramedSource* newDemuxedTrackByTrackNumber(unsigned trackNumber);
+      // As above, but creates a new stream for a specific track number within the Matroska file.
+      // (You should not call this function more than once with the same track number.)
+
+      // Note: We assume that:
+      // - Every track created by "newDemuxedTrack()" is later read
+      // - All calls to "newDemuxedTrack()" are made before any track is read
+
+protected:
+  friend class OggFile;
+  friend class OggFileParser;
+  class OggDemuxedTrack* lookupDemuxedTrack(u_int32_t trackNumber);
+
+  OggDemux(OggFile& ourFile);
+  virtual ~OggDemux();
+
+private:
+  friend class OggDemuxedTrack;
+  void removeTrack(u_int32_t trackNumber);
+  void continueReading(); // called by a demuxed track to tell us that it has a pending read ("doGetNextFrame()")
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+private:
+  OggFile& fOurFile;
+  class OggFileParser* fOurParser;
+  HashTable* fDemuxedTracksTable;
+  OggTrackTableIterator* fIter;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/OggFileServerDemux.hh

@@ -0,0 +1,85 @@
+/**********
+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 server demultiplexor for an Ogg file
+// C++ header
+
+#ifndef _OGG_FILE_SERVER_DEMUX_HH
+#define _OGG_FILE_SERVER_DEMUX_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+
+#ifndef _OGG_FILE_HH
+#include "OggFile.hh"
+#endif
+
+class LIVEMEDIA_API OggFileServerDemux: public Medium {
+public:
+  typedef void (onCreationFunc)(OggFileServerDemux* newDemux, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName,
+			onCreationFunc* onCreation, void* onCreationClientData);
+    // Note: Unlike most "createNew()" functions, this one doesn't return a new object immediately.  Instead, because this class
+    // requires file reading (to parse the Ogg 'Track' headers) before a new object can be initialized, the creation of a new
+    // object is signalled by calling - from the event loop - an 'onCreationFunc' that is passed as a parameter to "createNew()". 
+
+  ServerMediaSubsession* newServerMediaSubsession();
+  ServerMediaSubsession* newServerMediaSubsession(u_int32_t& resultTrackNumber);
+    // Returns a new "ServerMediaSubsession" object that represents the next media track
+    // from the file.  This function returns NULL when no more media tracks exist.
+
+  ServerMediaSubsession* newServerMediaSubsessionByTrackNumber(u_int32_t trackNumber);
+  // As above, but creates a new "ServerMediaSubsession" object for a specific track number
+  // within the Ogg file.
+  // (You should not call this function more than once with the same track number.)
+
+  // The following public: member functions are called only by the "ServerMediaSubsession" objects:
+
+  OggFile* ourOggFile() { return fOurOggFile; }
+  char const* fileName() const { return fFileName; }
+
+  FramedSource* newDemuxedTrack(unsigned clientSessionId, u_int32_t trackNumber);
+    // Used by the "ServerMediaSubsession" objects to implement their "createNewStreamSource()" virtual function.
+
+private:
+  OggFileServerDemux(UsageEnvironment& env, char const* fileName,
+		     onCreationFunc* onCreation, void* onCreationClientData);
+      // called only by createNew()
+  virtual ~OggFileServerDemux();
+
+  static void onOggFileCreation(OggFile* newFile, void* clientData);
+  void onOggFileCreation(OggFile* newFile);
+
+  static void onDemuxDeletion(void* clientData, OggDemux* demuxBeingDeleted);
+  void onDemuxDeletion(OggDemux* demuxBeingDeleted);
+  
+private:
+  char const* fFileName; 
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+  OggFile* fOurOggFile;
+
+  // Used to implement "newServerMediaSubsession()":
+  OggTrackTableIterator* fIter;
+
+  // Used to set up demuxing, to implement "newDemuxedTrack()":
+  unsigned fLastClientSessionId;
+  OggDemux* fLastCreatedDemux;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/OggFileSink.hh

@@ -0,0 +1,79 @@
+/**********
+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.
+// 'Ogg' File Sink (recording a single media track only)
+// C++ header
+
+#ifndef _OGG_FILE_SINK_HH
+#define _OGG_FILE_SINK_HH
+
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+
+class LIVEMEDIA_API OggFileSink: public FileSink {
+public:
+  static OggFileSink* createNew(UsageEnvironment& env, char const* fileName,
+				unsigned samplingFrequency = 0, // used for granule_position
+				char const* configStr = NULL,
+      // "configStr" is an optional 'SDP format' string (Base64-encoded)
+      // representing 'packed configuration headers' ("identification", "comment", "setup")
+      // to prepend to the output.  (For 'Vorbis" audio and 'Theora' video.)
+				unsigned bufferSize = 100000,
+				Boolean oneFilePerFrame = False);
+      // See "FileSink.hh" for a description of these parameters.
+
+protected:
+  OggFileSink(UsageEnvironment& env, FILE* fid, unsigned samplingFrequency, char const* configStr,
+	      unsigned bufferSize, char const* perFrameFileNamePrefix);
+      // called only by createNew()
+  virtual ~OggFileSink();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+  virtual void addData(unsigned char const* data, unsigned dataSize,
+		       struct timeval presentationTime);
+  virtual void afterGettingFrame(unsigned frameSize, unsigned numTruncatedBytes,
+				 struct timeval presentationTime);
+
+private:
+  static void ourOnSourceClosure(void* clientData);
+  void ourOnSourceClosure();
+
+private:
+  unsigned fSamplingFrequency;
+  char const* fConfigStr;
+  Boolean fHaveWrittenFirstFrame, fHaveSeenEOF;
+  struct timeval fFirstPresentationTime;
+  int64_t fGranulePosition;
+  int64_t fGranulePositionAdjustment; // used to ensure that "fGranulePosition" stays monotonic
+  u_int32_t fPageSequenceNumber;
+  u_int8_t fPageHeaderBytes[27];
+      // the header of each Ogg page, through the "number_page_segments" byte
+
+  // Special fields used for Theora video:
+  Boolean fIsTheora;
+  u_int64_t fGranuleIncrementPerFrame; // == 1 << KFGSHIFT
+
+  // Because the last Ogg page before EOF needs to have a special 'eos' bit set in the header,
+  // we need to defer the writing of each incoming frame.  To do this, we maintain a 2nd buffer:
+  unsigned char* fAltBuffer;
+  unsigned fAltFrameSize, fAltNumTruncatedBytes;
+  struct timeval fAltPresentationTime;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/OnDemandServerMediaSubsession.hh

@@ -0,0 +1,233 @@
+/**********
+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.
+// C++ header
+
+#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+#define _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _SERVER_MEDIA_SESSION_HH
+#include "ServerMediaSession.hh"
+#endif
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _BASIC_UDP_SINK_HH
+#include "BasicUDPSink.hh"
+#endif
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+
+class LIVEMEDIA_API OnDemandServerMediaSubsession: public ServerMediaSubsession {
+protected: // we're a virtual base class
+  OnDemandServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource,
+				portNumBits initialPortNum = 6970,
+				Boolean multiplexRTCPWithRTP = False);
+  virtual ~OnDemandServerMediaSubsession();
+
+protected: // redefined virtual functions
+  virtual char const* sdpLines(int addressFamily);
+  virtual void getStreamParameters(unsigned clientSessionId,
+				   struct sockaddr_storage const& clientAddress,
+                                   Port const& clientRTPPort,
+                                   Port const& clientRTCPPort,
+				   int tcpSocketNum,
+                                   unsigned char rtpChannelId,
+                                   unsigned char rtcpChannelId,
+				   TLSState* tlsState,
+                                   struct sockaddr_storage& destinationAddress,
+				   u_int8_t& destinationTTL,
+                                   Boolean& isMulticast,
+                                   Port& serverRTPPort,
+                                   Port& serverRTCPPort,
+                                   void*& streamToken);
+  virtual void startStream(unsigned clientSessionId, void* streamToken,
+			   TaskFunc* rtcpRRHandler,
+			   void* rtcpRRHandlerClientData,
+			   unsigned short& rtpSeqNum,
+                           unsigned& rtpTimestamp,
+			   ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                           void* serverRequestAlternativeByteHandlerClientData);
+  virtual void pauseStream(unsigned clientSessionId, void* streamToken);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+  virtual void seekStream(unsigned clientSessionId, void* streamToken, char*& absStart, char*& absEnd);
+  virtual void nullSeekStream(unsigned clientSessionId, void* streamToken,
+			      double streamEndTime, u_int64_t& numBytes);
+  virtual void setStreamScale(unsigned clientSessionId, void* streamToken, float scale);
+  virtual float getCurrentNPT(void* streamToken);
+  virtual FramedSource* getStreamSource(void* streamToken);
+  virtual void getRTPSinkandRTCP(void* streamToken,
+				 RTPSink const*& rtpSink, RTCPInstance const*& rtcp);
+  virtual void deleteStream(unsigned clientSessionId, void*& streamToken);
+
+protected: // new virtual functions, possibly redefined by subclasses
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual void seekStreamSource(FramedSource* inputSource, double& seekNPT, double streamDuration, u_int64_t& numBytes);
+    // This routine is used to seek by relative (i.e., NPT) time.
+    // "streamDuration", if >0.0, specifies how much data to stream, past "seekNPT".  (If <=0.0, all remaining data is streamed.)
+    // "numBytes" returns the size (in bytes) of the data to be streamed, or 0 if unknown or unlimited.
+  virtual void seekStreamSource(FramedSource* inputSource, char*& absStart, char*& absEnd);
+    // This routine is used to seek by 'absolute' time.
+    // "absStart" should be a string of the form "YYYYMMDDTHHMMSSZ" or "YYYYMMDDTHHMMSS.<frac>Z".
+    // "absEnd" should be either NULL (for no end time), or a string of the same form as "absStart".
+    // These strings may be modified in-place, or can be reassigned to a newly-allocated value (after delete[]ing the original).
+  virtual void setStreamSourceScale(FramedSource* inputSource, float scale);
+  virtual void setStreamSourceDuration(FramedSource* inputSource, double streamDuration, u_int64_t& numBytes);
+  virtual void closeStreamSource(FramedSource* inputSource);
+
+protected: // new virtual functions, defined by all subclasses
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate) = 0;
+      // "estBitrate" is the stream's estimated bitrate, in kbps
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+				    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource) = 0;
+
+protected: // new virtual functions, may be redefined by a subclass:
+  virtual Groupsock* createGroupsock(struct sockaddr_storage const& addr, Port port);
+  virtual RTCPInstance* createRTCP(Groupsock* RTCPgs, unsigned totSessionBW, /* in kbps */
+				   unsigned char const* cname, RTPSink* sink);
+
+public:
+  void multiplexRTCPWithRTP() { fMultiplexRTCPWithRTP = True; }
+    // An alternative to passing the "multiplexRTCPWithRTP" parameter as True in the constructor
+
+  void setRTCPAppPacketHandler(RTCPAppHandlerFunc* handler, void* clientData);
+    // Sets a handler to be called if a RTCP "APP" packet arrives from any future client.
+    // (Any current clients are not affected; any "APP" packets from them will continue to be
+    // handled by whatever handler existed when the client sent its first RTSP "PLAY" command.)
+    // (Call with (NULL, NULL) to remove an existing handler - for future clients only)
+
+  void sendRTCPAppPacket(u_int8_t subtype, char const* name,
+			 u_int8_t* appDependentData, unsigned appDependentDataSize);
+    // Sends a custom RTCP "APP" packet to the most recent client (if "reuseFirstSource" was False),
+    // or to all current clients (if "reuseFirstSource" was True).
+    // The parameters correspond to their
+    // respective fields as described in the RTP/RTCP definition (RFC 3550).
+    // Note that only the low-order 5 bits of "subtype" are used, and only the first 4 bytes
+    // of "name" are used.  (If "name" has fewer than 4 bytes, or is NULL,
+    // then the remaining bytes are '\0'.)
+
+protected:
+  void setSDPLinesFromRTPSink(RTPSink* rtpSink, FramedSource* inputSource,
+			      unsigned estBitrate);
+      // used to implement "sdpLines()"
+
+protected:
+  char* fSDPLines;
+  u_int8_t* fMIKEYStateMessage; // used if we're streaming SRTP
+  unsigned fMIKEYStateMessageSize; // ditto
+  HashTable* fDestinationsHashTable; // indexed by client session id
+
+private:
+  Boolean fReuseFirstSource;
+  portNumBits fInitialPortNum;
+  Boolean fMultiplexRTCPWithRTP;
+  void* fLastStreamToken;
+  char fCNAME[100]; // for RTCP
+  RTCPAppHandlerFunc* fAppHandlerTask;
+  void* fAppHandlerClientData;
+  friend class StreamState;
+};
+
+
+// A class that represents the state of an ongoing stream.  This is used only internally, in the implementation of
+// "OnDemandServerMediaSubsession", but we expose the definition here, in case subclasses of "OnDemandServerMediaSubsession"
+// want to access it.
+
+class LIVEMEDIA_API Destinations {
+public:
+  Destinations(struct sockaddr_storage const& destAddr,
+               Port const& rtpDestPort,
+               Port const& rtcpDestPort)
+    : isTCP(False), addr(destAddr), rtpPort(rtpDestPort), rtcpPort(rtcpDestPort) {
+  }
+  Destinations(int tcpSockNum, unsigned char rtpChanId, unsigned char rtcpChanId,
+	       TLSState* tlsSt)
+    : isTCP(True), rtpPort(0) /*dummy*/, rtcpPort(0) /*dummy*/,
+      tcpSocketNum(tcpSockNum), rtpChannelId(rtpChanId), rtcpChannelId(rtcpChanId),
+      tlsState(tlsSt) {
+  }
+
+public:
+  Boolean isTCP;
+  struct sockaddr_storage addr;
+  Port rtpPort;
+  Port rtcpPort;
+  int tcpSocketNum;
+  unsigned char rtpChannelId, rtcpChannelId;
+  TLSState* tlsState;
+};
+
+class LIVEMEDIA_API StreamState {
+public:
+  StreamState(OnDemandServerMediaSubsession& master,
+              Port const& serverRTPPort, Port const& serverRTCPPort,
+	      RTPSink* rtpSink, BasicUDPSink* udpSink,
+	      unsigned totalBW, FramedSource* mediaSource,
+	      Groupsock* rtpGS, Groupsock* rtcpGS);
+  virtual ~StreamState();
+
+  void startPlaying(Destinations* destinations, unsigned clientSessionId,
+		    TaskFunc* rtcpRRHandler, void* rtcpRRHandlerClientData,
+		    ServerRequestAlternativeByteHandler* serverRequestAlternativeByteHandler,
+                    void* serverRequestAlternativeByteHandlerClientData);
+  void pause();
+  void sendRTCPAppPacket(u_int8_t subtype, char const* name,
+			 u_int8_t* appDependentData, unsigned appDependentDataSize);
+  void endPlaying(Destinations* destinations, unsigned clientSessionId);
+  void reclaim();
+
+  unsigned& referenceCount() { return fReferenceCount; }
+
+  Port const& serverRTPPort() const { return fServerRTPPort; }
+  Port const& serverRTCPPort() const { return fServerRTCPPort; }
+
+  RTPSink* rtpSink() const { return fRTPSink; }
+  RTCPInstance* rtcpInstance() const { return fRTCPInstance; }
+
+  float streamDuration() const { return fStreamDuration; }
+
+  FramedSource* mediaSource() const { return fMediaSource; }
+  float& startNPT() { return fStartNPT; }
+
+private:
+  OnDemandServerMediaSubsession& fMaster;
+  Boolean fAreCurrentlyPlaying;
+  unsigned fReferenceCount;
+
+  Port fServerRTPPort, fServerRTCPPort;
+
+  RTPSink* fRTPSink;
+  BasicUDPSink* fUDPSink;
+
+  float fStreamDuration;
+  unsigned fTotalBW;
+  RTCPInstance* fRTCPInstance;
+
+  FramedSource* fMediaSource;
+  float fStartNPT; // initial 'normal play time'; reset after each seek
+
+  Groupsock* fRTPgs;
+  Groupsock* fRTCPgs;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/OutputFile.hh

@@ -0,0 +1,31 @@
+/**********
+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.
+// Common routines for opening/closing named output files
+// C++ header
+
+#ifndef _OUTPUT_FILE_HH
+#define _OUTPUT_FILE_HH
+
+#include <UsageEnvironment.hh>
+#include <stdio.h>
+
+LIVEMEDIA_API FILE* OpenOutputFile(UsageEnvironment& env, char const* fileName);
+
+LIVEMEDIA_API void CloseOutputFile(FILE* fid);
+
+#endif