ilabs-flir 1.0.7 → 2.0.3

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

@@ -0,0 +1,374 @@
+/**********
+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 data structure that represents a session that consists of
+// potentially multiple (audio and/or video) sub-sessions
+// (This data structure is used for media *receivers* - i.e., clients.
+//  For media streamers, use "ServerMediaSession" instead.)
+// C++ header
+
+/* NOTE: To support receiving your own custom RTP payload format, you must first define a new
+   subclass of "MultiFramedRTPSource" (or "BasicUDPSource") that implements it.
+   Then define your own subclass of "MediaSession" and "MediaSubsession", as follows:
+   - In your subclass of "MediaSession" (named, for example, "myMediaSession"):
+       - Define and implement your own static member function
+           static myMediaSession* createNew(UsageEnvironment& env, char const* sdpDescription);
+	 and call this - instead of "MediaSession::createNew()" - in your application,
+	 when you create a new "MediaSession" object.
+       - Reimplement the "createNewMediaSubsession()" virtual function, as follows:
+           MediaSubsession* myMediaSession::createNewMediaSubsession() { return new myMediaSubsession(*this); }
+   - In your subclass of "MediaSubsession" (named, for example, "myMediaSubsession"):
+       - Reimplement the "createSourceObjects()" virtual function, perhaps similar to this:
+           Boolean myMediaSubsession::createSourceObjects(int useSpecialRTPoffset) {
+	     if (strcmp(fCodecName, "X-MY-RTP-PAYLOAD-FORMAT") == 0) {
+	       // This subsession uses our custom RTP payload format:
+	       fReadSource = fRTPSource = myRTPPayloadFormatRTPSource::createNew( <parameters> );
+	       return True;
+	     } else {
+	       // This subsession uses some other RTP payload format - perhaps one that we already implement:
+	       return ::createSourceObjects(useSpecialRTPoffset);
+	     }
+	   }  
+*/
+
+#ifndef _MEDIA_SESSION_HH
+#define _MEDIA_SESSION_HH
+
+#ifndef _RTCP_HH
+#include "RTCP.hh"
+#endif
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class MediaSubsession; // forward
+
+class LIVEMEDIA_API MediaSession: public Medium {
+public:
+  static MediaSession* createNew(UsageEnvironment& env,
+				 char const* sdpDescription);
+
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      MediaSession*& resultSession);
+
+  Boolean hasSubsessions() const { return fSubsessionsHead != NULL; }
+
+  char* connectionEndpointName() const { return fConnectionEndpointName; }
+  int connectionEndpointNameAddressFamily() const { return fConnectionEndpointNameAddressFamily; }
+  char const* CNAME() const { return fCNAME; }
+  struct sockaddr_storage const& sourceFilterAddr() const { return fSourceFilterAddr; }
+  float& scale() { return fScale; }
+  float& speed() { return fSpeed; }
+  char* mediaSessionType() const { return fMediaSessionType; }
+  char* sessionName() const { return fSessionName; }
+  char* sessionDescription() const { return fSessionDescription; }
+  char const* controlPath() const { return fControlPath; }
+
+  bool hasPlayStartTime() { return fHasPlayStartTime; }
+  bool hasPlayEndTime() { return fHasPlayEndTime; }
+  double& playStartTime() { return fMaxPlayStartTime; }
+  double& playEndTime() { return fMaxPlayEndTime; }
+  char* absStartTime() const;
+  char* absEndTime() const;
+  // Used only to set the local fields:
+  char*& _absStartTime() { return fAbsStartTime; }
+  char*& _absEndTime() { return fAbsEndTime; }
+
+  Boolean initiateByMediaType(char const* mimeType,
+			      MediaSubsession*& resultSubsession,
+			      int useSpecialRTPoffset = -1);
+      // Initiates the first subsession with the specified MIME type
+      // Returns the resulting subsession, or 'multi source' (not both)
+
+  MIKEYState* getMIKEYState() const { return fMIKEYState; }
+  SRTPCryptographicContext* getCrypto() const { return fCrypto; }
+
+protected: // redefined virtual functions
+  virtual Boolean isMediaSession() const;
+
+protected:
+  MediaSession(UsageEnvironment& env);
+      // called only by createNew();
+  virtual ~MediaSession();
+
+  virtual MediaSubsession* createNewMediaSubsession();
+
+  Boolean initializeWithSDP(char const* sdpDescription);
+  Boolean parseSDPLine(char const* input, char const*& nextLine);
+  Boolean parseSDPLine_s(char const* sdpLine);
+  Boolean parseSDPLine_i(char const* sdpLine);
+  Boolean parseSDPLine_c(char const* sdpLine);
+  Boolean parseSDPAttribute_type(char const* sdpLine);
+  Boolean parseSDPAttribute_control(char const* sdpLine);
+  Boolean parseSDPAttribute_range(char const* sdpLine);
+  Boolean parseSDPAttribute_source_filter(char const* sdpLine);
+  Boolean parseSDPAttribute_key_mgmt(char const* sdpLine);
+
+  static char* lookupPayloadFormat(unsigned char rtpPayloadType,
+				   unsigned& rtpTimestampFrequency,
+				   unsigned& numChannels);
+  static unsigned guessRTPTimestampFrequency(char const* mediumName,
+					     char const* codecName);
+
+protected:
+  friend class MediaSubsessionIterator;
+  char* fCNAME; // used for RTCP
+
+  // Linkage fields:
+  MediaSubsession* fSubsessionsHead;
+  MediaSubsession* fSubsessionsTail;
+
+  // Fields set from a SDP description:
+  char* fConnectionEndpointName;
+  bool fHasPlayStartTime;
+  bool fHasPlayEndTime;
+  int fConnectionEndpointNameAddressFamily;
+  double fMaxPlayStartTime;
+  double fMaxPlayEndTime;
+  char* fAbsStartTime;
+  char* fAbsEndTime;
+  struct sockaddr_storage fSourceFilterAddr; // used for SSM
+  float fScale; // set from a RTSP "Scale:" header
+  float fSpeed;
+  char* fMediaSessionType; // holds a=type value
+  char* fSessionName; // holds s=<session name> value
+  char* fSessionDescription; // holds i=<session description> value
+  char* fControlPath; // holds optional a=control: string
+
+  // Optional key management and crypto state:
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+};
+
+
+class LIVEMEDIA_API MediaSubsessionIterator {
+public:
+  MediaSubsessionIterator(MediaSession const& session);
+  virtual ~MediaSubsessionIterator();
+
+  MediaSubsession* next(); // NULL if none
+  void reset();
+
+private:
+  MediaSession const& fOurSession;
+  MediaSubsession* fNextPtr;
+};
+
+
+class LIVEMEDIA_API MediaSubsession {
+public:
+  MediaSession& parentSession() { return fParent; }
+  MediaSession const& parentSession() const { return fParent; }
+
+  unsigned short clientPortNum() const { return fClientPortNum; }
+  unsigned char rtpPayloadFormat() const { return fRTPPayloadFormat; }
+  char const* savedSDPLines() const { return fSavedSDPLines; }
+  char const* mediumName() const { return fMediumName; }
+  char const* codecName() const { return fCodecName; }
+  char const* protocolName() const { return fProtocolName; }
+  char const* controlPath() const { return fControlPath; }
+
+  Boolean isSSM() const { return !addressIsNull(fSourceFilterAddr); }
+
+  unsigned short videoWidth() const { return fVideoWidth; }
+  unsigned short videoHeight() const { return fVideoHeight; }
+  unsigned videoFPS() const { return fVideoFPS; }
+  unsigned numChannels() const { return fNumChannels; }
+  float& scale() { return fScale; }
+  float& speed() { return fSpeed; }
+
+  RTPSource* rtpSource() { return fRTPSource; }
+  RTCPInstance* rtcpInstance() { return fRTCPInstance; }
+  unsigned rtpTimestampFrequency() const { return fRTPTimestampFrequency; }
+  Boolean rtcpIsMuxed() const { return fMultiplexRTCPWithRTP; }
+  FramedSource* readSource() { return fReadSource; }
+    // This is the source that client sinks read from.  It is usually
+    // (but not necessarily) the same as "rtpSource()"
+  void addFilter(FramedFilter* filter);
+    // Changes "readSource()" to "filter" (which must have just been created with "readSource()" as its input)
+
+  double playStartTime() const;
+  double playEndTime() const;
+  char* absStartTime() const;
+  char* absEndTime() const;
+  // Used only to set the local fields:
+  double& _playStartTime() { return fPlayStartTime; }
+  double& _playEndTime() { return fPlayEndTime; }
+  char*& _absStartTime() { return fAbsStartTime; }
+  char*& _absEndTime() { return fAbsEndTime; }
+
+  Boolean initiate(int useSpecialRTPoffset = -1);
+      // Creates a "RTPSource" for this subsession. (Has no effect if it's
+      // already been created.)  Returns True iff this succeeds.
+  void deInitiate(); // Destroys any previously created RTPSource
+  Boolean setClientPortNum(unsigned short portNum);
+      // Sets the preferred client port number that any "RTPSource" for
+      // this subsession would use.  (By default, the client port number
+      // is gotten from the original SDP description, or - if the SDP
+      // description does not specfy a client port number - an ephemeral
+      // (even) port number is chosen.)  This routine must *not* be
+      // called after initiate().
+  void receiveRawMP3ADUs() { fReceiveRawMP3ADUs = True; } // optional hack for audio/MPA-ROBUST; must not be called after initiate()
+  void receiveRawJPEGFrames() { fReceiveRawJPEGFrames = True; } // optional hack for video/JPEG; must not be called after initiate()
+  char*& connectionEndpointName() { return fConnectionEndpointName; }
+  char const* connectionEndpointName() const {
+    return fConnectionEndpointName;
+  }
+  int connectionEndpointNameAddressFamily() const {
+    return fConnectionEndpointNameAddressFamily == AF_UNSPEC
+      ? parentSession().connectionEndpointNameAddressFamily()
+      : fConnectionEndpointNameAddressFamily;
+  }
+
+  // 'Bandwidth' parameter, set in the "b=" SDP line:
+  unsigned bandwidth() const { return fBandwidth; }
+
+  // General SDP attribute accessor functions:
+  char const* attrVal_str(char const* attrName) const;
+      // returns "" if attribute doesn't exist (and has no default value), or is not a string
+  char const* attrVal_strToLower(char const* attrName) const;
+      // returns "" if attribute doesn't exist (and has no default value), or is not a string
+  unsigned attrVal_int(char const* attrName) const;
+      // also returns 0 if attribute doesn't exist (and has no default value)
+  unsigned attrVal_unsigned(char const* attrName) const { return (unsigned)attrVal_int(attrName); }
+  Boolean attrVal_bool(char const* attrName) const { return attrVal_int(attrName) != 0; }
+
+  // Old, now-deprecated SDP attribute accessor functions, kept here for backwards-compatibility:
+  char const* fmtp_config() const;
+  char const* fmtp_configuration() const { return fmtp_config(); }
+  char const* fmtp_spropparametersets() const { return attrVal_str("sprop-parameter-sets"); }
+  char const* fmtp_spropvps() const { return attrVal_str("sprop-vps"); }
+  char const* fmtp_spropsps() const { return attrVal_str("sprop-sps"); }
+  char const* fmtp_sproppps() const { return attrVal_str("sprop-pps"); }
+
+  void getConnectionEndpointAddress(struct sockaddr_storage& addr) const;
+      // Converts "fConnectionEndpointName" to an address (or 0 if unknown)
+  void setDestinations(struct sockaddr_storage const& defaultDestAddress);
+      // Uses "fConnectionEndpointName" and "serverPortNum" to set
+      // the destination address and port of the RTP and RTCP objects.
+      // This is typically called by RTSP clients after doing "SETUP".
+
+  char const* sessionId() const { return fSessionId; }
+  void setSessionId(char const* sessionId);
+
+  // Public fields that external callers can use to keep state.
+  // (They are responsible for all storage management on these fields)
+  unsigned short serverPortNum; // in host byte order (used by RTSP)
+  unsigned char rtpChannelId, rtcpChannelId; // used by RTSP (for RTP/TCP)
+  MediaSink* sink; // callers can use this to keep track of who's playing us
+  void* miscPtr; // callers can use this for whatever they want
+
+  // Parameters set from a RTSP "RTP-Info:" header:
+  struct {
+    u_int16_t seqNum;
+    u_int32_t timestamp;
+    Boolean infoIsNew; // not part of the RTSP header; instead, set whenever this struct is filled in
+  } rtpInfo;
+
+  double getNormalPlayTime(struct timeval const& presentationTime);
+  // Computes the stream's "Normal Play Time" (NPT) from the given "presentationTime".
+  // (For the definition of "Normal Play Time", see RFC 2326, section 3.6.)
+  // This function is useful only if the "rtpInfo" structure was previously filled in
+  // (e.g., by a "RTP-Info:" header in a RTSP response).
+  // Also, for this function to work properly, the RTP stream's presentation times must (eventually) be
+  // synchronized via RTCP.
+  // (Note: If this function returns a negative number, then the result should be ignored by the caller.)
+
+  MIKEYState* getMIKEYState() const { return fMIKEYState != NULL ? fMIKEYState : fParent.getMIKEYState(); }
+  SRTPCryptographicContext* getCrypto() const { return fCrypto != NULL ? fCrypto : fParent.getCrypto(); }
+
+protected:
+  friend class MediaSession;
+  friend class MediaSubsessionIterator;
+  MediaSubsession(MediaSession& parent);
+  virtual ~MediaSubsession();
+
+  UsageEnvironment& env() { return fParent.envir(); }
+  void setNext(MediaSubsession* next) { fNext = next; }
+
+  void setAttribute(char const* name, char const* value = NULL, Boolean valueIsHexadecimal = False);
+
+  Boolean parseSDPLine_c(char const* sdpLine);
+  Boolean parseSDPLine_b(char const* sdpLine);
+  Boolean parseSDPAttribute_rtpmap(char const* sdpLine);
+  Boolean parseSDPAttribute_rtcpmux(char const* sdpLine);
+  Boolean parseSDPAttribute_control(char const* sdpLine);
+  Boolean parseSDPAttribute_range(char const* sdpLine);
+  Boolean parseSDPAttribute_fmtp(char const* sdpLine);
+  Boolean parseSDPAttribute_source_filter(char const* sdpLine);
+  Boolean parseSDPAttribute_x_dimensions(char const* sdpLine);
+  Boolean parseSDPAttribute_framerate(char const* sdpLine);
+  Boolean parseSDPAttribute_key_mgmt(char const* sdpLine);
+
+  virtual Boolean createSourceObjects(int useSpecialRTPoffset);
+    // create "fRTPSource" and "fReadSource" member objects, after we've been initialized via SDP
+
+protected:
+  // Linkage fields:
+  MediaSession& fParent;
+  MediaSubsession* fNext;
+
+  // Fields set from a SDP description:
+  char* fConnectionEndpointName; // may also be set by RTSP SETUP response
+  int fConnectionEndpointNameAddressFamily;
+  unsigned short fClientPortNum; // in host byte order
+      // This field is also set by initiate()
+  unsigned char fRTPPayloadFormat;
+  char* fSavedSDPLines;
+  char* fMediumName;
+  char* fCodecName;
+  char* fProtocolName;
+  unsigned fRTPTimestampFrequency;
+  Boolean fMultiplexRTCPWithRTP;
+  char* fControlPath; // holds optional a=control: string
+
+  // Optional key management and crypto state:
+  MIKEYState* fMIKEYState;
+  SRTPCryptographicContext* fCrypto;
+
+  struct sockaddr_storage fSourceFilterAddr; // used for SSM
+  unsigned fBandwidth; // in kilobits-per-second, from b= line
+
+  double fPlayStartTime;
+  double fPlayEndTime;
+  char* fAbsStartTime;
+  char* fAbsEndTime;
+  unsigned short fVideoWidth, fVideoHeight;
+     // screen dimensions (set by an optional a=x-dimensions: <w>,<h> line)
+  unsigned fVideoFPS;
+     // frame rate (set by an optional "a=framerate: <fps>" or "a=x-framerate: <fps>" line)
+  unsigned fNumChannels;
+     // optionally set by "a=rtpmap:" lines for audio sessions.  Default: 1
+  float fScale; // set from a RTSP "Scale:" header
+  float fSpeed;
+  double fNPT_PTS_Offset; // set by "getNormalPlayTime()"; add this to a PTS to get NPT
+  HashTable* fAttributeTable; // for "a=fmtp:" attributes.  (Later an array by payload type #####)
+
+  // Fields set or used by initiate():
+  Groupsock* fRTPSocket; Groupsock* fRTCPSocket; // works even for unicast
+  RTPSource* fRTPSource; RTCPInstance* fRTCPInstance;
+  FramedSource* fReadSource;
+  Boolean fReceiveRawMP3ADUs, fReceiveRawJPEGFrames;
+
+  // Other fields:
+  char* fSessionId; // used by RTSP
+};
+
+#endif

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

