VaapiVideoAccelerator: make Vaapi accelerator work with ozone

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/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
-#include "ui/gl/gl_surface_egl.h"
-#include "ui/gl/gl_surface_glx.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
+#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(OS_WIN) && defined(ARCH_CPU_X86_FAMILY)
-#define GL_VARIANT_GLX 1
-#else
-#define GL_VARIANT_EGL 1
+#if defined(USE_OZONE)
+#include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/ui_thread_gpu.h"
+#include "ui/platform_window/platform_window.h"
+#include "ui/platform_window/platform_window_delegate.h"
 #endif
 
 // Helper for Shader creation.
 static void CreateShader(GLuint program,
                          GLenum type,
                          const char* source,
                          int size) {
   GLuint shader = glCreateShader(type);
   glShaderSource(shader, 1, &source, &size);
   glCompileShader(shader);
   int result = GL_FALSE;
   glGetShaderiv(shader, GL_COMPILE_STATUS, &result);
   if (!result) {
     char log[4096];
     glGetShaderInfoLog(shader, arraysize(log), NULL, log);
     LOG(FATAL) << log;
   }
   glAttachShader(program, shader);
   glDeleteShader(shader);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 namespace content {
 
+#if defined(USE_OZONE)
+
+// Ozone Gbm Surfaces are always created to the size of the screen, so
+// it doesn't matter what size we are passing here, we will update it
+// once the surface is created.
+const int kTestWindowWidth = 1;
+const int kTestWindowHeight = 1;

[Owen Lin, 2014/11/06 05:45:01]

How about const gfx::Rect kTestWindowSize(1, 1); ?
Why not just use an empty Rect ?

[llandwerlin-old, 2014/11/10 09:34:16]

Added an empty Rect in the StubOzoneDelegate constructor.

+
+class RenderingHelper::StubOzoneDelegate : public ui::PlatformWindowDelegate {
+ public:
+  StubOzoneDelegate() : widget_(gfx::kNullAcceleratedWidget) {
+    platform_window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
+        this, gfx::Rect(kTestWindowWidth, kTestWindowHeight));
+  }
+  virtual ~StubOzoneDelegate() {}
+
+  virtual void OnBoundsChanged(const gfx::Rect& new_bounds) override {}
+
+  virtual void OnDamageRect(const gfx::Rect& damaged_region) override {}
+
+  virtual void DispatchEvent(ui::Event* event) override {}
+
+  virtual void OnCloseRequest() override {}
+  virtual void OnClosed() override {}
+
+  virtual void OnWindowStateChanged(
+      ui::PlatformWindowState new_state) override {};
+
+  virtual void OnLostCapture() override {};
+
+  virtual void OnAcceleratedWidgetAvailable(
+      gfx::AcceleratedWidget widget) override {
+    widget_ = widget;
+  };
+
+  virtual void OnActivationChanged(bool active) override {};
+
+  gfx::AcceleratedWidget GetAcceleratedWidget() const { return widget_; }
+
+  gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
+
+ private:
+  scoped_ptr<ui::PlatformWindow> platform_window_;
+  gfx::AcceleratedWidget widget_;
+};
+
+#endif  // defined(USE_OZONE)
+
 RenderingHelperParams::RenderingHelperParams()
     : rendering_fps(0), warm_up_iterations(0), render_as_thumbnails(false) {
 }
 
 RenderingHelperParams::~RenderingHelperParams() {}
 
 VideoFrameTexture::VideoFrameTexture(uint32 texture_target,
                                      uint32 texture_id,
                                      const base::Closure& no_longer_needed_cb)
     : texture_target_(texture_target),
@@ skipping 15 matching lines @@
 
 // static
 bool RenderingHelper::InitializeOneOff() {
   base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 #if GL_VARIANT_GLX
   cmd_line->AppendSwitchASCII(switches::kUseGL,
                               gfx::kGLImplementationDesktopName);
 #else
   cmd_line->AppendSwitchASCII(switches::kUseGL, gfx::kGLImplementationEGLName);
 #endif
+
+#if defined(USE_OZONE)
+  static ui::UiThreadGpu ui_thread_gpu;
+  ui::OzonePlatform::InitializeForUI();
+  return gfx::GLSurface::InitializeOneOff() && ui_thread_gpu.Initialize();
+#else
   return gfx::GLSurface::InitializeOneOff();
+#endif
 }
 
 RenderingHelper::RenderingHelper() {
   window_ = gfx::kNullAcceleratedWidget;
   Clear();
 }
 
 RenderingHelper::~RenderingHelper() {
   CHECK_EQ(videos_.size(), 0U) << "Must call UnInitialize before dtor.";
   Clear();
@@ skipping 21 matching lines @@
 
 #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,
                            screen_size_.width(),

[Owen Lin, 2014/11/06 05:45:01]

Remove line 189 (screen_size_ = ...) and just use GetSystemMetrics(MS_CXSCREEN)
here. 

You will update screen_size_ later.

Same as the case for USE_X11.

[llandwerlin-old, 2014/11/10 09:34:16]

Done.

                            screen_size_.height(),
                            NULL,
                            NULL,
                            NULL,
                            NULL);
 #elif defined(USE_X11)
   Display* display = gfx::GetXDisplay();
   Screen* screen = DefaultScreenOfDisplay(display);
   screen_size_ = gfx::Size(XWidthOfScreen(screen), XHeightOfScreen(screen));
 
@@ skipping 14 matching lines @@
                           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)
