MPEGProgramStreamParser Class Reference

Inheritance diagram for MPEGProgramStreamParser:

[legend]Collaboration diagram for MPEGProgramStreamParser:

[legend]

Public Member Functions
	MPEGProgramStreamParser (MPEG1or2Demux *usingDemux, FramedSource *inputSource)
virtual	~MPEGProgramStreamParser ()
unsigned char	parse ()
virtual void	flushInput ()
Protected Types
typedef void(	clientContinueFunc )(void *clientData, unsigned char *ptr, unsigned size, struct timeval presentationTime)
Protected Member Functions
void	saveParserState ()
virtual void	restoreSavedParserState ()
u_int32_t	get4Bytes ()
u_int32_t	test4Bytes ()
u_int16_t	get2Bytes ()
u_int8_t	get1Byte ()
u_int8_t	test1Byte (unsigned numBytes)
void	getBytes (u_int8_t *to, unsigned numBytes)
void	testBytes (u_int8_t *to, unsigned numBytes)
void	skipBytes (unsigned numBytes)
void	skipBits (unsigned numBits)
unsigned	getBits (unsigned numBits)
unsigned	curOffset () const
unsigned &	totNumValidBytes ()
Boolean	haveSeenEOF () const
unsigned	bankSize () const
Private Member Functions
void	setParseState (MPEGParseState parseState)
void	parsePackHeader ()
void	parseSystemHeader ()
unsigned char	parsePESPacket ()
Boolean	isSpecialStreamId (unsigned char stream_id) const
Private Attributes
MPEG1or2Demux *	fUsingDemux
MPEGParseState	fCurrentParseState

---

Detailed Description

Definition at line 35 of file MPEG1or2Demux.cpp.

---

Member Typedef Documentation

typedef void( StreamParser::clientContinueFunc)(void *clientData, unsigned char *ptr, unsigned size, struct timeval presentationTime) [protected, inherited]

Definition at line 33 of file StreamParser.hh.

---

Constructor & Destructor Documentation

MPEGProgramStreamParser::MPEGProgramStreamParser	(	MPEG1or2Demux *	usingDemux,
		FramedSource *	inputSource
	)

Definition at line 328 of file MPEG1or2Demux.cpp.

  : StreamParser(inputSource, MPEG1or2Demux::handleClosure, usingDemux,
                 &MPEG1or2Demux::continueReadProcessing, usingDemux),
  fUsingDemux(usingDemux), fCurrentParseState(PARSING_PACK_HEADER) {
}

MPEGProgramStreamParser::~MPEGProgramStreamParser

(

)

[virtual]

Definition at line 335 of file MPEG1or2Demux.cpp.

                                                  {
}

---

Member Function Documentation

unsigned char MPEGProgramStreamParser::parse

(

)

Definition at line 343 of file MPEG1or2Demux.cpp.

References fCurrentParseState, parsePackHeader(), parsePESPacket(), parseSystemHeader(), PARSING_PACK_HEADER, PARSING_PES_PACKET, and PARSING_SYSTEM_HEADER.

