ilabs-flir 1.0.7 → 2.0.3

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

@@ -0,0 +1,101 @@
+/**********
+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.
+// MPEG-4 audio, using LATM multiplexing
+// C++ header
+
+#ifndef _MPEG4_LATM_AUDIO_RTP_SOURCE_HH
+#define _MPEG4_LATM_AUDIO_RTP_SOURCE_HH
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#include "MultiFramedRTPSource.hh"
+#endif
+
+class LIVEMEDIA_API MPEG4LATMAudioRTPSource: public MultiFramedRTPSource {
+public:
+  static MPEG4LATMAudioRTPSource*
+  createNew(UsageEnvironment& env, Groupsock* RTPgs,
+	    unsigned char rtpPayloadFormat,
+	    unsigned rtpTimestampFrequency);
+
+  // By default, the LATM data length field is included at the beginning of each
+  // returned frame.  To omit this field, call the following:
+  void omitLATMDataLengthField();
+
+  Boolean returnedFrameIncludesLATMDataLengthField() const { return fIncludeLATMDataLengthField; }
+
+protected:
+  virtual ~MPEG4LATMAudioRTPSource();
+
+private:
+  MPEG4LATMAudioRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+			  unsigned char rtpPayloadFormat,
+			  unsigned rtpTimestampFrequency);
+      // called only by createNew()
+
+private:
+  // redefined virtual functions:
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+                                       unsigned& resultSpecialHeaderSize);
+  virtual char const* MIMEtype() const;
+
+private:
+  Boolean fIncludeLATMDataLengthField;
+};
+
+
+// A utility for parsing a "StreamMuxConfig" string
+Boolean
+parseStreamMuxConfigStr(char const* configStr,
+			// result parameters:
+			Boolean& audioMuxVersion,
+			Boolean& allStreamsSameTimeFraming,
+			unsigned char& numSubFrames,
+			unsigned char& numProgram,
+			unsigned char& numLayer,
+			unsigned char*& audioSpecificConfig,
+			unsigned& audioSpecificConfigSize);
+    // Parses "configStr" as a sequence of hexadecimal digits, representing
+    // a "StreamMuxConfig" (as defined in ISO.IEC 14496-3, table 1.21).
+    // Returns, in "audioSpecificConfig", a binary representation of
+    // the enclosed "AudioSpecificConfig" structure (of size
+    // "audioSpecificConfigSize" bytes).  The memory for this is allocated
+    // dynamically by this function; the caller is responsible for
+    // freeing it.  Other values, that precede "AudioSpecificConfig",
+    // are returned in the other parameters.
+    // Returns True iff the parsing succeeds.
+    // IMPORTANT NOTE: The implementation of this function currently assumes
+    // that everything after the first "numLayer" field is an
+    // "AudioSpecificConfig".  Therefore, it will not work properly if
+    // "audioMuxVersion" != 0, "numProgram" > 0, or "numLayer" > 0.
+    // Also, any 'other data' or CRC info will be included at
+    // the end of "audioSpecificConfig".
+
+unsigned char* parseStreamMuxConfigStr(char const* configStr,
+				       // result parameter:
+				       unsigned& audioSpecificConfigSize);
+    // A variant of the above that returns just the "AudioSpecificConfig" data
+    // (or NULL) if the parsing failed, without bothering with the other
+    // result parameters.
+
+unsigned char* parseGeneralConfigStr(char const* configStr,
+				     // result parameter:
+				     unsigned& configSize);
+    // A routine that parses an arbitrary config string, returning
+    // the result in binary form.
+
+#endif

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

@@ -0,0 +1,61 @@
+/**********
+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 a MPEG-4 video file.
+// C++ header
+
+#ifndef _MPEG4_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+#define _MPEG4_VIDEO_FILE_SERVER_MEDIA_SUBSESSION_HH
+
+#ifndef _FILE_SERVER_MEDIA_SUBSESSION_HH
+#include "FileServerMediaSubsession.hh"
+#endif
+
+class LIVEMEDIA_API MPEG4VideoFileServerMediaSubsession: public FileServerMediaSubsession{
+public:
+  static MPEG4VideoFileServerMediaSubsession*
+  createNew(UsageEnvironment& env, char const* fileName, Boolean reuseFirstSource);
+
+  // Used to implement "getAuxSDPLine()":
+  void checkForAuxSDPLine1();
+  void afterPlayingDummy1();
+
+protected:
+  MPEG4VideoFileServerMediaSubsession(UsageEnvironment& env,
+				      char const* fileName, Boolean reuseFirstSource);
+      // called only by createNew();
+  virtual ~MPEG4VideoFileServerMediaSubsession();
+
+  void setDoneFlag() { fDoneFlag = ~0; }
+
+protected: // redefined virtual functions
+  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
+				    FramedSource* inputSource);
+  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
+					      unsigned& estBitrate);
+  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
+                                    unsigned char rtpPayloadTypeIfDynamic,
+				    FramedSource* inputSource);
+
+private:
+  char* fAuxSDPLine;
+  char fDoneFlag; // used when setting up "fAuxSDPLine"
+  RTPSink* fDummyRTPSink; // ditto
+};
+
+#endif

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

@@ -0,0 +1,73 @@
+/**********
+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 simplified version of "MPEG4VideoStreamFramer" that takes only complete,
+// discrete frames (rather than an arbitrary byte stream) as input.
+// This avoids the parsing and data copying overhead of the full
+// "MPEG4VideoStreamFramer".
+// C++ header
+
+#ifndef _MPEG4_VIDEO_STREAM_DISCRETE_FRAMER_HH
+#define _MPEG4_VIDEO_STREAM_DISCRETE_FRAMER_HH
+
+#ifndef _MPEG4_VIDEO_STREAM_FRAMER_HH
+#include "MPEG4VideoStreamFramer.hh"
+#endif
+
+class LIVEMEDIA_API MPEG4VideoStreamDiscreteFramer: public MPEG4VideoStreamFramer {
+public:
+  static MPEG4VideoStreamDiscreteFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource, Boolean leavePresentationTimesUnmodified = False);
+
+protected:
+  MPEG4VideoStreamDiscreteFramer(UsageEnvironment& env,
+				 FramedSource* inputSource, Boolean leavePresentationTimesUnmodified);
+      // called only by createNew()
+  virtual ~MPEG4VideoStreamDiscreteFramer();
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+
+protected:
+  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);
+
+  Boolean getNextFrameBit(u_int8_t& result);
+  Boolean getNextFrameBits(unsigned numBits, u_int32_t& result);
+    // Which are used by:
+  void analyzeVOLHeader();
+
+protected:
+  Boolean fLeavePresentationTimesUnmodified;
+  u_int32_t vop_time_increment_resolution;
+  unsigned fNumVTIRBits;
+  // # of bits needed to count to "vop_time_increment_resolution"
+  struct timeval fLastNonBFramePresentationTime;
+  unsigned fLastNonBFrameVop_time_increment;
+
+private:
+  unsigned fNumBitsSeenSoFar; // used by the getNextFrameBit*() routines
+};
+
+#endif

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

@@ -0,0 +1,75 @@
+/**********
+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 breaks up an MPEG-4 video elementary stream into
+//   frames for:
+// - Visual Object Sequence (VS) Header + Visual Object (VO) Header
+//   + Video Object Layer (VOL) Header
+// - Group of VOP (GOV) Header
+// - VOP frame
+// C++ header
+
+#ifndef _MPEG4_VIDEO_STREAM_FRAMER_HH
+#define _MPEG4_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#include "MPEGVideoStreamFramer.hh"
+#endif
+
+class LIVEMEDIA_API MPEG4VideoStreamFramer: public MPEGVideoStreamFramer {
+public:
+  static MPEG4VideoStreamFramer*
+  createNew(UsageEnvironment& env, FramedSource* inputSource);
+
+  u_int8_t profile_and_level_indication() const {
+    return fProfileAndLevelIndication;
+  }
+
+  unsigned char* getConfigBytes(unsigned& numBytes) const;
+
+  void setConfigInfo(u_int8_t profileAndLevelIndication, char const* configStr);
+    // Assigns the "profile_and_level_indication" number, and the 'config' bytes.
+    // If this function is not called, then this data is only assigned later, when it appears in the input stream.
+
+protected:
+  MPEG4VideoStreamFramer(UsageEnvironment& env,
+			 FramedSource* inputSource,
+			 Boolean createParser = True);
+      // called only by createNew(), or by subclass constructors
+  virtual ~MPEG4VideoStreamFramer();
+
+  void startNewConfig();
+  void appendToNewConfig(unsigned char* newConfigBytes,
+			 unsigned numNewBytes);
+  void completeNewConfig();
+
+private:
+  // redefined virtual functions:
+  virtual Boolean isMPEG4VideoStreamFramer() const;
+
+protected:
+  u_int8_t fProfileAndLevelIndication;
+  unsigned char* fConfigBytes;
+  unsigned fNumConfigBytes;
+
+private:
+  unsigned char* fNewConfigBytes;
+  unsigned fNumNewConfigBytes;
+  friend class MPEG4VideoStreamParser; // hack
+};
+
+#endif

package/ios/Flir/Frameworks/liblive666.dylib.xcframework/ios-arm64_x86_64-simulator/liblive666.dylib.framework/Headers/liveMedia/MPEGVideoStreamFramer.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 filter that breaks up an MPEG video elementary stream into
+//   headers and frames
+// C++ header
+
+#ifndef _MPEG_VIDEO_STREAM_FRAMER_HH
+#define _MPEG_VIDEO_STREAM_FRAMER_HH
+
+#ifndef _FRAMED_FILTER_HH
+#include "FramedFilter.hh"
+#endif
+
+class LIVEMEDIA_API TimeCode {
+public:
+  TimeCode();
+  virtual ~TimeCode();
+
+  int operator==(TimeCode const& arg2) const;
+  unsigned days, hours, minutes, seconds, pictures;
+};
+
+class LIVEMEDIA_API MPEGVideoStreamFramer: public FramedFilter {
+public:
+  Boolean& pictureEndMarker() { return fPictureEndMarker; }
+      // a hack for implementing the RTP 'M' bit
+
+  void flushInput(); // called if there is a discontinuity (seeking) in the input
+
+protected:
+  MPEGVideoStreamFramer(UsageEnvironment& env, FramedSource* inputSource);
+      // we're an abstract base class
+  virtual ~MPEGVideoStreamFramer();
+
+  void computePresentationTime(unsigned numAdditionalPictures);
+      // sets "fPresentationTime"
+  void setTimeCode(unsigned hours, unsigned minutes, unsigned seconds,
+		   unsigned pictures, unsigned picturesSinceLastGOP);
+
+protected: // redefined virtual functions
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  void reset();
+
+  static void continueReadProcessing(void* clientData,
+				     unsigned char* ptr, unsigned size,
+				     struct timeval presentationTime);
+  void continueReadProcessing();
+
+protected:
+  double fFrameRate; // Note: For MPEG-4, this is really a 'tick rate'
+  unsigned fPictureCount; // hack used to implement doGetNextFrame()
+  Boolean fPictureEndMarker;
+  struct timeval fPresentationTimeBase;
+
+  // parsing state
+  class MPEGVideoStreamParser* fParser;
+  friend class MPEGVideoStreamParser; // hack
+
+private:
+  TimeCode fCurGOPTimeCode, fPrevGOPTimeCode;
+  unsigned fPicturesAdjustment;
+  double fPictureTimeBase;
+  unsigned fTcSecsBase;
+  Boolean fHaveSeenFirstTimeCode;
+};
+
+#endif

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

@@ -0,0 +1,218 @@
+/**********
+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 a Matroska file.
+// C++ header
+
+#ifndef _MATROSKA_FILE_HH
+#define _MATROSKA_FILE_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+#ifndef _FILE_SINK_HH
+#include "FileSink.hh"
+#endif
+#ifndef _HASH_TABLE_HH
+#include "HashTable.hh"
+#endif
+
+class MatroskaTrack; // forward
+class MatroskaDemux; // forward
+
+typedef void MatroskaDemuxOnDeletionFunc(void* objectToNotify, MatroskaDemux* demuxBeingDeleted);
+
+class LIVEMEDIA_API MatroskaFile: public Medium {
+public:
+  typedef void (onCreationFunc)(MatroskaFile* newFile, void* clientData);
+  static void createNew(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
+			char const* preferredLanguage = "eng");
+    // Note: Unlike most "createNew()" functions, this one doesn't return a new object immediately.  Instead, because this class
+    // requires file reading (to parse the Matroska '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()".
+
+  MatroskaTrack* lookup(unsigned trackNumber) const;
+
+  MatroskaDemux* newDemux(MatroskaDemuxOnDeletionFunc* onDeletionFunc = NULL, void* objectToNotify = NULL);
+      // Creates a demultiplexor for extracting tracks from this file.
+      // (Separate clients will typically have separate demultiplexors.)
+
+  // Parameters of the file ('Segment'); set when the file is parsed:
+  unsigned timecodeScale() { return fTimecodeScale; } // in nanoseconds
+  float segmentDuration() { return fSegmentDuration; } // in units of "timecodeScale()"
+  float fileDuration(); // in seconds
+  
+  char const* fileName() const { return fFileName; }
+
+  unsigned chosenVideoTrackNumber() { return fChosenVideoTrackNumber; }
+  unsigned chosenAudioTrackNumber() { return fChosenAudioTrackNumber; }
+  unsigned chosenSubtitleTrackNumber() { return fChosenSubtitleTrackNumber; }
+
+  FramedSource*
+  createSourceForStreaming(FramedSource* baseSource, unsigned 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.
+
+  char const* trackMIMEType(unsigned trackNumber) const;
+      // in the form "<medium-name>/<CODEC-NAME>", or NULL if no such track exists
+
+  RTPSink* createRTPSinkForTrackNumber(unsigned 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
+
+  FileSink* createFileSinkForTrackNumber(unsigned trackNumber, char const* fileName);
+    // Creates a "FileSink" object that would be appropriate for recording the contents of
+    // the specified track, or NULL if no appropriate "FileSink" exists.
+
+private:
+  MatroskaFile(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
+	       char const* preferredLanguage);
+      // called only by createNew()
+  virtual ~MatroskaFile();
+
+  static void handleEndOfTrackHeaderParsing(void* clientData);
+  void handleEndOfTrackHeaderParsing();
+
+  void addTrack(MatroskaTrack* newTrack, unsigned trackNumber);
+  void addCuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster);
+  Boolean lookupCuePoint(double& cueTime, u_int64_t& resultClusterOffsetInFile, unsigned& resultBlockNumWithinCluster);
+  void printCuePoints(FILE* fid);
+
+  void removeDemux(MatroskaDemux* demux);
+
+  void getH264ConfigData(MatroskaTrack const* track,
+			 u_int8_t*& sps, unsigned& spsSize,
+			 u_int8_t*& pps, unsigned& ppsSize);
+    // "sps","pps" are dynamically allocated by this function, and must be delete[]d afterwards
+  void getH265ConfigData(MatroskaTrack const* track,
+			 u_int8_t*& vps, unsigned& vpsSize,
+			 u_int8_t*& sps, unsigned& spsSize,
+			 u_int8_t*& pps, unsigned& ppsSize);
+    // "vps","sps","pps" are dynamically allocated by this function, and must be delete[]d afterwards
+
+  void getVorbisOrTheoraConfigData(MatroskaTrack const* track,
+				   u_int8_t*& identificationHeader, unsigned& identificationHeaderSize,
+				   u_int8_t*& commentHeader, unsigned& commentHeaderSize,
+				   u_int8_t*& setupHeader, unsigned& setupHeaderSize);
+    // "identificationHeader", "commentHeader", "setupHeader" are dynamically allocated by this function, and must be delete[]d afterwards
+
+private:
+  friend class MatroskaFileParser;
+  friend class MatroskaDemux;
+  char const* fFileName;
+  onCreationFunc* fOnCreation;
+  void* fOnCreationClientData;
+  char const* fPreferredLanguage;
+
+  unsigned fTimecodeScale; // in nanoseconds
+  float fSegmentDuration; // in units of "fTimecodeScale"
+  u_int64_t fSegmentDataOffset, fClusterOffset, fCuesOffset;
+
+  class MatroskaTrackTable* fTrackTable;
+  HashTable* fDemuxesTable;
+  class CuePoint* fCuePoints;
+  unsigned fChosenVideoTrackNumber, fChosenAudioTrackNumber, fChosenSubtitleTrackNumber;
+  class MatroskaFileParser* fParserForInitialization;
+};
+
+// We define our own track type codes as bits (powers of 2), so we can use the set of track types as a bitmap, representing a set:
+// (Note that MATROSKA_TRACK_TYPE_OTHER must be last, and have the largest value.)
+#define MATROSKA_TRACK_TYPE_VIDEO 0x01
+#define MATROSKA_TRACK_TYPE_AUDIO 0x02
+#define MATROSKA_TRACK_TYPE_SUBTITLE 0x04
+#define MATROSKA_TRACK_TYPE_OTHER 0x08
+
+class LIVEMEDIA_API MatroskaTrack {
+public:
+  MatroskaTrack();
+  virtual ~MatroskaTrack();
+
+  // track parameters
+  unsigned trackNumber;
+  u_int8_t trackType;
+  Boolean isEnabled, isDefault, isForced;
+  unsigned defaultDuration;
+  char* name;
+  char* language;
+  char* codecID;
+  unsigned samplingFrequency;
+  unsigned numChannels;
+  char const* mimeType;
+  unsigned codecPrivateSize;
+  u_int8_t* codecPrivate;
+  Boolean codecPrivateUsesH264FormatForH265; // a hack specifically for H.265 video tracks
+  Boolean codecIsOpus; // a hack for Opus audio
+  unsigned headerStrippedBytesSize;
+  u_int8_t* headerStrippedBytes;
+  char const* colorSampling;
+  char const* colorimetry;
+  unsigned pixelWidth;
+  unsigned pixelHeight;
+  unsigned bitDepth;
+  unsigned subframeSizeSize; // 0 means: frames do not have subframes (the default behavior)
+  Boolean haveSubframes() const { return subframeSizeSize > 0; }
+};
+
+class LIVEMEDIA_API MatroskaDemux: public Medium {
+public:
+  FramedSource* newDemuxedTrack();
+  FramedSource* newDemuxedTrack(unsigned& resultTrackNumber);
+      // Returns a new stream ("FramedSource" subclass) that represents the next preferred media
+      // track (video, audio, subtitle - in that order) from the file. (Preferred media tracks
+      // are based on the file's language preference.)
+      // 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 MatroskaFile;
+  friend class MatroskaFileParser;
+  class MatroskaDemuxedTrack* lookupDemuxedTrack(unsigned trackNumber);
+
+  MatroskaDemux(MatroskaFile& ourFile); // we're created only by a "MatroskaFile" (a friend)
+  virtual ~MatroskaDemux();
+
+private:
+  friend class MatroskaDemuxedTrack;
+  void removeTrack(unsigned trackNumber);
+  void continueReading(); // called by a demuxed track to tell us that it has a pending read ("doGetNextFrame()")
+  void seekToTime(double& seekNPT);
+  void pause();
+
+  static void handleEndOfFile(void* clientData);
+  void handleEndOfFile();
+
+  void resetState();
+
+private:
+  MatroskaFile& fOurFile;
+  class MatroskaFileParser* fOurParser;
+  HashTable* fDemuxedTracksTable;
+
+  // Used to implement "newServerMediaSubsession()":
+  u_int8_t fNextTrackTypeToCheck;
+};
+
+#endif