rendering_helper - Drop frames if the decoder cannot catch up.

content/common/gpu/media/rendering_helper.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 "content/common/gpu/media/rendering_helper.h"
 
 #include <algorithm>
 #include <numeric>
 #include <vector>
 
@@ skipping 57 matching lines @@
       texture_id_(texture_id),
       no_longer_needed_cb_(no_longer_needed_cb) {
   DCHECK(!no_longer_needed_cb_.is_null());
 }
 
 VideoFrameTexture::~VideoFrameTexture() {
   base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 RenderingHelper::RenderedVideo::RenderedVideo()
-    : last_frame_rendered(false), is_flushing(false) {
+    : last_frame_rendered(false), is_flushing(false), frames_to_drop(0) {
 }
 
 RenderingHelper::RenderedVideo::~RenderedVideo() {
 }
 
 // static
 bool RenderingHelper::InitializeOneOff() {
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 #if GL_VARIANT_GLX
   cmd_line->AppendSwitchASCII(switches::kUseGL,
@@ skipping 302 matching lines @@
   ++frame_count_;
 }
 
 void RenderingHelper::QueueVideoFrame(
     size_t window_id,
     scoped_refptr<VideoFrameTexture> video_frame) {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   RenderedVideo* video = &videos_[window_id];
   DCHECK(!video->is_flushing);
 
+  if (video->frames_to_drop > 0) {
+    --video->frames_to_drop;

[acolwell GONE FROM CHROMIUM, 2014/09/16 19:10:39]

Is this frame dropping visible outside this code in some way? Web applications
need to be able to observe this via HTMLVideoElement::webkitDroppedFrameCount()
and VideoPlaybackQuality::droppedVideoFrame() so that they can adapt the content
downward to avoid overtaxing the decoder.

[Owen Lin, 2014/09/17 02:48:35]

The code is only used in the vda_unittest. It won't affect others.

+    return;
+  }
+
   // Pop the last frame if it has been rendered.
   if (video->last_frame_rendered) {
     // When last_frame_rendered is true, we should have only one pending frame.
     // Since we are going to have a new frame, we can release the pending one.
     DCHECK(video->pending_frames.size() == 1);
     video->pending_frames.pop();
     video->last_frame_rendered = false;
   }
 
   video->pending_frames.push(video_frame);
@@ skipping 107 matching lines @@
     RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
   } else {
     for (size_t i = 0; i < videos_.size(); ++i) {
       RenderedVideo* video = &videos_[i];
       if (video->pending_frames.empty())
         continue;
       scoped_refptr<VideoFrameTexture> frame = video->pending_frames.front();
       GLSetViewPort(video->render_area);
       RenderTexture(frame->texture_target(), frame->texture_id());
 
+      if (video->last_frame_rendered)

[Pawel Osciak, 2014/09/15 14:09:34]

Please note here that we won't start dropping before first frame is queued via
QueueVideoFrame, because initially last_frame_rendered is false, which means
that we don't drop if the first frame is delivered late.
And the above behavior is ok from the point of view of the test framework that
counts frames, it will still catch late first decode, right?

[Owen Lin, 2014/09/16 01:38:34]

That's the expected behavior, we always wait for the first frame.
We have a metrics on the delivery time of the first frame in the VDAPerf test so
we still catch this kind of bugs.

+        ++video->frames_to_drop;
+
       if (video->pending_frames.size() > 1 || video->is_flushing) {
         frames_to_be_returned.push_back(video->pending_frames.front());
         video->pending_frames.pop();
         video->last_frame_rendered = false;
       } else {
         video->last_frame_rendered = true;
       }
     }
   }
 
@@ skipping 47 matching lines @@
     scale = std::min(1.0f, scale);
 
     size_t w = scale * size.width();
     size_t h = scale * size.height();
     size_t x = offset_x[i % cols] + (widths[i % cols] - w) / 2;
     size_t y = offset_y[i / cols] + (heights[i / cols] - h) / 2;
     videos_[i].render_area = gfx::Rect(x, y, w, h);
   }
 }
 }  // namespace content