Revert of ozone: Pick CRTCs with majority of planes.

ui/ozone/platform/drm/common/drm_util.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/common/drm_util.h"
 
 #include <drm_fourcc.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <xf86drm.h>
 #include <xf86drmMode.h>
-#include <algorithm>
 #include <utility>
 
-#include "base/containers/small_map.h"
 #include "ui/display/util/edid_parser.h"
 
 #if !defined(DRM_MODE_CONNECTOR_DSI)
 #define DRM_MODE_CONNECTOR_DSI 16
 #endif
 
 #if !defined(DRM_CAP_CURSOR_WIDTH)
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
@@ skipping 24 matching lines @@
 bool IsCrtcInUse(uint32_t crtc,
                  const ScopedVector<HardwareDisplayControllerInfo>& displays) {
   for (size_t i = 0; i < displays.size(); ++i) {
     if (crtc == displays[i]->crtc()->crtc_id)
       return true;
   }
 
   return false;
 }
 
-// Return a CRTC compatible with |connector| and not already used in |displays|.
-// If there are multiple compatible CRTCs, the one that supports the majority of
-// planes will be returned.
 uint32_t GetCrtc(int fd,
                  drmModeConnector* connector,
                  drmModeRes* resources,
                  const ScopedVector<HardwareDisplayControllerInfo>& displays) {
-  ScopedDrmPlaneResPtr plane_resources(drmModeGetPlaneResources(fd));
-  std::vector<ScopedDrmPlanePtr> planes;
-  for (uint32_t i = 0; i < plane_resources->count_planes; i++)
-    planes.emplace_back(drmModeGetPlane(fd, plane_resources->planes[i]));
-
-  DCHECK_GE(32, resources->count_crtcs);
-  uint32_t best_crtc = 0;
-  int best_crtc_planes = 0;
+  // If the connector already has an encoder try to re-use.
+  if (connector->encoder_id) {
+    ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoder_id));
+    if (encoder && encoder->crtc_id && !IsCrtcInUse(encoder->crtc_id, displays))
+      return encoder->crtc_id;
+  }
 
   // Try to find an encoder for the connector.
   for (int i = 0; i < connector->count_encoders; ++i) {
     ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, connector->encoders[i]));
     if (!encoder)
       continue;
 
     for (int j = 0; j < resources->count_crtcs; ++j) {
       // Check if the encoder is compatible with this CRTC
-      int crtc_bit = 1 << j;
-      if (!(encoder->possible_crtcs & crtc_bit) ||
+      if (!(encoder->possible_crtcs & (1 << j)) ||
           IsCrtcInUse(resources->crtcs[j], displays))
         continue;
 
-      int supported_planes = std::count_if(
-          planes.begin(), planes.end(), [crtc_bit](const ScopedDrmPlanePtr& p) {
-            return p->possible_crtcs & crtc_bit;
-          });
-
-      if (supported_planes > best_crtc_planes) {
-        best_crtc_planes = supported_planes;
-        best_crtc = resources->crtcs[j];
-      }
+      return resources->crtcs[j];
     }
   }
 
-  return best_crtc;
+  return 0;
 }
 
 // Computes the refresh rate for the specific mode. If we have enough
 // information use the mode timings to compute a more exact value otherwise
 // fallback to using the mode's vertical refresh rate (the kernel computes this
 // the same way, however there is a loss in precision since |vrefresh| is sent
 // as an integer).
 float GetRefreshRate(const drmModeModeInfo& mode) {
   if (!mode.htotal || !mode.vtotal)
     return mode.vrefresh;
@@ skipping 122 matching lines @@
 
 HardwareDisplayControllerInfo::~HardwareDisplayControllerInfo() {
 }
 
 ScopedVector<HardwareDisplayControllerInfo> GetAvailableDisplayControllerInfos(
     int fd) {
   ScopedDrmResourcesPtr resources(drmModeGetResources(fd));
   DCHECK(resources) << "Failed to get DRM resources";
   ScopedVector<HardwareDisplayControllerInfo> displays;
 
-  std::vector<ScopedDrmConnectorPtr> available_connectors;
-  std::vector<ScopedDrmConnectorPtr::element_type*> connectors;
   for (int i = 0; i < resources->count_connectors; ++i) {
     ScopedDrmConnectorPtr connector(
         drmModeGetConnector(fd, resources->connectors[i]));
-    connectors.push_back(connector.get());
 
-    if (connector && connector->connection == DRM_MODE_CONNECTED &&
-        connector->count_modes != 0)
-      available_connectors.push_back(std::move(connector));
-  }
+    if (!connector || connector->connection != DRM_MODE_CONNECTED ||
+        connector->count_modes == 0)
+      continue;
 
-  base::SmallMap<std::map<ScopedDrmConnectorPtr::element_type*, int>>
-      connector_crtcs;
-  for (auto& c : available_connectors) {
-    uint32_t possible_crtcs = 0;
-    for (int i = 0; i < c->count_encoders; ++i) {
-      ScopedDrmEncoderPtr encoder(drmModeGetEncoder(fd, c->encoders[i]));
-      if (!encoder)
-        continue;
-      possible_crtcs |= encoder->possible_crtcs;
-    }
-    connector_crtcs[c.get()] = possible_crtcs;
-  }
-  // Make sure to start assigning a crtc to the connector that supports the
-  // fewest crtcs first.
-  std::stable_sort(available_connectors.begin(), available_connectors.end(),
-                   [&connector_crtcs](const ScopedDrmConnectorPtr& c1,
-                                      const ScopedDrmConnectorPtr& c2) {
-                     // When c1 supports a proper subset of the crtcs of c2, we
-                     // should process c1 first (return true).
-                     int c1_crtcs = connector_crtcs[c1.get()];
-                     int c2_crtcs = connector_crtcs[c2.get()];
-                     return (c1_crtcs & c2_crtcs) == c1_crtcs &&
-                            c1_crtcs != c2_crtcs;
-                   });
-
-  for (auto& c : available_connectors) {
-    uint32_t crtc_id = GetCrtc(fd, c.get(), resources.get(), displays);
+    uint32_t crtc_id = GetCrtc(fd, connector.get(), resources.get(), displays);
     if (!crtc_id)
       continue;
 
     ScopedDrmCrtcPtr crtc(drmModeGetCrtc(fd, crtc_id));
-    size_t index = std::find(connectors.begin(), connectors.end(), c.get()) -
-                   connectors.begin();
-    DCHECK_LT(index, connectors.size());
-    displays.push_back(new HardwareDisplayControllerInfo(
-        std::move(c), std::move(crtc), index));
+    displays.push_back(new HardwareDisplayControllerInfo(std::move(connector),
+                                                         std::move(crtc), i));
   }
 
   return displays;
 }
 
 bool SameMode(const drmModeModeInfo& lhs, const drmModeModeInfo& rhs) {
   return lhs.clock == rhs.clock && lhs.hdisplay == rhs.hdisplay &&
          lhs.vdisplay == rhs.vdisplay && lhs.vrefresh == rhs.vrefresh &&
          lhs.hsync_start == rhs.hsync_start && lhs.hsync_end == rhs.hsync_end &&
          lhs.htotal == rhs.htotal && lhs.hskew == rhs.hskew &&
@@ skipping 141 matching lines @@
     case gfx::BufferFormat::BGR_565:
       return DRM_FORMAT_RGB565;
     case gfx::BufferFormat::UYVY_422:
       return DRM_FORMAT_UYVY;
     default:
       NOTREACHED();
       return 0;
   }
 }
 }  // namespace ui