rendering_helper - Change the layout of the rendering areas.

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>
+
 #include "base/bind.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_context_stub_with_extensions.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
@@ skipping 55 matching lines @@
 #if defined(OS_WIN)
   window_ = NULL;
 #else
   x_window_ = (Window)0;
 #endif
 
   Clear();
 }
 
 RenderingHelper::~RenderingHelper() {
-  CHECK_EQ(frame_dimensions_.size(), 0U)
-      << "Must call UnInitialize before dtor.";
+  CHECK_EQ(clients_.size(), 0U) << "Must call UnInitialize before dtor.";
   Clear();
 }
 
 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()) {
+  // Use cients_.size() != 0 as a proxy for the class having already been
+  // Initialize()'d, and UnInitialize() before continuing.
+  if (clients_.size()) {
     base::WaitableEvent done(false, false);
     UnInitialize(&done);
     done.Wait();
   }
 
   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();
-  CHECK_GT(params.num_windows, 0);
-
-  gfx::Size window_size;
 
 #if GL_VARIANT_GLX
   x_display_ = gfx::GetXDisplay();
   CHECK(x_display_);
   CHECK(glXQueryVersion(x_display_, NULL, NULL));
   const int fbconfig_attr[] = {
     GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
     GLX_RENDER_TYPE, GLX_RGBA_BIT,
     GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT,
     GLX_BIND_TO_TEXTURE_RGB_EXT, GL_TRUE,
     GLX_DOUBLEBUFFER, True,
     GL_NONE,
   };
   int num_fbconfigs;
   scoped_ptr<GLXFBConfig, XFreeDeleter> glx_fb_configs(
       glXChooseFBConfig(x_display_, DefaultScreen(x_display_), fbconfig_attr,
                         &num_fbconfigs));
   CHECK(glx_fb_configs.get());
   CHECK_GT(num_fbconfigs, 0);
   x_visual_ = glXGetVisualFromFBConfig(x_display_, glx_fb_configs.get()[0]);
   CHECK(x_visual_);
   gl_context_ = glXCreateContext(x_display_, x_visual_, 0, true);
   CHECK(gl_context_);
   stub_context->AddExtensionsString(
       reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS)));
   stub_context->SetGLVersionString(
       reinterpret_cast<const char*>(glGetString(GL_VERSION)));
 
   Screen* screen = DefaultScreenOfDisplay(x_display_);
-  window_size = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
+  screen_size_ = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
 #else // EGL
   EGLNativeDisplayType native_display;
 
 #if defined(OS_WIN)
   native_display = EGL_DEFAULT_DISPLAY;
-  window_size =
+  screen_size_ =
       gfx::Size(GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
 #else
   x_display_ = gfx::GetXDisplay();
   CHECK(x_display_);
   native_display = x_display_;
 
   Screen* screen = DefaultScreenOfDisplay(x_display_);
-  window_size = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
+  screen_size_ = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
 #endif
   gl_display_ = eglGetDisplay(native_display);
   CHECK(gl_display_);
   CHECK(eglInitialize(gl_display_, NULL, NULL)) << glGetError();
 
   static EGLint rgba8888[] = {
     EGL_RED_SIZE, 8,
     EGL_GREEN_SIZE, 8,
     EGL_BLUE_SIZE, 8,
     EGL_ALPHA_SIZE, 8,
@@ skipping 10 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_ = params.clients;
-  // 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));
-  }
+  CHECK_GT(clients_.size(), 0U);
+  LayoutRenderingAreas();
 
 #if defined(OS_WIN)
   window_ = CreateWindowEx(0,
                            L"Static",
                            L"VideoDecodeAcceleratorTest",
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                            0,
                            0,
-                           window_size.width(),
-                           window_size.height(),
+                           screen_size_.width(),
+                           screen_size_.height(),
                            NULL,
                            NULL,
                            NULL,
                            NULL);
   CHECK(window_ != NULL);
 #else
   int depth = DefaultDepth(x_display_, DefaultScreen(x_display_));
 
 #if defined(GL_VARIANT_GLX)
   CHECK_EQ(depth, x_visual_->depth);
 #endif
 
   XSetWindowAttributes window_attributes;
   window_attributes.background_pixel =
       BlackPixel(x_display_, DefaultScreen(x_display_));
   window_attributes.override_redirect = true;
 
   x_window_ = XCreateWindow(x_display_,
                             DefaultRootWindow(x_display_),
                             0,
                             0,
-                            window_size.width(),
-                            window_size.height(),
+                            screen_size_.width(),
+                            screen_size_.height(),
                             0 /* border width */,
                             depth,
                             CopyFromParent /* class */,
                             CopyFromParent /* visual */,
                             (CWBackPixel | CWOverrideRedirect),
                             &window_attributes);
   XStoreName(x_display_, x_window_, "VideoDecodeAcceleratorTest");
   XSelectInput(x_display_, x_window_, ExposureMask);
   XMapWindow(x_display_, x_window_);
 #endif
@@ skipping 13 matching lines @@
   CHECK(glXMakeContextCurrent(x_display_, x_window_, x_window_, gl_context_));
 #else  // EGL
   CHECK(eglMakeCurrent(gl_display_, gl_surface_, gl_surface_, gl_context_))
       << eglGetError();
 #endif
 
   // Must be done after a context is made current.
   gfx::InitializeDynamicGLBindings(kGLImplementation, stub_context.get());
 
   if (render_as_thumbnails_) {
-    CHECK_EQ(frame_dimensions_.size(), 1U);
+    CHECK_EQ(clients_.size(), 1U);
 
     GLint max_texture_size;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
     CHECK_GE(max_texture_size, params.thumbnails_page_size.width());
     CHECK_GE(max_texture_size, params.thumbnails_page_size.height());
 
     thumbnails_fbo_size_ = params.thumbnails_page_size;
     thumbnail_size_ = params.thumbnail_size;
 
     glGenFramebuffersEXT(1, &thumbnails_fbo_id_);
@@ skipping 124 matching lines @@
 #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::CreateTexture(int window_id,
-                                    uint32 texture_target,
+void RenderingHelper::CreateTexture(uint32 texture_target,
                                     uint32* texture_id,
+                                    const gfx::Size& size,
                                     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));
+    message_loop_->PostTask(FROM_HERE,
+                            base::Bind(&RenderingHelper::CreateTexture,
+                                       base::Unretained(this),
+                                       texture_target,
+                                       texture_id,
+                                       size,
+                                       done));
     return;
   }
   glGenTextures(1, texture_id);
   glBindTexture(texture_target, *texture_id);
-  int dimensions_id = window_id % frame_dimensions_.size();
   if (texture_target == GL_TEXTURE_2D) {
     glTexImage2D(GL_TEXTURE_2D,
                  0,
                  GL_RGBA,
-                 frame_dimensions_[dimensions_id].width(),
-                 frame_dimensions_[dimensions_id].height(),
+                 size.width(),
+                 size.height(),
                  0,
                  GL_RGBA,
                  GL_UNSIGNED_BYTE,
                  NULL);
   }
   glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   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,
@@ skipping 44 matching lines @@
 
 void* RenderingHelper::GetGLDisplay() {
 #if GL_VARIANT_GLX
   return x_display_;
 #else  // EGL
   return gl_display_;
 #endif
 }
 
 void RenderingHelper::Clear() {
-  frame_dimensions_.clear();
-  texture_id_to_surface_index_.clear();
+  clients_.clear();
   message_loop_ = NULL;
   gl_context_ = NULL;
 #if GL_VARIANT_EGL
   gl_display_ = EGL_NO_DISPLAY;
   gl_surface_ = EGL_NO_SURFACE;
 #endif
   render_as_thumbnails_ = false;
   frame_count_ = 0;
   thumbnails_fbo_id_ = 0;
   thumbnails_texture_id_ = 0;
@@ skipping 68 matching lines @@
     }
   }
 
 #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
 }
+
+// Helper function for the LayoutRenderingAreas(). The |lengths| are the
+// heights(widths) of the rows(columns). It scales the elements in
+// |lengths| proportionally so that the sum of them equal to |total_length|.
+// It also outputs the coordinates of the rows(columns) to |offsets|.
+static void ScaleAndCalculateOffsets(std::vector<int>* lengths,
+                                     std::vector<int>* offsets,
+                                     int total_length) {
+  int sum = std::accumulate(lengths->begin(), lengths->end(), 0);
+  for (size_t i = 0; i < lengths->size(); ++i) {
+    lengths->at(i) = lengths->at(i) * total_length / sum;
+    offsets->at(i) = (i == 0) ? 0 : offsets->at(i - 1) + lengths->at(i - 1);
+  }
+}
+
+void RenderingHelper::LayoutRenderingAreas() {
+  // Find the number of colums and rows.
+  // The smallest n * n or n * (n + 1) > number of clients.
+  size_t cols = sqrt(clients_.size() - 1) + 1;
+  size_t rows = (clients_.size() + cols - 1) / cols;
+
+  // Find the widths and heights of the grid.
+  std::vector<int> widths(cols);
+  std::vector<int> heights(rows);
+  std::vector<int> offset_x(cols);
+  std::vector<int> offset_y(rows);
+
+  for (size_t i = 0; i < clients_.size(); ++i) {
+    const gfx::Size& window_size = clients_[i]->GetWindowSize();
+    widths[i % cols] = std::max(widths[i % cols], window_size.width());
+    heights[i / cols] = std::max(heights[i / cols], window_size.height());
+  }
+
+  ScaleAndCalculateOffsets(&widths, &offset_x, screen_size_.width());
+  ScaleAndCalculateOffsets(&heights, &offset_y, screen_size_.height());
+
+  // Put each render_area_ in the center of each cell.
+  render_areas_.clear();
+  for (size_t i = 0; i < clients_.size(); ++i) {
+    const gfx::Size& window_size = clients_[i]->GetWindowSize();
+    float scale =
+        std::min(static_cast<float>(widths[i % cols]) / window_size.width(),
+                 static_cast<float>(heights[i / cols]) / window_size.height());
+
+    // Don't scale up the texture.
+    scale = std::min(1.0f, scale);
+
+    size_t w = scale * window_size.width();
+    size_t h = scale * window_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;
+    render_areas_.push_back(gfx::Rect(x, y, w, h));
+  }
+}
 }  // namespace content