[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 {
 
+// Format for storing the video decoded pictures

[Pawel Osciak, 2015/10/30 02:38:34]

Nit: please use dots at the end of sentences.
Also, I don't think this is actually for "storing", we decode into YUV420, but
for usage with GLImages we have to convert to this format.

[william.xie1, 2015/10/30 08:52:17]

Done.

+const gfx::BufferFormat kPictureStorageFormat = gfx::BufferFormat::BGRX_8888;
+// Format for renderring the video pictures

[Pawel Osciak, 2015/10/30 02:38:34]

This is also not precise enough. We don't use this format when not using
overlays.

[william.xie1, 2015/10/30 08:52:17]

Done.

+const gfx::BufferFormat kPictureRenderFormat = gfx::BufferFormat::UYVY_422;
+
+uint32_t BufferFormatToVAFourCC(gfx::BufferFormat fmt) {
+  switch (fmt) {
+    case gfx::BufferFormat::BGRX_8888:
+      return VA_FOURCC_BGRX;
+    case gfx::BufferFormat::UYVY_422:
+      return VA_FOURCC_UYVY;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
+uint32_t VAFourCCToVARTFormat(uint32_t fourcc) {
+  switch (fourcc) {
+    case VA_FOURCC_UYVY:
+      return VA_RT_FORMAT_YUV422;
+    case VA_FOURCC_BGRX:
+      return VA_RT_FORMAT_RGB32;
+    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 =
+      BufferFormatToVAFourCC(pixmap->GetBufferFormat());
   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);
+      VAFourCCToVARTFormat(va_attrib_extbuf.pixel_format), 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(), kPictureStorageFormat);
   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 38 matching lines @@
     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, kPictureRenderFormat);

[kalyank, 2015/10/29 17:49:40]

Sorry, if I wasn't clear earlier, hardcoding the format here is wrong. In
fullscreen case, the overall benefits for collapsing planes to one will outweigh
using UYVY on platforms where primary cannot support this. I still think that
there should be some pre-validation (by the caller ?) as which format is
optimal, if it is supported by the hardware and use it in here. 

[Pawel Osciak, 2015/10/30 02:38:34]

+1 to this, this is basically what I was hoping for when asking for a way to
query upper layers for optimal format, both for overlays and non-overlay
scenarios.

How could we query for the optimal format?

[william.xie1, 2015/10/30 08:52:17]

Done.

[william.xie1, 2015/10/30 08:52:17]

Done.

[william.xie1, 2015/10/30 08:52:17]

We get the optimal format from ozone platform, currently we use the well known
best format UYVY for overlay, but it is possible to change the render format
dynamically based on the scenarios in the future.

[seanvk, 2015/10/30 15:20:43]

Keep in mind too that SoC x86 platforms may use other formats in the future for
overlay.  So I tend to agree that hardcoding this format is not a good idea.

Sean

     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;
@@ skipping 16 matching lines @@
 
 scoped_refptr<gfx::GLImage> VaapiDrmPicture::GetImageToBind() {
   return gl_image_;
 }
 
 bool VaapiDrmPicture::AllowOverlay() const {
   return true;
 }
 
 }  // namespace