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"

[Pawel Osciak, 2014/11/03 01:36:51]

Should this be under GL_VARIANT_EGL below?

-#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;

[Pawel Osciak, 2014/11/03 01:36:51]

I realized, could we use a fullscreen window?

[Owen Lin, 2014/11/03 06:59:05]

The performance on a non-fullscreen window is not optimized on some platforms
(arm based). This is why we use a fullscreen window.

+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{};

[Pawel Osciak, 2014/11/03 01:36:51]

Some methods have spaces after override and before {}, some don't.

[llandwerlin-old, 2014/11/04 16:16:28]

Acknowledged.

+
+  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),
       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()
     : is_flushing(false), frames_to_drop(0) {
 }
 
 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 56 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();

[Owen Lin, 2014/11/03 06:59:05]

How could you make sure the widget_ is available now ? 

[llandwerlin-old, 2014/11/04 16:16:28]

When the DriWindow is created and initialized, it immediately calls
OnAcceleratedWidgetAvailable() on the window delegate with the widget id.
If that's not the case, it means we failed to create a window and the test will
fail on the :

CHECK(window_ != gfx::kNullAcceleratedWidget);

+
+  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_.get(), gfx::PreferIntegratedGpu);

[Pawel Osciak, 2014/11/03 01:36:51]

ozone_demo also calls gl_surface_->Resize() here, do we need to do the same?

[llandwerlin-old, 2014/11/04 16:16:28]

I haven't identified an ozone api to return the size of the screen. But surfaces
seems to be created at the size of the screen so I'll use that instead :

https://code.google.com/p/chromium/codesearch#chromium/src/ui/ozone/platform/...

   gl_context_->MakeCurrent(gl_surface_.get());

[Pawel Osciak, 2014/11/03 01:36:50]

Should we verify this succeeded?

[llandwerlin-old, 2014/11/04 16:16:28]

Acknowledged.

 
   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);
 
-  if (frame_duration_ != base::TimeDelta())
-    WarmUpRendering(params.warm_up_iterations);
+  WarmUpRendering(params.warm_up_iterations);

[Pawel Osciak, 2014/11/03 01:36:51]

Why is that if not needed anymore?

[llandwerlin-old, 2014/11/03 09:30:10]

That seems to be a workaround for drivers that are slow to render the first few
frames, I suppose Owen would know more.

[Owen Lin, 2014/11/04 08:47:49]

I think you still need the if. We use frame_duration == 0 as a hint that the
rendering is disabled.

 
-  // 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(
-      &RenderingHelper::UpdateVSyncParameters, base::Unretained(this), done));
+  // If this test doesn't do any rendering, just signal we're ready.
+  if (params.suppress_rendering)

[Owen Lin, 2014/11/03 06:59:06]

We use "frame_duration == base::TimeDelta()" to detect if the rendering is
disabled.

if (frame_duration_ != base::TimeDelta()) {
  WarmUpRendering(...);
  gl_surface_->GetVSyncProvider()->GetVSyncParameters(...);
} else {
  done->Signal();
}

I think the code depends on the availability of the VSync info. So, why do you
have the case: "if we couldn't figure out the vsync_interval ...... ".

[llandwerlin-old, 2014/11/03 09:30:10]

To get a vsync_internal value, we need to render at least once. If there is no
rendering, we wait forever a vsync even that will never happen.
My understanding is that if you have a gpu process running, then you can get an
answer without ever rendering anything because there has been frames rendered
and displayed before, whereas the Ozone setup for this test doesn't use the
gpu-process and we have no history to compute the vsync_interval.

[Owen Lin, 2014/11/04 08:47:49]

But it is not what I saw. In vda_unittest, there is no gpu process, but I always
got the vsync info sucessfully without rendering anything. Theoretically, VSync
should be triggered even without rendering.

If this is the case for ozone, maybe we need the WarmUpRendering to provide us
the vsync information. In that case, please make sure WarmUpRendering is called
with warm_up_iterations >= 1 and add comments to explain the details.

+    done->Signal();
+  else

[Pawel Osciak, 2014/11/03 01:36:51]

You could just drop else.

[llandwerlin-old, 2014/11/03 09:30:10]

Ok, I would need to remove the done pointer too.

+    // 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(
+        &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);
   glBindTexture(GL_TEXTURE_2D, texture_id);
@@ skipping 131 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 53 matching lines @@
 
   // 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);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

[Owen Lin, 2014/11/03 06:59:06]

Why we need to clear the color buffer, (I think video frames are opaque)? This
will significantly affect the performance. 

[llandwerlin-old, 2014/11/03 09:30:10]

This was to workaround a bug in Mesa :

http://cgit.freedesktop.org/mesa/mesa/commit/src?id=d175e7c16b4de1a4231b806da...

But I think you fixed this issue with need_swap_buffer.

[llandwerlin-old, 2014/11/04 16:16:28]

I need to leave it for the non thumbnail case, otherwise you can see previous
tests' last frame.

+    glClear(GL_COLOR_BUFFER_BIT);
     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);
     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 83 matching lines @@
       video.pending_frames.pop();
     } else {
       ++video.frames_to_drop;
     }
   }
 }
 
 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_);
+  // If we couldn't figure out the vsync interval, just render as
+  // quick as possible.

[Pawel Osciak, 2014/11/03 01:36:51]

What if we are falling behind even if we are rendering as fast as possible? I
think it would be better to make target = now and still go through the frame
dropping mechanism.

[Owen Lin, 2014/11/03 06:59:05]

Are you saying there won't be vsync info on ozone platform? We use vsync to
prevent queuing swap buffers too fast. All the swap buffer blocked and affect
decoding on VAAPI platforms.

BTW, if there is no vsync info available, you should render at the
|scheduled_render_time_| to keep the specified FPS.

[llandwerlin-old, 2014/11/03 09:30:10]

As explained in another comment, we won't get a vsync_interval on Ozone until we
render+swapBuffer a first frame. So this is just for a case for the first frame.

[Owen Lin, 2014/11/04 08:47:49]

We will wait forever on getting the vsync info in Initialize(). So, it would be
a deadlock if there is no vsync provided. We don't need to handle the case here.

+  if (vsync_interval_ > base::TimeDelta()) {
+    // 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_;
+    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();
+    // 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);
+  } else {
+    message_loop_->PostTask(FROM_HERE, render_task_.callback());
   }
-
-  message_loop_->PostDelayedTask(
-      FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace content