Mpeg2TS - estimate duration for video frames.

media/formats/mp2t/mp2t_stream_parser.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/mp2t_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
@@ skipping 139 matching lines @@
 }
 
 Mp2tStreamParser::BufferQueueWithConfig::~BufferQueueWithConfig() {
 }
 
 Mp2tStreamParser::Mp2tStreamParser(bool sbr_in_mimetype)
   : sbr_in_mimetype_(sbr_in_mimetype),
     selected_audio_pid_(-1),
     selected_video_pid_(-1),
     is_initialized_(false),
-    segment_started_(false),
-    first_video_frame_in_segment_(true) {
+    segment_started_(false) {
 }
 
 Mp2tStreamParser::~Mp2tStreamParser() {
   STLDeleteValues(&pids_);
 }
 
 void Mp2tStreamParser::Init(
     const InitCB& init_cb,
     const NewConfigCB& config_cb,
     const NewBuffersCB& new_buffers_cb,
@@ skipping 31 matching lines @@
     delete pid_state;
   }
   pids_.clear();
   EmitRemainingBuffers();
   buffer_queue_chain_.clear();
 
   // End of the segment.
   // Note: does not need to invoke |end_of_segment_cb_| since flushing the
   // stream parser already involves the end of the current segment.
   segment_started_ = false;
-  first_video_frame_in_segment_ = true;
-  discarded_frames_dts_.clear();
 
   // Remove any bytes left in the TS buffer.
   // (i.e. any partial TS packet => less than 188 bytes).
   ts_byte_queue_.Reset();
 
   // Reset the selected PIDs.
   selected_audio_pid_ = -1;
   selected_video_pid_ = -1;
 }
 
