Mpeg2 TS parser: Es parsing using an ES byte queue.

media/formats/mp2t/es_parser_h264.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/formats/mp2t/es_parser_h264.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/buffers.h"
@@ skipping 10 matching lines @@
 namespace mp2t {
 
 // An AUD NALU is at least 4 bytes:
 // 3 bytes for the start code + 1 byte for the NALU type.
 const int kMinAUDSize = 4;
 
 EsParserH264::EsParserH264(
     const NewVideoConfigCB& new_video_config_cb,
     const EmitBufferCB& emit_buffer_cb)
     : es_adapter_(new_video_config_cb, emit_buffer_cb),
-      es_queue_(new media::OffsetByteQueue()),
       h264_parser_(new H264Parser()),
       current_access_unit_pos_(0),
       next_access_unit_pos_(0) {
 }
 
 EsParserH264::~EsParserH264() {
 }
 
-bool EsParserH264::Parse(const uint8* buf, int size,
-                         base::TimeDelta pts,
-                         DecodeTimestamp dts) {
-  // Note: Parse is invoked each time a PES packet has been reassembled.
-  // Unfortunately, a PES packet does not necessarily map
-  // to an h264 access unit, although the HLS recommendation is to use one PES
-  // for each access unit (but this is just a recommendation and some streams
-  // do not comply with this recommendation).
-
-  // HLS recommendation: "In AVC video, you should have both a DTS and a
-  // PTS in each PES header".
-  // However, some streams do not comply with this recommendation.
-  DVLOG_IF(1, pts == kNoTimestamp()) << "Each video PES should have a PTS";
-  if (pts != kNoTimestamp()) {
-    TimingDesc timing_desc;
-    timing_desc.pts = pts;
-    timing_desc.dts = (dts != kNoDecodeTimestamp()) ? dts :
-        DecodeTimestamp::FromPresentationTime(pts);
-
-    // Link the end of the byte queue with the incoming timing descriptor.
-    timing_desc_list_.push_back(
-        std::pair<int64, TimingDesc>(es_queue_->tail(), timing_desc));
-  }
-
-  // Add the incoming bytes to the ES queue.
-  es_queue_->Push(buf, size);
-  return ParseInternal();
-}
-
 void EsParserH264::Flush() {
-  DVLOG(1) << "EsParserH264::Flush";
+  DVLOG(1) << __FUNCTION__;
   if (!FindAUD(&current_access_unit_pos_))
     return;
 
   // Simulate an additional AUD to force emitting the last access unit
   // which is assumed to be complete at this point.
   uint8 aud[] = { 0x00, 0x00, 0x01, 0x09 };
   es_queue_->Push(aud, sizeof(aud));
-  ParseInternal();
+  ParseFromEsQueue();
 
   es_adapter_.Flush();
 }
 
-void EsParserH264::Reset() {
-  DVLOG(1) << "EsParserH264::Reset";
-  es_queue_.reset(new media::OffsetByteQueue());
+void EsParserH264::ResetInternal() {
+  DVLOG(1) << __FUNCTION__;
   h264_parser_.reset(new H264Parser());
   current_access_unit_pos_ = 0;
   next_access_unit_pos_ = 0;
-  timing_desc_list_.clear();
   last_video_decoder_config_ = VideoDecoderConfig();
   es_adapter_.Reset();
 }
 
 bool EsParserH264::FindAUD(int64* stream_pos) {
   while (true) {
     const uint8* es;
     int size;
     es_queue_->PeekAt(*stream_pos, &es, &size);
 
@@ skipping 16 matching lines @@
       break;
 
     // The current NALU is not an AUD, skip the start code
     // and continue parsing the stream.
     *stream_pos += start_code_size;
   }
 
   return true;
 }
 
-bool EsParserH264::ParseInternal() {
+bool EsParserH264::ParseFromEsQueue() {
   DCHECK_LE(es_queue_->head(), current_access_unit_pos_);
   DCHECK_LE(current_access_unit_pos_, next_access_unit_pos_);
   DCHECK_LE(next_access_unit_pos_, es_queue_->tail());
 
   // Find the next AUD located at or after |current_access_unit_pos_|. This is
   // needed since initially |current_access_unit_pos_| might not point to
   // an AUD.
   // Discard all the data before the updated |current_access_unit_pos_|
   // since it won't be used again.
   bool aud_found = FindAUD(&current_access_unit_pos_);
@@ skipping 88 matching lines @@
                    is_key_frame, pps_id_for_access_unit));
   current_access_unit_pos_ = next_access_unit_pos_;
   es_queue_->Trim(current_access_unit_pos_);
 
   return true;
 }
 
 bool EsParserH264::EmitFrame(int64 access_unit_pos, int access_unit_size,
                              bool is_key_frame, int pps_id) {
   // Get the access unit timing info.
-  TimingDesc current_timing_desc = {kNoDecodeTimestamp(), kNoTimestamp()};
-  while (!timing_desc_list_.empty() &&
-         timing_desc_list_.front().first <= access_unit_pos) {
-    current_timing_desc = timing_desc_list_.front().second;
-    timing_desc_list_.pop_front();
-  }
+  TimingDesc current_timing_desc = GetTimingDescriptor(access_unit_pos);
   if (current_timing_desc.pts == kNoTimestamp())
     return false;
 
+  if (current_timing_desc.dts == kNoDecodeTimestamp()) {
+    current_timing_desc.dts =
+        DecodeTimestamp::FromPresentationTime(current_timing_desc.pts);
+  }
+
   // Update the video decoder configuration if needed.
   const H264PPS* pps = h264_parser_->GetPPS(pps_id);
   if (!pps) {
     // Only accept an invalid PPS at the beginning when the stream
     // does not necessarily start with an SPS/PPS/IDR.
     // In this case, the initial frames are conveyed to the upper layer with
     // an invalid VideoDecoderConfig and it's up to the upper layer
     // to process this kind of frame accordingly.
     if (last_video_decoder_config_.IsValidConfig())
       return false;
@@ skipping 72 matching lines @@
              << " height=" << sps->sar_height;
     last_video_decoder_config_ = video_decoder_config;
     es_adapter_.OnConfigChanged(video_decoder_config);
   }
 
   return true;
 }
 
 }  // namespace mp2t
 }  // namespace media