content/common/gpu/media/vaapi_drm_picture.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/file_descriptor_posix.h"
   6 #include "content/common/gpu/media/va_surface.h"
   7 #include "content/common/gpu/media/vaapi_drm_picture.h"
   8 #include "content/common/gpu/media/vaapi_wrapper.h"
   9 #include "third_party/libva/va/drm/va_drm.h"
  10 #include "third_party/libva/va/va.h"
  11 #include "third_party/libva/va/va_drmcommon.h"
  12 #include "ui/gfx/gpu_memory_buffer.h"
  13 #include "ui/gl/gl_bindings.h"
  14 #include "ui/gl/gl_image_ozone_native_pixmap.h"
  15 #include "ui/gl/scoped_binders.h"
  16 #include "ui/ozone/public/native_pixmap.h"
  17 #include "ui/ozone/public/ozone_platform.h"
  18 #include "ui/ozone/public/surface_factory_ozone.h"
  19
  20 namespace content {
  21
  22 VaapiDrmPicture::VaapiDrmPicture(
  23     VaapiWrapper* vaapi_wrapper,
  24     const base::Callback<bool(void)>& make_context_current,
  25     int32 picture_buffer_id,
  26     uint32 texture_id,
  27     const gfx::Size& size)
  28     : VaapiPicture(picture_buffer_id, texture_id, size),
  29       vaapi_wrapper_(vaapi_wrapper),
  30       make_context_current_(make_context_current),
  31       weak_this_factory_(this) {
  32 }
  33
  34 VaapiDrmPicture::~VaapiDrmPicture() {
  35   if (gl_image_ && make_context_current_.Run()) {
  36     gl_image_->ReleaseTexImage(GL_TEXTURE_EXTERNAL_OES);
  37     gl_image_->Destroy(true);
  38
  39     DCHECK_EQ(glGetError(), static_cast<GLenum>(GL_NO_ERROR));
  40   }
  41 }
  42
  43 scoped_refptr<VASurface> VaapiDrmPicture::CreateVASurfaceForPixmap(
  44     scoped_refptr<ui::NativePixmap> pixmap,
  45     gfx::Size pixmap_size) {
  46   // Get the dmabuf of the created buffer.
  47   int dmabuf_fd = pixmap->GetDmaBufFd();
  48   if (dmabuf_fd < 0) {
  49     LOG(ERROR) << "Failed to get dmabuf from an Ozone NativePixmap";
  50     return nullptr;
  51   }
  52   int dmabuf_pitch = pixmap->GetDmaBufPitch();
  53
  54   // Create a VASurface out of the created buffer using the dmabuf.
  55   VASurfaceAttribExternalBuffers va_attrib_extbuf;
  56   memset(&va_attrib_extbuf, 0, sizeof(va_attrib_extbuf));
  57   va_attrib_extbuf.pixel_format = VA_FOURCC_BGRX;
  58   va_attrib_extbuf.width = pixmap_size.width();
  59   va_attrib_extbuf.height = pixmap_size.height();
  60   va_attrib_extbuf.data_size = pixmap_size.height() * dmabuf_pitch;
  61   va_attrib_extbuf.num_planes = 1;
  62   va_attrib_extbuf.pitches[0] = dmabuf_pitch;
  63   va_attrib_extbuf.offsets[0] = 0;
  64   va_attrib_extbuf.buffers = reinterpret_cast<unsigned long*>(&dmabuf_fd);
  65   va_attrib_extbuf.num_buffers = 1;
  66   va_attrib_extbuf.flags = 0;
  67   va_attrib_extbuf.private_data = NULL;
  68
  69   std::vector<VASurfaceAttrib> va_attribs;
  70   va_attribs.resize(2);
  71
  72   va_attribs[0].type = VASurfaceAttribMemoryType;
  73   va_attribs[0].flags = VA_SURFACE_ATTRIB_SETTABLE;
  74   va_attribs[0].value.type = VAGenericValueTypeInteger;
  75   va_attribs[0].value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
  76
  77   va_attribs[1].type = VASurfaceAttribExternalBufferDescriptor;
  78   va_attribs[1].flags = VA_SURFACE_ATTRIB_SETTABLE;
  79   va_attribs[1].value.type = VAGenericValueTypePointer;
  80   va_attribs[1].value.value.p = &va_attrib_extbuf;
  81
  82   scoped_refptr<VASurface> va_surface = vaapi_wrapper_->CreateUnownedSurface(
  83       VA_RT_FORMAT_RGB32, pixmap_size, va_attribs);
  84   if (!va_surface) {
  85     LOG(ERROR) << "Failed to create VASurface for an Ozone NativePixmap";
  86     return nullptr;
  87   }
  88
  89   return va_surface;
  90 }
  91
  92 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CreateNativePixmap(
  93     gfx::Size size) {
  94   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
  95   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
  96
  97   // Create a buffer from Ozone.
  98   return factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size,
  99                                      gfx::BufferFormat::BGRX_8888,
 100                                      gfx::BufferUsage::SCANOUT);
 101 }
 102
 103 bool VaapiDrmPicture::Initialize() {
 104   // We want to create a VASurface and an EGLImage out of the same
 105   // memory buffer, so we can output decoded pictures to it using
 106   // VAAPI and also use it to paint with GL.
 107   pixmap_ = CreateNativePixmap(size());
 108   if (!pixmap_) {
 109     LOG(ERROR) << "Failed creating an Ozone NativePixmap";
 110     return false;
 111   }
 112
 113   va_surface_ = CreateVASurfaceForPixmap(pixmap_, size());
 114   if (!va_surface_) {
 115     LOG(ERROR) << "Failed creating VASurface for NativePixmap";
 116     return false;
 117   }
 118
 119   // Weak pointers can only bind to methods without return values,
 120   // hence we cannot bind ScalePixmap here. Instead we use a
 121   // static function to solve this problem.
 122   pixmap_->SetScalingCallback(base::Bind(&VaapiDrmPicture::CallScalePixmap,
 123                                          weak_this_factory_.GetWeakPtr()));
 124
 125   if (!make_context_current_.Run())
 126     return false;
 127
 128   gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_EXTERNAL_OES,
 129                                           texture_id());
 130   scoped_refptr<gfx::GLImageOzoneNativePixmap> image(
 131       new gfx::GLImageOzoneNativePixmap(size(), GL_BGRA_EXT));
 132   if (!image->Initialize(pixmap_.get(), gfx::BufferFormat::BGRX_8888)) {
 133     LOG(ERROR) << "Failed to create GLImage";
 134     return false;
 135   }
 136   gl_image_ = image;
 137   if (!gl_image_->BindTexImage(GL_TEXTURE_EXTERNAL_OES)) {
 138     LOG(ERROR) << "Failed to bind texture to GLImage";
 139     return false;
 140   }
 141
 142   return true;
 143 }
 144
 145 bool VaapiDrmPicture::DownloadFromSurface(
 146     const scoped_refptr<VASurface>& va_surface) {
 147   return vaapi_wrapper_->BlitSurface(va_surface->id(), va_surface->size(),
 148                                      va_surface_->id(), va_surface_->size());
 149 }
 150
 151 // static
 152 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CallScalePixmap(
 153     base::WeakPtr<VaapiDrmPicture> weak_ptr,
 154     gfx::Size new_size) {
 155   if (!weak_ptr.get()) {
 156     LOG(ERROR) << "Failed scaling NativePixmap as scaling "
 157                   "unit(VaapiDrmPicture) is deleted";
 158     return nullptr;
 159   }
 160   return weak_ptr->ScalePixmap(new_size);
 161 }
 162
 163 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::ScalePixmap(
 164     gfx::Size new_size) {
 165   if (!scaled_va_surface_.get() || scaled_va_surface_->size() != new_size) {
 166     scaled_pixmap_ = CreateNativePixmap(new_size);
 167     if (!scaled_pixmap_) {
 168       LOG(ERROR) << "Failed creating an Ozone NativePixmap for scaling";
 169       scaled_va_surface_ = nullptr;
 170       return nullptr;
 171     }
 172     scaled_va_surface_ = CreateVASurfaceForPixmap(scaled_pixmap_, new_size);
 173     if (!scaled_va_surface_) {
 174       LOG(ERROR) << "Failed creating VA Surface for pixmap";
 175       scaled_pixmap_ = nullptr;
 176       return nullptr;
 177     }
 178   }
 179
 180   DCHECK(scaled_pixmap_);
 181   bool vpp_result = vaapi_wrapper_->BlitSurface(
 182       va_surface_->id(), va_surface_->size(), scaled_va_surface_->id(),
 183       scaled_va_surface_->size());
 184   if (!vpp_result) {
 185     LOG(ERROR) << "Failed scaling NativePixmap";
 186     scaled_pixmap_ = nullptr;
 187     scaled_va_surface_ = nullptr;
 188     return nullptr;
 189   }
 190
 191   return scaled_pixmap_;
 192 }
 193
 194 scoped_refptr<gfx::GLImage> VaapiDrmPicture::GetImageToBind() {
 195   return gl_image_;
 196 }
 197
 198 bool VaapiDrmPicture::AllowOverlay() const {
 199   return true;
 200 }
 201
 202 }  // namespace