video_decode_accelerator_unittest: enable test on ozone surfaceless

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/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
+#include "content/common/gpu/media/gl_renderer.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #endif
 
 #if defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
 #include "ui/gl/gl_surface_glx.h"
 #define GL_VARIANT_GLX 1
 #else
 #include "ui/gl/gl_surface_egl.h"
 #define GL_VARIANT_EGL 1
 #endif
 
 #if defined(USE_OZONE)
+#include "content/common/gpu/media/surfaceless_gl_renderer.h"
 #if defined(OS_CHROMEOS)
 #include "ui/display/chromeos/display_configurator.h"
 #endif  // defined(OS_CHROMEOS)
+#include "ui/ozone/gpu/gpu_memory_buffer_factory_ozone_native_buffer.h"
 #include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/ozone_switches.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/platform_window_delegate.h"
 #endif  // defined(USE_OZONE)
 
 // Helper for Shader creation.
 static void CreateShader(GLuint program,
                          GLenum type,
                          const char* source,
                          int size) {
   GLuint shader = glCreateShader(type);
@@ skipping 68 matching lines @@
   void OnActivationChanged(bool active) override {};
 
   gfx::AcceleratedWidget accelerated_widget() const {
     return accelerated_widget_;
   }
 
   gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
 
   ui::PlatformWindow* platform_window() const { return platform_window_.get(); }
 
+  ui::GpuMemoryBufferFactoryOzoneNativeBuffer* buffer_factory() {
+    return &buffer_factory_;
+  }
+
  private:
+  // Used by the surfaceless renderers to allocate buffers.
+  ui::GpuMemoryBufferFactoryOzoneNativeBuffer buffer_factory_;
+
   scoped_ptr<ui::PlatformWindow> platform_window_;
   gfx::AcceleratedWidget accelerated_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(StubOzoneDelegate);
 };
 
 #endif  // defined(USE_OZONE)
 
 RenderingHelperParams::RenderingHelperParams()
     : rendering_fps(0), warm_up_iterations(0), render_as_thumbnails(false) {
@@ skipping 36 matching lines @@
   done->Signal();
 }
 
 RenderingHelper::RenderingHelper() {
   window_ = gfx::kNullAcceleratedWidget;
   Clear();
 }
 
 RenderingHelper::~RenderingHelper() {
   CHECK_EQ(videos_.size(), 0U) << "Must call UnInitialize before dtor.";
-  Clear();
+  CHECK(!gl_renderer_);
 }
 
 void RenderingHelper::Setup() {
 #if defined(OS_WIN)
+  screen_size_  = gfx::Size(GetSystemMetrics(SM_CXSCREEN),
+                            GetSystemMetrics(SM_CYSCREEN));
   window_ = CreateWindowEx(0,
                            L"Static",
                            L"VideoDecodeAcceleratorTest",
                            WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                            0,
                            0,
-                           GetSystemMetrics(SM_CXSCREEN),
-                           GetSystemMetrics(SM_CYSCREEN),
+                           screen_size_.width(),
+                           screen_size_.height(),
                            NULL,
                            NULL,
                            NULL,
                            NULL);
 #elif defined(USE_X11)
   Display* display = gfx::GetXDisplay();
   Screen* screen = DefaultScreenOfDisplay(display);
 
   CHECK(display);
 
   XSetWindowAttributes window_attributes;
   memset(&window_attributes, 0, sizeof(window_attributes));
   window_attributes.background_pixel =
       BlackPixel(display, DefaultScreen(display));
   window_attributes.override_redirect = true;
   int depth = DefaultDepth(display, DefaultScreen(display));
 
+  screen_size_  = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
+
   window_ = XCreateWindow(display,
                           DefaultRootWindow(display),
                           0,
                           0,
-                          XWidthOfScreen(screen),
-                          XHeightOfScreen(screen),
+                          screen_size_.width(),
+                          screen_size_.height(),
                           0 /* border width */,
                           depth,
                           CopyFromParent /* class */,
                           CopyFromParent /* visual */,
                           (CWBackPixel | CWOverrideRedirect),
                           &window_attributes);
   XStoreName(display, window_, "VideoDecodeAcceleratorTest");
   XSelectInput(display, window_, ExposureMask);
   XMapWindow(display, window_);
 #elif defined(USE_OZONE)
@@ skipping 10 matching lines @@
   base::RunLoop wait_display_setup;
   DisplayConfiguratorObserver display_setup_observer(&wait_display_setup);
   display_configurator_.reset(new ui::DisplayConfigurator());
   display_configurator_->AddObserver(&display_setup_observer);
   display_configurator_->Init(true);
   display_configurator_->ForceInitialConfigure(0);
   // Make sure all the display configuration is applied.
   wait_display_setup.Run();
   display_configurator_->RemoveObserver(&display_setup_observer);
 
+  screen_size_ = display_configurator_->framebuffer_size();
+#else
+  screen_size_ = gfx::Size(800, 600));
+#endif
   platform_window_delegate_->platform_window()->SetBounds(
-      gfx::Rect(display_configurator_->framebuffer_size()));
-#else
-  platform_window_delegate_->platform_window()->SetBounds(gfx::Rect(800, 600));
-#endif
+      gfx::Rect(screen_size_));
 
   // On Ozone/DRI, platform windows are associated with the physical
   // outputs. Association is achieved by matching the bounds of the
   // window with the origin & modeset of the display output. Until a
   // window is associated with a display output, we cannot get vsync
   // events, because there is no hardware to get events from. Here we
   // wait for the window to resized and therefore associated with
   // display output to be sure that we will get such events.
   wait_window_resize.RunUntilIdle();
 #else
