live: MPEG1or2VideoStreamParser Class Reference

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

Definition at line 33 of file StreamParser.hh.

MPEG1or2VideoStreamParser::MPEG1or2VideoStreamParser	(	MPEG1or2VideoStreamFramer *	usingSource,
		FramedSource *	inputSource,
		Boolean	iFramesOnly,
		double	vshPeriod
	)

Definition at line 123 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamFramer::reset().

00126   : MPEGVideoStreamParser(usingSource, inputSource),
00127     fCurrentParseState(PARSING_VIDEO_SEQUENCE_HEADER),
00128     fVSHPeriod(vshPeriod), fIFramesOnly(iFramesOnly) {
00129   reset();
00130 }

MPEG1or2VideoStreamParser::~MPEG1or2VideoStreamParser ( ) [virtual]

Definition at line 132 of file MPEG1or2VideoStreamFramer.cpp.

00132                                                       {
00133 }

void MPEG1or2VideoStreamParser::flushInput ( ) [private, virtual]

Reimplemented from StreamParser.

Definition at line 148 of file MPEG1or2VideoStreamFramer.cpp.

References fCurrentParseState, StreamParser::flushInput(), PARSING_GOP_HEADER, PARSING_VIDEO_SEQUENCE_HEADER, reset(), and MPEGVideoStreamParser::setParseState().

00148                                            {
00149   reset();
00150   StreamParser::flushInput();
00151   if (fCurrentParseState != PARSING_VIDEO_SEQUENCE_HEADER) {
00152     setParseState(PARSING_GOP_HEADER); // start from the next GOP
00153   }
00154 }

unsigned MPEG1or2VideoStreamParser::parse ( ) [private, virtual]

Implements MPEGVideoStreamParser.

Definition at line 156 of file MPEG1or2VideoStreamFramer.cpp.

References False, fCurrentParseState, parseGOPHeader(), parsePictureHeader(), parseSlice(), parseVideoSequenceHeader(), PARSING_GOP_HEADER, PARSING_GOP_HEADER_SEEN_CODE, PARSING_PICTURE_HEADER, PARSING_SLICE, PARSING_VIDEO_SEQUENCE_HEADER, PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE, and True.

Referenced by parsePictureHeader(), and parseSlice().

00156                                           {
00157   try {
00158     switch (fCurrentParseState) {
00159     case PARSING_VIDEO_SEQUENCE_HEADER: {
00160       return parseVideoSequenceHeader(False);
00161     }
00162     case PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE: {
00163       return parseVideoSequenceHeader(True);
00164     }
00165     case PARSING_GOP_HEADER: {
00166       return parseGOPHeader(False);
00167     }
00168     case PARSING_GOP_HEADER_SEEN_CODE: {
00169       return parseGOPHeader(True);
00170     }
00171     case PARSING_PICTURE_HEADER: {
00172       return parsePictureHeader();
00173     }
00174     case PARSING_SLICE: {
00175       return parseSlice();
00176     }
00177     default: {
00178       return 0; // shouldn't happen
00179     }
00180     }
00181   } catch (int /*e*/) {
00182 #ifdef DEBUG
00183     fprintf(stderr, "MPEG1or2VideoStreamParser::parse() EXCEPTION (This is normal behavior - *not* an error)\n");
00184 #endif
00185     return 0;  // the parsing got interrupted
00186   }
00187 }

void MPEG1or2VideoStreamParser::reset ( ) [private]

Definition at line 140 of file MPEG1or2VideoStreamFramer.cpp.

References False, fCurPicTemporalReference, fCurrentSliceNumber, fPicturesSinceLastGOP, fSavedVSHSize, and fSkippingCurrentPicture.

Referenced by flushInput().

00140                                       {
00141   fPicturesSinceLastGOP = 0;
00142   fCurPicTemporalReference = 0;
00143   fCurrentSliceNumber = 0;
00144   fSavedVSHSize = 0;
00145   fSkippingCurrentPicture = False;
00146 }

MPEG1or2VideoStreamFramer* MPEG1or2VideoStreamParser::usingSource ( ) [inline, private]

Definition at line 54 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamParser::fUsingSource.

Referenced by needToUseSavedVSH(), parseGOPHeader(), parsePictureHeader(), parseSlice(), parseVideoSequenceHeader(), saveCurrentVSH(), and useSavedVSH().

00054                                            {
00055     return (MPEG1or2VideoStreamFramer*)fUsingSource;
00056   }

void MPEG1or2VideoStreamParser::setParseState ( MPEGParseState parseState ) [private]

Definition at line 135 of file MPEG1or2VideoStreamFramer.cpp.

References fCurrentParseState, and MPEGVideoStreamParser::setParseState().

00135                                                                        {
00136   fCurrentParseState = parseState;
00137   MPEGVideoStreamParser::setParseState();
00138 }

unsigned MPEG1or2VideoStreamParser::parseVideoSequenceHeader ( Boolean haveSeenStartCode ) [private]