+  platform_window_delegate_.reset(new RenderingHelper::StubOzoneDelegate());
+  window_ = platform_window_delegate_->GetAcceleratedWidget();
 #else
 #error unknown platform
 #endif
   CHECK(window_ != gfx::kNullAcceleratedWidget);
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
+  screen_size_ = gl_surface_->GetSize();
+
   gl_context_ = gfx::GLContext::CreateGLContext(
       NULL, gl_surface_.get(), gfx::PreferIntegratedGpu);
-  gl_context_->MakeCurrent(gl_surface_.get());
+  CHECK(gl_context_->MakeCurrent(gl_surface_.get()));
 
   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 105 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);
 
+  int warm_up_iterations = 0;
   if (frame_duration_ != base::TimeDelta())
-    WarmUpRendering(params.warm_up_iterations);
+    warm_up_iterations = params.warm_up_iterations;
+#if defined(USE_OZONE)
+  // On Ozone the VSyncProvider can't provide a vsync_internal until
+  // we render at least a frame, so we warm up with at least one
+  // frame.
+  warm_up_iterations = std::max(1, warm_up_iterations);
+#endif
+  if (warm_up_iterations > 0)
+    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.)
   gl_surface_->GetVSyncProvider()->GetVSyncParameters(base::Bind(

[Owen Lin, 2014/11/06 05:45:01]

I like your idea that don't call this function if rendering is disabled. 

When rendering is disabled, this class is only used to provide textures for the
video decoder. All the rendering related functions won't be called.

       &RenderingHelper::UpdateVSyncParameters, base::Unretained(this), done));
 }
 
 // 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);
@@ skipping 132 matching lines @@
   glBindTexture(texture_target, 0);
   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);
 }
 
-void* RenderingHelper::GetGLContext() {
+scoped_refptr<gfx::GLContext> RenderingHelper::GetGLContext() {
+  return gl_context_;
+}
+
+void* RenderingHelper::GetGLContextHandle() {
   return gl_context_->GetHandle();
 }
 
 void* RenderingHelper::GetGLDisplay() {
   return 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;
 
 #if defined(OS_WIN)
   if (window_)
     DestroyWindow(window_);
-#else
+#elif defined(USE_X11)
   // Destroy resources acquired in Initialize, in reverse-acquisition order.
   if (window_) {
     CHECK(XUnmapWindow(gfx::GetXDisplay(), window_));
     CHECK(XDestroyWindow(gfx::GetXDisplay(), window_));
   }
 #endif
   window_ = gfx::kNullAcceleratedWidget;
 }
 
 void RenderingHelper::GetThumbnailsAsRGB(std::vector<unsigned char>* rgb,
@@ skipping 56 matching lines @@
   // 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);
     RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
     need_swap_buffer = true;
   } else {
+    GLSetViewPort(gfx::Rect(screen_size_));
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);

[marcheu, 2014/11/04 19:25:38]

I'm not sure why this is needed now?

[llandwerlin-old, 2014/11/05 10:17:35]

Yes, otherwise I can see the last frame of the previous test every other frame.

     for (RenderedVideo& video : videos_) {
       if (video.pending_frames.empty())
         continue;
       need_swap_buffer = true;
       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 || video.is_flushing) {
         frames_to_be_returned.push_back(video.pending_frames.front());
@@ skipping 67 matching lines @@
 void RenderingHelper::UpdateVSyncParameters(base::WaitableEvent* done,
                                             const base::TimeTicks timebase,
                                             const base::TimeDelta interval) {
   vsync_timebase_ = timebase;
   vsync_interval_ = interval;
 
   if (done)
     done->Signal();
 }
 
-void RenderingHelper::DropOneFrameForAllVideos() {
+uint32 RenderingHelper::DropOneFrameForAllVideos() {
+  uint32 frames_dropped = 0;
   for (RenderedVideo& video : videos_) {
     if (video.pending_frames.empty())
       continue;
 
     if (video.pending_frames.size() > 1 || video.is_flushing) {
+      frames_dropped++;
       video.pending_frames.pop();
     } else {
       ++video.frames_to_drop;
     }
   }
+  return frames_dropped;
 }
 
 void RenderingHelper::ScheduleNextRenderContent() {
   scheduled_render_time_ += frame_duration_;
 
   // Schedules the next RenderContent() at latest VSYNC before the
   // |scheduled_render_time_|.
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks target =
       std::max(now + vsync_interval_, scheduled_render_time_);
 
   int64 intervals = (target - vsync_timebase_) / vsync_interval_;
   target = vsync_timebase_ + intervals * vsync_interval_;
 
   // When the rendering falls behind, drops frames.
-  while (scheduled_render_time_ < target) {
-    scheduled_render_time_ += frame_duration_;
-    DropOneFrameForAllVideos();
+  if (frame_duration_ > base::TimeDelta()) {
+    while (scheduled_render_time_ < target) {
+      scheduled_render_time_ += frame_duration_;
+      DropOneFrameForAllVideos();
+    }
+  } else {
+    // If we don't have a frame_duration_, just drop as many frames as

[Owen Lin, 2014/11/06 05:45:01]

This is not needed. If frame_duration is null, we won't call RenderContent()
(and related functions) at all. 

[llandwerlin-old, 2014/11/10 09:34:16]

Done.

+    // possible.
+    while (DropOneFrameForAllVideos() > 0)
+      ;
   }
-
   message_loop_->PostDelayedTask(
       FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace content