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

ui/ozone/platform/drm/gpu/drm_window.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 "ui/ozone/platform/drm/gpu/drm_window.h"
 
-#include <drm_fourcc.h>
-
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkSurface.h"
-#include "ui/ozone/common/gpu/ozone_gpu_message_params.h"
-#include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/crtc_controller.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
-#include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
+#include "ui/ozone/platform/drm/gpu/drm_overlay_candidate.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 
 namespace ui {
 
 namespace {
 
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
@@ skipping 26 matching lines @@
       screen_manager_(screen_manager) {
 }
 
 DrmWindow::~DrmWindow() {
 }
 
 void DrmWindow::Initialize() {
   TRACE_EVENT1("drm", "DrmWindow::Initialize", "widget", widget_);
 
   device_manager_->UpdateDrmDevice(widget_, nullptr);
+  overlay_validator_ = make_scoped_ptr(new DrmOverlayCandidate(this));
 }
 
 void DrmWindow::Shutdown() {
   TRACE_EVENT1("drm", "DrmWindow::Shutdown", "widget", widget_);
   device_manager_->RemoveDrmDevice(widget_);
 }
 
 gfx::AcceleratedWidget DrmWindow::GetAcceleratedWidget() {
   return widget_;
 }
@@ skipping 57 matching lines @@
 
   if (!controller_) {
     callback.Run(gfx::SwapResult::SWAP_ACK);
     return;
   }
 
   controller_->SchedulePageFlip(last_submitted_planes_, callback);
 }
 
 std::vector<OverlayCheck_Params> DrmWindow::TestPageFlip(
-    const std::vector<OverlayCheck_Params>& overlays,
+    const std::vector<OverlayCheck_Params>& current_combination,
+    const std::vector<OverlayCheck_Params>& new_combination,
     ScanoutBufferGenerator* buffer_generator) {
-  std::vector<OverlayCheck_Params> params;
-  if (!controller_) {
-    // Nothing much we can do here.
-    return params;
-  }
-
-  OverlayPlaneList compatible_test_list;
-  scoped_refptr<DrmDevice> drm = controller_->GetAllocationDrmDevice();
-  for (const auto& overlay : overlays) {
-    OverlayCheck_Params overlay_params(overlay);
-    gfx::Size size =
-        (overlay.plane_z_order == 0) ? bounds().size() : overlay.buffer_size;
-    scoped_refptr<ScanoutBuffer> buffer;
-    // Check if we can re-use existing buffers.
-    for (const auto& plane : last_submitted_planes_) {
-      uint32_t format = GetFourCCFormatFromBufferFormat(overlay.format);
-      // We always use a storage type of XRGB, even if the pixel format
-      // is ARGB.
-      if (format == DRM_FORMAT_ARGB8888)
-        format = DRM_FORMAT_XRGB8888;
-
-      if (plane.buffer->GetFramebufferPixelFormat() == format &&
-          plane.z_order == overlay.plane_z_order &&
-          plane.display_bounds == overlay.display_rect &&
-          plane.buffer->GetSize() == size) {
-        buffer = plane.buffer;
-        break;
-      }
-    }
-
-    if (!buffer)
-      buffer = buffer_generator->Create(drm, overlay.format, size);
-
-    if (!buffer)
-      continue;
-
-    OverlayPlane plane(buffer, overlay.plane_z_order, overlay.transform,
-                       overlay.display_rect, overlay.crop_rect);
-
-    // Buffer for Primary plane should always be present for compatibility test.
-    if (!compatible_test_list.size() && overlay.plane_z_order != 0) {
-      compatible_test_list.push_back(
-          *OverlayPlane::GetPrimaryPlane(last_submitted_planes_));
-    }
-
-    compatible_test_list.push_back(plane);
-
-    if (controller_->TestPageFlip(compatible_test_list)) {
-      overlay_params.plane_ids =
-          controller_->GetCompatibleHardwarePlaneIds(plane);
-      params.push_back(overlay_params);
-    }
-
-    if (compatible_test_list.size() > 1)
-      compatible_test_list.pop_back();
-  }
-
-  return params;
+  return overlay_validator_->TestPageFlip(current_combination, new_combination,
+                                          last_submitted_planes_,
+                                          buffer_generator);
 }
 
 const OverlayPlane* DrmWindow::GetLastModesetBuffer() {
   return OverlayPlane::GetPrimaryPlane(last_submitted_planes_);
 }
 
 void DrmWindow::GetVSyncParameters(
     const gfx::VSyncProvider::UpdateVSyncCallback& callback) const {
   if (!controller_)
     return;
 
   // If we're in mirror mode the 2 CRTCs should have similar modes with the same
   // refresh rates.
   CrtcController* crtc = controller_->crtc_controllers()[0];
   // The value is invalid, so we can't update the parameters.
   if (controller_->GetTimeOfLastFlip() == 0 || crtc->mode().vrefresh == 0)
     return;
 
   // Stores the time of the last refresh.
   base::TimeTicks timebase =
       base::TimeTicks::FromInternalValue(controller_->GetTimeOfLastFlip());
   // Stores the refresh rate.
   base::TimeDelta interval =
       base::TimeDelta::FromSeconds(1) / crtc->mode().vrefresh;
 
   callback.Run(timebase, interval);
 }
 
+void DrmWindow::GetOverlayBufferConfigurations(
+    const OverlayParamCallback& callback) const {
+  callback.Run(overlay_validator_->GetOverlayConfigurations());
+}
+
 void DrmWindow::ResetCursor(bool bitmap_only) {
   if (!controller_)
     return;
 
   if (cursor_bitmaps_.size()) {
     // Draw new cursor into backbuffer.
     UpdateCursorImage(cursor_buffers_[cursor_frontbuffer_ ^ 1].get(),
                       cursor_bitmaps_[cursor_frame_]);
 
     // Reset location & buffer.
@@ skipping 55 matching lines @@
       if (!cursor_buffers_[i]->Initialize(
               info, false /* should_register_framebuffer */)) {
         LOG(FATAL) << "Failed to initialize cursor buffer";
         return;
       }
     }
   }
 }
 
 }  // namespace ui