@@ skipping 273 matching lines @@
     scoped_refptr<StreamParserBuffer> stream_parser_buffer) {
   DCHECK_EQ(pes_pid, selected_audio_pid_);
 
   DVLOG(LOG_LEVEL_ES)
       << "OnEmitAudioBuffer: "
       << " size="
       << stream_parser_buffer->data_size()
       << " dts="
       << stream_parser_buffer->GetDecodeTimestamp().InMilliseconds()
       << " pts="
-      << stream_parser_buffer->timestamp().InMilliseconds();
+      << stream_parser_buffer->timestamp().InMilliseconds()
+      << " dur="
+      << stream_parser_buffer->duration().InMilliseconds();
   stream_parser_buffer->set_timestamp(
       stream_parser_buffer->timestamp() - time_offset_);
   stream_parser_buffer->SetDecodeTimestamp(
       stream_parser_buffer->GetDecodeTimestamp() - time_offset_);
 
   // Ignore the incoming buffer if it is not associated with any config.
   if (buffer_queue_chain_.empty()) {
     DVLOG(1) << "Ignoring audio buffer with no corresponding audio config";

[wolenetz, 2014/07/10 17:57:23]

If there has been no init segment prior to media segment, shouldn't parse error
occur? Should this clause trigger parse err? Furthermore, if there is a
non-empty chain, but it's back() has no audio config, should we log or emit some
kind of error indication here, too?

[damienv1, 2014/07/10 18:34:51]

True. With the updated code, there should always be a config before a frame is
pushed:
- was already the case for ADTS audio
- is now the case of H264 as well: the ES adapter emits frame only after it gets
the first config.

Will replace DVLOG with NOTREACHED (I prefer it to a single DCHECK which would
make "buffer_queue_chain_.back().audio_queue.push_back" crash in production.

     return;
   }
 
   buffer_queue_chain_.back().audio_queue.push_back(stream_parser_buffer);
 }
 
 void Mp2tStreamParser::OnEmitVideoBuffer(
     int pes_pid,
     scoped_refptr<StreamParserBuffer> stream_parser_buffer) {
   DCHECK_EQ(pes_pid, selected_video_pid_);
 
   DVLOG(LOG_LEVEL_ES)
       << "OnEmitVideoBuffer"
       << " size="
       << stream_parser_buffer->data_size()
       << " dts="
       << stream_parser_buffer->GetDecodeTimestamp().InMilliseconds()
       << " pts="
       << stream_parser_buffer->timestamp().InMilliseconds()
+      << " dur="
+      << stream_parser_buffer->duration().InMilliseconds()
       << " IsKeyframe="
       << stream_parser_buffer->IsKeyframe();
   stream_parser_buffer->set_timestamp(
       stream_parser_buffer->timestamp() - time_offset_);
   stream_parser_buffer->SetDecodeTimestamp(
       stream_parser_buffer->GetDecodeTimestamp() - time_offset_);
 
-  // Discard the incoming buffer:
-  // - if it is not associated with any config,
-  // - or if only non-key frames have been added to a new segment.
-  if (buffer_queue_chain_.empty() ||
-      (first_video_frame_in_segment_ && !stream_parser_buffer->IsKeyframe())) {
-    DVLOG(1) << "Discard video buffer:"
-             << " keyframe=" << stream_parser_buffer->IsKeyframe()
-             << " dts="
-             << stream_parser_buffer->GetDecodeTimestamp().InMilliseconds();
-    if (discarded_frames_dts_.empty() ||
-        discarded_frames_min_pts_ > stream_parser_buffer->timestamp()) {
-      discarded_frames_min_pts_ = stream_parser_buffer->timestamp();
-    }
-    discarded_frames_dts_.push_back(
-        stream_parser_buffer->GetDecodeTimestamp());
+  // Ignore the incoming buffer if it is not associated with any config.
+  if (buffer_queue_chain_.empty()) {
+    DVLOG(1) << "Ignoring video buffer with no corresponding video config";

[wolenetz, 2014/07/10 17:57:23]

If there has been no init segment prior to media segment, shouldn't parse error
occur? Should this clause trigger parse err? Furthermore, if there is a
non-empty chain, but it's back() has no video config, should we log or emit some
kind of error indication here, too?

[damienv1, 2014/07/10 18:34:52]

ditto.

     return;
   }
 
-  // Fill the gap created by frames that have been discarded.
-  if (!discarded_frames_dts_.empty())
-    FillVideoGap(stream_parser_buffer);
-
-  first_video_frame_in_segment_ = false;
   buffer_queue_chain_.back().video_queue.push_back(stream_parser_buffer);
 }
 
 bool Mp2tStreamParser::EmitRemainingBuffers() {
   DVLOG(LOG_LEVEL_ES) << "Mp2tStreamParser::EmitRemainingBuffers";
 
   // No buffer should be sent until fully initialized.
   if (!is_initialized_)
     return true;
 
@@ skipping 47 matching lines @@
 
   // Push an empty queue with the last audio/video config
   // so that buffers with the same config can be added later on.
   BufferQueueWithConfig queue_with_config(
       true, last_audio_config, last_video_config);
   buffer_queue_chain_.push_back(queue_with_config);
 
   return true;
 }
 
-void Mp2tStreamParser::FillVideoGap(
-    const scoped_refptr<StreamParserBuffer>& stream_parser_buffer) {
-  DCHECK(!buffer_queue_chain_.empty());
-  DCHECK(!discarded_frames_dts_.empty());
-  DCHECK(stream_parser_buffer->IsKeyframe());
-
-  // PTS is interpolated between the min PTS of discarded frames
-  // and the PTS of the first valid buffer.
-  base::TimeDelta pts = discarded_frames_min_pts_;
-  base::TimeDelta pts_delta =
-      (stream_parser_buffer->timestamp() - pts) / discarded_frames_dts_.size();
-
-  while (!discarded_frames_dts_.empty()) {
-    scoped_refptr<StreamParserBuffer> frame =
-        StreamParserBuffer::CopyFrom(
-            stream_parser_buffer->data(),
-            stream_parser_buffer->data_size(),
-            stream_parser_buffer->IsKeyframe(),
-            stream_parser_buffer->type(),
-            stream_parser_buffer->track_id());
-    frame->SetDecodeTimestamp(discarded_frames_dts_.front());
-    frame->set_timestamp(pts);
-    buffer_queue_chain_.back().video_queue.push_back(frame);
-    pts += pts_delta;
-    discarded_frames_dts_.pop_front();
-  }
-}
-
 }  // namespace mp2t
 }  // namespace media