Use SkICC in gfx::ICCProfile and gfx::ColorSpace

ui/gfx/color_space.cc

 // Copyright (c) 2012 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/gfx/color_space.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
@@ skipping 23 matching lines @@
 ColorSpace::MatrixID ColorSpace::MatrixIDFromInt(int matrix_id) {
   if (matrix_id < 0 || matrix_id > static_cast<int>(MatrixID::LAST))
     return MatrixID::UNKNOWN;
   if (matrix_id > static_cast<int>(MatrixID::LAST_STANDARD_VALUE) &&
       matrix_id < 1000)
     return MatrixID::UNKNOWN;
   return static_cast<MatrixID>(matrix_id);
 }
 
 ColorSpace::ColorSpace() {
+  memset(custom_transfer_params_, 0, sizeof(custom_transfer_params_));
   memset(custom_primary_matrix_, 0, sizeof(custom_primary_matrix_));
 }
 
 ColorSpace::ColorSpace(PrimaryID primaries,
                        TransferID transfer,
                        MatrixID matrix,
                        RangeID range)
     : primaries_(primaries),
       transfer_(transfer),
       matrix_(matrix),
       range_(range) {
+  memset(custom_transfer_params_, 0, sizeof(custom_transfer_params_));
   memset(custom_primary_matrix_, 0, sizeof(custom_primary_matrix_));
-  // TODO: Set profile_id_
 }
 
 ColorSpace::ColorSpace(int primaries, int transfer, int matrix, RangeID range)
     : primaries_(PrimaryIDFromInt(primaries)),
       transfer_(TransferIDFromInt(transfer)),
       matrix_(MatrixIDFromInt(matrix)),
       range_(range) {
+  memset(custom_transfer_params_, 0, sizeof(custom_transfer_params_));
   memset(custom_primary_matrix_, 0, sizeof(custom_primary_matrix_));
-  // TODO: Set profile_id_
 }
 
 ColorSpace::ColorSpace(const ColorSpace& other)
     : primaries_(other.primaries_),
       transfer_(other.transfer_),
       matrix_(other.matrix_),
       range_(other.range_),
       icc_profile_id_(other.icc_profile_id_),
       sk_color_space_(other.sk_color_space_) {
+  memcpy(custom_transfer_params_, other.custom_transfer_params_,
+         sizeof(custom_transfer_params_));
   memcpy(custom_primary_matrix_, other.custom_primary_matrix_,
          sizeof(custom_primary_matrix_));
 }
 
 ColorSpace::~ColorSpace() = default;
 
 // static
 ColorSpace ColorSpace::CreateSRGB() {
   ColorSpace result(PrimaryID::BT709, TransferID::IEC61966_2_1, MatrixID::RGB,
                     RangeID::FULL);
@@ skipping 32 matching lines @@
 }
 
 bool ColorSpace::operator==(const ColorSpace& other) const {
   if (primaries_ != other.primaries_ || transfer_ != other.transfer_ ||
       matrix_ != other.matrix_ || range_ != other.range_)
     return false;
   if (primaries_ == PrimaryID::CUSTOM &&
       memcmp(custom_primary_matrix_, other.custom_primary_matrix_,
              sizeof(custom_primary_matrix_)))
     return false;
+  if (transfer_ == TransferID::CUSTOM &&
+      memcmp(custom_transfer_params_, other.custom_transfer_params_,
+             sizeof(custom_transfer_params_)))
+    return false;
   return true;
 }
 
 bool ColorSpace::IsHDR() const {
   return transfer_ == TransferID::SMPTEST2084 ||
          transfer_ == TransferID::ARIB_STD_B67;
 }
 
 bool ColorSpace::operator!=(const ColorSpace& other) const {
   return !(*this == other);
@@ skipping 18 matching lines @@
     return false;
   if (primaries_ == PrimaryID::CUSTOM) {
     int primary_result =
         memcmp(custom_primary_matrix_, other.custom_primary_matrix_,
                sizeof(custom_primary_matrix_));
     if (primary_result < 0)
       return true;
     if (primary_result > 0)
       return false;
   }
+  if (transfer_ == TransferID::CUSTOM) {
+    int transfer_result =
+        memcmp(custom_transfer_params_, other.custom_transfer_params_,
+               sizeof(custom_transfer_params_));
+    if (transfer_result < 0)
+      return true;
+    if (transfer_result > 0)
+      return false;
+  }
   return false;
 }
 
 ColorSpace ColorSpace::FromSkColorSpace(
     const sk_sp<SkColorSpace>& sk_color_space) {
   if (!sk_color_space)
     return gfx::ColorSpace();
   if (SkColorSpace::Equals(
           sk_color_space.get(),
           SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named).get()))
     return gfx::ColorSpace::CreateSRGB();
 
   // TODO(crbug.com/634102): Add conversion to gfx::ColorSpace for
   // non-ICC-profile based color spaces.
   ICCProfile icc_profile = ICCProfile::FromSkColorSpace(sk_color_space);
   return icc_profile.GetColorSpace();
 }
 
+bool ColorSpace::GetPrimaryMatrix(SkMatrix44* to_XYZD50) const {
+  if (primaries_ == PrimaryID::CUSTOM) {
+    to_XYZD50->set3x3RowMajorf(custom_primary_matrix_);
+    return true;
+  }
+  // TODO(ccameron): Merge with primary look-up in ColorTransform.
+  return false;
+}
+
+bool ColorSpace::GetTransferFunction(SkColorSpaceTransferFn* fn) const {
+  if (transfer_ == TransferID::CUSTOM) {
+    fn->fA = custom_transfer_params_[0];
+    fn->fB = custom_transfer_params_[1];
+    fn->fC = custom_transfer_params_[2];
+    fn->fD = custom_transfer_params_[3];
+    fn->fE = custom_transfer_params_[4];
+    fn->fF = custom_transfer_params_[5];
+    fn->fG = custom_transfer_params_[6];
+    return true;
+  }
+  // TODO(ccameron): Add transfer look-up for non-CUSTOM transfer functions.
+  return false;
+}
+
 }  // namespace gfx