Optimize plane usage when primary is obscured by Overlay

ui/ozone/platform/drm/gpu/hardware_display_plane_manager.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/hardware_display_plane_manager.h"
 
+#include <drm_fourcc.h>
+
 #include <set>
 
 #include "base/logging.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 #include "ui/ozone/platform/drm/gpu/scanout_buffer.h"
 
 namespace ui {
 namespace {
 
@@ skipping 154 matching lines @@
   if (!plane->IsSupportedFormat(overlay.buffer->GetFramebufferPixelFormat()))
     return false;
 
   // TODO(kalyank): We should check for z-order and any needed transformation
   // support. Driver doesn't expose any property to check for z-order, can we
   // rely on the sorting we do based on plane ids ?
 
   return true;
 }
 
+void HardwareDisplayPlaneManager::ResetCurrentPlaneList(
+    HardwareDisplayPlaneList* plane_list) const {
+  for (auto* hardware_plane : plane_list->plane_list) {
+    hardware_plane->set_in_use(false);
+    hardware_plane->set_owning_crtc(0);
+  }
+
+  plane_list->plane_list.clear();
+  plane_list->legacy_page_flips.clear();
+#if defined(USE_DRM_ATOMIC)
+  plane_list->atomic_property_set.reset(drmModeAtomicAlloc());
+#endif
+}
+
 void HardwareDisplayPlaneManager::BeginFrame(
     HardwareDisplayPlaneList* plane_list) {
   for (auto* plane : plane_list->old_plane_list) {
     plane->set_in_use(false);
   }
 }
 
 bool HardwareDisplayPlaneManager::AssignOverlayPlanes(
     HardwareDisplayPlaneList* plane_list,
     const OverlayPlaneList& overlay_list,
     uint32_t crtc_id,
     CrtcController* crtc) {
   int crtc_index = LookupCrtcIndex(crtc_id);
   if (crtc_index < 0) {
     LOG(ERROR) << "Cannot find crtc " << crtc_id;
     return false;
   }
 
   size_t plane_idx = 0;
+  HardwareDisplayPlane* primary_plane = nullptr;
+  gfx::Rect primary_display_bounds;
+  gfx::Rect primary_src_rect;
+  uint32_t primary_format;
   for (const auto& plane : overlay_list) {
     HardwareDisplayPlane* hw_plane =
         FindNextUnusedPlane(&plane_idx, crtc_index, plane);
     if (!hw_plane) {
       LOG(ERROR) << "Failed to find a free plane for crtc " << crtc_id;
+      ResetCurrentPlaneList(plane_list);
       return false;
     }
 
     gfx::Rect fixed_point_rect;
+    uint32_t fourcc_format = plane.buffer->GetFramebufferPixelFormat();
     if (hw_plane->type() != HardwareDisplayPlane::kDummy) {
       const gfx::Size& size = plane.buffer->GetSize();
-      gfx::RectF crop_rect = gfx::RectF(plane.crop_rect);
+      gfx::RectF crop_rect = plane.crop_rect;
       crop_rect.Scale(size.width(), size.height());
 
       // This returns a number in 16.16 fixed point, required by the DRM overlay
       // APIs.
       auto to_fixed_point =
           [](double v) -> uint32_t { return v * kFixedPointScaleValue; };
       fixed_point_rect = gfx::Rect(to_fixed_point(crop_rect.x()),
                                    to_fixed_point(crop_rect.y()),
                                    to_fixed_point(crop_rect.width()),
                                    to_fixed_point(crop_rect.height()));
     }
 
+    // If Overlay completely covers primary and isn't transparent, than use
+    // it as primary. This reduces the no of planes which need to be read in
+    // display controller side.
+    if (primary_plane) {
+      bool needs_blending = true;
+      if (fourcc_format == DRM_FORMAT_XRGB8888)
+        needs_blending = false;
+      // TODO(kalyank): Check if we can move this optimization to
+      // DrmOverlayCandidatesHost.
+      if (!needs_blending && primary_format == fourcc_format &&
+          primary_display_bounds == plane.display_bounds &&
+          fixed_point_rect == primary_src_rect) {
+        ResetCurrentPlaneList(plane_list);
+        hw_plane = primary_plane;
+      }
+    } else {
+      primary_plane = hw_plane;
+      primary_display_bounds = plane.display_bounds;
+      primary_src_rect = fixed_point_rect;
+      primary_format = fourcc_format;
+    }
+
+    if (!SetPlaneData(plane_list, hw_plane, plane, crtc_id, fixed_point_rect,
+                      crtc)) {
+      ResetCurrentPlaneList(plane_list);
+      return false;
+    }
+
     plane_list->plane_list.push_back(hw_plane);
     hw_plane->set_owning_crtc(crtc_id);
-    if (SetPlaneData(plane_list, hw_plane, plane, crtc_id, fixed_point_rect,
-                     crtc)) {
-      hw_plane->set_in_use(true);
-    } else {
-      return false;
-    }
+    hw_plane->set_in_use(true);
   }
   return true;
 }
 
 std::vector<uint32_t>
 HardwareDisplayPlaneManager::GetCompatibleHardwarePlaneIds(
     const OverlayPlane& plane,
     uint32_t crtc_id) const {
   int crtc_index = LookupCrtcIndex(crtc_id);
   if (crtc_index < 0) {
     LOG(ERROR) << "Cannot find crtc " << crtc_id;
     return std::vector<uint32_t>();
   }
 
   std::vector<uint32_t> plane_ids;
   for (auto* hardware_plane : planes_) {
     if (IsCompatible(hardware_plane, plane, crtc_index))
       plane_ids.push_back(hardware_plane->plane_id());
   }
 
   return plane_ids;
 }
 
 }  // namespace ui