[Ozone] Enables overlay render format setting path and by default use UYVY

content/common/gpu/media/vaapi_drm_picture.cc

 // Copyright 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 "base/file_descriptor_posix.h"
 #include "content/common/gpu/media/va_surface.h"
 #include "content/common/gpu/media/vaapi_drm_picture.h"
 #include "content/common/gpu/media/vaapi_wrapper.h"
 #include "third_party/libva/va/drm/va_drm.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_drmcommon.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image_ozone_native_pixmap.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 {
 
+int GetVASurfaceFormatFromPixmapFormat(int fmt) {
+  switch (fmt) {
+    case GBM_FORMAT_XRGB8888:
+      return VA_FOURCC_BGRX;

[kalyank, 2015/10/21 19:48:41]

Hmm do we need this conversion ? GBM_FORMAT_* are FOURCC formats

[marcheu1, 2015/10/21 19:58:57]

Sadly, there are formats like GBM_BO_FORMAT_XRGB8888 which aren't fourcc ones.
Now granted they aren't used here, so maybe it doesn't matter. But if we just
pass through the same format, we should at least test those two.

[kalyank, 2015/10/21 20:20:00]

We shouldn't be using GBM_BO_FORMAT_XRGB8888 at all in chrome side.
We could have DCHECK in place during va surface creation to ensure that we don't
pass GBM_BO_* accidently in future ?

[william.xie1, 2015/10/22 07:35:41]

Suggested by Spang, here is gfx::BufferFormat to VA surface format conversion
now.

[william.xie1, 2015/10/22 07:35:41]

Acknowledged.

+    case GBM_FORMAT_UYVY:
+      return VA_FOURCC_UYVY;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 VaapiDrmPicture::VaapiDrmPicture(
     VaapiWrapper* vaapi_wrapper,
     const base::Callback<bool(void)>& make_context_current,
     int32 picture_buffer_id,
     uint32 texture_id,
     const gfx::Size& size)
     : VaapiPicture(picture_buffer_id, texture_id, size),
       vaapi_wrapper_(vaapi_wrapper),
       make_context_current_(make_context_current),
       weak_this_factory_(this) {
@@ skipping 15 matching lines @@
   int dmabuf_fd = pixmap->GetDmaBufFd();
   if (dmabuf_fd < 0) {
     LOG(ERROR) << "Failed to get dmabuf from an Ozone NativePixmap";
     return nullptr;
   }
   int dmabuf_pitch = pixmap->GetDmaBufPitch();
 
   // Create a VASurface out of the created buffer using the dmabuf.
   VASurfaceAttribExternalBuffers va_attrib_extbuf;
   memset(&va_attrib_extbuf, 0, sizeof(va_attrib_extbuf));
-  va_attrib_extbuf.pixel_format = VA_FOURCC_BGRX;
+  va_attrib_extbuf.pixel_format =
+      GetVASurfaceFormatFromPixmapFormat(pixmap->GetPixelFormat());
   va_attrib_extbuf.width = pixmap_size.width();
   va_attrib_extbuf.height = pixmap_size.height();
   va_attrib_extbuf.data_size = pixmap_size.height() * dmabuf_pitch;
   va_attrib_extbuf.num_planes = 1;
   va_attrib_extbuf.pitches[0] = dmabuf_pitch;
   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;
 
   std::vector<VASurfaceAttrib> va_attribs;
   va_attribs.resize(2);
 
   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;
 
   scoped_refptr<VASurface> va_surface = vaapi_wrapper_->CreateUnownedSurface(
-      VA_RT_FORMAT_RGB32, pixmap_size, va_attribs);
+      va_attrib_extbuf.pixel_format == VA_FOURCC_UYVY ? VA_RT_FORMAT_YUV422
+                                                      : VA_RT_FORMAT_RGB32,
+      pixmap_size, va_attribs);
   if (!va_surface) {
     LOG(ERROR) << "Failed to create VASurface for an Ozone NativePixmap";
     return nullptr;
   }
 
   return va_surface;
 }
 
 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CreateNativePixmap(
-    gfx::Size size) {
+    gfx::Size size,
+    gfx::BufferFormat format) {
   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
 
   // Create a buffer from Ozone.
-  return factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size,
-                                     gfx::BufferFormat::BGRX_8888,
+  return factory->CreateNativePixmap(gfx::kNullAcceleratedWidget, size, format,
                                      gfx::BufferUsage::SCANOUT);
 }
 
 bool VaapiDrmPicture::Initialize() {
   // We want to create a VASurface and an EGLImage out of the same
   // memory buffer, so we can output decoded pictures to it using
   // VAAPI and also use it to paint with GL.
-  pixmap_ = CreateNativePixmap(size());
+  pixmap_ = CreateNativePixmap(size(), gfx::BufferFormat::BGRX_8888);
   if (!pixmap_) {
     LOG(ERROR) << "Failed creating an Ozone NativePixmap";
     return false;
   }
 
   va_surface_ = CreateVASurfaceForPixmap(pixmap_, size());
   if (!va_surface_) {
     LOG(ERROR) << "Failed creating VASurface for NativePixmap";
     return false;
   }
@@ skipping 19 matching lines @@
   if (!gl_image_->BindTexImage(GL_TEXTURE_EXTERNAL_OES)) {
     LOG(ERROR) << "Failed to bind texture to GLImage";
     return false;
   }
 
   return true;
 }
 
 bool VaapiDrmPicture::DownloadFromSurface(
     const scoped_refptr<VASurface>& va_surface) {
-  return vaapi_wrapper_->BlitSurface(va_surface->id(), va_surface->size(),
-                                     va_surface_->id(), va_surface_->size());
+  return vaapi_wrapper_->BlitSurface(va_surface, va_surface_);
 }
 
 // static
 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::CallScalePixmap(
     base::WeakPtr<VaapiDrmPicture> weak_ptr,
     gfx::Size new_size) {
   if (!weak_ptr.get()) {
     LOG(ERROR) << "Failed scaling NativePixmap as scaling "
                   "unit(VaapiDrmPicture) is deleted";
     return nullptr;
   }
   return weak_ptr->ScalePixmap(new_size);
 }
 
 scoped_refptr<ui::NativePixmap> VaapiDrmPicture::ScalePixmap(
     gfx::Size new_size) {
   if (!scaled_va_surface_.get() || scaled_va_surface_->size() != new_size) {
-    scaled_pixmap_ = CreateNativePixmap(new_size);
+    scaled_pixmap_ = CreateNativePixmap(new_size, gfx::BufferFormat::UYVY_422);

[kalyank, 2015/10/21 19:48:41]

We use UYUY format when scaling is needed otherwise BGRX, why ?

[kalyank, 2015/10/21 21:32:23]

Using YUV formats has benefits when video buffer can be directly consumed by
display controller. Otherwise, I don't see any benefit of this as Compositor
will need to convert to RGB before rendering to back buffer. We should have
checks here to use this format only when Overlay support is enabled in Chrome. 

[seanvk, 2015/10/21 21:38:34]

Agree with @kalyank.  We should not be assuming hardware overlay is always
present.

[william.xie1, 2015/10/22 07:35:41]

Done.

[william.xie1, 2015/10/22 07:35:41]

Done.

     if (!scaled_pixmap_) {
       LOG(ERROR) << "Failed creating an Ozone NativePixmap for scaling";
       scaled_va_surface_ = nullptr;
       return nullptr;
     }
     scaled_va_surface_ = CreateVASurfaceForPixmap(scaled_pixmap_, new_size);
     if (!scaled_va_surface_) {
       LOG(ERROR) << "Failed creating VA Surface for pixmap";
       scaled_pixmap_ = nullptr;
       return nullptr;
     }
   }
 
   DCHECK(scaled_pixmap_);
-  bool vpp_result = vaapi_wrapper_->BlitSurface(
-      va_surface_->id(), va_surface_->size(), scaled_va_surface_->id(),
-      scaled_va_surface_->size());
+  bool vpp_result =
+      vaapi_wrapper_->BlitSurface(va_surface_, scaled_va_surface_);
   if (!vpp_result) {
     LOG(ERROR) << "Failed scaling NativePixmap";
     scaled_pixmap_ = nullptr;
     scaled_va_surface_ = nullptr;
     return nullptr;
   }
 
   return scaled_pixmap_;
 }
 
 scoped_refptr<gfx::GLImage> VaapiDrmPicture::GetImageToBind() {
   return gl_image_;
 }
 
 bool VaapiDrmPicture::AllowOverlay() const {
   return true;
 }
 
 }  // namespace