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

content/common/gpu/media/vaapi_wrapper.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/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 96 matching lines @@
     required_attribs.insert(
         required_attribs.end(),
         kEncodeVAConfigAttribs,
         kEncodeVAConfigAttribs + arraysize(kEncodeVAConfigAttribs));
   }
   return required_attribs;
 }
 
 VASurface::VASurface(VASurfaceID va_surface_id,
                      const gfx::Size& size,
+                     unsigned int format,
                      const ReleaseCB& release_cb)
-    : va_surface_id_(va_surface_id), size_(size), release_cb_(release_cb) {
+    : va_surface_id_(va_surface_id),
+      size_(size),
+      format_(format),
+      release_cb_(release_cb) {
   DCHECK(!release_cb_.is_null());
 }
 
 VASurface::~VASurface() {
   release_cb_.Run(va_surface_id_);
 }
 
 VaapiWrapper::VaapiWrapper()
-    : va_display_(NULL),
+    : va_surface_format_(0),
+      va_display_(NULL),
       va_config_id_(VA_INVALID_ID),
       va_context_id_(VA_INVALID_ID),
       va_vpp_config_id_(VA_INVALID_ID),
       va_vpp_context_id_(VA_INVALID_ID),
       va_vpp_buffer_id_(VA_INVALID_ID) {
   va_lock_ = va_display_state_.Get().va_lock();
 }
 
 VaapiWrapper::~VaapiWrapper() {
   DestroyPendingBuffers();
@@ skipping 366 matching lines @@
 
 bool VaapiWrapper::CreateSurfaces(unsigned int va_format,
                                   const gfx::Size& size,
                                   size_t num_surfaces,
                                   std::vector<VASurfaceID>* va_surfaces) {
   base::AutoLock auto_lock(*va_lock_);
   DVLOG(2) << "Creating " << num_surfaces << " surfaces";
 
   DCHECK(va_surfaces->empty());
   DCHECK(va_surface_ids_.empty());
+  DCHECK_EQ(va_surface_format_, 0u);
   va_surface_ids_.resize(num_surfaces);
 
   // Allocate surfaces in driver.
   VAStatus va_res =
       vaCreateSurfaces(va_display_, va_format, size.width(), size.height(),
                        &va_surface_ids_[0], va_surface_ids_.size(), NULL, 0);
 
   VA_LOG_ON_ERROR(va_res, "vaCreateSurfaces failed");
   if (va_res != VA_STATUS_SUCCESS) {
     va_surface_ids_.clear();
     return false;
   }
 
   // And create a context associated with them.
   va_res = vaCreateContext(va_display_, va_config_id_,
                            size.width(), size.height(), VA_PROGRESSIVE,
                            &va_surface_ids_[0], va_surface_ids_.size(),
                            &va_context_id_);
 
   VA_LOG_ON_ERROR(va_res, "vaCreateContext failed");
   if (va_res != VA_STATUS_SUCCESS) {
     DestroySurfaces();
     return false;
   }
 
   *va_surfaces = va_surface_ids_;
+  va_surface_format_ = va_format;
   return true;
 }
 
 void VaapiWrapper::DestroySurfaces() {
   base::AutoLock auto_lock(*va_lock_);
   DVLOG(2) << "Destroying " << va_surface_ids_.size()  << " surfaces";
 
   if (va_context_id_ != VA_INVALID_ID) {
     VAStatus va_res = vaDestroyContext(va_display_, va_context_id_);
     VA_LOG_ON_ERROR(va_res, "vaDestroyContext failed");
   }
 
   if (!va_surface_ids_.empty()) {
     VAStatus va_res = vaDestroySurfaces(va_display_, &va_surface_ids_[0],
                                         va_surface_ids_.size());
     VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces failed");
   }
 
   va_surface_ids_.clear();
   va_context_id_ = VA_INVALID_ID;
+  va_surface_format_ = 0;
 }
 
 scoped_refptr<VASurface> VaapiWrapper::CreateUnownedSurface(
     unsigned int va_format,
     const gfx::Size& size,
     const std::vector<VASurfaceAttrib>& va_attribs) {
   base::AutoLock auto_lock(*va_lock_);
 
   std::vector<VASurfaceAttrib> attribs(va_attribs);
   VASurfaceID va_surface_id;
   VAStatus va_res =
       vaCreateSurfaces(va_display_, va_format, size.width(), size.height(),
                        &va_surface_id, 1, &attribs[0], attribs.size());
 
   scoped_refptr<VASurface> va_surface;
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create unowned VASurface",
                        va_surface);
 
   // This is safe to use Unretained() here, because the VDA takes care
   // of the destruction order. All the surfaces will be destroyed
   // before VaapiWrapper.
   va_surface = new VASurface(
-      va_surface_id, size,
+      va_surface_id, size, va_format,
       base::Bind(&VaapiWrapper::DestroyUnownedSurface, base::Unretained(this)));
 
   return va_surface;
 }
 
 void VaapiWrapper::DestroyUnownedSurface(VASurfaceID va_surface_id) {
   base::AutoLock auto_lock(*va_lock_);
 
   VAStatus va_res = vaDestroySurfaces(va_display_, &va_surface_id, 1);
   VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces on surface failed");
@@ skipping 558 matching lines @@
   drm_fd_.reset(HANDLE_EINTR(dup(fd)));
 }
 #endif  // USE_OZONE
 
 bool VaapiWrapper::VADisplayState::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
       (major_version_ == major && minor_version_ < minor);
 }
 
 }  // namespace content