Ozone: Dont hardcode format to YUV when using Overlay Composition.

ui/ozone/platform/drm/gpu/drm_overlay_validator.cc

 // Copyright 2015 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 "ui/ozone/platform/drm/gpu/drm_overlay_validator.h"
 
 #include <drm_fourcc.h>
 
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
@@ skipping 88 matching lines @@
 }
 
 }  // namespace
 
 DrmOverlayValidator::OverlayHints::OverlayHints(uint32_t format,
                                                 bool scale_buffer)
     : optimal_format(format), handle_scaling(scale_buffer) {}
 
 DrmOverlayValidator::OverlayHints::~OverlayHints() {}
 
+DrmOverlayValidator::OverlayBuffer::OverlayBuffer(
+    const scoped_refptr<ScanoutBuffer>& buffer,
+    bool is_in_use)
+    : buffer(buffer), is_in_use(is_in_use) {}
+
+DrmOverlayValidator::OverlayBuffer::~OverlayBuffer() {}
+
 DrmOverlayValidator::DrmOverlayValidator(DrmWindow* window)
     : window_(window), overlay_hints_cache_(kMaxCacheSize) {}
 
 DrmOverlayValidator::~DrmOverlayValidator() {}
 
 std::vector<OverlayCheck_Params> DrmOverlayValidator::TestPageFlip(
     const std::vector<OverlayCheck_Params>& params,
     const OverlayPlaneList& last_used_planes,
     ScanoutBufferGenerator* buffer_generator) {
   std::vector<OverlayCheck_Params> validated_params = params;
@@ skipping 42 matching lines @@
       overlay.is_overlay_candidate = false;
       test_list.pop_back();
     }
   }
 
   UpdateOverlayHintsCache(drm, test_list, buffer_generator, &reusable_buffers);
 
   return validated_params;
 }
 
-uint32_t DrmOverlayValidator::GetOptimalBufferFormat(
-    const OverlayPlane& plane,
-    const OverlayPlaneList& plane_list) const {
-  const auto& iter = overlay_hints_cache_.Peek(plane_list);
-  // We dont have any information in cache about this combination of layers,
-  // return standard BGRX format.
-  if (iter == overlay_hints_cache_.end())
-    return DRM_FORMAT_XRGB8888;
+OverlayPlaneList DrmOverlayValidator::ValidatePlanesForPageFlip(
+    const OverlayPlaneList& planes,
+    ScanoutBufferGenerator* buffer_generator) {
+  // Release any OverlayBuffer which is not in use and mark any in use as
+  // available.
+  if (!overlay_buffers_cache_.empty()) {
+    std::vector<OverlayBuffer> re_usable_buffers;
+    for (const auto& processing_buffer : overlay_buffers_cache_) {
+      if (processing_buffer.is_in_use) {
+        re_usable_buffers.push_back(processing_buffer);
+        re_usable_buffers.back().is_in_use = false;
+      }
+    }
 
-  DCHECK(plane_list.size() == iter->second.size());
+    overlay_buffers_cache_.swap(re_usable_buffers);
+  }
 
-  size_t size = plane_list.size();
-  uint32_t index;
-  for (index = 0; index < size; index++) {
-    const OverlayPlane& test_plane = plane_list.at(index);
-    if (test_plane.z_order == plane.z_order &&
-        test_plane.plane_transform == plane.plane_transform &&
-        test_plane.display_bounds == plane.display_bounds &&
-        test_plane.crop_rect == plane.crop_rect) {
-      break;
+  if (planes.size() <= 1)
+    return planes;
+
+  HardwareDisplayController* controller = window_->GetController();
+  if (!controller)
+    return planes;
+
+  OverlayPlaneList pending_planes = planes;
+  std::sort(pending_planes.begin(), pending_planes.end(),
+            [](const OverlayPlane& l, const OverlayPlane& r) {
+              return l.z_order < r.z_order;
+            });
+
+  const auto& iter = overlay_hints_cache_.Get(planes);
+  scoped_refptr<DrmDevice> drm = controller->GetAllocationDrmDevice();
+
+  size_t size = planes.size();
+  bool use_hints = iter != overlay_hints_cache_.end();
+
+  for (size_t i = 0; i < size; i++) {
+    auto& plane = pending_planes.at(i);
+    if (plane.processing_callback.is_null())
+      continue;
+
+    uint32_t original_format = plane.buffer->GetFramebufferPixelFormat();
+    uint32_t target_format = original_format;
+
+    const gfx::Size& original_size = plane.buffer->GetSize();
+    gfx::Size target_size =
+        GetScaledSize(original_size, plane.display_bounds, plane.crop_rect);
+
+    if (use_hints) {
+      DCHECK(size == iter->second.size());
+      const OverlayHints& hints = iter->second.at(i);
+      target_format = hints.optimal_format;
+
+      // We can handle plane scaling, avoid scaling buffer here.
+      if (!hints.handle_scaling)
+        target_size = original_size;
+    }
+
+    if (original_size != target_size || original_format != target_format) {
+      scoped_refptr<ScanoutBuffer> buffer = GetBufferForPageFlip(
+          drm, buffer_generator, target_size, target_format);
+      DCHECK(buffer);
+
+      if (plane.processing_callback.Run(plane.buffer, buffer))
+        plane.buffer = buffer;
     }
   }
 
-  return iter->second.at(index).optimal_format;
+  return pending_planes;
 }
 
 void DrmOverlayValidator::ClearCache() {
   overlay_hints_cache_.Clear();
+  overlay_buffers_cache_.clear();
 }
 
 void DrmOverlayValidator::UpdateOverlayHintsCache(
     const scoped_refptr<DrmDevice>& drm,
     const OverlayPlaneList& plane_list,
     ScanoutBufferGenerator* buffer_generator,
     std::vector<scoped_refptr<ScanoutBuffer>>* reusable_buffers) {
   const auto& iter = overlay_hints_cache_.Get(plane_list);
   if (iter != overlay_hints_cache_.end())
     return;
@@ skipping 38 matching lines @@
   }
 
   // Make sure we dont hold reference to buffer when caching this plane list.
   for (auto& plane : preferred_format_test_list)
     plane.buffer = nullptr;
 
   DCHECK(preferred_format_test_list.size() == overlay_hints.size());
   overlay_hints_cache_.Put(preferred_format_test_list, overlay_hints);
 }
 
+scoped_refptr<ScanoutBuffer> DrmOverlayValidator::GetBufferForPageFlip(
+    const scoped_refptr<DrmDevice>& drm_device,
+    ScanoutBufferGenerator* buffer_generator,
+    const gfx::Size& size,
+    uint32_t format) {
+  // Check if we can re-use existing buffers.
+  for (auto& reusable_buffer : overlay_buffers_cache_) {
+    if (reusable_buffer.buffer->GetFramebufferPixelFormat() == format &&
+        reusable_buffer.buffer->GetSize() == size &&
+        !reusable_buffer.is_in_use) {
+      reusable_buffer.is_in_use = true;
+      return reusable_buffer.buffer;
+    }
+  }
+
+  gfx::BufferFormat buffer_format = GetBufferFormatFromFourCCFormat(format);
+  scoped_refptr<ScanoutBuffer> scanout_buffer =
+      buffer_generator->Create(drm_device, buffer_format, size);
+
+  overlay_buffers_cache_.push_back(
+      OverlayBuffer(scanout_buffer, true /* is_in_use */));
+
+  return scanout_buffer;
+}
+
 }  // namespace ui