media: In low delay mode, do not accumulate frames earlier than the start time.

media/renderers/video_renderer_impl.cc

 // Copyright 2013 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/renderers/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
@@ skipping 472 matching lines @@
       return;
 
     DCHECK_EQ(state_, kPlaying);
 
     // Can happen when demuxers are preparing for a new Seek().
     if (!frame.get()) {
       DCHECK_EQ(status, VideoFrameStream::DEMUXER_READ_ABORTED);
       return;
     }
 
+    // In low delay mode, don't accumulate frames that's earlier than the start
+    // time. Otherwise we could declare HAVE_ENOUGH_DATA and start playback
+    // prematurely.
+    if (low_delay_ &&
+        !frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM) &&
+        frame->timestamp() < start_timestamp_) {
+      AttemptRead_Locked();
+      return;
+    }
+
     if (frame->metadata()->IsTrue(VideoFrameMetadata::END_OF_STREAM)) {
       DCHECK(!received_end_of_stream_);
       received_end_of_stream_ = true;
 
       // See if we can fire EOS immediately instead of waiting for Render().
       if (use_new_video_renderering_path_)
         MaybeFireEndedCallback();
     } else {
       // Maintain the latest frame decoded so the correct frame is displayed
       // after prerolling has completed.

[xhwang, 2015/07/21 20:30:26]

Is this mostly for the old rendering path? Can we just drop all early frames in
low-delay and non-low-delay modes? It seems to me early frames are just an
inevitable artifact of the demuxer, and it should be isolated from our rendering
logic.

[DaleCurtis, 2015/07/21 21:16:50]

Well, consider what happens if T=1s and the frames are 0s, 10s. Would we discard
the frame at 0s and wait for the 10s frame?  At most I think you could always
discard [frame_start, frame_end] when T > frame_end.

[xhwang, 2015/07/21 21:53:37]

I see your point. Things would be much simpler if we have a good estimation of
the duration... Not sure how hard to plumb that through.

       if (frame->timestamp() <= start_timestamp_) {
         if (use_new_video_renderering_path_)
           algorithm_->Reset();
         ready_frames_.clear();
       }
       AddReadyFrame_Locked(frame);
     }
 
     // Background rendering updates may not be ticking fast enough by itself to
     // remove expired frames, so give it a boost here by ensuring we don't exit
@@ skipping 264 matching lines @@
 base::TimeTicks VideoRendererImpl::ConvertMediaTimestamp(
     base::TimeDelta media_time) {
   std::vector<base::TimeDelta> media_times(1, media_time);
   std::vector<base::TimeTicks> wall_clock_times;
   if (!wall_clock_time_cb_.Run(media_times, &wall_clock_times))
     return base::TimeTicks();
   return wall_clock_times[0];
 }
 
 }  // namespace media