Definition at line 244 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamFramer::computePresentationTime(), MPEGVideoStreamParser::curFrameSize(), MPEGVideoStreamFramer::fFrameRate, fPicturesSinceLastGOP, frameRateFromCode, StreamParser::get1Byte(), StreamParser::get4Bytes(), GROUP_START_CODE, PARSING_GOP_HEADER_SEEN_CODE, PARSING_PICTURE_HEADER, PARSING_VIDEO_SEQUENCE_HEADER, PICTURE_START_CODE, MPEGVideoStreamParser::save4Bytes(), saveCurrentVSH(), MPEGVideoStreamParser::saveToNextCode(), MPEGVideoStreamParser::setParseState(), StreamParser::test4Bytes(), usingSource(), and VIDEO_SEQUENCE_HEADER_START_CODE.

Referenced by parse().

00244                                                     {
00245 #ifdef DEBUG
00246   fprintf(stderr, "parsing video sequence header\n");
00247 #endif
00248   unsigned first4Bytes;
00249   if (!haveSeenStartCode) {
00250     while ((first4Bytes = test4Bytes()) != VIDEO_SEQUENCE_HEADER_START_CODE) {
00251 #ifdef DEBUG
00252       fprintf(stderr, "ignoring non video sequence header: 0x%08x\n", first4Bytes);
00253 #endif
00254       get1Byte(); setParseState(PARSING_VIDEO_SEQUENCE_HEADER);
00255           // ensures we progress over bad data
00256     }
00257     first4Bytes = get4Bytes();
00258   } else {
00259     // We've already seen the start code
00260     first4Bytes = VIDEO_SEQUENCE_HEADER_START_CODE;
00261   }
00262   save4Bytes(first4Bytes);
00263 
00264   // Next, extract the size and rate parameters from the next 8 bytes
00265   unsigned paramWord1 = get4Bytes();
00266   save4Bytes(paramWord1);
00267   unsigned next4Bytes = get4Bytes();
00268 #ifdef DEBUG
00269   unsigned short horizontal_size_value   = (paramWord1&0xFFF00000)>>(32-12);
00270   unsigned short vertical_size_value     = (paramWord1&0x000FFF00)>>8;
00271   unsigned char aspect_ratio_information = (paramWord1&0x000000F0)>>4;
00272 #endif
00273   unsigned char frame_rate_code          = (paramWord1&0x0000000F);
00274   usingSource()->fFrameRate = frameRateFromCode[frame_rate_code];
00275 #ifdef DEBUG
00276   unsigned bit_rate_value                = (next4Bytes&0xFFFFC000)>>(32-18);
00277   unsigned vbv_buffer_size_value         = (next4Bytes&0x00001FF8)>>3;
00278   fprintf(stderr, "horizontal_size_value: %d, vertical_size_value: %d, aspect_ratio_information: %d, frame_rate_code: %d (=>%f fps), bit_rate_value: %d (=>%d bps), vbv_buffer_size_value: %d\n", horizontal_size_value, vertical_size_value, aspect_ratio_information, frame_rate_code, usingSource()->fFrameRate, bit_rate_value, bit_rate_value*400, vbv_buffer_size_value);
00279 #endif
00280 
00281   // Now, copy all bytes that we see, up until we reach a GROUP_START_CODE
00282   // or a PICTURE_START_CODE:
00283   do {
00284     saveToNextCode(next4Bytes);
00285   } while (next4Bytes != GROUP_START_CODE && next4Bytes != PICTURE_START_CODE);
00286 
00287   setParseState((next4Bytes == GROUP_START_CODE)
00288                 ? PARSING_GOP_HEADER_SEEN_CODE : PARSING_PICTURE_HEADER);
00289 
00290   // Compute this frame's timestamp by noting how many pictures we've seen
00291   // since the last GOP header:
00292   usingSource()->computePresentationTime(fPicturesSinceLastGOP);
00293 
00294   // Save this video_sequence_header, in case we need to insert a copy
00295   // into the stream later:
00296   saveCurrentVSH();
00297 
00298   return curFrameSize();
00299 }

unsigned MPEG1or2VideoStreamParser::parseGOPHeader ( Boolean haveSeenStartCode ) [private]

Definition at line 301 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamFramer::computePresentationTime(), MPEGVideoStreamParser::curFrameSize(), fPicturesSinceLastGOP, StreamParser::get1Byte(), StreamParser::get4Bytes(), GROUP_START_CODE, needToUseSavedVSH(), PARSING_GOP_HEADER, PARSING_PICTURE_HEADER, PICTURE_START_CODE, MPEGVideoStreamParser::save4Bytes(), MPEGVideoStreamParser::saveToNextCode(), MPEGVideoStreamParser::setParseState(), MPEGVideoStreamFramer::setTimeCode(), StreamParser::test4Bytes(), useSavedVSH(), and usingSource().

Referenced by parse().

