VaapiVideoAccelerator: make Vaapi accelerator work with ozone

content/common/gpu/media/vaapi_picture_provider_drm.cc

+// Copyright (c) 2014 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/vaapi_picture_provider_drm.h"
+#include "content/common/gpu/media/vaapi_wrapper.h"
+#include "third_party/libva/va/drm/va_drm.h"
+#include "third_party/libva/va/va_drmcommon.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_image.h"
+#include "ui/gl/gl_image_egl.h"
+#include "ui/gl/scoped_binders.h"
+#include "ui/ozone/public/native_pixmap.h"
+#include "ui/ozone/public/ozone_platform.h"
+#include "ui/ozone/public/surface_factory_ozone.h"
+
+namespace content {
+
+class DrmPicture : public VaapiPictureProvider::Picture {
+ public:
+  DrmPicture(scoped_refptr<VaapiWrapper> vaapi_wrapper,
+             const base::Callback<bool(void)> make_context_current,
+             int32 picture_buffer_id,
+             uint32 texture_id,
+             const gfx::Size& size)
+      : Picture(picture_buffer_id, texture_id, size),
+        vaapi_wrapper_(vaapi_wrapper),
+        make_context_current_(make_context_current) {}
+
+  virtual ~DrmPicture();
+
+  bool Initialize() override;
+
+  virtual bool DownloadFromSurface(VASurfaceID va_surface_id,
+                                   const gfx::Size& surface_size) override;
+
+ private:
+  scoped_refptr<VaapiWrapper> vaapi_wrapper_;
+  base::Callback<bool(void)> make_context_current_;
+  scoped_refptr<VASurface> va_surface_;
+  scoped_refptr<ui::NativePixmap> pixmap_;
+  scoped_refptr<gfx::GLImageEGL> gl_image_;
+
+  DISALLOW_COPY_AND_ASSIGN(DrmPicture);
+};
+
+DrmPicture::~DrmPicture() {
+  if (gl_image_.get() && make_context_current_.Run()) {
+    // ReleaseTexImage on a GLImageEGL does nothing, to deassociate
+    // the renderer's texture from the image, just set the storage
+    // of that texture to NULL
+    gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id());
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 GL_RGBA,
+                 size().width(),
+                 size().height(),
+                 0,
+                 GL_RGBA,
+                 GL_UNSIGNED_BYTE,
+                 NULL);
+
+    gl_image_->Destroy(true);
+
+    DCHECK_EQ(glGetError(), GL_NO_ERROR);
+  }
+}
+
+bool DrmPicture::Initialize() {
+  VASurfaceAttrib va_attribs[2];
+  VASurfaceAttribExternalBuffers va_attrib_extbuf;
+
+  ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
+  ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
+
+  pixmap_ =
+      factory->CreateNativePixmap(size(), ui::SurfaceFactoryOzone::RGBA_8888);
+  if (!pixmap_.get())
+    return false;
+
+  int dmabuf_fd = pixmap_->GetDmaBufFd();
+  if (dmabuf_fd < 0)
+    return false;
+
+  va_attrib_extbuf.pixel_format = VA_FOURCC_BGRX;
+  va_attrib_extbuf.width = size().width();
+  va_attrib_extbuf.height = size().height();
+  va_attrib_extbuf.data_size = size().height() * pixmap_->GetDmaBufPitch();
+  va_attrib_extbuf.num_planes = 1;
+  va_attrib_extbuf.pitches[0] = pixmap_->GetDmaBufPitch();
+  va_attrib_extbuf.offsets[0] = 0;
+  va_attrib_extbuf.buffers = reinterpret_cast<unsigned long*>(&dmabuf_fd);
+  va_attrib_extbuf.num_buffers = 1;
+  va_attrib_extbuf.flags = 0;
+  va_attrib_extbuf.private_data = NULL;
+
+  va_attribs[0].type = VASurfaceAttribMemoryType;
+  va_attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
+  va_attribs[0].value.type = VAGenericValueTypeInteger;
+  va_attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
+
+  va_attribs[1].type = VASurfaceAttribExternalBufferDescriptor;
+  va_attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
+  va_attribs[1].value.type = VAGenericValueTypePointer;
+  va_attribs[1].value.value.p = &va_attrib_extbuf;
+
+  va_surface_ = vaapi_wrapper_->CreateUnownedSurface(
+      VA_RT_FORMAT_RGB32, size(), va_attribs, arraysize(va_attribs));
+  if (!va_surface_.get())
+    return false;
+
+  if (!make_context_current_.Run())
+    return false;
+
+  gl_image_ = new gfx::GLImageEGL(size());
+  EGLint attrs[] = {EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE};
+  if (!gl_image_->Initialize(
+          EGL_NATIVE_PIXMAP_KHR, pixmap_->GetEGLClientBuffer(), attrs))
+    return false;
+
+  return true;
+}
+
+bool DrmPicture::DownloadFromSurface(VASurfaceID va_surface_id,
+                                     const gfx::Size& surface_size) {
+  if (!vaapi_wrapper_->BlitSurface(
+          va_surface_id, surface_size, va_surface_->id(), va_surface_->size()))
+    return false;
+
+  if (!make_context_current_.Run())
+    return false;
+
+  gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, texture_id());
+  return gl_image_->BindTexImage(GL_TEXTURE_2D);
+}
+
+DrmVaapiPictureProvider::DrmVaapiPictureProvider(
+    scoped_refptr<VaapiWrapper> vaapi_wrapper,
+    const base::Callback<bool(void)> make_context_current)
+    : make_context_current_(make_context_current),
+      vaapi_wrapper_(vaapi_wrapper) {
+}
+
+DrmVaapiPictureProvider::~DrmVaapiPictureProvider() {
+}
+
+linked_ptr<VaapiPictureProvider::Picture>
+DrmVaapiPictureProvider::AllocatePicture(int32 picture_buffer_id,
+                                         uint32 texture_id,
+                                         const gfx::Size& size) {
+  return linked_ptr<VaapiPictureProvider::Picture>(
+      new DrmPicture(vaapi_wrapper_,
+                     make_context_current_,
+                     picture_buffer_id,
+                     texture_id,
+                     size));
+}
+
+bool DrmVaapiPictureProvider::Initialize() {
+  return true;
+}
+
+}  // namespace