ilabs-flir 1.0.7 → 2.0.1

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

@@ -0,0 +1,192 @@
+/**********
+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 sink that generates a QuickTime file from a composite media session
+// C++ header
+
+#ifndef _QUICKTIME_FILE_SINK_HH
+#define _QUICKTIME_FILE_SINK_HH
+
+#ifndef _MEDIA_SESSION_HH
+#include "MediaSession.hh"
+#endif
+
+class LIVEMEDIA_API QuickTimeFileSink: public Medium {
+public:
+  static QuickTimeFileSink* createNew(UsageEnvironment& env,
+				      MediaSession& inputSession,
+				      char const* outputFileName,
+				      unsigned bufferSize = 20000,
+				      unsigned short movieWidth = 240,
+				      unsigned short movieHeight = 180,
+				      unsigned movieFPS = 15,
+				      Boolean packetLossCompensate = False,
+				      Boolean syncStreams = False,
+				      Boolean generateHintTracks = False,
+				      Boolean generateMP4Format = False);
+
+  typedef void (afterPlayingFunc)(void* clientData);
+  Boolean startPlaying(afterPlayingFunc* afterFunc,
+                       void* afterClientData);
+
+  unsigned numActiveSubsessions() const { return fNumSubsessions; }
+
+protected:
+  QuickTimeFileSink(UsageEnvironment& env, MediaSession& inputSession,
+		    char const* outputFileName, unsigned bufferSize,
+		    unsigned short movieWidth, unsigned short movieHeight,
+		    unsigned movieFPS, Boolean packetLossCompensate,
+		    Boolean syncStreams, Boolean generateHintTracks,
+		    Boolean generateMP4Format);
+      // called only by createNew()
+  virtual ~QuickTimeFileSink();
+
+  virtual void noteRecordedFrame(MediaSubsession& inputSubsession,
+				 unsigned packetDataSize, struct timeval const& presentationTime);
+
+private:
+  Boolean continuePlaying();
+  static void afterGettingFrame(void* clientData, unsigned frameSize,
+				unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  static void onSourceClosure(void* clientData);
+  void onSourceClosure1();
+  static void onRTCPBye(void* clientData);
+  void completeOutputFile();
+
+private:
+  friend class SubsessionIOState;
+  MediaSession& fInputSession;
+  FILE* fOutFid;
+  unsigned fBufferSize;
+  Boolean fPacketLossCompensate;
+  Boolean fSyncStreams, fGenerateMP4Format;
+  struct timeval fNewestSyncTime, fFirstDataTime;
+  Boolean fAreCurrentlyBeingPlayed;
+  afterPlayingFunc* fAfterFunc;
+  void* fAfterClientData;
+  unsigned fAppleCreationTime;
+  unsigned fLargestRTPtimestampFrequency;
+  unsigned fNumSubsessions, fNumSyncedSubsessions;
+  struct timeval fStartTime;
+  Boolean fHaveCompletedOutputFile;
+
+private:
+  ///// Definitions specific to the QuickTime file format:
+
+  unsigned addWord64(u_int64_t word);
+  unsigned addWord(unsigned word);
+  unsigned addHalfWord(unsigned short halfWord);
+  unsigned addByte(unsigned char byte) {
+    putc(byte, fOutFid);
+    return 1;
+  }
+  unsigned addZeroWords(unsigned numWords);
+  unsigned add4ByteString(char const* str);
+  unsigned addArbitraryString(char const* str,
+			      Boolean oneByteLength = True);
+  unsigned addAtomHeader(char const* atomName);
+  unsigned addAtomHeader64(char const* atomName);
+      // strlen(atomName) must be 4
+  void setWord(int64_t filePosn, unsigned size);
+  void setWord64(int64_t filePosn, u_int64_t size);
+
+  unsigned movieTimeScale() const {return fLargestRTPtimestampFrequency;}
+
+  // Define member functions for outputting various types of atom:
+#define _atom(name) unsigned addAtom_##name()
+  _atom(ftyp); // for MP4 format files
+  _atom(moov);
+      _atom(mvhd);
+  _atom(iods); // for MP4 format files
+      _atom(trak);
+          _atom(tkhd);
+          _atom(edts);
+              _atom(elst);
+          _atom(tref);
+              _atom(hint);
+          _atom(mdia);
+              _atom(mdhd);
+              _atom(hdlr);
+              _atom(minf);
+                  _atom(smhd);
+                  _atom(vmhd);
+                  _atom(gmhd);
+                      _atom(gmin);
+                  unsigned addAtom_hdlr2();
+                  _atom(dinf);
+                      _atom(dref);
+                          _atom(alis);
+                  _atom(stbl);
+                      _atom(stsd);
+                          unsigned addAtom_genericMedia();
+                          unsigned addAtom_soundMediaGeneral();
+                          _atom(ulaw);
+                          _atom(alaw);
+                          _atom(Qclp);
+                              _atom(wave);
+                                  _atom(frma);
+                                  _atom(Fclp);
+                                  _atom(Hclp);
+                          _atom(mp4a);
+//                            _atom(wave);
+//                                _atom(frma);
+                                  _atom(esds);
+                                  _atom(srcq);
+                          _atom(h263);
+                          _atom(avc1);
+                              _atom(avcC);
+                          _atom(mp4v);
+                          _atom(rtp);
+                              _atom(tims);
+                      _atom(stts);
+                      _atom(stss);
+                      _atom(stsc);
+                      _atom(stsz);
+                      _atom(co64);
+          _atom(udta);
+              _atom(name);
+              _atom(hnti);
+                  _atom(sdp);
+              _atom(hinf);
+                  _atom(totl);
+                  _atom(npck);
+                  _atom(tpay);
+                  _atom(trpy);
+                  _atom(nump);
+                  _atom(tpyl);
+                  _atom(dmed);
+                  _atom(dimm);
+                  _atom(drep);
+                  _atom(tmin);
+                  _atom(tmax);
+                  _atom(pmax);
+                  _atom(dmax);
+                  _atom(payt);
+  unsigned addAtom_dummy();
+
+private:
+  unsigned short fMovieWidth, fMovieHeight;
+  unsigned fMovieFPS;
+  int64_t fMDATposition;
+  int64_t fMVHD_durationPosn;
+  unsigned fMaxTrackDurationM; // in movie time units
+  class SubsessionIOState* fCurrentIOState;
+};
+
+#endif

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

@@ -0,0 +1,68 @@
+/**********
+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 containing generic QuickTime stream data, as defined in
+//     <http://developer.apple.com/quicktime/icefloe/dispatch026.html>
+// C++ header
+
+#ifndef _QUICKTIME_GENERIC_RTP_SOURCE_HH
+#define _QUICKTIME_GENERIC_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class LIVEMEDIA_API QuickTimeGenericRTPSource: public MultiFramedRTPSource {
+public:
+  static QuickTimeGenericRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat, unsigned rtpTimestampFrequency,
+	    char const* mimeTypeString);
+
+  // QuickTime-specific information, set from the QuickTime header
+  // in each packet.  This, along with the data following the header,
+  // is used by receivers.
+  struct QTState {
+    char PCK;
+    unsigned timescale;
+    char* sdAtom;
+    unsigned sdAtomSize;
+    unsigned short width, height;
+    // later add other state as needed #####
+  } qtState;
+
+protected:
+  virtual ~QuickTimeGenericRTPSource();
+
+private:
+  QuickTimeGenericRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			    unsigned char rtpPayloadFormat,
+			    unsigned rtpTimestampFrequency,
+			    char const* mimeTypeString);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  char const* fMIMEtypeString;
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64/liblive666.dylib.framework/Headers/liveMedia/RTCP.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.
+// RTCP
+// C++ header
+
+#ifndef _RTCP_HH
+#define _RTCP_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+#ifndef _SRTP_CRYPTOGRAPHIC_CONTEXT_HH
+#include "SRTPCryptographicContext.hh"
+#endif
+
+class LIVEMEDIA_API SDESItem {
+public:
+  SDESItem(unsigned char tag, unsigned char const* value);
+
+  unsigned char const* data() const {return fData;}
+  unsigned totalSize() const;
+
+private:
+  unsigned char fData[2 + 0xFF]; // first 2 bytes are tag and length
+};
+
+typedef void RTCPAppHandlerFunc(void* clientData,
+				u_int8_t subtype, u_int32_t nameBytes/*big-endian order*/,
+				u_int8_t* appDependentData, unsigned appDependentDataSize);
+
+class RTCPMemberDatabase; // forward
+
+typedef void ByeWithReasonHandlerFunc(void* clientData, char const* reason);
+
+class LIVEMEDIA_API RTCPInstance: public Medium {
+public:
+  static RTCPInstance* createNew(UsageEnvironment& env, Groupsock* RTCPgs,
+				 unsigned totSessionBW, /* in kbps */
+				 unsigned char const* cname,
+				 RTPSink* sink,
+				 RTPSource* source,
+				 Boolean isSSMTransmitter = False,
+				 SRTPCryptographicContext* crypto = NULL);
+
+  static Boolean lookupByName(UsageEnvironment& env, char const* instanceName,
+                              RTCPInstance*& resultInstance);
+
+  unsigned numMembers() const;
+  unsigned totSessionBW() const { return fTotSessionBW; }
+
+  void setupForSRTCP();
+  
+  void setByeHandler(TaskFunc* handlerTask, void* clientData,
+		     Boolean handleActiveParticipantsOnly = True);
+      // Assigns a handler routine to be called if a "BYE" arrives.
+      // The handler is called once only; for subsequent "BYE"s,
+      // "setByeHandler()" would need to be called again.
+      // If "handleActiveParticipantsOnly" is True, then the handler is called
+      // only if the SSRC is for a known sender (if we have a "RTPSource"),
+      // or if the SSRC is for a known receiver (if we have a "RTPSink").
+      // This prevents (for example) the handler for a multicast receiver being
+      // called if some other multicast receiver happens to exit.
+      // If "handleActiveParticipantsOnly" is False, then the handler is called
+      // for any incoming RTCP "BYE".
+      // (To remove an existing "BYE" handler, call "setByeHandler()" again, with a "handlerTask" of NULL.)
+  void setByeWithReasonHandler(ByeWithReasonHandlerFunc* handlerTask, void* clientData,
+			       Boolean handleActiveParticipantsOnly = True);
+      // Like "setByeHandler()", except that a string 'reason for the bye' (received as part of
+      // the RTCP "BYE" packet) is passed to the handler function (along with "clientData").
+      // (The 'reason' parameter to the handler function will be a dynamically-allocated string,
+      // or NULL, and should be delete[]d by the handler function.)
+  void setSRHandler(TaskFunc* handlerTask, void* clientData);
+  void setRRHandler(TaskFunc* handlerTask, void* clientData);
+      // Assigns a handler routine to be called if a "SR" or "RR" packet
+      // (respectively) arrives.  Unlike "setByeHandler()", the handler will
+      // be called once for each incoming "SR" or "RR".  (To turn off handling,
+      // call the function again with "handlerTask" (and "clientData") as NULL.)
+  void setSpecificRRHandler(struct sockaddr_storage const& fromAddress, Port fromPort,
+			    TaskFunc* handlerTask, void* clientData);
+      // Like "setRRHandler()", but applies only to "RR" packets that come from
+      // a specific source address and port.  (Note that if both a specific
+      // and a general "RR" handler function is set, then both will be called.)
+  void unsetSpecificRRHandler(struct sockaddr_storage const& fromAddress, Port fromPort); // equivalent to setSpecificRRHandler(..., NULL, NULL);
+  void setAppHandler(RTCPAppHandlerFunc* handlerTask, void* clientData);
+      // Assigns a handler routine to be called whenever an "APP" packet arrives.  (To turn off
+      // handling, call the function again with "handlerTask" (and "clientData") as NULL.)
+  void sendAppPacket(u_int8_t subtype, char const* name,
+		     u_int8_t* appDependentData, unsigned appDependentDataSize);
+      // Sends a custom RTCP "APP" packet to the peer(s).  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'.)
+
+  Groupsock* RTCPgs() const { return fRTCPInterface.gs(); }
+
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId) {
+    fRTCPInterface.removeStreamSocket(sockNum, streamChannelId);
+  }
+    // hacks to allow sending RTP over TCP (RFC 2236, section 10.12)
+
+  void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+                                void* handlerClientData) {
+    fRTCPInterface.setAuxilliaryReadHandler(handlerFunc,
+					    handlerClientData);
+  }
+
+  void injectReport(u_int8_t const* packet, unsigned packetSize, struct sockaddr_storage const& fromAddress);
+    // Allows an outside party to inject an RTCP report (from other than the network interface)
+
+protected:
+  RTCPInstance(UsageEnvironment& env, Groupsock* RTPgs, unsigned totSessionBW,
+	       unsigned char const* cname,
+	       RTPSink* sink, RTPSource* source,
+	       Boolean isSSMTransmitter,
+	       SRTPCryptographicContext* crypto);
+      // called only by createNew()
+  virtual ~RTCPInstance();
+
+  virtual void noteArrivingRR(struct sockaddr_storage const& fromAddressAndPort,
+			      int tcpSocketNum, unsigned char tcpStreamChannelId);
+
+  void incomingReportHandler1();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isRTCPInstance() const;
+
+private:
+  Boolean addReport(Boolean alwaysAdd = False);
+    void addSR();
+    void addRR();
+      void enqueueCommonReportPrefix(unsigned char packetType, u_int32_t SSRC,
+				     unsigned numExtraWords = 0);
+      void enqueueCommonReportSuffix();
+        void enqueueReportBlock(RTPReceptionStats* receptionStats);
+  void addSDES();
+  void addBYE(char const* reason);
+
+  void sendBuiltPacket();
+
+  static void onExpire(RTCPInstance* instance);
+  void onExpire1();
+
+  static void incomingReportHandler(RTCPInstance* instance, int /*mask*/);
+  void processIncomingReport(unsigned packetSize, struct sockaddr_storage const& fromAddressAndPort,
+			     int tcpSocketNum, unsigned char tcpStreamChannelId);
+  void onReceive(int typeOfPacket, int totPacketSize, u_int32_t ssrc);
+
+private:
+  u_int8_t* fInBuf;
+  unsigned fNumBytesAlreadyRead;
+  OutPacketBuffer* fOutBuf;
+  RTPInterface fRTCPInterface;
+  unsigned fTotSessionBW;
+  RTPSink* fSink;
+  RTPSource* fSource;
+  Boolean fIsSSMTransmitter;
+  SRTPCryptographicContext* fCrypto;
+
+  SDESItem fCNAME;
+  RTCPMemberDatabase* fKnownMembers;
+  unsigned fOutgoingReportCount; // used for SSRC member aging
+
+  double fAveRTCPSize;
+  int fIsInitial;
+  double fPrevReportTime;
+  double fNextReportTime;
+  int fPrevNumMembers;
+
+  int fLastSentSize;
+  int fLastReceivedSize;
+  u_int32_t fLastReceivedSSRC;
+  int fTypeOfEvent;
+  int fTypeOfPacket;
+  Boolean fHaveJustSentPacket;
+  unsigned fLastPacketSentSize;
+
+  TaskFunc* fByeHandlerTask;
+  ByeWithReasonHandlerFunc* fByeWithReasonHandlerTask;
+  void* fByeHandlerClientData;
+  Boolean fByeHandleActiveParticipantsOnly;
+  TaskFunc* fSRHandlerTask;
+  void* fSRHandlerClientData;
+  TaskFunc* fRRHandlerTask;
+  void* fRRHandlerClientData;
+  AddressPortLookupTable* fSpecificRRHandlerTable;
+  RTCPAppHandlerFunc* fAppHandlerTask;
+  void* fAppHandlerClientData;
+
+public: // because this stuff is used by an external "C" function
+  void schedule(double nextTime);
+  void reschedule(double nextTime);
+  void sendReport();
+  void sendBYE(char const* reason = NULL);
+  int typeOfEvent() {return fTypeOfEvent;}
+  int sentPacketSize() {return fLastSentSize;}
+  int packetType() {return fTypeOfPacket;}
+  int receivedPacketSize() {return fLastReceivedSize;}
+  int checkNewSSRC();
+  void removeLastReceivedSSRC();
+  void removeSSRC(u_int32_t ssrc, Boolean alsoRemoveStats);
+};
+
+// RTCP packet types:
+const unsigned char RTCP_PT_SR = 200;
+const unsigned char RTCP_PT_RR = 201;
+const unsigned char RTCP_PT_SDES = 202;
+const unsigned char RTCP_PT_BYE = 203;
+const unsigned char RTCP_PT_APP = 204;
+const unsigned char RTCP_PT_RTPFB = 205; // Generic RTP Feedback [RFC4585]
+const unsigned char RTCP_PT_PSFB = 206; // Payload-specific [RFC4585]
+const unsigned char RTCP_PT_XR = 207; // extended report [RFC3611]
+const unsigned char RTCP_PT_AVB = 208; // AVB RTCP packet ["Standard for Layer 3 Transport Protocol for Time Sensitive Applications in Local Area Networks." Work in progress.]
+const unsigned char RTCP_PT_RSI = 209; // Receiver Summary Information [RFC5760]
+const unsigned char RTCP_PT_TOKEN = 210; // Port Mapping [RFC6284]
+const unsigned char RTCP_PT_IDMS = 211; // IDMS Settings [RFC7272]
+
+// SDES tags:
+const unsigned char RTCP_SDES_END = 0;
+const unsigned char RTCP_SDES_CNAME = 1;
+const unsigned char RTCP_SDES_NAME = 2;
+const unsigned char RTCP_SDES_EMAIL = 3;
+const unsigned char RTCP_SDES_PHONE = 4;
+const unsigned char RTCP_SDES_LOC = 5;
+const unsigned char RTCP_SDES_TOOL = 6;
+const unsigned char RTCP_SDES_NOTE = 7;
+const unsigned char RTCP_SDES_PRIV = 8;
+
+#endif

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

