Add support for more advanced color correction

ash/display/display_color_manager_chromeos.cc

 // Copyright 2015 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 "ash/display/display_color_manager_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 11 matching lines @@
 #include "ui/display/types/display_snapshot.h"
 #include "ui/display/types/gamma_ramp_rgb_entry.h"
 #include "ui/display/types/native_display_delegate.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 
 namespace ash {
 
 namespace {
 
-bool ParseFile(const base::FilePath& path,
+base::FilePath PathForProductID(int64_t product_id) {
+  base::FilePath path;
+  CHECK(
+      PathService::Get(chromeos::DIR_DEVICE_COLOR_CALIBRATION_PROFILES, &path));
+  path = path.Append(base::StringPrintf("%08" PRIx64 ".icc", product_id));
+  return path;
+}
+
+bool ParseFile(bool has_color_correction_matrix,
+               int64_t product_id,
                DisplayColorManager::ColorCalibrationData* data) {
+  base::FilePath path = PathForProductID(product_id);
+  VLOG(1) << "Trying ICC file " << path.value()
+          << " with product id: " << product_id
+          << " has_color_correction_matrix: "
+          << (has_color_correction_matrix ? "true" : "false");
+
   if (!base::PathExists(path))  // No icc file for this display; not an error.
     return false;
+
   qcms_profile* display_profile = qcms_profile_from_path(path.value().c_str());
 
   if (!display_profile) {
     LOG(WARNING) << "Unable to load ICC file: " << path.value();
     return false;
   }
 
   size_t vcgt_channel_length =
       qcms_profile_get_vcgt_channel_length(display_profile);
-  if (!vcgt_channel_length) {
+
+  if (!has_color_correction_matrix && !vcgt_channel_length) {
     LOG(WARNING) << "No vcgt table in ICC file: " << path.value();
     qcms_profile_release(display_profile);
     return false;
   }
 
-  std::vector<uint16_t> vcgt_data;
-  vcgt_data.resize(vcgt_channel_length * 3);
-  if (!qcms_profile_get_vcgt_rgb_channels(display_profile, &vcgt_data[0])) {
-    LOG(WARNING) << "Unable to get vcgt data";
-    qcms_profile_release(display_profile);
-    return false;
+  if (vcgt_channel_length) {
+    if (has_color_correction_matrix) {
+      VLOG(1) << "Using VCGT data on CTM enabled platform.";
+    }
+
+    std::vector<uint16_t> vcgt_data;
+    vcgt_data.resize(vcgt_channel_length * 3);
+    if (!qcms_profile_get_vcgt_rgb_channels(display_profile, &vcgt_data[0])) {
+      LOG(WARNING) << "Unable to get vcgt data";
+      qcms_profile_release(display_profile);
+      return false;
+    }
+
+    data->gamma_lut.resize(vcgt_channel_length);
+    for (size_t i = 0; i < vcgt_channel_length; ++i) {
+      data->gamma_lut[i].r = vcgt_data[i];
+      data->gamma_lut[i].g = vcgt_data[vcgt_channel_length + i];
+      data->gamma_lut[i].b = vcgt_data[(vcgt_channel_length * 2) + i];
+    }
+  } else {
+    VLOG(1) << "Using full degamma/gamma/CTM from profile.";
+    qcms_profile* srgb_profile = qcms_profile_sRGB();
+
+    qcms_transform* transform =
+        qcms_transform_create(srgb_profile, QCMS_DATA_RGB_8, display_profile,
+                              QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
+
+    if (!transform) {
+      LOG(WARNING)
+          << "Unable to create transformation from sRGB to display profile.";
+
+      qcms_profile_release(display_profile);
+      qcms_profile_release(srgb_profile);
+      return false;
+    }
+
+    if (!qcms_transform_is_matrix(transform)) {
+      LOG(WARNING) << "No transformation matrix available";
+
+      qcms_transform_release(transform);
+      qcms_profile_release(display_profile);
+      qcms_profile_release(srgb_profile);
+      return false;
+    }
+
+    size_t degamma_size = qcms_transform_get_input_trc_rgba(
+        transform, srgb_profile, QCMS_TRC_FLOAT, NULL);
+    size_t gamma_size = qcms_transform_get_output_trc_rgba(
+        transform, display_profile, QCMS_TRC_FLOAT, NULL);
+
+    if (degamma_size == 0 || gamma_size == 0) {
+      LOG(WARNING)
+          << "Invalid number of elements in gamma tables: degamma size = "
+          << degamma_size << " gamma size = " << gamma_size;
+
+      qcms_transform_release(transform);
+      qcms_profile_release(display_profile);
+      qcms_profile_release(srgb_profile);
+      return false;
+    }
+
+    std::vector<float> degamma_data;
+    std::vector<float> gamma_data;
+    degamma_data.resize(degamma_size * 4);
+    gamma_data.resize(gamma_size * 4);
+
+    qcms_transform_get_input_trc_rgba(transform, srgb_profile, QCMS_TRC_FLOAT,
+                                      &degamma_data[0]);
+    qcms_transform_get_output_trc_rgba(transform, display_profile,
+                                       QCMS_TRC_FLOAT, &gamma_data[0]);
+
+#define FLOAT_TO_FIXED(f) static_cast<uint32_t>(f * ((1 << 24)));
+    data->degamma_lut.resize(degamma_size);
+    for (size_t i = 0; i < degamma_size; ++i) {
+      data->degamma_lut[i].r = FLOAT_TO_FIXED(degamma_data[i * 4]);
+      data->degamma_lut[i].g = FLOAT_TO_FIXED(degamma_data[(i * 4) + 1]);
+      data->degamma_lut[i].b = FLOAT_TO_FIXED(degamma_data[(i * 4) + 2]);
+    }
+
+    data->gamma_lut.resize(gamma_size);
+    for (size_t i = 0; i < gamma_size; ++i) {
+      data->gamma_lut[i].r = FLOAT_TO_FIXED(gamma_data[i * 4]);
+      data->gamma_lut[i].g = FLOAT_TO_FIXED(gamma_data[(i * 4) + 1]);
+      data->gamma_lut[i].b = FLOAT_TO_FIXED(gamma_data[(i * 4) + 2]);
+    }
+#undef FLOAT_TO_FIXED
+
+    for (int i = 0; i < 9; ++i) {
+      data->correction_matrix[i] =
+          qcms_transform_get_matrix(transform, i / 3, i % 3);
+    }
+
+    qcms_transform_release(transform);
+    qcms_profile_release(srgb_profile);
   }
 
-  data->lut.resize(vcgt_channel_length);
-  for (size_t i = 0; i < vcgt_channel_length; ++i) {
-    data->lut[i].r = vcgt_data[i];
-    data->lut[i].g = vcgt_data[vcgt_channel_length + i];
-    data->lut[i].b = vcgt_data[(vcgt_channel_length * 2) + i];
-  }
+  VLOG(1) << "ICC file successfully parsed";
   qcms_profile_release(display_profile);
   return true;
 }
 
-base::FilePath PathForDisplaySnapshot(const ui::DisplaySnapshot* snapshot) {
-  base::FilePath path;
-  CHECK(
-      PathService::Get(chromeos::DIR_DEVICE_COLOR_CALIBRATION_PROFILES, &path));
-  path = path.Append(
-      base::StringPrintf("%08" PRIx64 ".icc", snapshot->product_id()));
-  return path;
-}
-
 }  // namespace
 
 DisplayColorManager::DisplayColorManager(
     ui::DisplayConfigurator* configurator,
     base::SequencedWorkerPool* blocking_pool)
     : configurator_(configurator), blocking_pool_(blocking_pool) {
   configurator_->AddObserver(this);
 }
 
 DisplayColorManager::~DisplayColorManager() {
   configurator_->RemoveObserver(this);
   STLDeleteValues(&calibration_map_);
 }
 
 void DisplayColorManager::OnDisplayModeChanged(
     const ui::DisplayConfigurator::DisplayStateList& display_states) {
   for (const ui::DisplaySnapshot* state : display_states) {
     if (calibration_map_[state->product_id()]) {
       ApplyDisplayColorCalibration(state->display_id(), state->product_id());
     } else {
       if (state->product_id() != ui::DisplaySnapshot::kInvalidProductID)
         LoadCalibrationForDisplay(state);
     }
   }
 }
 
 void DisplayColorManager::ApplyDisplayColorCalibration(int64_t display_id,
                                                        int64_t product_id) {
   if (calibration_map_.find(product_id) != calibration_map_.end()) {
-    ColorCalibrationData* ramp = calibration_map_[product_id];
-    if (!configurator_->SetGammaRamp(display_id, ramp->lut))
-      LOG(WARNING) << "Error applying gamma ramp";
+    ColorCalibrationData* data = calibration_map_[product_id];
+    if (data->degamma_lut.size() == 0) {
+      if (!configurator_->SetGammaRamp(display_id, data->gamma_lut))
+        LOG(WARNING) << "Error applying gamma ramp";
+    } else {
+      if (!configurator_->SetColorCorrection(display_id, data->degamma_lut,
+                                             data->gamma_lut,
+                                             data->correction_matrix))
+        LOG(WARNING) << "Error applying color correction data";
+    }
   }
 }
 
 void DisplayColorManager::LoadCalibrationForDisplay(
     const ui::DisplaySnapshot* display) {
   if (display->display_id() == gfx::Display::kInvalidDisplayID) {
     LOG(WARNING) << "Trying to load calibration data for invalid display id";
     return;
   }
 
-  base::FilePath path = PathForDisplaySnapshot(display);
-  VLOG(1) << "Loading ICC file " << path.value()
-          << " for display id: " << display->display_id()
-          << " with product id: " << display->product_id();
+  scoped_ptr<ColorCalibrationData> data(new ColorCalibrationData());
+  base::Callback<bool(void)> request;
+  request = base::Callback<bool(void)>(
+      base::Bind(&ParseFile, display->has_color_correction_matrix(),
+                 display->product_id(), base::Unretained(data.get())));
 
-  scoped_ptr<ColorCalibrationData> data(new ColorCalibrationData());
-  base::Callback<bool(void)> request(
-      base::Bind(&ParseFile, path, base::Unretained(data.get())));
   base::PostTaskAndReplyWithResult(
       blocking_pool_, FROM_HERE, request,
       base::Bind(&DisplayColorManager::UpdateCalibrationData, AsWeakPtr(),
                  display->display_id(), display->product_id(),
                  base::Passed(data.Pass())));
 }
 
 void DisplayColorManager::UpdateCalibrationData(
     int64_t display_id,
     int64_t product_id,
     scoped_ptr<ColorCalibrationData> data,
     bool success) {
   DCHECK_EQ(base::MessageLoop::current()->type(), base::MessageLoop::TYPE_UI);
   if (success) {
     // The map takes over ownership of the underlying memory.
     calibration_map_[product_id] = data.release();
     ApplyDisplayColorCalibration(display_id, product_id);
   }
 }
 
 DisplayColorManager::ColorCalibrationData::ColorCalibrationData() {}
 
 DisplayColorManager::ColorCalibrationData::~ColorCalibrationData() {}
 
 }  // namespace ash