Reland: ash: reset color management when new screens are hotplugged

ui/ozone/platform/drm/gpu/drm_device.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_device.h"
 
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <unistd.h>
 #include <xf86drm.h>
@@ skipping 167 matching lines @@
   ret = drmIoctl(fd, DRM_IOCTL_MODE_DESTROYPROPBLOB, &destroy);
   return ret < 0 ? -errno : ret;
 }
 
 using ScopedDrmColorLutPtr = std::unique_ptr<DrmColorLut, base::FreeDeleter>;
 using ScopedDrmColorCtmPtr = std::unique_ptr<DrmColorCtm, base::FreeDeleter>;
 
 ScopedDrmColorLutPtr CreateLutBlob(
     const std::vector<GammaRampRGBEntry>& source) {
   TRACE_EVENT0("drm", "CreateLutBlob");
+  if (source.empty())
+    return nullptr;
+
   ScopedDrmColorLutPtr lut(
       static_cast<DrmColorLut*>(malloc(sizeof(DrmColorLut) * source.size())));
   DrmColorLut* p = lut.get();
   for (size_t i = 0; i < source.size(); ++i) {
     p[i].red = source[i].r;
     p[i].green = source[i].g;
     p[i].blue = source[i].b;
   }
   return lut;
 }
 
 ScopedDrmColorCtmPtr CreateCTMBlob(
     const std::vector<float>& correction_matrix) {
+  if (correction_matrix.empty())
+    return nullptr;
+
   ScopedDrmColorCtmPtr ctm(
       static_cast<DrmColorCtm*>(malloc(sizeof(DrmColorCtm))));
   for (size_t i = 0; i < arraysize(ctm->ctm_coeff); ++i) {
     if (correction_matrix[i] < 0) {
       ctm->ctm_coeff[i] = static_cast<uint64_t>(
           -correction_matrix[i] * (static_cast<uint64_t>(1) << 32));
       ctm->ctm_coeff[i] |= static_cast<uint64_t>(1) << 63;
     } else {
       ctm->ctm_coeff[i] = static_cast<uint64_t>(
           correction_matrix[i] * (static_cast<uint64_t>(1) << 32));
     }
   }
   return ctm;
 }
 
 bool SetBlobProperty(int fd,
                      uint32_t object_id,
                      uint32_t object_type,
                      uint32_t prop_id,
                      const char* property_name,
                      unsigned char* data,
                      size_t length) {
-  uint32_t blob_id;
+  uint32_t blob_id = 0;
   int res;
-  res = CreatePropertyBlob(fd, data, length, &blob_id);
-  if (res != 0) {
-    LOG(ERROR) << "Error creating property blob: " << base::safe_strerror(res)
-               << " for property " << property_name;
-    return false;
+
+  if (data) {
+    res = CreatePropertyBlob(fd, data, length, &blob_id);
+    if (res != 0) {
+      LOG(ERROR) << "Error creating property blob: " << base::safe_strerror(res)
+                 << " for property " << property_name;
+      return false;
+    }
   }
+
+  bool success = false;
   res = drmModeObjectSetProperty(fd, object_id, object_type, prop_id, blob_id);
   if (res != 0) {
     LOG(ERROR) << "Error updating property: " << base::safe_strerror(res)
                << " for property " << property_name;
+  } else {
+    success = true;
+  }
+  if (blob_id != 0)
     DestroyPropertyBlob(fd, blob_id);
-    return false;
-  }
-  DestroyPropertyBlob(fd, blob_id);
-  return true;
+  return success;
 }
 
 std::vector<GammaRampRGBEntry> ResampleLut(
     const std::vector<GammaRampRGBEntry>& lut_in,
     size_t desired_size) {
   TRACE_EVENT1("drm", "ResampleLut", "desired_size", desired_size);
+  if (lut_in.empty())
+    return std::vector<GammaRampRGBEntry>();
+
   if (lut_in.size() == desired_size)
     return lut_in;
 
   std::vector<GammaRampRGBEntry> result;
   result.resize(desired_size);
 
   for (size_t i = 0; i < desired_size; ++i) {
     size_t base_index = lut_in.size() * i / desired_size;
     size_t remaining = lut_in.size() * i % desired_size;
     if (base_index < lut_in.size() - 1) {
@@ skipping 411 matching lines @@
 
 bool DrmDevice::DropMaster() {
   TRACE_EVENT1("drm", "DrmDevice::DropMaster", "path", device_path_.value());
   DCHECK(file_.IsValid());
   return (drmDropMaster(file_.GetPlatformFile()) == 0);
 }
 
 bool DrmDevice::SetGammaRamp(uint32_t crtc_id,
                              const std::vector<GammaRampRGBEntry>& lut) {
   ScopedDrmCrtcPtr crtc = GetCrtc(crtc_id);
+  size_t gamma_size = static_cast<size_t>(crtc->gamma_size);
+
+  if (gamma_size == 0 && lut.empty())
+    return true;
+
+  if (gamma_size == 0) {
+    LOG(ERROR) << "Gamma table not supported";
+    return false;
+  }
 
   // TODO(robert.bradford) resample the incoming ramp to match what the kernel
   // expects.
-  if (static_cast<size_t>(crtc->gamma_size) != lut.size()) {
+  if (!lut.empty() && gamma_size != lut.size()) {
     LOG(ERROR) << "Gamma table size mismatch: supplied " << lut.size()
-               << " expected " << crtc->gamma_size;
+               << " expected " << gamma_size;
+    return false;
   }
 
   std::vector<uint16_t> r, g, b;
-  r.reserve(lut.size());
-  g.reserve(lut.size());
-  b.reserve(lut.size());
+  r.reserve(gamma_size);
+  g.reserve(gamma_size);
+  b.reserve(gamma_size);
 
-  for (size_t i = 0; i < lut.size(); ++i) {
-    r.push_back(lut[i].r);
-    g.push_back(lut[i].g);
-    b.push_back(lut[i].b);
+  if (lut.empty()) {
+    // Create a linear gamma ramp table to deactivate the feature.
+    for (size_t i = 0; i < gamma_size; ++i) {
+      uint16_t value = (i * ((1 << 16) - 1)) / (gamma_size - 1);
+      r.push_back(value);
+      g.push_back(value);
+      b.push_back(value);
+    }
+  } else {
+    for (size_t i = 0; i < gamma_size; ++i) {
+      r.push_back(lut[i].r);
+      g.push_back(lut[i].g);
+      b.push_back(lut[i].b);
+    }
   }
 
   DCHECK(file_.IsValid());
   TRACE_EVENT0("drm", "DrmDevice::SetGamma");
   return (drmModeCrtcSetGamma(file_.GetPlatformFile(), crtc_id, r.size(), &r[0],
                               &g[0], &b[0]) == 0);
 }
 
 bool DrmDevice::SetColorCorrection(
     uint32_t crtc_id,
@@ skipping 12 matching lines @@
       degamma_lut_size = crtc_props->prop_values[i];
     }
     if (property && !strcmp(property->name, "GAMMA_LUT_SIZE")) {
       gamma_lut_size = crtc_props->prop_values[i];
     }
 
     if (degamma_lut_size && gamma_lut_size)
       break;
   }
 
+  // If we can't find the degamma & gamma lut size, it means the properties
+  // aren't available. We should then use the legacy gamma ramp ioctl.
   if (degamma_lut_size == 0 || gamma_lut_size == 0) {
-    LOG(WARNING) << "No available (de)gamma tables.";
-    return false;
+    return SetGammaRamp(crtc_id, gamma_lut);
   }
 
   ScopedDrmColorLutPtr degamma_blob_data =
       CreateLutBlob(ResampleLut(degamma_lut, degamma_lut_size));
   ScopedDrmColorLutPtr gamma_blob_data =
       CreateLutBlob(ResampleLut(gamma_lut, gamma_lut_size));
   ScopedDrmColorCtmPtr ctm_blob_data = CreateCTMBlob(correction_matrix);
 
   for (uint32_t i = 0; i < crtc_props->count_props; ++i) {
     ScopedDrmPropertyPtr property(
@@ skipping 24 matching lines @@
               reinterpret_cast<unsigned char*>(ctm_blob_data.get()),
               sizeof(DrmColorCtm)))
         return false;
     }
   }
 
   return true;
 }
 
 }  // namespace ui