@@ -0,0 +1,135 @@
+/**********
+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.
+// Media Sinks
+// C++ header
+
+#ifndef _MEDIA_SINK_HH
+#define _MEDIA_SINK_HH
+
+#ifndef _FRAMED_SOURCE_HH
+#include "FramedSource.hh"
+#endif
+
+class LIVEMEDIA_API MediaSink: public Medium {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sinkName,
+			      MediaSink*& resultSink);
+
+  typedef void (afterPlayingFunc)(void* clientData);
+  Boolean startPlaying(MediaSource& source,
+		       afterPlayingFunc* afterFunc,
+		       void* afterClientData);
+  virtual void stopPlaying();
+
+  // Test for specific types of sink:
+  virtual Boolean isRTPSink() const;
+
+  FramedSource* source() const {return fSource;}
+
+protected:
+  MediaSink(UsageEnvironment& env); // abstract base class
+  virtual ~MediaSink();
+
+  virtual Boolean sourceIsCompatibleWithUs(MediaSource& source);
+      // called by startPlaying()
+  virtual Boolean continuePlaying() = 0;
+      // called by startPlaying()
+
+  static void onSourceClosure(void* clientData); // can be used in "getNextFrame()" calls
+  void onSourceClosure();
+      // should be called (on ourselves) by continuePlaying() when it
+      // discovers that the source we're playing from has closed.
+
+  FramedSource* fSource;
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isSink() const;
+
+private:
+  // The following fields are used when we're being played:
+  afterPlayingFunc* fAfterFunc;
+  void* fAfterClientData;
+};
+
+// A data structure that a sink may use for an output packet:
+class LIVEMEDIA_API OutPacketBuffer {
+public:
+  OutPacketBuffer(unsigned preferredPacketSize, unsigned maxPacketSize,
+		  unsigned maxBufferSize = 0);
+      // if "maxBufferSize" is >0, use it - instead of "maxSize" to compute the buffer size
+  ~OutPacketBuffer();
+
+  static unsigned maxSize;
+  static void increaseMaxSizeTo(unsigned newMaxSize) { if (newMaxSize > OutPacketBuffer::maxSize) OutPacketBuffer::maxSize = newMaxSize; }
+
+  unsigned char* curPtr() const {return &fBuf[fPacketStart + fCurOffset];}
+  unsigned totalBytesAvailable() const {
+    return fLimit - (fPacketStart + fCurOffset);
+  }
+  unsigned totalBufferSize() const { return fLimit; }
+  unsigned char* packet() const {return &fBuf[fPacketStart];}
+  unsigned curPacketSize() const {return fCurOffset;}
+
+  void increment(unsigned numBytes) {fCurOffset += numBytes;}
+
+  void enqueue(unsigned char const* from, unsigned numBytes);
+  void enqueueWord(u_int32_t word);
+  void insert(unsigned char const* from, unsigned numBytes, unsigned toPosition);
+  void insertWord(u_int32_t word, unsigned toPosition);
+  void extract(unsigned char* to, unsigned numBytes, unsigned fromPosition);
+  u_int32_t extractWord(unsigned fromPosition);
+
+  void skipBytes(unsigned numBytes);
+
+  Boolean isPreferredSize() const {return fCurOffset >= fPreferred;}
+  Boolean wouldOverflow(unsigned numBytes) const {
+    return (fCurOffset+numBytes) > fMax;
+  }
+  unsigned numOverflowBytes(unsigned numBytes) const {
+    return (fCurOffset+numBytes) - fMax;
+  }
+  Boolean isTooBigForAPacket(unsigned numBytes) const {
+    return numBytes > fMax;
+  }
+
+  void setOverflowData(unsigned overflowDataOffset,
+		       unsigned overflowDataSize,
+		       struct timeval const& presentationTime,
+		       unsigned durationInMicroseconds);
+  unsigned overflowDataSize() const {return fOverflowDataSize;}
+  struct timeval overflowPresentationTime() const {return fOverflowPresentationTime;}
+  unsigned overflowDurationInMicroseconds() const {return fOverflowDurationInMicroseconds;}
+  Boolean haveOverflowData() const {return fOverflowDataSize > 0;}
+  void useOverflowData();
+
+  void adjustPacketStart(unsigned numBytes);
+  void resetPacketStart();
+  void resetOffset() { fCurOffset = 0; }
+  void resetOverflowData() { fOverflowDataOffset = fOverflowDataSize = 0; }
+
+private:
+  unsigned fPacketStart, fCurOffset, fPreferred, fMax, fLimit;
+  unsigned char* fBuf;
+
+  unsigned fOverflowDataOffset, fOverflowDataSize;
+  struct timeval fOverflowPresentationTime;
+  unsigned fOverflowDurationInMicroseconds;
+};
+
+#endif

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

@@ -0,0 +1,59 @@
+/**********
+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.
+// Media Sources
+// C++ header
+
+#ifndef _MEDIA_SOURCE_HH
+#define _MEDIA_SOURCE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+
+class LIVEMEDIA_API MediaSource: public Medium {
+public:
+  static Boolean lookupByName(UsageEnvironment& env, char const* sourceName,
+			      MediaSource*& resultSource);
+  virtual void getAttributes() const;
+      // attributes are returned in "env's" 'result message'
+
+  // The MIME type of this source:
+  virtual char const* MIMEtype() const;
+
+  // Test for specific types of source:
+  virtual Boolean isFramedSource() const;
+  virtual Boolean isRTPSource() const;
+  virtual Boolean isMPEG1or2VideoStreamFramer() const;
+  virtual Boolean isMPEG4VideoStreamFramer() const;
+  virtual Boolean isH264VideoStreamFramer() const;
+  virtual Boolean isH265VideoStreamFramer() const;
+  virtual Boolean isDVVideoStreamFramer() const;
+  virtual Boolean isJPEGVideoSource() const;
+  virtual Boolean isAMRAudioSource() const;
+  virtual Boolean isMPEG2TransportStreamMultiplexor() const;
+
+protected:
+  MediaSource(UsageEnvironment& env); // abstract base class
+  virtual ~MediaSource();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isSource() const;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64/liblive666.dylib.framework/Headers/liveMedia/MediaTranscodingTable.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 class that implements a database that can be accessed to create
+// "FramedFilter" (subclass) objects that transcode one codec into another.
+// The implementation of this class just returns NULL for each codec lookup;
+// To actually implement transcoding, you would subclass it.
+// C++ header
+
+#ifndef _MEDIA_TRANSCODING_TABLE_HH
+#define _MEDIA_TRANSCODING_TABLE_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+
+class LIVEMEDIA_API MediaTranscodingTable: public Medium {
+public:
+  virtual FramedFilter*
+  lookupTranscoder(MediaSubsession& /*inputCodecDescription*/, // in
+		   char*& outputCodecName/* out; must be delete[]d later */) {
+    // Default implementation: Return NULL (indicating: no transcoding).
+    // You would reimplement this virtual function in a subclass to return a new 'transcoding'
+    // "FramedFilter" (subclass) object for each ("mediumName","codecName") that you wish to
+    // transcode (or return NULL for no transcoding).
+    // (Note that "inputCodecDescription" must have a non-NULL "readSource()"; this is used
+    //  as the input to the new "FramedFilter" (subclass) object.)
+    outputCodecName = NULL;
+    return NULL;
+  }
+
+  virtual Boolean weWillTranscode(char const* /*mediumName*/, char const* /*codecName*/) {
+    // Default implementation: Return False.
+    // You would reimplement this in a subclass - returning True for each
+    // <mediumName>/<codecName> for which you'll do transcoding.
+    // Note: Unlike "lookupTranscoder()", this function does not actually create any 'transcoding'
+    // filter objects.  (It may be called before "MediaSubsession::initiate()".)
+    return False;
+  }
+
+protected: // we are to be subclassed only
+  MediaTranscodingTable(UsageEnvironment& env)
+    : Medium(env) {
+  }
+  virtual ~MediaTranscodingTable() {
+  }
+};
+
+#endif