vda_unittest - Move the fps control from ThrottleVDAClient to RenderingHelper.

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 "base/bind.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringize_macros.h"
@@ skipping 79 matching lines @@
 void RenderingHelper::Initialize(const RenderingHelperParams& params,
                                  base::WaitableEvent* done) {
   // Use frame_dimensions_.size() != 0 as a proxy for the class having already
   // been Initialize()'d, and UnInitialize() before continuing.
   if (frame_dimensions_.size()) {
     base::WaitableEvent done(false, false);
     UnInitialize(&done);
     done.Wait();
   }
 
-  // TODO(owenlin): pass fps from params
-  frame_duration_ = base::TimeDelta::FromSeconds(1) / 60;
+  frame_duration_ = params.rendering_fps > 0
+      ? base::TimeDelta::FromSeconds(1) / params.rendering_fps
+      : base::TimeDelta();
 
   gfx::InitializeStaticGLBindings(kGLImplementation);
   scoped_refptr<gfx::GLContextStubWithExtensions> stub_context(
       new gfx::GLContextStubWithExtensions());
 
   CHECK_GT(params.window_dimensions.size(), 0U);
   CHECK_EQ(params.frame_dimensions.size(), params.window_dimensions.size());
   frame_dimensions_ = params.frame_dimensions;
   render_as_thumbnails_ = params.render_as_thumbnails;
   message_loop_ = base::MessageLoop::current();
@@ skipping 68 matching lines @@
       gl_display_, egl_config, EGL_NO_CONTEXT, context_attribs);
   CHECK_NE(gl_context_, EGL_NO_CONTEXT) << eglGetError();
   stub_context->AddExtensionsString(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
   stub_context->AddExtensionsString(
       eglQueryString(gl_display_, EGL_EXTENSIONS));
   stub_context->SetGLVersionString(
       reinterpret_cast<const char*>(glGetString(GL_VERSION)));
 #endif
 
+  clients_.resize(params.num_windows);
   // Per-window/surface X11 & EGL initialization.
   for (int i = 0; i < params.num_windows; ++i) {
     // Arrange X windows whimsically, with some padding.
     int j = i % params.window_dimensions.size();
     int width = params.window_dimensions[j].width();
     int height = params.window_dimensions[j].height();
     CHECK_GT(width, 0);
     CHECK_GT(height, 0);
     int top_left_x = (width + 20) * (i % 4);
     int top_left_y = (height + 12) * (i % 3);
     render_areas_.push_back(gfx::Rect(
         top_left_x, top_left_y, width, height));
-
-    // Initialize to an invalid texture id: 0 to indicate no texture
-    // for rendering.
-    texture_ids_.push_back(0);
-    texture_targets_.push_back(0);
   }
 
 #if defined(OS_WIN)
   window_ = CreateWindowEx(0, L"Static", L"VideoDecodeAcceleratorTest",
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE, 0, 0,
                            window_size.width(), widow_size.height(),
                            NULL, NULL, NULL, NULL);
   CHECK(window_ != NULL);
 #else
   int depth = DefaultDepth(x_display_, DefaultScreen(x_display_));
@@ skipping 67 matching lines @@
                               GL_COLOR_ATTACHMENT0,
                               GL_TEXTURE_2D,
                               thumbnails_texture_id_,
                               0);
 
     GLenum fb_status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
     CHECK(fb_status == GL_FRAMEBUFFER_COMPLETE) << fb_status;
     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT);
     glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
-
-    // In render_as_thumbnails_ mode, we render the FBO content on the
-    // screen instead of the decoded textures.
-    texture_targets_[0] = GL_TEXTURE_2D;
-    texture_ids_[0] = thumbnails_texture_id_;
   }
 
   // These vertices and texture coords. map (0,0) in the texture to the
   // bottom left of the viewport.  Since we get the video frames with the
   // the top left at (0,0) we need to flip the texture y coordinate
   // in the vertex shader for this to be rendered the right way up.
   // In the case of thumbnail rendering we use the same vertex shader
   // to render the FBO the screen, where we do not want this flipping.
   static const float kVertices[] =
       { -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, 1.f, -1.f, };
@@ skipping 59 matching lines @@
   if (tex_external != -1) {
     glUniform1i(tex_external, 1);
   }
   int pos_location = glGetAttribLocation(program_, "in_pos");
   glEnableVertexAttribArray(pos_location);
   glVertexAttribPointer(pos_location, 2, GL_FLOAT, GL_FALSE, 0, kVertices);
   int tc_location = glGetAttribLocation(program_, "in_tc");
   glEnableVertexAttribArray(tc_location);
   glVertexAttribPointer(tc_location, 2, GL_FLOAT, GL_FALSE, 0, kTextureCoords);
 
-  render_timer_.Start(FROM_HERE, frame_duration_, this,
-                      &RenderingHelper::RenderContent);
+  if (frame_duration_ != base::TimeDelta()) {
+    render_timer_.Start(FROM_HERE, frame_duration_, this,
+                        &RenderingHelper::RenderContent);
+  }
   done->Signal();
 }
 
 void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   render_timer_.Stop();
   if (render_as_thumbnails_) {
     glDeleteTextures(1, &thumbnails_texture_id_);
     glDeleteFramebuffersEXT(1, &thumbnails_fbo_id_);
   }
 #if GL_VARIANT_GLX
 
   glXDestroyContext(x_display_, gl_context_);
 #else // EGL
   CHECK(eglDestroyContext(gl_display_, gl_context_));
   CHECK(eglDestroySurface(gl_display_, gl_surface_));
   CHECK(eglTerminate(gl_display_));
 #endif
   gfx::ClearGLBindings();
   Clear();
   done->Signal();
 }
 