@@ skipping 25 matching lines @@
 void RenderingHelper::Initialize(const RenderingHelperParams& params,
                                  base::WaitableEvent* done) {
   // Use videos_.size() != 0 as a proxy for the class having already been
   // Initialize()'d, and UnInitialize() before continuing.
   if (videos_.size()) {
     base::WaitableEvent done(false, false);
     UnInitialize(&done);
     done.Wait();
   }
 
+#if defined(USE_OZONE)
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kOzoneUseSurfaceless))
+    gl_renderer_.reset(new SurfacelessGlRenderer(
+        window_, screen_size_, platform_window_delegate_->buffer_factory()));
+  else
+    gl_renderer_.reset(new GlRenderer(window_, screen_size_));
+#else
+  gl_renderer_.reset(new GlRenderer(window_, screen_size_));
+#endif
+
+  CHECK(gl_renderer_->Initialize());
+
   render_task_.Reset(
       base::Bind(&RenderingHelper::RenderContent, base::Unretained(this)));
 
   frame_duration_ = params.rendering_fps > 0
                         ? base::TimeDelta::FromSeconds(1) / params.rendering_fps
                         : base::TimeDelta();
 
   render_as_thumbnails_ = params.render_as_thumbnails;
   message_loop_ = base::MessageLoop::current();
 
-  gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
-  screen_size_ = gl_surface_->GetSize();
-
-  gl_context_ = gfx::GLContext::CreateGLContext(
-      NULL, gl_surface_.get(), gfx::PreferIntegratedGpu);
-  CHECK(gl_context_->MakeCurrent(gl_surface_.get()));
+  CHECK(gl_renderer_->MakeCurrent());
 
   CHECK_GT(params.window_sizes.size(), 0U);
   videos_.resize(params.window_sizes.size());
   LayoutRenderingAreas(params.window_sizes);
 
   if (render_as_thumbnails_) {
     CHECK_EQ(videos_.size(), 1U);
 
     GLint max_texture_size;
     glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
@@ skipping 14 matching lines @@
                  0,
                  GL_RGB,
                  GL_UNSIGNED_SHORT_5_6_5,
                  NULL);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glBindTexture(GL_TEXTURE_2D, 0);
 
-    glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
+    gl_renderer_->BindFramebuffer(thumbnails_fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
                               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);