00301                                                                             {
00302   // First check whether we should insert a previously-saved
00303   // 'video_sequence_header' here:
00304   if (needToUseSavedVSH()) return useSavedVSH();
00305 
00306 #ifdef DEBUG
00307   fprintf(stderr, "parsing GOP header\n");
00308 #endif
00309   unsigned first4Bytes;
00310   if (!haveSeenStartCode) {
00311     while ((first4Bytes = test4Bytes()) != GROUP_START_CODE) {
00312 #ifdef DEBUG
00313       fprintf(stderr, "ignoring non GOP start code: 0x%08x\n", first4Bytes);
00314 #endif
00315       get1Byte(); setParseState(PARSING_GOP_HEADER);
00316           // ensures we progress over bad data
00317     }
00318     first4Bytes = get4Bytes();
00319   } else {
00320     // We've already seen the GROUP_START_CODE
00321     first4Bytes = GROUP_START_CODE;
00322   }
00323   save4Bytes(first4Bytes);
00324 
00325   // Next, extract the (25-bit) time code from the next 4 bytes:
00326   unsigned next4Bytes = get4Bytes();
00327   unsigned time_code = (next4Bytes&0xFFFFFF80)>>(32-25);
00328 #if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
00329   Boolean drop_frame_flag     = (time_code&0x01000000) != 0;
00330 #endif
00331   unsigned time_code_hours    = (time_code&0x00F80000)>>19;
00332   unsigned time_code_minutes  = (time_code&0x0007E000)>>13;
00333   unsigned time_code_seconds  = (time_code&0x00000FC0)>>6;
00334   unsigned time_code_pictures = (time_code&0x0000003F);
00335 #if defined(DEBUG) || defined(DEBUG_TIMESTAMPS)
00336   fprintf(stderr, "time_code: 0x%07x, drop_frame %d, hours %d, minutes %d, seconds %d, pictures %d\n", time_code, drop_frame_flag, time_code_hours, time_code_minutes, time_code_seconds, time_code_pictures);
00337 #endif
00338 #ifdef DEBUG
00339   Boolean closed_gop  = (next4Bytes&0x00000040) != 0;
00340   Boolean broken_link = (next4Bytes&0x00000020) != 0;
00341   fprintf(stderr, "closed_gop: %d, broken_link: %d\n", closed_gop, broken_link);
00342 #endif
00343 
00344   // Now, copy all bytes that we see, up until we reach a PICTURE_START_CODE:
00345   do {
00346     saveToNextCode(next4Bytes);
00347   } while (next4Bytes != PICTURE_START_CODE);
00348 
00349   // Record the time code:
00350   usingSource()->setTimeCode(time_code_hours, time_code_minutes,
00351                              time_code_seconds, time_code_pictures,
00352                              fPicturesSinceLastGOP);
00353 
00354   fPicturesSinceLastGOP = 0;
00355 
00356   // Compute this frame's timestamp:
00357   usingSource()->computePresentationTime(0);
00358 
00359   setParseState(PARSING_PICTURE_HEADER);
00360 
00361   return curFrameSize();
00362 }

unsigned MPEG1or2VideoStreamParser::parsePictureHeader ( ) [private]

Definition at line 371 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamFramer::computePresentationTime(), MPEGVideoStreamParser::curFrameSize(), fCurPicTemporalReference, fCurrentSliceNumber, fIFramesOnly, fSkippingCurrentPicture, StreamParser::get4Bytes(), isSliceStartCode(), parse(), PARSING_SLICE, PICTURE_START_CODE, MPEGVideoStreamParser::save4Bytes(), MPEGVideoStreamParser::saveToNextCode(), MPEGVideoStreamParser::setParseState(), MPEGVideoStreamParser::skipToNextCode(), and usingSource().

Referenced by parse().

00371                                                        {
00372 #ifdef DEBUG
00373   fprintf(stderr, "parsing picture header\n");
00374 #endif
00375   // Note that we've already read the PICTURE_START_CODE
00376   // Next, extract the temporal reference from the next 4 bytes:
00377   unsigned next4Bytes = get4Bytes();
00378   unsigned short temporal_reference = (next4Bytes&0xFFC00000)>>(32-10);
00379   unsigned char picture_coding_type = (next4Bytes&0x00380000)>>19;
00380 #ifdef DEBUG
00381   unsigned short vbv_delay          = (next4Bytes&0x0007FFF8)>>3;
00382   fprintf(stderr, "temporal_reference: %d, picture_coding_type: %d, vbv_delay: %d\n", temporal_reference, picture_coding_type, vbv_delay);
00383 #endif
00384 
00385   fSkippingCurrentPicture = fIFramesOnly && picture_coding_type != 1;
00386   if (fSkippingCurrentPicture) {
00387     // Skip all bytes that we see, up until we reach a slice_start_code:
00388     do {
00389       skipToNextCode(next4Bytes);
00390     } while (!isSliceStartCode(next4Bytes));
00391   } else {
00392     // Save the PICTURE_START_CODE that we've already read:
00393     save4Bytes(PICTURE_START_CODE);
00394 
00395     // Copy all bytes that we see, up until we reach a slice_start_code:
00396     do {
00397       saveToNextCode(next4Bytes);
00398     } while (!isSliceStartCode(next4Bytes));
00399   }
00400 
00401   setParseState(PARSING_SLICE);
00402 
00403   fCurrentSliceNumber = next4Bytes&0xFF;
00404 
00405   // Record the temporal reference:
00406   fCurPicTemporalReference = temporal_reference;
00407 
00408   // Compute this frame's timestamp:
00409   usingSource()->computePresentationTime(fCurPicTemporalReference);
00410 
00411   if (fSkippingCurrentPicture) {
00412     return parse(); // try again, until we get a non-skipped frame
00413   } else {
00414     return curFrameSize();
00415   }
00416 }

unsigned MPEG1or2VideoStreamParser::parseSlice ( ) [private]

Definition at line 418 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamFramer::computePresentationTime(), MPEGVideoStreamParser::curFrameSize(), Medium::envir(), fCurPicTemporalReference, fCurrentSliceNumber, MPEGVideoStreamFramer::fPictureCount, MPEGVideoStreamFramer::fPictureEndMarker, fPicturesSinceLastGOP, fSkippingCurrentPicture, GROUP_START_CODE, isSliceStartCode(), parse(), PARSING_GOP_HEADER_SEEN_CODE, PARSING_PICTURE_HEADER, PARSING_SLICE, PARSING_VIDEO_SEQUENCE_HEADER, PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE, PICTURE_START_CODE, MPEGVideoStreamParser::saveToNextCode(), SEQUENCE_END_CODE, MPEGVideoStreamParser::setParseState(), MPEGVideoStreamParser::skipToNextCode(), True, usingSource(), and VIDEO_SEQUENCE_HEADER_START_CODE.

Referenced by parse().

00418                                                {
00419   // Note that we've already read the slice_start_code:
00420   unsigned next4Bytes = PICTURE_START_CODE|fCurrentSliceNumber;
00421 #ifdef DEBUG_SLICE
00422   fprintf(stderr, "parsing slice: 0x%08x\n", next4Bytes);
00423 #endif
00424 
00425   if (fSkippingCurrentPicture) {
00426     // Skip all bytes that we see, up until we reach a code of some sort:
00427     skipToNextCode(next4Bytes);
00428   } else {
00429     // Copy all bytes that we see, up until we reach a code of some sort:
00430     saveToNextCode(next4Bytes);
00431   }
00432 
00433   // The next thing to parse depends on the code that we just saw:
00434   if (isSliceStartCode(next4Bytes)) { // common case
00435     setParseState(PARSING_SLICE);
00436     fCurrentSliceNumber = next4Bytes&0xFF;
00437   } else {
00438     // Because we don't see any more slices, we are assumed to have ended
00439     // the current picture:
00440     ++fPicturesSinceLastGOP;
00441     ++usingSource()->fPictureCount;
00442     usingSource()->fPictureEndMarker = True; // HACK #####
00443 
00444     switch (next4Bytes) {
00445     case SEQUENCE_END_CODE: {
00446       setParseState(PARSING_VIDEO_SEQUENCE_HEADER);
00447       break;
00448     }
00449     case VIDEO_SEQUENCE_HEADER_START_CODE: {
00450       setParseState(PARSING_VIDEO_SEQUENCE_HEADER_SEEN_CODE);
00451       break;
00452     }
00453     case GROUP_START_CODE: {
00454       setParseState(PARSING_GOP_HEADER_SEEN_CODE);
00455       break;
00456     }
00457     case PICTURE_START_CODE: {
00458       setParseState(PARSING_PICTURE_HEADER);
00459       break;
00460     }
00461     default: {
00462       usingSource()->envir() << "MPEG1or2VideoStreamParser::parseSlice(): Saw unexpected code "
00463                             << (void*)next4Bytes << "\n";
00464       setParseState(PARSING_SLICE); // the safest way to recover...
00465       break;
00466     }
00467     }
00468   }
00469 
00470   // Compute this frame's timestamp:
00471   usingSource()->computePresentationTime(fCurPicTemporalReference);
00472 
00473   if (fSkippingCurrentPicture) {
00474     return parse(); // try again, until we get a non-skipped frame
00475   } else {
00476     return curFrameSize();
00477   }
00478 }

void MPEG1or2VideoStreamParser::saveCurrentVSH ( ) [private]

Definition at line 189 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamParser::curFrameSize(), frameSize, fSavedVSHBuffer, fSavedVSHSize, fSavedVSHTimestamp, MPEGVideoStreamParser::fStartOfFrame, MPEG1or2VideoStreamFramer::getCurrentPTS(), and usingSource().

Referenced by parseVideoSequenceHeader().

