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 "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"
-#endif
-
-#if !defined(OS_WIN) && defined(ARCH_CPU_X86_FAMILY)
+#include "ui/gl/gl_surface_glx.h"
 #define GL_VARIANT_GLX 1
 #else
 #define GL_VARIANT_EGL 1
 #endif
 
+#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)
+
+const int kTestWindowWidth = 800;
+const int kTestWindowHeight = 600;
+
+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
+
+
 RenderingHelperParams::RenderingHelperParams() {}
 
 RenderingHelperParams::~RenderingHelperParams() {}
 
 VideoFrameTexture::VideoFrameTexture(uint32 texture_target,
                                      uint32 texture_id,
                                      const base::Closure& no_longer_needed_cb)
     : 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), 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,
                               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 53 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();
+
+  screen_size_ = platform_window_delegate_->GetSize();
 #else
 #error unknown platform
 #endif
   CHECK(window_ != gfx::kNullAcceleratedWidget);
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(window_);
   gl_context_ = gfx::GLContext::CreateGLContext(
       NULL, gl_surface_, gfx::PreferIntegratedGpu);
   gl_context_->MakeCurrent(gl_surface_);
 
@@ skipping 246 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 31 matching lines @@
 
   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);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
     RenderTexture(GL_TEXTURE_2D, thumbnails_texture_id_);
   } else {
+    GLSetViewPort(gfx::Rect(screen_size_));
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
     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 || video->is_flushing) {
         frames_to_be_returned.push_back(video->pending_frames.front());
@@ skipping 55 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