+    gl_renderer_->UnbindFramebuffer();
   }
 
   // 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 46 matching lines @@
   int result = GL_FALSE;
   glGetProgramiv(program_, GL_LINK_STATUS, &result);
   if (!result) {
     char log[4096];
     glGetShaderInfoLog(program_, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glUseProgram(program_);
   glDeleteProgram(program_);
 
-  glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
+  glUniform1i(glGetUniformLocation(program_, "tex_flip"),
+              gl_renderer_->IsFlipped() ? 0 : 1);
   glUniform1i(glGetUniformLocation(program_, "tex"), 0);
   GLint tex_external = glGetUniformLocation(program_, "tex_external");
   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);
@@ skipping 10 matching lines @@
     // test's last frames, so we set warm up iterations to 2, to clear
     // the front and back buffers.
     warm_up_iterations = std::max(2, warm_up_iterations);
 #endif
     WarmUpRendering(warm_up_iterations);
   }
 
   // It's safe to use Unretained here since |rendering_thread_| will be stopped
   // in VideoDecodeAcceleratorTest.TearDown(), while the |rendering_helper_| is
   // a member of that class. (See video_decode_accelerator_unittest.cc.)
-  gfx::VSyncProvider* vsync_provider = gl_surface_->GetVSyncProvider();
+  gfx::VSyncProvider* vsync_provider =
+      gl_renderer_->gl_surface()->GetVSyncProvider();
   if (vsync_provider && frame_duration_ != base::TimeDelta())
     vsync_provider->GetVSyncParameters(base::Bind(
         &RenderingHelper::UpdateVSyncParameters, base::Unretained(this), done));
   else
     done->Signal();
 }
 
 // The rendering for the first few frames is slow (e.g., 100ms on Peach Pit).
 // This affects the numbers measured in the performance test. We try to render
 // several frames here to warm up the rendering.
 void RenderingHelper::WarmUpRendering(int warm_up_iterations) {
   unsigned int texture_id;
   scoped_ptr<GLubyte[]> emptyData(new GLubyte[screen_size_.GetArea() * 2]());
   glGenTextures(1, &texture_id);
   glBindTexture(GL_TEXTURE_2D, texture_id);
   glTexImage2D(GL_TEXTURE_2D,
                0,
                GL_RGB,
                screen_size_.width(),
                screen_size_.height(),
                0,
                GL_RGB,
                GL_UNSIGNED_SHORT_5_6_5,
                emptyData.get());
   for (int i = 0; i < warm_up_iterations; ++i) {
     RenderTexture(GL_TEXTURE_2D, texture_id);
-    gl_surface_->SwapBuffers();
+    gl_renderer_->SwapBuffers();
   }
   glDeleteTextures(1, &texture_id);
 }
 
 void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
 
   render_task_.Cancel();
 
   if (render_as_thumbnails_) {
     glDeleteTextures(1, &thumbnails_texture_id_);
     glDeleteFramebuffersEXT(1, &thumbnails_fbo_id_);
   }
 
-  gl_context_->ReleaseCurrent(gl_surface_.get());
-  gl_context_ = NULL;
-  gl_surface_ = NULL;
+  Clear();
 
-  Clear();
   done->Signal();
 }
 
 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,
@@ skipping 38 matching lines @@
   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_);
+  gl_renderer_->BindFramebuffer(thumbnails_fbo_id_);
   GLSetViewPort(area);
   RenderTexture(texture_target, texture_id);
-  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+  gl_renderer_->UnbindFramebuffer();
 
   // Need to flush the GL commands before we return the tnumbnail texture to
   // the decoder.
   glFlush();
   ++frame_count_;
 }
 
 void RenderingHelper::QueueVideoFrame(
     size_t window_id,
     scoped_refptr<VideoFrameTexture> video_frame) {
@@ skipping 29 matching lines @@
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 void RenderingHelper::DeleteTexture(uint32 texture_id) {
   CHECK_EQ(base::MessageLoop::current(), message_loop_);
   glDeleteTextures(1, &texture_id);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 scoped_refptr<gfx::GLContext> RenderingHelper::GetGLContext() {
-  return gl_context_;
+  return gl_renderer_->gl_context();
 }
 
 void* RenderingHelper::GetGLContextHandle() {
-  return gl_context_->GetHandle();
+  return gl_renderer_->gl_context()->GetHandle();
 }
 
 void* RenderingHelper::GetGLDisplay() {
-  return gl_surface_->GetDisplay();
+  return gl_renderer_->gl_surface()->GetDisplay();
 }
 
 void RenderingHelper::Clear() {
   videos_.clear();
   message_loop_ = NULL;
-  gl_context_ = NULL;
-  gl_surface_ = NULL;
 
   render_as_thumbnails_ = false;
   frame_count_ = 0;
   thumbnails_fbo_id_ = 0;
   thumbnails_texture_id_ = 0;
+
+  gl_renderer_.reset();
 }
 
 void RenderingHelper::GetThumbnailsAsRGB(std::vector<unsigned char>* rgb,
                                          bool* alpha_solid,
                                          base::WaitableEvent* done) {
   CHECK(render_as_thumbnails_);
 
   const size_t num_pixels = thumbnails_fbo_size_.GetArea();
   std::vector<unsigned char> rgba;
   rgba.resize(num_pixels * 4);
-  glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
+  gl_renderer_->BindFramebuffer(thumbnails_fbo_id_);
   glPixelStorei(GL_PACK_ALIGNMENT, 1);
   // We can only count on GL_RGBA/GL_UNSIGNED_BYTE support.
   glReadPixels(0,
                0,
                thumbnails_fbo_size_.width(),
                thumbnails_fbo_size_.height(),
                GL_RGBA,
                GL_UNSIGNED_BYTE,
                &rgba[0]);
-  glBindFramebufferEXT(GL_FRAMEBUFFER, 0);
+  gl_renderer_->UnbindFramebuffer();
   rgb->resize(num_pixels * 3);
   // Drop the alpha channel, but check as we go that it is all 0xff.
   bool solid = true;
   unsigned char* rgb_ptr = &((*rgb)[0]);
   unsigned char* rgba_ptr = &rgba[0];
   for (size_t i = 0; i < num_pixels; ++i) {
     *rgb_ptr++ = *rgba_ptr++;
     *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_);
 
   // Update the VSync params.
   //
   // It's safe to use Unretained here since |rendering_thread_| will be stopped
   // in VideoDecodeAcceleratorTest.TearDown(), while the |rendering_helper_| is
   // a member of that class. (See video_decode_accelerator_unittest.cc.)
-  gfx::VSyncProvider* vsync_provider = gl_surface_->GetVSyncProvider();
+  gfx::VSyncProvider* vsync_provider =
+      gl_renderer_->gl_surface()->GetVSyncProvider();
   if (vsync_provider) {
     vsync_provider->GetVSyncParameters(base::Bind(
         &RenderingHelper::UpdateVSyncParameters, base::Unretained(this),
         static_cast<base::WaitableEvent*>(NULL)));
   }
 
-  glUniform1i(glGetUniformLocation(program_, "tex_flip"), 1);
+  glUniform1i(glGetUniformLocation(program_, "tex_flip"),
+              gl_renderer_->IsFlipped() ? 0 : 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;
   bool need_swap_buffer = false;
   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);
@@ skipping 11 matching lines @@
       if (video.pending_frames.size() > 1 || video.is_flushing) {
         frames_to_be_returned.push_back(video.pending_frames.front());
         video.pending_frames.pop();
       } else {
         ++video.frames_to_drop;
       }
     }
   }
 
   if (need_swap_buffer)
-    gl_surface_->SwapBuffers();
+    gl_renderer_->SwapBuffers();
 
   ScheduleNextRenderContent();
 }
 
 // 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,
@@ skipping 87 matching lines @@
   // When the rendering falls behind, drops frames.
   while (scheduled_render_time_ < target) {
     scheduled_render_time_ += frame_duration_;
     DropOneFrameForAllVideos();
   }
 
   message_loop_->PostDelayedTask(
       FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace content