MPEG1or2Demux.hh

Go to the documentation of this file.

/**********
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-2024 Live Networks, Inc.  All rights reserved.
// Demultiplexer for a MPEG 1 or 2 Program Stream
// C++ header
 
#ifndef _MPEG_1OR2_DEMUX_HH
#define _MPEG_1OR2_DEMUX_HH
 
#ifndef _FRAMED_SOURCE_HH
#include "FramedSource.hh"
#endif
 
class MPEG1or2DemuxedElementaryStream; // forward
 
typedef void MPEG1or2DemuxOnDeletionFunc(void* objectToNotify, class MPEG1or2Demux* demuxBeingDeleted);
 
class MPEG1or2Demux: public Medium {
public:
  static MPEG1or2Demux* createNew(UsageEnvironment& env,
                                  FramedSource* inputSource,
                                  Boolean reclaimWhenLastESDies = False,
                                  MPEG1or2DemuxOnDeletionFunc* onDeletionFunc = NULL,
                                  void* objectToNotify = NULL);
  // If "reclaimWhenLastESDies" is True, the the demux is deleted when
  // all "MPEG1or2DemuxedElementaryStream"s that we created get deleted.
 
  MPEG1or2DemuxedElementaryStream* newElementaryStream(u_int8_t streamIdTag);
 
  // Specialized versions of the above for audio and video:
  MPEG1or2DemuxedElementaryStream* newAudioStream();
  MPEG1or2DemuxedElementaryStream* newVideoStream();
 
  // A hack for getting raw, undemuxed PES packets from the Program Stream:
  MPEG1or2DemuxedElementaryStream* newRawPESStream();
 
  void getNextFrame(u_int8_t streamIdTag,
                    unsigned char* to, unsigned maxSize,
                    FramedSource::afterGettingFunc* afterGettingFunc,
                    void* afterGettingClientData,
                    FramedSource::onCloseFunc* onCloseFunc,
                    void* onCloseClientData);
      // similar to FramedSource::getNextFrame(), except that it also
      // takes a stream id tag as parameter.
 
  void stopGettingFrames(u_int8_t streamIdTag);
      // similar to FramedSource::stopGettingFrames(), except that it also
      // takes a stream id tag as parameter.
 
  static void handleClosure(void* clientData);
      // This should be called (on ourself) if the source is discovered
      // to be closed (i.e., no longer readable)
 
  FramedSource* inputSource() const { return fInputSource; }
 
  class SCR {
  public:
    SCR();
 
    u_int8_t highBit;
    u_int32_t remainingBits;
    u_int16_t extension;
 
    Boolean isValid;
  };
  SCR& lastSeenSCR() { return fLastSeenSCR; }
 
  unsigned char mpegVersion() const { return fMPEGversion; }
 
  void flushInput(); // should be called before any 'seek' on the underlying source
 
private:
  MPEG1or2Demux(UsageEnvironment& env,
                FramedSource* inputSource, Boolean reclaimWhenLastESDies,
                MPEG1or2DemuxOnDeletionFunc* onDeletionFunc, void* objectToNotify);
      // called only by createNew()
  virtual ~MPEG1or2Demux();
 
  void registerReadInterest(u_int8_t streamIdTag,
                            unsigned char* to, unsigned maxSize,
                            FramedSource::afterGettingFunc* afterGettingFunc,
                            void* afterGettingClientData,
                            FramedSource::onCloseFunc* onCloseFunc,
                            void* onCloseClientData);
 
  Boolean useSavedData(u_int8_t streamIdTag,
                       unsigned char* to, unsigned maxSize,
                       FramedSource::afterGettingFunc* afterGettingFunc,
                       void* afterGettingClientData);
 
  static void continueReadProcessing(void* clientData,
                                     unsigned char* ptr, unsigned size,
                                     struct timeval presentationTime);
  void continueReadProcessing();
 
private:
  friend class MPEG1or2DemuxedElementaryStream;
  void noteElementaryStreamDeletion(MPEG1or2DemuxedElementaryStream* es);
 
private:
  FramedSource* fInputSource;
  SCR fLastSeenSCR;
  unsigned char fMPEGversion;
 
  unsigned char fNextAudioStreamNumber;
  unsigned char fNextVideoStreamNumber;
  Boolean fReclaimWhenLastESDies;
  unsigned fNumOutstandingESs;
 
  // A descriptor for each possible stream id tag:
  typedef struct OutputDescriptor {
    // input parameters
    unsigned char* to; unsigned maxSize;
    FramedSource::afterGettingFunc* fAfterGettingFunc;
    void* afterGettingClientData;
    FramedSource::onCloseFunc* fOnCloseFunc;
    void* onCloseClientData;
 
    // output parameters
    unsigned frameSize; struct timeval presentationTime;
    class SavedData; // forward
    SavedData* savedDataHead;
    SavedData* savedDataTail;
    unsigned savedDataTotalSize;
 
    // status parameters
    Boolean isPotentiallyReadable;
    Boolean isCurrentlyActive;
    Boolean isCurrentlyAwaitingData;
  } OutputDescriptor_t;
  OutputDescriptor_t fOutput[256];
 
  unsigned fNumPendingReads;
  Boolean fHaveUndeliveredData;
 
  MPEG1or2DemuxOnDeletionFunc* fOnDeletionFunc;
  void* fOnDeletionObjectToNotify;
 
private: // parsing state
  class MPEGProgramStreamParser* fParser;
  friend class MPEGProgramStreamParser; // hack
};
 
#endif