Add support for more advanced color correction

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>
 #include <xf86drmMode.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/posix/safe_strerror.h"
 #include "base/task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_legacy.h"
 
 #if defined(USE_DRM_ATOMIC)
 #include "ui/ozone/platform/drm/gpu/hardware_display_plane_manager_atomic.h"
@@ skipping 79 matching lines @@
 }
 
 bool CanQueryForResources(int fd) {
   drm_mode_card_res resources;
   memset(&resources, 0, sizeof(resources));
   // If there is no error getting DRM resources then assume this is a
   // modesetting device.
   return !drmIoctl(fd, DRM_IOCTL_MODE_GETRESOURCES, &resources);
 }
 
+// TODO(robert.bradford): Replace with libdrm structures after libdrm roll.
+// https://crbug.com/586475
+struct DrmColorLut {
+  uint16_t red;
+  uint16_t green;
+  uint16_t blue;
+  uint16_t reserved;
+};
+
+struct DrmColorCtm {
+  int64_t ctm_coeff[9];
+};
+
+typedef scoped_ptr<DrmColorLut, base::FreeDeleter> ScopedDrmColorLut;

[dnicoara, 2016/02/24 14:24:34]

nit: Add a "Ptr" suffix to match the other ScopedDrm*Ptr typedefs.

[robert.bradford, 2016/02/24 15:22:05]

Done.

+typedef scoped_ptr<DrmColorCtm, base::FreeDeleter> ScopedDrmColorCtm;
+
+ScopedDrmColorLut CreateLutBlob(const std::vector<GammaRampRGBEntry>& source) {
+  TRACE_EVENT0("drm", "CreateLutBlob");
+
+  ScopedDrmColorLut res(new DrmColorLut[source.size()]);
+  DrmColorLut* lut = res.get();
+  for (size_t i = 0; i < source.size(); ++i) {
+    lut[i].red = source[i].r;
+    lut[i].green = source[i].g;
+    lut[i].blue = source[i].b;
+  }
+  return res;
+}
+
+ScopedDrmColorCtm CreateCTMBlob(const std::vector<float>& correction_matrix) {
+  ScopedDrmColorCtm ctm(new DrmColorCtm);

[dnicoara, 2016/02/24 14:24:34]

You're allocating with new() but freeing with free(). Since you're not passing
ownership to DRM is there any reason to use malloc/free?

The one thing that I could think of is to be closer to the DRM allocation type,
especially since these will be done via a DRM API (once that's available). Is
this the case?

[robert.bradford, 2016/02/24 15:22:05]

You're right, malloc & free is best.
These are just raw structures, you could allocate them however you like as the
ioctl() will ultimately copy from userspace to kernel space. libdrm won't ever
provide any kind of allocation mechanism for these.

+
+  for (int i = 0; i < 9; ++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;
+  int res;
+  res = drmModeCreatePropertyBlob(fd, data, length, &blob_id);
+  if (res != 0) {
+    LOG(ERROR) << "Error creating property blob: " << base::safe_strerror(res)
+               << " for property " << property_name;
+    return 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;
+    drmModeDestroyPropertyBlob(fd, blob_id);
+    return false;
+  }
+  drmModeDestroyPropertyBlob(fd, blob_id);
+  return true;
+}
+
+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.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) {
+      result[i].r = lut_in[base_index].r +
+                    (lut_in[base_index + 1].r - lut_in[base_index].r) *
+                        remaining / desired_size;
+      result[i].g = lut_in[base_index].g +
+                    (lut_in[base_index + 1].g - lut_in[base_index].g) *
+                        remaining / desired_size;
+      result[i].b = lut_in[base_index].b +
+                    (lut_in[base_index + 1].b - lut_in[base_index].b) *
+                        remaining / desired_size;
+    } else {
+      result[i] = lut_in[lut_in.size() - 1];
+    }
+  }
+
+  return result;
+}
+
 }  // namespace
 
 class DrmDevice::PageFlipManager {
  public:
   PageFlipManager() : next_id_(0) {}
   ~PageFlipManager() {}
 
   void OnPageFlip(uint32_t frame,
                   uint32_t seconds,
                   uint32_t useconds,
@@ skipping 409 matching lines @@
     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,
+    const std::vector<GammaRampRGBEntry>& degamma_lut,
+    const std::vector<GammaRampRGBEntry>& gamma_lut,
+    const std::vector<float>& correction_matrix) {
+  ScopedDrmObjectPropertyPtr crtc_props(drmModeObjectGetProperties(
+      file_.GetPlatformFile(), crtc_id, DRM_MODE_OBJECT_CRTC));
+  uint64_t degamma_lut_size = 0;
+  uint64_t gamma_lut_size = 0;
+
+  for (uint32_t i = 0; i < crtc_props->count_props; ++i) {
+    ScopedDrmPropertyPtr property(
+        drmModeGetProperty(file_.GetPlatformFile(), crtc_props->props[i]));
+    if (property && !strcmp(property->name, "DEGAMMA_LUT_SIZE")) {
+      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 (degamma_lut_size == 0 || gamma_lut_size == 0) {
+    LOG(WARNING) << "No available (de)gamma tables.";
+    return false;
+  }
+
+  ScopedDrmColorLut degamma_blob_data =
+      CreateLutBlob(ResampleLut(degamma_lut, degamma_lut_size));
+  ScopedDrmColorLut gamma_blob_data =
+      CreateLutBlob(ResampleLut(gamma_lut, gamma_lut_size));
+  ScopedDrmColorCtm ctm_blob_data = CreateCTMBlob(correction_matrix);
+
+  for (uint32_t i = 0; i < crtc_props->count_props; ++i) {
+    ScopedDrmPropertyPtr property(
+        drmModeGetProperty(file_.GetPlatformFile(), crtc_props->props[i]));
+    if (!property)
+      continue;
+
+    if (!strcmp(property->name, "DEGAMMA_LUT")) {
+      if (!SetBlobProperty(
+              file_.GetPlatformFile(), crtc_id, DRM_MODE_OBJECT_CRTC,
+              crtc_props->props[i], property->name,
+              reinterpret_cast<unsigned char*>(degamma_blob_data.get()),
+              sizeof(DrmColorLut) * degamma_lut_size))
+        return false;
+    }
+    if (!strcmp(property->name, "GAMMA_LUT")) {
+      if (!SetBlobProperty(
+              file_.GetPlatformFile(), crtc_id, DRM_MODE_OBJECT_CRTC,
+              crtc_props->props[i], property->name,
+              reinterpret_cast<unsigned char*>(gamma_blob_data.get()),
+              sizeof(DrmColorLut) * gamma_lut_size))
+        return false;
+    }
+    if (!strcmp(property->name, "CTM")) {
+      if (!SetBlobProperty(
+              file_.GetPlatformFile(), crtc_id, DRM_MODE_OBJECT_CRTC,
+              crtc_props->props[i], property->name,
+              reinterpret_cast<unsigned char*>(ctm_blob_data.get()),
+              sizeof(DrmColorCtm)))
+        return false;
+    }
+  }
+
+  return true;
+}
+
 }  // namespace ui