Referenced by MPEG1or2Demux::continueReadProcessing().

                                             {
  unsigned char acquiredStreamTagId = 0;

  try {
    do {
      switch (fCurrentParseState) {
      case PARSING_PACK_HEADER: {
        parsePackHeader();
        break;
      }
      case PARSING_SYSTEM_HEADER: {
        parseSystemHeader();
        break;
      }
      case PARSING_PES_PACKET: {
        acquiredStreamTagId = parsePESPacket();
        break;
      }
      }
    } while(acquiredStreamTagId == 0);

    return acquiredStreamTagId;
  } catch (int /*e*/) {
#ifdef DEBUG
    fprintf(stderr, "MPEGProgramStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
    fflush(stderr);
#endif
    return 0;  // the parsing got interrupted
  }
}

void MPEGProgramStreamParser::setParseState

(

MPEGParseState

parseState

)

[private]

Definition at line 338 of file MPEG1or2Demux.cpp.

References fCurrentParseState, and StreamParser::saveParserState().

Referenced by parsePackHeader(), parsePESPacket(), and parseSystemHeader().

                                                                     {
  fCurrentParseState = parseState;
  saveParserState();
}

void MPEGProgramStreamParser::parsePackHeader

(

)

[private]

Definition at line 383 of file MPEG1or2Demux.cpp.

References Medium::envir(), MPEG1or2Demux::SCR::extension, MPEG1or2Demux::fLastSeenSCR, MPEG1or2Demux::fMPEGversion, fUsingDemux, StreamParser::get1Byte(), StreamParser::get4Bytes(), StreamParser::getBits(), MPEG1or2Demux::SCR::highBit, isPacketStartCode(), MPEG1or2Demux::SCR::isValid, PACK_START_CODE, PARSING_PACK_HEADER, PARSING_PES_PACKET, PARSING_SYSTEM_HEADER, MPEG1or2Demux::SCR::remainingBits, setParseState(), StreamParser::skipBits(), StreamParser::skipBytes(), SYSTEM_HEADER_START_CODE, StreamParser::test4Bytes(), and True.

Referenced by parse().

                                              {
#ifdef DEBUG
  fprintf(stderr, "parsing pack header\n"); fflush(stderr);
#endif
  unsigned first4Bytes;
  while (1) {
    first4Bytes = test4Bytes();

    // We're supposed to have a pack header here, but check also for
    // a system header or a PES packet, just in case:
    if (first4Bytes == PACK_START_CODE) {
      skipBytes(4);
      break;
    } else if (first4Bytes == SYSTEM_HEADER_START_CODE) {
#ifdef DEBUG
      fprintf(stderr, "found system header instead of pack header\n");
#endif
      setParseState(PARSING_SYSTEM_HEADER);
      return;
    } else if (isPacketStartCode(first4Bytes)) {
#ifdef DEBUG
      fprintf(stderr, "found packet start code 0x%02x instead of pack header\n", first4Bytes);
#endif
      setParseState(PARSING_PES_PACKET);
      return;
    }

    setParseState(PARSING_PACK_HEADER); // ensures we progress over bad data
    if ((first4Bytes&0xFF) > 1) { // a system code definitely doesn't start here
      skipBytes(4);
    } else {
      skipBytes(1);
    }
  }

  // The size of the pack header differs depending on whether it's
  // MPEG-1 or MPEG-2.  The next byte tells us this:
  unsigned char nextByte = get1Byte();
  MPEG1or2Demux::SCR& scr = fUsingDemux->fLastSeenSCR; // alias
  if ((nextByte&0xF0) == 0x20) { // MPEG-1
    fUsingDemux->fMPEGversion = 1;
    scr.highBit =  (nextByte&0x08)>>3;
    scr.remainingBits = (nextByte&0x06)<<29;
    unsigned next4Bytes = get4Bytes();
    scr.remainingBits |= (next4Bytes&0xFFFE0000)>>2;
    scr.remainingBits |= (next4Bytes&0x0000FFFE)>>1;
    scr.extension = 0;
    scr.isValid = True;
    skipBits(24);

#if defined(DEBUG_TIMESTAMPS) || defined(DEBUG_SCR_TIMESTAMPS)
    fprintf(stderr, "pack hdr system_clock_reference_base: 0x%x",
            scr.highBit);
    fprintf(stderr, "%08x\n", scr.remainingBits);
#endif
  } else if ((nextByte&0xC0) == 0x40) { // MPEG-2
    fUsingDemux->fMPEGversion = 2;
    scr.highBit =  (nextByte&0x20)>>5;
    scr.remainingBits = (nextByte&0x18)<<27;
    scr.remainingBits |= (nextByte&0x03)<<28;
    unsigned next4Bytes = get4Bytes();
    scr.remainingBits |= (next4Bytes&0xFFF80000)>>4;
    scr.remainingBits |= (next4Bytes&0x0003FFF8)>>3;
    scr.extension = (next4Bytes&0x00000003)<<7;
    next4Bytes = get4Bytes();
    scr.extension |= (next4Bytes&0xFE000000)>>25;
    scr.isValid = True;
    skipBits(5);

#if defined(DEBUG_TIMESTAMPS) || defined(DEBUG_SCR_TIMESTAMPS)
    fprintf(stderr, "pack hdr system_clock_reference_base: 0x%x",
            scr.highBit);
    fprintf(stderr, "%08x\n", scr.remainingBits);
    fprintf(stderr, "pack hdr system_clock_reference_extension: 0x%03x\n",
            scr.extension);
#endif
    unsigned char pack_stuffing_length = getBits(3);
    skipBytes(pack_stuffing_length);
  } else { // unknown
    fUsingDemux->envir() << "StreamParser::parsePack() saw strange byte "
                          << (void*)nextByte
                          << " following pack_start_code\n";
  }

  // Check for a System Header next:
  setParseState(PARSING_SYSTEM_HEADER);
}

void MPEGProgramStreamParser::parseSystemHeader

(

)

[private]

Definition at line 471 of file MPEG1or2Demux.cpp.

References Medium::envir(), fUsingDemux, StreamParser::get2Bytes(), PARSING_PES_PACKET, setParseState(), StreamParser::skipBytes(), SYSTEM_HEADER_START_CODE, and StreamParser::test4Bytes().

Referenced by parse().

                                                {
#ifdef DEBUG
  fprintf(stderr, "parsing system header\n"); fflush(stderr);
#endif
  unsigned next4Bytes = test4Bytes();
  if (next4Bytes != SYSTEM_HEADER_START_CODE) {
    // The system header was optional.  Look for a PES Packet instead:
    setParseState(PARSING_PES_PACKET);
    return;
  }

#ifdef DEBUG
  fprintf(stderr, "saw system_header_start_code\n"); fflush(stderr);
#endif
  skipBytes(4); // we've already seen the system_header_start_code

  unsigned short remaining_header_length = get2Bytes();

  // According to the MPEG-1 and MPEG-2 specs, "remaining_header_length" should be
  // at least 6 bytes.  Check this now:
  if (remaining_header_length < 6) {
    fUsingDemux->envir() << "StreamParser::parseSystemHeader(): saw strange header_length: "
                          << remaining_header_length << " < 6\n";
  }
  skipBytes(remaining_header_length);

  // Check for a PES Packet next:
  setParseState(PARSING_PES_PACKET);
}

unsigned char MPEGProgramStreamParser::parsePESPacket

(

)

[private]

Definition at line 525 of file MPEG1or2Demux.cpp.

References StreamParser::curOffset(), Medium::envir(), MPEG1or2Demux::fHaveUndeliveredData, MPEG1or2Demux::fMPEGversion, MPEG1or2Demux::fOutput, MPEG1or2Demux::OutputDescriptor::frameSize, fUsingDemux, StreamParser::get1Byte(), StreamParser::get2Bytes(), StreamParser::get4Bytes(), StreamParser::getBits(), StreamParser::getBytes(), MPEG1or2Demux::OutputDescriptor::isCurrentlyActive, MPEG1or2Demux::OutputDescriptor::isCurrentlyAwaitingData, isPacketStartCode(), MPEG1or2Demux::OutputDescriptor::isPotentiallyReadable, isSpecialStreamId(), MPEG1or2Demux::OutputDescriptor::maxSize, NULL, PARSING_PACK_HEADER, PARSING_PES_PACKET, RAW_PES, READER_NOT_READY, StreamParser::restoreSavedParserState(), MPEG1or2Demux::OutputDescriptor::savedDataHead, MPEG1or2Demux::OutputDescriptor::savedDataTail, MPEG1or2Demux::OutputDescriptor::savedDataTotalSize, setParseState(), StreamParser::skipBytes(), StreamParser::test4Bytes(), MPEG1or2Demux::OutputDescriptor::to, and True.

Referenced by parse().

                                                      {
#ifdef DEBUG
  fprintf(stderr, "parsing PES packet\n"); fflush(stderr);
#endif
  unsigned next4Bytes = test4Bytes();
  if (!isPacketStartCode(next4Bytes)) {
    // The PES Packet was optional.  Look for a Pack Header instead:
    setParseState(PARSING_PACK_HEADER);
    return 0;
  }

#ifdef DEBUG
  fprintf(stderr, "saw packet_start_code_prefix\n"); fflush(stderr);
#endif
  skipBytes(3); // we've already seen the packet_start_code_prefix

  unsigned char stream_id = get1Byte();
#if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
  unsigned char streamNum = stream_id;
  char const* streamTypeStr;
  if ((stream_id&0xE0) == 0xC0) {
    streamTypeStr = "audio";
    streamNum = stream_id&~0xE0;
  } else if ((stream_id&0xF0) == 0xE0) {
    streamTypeStr = "video";
    streamNum = stream_id&~0xF0;
  } else if (stream_id == 0xbc) {
    streamTypeStr = "reserved";
  } else if (stream_id == 0xbd) {
    streamTypeStr = "private_1";
  } else if (stream_id == 0xbe) {
    streamTypeStr = "padding";
  } else if (stream_id == 0xbf) {
    streamTypeStr = "private_2";
  } else {
    streamTypeStr = "unknown";
  }
#endif
#ifdef DEBUG
  static unsigned frameCount = 1;
  fprintf(stderr, "%d, saw %s stream: 0x%02x\n", frameCount, streamTypeStr, streamNum); fflush(stderr);
#endif

  unsigned short PES_packet_length = get2Bytes();
#ifdef DEBUG
  fprintf(stderr, "PES_packet_length: %d\n", PES_packet_length); fflush(stderr);
#endif

  // Parse over the rest of the header, until we get to the packet data itself.
  // This varies depending upon the MPEG version:
  if (fUsingDemux->fOutput[RAW_PES].isPotentiallyReadable) {
    // Hack: We've been asked to return raw PES packets, for every stream:
    stream_id = RAW_PES;
  }
  unsigned savedParserOffset = curOffset();
#ifdef DEBUG_TIMESTAMPS
  unsigned char pts_highBit = 0;
  unsigned pts_remainingBits = 0;
  unsigned char dts_highBit = 0;
  unsigned dts_remainingBits = 0;
#endif
  if (fUsingDemux->fMPEGversion == 1) {
    if (!isSpecialStreamId(stream_id)) {
      unsigned char nextByte;
      while ((nextByte = get1Byte()) == 0xFF) { // stuffing_byte
      }
      if ((nextByte&0xC0) == 0x40) { // '01'
        skipBytes(1);
        nextByte = get1Byte();
      }
      if ((nextByte&0xF0) == 0x20) { // '0010'
#ifdef DEBUG_TIMESTAMPS
        pts_highBit =  (nextByte&0x08)>>3;
        pts_remainingBits = (nextByte&0x06)<<29;
        unsigned next4Bytes = get4Bytes();
        pts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        pts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;
#else
        skipBytes(4);
#endif
      } else if ((nextByte&0xF0) == 0x30) { // '0011'
#ifdef DEBUG_TIMESTAMPS
        pts_highBit =  (nextByte&0x08)>>3;
        pts_remainingBits = (nextByte&0x06)<<29;
        unsigned next4Bytes = get4Bytes();
        pts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        pts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;

        nextByte = get1Byte();
        dts_highBit =  (nextByte&0x08)>>3;
        dts_remainingBits = (nextByte&0x06)<<29;
        next4Bytes = get4Bytes();
        dts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        dts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;
#else
        skipBytes(9);
#endif
      }
    }
  } else { // assume MPEG-2
    if (!isSpecialStreamId(stream_id)) {
      // Fields in the next 3 bytes determine the size of the rest:
      unsigned next3Bytes = getBits(24);
#ifdef DEBUG_TIMESTAMPS
      unsigned char PTS_DTS_flags       = (next3Bytes&0x00C000)>>14;
#endif
#ifdef undef
      unsigned char ESCR_flag           = (next3Bytes&0x002000)>>13;
      unsigned char ES_rate_flag        = (next3Bytes&0x001000)>>12;
      unsigned char DSM_trick_mode_flag = (next3Bytes&0x000800)>>11;
#endif
      unsigned char PES_header_data_length = (next3Bytes&0x0000FF);
#ifdef DEBUG
      fprintf(stderr, "PES_header_data_length: 0x%02x\n", PES_header_data_length); fflush(stderr);
#endif
#ifdef DEBUG_TIMESTAMPS
      if (PTS_DTS_flags == 0x2 && PES_header_data_length >= 5) {
        unsigned char nextByte = get1Byte();
        pts_highBit =  (nextByte&0x08)>>3;
        pts_remainingBits = (nextByte&0x06)<<29;
        unsigned next4Bytes = get4Bytes();
        pts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        pts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;

        skipBytes(PES_header_data_length-5);
      } else if (PTS_DTS_flags == 0x3 && PES_header_data_length >= 10) {
        unsigned char nextByte = get1Byte();
        pts_highBit =  (nextByte&0x08)>>3;
        pts_remainingBits = (nextByte&0x06)<<29;
        unsigned next4Bytes = get4Bytes();
        pts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        pts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;

        nextByte = get1Byte();
        dts_highBit =  (nextByte&0x08)>>3;
        dts_remainingBits = (nextByte&0x06)<<29;
        next4Bytes = get4Bytes();
        dts_remainingBits |= (next4Bytes&0xFFFE0000)>>2;
        dts_remainingBits |= (next4Bytes&0x0000FFFE)>>1;

        skipBytes(PES_header_data_length-10);
      }
#else
      skipBytes(PES_header_data_length);
#endif
    }
  }
#ifdef DEBUG_TIMESTAMPS
  fprintf(stderr, "%s stream, ", streamTypeStr);
  fprintf(stderr, "packet presentation_time_stamp: 0x%x", pts_highBit);
  fprintf(stderr, "%08x\n", pts_remainingBits);
  fprintf(stderr, "\t\tpacket decoding_time_stamp: 0x%x", dts_highBit);
  fprintf(stderr, "%08x\n", dts_remainingBits);
#endif

  // The rest of the packet will be the "PES_packet_data_byte"s
  // Make sure that "PES_packet_length" was consistent with where we are now:
  unsigned char acquiredStreamIdTag = 0;
  unsigned currentParserOffset = curOffset();
  unsigned bytesSkipped = currentParserOffset - savedParserOffset;
  if (stream_id == RAW_PES) {
    restoreSavedParserState(); // so we deliver from the beginning of the PES packet
    PES_packet_length += 6; // to include the whole of the PES packet
    bytesSkipped = 0;
  }
  if (PES_packet_length < bytesSkipped) {
    fUsingDemux->envir() << "StreamParser::parsePESPacket(): saw inconsistent PES_packet_length "
                          << PES_packet_length << " < "
                          << bytesSkipped << "\n";
  } else {
    PES_packet_length -= bytesSkipped;
#ifdef DEBUG
    unsigned next4Bytes = test4Bytes();
#endif

    // Check whether our using source is interested in this stream type.
    // If so, deliver the frame to him:
    MPEG1or2Demux::OutputDescriptor_t& out = fUsingDemux->fOutput[stream_id];
    if (out.isCurrentlyAwaitingData) {
      unsigned numBytesToCopy;
      if (PES_packet_length > out.maxSize) {
        fUsingDemux->envir() << "MPEGProgramStreamParser::parsePESPacket() error: PES_packet_length ("
                              << PES_packet_length
                              << ") exceeds max frame size asked for ("
                              << out.maxSize << ")\n";
        numBytesToCopy = out.maxSize;
      } else {
        numBytesToCopy = PES_packet_length;
      }

      getBytes(out.to, numBytesToCopy);
      out.frameSize = numBytesToCopy;
#ifdef DEBUG
      fprintf(stderr, "%d, %d bytes of PES_packet_data (out.maxSize: %d); first 4 bytes: 0x%08x\n", frameCount, numBytesToCopy, out.maxSize, next4Bytes); fflush(stderr);
#endif
      // set out.presentationTime later #####
      acquiredStreamIdTag = stream_id;
      PES_packet_length -= numBytesToCopy;
    } else if (out.isCurrentlyActive) {
      // Someone has been reading this stream, but isn't right now.
      // We can't deliver this frame until he asks for it, so punt for now.
      // The next time he asks for a frame, he'll get it.
#ifdef DEBUG
      fprintf(stderr, "%d, currently undeliverable PES data; first 4 bytes: 0x%08x - currently undeliverable!\n", frameCount, next4Bytes); fflush(stderr);
#endif
      restoreSavedParserState(); // so we read from the beginning next time
      fUsingDemux->fHaveUndeliveredData = True;
      throw READER_NOT_READY;
    } else if (out.isPotentiallyReadable &&
               out.savedDataTotalSize + PES_packet_length < 1000000 /*limit*/) {
      // Someone is interested in this stream, but hasn't begun reading it yet.
      // Save this data, so that the reader will get it when he later asks for it.
      unsigned char* buf = new unsigned char[PES_packet_length];
      getBytes(buf, PES_packet_length);
      MPEG1or2Demux::OutputDescriptor::SavedData* savedData
        = new MPEG1or2Demux::OutputDescriptor::SavedData(buf, PES_packet_length);
      if (out.savedDataHead == NULL) {
        out.savedDataHead = out.savedDataTail = savedData;
      } else {
        out.savedDataTail->next = savedData;
        out.savedDataTail = savedData;
      }
      out.savedDataTotalSize += PES_packet_length;
      PES_packet_length = 0;
    }
    skipBytes(PES_packet_length);
  }

  // Check for another PES Packet next:
  setParseState(PARSING_PES_PACKET);
#ifdef DEBUG
  ++frameCount;
#endif
 return acquiredStreamIdTag;
}

Boolean MPEGProgramStreamParser::isSpecialStreamId

(

unsigned char

stream_id

)

const [private]

Definition at line 506 of file MPEG1or2Demux.cpp.

References False, MPEG1or2Demux::fMPEGversion, fUsingDemux, private_stream_1, private_stream_2, RAW_PES, and True.

Referenced by parsePESPacket().

                                                 {
  if (stream_id == RAW_PES) return True; // hack

  if (fUsingDemux->fMPEGversion == 1) {
    return stream_id == private_stream_2;
  } else { // assume MPEG-2
    if (stream_id <= private_stream_2) {
      return stream_id != private_stream_1;
    } else if ((stream_id&0xF0) == 0xF0) {
      unsigned char lower4Bits = stream_id&0x0F;
      return lower4Bits <= 2 || lower4Bits == 0x8 || lower4Bits == 0xF;
    } else {
      return False;
    }
  }
}

void StreamParser::flushInput

(

)

[virtual, inherited]

Reimplemented in H264VideoStreamParser, MPEG1or2VideoStreamParser, and MPEG4VideoStreamParser.

Definition at line 28 of file StreamParser.cpp.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, StreamParser::fSavedParserIndex, StreamParser::fSavedRemainingUnparsedBits, and StreamParser::fTotNumValidBytes.

Referenced by MPEGVideoStreamFramer::flushInput(), MPEG4VideoStreamParser::flushInput(), MPEG1or2VideoStreamParser::flushInput(), MPEG1or2Demux::flushInput(), MPEG1or2AudioStreamFramer::flushInput(), H264VideoStreamParser::flushInput(), AC3AudioStreamFramer::flushInput(), and MatroskaFileParser::resetStateAfterSeeking().

                              {
  fCurParserIndex = fSavedParserIndex = 0;
  fSavedRemainingUnparsedBits = fRemainingUnparsedBits = 0;
  fTotNumValidBytes = 0;
}

void StreamParser::saveParserState

(

)

[protected, inherited]

Definition at line 58 of file StreamParser.cpp.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, StreamParser::fSavedParserIndex, and StreamParser::fSavedRemainingUnparsedBits.

Referenced by MPEG1or2AudioStreamParser::parse(), AC3AudioStreamParser::parseFrame(), MPEGVideoStreamParser::setParseState(), setParseState(), MatroskaFileParser::setParseState(), and H263plusVideoStreamParser::setParseState().

                                   {
  fSavedParserIndex = fCurParserIndex;
  fSavedRemainingUnparsedBits = fRemainingUnparsedBits;
}

void StreamParser::restoreSavedParserState

(

)

[protected, virtual, inherited]

Reimplemented in H263plusVideoStreamParser, MatroskaFileParser, and MPEGVideoStreamParser.

Definition at line 63 of file StreamParser.cpp.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, StreamParser::fSavedParserIndex, and StreamParser::fSavedRemainingUnparsedBits.

Referenced by StreamParser::afterGettingBytes1(), parsePESPacket(), MPEGVideoStreamParser::restoreSavedParserState(), MatroskaFileParser::restoreSavedParserState(), and H263plusVideoStreamParser::restoreSavedParserState().

                                           {
  fCurParserIndex = fSavedParserIndex;
  fRemainingUnparsedBits = fSavedRemainingUnparsedBits;
}

u_int32_t StreamParser::get4Bytes

(

)

[inline, protected, inherited]

Definition at line 46 of file StreamParser.hh.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, and StreamParser::test4Bytes().

Referenced by AC3AudioStreamParser::parseFrame(), MPEG1or2VideoStreamParser::parseGOPHeader(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), parsePackHeader(), parsePESPacket(), MPEG1or2VideoStreamParser::parsePictureHeader(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), MPEG1or2VideoStreamParser::parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEGVideoStreamParser::saveToNextCode(), and MPEGVideoStreamParser::skipToNextCode().

                        { // byte-aligned; returned in big-endian order
    u_int32_t result = test4Bytes();
    fCurParserIndex += 4;
    fRemainingUnparsedBits = 0;

    return result;
  }

u_int32_t StreamParser::test4Bytes

(

)

[inline, protected, inherited]

Definition at line 53 of file StreamParser.hh.

References StreamParser::ensureValidBytes(), and StreamParser::nextToParse().

Referenced by StreamParser::get4Bytes(), StreamParser::getBits(), MPEG1or2AudioStreamParser::parse(), H264VideoStreamParser::parse(), AC3AudioStreamParser::parseFrame(), MPEG1or2VideoStreamParser::parseGOPHeader(), parsePackHeader(), parsePESPacket(), parseSystemHeader(), MPEG1or2VideoStreamParser::parseVideoSequenceHeader(), and MPEG4VideoStreamParser::parseVisualObjectSequence().

                         { // as above, but doesn't advance ptr
    ensureValidBytes(4);

    unsigned char const* ptr = nextToParse();
    return (ptr[0]<<24)|(ptr[1]<<16)|(ptr[2]<<8)|ptr[3];
  }

u_int16_t StreamParser::get2Bytes

(

)

[inline, protected, inherited]

Definition at line 60 of file StreamParser.hh.

References StreamParser::ensureValidBytes(), StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, and StreamParser::nextToParse().

Referenced by parsePESPacket(), and parseSystemHeader().

                        {
    ensureValidBytes(2);

    unsigned char const* ptr = nextToParse();
    u_int16_t result = (ptr[0]<<8)|ptr[1];

    fCurParserIndex += 2;
    fRemainingUnparsedBits = 0;

    return result;
  }

u_int8_t StreamParser::get1Byte

(

)

[inline, protected, inherited]

Definition at line 72 of file StreamParser.hh.

References StreamParser::curBank(), StreamParser::ensureValidBytes(), StreamParser::fCurParserIndex, and StreamParser::fRemainingUnparsedBits.

Referenced by MatroskaFileParser::deliverFrameWithinBlock(), H264VideoStreamParser::parse(), MatroskaFileParser::parseBlock(), MatroskaFileParser::parseEBMLNumber(), MatroskaFileParser::parseEBMLVal_binary(), MatroskaFileParser::parseEBMLVal_string(), MatroskaFileParser::parseEBMLVal_unsigned64(), MPEG1or2VideoStreamParser::parseGOPHeader(), H263plusVideoStreamParser::parseH263Frame(), parsePackHeader(), parsePESPacket(), MPEG4VideoStreamParser::parseVideoObjectPlane(), MPEG1or2VideoStreamParser::parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEGVideoStreamParser::saveToNextCode(), and MPEGVideoStreamParser::skipToNextCode().

                      { // byte-aligned
    ensureValidBytes(1);
    fRemainingUnparsedBits = 0;
    return curBank()[fCurParserIndex++];
  }

u_int8_t StreamParser::test1Byte

(

unsigned

numBytes

)

[inline, protected, inherited]

Definition at line 77 of file StreamParser.hh.

References StreamParser::ensureValidBytes(), and StreamParser::nextToParse().

                                        { // as above, but doesn't advance ptr
    ensureValidBytes(1);
    return nextToParse()[0];
  }

void StreamParser::getBytes	(	u_int8_t *	to,
		unsigned	numBytes
	)			[inline, protected, inherited]

Definition at line 82 of file StreamParser.hh.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, and StreamParser::testBytes().

Referenced by MatroskaFileParser::deliverFrameBytes(), MPEG1or2AudioStreamParser::parse(), AC3AudioStreamParser::parseFrame(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), H263plusVideoStreamParser::parseH263Frame(), and parsePESPacket().

                                                 {
    testBytes(to, numBytes);
    fCurParserIndex += numBytes;
    fRemainingUnparsedBits = 0;
  }

void StreamParser::testBytes	(	u_int8_t *	to,
		unsigned	numBytes
	)			[inline, protected, inherited]

Definition at line 87 of file StreamParser.hh.

References StreamParser::ensureValidBytes(), and StreamParser::nextToParse().

Referenced by StreamParser::getBytes(), and H264VideoStreamParser::parse().

                                                  { // as above, but doesn't advance ptr
    ensureValidBytes(numBytes);
    memmove(to, nextToParse(), numBytes);
  }

void StreamParser::skipBytes

(

unsigned

numBytes

)

[inline, protected, inherited]

Definition at line 91 of file StreamParser.hh.

References StreamParser::ensureValidBytes(), and StreamParser::fCurParserIndex.

Referenced by MatroskaFileParser::deliverFrameBytes(), MPEG1or2AudioStreamParser::parse(), H264VideoStreamParser::parse(), MatroskaFileParser::parseBlock(), AC3AudioStreamParser::parseFrame(), parsePackHeader(), parsePESPacket(), parseSystemHeader(), and MatroskaFileParser::skipHeader().

                                    {
    ensureValidBytes(numBytes);
    fCurParserIndex += numBytes;
  }

void StreamParser::skipBits

(

unsigned

numBits

)

[protected, inherited]

Definition at line 68 of file StreamParser.cpp.

References StreamParser::ensureValidBytes(), StreamParser::fCurParserIndex, and StreamParser::fRemainingUnparsedBits.

Referenced by parsePackHeader().

                                            {
  if (numBits <= fRemainingUnparsedBits) {
    fRemainingUnparsedBits -= numBits;
  } else {
    numBits -= fRemainingUnparsedBits;

    unsigned numBytesToExamine = (numBits+7)/8; // round up
    ensureValidBytes(numBytesToExamine);
    fCurParserIndex += numBytesToExamine;

    fRemainingUnparsedBits = 8*numBytesToExamine - numBits;
  }
}

unsigned StreamParser::getBits

(

unsigned

numBits

)

[protected, inherited]

Definition at line 82 of file StreamParser.cpp.

References StreamParser::fCurParserIndex, StreamParser::fRemainingUnparsedBits, StreamParser::lastParsed(), and StreamParser::test4Bytes().

Referenced by parsePackHeader(), and parsePESPacket().

                                               {
  if (numBits <= fRemainingUnparsedBits) {
    unsigned char lastByte = *lastParsed();
    lastByte >>= (fRemainingUnparsedBits - numBits);
    fRemainingUnparsedBits -= numBits;

    return (unsigned)lastByte &~ ((~0)<<numBits);
  } else {
    unsigned char lastByte;
    if (fRemainingUnparsedBits > 0) {
      lastByte = *lastParsed();
    } else {
      lastByte = 0;
    }

    unsigned remainingBits = numBits - fRemainingUnparsedBits; // > 0

    // For simplicity, read the next 4 bytes, even though we might not
    // need all of them here:
    unsigned result = test4Bytes();

    result >>= (32 - remainingBits);
    result |= (lastByte << remainingBits);
    if (numBits < 32) result &=~ ((~0)<<numBits);

    unsigned const numRemainingBytes = (remainingBits+7)/8;
    fCurParserIndex += numRemainingBytes;
    fRemainingUnparsedBits = 8*numRemainingBytes - remainingBits;

    return result;
  }
}

unsigned StreamParser::curOffset

(

)

const [inline, protected, inherited]

Definition at line 100 of file StreamParser.hh.

References StreamParser::fCurParserIndex.

Referenced by H264VideoStreamParser::parse(), MatroskaFileParser::parseBlock(), and parsePESPacket().

{ return fCurParserIndex; }

unsigned& StreamParser::totNumValidBytes

(

)

[inline, protected, inherited]

Definition at line 102 of file StreamParser.hh.

References StreamParser::fTotNumValidBytes.

Referenced by H264VideoStreamParser::parse(), and AC3AudioStreamParser::testStreamCode().

{ return fTotNumValidBytes; }

Boolean StreamParser::haveSeenEOF

(

)

const [inline, protected, inherited]

Definition at line 104 of file StreamParser.hh.

References StreamParser::fHaveSeenEOF.

Referenced by H264VideoStreamParser::parse().

{ return fHaveSeenEOF; }

unsigned StreamParser::bankSize

(

)

const [protected, inherited]

Definition at line 115 of file StreamParser.cpp.

References BANK_SIZE.

Referenced by MatroskaFileParser::deliverFrameBytes(), and MatroskaFileParser::skipHeader().

                                      {
  return BANK_SIZE;
}

---

Field Documentation

MPEG1or2Demux* MPEGProgramStreamParser::fUsingDemux [private]

Definition at line 56 of file MPEG1or2Demux.cpp.

Referenced by isSpecialStreamId(), parsePackHeader(), parsePESPacket(), and parseSystemHeader().

MPEGParseState MPEGProgramStreamParser::fCurrentParseState [private]

Definition at line 57 of file MPEG1or2Demux.cpp.

Referenced by parse(), and setParseState().

---

The documentation for this class was generated from the following file:

• liveMedia/MPEG1or2Demux.cpp

---