@@ -0,0 +1,115 @@
+/**********
+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.
+// An abstraction of a network interface used for RTP (or RTCP).
+// (This allows the RTP-over-TCP hack (RFC 2326, section 10.12) to
+// be implemented transparently.)
+// C++ header
+
+#ifndef _RTP_INTERFACE_HH
+#define _RTP_INTERFACE_HH
+
+#ifndef _MEDIA_HH
+#include "Media.hh"
+#endif
+#ifndef _TLS_STATE_HH
+#include "TLSState.hh"
+#endif
+#ifndef _GROUPSOCK_HH
+#include <Groupsock.hh>
+#endif
+
+// Typedef for an optional auxilliary handler function, to be called
+// when each new packet is read:
+typedef void AuxHandlerFunc(void* clientData, unsigned char* packet,
+			    unsigned& packetSize);
+
+typedef void ServerRequestAlternativeByteHandler(void* instance, u_int8_t requestByte);
+// A hack that allows a handler for RTP/RTCP packets received over TCP to process RTSP commands that may also appear within
+// the same TCP connection.  A RTSP server implementation would supply a function like this - as a parameter to
+// "ServerMediaSubsession::startStream()".
+
+class LIVEMEDIA_API RTPInterface {
+public:
+  RTPInterface(Medium* owner, Groupsock* gs);
+  virtual ~RTPInterface();
+
+  Groupsock* gs() const { return fGS; }
+
+  void setStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void addStreamSocket(int sockNum, unsigned char streamChannelId, TLSState* tlsState);
+  void removeStreamSocket(int sockNum, unsigned char streamChannelId);
+  static void setServerRequestAlternativeByteHandler(UsageEnvironment& env, int socketNum,
+						     ServerRequestAlternativeByteHandler* handler, void* clientData);
+  static void clearServerRequestAlternativeByteHandler(UsageEnvironment& env, int socketNum);
+
+  Boolean sendPacket(unsigned char* packet, unsigned packetSize);
+  void startNetworkReading(TaskScheduler::BackgroundHandlerProc*
+                           handlerProc);
+  Boolean handleRead(unsigned char* buffer, unsigned bufferMaxSize,
+		     // out parameters:
+		     unsigned& bytesRead, struct sockaddr_storage& fromAddress,
+		     int& tcpSocketNum, unsigned char& tcpStreamChannelId,
+		     Boolean& packetReadWasIncomplete);
+  // Note: If "tcpSocketNum" < 0, then the packet was received over UDP, and "tcpStreamChannelId"
+  //   is undefined (and irrelevant).
+
+
+  // Otherwise (if "tcpSocketNum" >= 0), the packet was received (interleaved) over TCP, and
+  //   "tcpStreamChannelId" will return the channel id.
+
+  void stopNetworkReading();
+
+  UsageEnvironment& envir() const { return fOwner->envir(); }
+
+  void setAuxilliaryReadHandler(AuxHandlerFunc* handlerFunc,
+				void* handlerClientData) {
+    fAuxReadHandlerFunc = handlerFunc;
+    fAuxReadHandlerClientData = handlerClientData;
+  }
+
+  void forgetOurGroupsock() { fGS = NULL; }
+    // This may be called - *only immediately prior* to deleting this - to prevent our destructor
+    // from turning off background reading on the 'groupsock'.  (This is in case the 'groupsock'
+    // is also being read from elsewhere.)
+
+private:
+  // Helper functions for sending a RTP or RTCP packet over a TCP connection:
+  Boolean sendRTPorRTCPPacketOverTCP(unsigned char* packet, unsigned packetSize,
+				     int socketNum, unsigned char streamChannelId,
+				     TLSState* tlsState);
+  Boolean sendDataOverTCP(int socketNum, TLSState* tlsState,
+			  u_int8_t const* data, unsigned dataSize, Boolean forceSendToSucceed);
+
+private:
+  friend class SocketDescriptor;
+  Medium* fOwner;
+  Groupsock* fGS;
+  class tcpStreamRecord* fTCPStreams; // optional, for RTP-over-TCP streaming/receiving
+
+  unsigned short fNextTCPReadSize;
+    // how much data (if any) is available to be read from the TCP stream
+  int fNextTCPReadStreamSocketNum;
+  unsigned char fNextTCPReadStreamChannelId;
+  TLSState* fNextTCPReadTLSState;
+  TaskScheduler::BackgroundHandlerProc* fReadHandlerProc; // if any
+
+  AuxHandlerFunc* fAuxReadHandlerFunc;
+  void* fAuxReadHandlerClientData;
+};
+
+#endif