rendering_helper - Wait for rendering before resetting the decoder.

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 56 matching lines @@
     : texture_target_(texture_target),
       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) {
+RenderingHelper::RenderedVideo::RenderedVideo()
+    : last_frame_rendered(false), is_flushing(false) {
 }
 
 RenderingHelper::RenderedVideo::~RenderedVideo() {
 }
 
 // static
 bool RenderingHelper::InitializeOneOff() {
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 #if GL_VARIANT_GLX
   cmd_line->AppendSwitchASCII(switches::kUseGL,
@@ skipping 300 matching lines @@
   // the decoder.
   glFlush();
   ++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);
 
   // 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);
 }
 
-void RenderingHelper::DropPendingFrames(size_t window_id) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
-  RenderedVideo* video = &videos_[window_id];
-  video->pending_frames = std::queue<scoped_refptr<VideoFrameTexture> >();
-  video->last_frame_rendered = false;
-}
-
 void RenderingHelper::RenderTexture(uint32 texture_target, uint32 texture_id) {
   // The ExternalOES sampler is bound to GL_TEXTURE1 and the Texture2D sampler
   // is bound to GL_TEXTURE0.
   if (texture_target == GL_TEXTURE_2D) {
     glActiveTexture(GL_TEXTURE0 + 0);
   } else if (texture_target == GL_TEXTURE_EXTERNAL_OES) {
     glActiveTexture(GL_TEXTURE0 + 1);
   }
   glBindTexture(texture_target, texture_id);
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
@@ skipping 68 matching lines @@
     *rgb_ptr++ = *rgba_ptr++;
     *rgb_ptr++ = *rgba_ptr++;
     solid = solid && (*rgba_ptr == 0xff);
     rgba_ptr++;
   }
   *alpha_solid = solid;
 
   done->Signal();
 }
 
+void RenderingHelper::Flush(size_t window_id) {
+  videos_[window_id].is_flushing = true;
+}
+
 void RenderingHelper::RenderContent() {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
 
   // Frames that will be returned to the client (via the no_longer_needed_cb)
   // after this vector falls out of scope at the end of this method. We need
   // to keep references to them until after SwapBuffers() call below.
   std::vector<scoped_refptr<VideoFrameTexture> > frames_to_be_returned;
 
   if (render_as_thumbnails_) {
     // In render_as_thumbnails_ mode, we render the FBO content on the
     // screen instead of the decoded textures.
     GLSetViewPort(videos_[0].render_area);
     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->pending_frames.size() > 1) {
+      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;
       }
     }
   }
 
   gl_surface_->SwapBuffers();
 }
 
 // Helper function for the LayoutRenderingAreas(). The |lengths| are the
@@ skipping 43 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