MPEGProgramStreamParser Class Reference

Inheritance diagram for MPEGProgramStreamParser:

[legend]Collaboration diagram for MPEGProgramStreamParser:

[legend]

Public Member Functions
	MPEGProgramStreamParser (MPEG1or2Demux *usingSource, 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 ()
void	getBytes (u_int8_t *to, unsigned numBytes)
void	skipBytes (unsigned numBytes)
void	skipBits (unsigned numBits)
unsigned	getBits (unsigned numBits)
unsigned	curOffset () const
unsigned &	totNumValidBytes ()
Private Member Functions
void	setParseState (MPEGParseState parseState)
void	parsePackHeader ()
void	parseSystemHeader ()
unsigned char	parsePESPacket ()
Boolean	isSpecialStreamId (unsigned char stream_id) const
Private Attributes
MPEG1or2Demux *	fUsingSource
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 *	usingSource,
		FramedSource *	inputSource
	)

Definition at line 325 of file MPEG1or2Demux.cpp.

  : StreamParser(inputSource, MPEG1or2Demux::handleClosure, usingSource,
                 &MPEG1or2Demux::continueReadProcessing, usingSource),
  fUsingSource(usingSource), fCurrentParseState(PARSING_PACK_HEADER) {
}

MPEGProgramStreamParser::~MPEGProgramStreamParser

(

)

[virtual]

Definition at line 332 of file MPEG1or2Demux.cpp.

                                                  {
}

---

Member Function Documentation

unsigned char MPEGProgramStreamParser::parse

(

)

Definition at line 340 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 335 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 380 of file MPEG1or2Demux.cpp.

References Medium::envir(), MPEG1or2Demux::SCR::extension, MPEG1or2Demux::fLastSeenSCR, MPEG1or2Demux::fMPEGversion, fUsingSource, 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 = fUsingSource->fLastSeenSCR; // alias
  if ((nextByte&0xF0) == 0x20) { // MPEG-1
    fUsingSource->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
    fUsingSource->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
    fUsingSource->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 468 of file MPEG1or2Demux.cpp.

References Medium::envir(), fUsingSource, 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) {
    fUsingSource->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 522 of file MPEG1or2Demux.cpp.

References StreamParser::curOffset(), Medium::envir(), MPEG1or2Demux::fHaveUndeliveredData, MPEG1or2Demux::fMPEGversion, MPEG1or2Demux::fOutput, MPEG1or2Demux::OutputDescriptor::frameSize, fUsingSource, 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* 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 (fUsingSource->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 (fUsingSource->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) {
    fUsingSource->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 = fUsingSource->fOutput[stream_id];
    if (out.isCurrentlyAwaitingData) {
      unsigned numBytesToCopy;
      if (PES_packet_length > out.maxSize) {
        fUsingSource->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
      fUsingSource->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 503 of file MPEG1or2Demux.cpp.

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

Referenced by parsePESPacket().

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

  if (fUsingSource->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 MPEG1or2VideoStreamParser, and MPEG4VideoStreamParser.

Definition at line 178 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(), and AC3AudioStreamFramer::flushInput().

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

void StreamParser::saveParserState

(

)

[protected, inherited]

Definition at line 121 of file StreamParser.cpp.

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

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

                                   {
  fSavedParserIndex = fCurParserIndex;
  fSavedRemainingUnparsedBits = fRemainingUnparsedBits;
}

void StreamParser::restoreSavedParserState

(

)

[protected, virtual, inherited]

Reimplemented in H263plusVideoStreamParser, and MPEGVideoStreamParser.

Definition at line 126 of file StreamParser.cpp.

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

Referenced by StreamParser::afterGettingBytes(), parsePESPacket(), MPEGVideoStreamParser::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(), 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 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++];
  }

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

Definition at line 78 of file StreamParser.hh.

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

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

                                                 {
    ensureValidBytes(numBytes);
    memmove(to, nextToParse(), numBytes);
    fCurParserIndex += numBytes;
    fRemainingUnparsedBits = 0;
  }

void StreamParser::skipBytes

(

unsigned

numBytes

)

[inline, protected, inherited]

Definition at line 84 of file StreamParser.hh.

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

Referenced by MPEG1or2AudioStreamParser::parse(), AC3AudioStreamParser::parseFrame(), parsePackHeader(), parsePESPacket(), and parseSystemHeader().

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

void StreamParser::skipBits

(

unsigned

numBits

)

[protected, inherited]

Definition at line 131 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 145 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 93 of file StreamParser.hh.

References StreamParser::fCurParserIndex.

Referenced by parsePESPacket().

{ return fCurParserIndex; }

unsigned& StreamParser::totNumValidBytes

(

)

[inline, protected, inherited]

Definition at line 95 of file StreamParser.hh.

References StreamParser::fTotNumValidBytes.

Referenced by AC3AudioStreamParser::testStreamCode().

{ return fTotNumValidBytes; }

---

Field Documentation

MPEG1or2Demux* MPEGProgramStreamParser::fUsingSource [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

---