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()),
+      //es_queue_(new media::OffsetByteQueue()),

[wolenetz, 2014/08/26 23:01:44]

ditto

[damienv1, 2014/08/27 16:23:43]

My mistake. Forgot to remove this line.

       h264_parser_(new H264Parser()),
       current_access_unit_pos_(0),
       next_access_unit_pos_(0) {
 }
 
 EsParserH264::~EsParserH264() {
 }
 

[wolenetz, 2014/08/26 23:01:44]

nit: Did you mean to drop the old ::Parse()'s Note about HLS, and its DVLOG_IF?

[damienv1, 2014/08/27 16:23:43]

I added back the HLS comment in the header file.
Regarding the DVLOG_IF, it is kind of an artificial restriction. If there is no
timing associated with an access unit, we will fail in EmitFrame when trying to
get the timing (this is really what matters). So I dropped the DVLOG_IF.

-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";
   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() {

[wolenetz, 2014/08/26 23:01:44]

ditto: super::Reset() should call some child::ResetInternal().

[damienv1, 2014/08/27 16:23:43]

Done.

   DVLOG(1) << "EsParserH264::Reset";
-  es_queue_.reset(new media::OffsetByteQueue());
+  EsParser::Reset();
   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