00189                                                {
00190   unsigned frameSize = curFrameSize();
00191   if (frameSize > sizeof fSavedVSHBuffer) return; // too big to save
00192 
00193   memmove(fSavedVSHBuffer, fStartOfFrame, frameSize);
00194   fSavedVSHSize = frameSize;
00195   fSavedVSHTimestamp = usingSource()->getCurrentPTS();
00196 }

Boolean MPEG1or2VideoStreamParser::needToUseSavedVSH ( ) [private]

Definition at line 198 of file MPEG1or2VideoStreamFramer.cpp.

References fSavedVSHSize, fSavedVSHTimestamp, fVSHPeriod, MPEG1or2VideoStreamFramer::getCurrentPTS(), and usingSource().

Referenced by parseGOPHeader().

00198                                                      {
00199   return usingSource()->getCurrentPTS() > fSavedVSHTimestamp+fVSHPeriod
00200     && fSavedVSHSize > 0;
00201 }

unsigned MPEG1or2VideoStreamParser::useSavedVSH ( ) [private]

Definition at line 203 of file MPEG1or2VideoStreamFramer.cpp.

References MPEGVideoStreamParser::fLimit, fSavedVSHBuffer, fSavedVSHSize, fSavedVSHTimestamp, MPEGVideoStreamParser::fStartOfFrame, MPEG1or2VideoStreamFramer::getCurrentPTS(), and usingSource().

Referenced by parseGOPHeader().

00203                                                 {
00204   unsigned bytesToUse = fSavedVSHSize;
00205   unsigned maxBytesToUse = fLimit - fStartOfFrame;
00206   if (bytesToUse > maxBytesToUse) bytesToUse = maxBytesToUse;
00207 
00208   memmove(fStartOfFrame, fSavedVSHBuffer, bytesToUse);
00209 
00210   // Also reset the saved timestamp:
00211   fSavedVSHTimestamp = usingSource()->getCurrentPTS();
00212 
00213 #ifdef DEBUG
00214   fprintf(stderr, "used saved video_sequence_header (%d bytes)\n", bytesToUse);
00215 #endif
00216   return bytesToUse;
00217 }

void MPEGVideoStreamParser::registerReadInterest	(	unsigned char *	to,
		unsigned	maxSize
	)			`[inherited]`

Definition at line 40 of file MPEGVideoStreamParser.cpp.

References MPEGVideoStreamParser::fLimit, MPEGVideoStreamParser::fNumTruncatedBytes, MPEGVideoStreamParser::fSavedNumTruncatedBytes, MPEGVideoStreamParser::fSavedTo, MPEGVideoStreamParser::fStartOfFrame, and MPEGVideoStreamParser::fTo.

Referenced by MPEGVideoStreamFramer::doGetNextFrame().

00041                                                                    {
00042   fStartOfFrame = fTo = fSavedTo = to;
00043   fLimit = to + maxSize;
00044   fNumTruncatedBytes = fSavedNumTruncatedBytes = 0;
00045 }

unsigned MPEGVideoStreamParser::numTruncatedBytes ( ) const [inline, inherited]

Definition at line 45 of file MPEGVideoStreamParser.hh.

References MPEGVideoStreamParser::fNumTruncatedBytes.

Referenced by MPEGVideoStreamFramer::continueReadProcessing().

00045 { return fNumTruncatedBytes; }

void MPEGVideoStreamParser::setParseState ( ) [inline, protected, inherited]

Definition at line 48 of file MPEGVideoStreamParser.hh.

References MPEGVideoStreamParser::fNumTruncatedBytes, MPEGVideoStreamParser::fSavedNumTruncatedBytes, MPEGVideoStreamParser::fSavedTo, MPEGVideoStreamParser::fTo, and StreamParser::saveParserState().