+void RenderingHelper::SetClient(int window_id, RenderingClient *client) {
+  if (base::MessageLoop::current() != message_loop_) {
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&RenderingHelper::SetClient, base::Unretained(this),
+                   window_id, client));
+    return;
+  }
+  clients_[window_id] = client;
+}
+
 void RenderingHelper::CreateTexture(int window_id,
                                     uint32 texture_target,
                                     uint32* texture_id,
                                     base::WaitableEvent* done) {
   if (base::MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
                    window_id, texture_target, texture_id, done));
     return;
@@ skipping 16 matching lines @@
   glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
   // OpenGLES2.0.25 section 3.8.2 requires CLAMP_TO_EDGE for NPOT textures.
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
   CHECK(texture_id_to_surface_index_.insert(
       std::make_pair(*texture_id, window_id)).second);
   done->Signal();
 }
 
+// Helper function to set GL viewport.
+static inline void GLSetViewPort(const gfx::Rect& area) {
+  glViewport(area.x(), area.y(), area.width(), area.height());
+  glScissor(area.x(), area.y(), area.width(), area.height());
+}
+
+void RenderingHelper::RenderThumbnail(uint32 texture_target,
+                                      uint32 texture_id) {
+  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  const int width = thumbnail_size_.width();
+  const int height = thumbnail_size_.height();
+  const int thumbnails_in_row = thumbnails_fbo_size_.width() / width;
+  const int thumbnails_in_column = thumbnails_fbo_size_.height() / height;
+  const int row = (frame_count_ / thumbnails_in_row) % thumbnails_in_column;
+  const int col = frame_count_ % thumbnails_in_row;
+
+  gfx::Rect area(col * width, row * height, width, height);
+
+  glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
+  GLSetViewPort(area);
+  RenderTexture(texture_target, texture_id);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+  ++frame_count_;
+}
 
 void RenderingHelper::RenderTexture(uint32 texture_target, uint32 texture_id) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
-  if (texture_id == 0)
-      return;
-
-  if (render_as_thumbnails_) {
-    const int width = thumbnail_size_.width();
-    const int height = thumbnail_size_.height();
-    const int thumbnails_in_row = thumbnails_fbo_size_.width() / width;
-    const int thumbnails_in_column = thumbnails_fbo_size_.height() / height;
-    const int row = (frame_count_ / thumbnails_in_row) % thumbnails_in_column;
-    const int col = frame_count_ % thumbnails_in_row;
-
-    gfx::Rect area(col * width, row * height, width, height);
-
-    glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
-    glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
-    DrawTexture(area, texture_target, texture_id);
-    glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
-    ++frame_count_;
-  } else {
-    size_t window_id = texture_id_to_surface_index_[texture_id];
-    texture_targets_[window_id] = texture_target;
-    texture_ids_[window_id] = texture_id;
-  }
-}
-
-void RenderingHelper::DrawTexture(const gfx::Rect& area,
-                                  uint32 texture_target,
-                                  uint32 texture_id) {
-  glViewport(area.x(), area.y(), area.width(), area.height());
-  glScissor(area.x(), area.y(), area.width(), area.height());
-
   // Unbound texture samplers default to (0, 0, 0, 1).  Use this fact to switch
   // between GL_TEXTURE_2D and GL_TEXTURE_EXTERNAL_OES as appopriate.
   if (texture_target == GL_TEXTURE_2D) {
     glActiveTexture(GL_TEXTURE0 + 0);
     glBindTexture(GL_TEXTURE_2D, texture_id);
     glActiveTexture(GL_TEXTURE0 + 1);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
   } else if (texture_target == GL_TEXTURE_EXTERNAL_OES) {
     glActiveTexture(GL_TEXTURE0 + 0);
     glBindTexture(GL_TEXTURE_2D, 0);
@@ skipping 81 matching lines @@
     *rgb_ptr++ = *rgba_ptr++;
     solid = solid && (*rgba_ptr == 0xff);
     rgba_ptr++;
   }
   *alpha_solid = solid;
 
   done->Signal();
 }
 
 void RenderingHelper::RenderContent() {
+
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
-  for (size_t i = 0; i < render_areas_.size(); ++i) {
-    DrawTexture(render_areas_[i], texture_targets_[i], texture_ids_[i]);
+
+  if (render_as_thumbnails_) {
+    // In render_as_thumbnails_ mode, we render the FBO content on the
+    // screen instead of the decoded textures.
+    GLSetViewPort(render_areas_[0]);
+    RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
+  } else {
+      for (size_t i = 0; i < clients_.size(); ++i) {
+        RenderingClient *client = clients_[i];
+        if (client != NULL) {
+          GLSetViewPort(render_areas_[i]);
+          client->RenderContent(this);
+        }
+      }
   }
 
 #if GL_VARIANT_GLX
   glXSwapBuffers(x_display_, x_window_);
 #else  // EGL
   eglSwapBuffers(gl_display_, gl_surface_);
   CHECK_EQ(static_cast<int>(eglGetError()), EGL_SUCCESS);
 #endif
 }
 }  // namespace content