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/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_x86_64-simulator/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_x86_64-simulator/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

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

@@ -0,0 +1,140 @@
+/**********
+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 sink for a common kind of payload format: Those which pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// C++ header
+
+#ifndef _MULTI_FRAMED_RTP_SINK_HH
+#define _MULTI_FRAMED_RTP_SINK_HH
+
+#ifndef _RTP_SINK_HH
+#include "RTPSink.hh"
+#endif
+
+class LIVEMEDIA_API MultiFramedRTPSink: public RTPSink {
+public:
+  void setPacketSizes(unsigned preferredPacketSize, unsigned maxPacketSize);
+
+  typedef void (onSendErrorFunc)(void* clientData);
+  void setOnSendErrorFunc(onSendErrorFunc* onSendErrorFunc, void* onSendErrorFuncData) {
+    // Can be used to set a callback function to be called if there's an error sending RTP packets on our socket.
+    fOnSendErrorFunc = onSendErrorFunc;
+    fOnSendErrorData = onSendErrorFuncData;
+  }
+
+protected:
+  MultiFramedRTPSink(UsageEnvironment& env,
+		     Groupsock* rtpgs, unsigned char rtpPayloadType,
+		     unsigned rtpTimestampFrequency,
+		     char const* rtpPayloadFormatName,
+		     unsigned numChannels = 1);
+	// we're a virtual base class
+
+  virtual ~MultiFramedRTPSink();
+
+  virtual void doSpecialFrameHandling(unsigned fragmentationOffset,
+				      unsigned char* frameStart,
+				      unsigned numBytesInFrame,
+				      struct timeval framePresentationTime,
+				      unsigned numRemainingBytes);
+      // perform any processing specific to the particular payload format
+  virtual Boolean allowFragmentationAfterStart() const;
+      // whether a frame can be fragmented if other frame(s) appear earlier
+      // in the packet (by default: False)
+  virtual Boolean allowOtherFramesAfterLastFragment() const;
+      // whether other frames can be packed into a packet following the
+      // final fragment of a previous, fragmented frame (by default: False)
+  virtual Boolean frameCanAppearAfterPacketStart(unsigned char const* frameStart,
+						 unsigned numBytesInFrame) const;
+      // whether this frame can appear in position >1 in a pkt (default: True)
+  virtual unsigned specialHeaderSize() const;
+      // returns the size of any special header used (following the RTP header) (default: 0)
+  virtual unsigned frameSpecificHeaderSize() const;
+      // returns the size of any frame-specific header used (before each frame
+      // within the packet) (default: 0)
+  virtual unsigned computeOverflowForNewFrame(unsigned newFrameSize) const;
+      // returns the number of overflow bytes that would be produced by adding a new
+      // frame of size "newFrameSize" to the current RTP packet.
+      // (By default, this just calls "numOverflowBytes()", but subclasses can redefine
+      // this to (e.g.) impose a granularity upon RTP payload fragments.)
+
+  // Functions that might be called by doSpecialFrameHandling(), or other subclass virtual functions:
+  Boolean isFirstPacket() const { return fIsFirstPacket; }
+  Boolean isFirstFrameInPacket() const { return fNumFramesUsedSoFar == 0; }
+  unsigned curFragmentationOffset() const { return fCurFragmentationOffset; }
+  void setMarkerBit();
+  void setTimestamp(struct timeval framePresentationTime);
+  void setSpecialHeaderWord(unsigned word, /* 32 bits, in host order */
+			    unsigned wordPosition = 0);
+  void setSpecialHeaderBytes(unsigned char const* bytes, unsigned numBytes,
+			     unsigned bytePosition = 0);
+  void setFrameSpecificHeaderWord(unsigned word, /* 32 bits, in host order */
+				  unsigned wordPosition = 0);
+  void setFrameSpecificHeaderBytes(unsigned char const* bytes, unsigned numBytes,
+				   unsigned bytePosition = 0);
+  void setFramePadding(unsigned numPaddingBytes);
+  unsigned numFramesUsedSoFar() const { return fNumFramesUsedSoFar; }
+  unsigned ourMaxPacketSize() const { return fOurMaxPacketSize; }
+
+public: // redefined virtual functions:
+  virtual void stopPlaying();
+
+protected: // redefined virtual functions:
+  virtual Boolean continuePlaying();
+
+private:
+  void buildAndSendPacket(Boolean isFirstPacket);
+  void packFrame();
+  void sendPacketIfNecessary();
+  static void sendNext(void* firstArg);
+  friend void sendNext(void*);
+
+  static void afterGettingFrame(void* clientData,
+				unsigned numBytesRead, unsigned numTruncatedBytes,
+				struct timeval presentationTime,
+				unsigned durationInMicroseconds);
+  void afterGettingFrame1(unsigned numBytesRead, unsigned numTruncatedBytes,
+			  struct timeval presentationTime,
+			  unsigned durationInMicroseconds);
+  Boolean isTooBigForAPacket(unsigned numBytes) const;
+
+  static void ourHandleClosure(void* clientData);
+
+private:
+  OutPacketBuffer* fOutBuf;
+
+  Boolean fNoFramesLeft;
+  unsigned fNumFramesUsedSoFar;
+  unsigned fCurFragmentationOffset;
+  Boolean fPreviousFrameEndedFragmentation;
+
+  Boolean fIsFirstPacket;
+  struct timeval fNextSendTime;
+  unsigned fTimestampPosition;
+  unsigned fSpecialHeaderPosition;
+  unsigned fSpecialHeaderSize; // size in bytes of any special header used
+  unsigned fCurFrameSpecificHeaderPosition;
+  unsigned fCurFrameSpecificHeaderSize; // size in bytes of cur frame-specific header
+  unsigned fTotalFrameSpecificHeaderSizes; // size of all frame-specific hdrs in pkt
+  unsigned fOurMaxPacketSize;
+
+  onSendErrorFunc* fOnSendErrorFunc;
+  void* fOnSendErrorData;
+};
+
+#endif

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