Referenced by MPEG4VideoStreamParser::flushInput(), flushInput(), H264VideoStreamParser::parse(), parseGOPHeader(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), parsePictureHeader(), parseSlice(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEG4VideoStreamParser::parseVisualObjectSequenceEndCode(), MPEG4VideoStreamParser::setParseState(), and setParseState().

00048                        {
00049     fSavedTo = fTo;
00050     fSavedNumTruncatedBytes = fNumTruncatedBytes;
00051     saveParserState();
00052   }

void MPEGVideoStreamParser::saveByte ( u_int8_t byte ) [inline, protected, inherited]

Definition at line 55 of file MPEGVideoStreamParser.hh.

References MPEGVideoStreamParser::fLimit, MPEGVideoStreamParser::fNumTruncatedBytes, and MPEGVideoStreamParser::fTo.

Referenced by H264VideoStreamParser::parse(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), MPEG4VideoStreamParser::parseVideoObjectPlane(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), and MPEGVideoStreamParser::saveToNextCode().

00055                                {
00056     if (fTo >= fLimit) { // there's no space left
00057       ++fNumTruncatedBytes;
00058       return;
00059     }
00060 
00061     *fTo++ = byte;
00062   }

void MPEGVideoStreamParser::save4Bytes ( u_int32_t word ) [inline, protected, inherited]

Definition at line 64 of file MPEGVideoStreamParser.hh.

References MPEGVideoStreamParser::fLimit, MPEGVideoStreamParser::fNumTruncatedBytes, and MPEGVideoStreamParser::fTo.

Referenced by H264VideoStreamParser::parse(), parseGOPHeader(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), parsePictureHeader(), MPEG4VideoStreamParser::parseVideoObjectPlane(), parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEG4VideoStreamParser::parseVisualObjectSequenceEndCode(), and MPEGVideoStreamParser::saveToNextCode().

00064                                   {
00065     if (fTo+4 > fLimit) { // there's no space left
00066       fNumTruncatedBytes += 4;
00067       return;
00068     }
00069 
00070     *fTo++ = word>>24; *fTo++ = word>>16; *fTo++ = word>>8; *fTo++ = word;
00071   }

void MPEGVideoStreamParser::saveToNextCode ( u_int32_t & curWord ) [inline, protected, inherited]

Definition at line 74 of file MPEGVideoStreamParser.hh.

References StreamParser::get1Byte(), StreamParser::get4Bytes(), MPEGVideoStreamParser::save4Bytes(), and MPEGVideoStreamParser::saveByte().

Referenced by parseGOPHeader(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), parsePictureHeader(), parseSlice(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), and MPEG4VideoStreamParser::parseVisualObjectSequence().

00074                                           {
00075     saveByte(curWord>>24);
00076     curWord = (curWord<<8)|get1Byte();
00077     while ((curWord&0xFFFFFF00) != 0x00000100) {
00078       if ((unsigned)(curWord&0xFF) > 1) {
00079         // a sync word definitely doesn't begin anywhere in "curWord"
00080         save4Bytes(curWord);
00081         curWord = get4Bytes();
00082       } else {
00083         // a sync word might begin in "curWord", although not at its start
00084         saveByte(curWord>>24);
00085         unsigned char newByte = get1Byte();
00086         curWord = (curWord<<8)|newByte;
00087       }
00088     }
00089   }

void MPEGVideoStreamParser::skipToNextCode ( u_int32_t & curWord ) [inline, protected, inherited]

Definition at line 92 of file MPEGVideoStreamParser.hh.

References StreamParser::get1Byte(), and StreamParser::get4Bytes().

Referenced by parsePictureHeader(), and parseSlice().

00092                                           {
00093     curWord = (curWord<<8)|get1Byte();
00094     while ((curWord&0xFFFFFF00) != 0x00000100) {
00095       if ((unsigned)(curWord&0xFF) > 1) {
00096         // a sync word definitely doesn't begin anywhere in "curWord"
00097         curWord = get4Bytes();
00098       } else {
00099         // a sync word might begin in "curWord", although not at its start
00100         unsigned char newByte = get1Byte();
00101         curWord = (curWord<<8)|newByte;
00102       }
00103     }
00104   }

unsigned MPEGVideoStreamParser::curFrameSize ( ) [inline, protected, inherited]

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(), MPEGProgramStreamParser::setParseState(), MatroskaFileParser::setParseState(), and H263plusVideoStreamParser::setParseState().

00058                                    {
00059   fSavedParserIndex = fCurParserIndex;
00060   fSavedRemainingUnparsedBits = fRemainingUnparsedBits;
00061 }

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(), parseGOPHeader(), MPEG4VideoStreamParser::parseGroupOfVideoObjectPlane(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), parsePictureHeader(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVideoObjectPlane(), parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEGVideoStreamParser::saveToNextCode(), and MPEGVideoStreamParser::skipToNextCode().

00046                         { // byte-aligned; returned in big-endian order
00047     u_int32_t result = test4Bytes();
00048     fCurParserIndex += 4;
00049     fRemainingUnparsedBits = 0;
00050 
00051     return result;
00052   }

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(), parseGOPHeader(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), MPEGProgramStreamParser::parseSystemHeader(), parseVideoSequenceHeader(), and MPEG4VideoStreamParser::parseVisualObjectSequence().

00053                          { // as above, but doesn't advance ptr
00054     ensureValidBytes(4);
00055 
00056     unsigned char const* ptr = nextToParse();
00057     return (ptr[0]<<24)|(ptr[1]<<16)|(ptr[2]<<8)|ptr[3];
00058   }

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 MPEGProgramStreamParser::parsePESPacket(), and MPEGProgramStreamParser::parseSystemHeader().

00060                         {
00061     ensureValidBytes(2);
00062 
00063     unsigned char const* ptr = nextToParse();
00064     u_int16_t result = (ptr[0]<<8)|ptr[1];
00065 
00066     fCurParserIndex += 2;
00067     fRemainingUnparsedBits = 0;
00068 
00069     return result;
00070   }

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(), parseGOPHeader(), H263plusVideoStreamParser::parseH263Frame(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), MPEG4VideoStreamParser::parseVideoObjectPlane(), parseVideoSequenceHeader(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEGVideoStreamParser::saveToNextCode(), and MPEGVideoStreamParser::skipToNextCode().

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

u_int8_t StreamParser::test1Byte ( unsigned numBytes ) [inline, protected, inherited]

Definition at line 77 of file StreamParser.hh.

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

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

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 MPEGProgramStreamParser::parsePESPacket().

00082                                                  {
00083     testBytes(to, numBytes);
00084     fCurParserIndex += numBytes;
00085     fRemainingUnparsedBits = 0;
00086   }

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().

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

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(), MPEGProgramStreamParser::parsePackHeader(), MPEGProgramStreamParser::parsePESPacket(), MPEGProgramStreamParser::parseSystemHeader(), and MatroskaFileParser::skipHeader().

00091                                     {
00092     ensureValidBytes(numBytes);
00093     fCurParserIndex += numBytes;
00094   }

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 MPEGProgramStreamParser::parsePackHeader().

00068                                             {
00069   if (numBits <= fRemainingUnparsedBits) {
00070     fRemainingUnparsedBits -= numBits;
00071   } else {
00072     numBits -= fRemainingUnparsedBits;
00073 
00074     unsigned numBytesToExamine = (numBits+7)/8; // round up
00075     ensureValidBytes(numBytesToExamine);
00076     fCurParserIndex += numBytesToExamine;
00077 
00078     fRemainingUnparsedBits = 8*numBytesToExamine - numBits;
00079   }
00080 }

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 MPEGProgramStreamParser::parsePackHeader(), and MPEGProgramStreamParser::parsePESPacket().

00082                                                {
00083   if (numBits <= fRemainingUnparsedBits) {
00084     unsigned char lastByte = *lastParsed();
00085     lastByte >>= (fRemainingUnparsedBits - numBits);
00086     fRemainingUnparsedBits -= numBits;
00087 
00088     return (unsigned)lastByte &~ ((~0)<<numBits);
00089   } else {
00090     unsigned char lastByte;
00091     if (fRemainingUnparsedBits > 0) {
00092       lastByte = *lastParsed();
00093     } else {
00094       lastByte = 0;
00095     }
00096 
00097     unsigned remainingBits = numBits - fRemainingUnparsedBits; // > 0
00098 
00099     // For simplicity, read the next 4 bytes, even though we might not
00100     // need all of them here:
00101     unsigned result = test4Bytes();
00102 
00103     result >>= (32 - remainingBits);
00104     result |= (lastByte << remainingBits);
00105     if (numBits < 32) result &=~ ((~0)<<numBits);
00106 
00107     unsigned const numRemainingBytes = (remainingBits+7)/8;
00108     fCurParserIndex += numRemainingBytes;
00109     fRemainingUnparsedBits = 8*numRemainingBytes - remainingBits;
00110 
00111     return result;
00112   }
00113 }

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 MPEGProgramStreamParser::parsePESPacket().

00100 { 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().

00102 { return fTotNumValidBytes; }

Boolean StreamParser::haveSeenEOF ( ) const [inline, protected, inherited]

Definition at line 104 of file StreamParser.hh.

References StreamParser::fHaveSeenEOF.

Referenced by H264VideoStreamParser::parse().

00104 { 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().

00115                                       {
00116   return BANK_SIZE;
00117 }

MPEGParseState MPEG1or2VideoStreamParser::fCurrentParseState [private]

Definition at line 65 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by flushInput(), parse(), and setParseState().

unsigned MPEG1or2VideoStreamParser::fPicturesSinceLastGOP [private]

Definition at line 66 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by parseGOPHeader(), parseSlice(), parseVideoSequenceHeader(), and reset().

unsigned short MPEG1or2VideoStreamParser::fCurPicTemporalReference [private]

Definition at line 68 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by parsePictureHeader(), parseSlice(), and reset().

unsigned char MPEG1or2VideoStreamParser::fCurrentSliceNumber [private]

Definition at line 70 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by parsePictureHeader(), parseSlice(), and reset().

unsigned char MPEG1or2VideoStreamParser::fSavedVSHBuffer[VSH_MAX_SIZE] [private]

Definition at line 74 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by saveCurrentVSH(), and useSavedVSH().

unsigned MPEG1or2VideoStreamParser::fSavedVSHSize [private]

Definition at line 75 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by needToUseSavedVSH(), reset(), saveCurrentVSH(), and useSavedVSH().

double MPEG1or2VideoStreamParser::fSavedVSHTimestamp [private]

Definition at line 76 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by needToUseSavedVSH(), saveCurrentVSH(), and useSavedVSH().

double MPEG1or2VideoStreamParser::fVSHPeriod [private]

Definition at line 77 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by needToUseSavedVSH().

Boolean MPEG1or2VideoStreamParser::fIFramesOnly [private]

Definition at line 78 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by parsePictureHeader().

Boolean MPEG1or2VideoStreamParser::fSkippingCurrentPicture [private]

Definition at line 78 of file MPEG1or2VideoStreamFramer.cpp.

Referenced by parsePictureHeader(), parseSlice(), and reset().

MPEGVideoStreamFramer* MPEGVideoStreamParser::fUsingSource [protected, inherited]

Definition at line 107 of file MPEGVideoStreamParser.hh.

Referenced by MPEG4VideoStreamParser::usingSource(), usingSource(), and H264VideoStreamParser::usingSource().

unsigned char* MPEGVideoStreamParser::fStartOfFrame [protected, inherited]

Definition at line 110 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::curFrameSize(), MPEG4VideoStreamParser::getNextFrameBit(), H264VideoStreamParser::parse(), MPEG4VideoStreamParser::parseVideoObjectLayer(), MPEG4VideoStreamParser::parseVisualObject(), MPEG4VideoStreamParser::parseVisualObjectSequence(), MPEGVideoStreamParser::registerReadInterest(), H264VideoStreamParser::removeEmulationBytes(), saveCurrentVSH(), and useSavedVSH().

unsigned char* MPEGVideoStreamParser::fTo [protected, inherited]

Definition at line 111 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::curFrameSize(), H264VideoStreamParser::parse(), MPEGVideoStreamParser::registerReadInterest(), H264VideoStreamParser::removeEmulationBytes(), MPEGVideoStreamParser::restoreSavedParserState(), MPEGVideoStreamParser::save4Bytes(), MPEGVideoStreamParser::saveByte(), and MPEGVideoStreamParser::setParseState().

unsigned char* MPEGVideoStreamParser::fLimit [protected, inherited]

Definition at line 112 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::registerReadInterest(), MPEGVideoStreamParser::save4Bytes(), MPEGVideoStreamParser::saveByte(), and useSavedVSH().

unsigned MPEGVideoStreamParser::fNumTruncatedBytes [protected, inherited]

Definition at line 113 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::numTruncatedBytes(), MPEGVideoStreamParser::registerReadInterest(), MPEGVideoStreamParser::restoreSavedParserState(), MPEGVideoStreamParser::save4Bytes(), MPEGVideoStreamParser::saveByte(), and MPEGVideoStreamParser::setParseState().

unsigned char* MPEGVideoStreamParser::fSavedTo [protected, inherited]

Definition at line 115 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::registerReadInterest(), MPEGVideoStreamParser::restoreSavedParserState(), and MPEGVideoStreamParser::setParseState().

unsigned MPEGVideoStreamParser::fSavedNumTruncatedBytes [protected, inherited]

Definition at line 116 of file MPEGVideoStreamParser.hh.

Referenced by MPEGVideoStreamParser::registerReadInterest(), MPEGVideoStreamParser::restoreSavedParserState(), and MPEGVideoStreamParser::setParseState().

MPEG1or2VideoStreamParser Class Reference

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation


Public Member Functions
	MPEG1or2VideoStreamParser (MPEG1or2VideoStreamFramer usingSource, FramedSource inputSource, Boolean iFramesOnly, double vshPeriod)
virtual	~MPEG1or2VideoStreamParser ()
void	registerReadInterest (unsigned char *to, unsigned maxSize)
unsigned	numTruncatedBytes () const
Protected Types
typedef void(	clientContinueFunc )(void clientData, unsigned char ptr, unsigned size, struct timeval presentationTime)
Protected Member Functions
void	setParseState ()
void	saveByte (u_int8_t byte)
void	save4Bytes (u_int32_t word)
void	saveToNextCode (u_int32_t &curWord)
void	skipToNextCode (u_int32_t &curWord)
unsigned	curFrameSize ()
void	saveParserState ()
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
Protected Attributes
MPEGVideoStreamFramer *	fUsingSource
unsigned char *	fStartOfFrame
unsigned char *	fTo
unsigned char *	fLimit
unsigned	fNumTruncatedBytes
unsigned char *	fSavedTo
unsigned	fSavedNumTruncatedBytes
Private Member Functions
virtual void	flushInput ()
virtual unsigned	parse ()
void	reset ()
MPEG1or2VideoStreamFramer *	usingSource ()
void	setParseState (MPEGParseState parseState)
unsigned	parseVideoSequenceHeader (Boolean haveSeenStartCode)
unsigned	parseGOPHeader (Boolean haveSeenStartCode)
unsigned	parsePictureHeader ()
unsigned	parseSlice ()
void	saveCurrentVSH ()
Boolean	needToUseSavedVSH ()
unsigned	useSavedVSH ()
Private Attributes
MPEGParseState	fCurrentParseState
unsigned	fPicturesSinceLastGOP
unsigned short	fCurPicTemporalReference
unsigned char	fCurrentSliceNumber
unsigned char	fSavedVSHBuffer [VSH_MAX_SIZE]
unsigned	fSavedVSHSize
double	fSavedVSHTimestamp
double	fVSHPeriod
Boolean	fIFramesOnly
Boolean	fSkippingCurrentPicture