@@ -0,0 +1,159 @@
+/**********
+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 source for a common kind of payload format: Those which pack multiple,
+// complete codec frames (as many as possible) into each RTP packet.
+// C++ header
+
+#ifndef _MULTI_FRAMED_RTP_SOURCE_HH
+#define _MULTI_FRAMED_RTP_SOURCE_HH
+
+#ifndef _RTP_SOURCE_HH
+#include "RTPSource.hh"
+#endif
+
+class BufferedPacket; // forward
+class BufferedPacketFactory; // forward
+
+class LIVEMEDIA_API MultiFramedRTPSource: public RTPSource {
+protected:
+  MultiFramedRTPSource(UsageEnvironment& env, Groupsock* RTPgs,
+		       unsigned char rtpPayloadFormat,
+		       unsigned rtpTimestampFrequency,
+		       BufferedPacketFactory* packetFactory = NULL);
+      // virtual base class
+  virtual ~MultiFramedRTPSource();
+
+  virtual Boolean processSpecialHeader(BufferedPacket* packet,
+				       unsigned& resultSpecialHeaderSize);
+      // Subclasses redefine this to handle any special, payload format
+      // specific header that follows the RTP header.
+
+  virtual Boolean packetIsUsableInJitterCalculation(unsigned char* packet,
+						    unsigned packetSize);
+      // The default implementation returns True, but this can be redefined
+
+protected:
+  Boolean fCurrentPacketBeginsFrame;
+  Boolean fCurrentPacketCompletesFrame;
+
+protected:
+  // redefined virtual functions:
+  virtual void doGetNextFrame();
+  virtual void doStopGettingFrames();
+
+private:
+  // redefined virtual functions:
+  virtual void setPacketReorderingThresholdTime(unsigned uSeconds);
+
+private:
+  void reset();
+  void doGetNextFrame1();
+
+  static void networkReadHandler(MultiFramedRTPSource* source, int /*mask*/);
+  void networkReadHandler1();
+
+  Boolean fAreDoingNetworkReads;
+  BufferedPacket* fPacketReadInProgress;
+  Boolean fNeedDelivery;
+  Boolean fPacketLossInFragmentedFrame;
+  unsigned char* fSavedTo;
+  unsigned fSavedMaxSize;
+
+  // A buffer to (optionally) hold incoming pkts that have been reorderered
+  class ReorderingPacketBuffer* fReorderingBuffer;
+};
+
+
+// A 'packet data' class that's used to implement the above.
+// Note that this can be subclassed - if desired - to redefine
+// "nextEnclosedFrameParameters()".
+
+class LIVEMEDIA_API BufferedPacket {
+public:
+  BufferedPacket();
+  virtual ~BufferedPacket();
+
+  Boolean hasUsableData() const { return fTail > fHead; }
+  unsigned useCount() const { return fUseCount; }
+
+  Boolean fillInData(RTPInterface& rtpInterface, struct sockaddr_storage& fromAddress, Boolean& packetReadWasIncomplete);
+  void assignMiscParams(unsigned short rtpSeqNo, unsigned rtpTimestamp,
+			struct timeval presentationTime,
+			Boolean hasBeenSyncedUsingRTCP,
+			Boolean rtpMarkerBit, struct timeval timeReceived);
+  void skip(unsigned numBytes); // used to skip over an initial header
+  void removePadding(unsigned numBytes); // used to remove trailing bytes
+  void appendData(unsigned char* newData, unsigned numBytes);
+  void use(unsigned char* to, unsigned toSize,
+	   unsigned& bytesUsed, unsigned& bytesTruncated,
+	   unsigned short& rtpSeqNo, unsigned& rtpTimestamp,
+	   struct timeval& presentationTime,
+	   Boolean& hasBeenSyncedUsingRTCP, Boolean& rtpMarkerBit);
+
+  BufferedPacket*& nextPacket() { return fNextPacket; }
+
+  unsigned short rtpSeqNo() const { return fRTPSeqNo; }
+  struct timeval const& timeReceived() const { return fTimeReceived; }
+
+  unsigned char* data() const { return &fBuf[fHead]; }
+  unsigned dataSize() const { return fTail-fHead; }
+  Boolean rtpMarkerBit() const { return fRTPMarkerBit; }
+  Boolean& isFirstPacket() { return fIsFirstPacket; }
+  unsigned bytesAvailable() const { return fPacketSize - fTail; }
+
+protected:
+  virtual void reset();
+  virtual unsigned nextEnclosedFrameSize(unsigned char*& framePtr,
+					 unsigned dataSize);
+      // The above function has been deprecated.  Instead, new subclasses should use:
+  virtual void getNextEnclosedFrameParameters(unsigned char*& framePtr,
+					      unsigned dataSize,
+					      unsigned& frameSize,
+					      unsigned& frameDurationInMicroseconds);
+
+  unsigned fPacketSize;
+  unsigned char* fBuf;
+  unsigned fHead;
+  unsigned fTail;
+
+private:
+  BufferedPacket* fNextPacket; // used to link together packets
+
+  unsigned fUseCount;
+  unsigned short fRTPSeqNo;
+  unsigned fRTPTimestamp;
+  struct timeval fPresentationTime; // corresponding to "fRTPTimestamp"
+  Boolean fHasBeenSyncedUsingRTCP;
+  Boolean fRTPMarkerBit;
+  Boolean fIsFirstPacket;
+  struct timeval fTimeReceived;
+};
+
+// A 'factory' class for creating "BufferedPacket" objects.
+// If you want to subclass "BufferedPacket", then you'll also
+// want to subclass this, to redefine createNewPacket()
+
+class LIVEMEDIA_API BufferedPacketFactory {
+public:
+  BufferedPacketFactory();
+  virtual ~BufferedPacketFactory();
+
+  virtual BufferedPacket* createNewPacket(MultiFramedRTPSource* ourSource);
+};
+
+#endif