// Copyright 2012 The Chromium Authors
// 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 <iomanip>
#include <limits>
#include <map>
#include <sstream>

#include "base/atomic_sequence_num.h"
#include "base/compiler_specific.h"
#include "base/debug/crash_logging.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/notreached.h"
#include "base/synchronization/lock.h"
#include "skia/ext/skcolorspace_primaries.h"
#include "skia/ext/skcolorspace_trfn.h"
#include "skia/ext/skia_utils_base.h"
#include "third_party/skia/include/core/SkColorSpace.h"
#include "third_party/skia/include/core/SkData.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkM44.h"
#include "third_party/skia/modules/skcms/skcms.h"
#include "ui/gfx/display_color_spaces.h"
#include "ui/gfx/icc_profile.h"
#include "ui/gfx/skia_color_space_util.h"

namespace gfx {

namespace {

static bool FloatsEqualWithinTolerance(const float* a,
                                       const float* b,
                                       int n,
                                       float tol) {
  for (int i = 0; i < n; ++i) {
    if (std::abs(UNSAFE_TODO(a[i]) - UNSAFE_TODO(b[i])) > tol) {
      return false;
    }
  }
  return true;
}

bool PrimaryIdContainsSRGB(ColorSpace::PrimaryID id) {
  DCHECK(id != ColorSpace::PrimaryID::INVALID &&
         id != ColorSpace::PrimaryID::CUSTOM);

  switch (id) {
    case ColorSpace::PrimaryID::BT709:
    case ColorSpace::PrimaryID::BT2020:
    case ColorSpace::PrimaryID::SMPTEST428_1:
    case ColorSpace::PrimaryID::SMPTEST431_2:
    case ColorSpace::PrimaryID::P3:
    case ColorSpace::PrimaryID::XYZ_D50:
    case ColorSpace::PrimaryID::ADOBE_RGB:
    case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
      return true;
    default:
      return false;
  }
}

float GetSDRWhiteLevelFromPQSkTransferFunction(
    const skcms_TransferFunction& fn) {
  DCHECK_EQ(fn.g, SkNamedTransferFn::kPQ.g);
  const double ws_a = static_cast<double>(fn.a) / SkNamedTransferFn::kPQ.a;
  const double w_a = pow(ws_a, fn.f);
  const double sdr_white_level_a = 10000.0f / w_a;
  return sdr_white_level_a;
}

}  // namespace

// static
constexpr float ColorSpace::kDefaultSDRWhiteLevel;
constexpr float kDefaultPeakWhite = 1000.f;
constexpr float kDefaultSystemGamma = 1.2f;

ColorSpace::ColorSpace(PrimaryID primaries,
                       TransferID transfer,
                       MatrixID matrix,
                       RangeID range,
                       const skcms_Matrix3x3* custom_primary_matrix,
                       const skcms_TransferFunction* custom_transfer_fn)
    : primaries_(primaries),
      transfer_(transfer),
      matrix_(matrix),
      range_(range) {
  if (custom_primary_matrix) {
    DCHECK_EQ(PrimaryID::CUSTOM, primaries_);
    SetCustomPrimaries(*custom_primary_matrix);
  }
  if (custom_transfer_fn) {
    DCHECK(transfer_ == TransferID::CUSTOM ||
           transfer_ == TransferID::CUSTOM_HDR);
    SetCustomTransferFunction(*custom_transfer_fn,
                              transfer_ == TransferID::CUSTOM_HDR);
  }
}

ColorSpace::ColorSpace(const SkColorSpace& sk_color_space, bool is_hdr)
    : ColorSpace(PrimaryID::INVALID,
                 TransferID::INVALID,
                 MatrixID::RGB,
                 RangeID::FULL) {
  skcms_TransferFunction fn;
  if (sk_color_space.isNumericalTransferFn(&fn)) {
    SetCustomTransferFunction(fn, is_hdr);
  } else if (skcms_TransferFunction_isHLGish(&fn)) {
    transfer_ = TransferID::HLG;
    transfer_params_[0] = 203.f;
    transfer_params_[1] = 1000.f;
    transfer_params_[2] = 1.2f;
  } else if (skcms_TransferFunction_isPQish(&fn)) {
    transfer_ = TransferID::PQ;
    transfer_params_[0] = GetSDRWhiteLevelFromPQSkTransferFunction(fn);
    if (transfer_params_[0] == 10000.f) {
      transfer_params_[0] = 203.f;
    }
  } else if (skcms_TransferFunction_isHLG(&fn)) {
    transfer_ = TransferID::HLG;
    transfer_params_[0] = fn.a;
    transfer_params_[1] = fn.b;
    transfer_params_[2] = fn.c;
  } else if (skcms_TransferFunction_isPQ(&fn)) {
    transfer_ = TransferID::PQ;
    transfer_params_[0] = fn.a;
  } else {
    // Construct an invalid result: Unable to extract necessary parameters
    return;
  }

  skcms_Matrix3x3 to_XYZD50;
  if (!sk_color_space.toXYZD50(&to_XYZD50)) {
    // Construct an invalid result: Unable to extract necessary parameters
    return;
  }
  SetCustomPrimaries(to_XYZD50);
}

bool ColorSpace::IsValid() const {
  return primaries_ != PrimaryID::INVALID && transfer_ != TransferID::INVALID &&
         matrix_ != MatrixID::INVALID && range_ != RangeID::INVALID;
}

// static
ColorSpace ColorSpace::CreateExtendedSRGB10Bit() {
  return ColorSpace(PrimaryID::P3, TransferID::CUSTOM_HDR, MatrixID::RGB,
                    RangeID::FULL, nullptr,
                    &SkNamedTransferFnExt::kSRGBExtended1023Over510);
}

// static
ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50,
                                    const skcms_TransferFunction& fn) {
  ColorSpace result(ColorSpace::PrimaryID::CUSTOM,
                    ColorSpace::TransferID::CUSTOM, ColorSpace::MatrixID::RGB,
                    ColorSpace::RangeID::FULL, &to_XYZD50, &fn);
  return result;
}

// static
ColorSpace ColorSpace::CreateCustom(const skcms_Matrix3x3& to_XYZD50,
                                    TransferID transfer) {
  ColorSpace result(ColorSpace::PrimaryID::CUSTOM, transfer,
                    ColorSpace::MatrixID::RGB, ColorSpace::RangeID::FULL,
                    &to_XYZD50, nullptr);
  return result;
}

void ColorSpace::SetCustomPrimaries(const skcms_Matrix3x3& to_XYZD50) {
  const PrimaryID kIDsToCheck[] = {
      PrimaryID::BT709,
      PrimaryID::BT470M,
      PrimaryID::BT470BG,
      PrimaryID::SMPTE170M,
      PrimaryID::SMPTE240M,
      PrimaryID::FILM,
      PrimaryID::BT2020,
      PrimaryID::SMPTEST428_1,
      PrimaryID::SMPTEST431_2,
      PrimaryID::P3,
      PrimaryID::XYZ_D50,
      PrimaryID::ADOBE_RGB,
      PrimaryID::APPLE_GENERIC_RGB,
      PrimaryID::WIDE_GAMUT_COLOR_SPIN,
      PrimaryID::EBU_3213_E,
  };
  for (PrimaryID id : kIDsToCheck) {
    skcms_Matrix3x3 matrix;
    GetPrimaryMatrix(id, &matrix);
    if (FloatsEqualWithinTolerance(&to_XYZD50.vals[0][0], &matrix.vals[0][0], 9,
                                   0.001f)) {
      primaries_ = id;
      return;
    }
  }

  UNSAFE_TODO(memcpy(custom_primary_matrix_, &to_XYZD50, 9 * sizeof(float)));
  primaries_ = PrimaryID::CUSTOM;
}

void ColorSpace::SetCustomTransferFunction(const skcms_TransferFunction& fn,
                                           bool is_hdr) {
  auto check_transfer_fn = [this, &fn](TransferID id) {
    skcms_TransferFunction id_fn;
    GetTransferFunction(id, &id_fn);
    if (!FloatsEqualWithinTolerance(&fn.g, &id_fn.g, 7, 0.001f)) {
      return false;
    }
    transfer_ = id;
    return true;
  };

  transfer_ = is_hdr ? TransferID::CUSTOM_HDR : TransferID::CUSTOM;

  if (transfer_ == TransferID::CUSTOM) {
    // These are all TransferIDs that will return a transfer function from
    // GetTransferFunction. When multiple ids map to the same function, this
    // list prioritizes the most common name (eg SRGB).
    const TransferID kIDsToCheck[] = {
        TransferID::SRGB,         TransferID::LINEAR,
        TransferID::GAMMA18,      TransferID::GAMMA22,
        TransferID::GAMMA24,      TransferID::GAMMA28,
        TransferID::SMPTE240M,    TransferID::BT709_APPLE,
        TransferID::SMPTEST428_1,
    };
    for (TransferID id : kIDsToCheck) {
      if (check_transfer_fn(id))
        return;
    }
  }

  if (transfer_ == TransferID::CUSTOM_HDR) {
    // This list is the same as above, but for HDR TransferIDs.
    const TransferID kIDsToCheckHDR[] = {
        TransferID::SRGB_HDR,
        TransferID::LINEAR_HDR,
    };
    for (TransferID id : kIDsToCheckHDR) {
      if (check_transfer_fn(id)) {
        return;
      }
    }
  }

  transfer_params_[0] = fn.a;
  transfer_params_[1] = fn.b;
  transfer_params_[2] = fn.c;
  transfer_params_[3] = fn.d;
  transfer_params_[4] = fn.e;
  transfer_params_[5] = fn.f;
  transfer_params_[6] = fn.g;
}

// static
size_t ColorSpace::TransferParamCount(TransferID transfer) {
  switch (transfer) {
    case TransferID::CUSTOM:
      return 7;
    case TransferID::CUSTOM_HDR:
      return 7;
    case TransferID::PQ:
      return 1;
    case TransferID::HLG:
      return 3;
    default:
      return 0;
  }
}

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) {
    if (UNSAFE_TODO(memcmp(custom_primary_matrix_, other.custom_primary_matrix_,
                           sizeof(custom_primary_matrix_)))) {
      return false;
    }
  }
  if (size_t param_count = TransferParamCount(transfer_)) {
    if (UNSAFE_TODO(memcmp(transfer_params_, other.transfer_params_,
                           param_count * sizeof(float)))) {
      return false;
    }
  }
  return true;
}

bool ColorSpace::IsWide() const {
  // These HDR transfer functions are always wide
  if (transfer_ == TransferID::SRGB_HDR ||
      transfer_ == TransferID::LINEAR_HDR ||
      transfer_ == TransferID::CUSTOM_HDR)
    return true;

  if (primaries_ == PrimaryID::BT2020 ||
      primaries_ == PrimaryID::SMPTEST431_2 || primaries_ == PrimaryID::P3 ||
      primaries_ == PrimaryID::ADOBE_RGB ||
      primaries_ == PrimaryID::WIDE_GAMUT_COLOR_SPIN ||
      // TODO(cblume/ccameron): Compute if the custom primaries actually are
      // wide. For now, assume so.
      primaries_ == PrimaryID::CUSTOM)
    return true;

  return false;
}

bool ColorSpace::IsHDR() const {
  return transfer_ == TransferID::PQ || transfer_ == TransferID::HLG ||
         transfer_ == TransferID::LINEAR_HDR ||
         transfer_ == TransferID::SRGB_HDR ||
         transfer_ == TransferID::CUSTOM_HDR ||
         transfer_ == TransferID::SCRGB_LINEAR_80_NITS;
}

bool ColorSpace::IsToneMappedByDefault() const {
  switch (transfer_) {
    case TransferID::PQ:
    case TransferID::HLG:
      return true;
    default:
      return false;
  }
}

bool ColorSpace::IsAffectedBySDRWhiteLevel() const {
  switch (transfer_) {
    case TransferID::PQ:
    case TransferID::HLG:
    case TransferID::SCRGB_LINEAR_80_NITS:
      return true;
    default:
      return false;
  }
}

bool ColorSpace::FullRangeEncodedValues() const {
  return transfer_ == TransferID::LINEAR_HDR ||
         transfer_ == TransferID::SRGB_HDR ||
         transfer_ == TransferID::CUSTOM_HDR ||
         transfer_ == TransferID::SCRGB_LINEAR_80_NITS ||
         transfer_ == TransferID::BT1361_ECG ||
         transfer_ == TransferID::IEC61966_2_4;
}

bool ColorSpace::operator<(const ColorSpace& other) const {
  if (primaries_ < other.primaries_)
    return true;
  if (primaries_ > other.primaries_)
    return false;
  if (transfer_ < other.transfer_)
    return true;
  if (transfer_ > other.transfer_)
    return false;
  if (matrix_ < other.matrix_)
    return true;
  if (matrix_ > other.matrix_)
    return false;
  if (range_ < other.range_)
    return true;
  if (range_ > other.range_)
    return false;
  if (primaries_ == PrimaryID::CUSTOM) {
    int primary_result =
        UNSAFE_TODO(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 (size_t param_count = TransferParamCount(transfer_)) {
    int transfer_result = UNSAFE_TODO(memcmp(
        transfer_params_, other.transfer_params_, param_count * sizeof(float)));
    if (transfer_result < 0)
      return true;
    if (transfer_result > 0)
      return false;
  }
  return false;
}

size_t ColorSpace::GetHash() const {
  size_t result = (static_cast<size_t>(primaries_) << 0) |
                  (static_cast<size_t>(transfer_) << 8) |
                  (static_cast<size_t>(matrix_) << 16) |
                  (static_cast<size_t>(range_) << 24);
  if (primaries_ == PrimaryID::CUSTOM) {
    const uint32_t* params =
        reinterpret_cast<const uint32_t*>(custom_primary_matrix_);
    result ^= params[0];
    result ^= UNSAFE_TODO(params[4]);
    result ^= UNSAFE_TODO(params[8]);
  }
  {
    // Note that |transfer_params_| must be zero when they are unused.
    const uint32_t* params =
        reinterpret_cast<const uint32_t*>(transfer_params_);
    result ^= UNSAFE_TODO(params[3]);
    result ^= UNSAFE_TODO(params[6]);
  }
  return result;
}

#define PRINT_ENUM_CASE(TYPE, NAME) \
  case TYPE::NAME:                  \
    ss << #NAME;                    \
    break;

std::string ColorSpace::ToString() const {
  std::stringstream ss;
  ss << std::fixed << std::setprecision(4);
  if (primaries_ != PrimaryID::CUSTOM)
    ss << "{primaries:";
  switch (primaries_) {
    PRINT_ENUM_CASE(PrimaryID, INVALID)
    PRINT_ENUM_CASE(PrimaryID, BT709)
    PRINT_ENUM_CASE(PrimaryID, BT470M)
    PRINT_ENUM_CASE(PrimaryID, BT470BG)
    PRINT_ENUM_CASE(PrimaryID, SMPTE170M)
    PRINT_ENUM_CASE(PrimaryID, SMPTE240M)
    PRINT_ENUM_CASE(PrimaryID, FILM)
    PRINT_ENUM_CASE(PrimaryID, BT2020)
    PRINT_ENUM_CASE(PrimaryID, SMPTEST428_1)
    PRINT_ENUM_CASE(PrimaryID, SMPTEST431_2)
    PRINT_ENUM_CASE(PrimaryID, P3)
    PRINT_ENUM_CASE(PrimaryID, XYZ_D50)
    PRINT_ENUM_CASE(PrimaryID, ADOBE_RGB)
    PRINT_ENUM_CASE(PrimaryID, APPLE_GENERIC_RGB)
    PRINT_ENUM_CASE(PrimaryID, WIDE_GAMUT_COLOR_SPIN)
    PRINT_ENUM_CASE(PrimaryID, EBU_3213_E)
    case PrimaryID::CUSTOM:
      ss << skia::SkColorSpacePrimariesToString(GetPrimaries());
      break;
  }
  ss << ", transfer:";
  switch (transfer_) {
    PRINT_ENUM_CASE(TransferID, INVALID)
    PRINT_ENUM_CASE(TransferID, BT709)
    PRINT_ENUM_CASE(TransferID, BT709_APPLE)
    PRINT_ENUM_CASE(TransferID, GAMMA18)
    PRINT_ENUM_CASE(TransferID, GAMMA22)
    PRINT_ENUM_CASE(TransferID, GAMMA24)
    PRINT_ENUM_CASE(TransferID, GAMMA28)
    PRINT_ENUM_CASE(TransferID, SMPTE170M)
    PRINT_ENUM_CASE(TransferID, SMPTE240M)
    PRINT_ENUM_CASE(TransferID, LINEAR)
    PRINT_ENUM_CASE(TransferID, LOG)
    PRINT_ENUM_CASE(TransferID, LOG_SQRT)
    PRINT_ENUM_CASE(TransferID, IEC61966_2_4)
    PRINT_ENUM_CASE(TransferID, BT1361_ECG)
    PRINT_ENUM_CASE(TransferID, SRGB)
    PRINT_ENUM_CASE(TransferID, BT2020_10)
    PRINT_ENUM_CASE(TransferID, BT2020_12)
    PRINT_ENUM_CASE(TransferID, SMPTEST428_1)
    PRINT_ENUM_CASE(TransferID, SRGB_HDR)
    PRINT_ENUM_CASE(TransferID, LINEAR_HDR)
    case TransferID::HLG:
      ss << "HLG (white:"
         << (transfer_params_[0] <= 0.f ? kDefaultSDRWhiteLevel
                                        : transfer_params_[0])
         << " nits, peak:"
         << (transfer_params_[1] <= 0.f ? kDefaultPeakWhite
                                        : transfer_params_[1])
         << " nits, gamma:"
         << (transfer_params_[2] <= 0.f ? kDefaultSystemGamma
                                        : transfer_params_[2])
         << ")";
      break;
    case TransferID::PQ:
      ss << "PQ (white:"
         << (transfer_params_[0] <= 0.f ? kDefaultSDRWhiteLevel
                                        : transfer_params_[0])
         << " nits)";
      break;
    case TransferID::CUSTOM: {
      skcms_TransferFunction fn;
      GetTransferFunction(&fn);
      ss << skia::SkcmsTransferFunctionToString(fn);
      break;
    }
    case TransferID::CUSTOM_HDR: {
      skcms_TransferFunction fn;
      GetTransferFunction(&fn);
      if (fn.g == 1.0f && fn.a > 0.0f && fn.b == 0.0f && fn.c == 0.0f &&
          fn.d == 0.0f && fn.e == 0.0f && fn.f == 0.0f) {
        ss << "LINEAR_HDR (slope " << fn.a << ")";
        break;
      }
      ss << skia::SkcmsTransferFunctionToString(fn);
      break;
    }
    case TransferID::SCRGB_LINEAR_80_NITS:
      ss << "scRGB linear (80 nit white)";
      break;
  }
  ss << ", matrix:";
  switch (matrix_) {
    PRINT_ENUM_CASE(MatrixID, INVALID)
    PRINT_ENUM_CASE(MatrixID, RGB)
    PRINT_ENUM_CASE(MatrixID, BT709)
    PRINT_ENUM_CASE(MatrixID, FCC)
    PRINT_ENUM_CASE(MatrixID, BT470BG)
    PRINT_ENUM_CASE(MatrixID, SMPTE170M)
    PRINT_ENUM_CASE(MatrixID, SMPTE240M)
    PRINT_ENUM_CASE(MatrixID, YCOCG)
    PRINT_ENUM_CASE(MatrixID, BT2020_NCL)
    PRINT_ENUM_CASE(MatrixID, YDZDX)
    PRINT_ENUM_CASE(MatrixID, GBR)
  }
  ss << ", range:";
  switch (range_) {
    PRINT_ENUM_CASE(RangeID, INVALID)
    PRINT_ENUM_CASE(RangeID, LIMITED)
    PRINT_ENUM_CASE(RangeID, FULL)
    PRINT_ENUM_CASE(RangeID, DERIVED)
  }
  ss << "}";
  return ss.str();
}

#undef PRINT_ENUM_CASE

ColorSpace ColorSpace::GetAsFullRangeRGB() const {
  ColorSpace result(*this);
  if (!IsValid())
    return result;
  result.matrix_ = MatrixID::RGB;
  result.range_ = RangeID::FULL;
  return result;
}

ContentColorUsage ColorSpace::GetContentColorUsage() const {
  if (IsHDR())
    return ContentColorUsage::kHDR;
  if (IsWide())
    return ContentColorUsage::kWideColorGamut;
  return ContentColorUsage::kSRGB;
}

ColorSpace ColorSpace::GetAsRGB() const {
  ColorSpace result(*this);
  if (IsValid())
    result.matrix_ = MatrixID::RGB;
  return result;
}

ColorSpace ColorSpace::GetScaledColorSpace(float factor) const {
  ColorSpace result(*this);
  skcms_Matrix3x3 to_XYZD50;
  GetPrimaryMatrix(&to_XYZD50);
  for (int row = 0; row < 3; ++row) {
    for (int col = 0; col < 3; ++col) {
      UNSAFE_TODO(to_XYZD50.vals[row][col]) *= factor;
    }
  }
  result.SetCustomPrimaries(to_XYZD50);
  return result;
}

bool ColorSpace::IsSuitableForBlending() const {
  switch (transfer_) {
    case TransferID::PQ:
      // PQ is not an acceptable space to do blending in -- blending 0 and 1
      // evenly will get a result of sRGB 0.259 (instead of 0.5).
      return false;
    case TransferID::HLG:
    case TransferID::LINEAR_HDR:
    case TransferID::SCRGB_LINEAR_80_NITS:
      // If the color space is nearly-linear, then it is not suitable for
      // blending -- blending 0 and 1 evenly will get a result of sRGB 0.735
      // (instead of 0.5).
      return false;
    case TransferID::CUSTOM_HDR: {
      // A gamma close enough to linear is treated as linear.
      skcms_TransferFunction fn;
      if (GetTransferFunction(&fn)) {
        constexpr float kMinGamma = 1.25;
        if (fn.g < kMinGamma)
          return false;
      }
      break;
    }
    default:
      break;
  }
  return true;
}

ColorSpace ColorSpace::GetWithMatrixAndRange(MatrixID matrix,
                                             RangeID range) const {
  ColorSpace result(*this);
  if (!IsValid())
    return result;

  result.matrix_ = matrix;
  result.range_ = range;
  return result;
}

ColorSpace ColorSpace::GetAsHDR() const {
  ColorSpace result = *this;
  skcms_TransferFunction fn;
  if (result.GetTransferFunction(&fn)) {
    result.SetCustomTransferFunction(fn, /*is_hdr=*/true);
  }
  return result;
}

ColorSpace ColorSpace::GetWithTransferFunction(TransferID transfer) const {
  DCHECK_NE(transfer, TransferID::CUSTOM);
  DCHECK_NE(transfer, TransferID::CUSTOM_HDR);
  ColorSpace result(*this);
  result.transfer_ = transfer;
  return result;
}

ColorSpace ColorSpace::GetWithTransferFunction(const skcms_TransferFunction& fn,
                                               bool is_hdr) const {
  ColorSpace result(*this);
  result.SetCustomTransferFunction(fn, is_hdr);
  return result;
}

ColorSpace ColorSpace::GetWithSdrWhiteLevel(float sdr_white_level) const {
  if (!IsAffectedBySDRWhiteLevel())
    return *this;

  return gfx::ColorSpace(*ToSkColorSpace(sdr_white_level), /*is_hdr=*/true);
}

sk_sp<SkColorSpace> ColorSpace::ToSkColorSpace(
    std::optional<float> sdr_white_level) const {
  // Handle only valid, full-range RGB spaces.
  if (!IsValid() || matrix_ != MatrixID::RGB || range_ != RangeID::FULL)
    return nullptr;

  // Use the named SRGB and linear-SRGB instead of the generic constructors.
  if (primaries_ == PrimaryID::BT709) {
    if (transfer_ == TransferID::SRGB)
      return SkColorSpace::MakeSRGB();
    if (transfer_ == TransferID::LINEAR || transfer_ == TransferID::LINEAR_HDR)
      return SkColorSpace::MakeSRGBLinear();
  }

  // This is almost equal to SkNamedTransferFunction::kSRGB, but has some slight
  // rounding differences that some tests depend on. These tests should be
  // updated.
  skcms_TransferFunction transfer_fn = {2.4f, 0.947867345704f, 0.052132654296f,
                                        0.077399380805f, 0.040449937172f};
  switch (transfer_) {
    case TransferID::SRGB:
      break;
    case TransferID::LINEAR:
    case TransferID::LINEAR_HDR:
      transfer_fn = SkNamedTransferFn::kLinear;
      break;
    case TransferID::HLG: {
      const float hdr_reference_white = sdr_white_level.value_or(
          transfer_params_[0] > 0.f ? transfer_params_[0]
                                    : kDefaultSDRWhiteLevel);
      const float peak_white =
          transfer_params_[1] > 0.f ? transfer_params_[1] : kDefaultPeakWhite;
      const float system_gamma =
          transfer_params_[2] > 0.f ? transfer_params_[2] : kDefaultSystemGamma;
      skcms_TransferFunction_makeHLG(&transfer_fn, hdr_reference_white,
                                     peak_white, system_gamma);
      break;
    }
    case TransferID::PQ: {
      const float hdr_reference_white = sdr_white_level.value_or(
          transfer_params_[0] > 0.f ? transfer_params_[0]
                                    : kDefaultSDRWhiteLevel);
      skcms_TransferFunction_makePQ(&transfer_fn, hdr_reference_white);
      break;
    }
    default:
      if (!GetTransferFunction(&transfer_fn, sdr_white_level)) {
        DLOG(ERROR) << "Failed to get transfer function for SkColorSpace";
        return nullptr;
      }
      break;
  }
  skcms_Matrix3x3 gamut = SkNamedGamut::kSRGB;
  switch (primaries_) {
    case PrimaryID::BT709:
      break;
    case PrimaryID::ADOBE_RGB:
      gamut = SkNamedGamut::kAdobeRGB;
      break;
    case PrimaryID::P3:
      gamut = SkNamedGamut::kDisplayP3;
      break;
    case PrimaryID::BT2020:
      gamut = SkNamedGamut::kRec2020;
      break;
    default:
      GetPrimaryMatrix(&gamut);
      break;
  }
  sk_sp<SkColorSpace> sk_color_space =
      SkColorSpace::MakeRGB(transfer_fn, gamut);
  if (!sk_color_space)
    DLOG(ERROR) << "SkColorSpace::MakeRGB failed.";

  return sk_color_space;
}

const struct _GLcolorSpace* ColorSpace::AsGLColorSpace() const {
  return reinterpret_cast<const struct _GLcolorSpace*>(this);
}

ColorSpace::PrimaryID ColorSpace::GetPrimaryID() const {
  return primaries_;
}

ColorSpace::TransferID ColorSpace::GetTransferID() const {
  return transfer_;
}

ColorSpace::MatrixID ColorSpace::GetMatrixID() const {
  return matrix_;
}

ColorSpace::RangeID ColorSpace::GetRangeID() const {
  return range_;
}

bool ColorSpace::HasExtendedSkTransferFn() const {
  return matrix_ == MatrixID::RGB;
}

bool ColorSpace::IsTransferFunctionEqualTo(
    const skcms_TransferFunction& fn) const {
  if (transfer_ == TransferID::PQ)
    return skcms_TransferFunction_isPQish(&fn) ||
           skcms_TransferFunction_isPQ(&fn);
  if (transfer_ == TransferID::HLG)
    return skcms_TransferFunction_isHLGish(&fn) ||
           skcms_TransferFunction_isHLG(&fn);
  if (!skcms_TransferFunction_isSRGBish(&fn))
    return false;
  skcms_TransferFunction transfer_fn;
  GetTransferFunction(&transfer_fn);
  return fn.a == transfer_fn.a && fn.b == transfer_fn.b &&
         fn.c == transfer_fn.c && fn.d == transfer_fn.d &&
         fn.e == transfer_fn.e && fn.f == transfer_fn.f &&
         fn.g == transfer_fn.g;
}

bool ColorSpace::Contains(const ColorSpace& other) const {
  if (primaries_ == PrimaryID::INVALID ||
      other.primaries_ == PrimaryID::INVALID)
    return false;

  // Contains() is commonly used to check if a color space contains sRGB. The
  // computation can be bypassed for known primary IDs.
  if (primaries_ != PrimaryID::CUSTOM && other.primaries_ == PrimaryID::BT709)
    return PrimaryIdContainsSRGB(primaries_);

  // |matrix| is the primary transform matrix from |other| to this color space.
  skcms_Matrix3x3 other_to_xyz;
  skcms_Matrix3x3 this_to_xyz;
  skcms_Matrix3x3 xyz_to_this;
  other.GetPrimaryMatrix(&other_to_xyz);
  GetPrimaryMatrix(&this_to_xyz);
  skcms_Matrix3x3_invert(&this_to_xyz, &xyz_to_this);
  skcms_Matrix3x3 matrix = skcms_Matrix3x3_concat(&xyz_to_this, &other_to_xyz);

  // Return true iff each primary is in the range [0, 1] after transforming.
  // Transforming a primary vector by |matrix| always results in a column of
  // |matrix|. So the multiplication can be skipped, and we can just check if
  // each value in the matrix is in the range [0, 1].
  constexpr float epsilon = 0.001f;
  for (int r = 0; r < 3; r++) {
    for (int c = 0; c < 3; c++) {
      if (UNSAFE_TODO(matrix.vals[r][c]) < -epsilon ||
          UNSAFE_TODO(matrix.vals[r][c]) > 1 + epsilon) {
        return false;
      }
    }
  }
  return true;
}

// static
SkColorSpacePrimaries ColorSpace::GetColorSpacePrimaries(
    PrimaryID primary_id,
    const skcms_Matrix3x3* custom_primary_matrix = nullptr) {
  SkColorSpacePrimaries primaries = SkNamedPrimariesExt::kInvalid;

  if (custom_primary_matrix && primary_id == PrimaryID::CUSTOM)
    return skia::GetD65PrimariesFromToXYZD50Matrix(*custom_primary_matrix);

  switch (primary_id) {
    case ColorSpace::PrimaryID::CUSTOM:
    case ColorSpace::PrimaryID::INVALID:
      break;

    case ColorSpace::PrimaryID::BT709:
      // BT709 is our default case. Put it after the switch just
      // in case we somehow get an id which is not listed in the switch.
      // (We don't want to use "default", because we want the compiler
      //  to tell us if we forgot some enum values.)
      return SkNamedPrimaries::kRec709;

    case ColorSpace::PrimaryID::BT470M:
      return SkNamedPrimaries::kRec470SystemM;

    case ColorSpace::PrimaryID::BT470BG:
      return SkNamedPrimaries::kRec470SystemBG;

    case ColorSpace::PrimaryID::SMPTE170M:
      return SkNamedPrimaries::kRec601;

    case ColorSpace::PrimaryID::SMPTE240M:
      return SkNamedPrimaries::kSMPTE_ST_240;

    case ColorSpace::PrimaryID::APPLE_GENERIC_RGB:
      return SkNamedPrimariesExt::kAppleGenericRGB;

    case ColorSpace::PrimaryID::WIDE_GAMUT_COLOR_SPIN:
      return SkNamedPrimariesExt::kWideGamutColorSpin;

    case ColorSpace::PrimaryID::FILM:
      return SkNamedPrimaries::kGenericFilm;

    case ColorSpace::PrimaryID::BT2020:
      return SkNamedPrimaries::kRec2020;

    case ColorSpace::PrimaryID::SMPTEST428_1:
      return SkNamedPrimaries::kSMPTE_ST_428_1;

    case ColorSpace::PrimaryID::SMPTEST431_2:
      return SkNamedPrimaries::kSMPTE_RP_431_2;

    case ColorSpace::PrimaryID::P3:
      return SkNamedPrimariesExt::kP3;

    case ColorSpace::PrimaryID::XYZ_D50:
      return SkNamedPrimariesExt::kXYZD50;

    case ColorSpace::PrimaryID::ADOBE_RGB:
      return SkNamedPrimariesExt::kA98RGB;

    case ColorSpace::PrimaryID::EBU_3213_E:
      return SkNamedPrimaries::kITU_T_H273_Value22;
  }
  return primaries;
}

SkColorSpacePrimaries ColorSpace::GetPrimaries() const {
  skcms_Matrix3x3 matrix;
  UNSAFE_TODO(memcpy(&matrix, custom_primary_matrix_, 9 * sizeof(float)));
  return GetColorSpacePrimaries(primaries_, &matrix);
}

// static
void ColorSpace::GetPrimaryMatrix(PrimaryID primary_id,
                                  skcms_Matrix3x3* to_XYZD50) {
  SkColorSpacePrimaries primaries = GetColorSpacePrimaries(primary_id);

  if (primary_id == PrimaryID::CUSTOM || primary_id == PrimaryID::INVALID) {
    *to_XYZD50 = SkNamedGamut::kXYZ;  // Identity
    return;
  }
  primaries.toXYZD50(to_XYZD50);
}

void ColorSpace::GetPrimaryMatrix(skcms_Matrix3x3* to_XYZD50) const {
  if (primaries_ == PrimaryID::CUSTOM) {
    UNSAFE_TODO(memcpy(to_XYZD50, custom_primary_matrix_, 9 * sizeof(float)));
  } else {
    GetPrimaryMatrix(primaries_, to_XYZD50);
  }
}

SkM44 ColorSpace::GetPrimaryMatrix() const {
  skcms_Matrix3x3 toXYZ_3x3;
  GetPrimaryMatrix(&toXYZ_3x3);
  return SkM44FromSkcmsMatrix3x3(toXYZ_3x3);
}

// static
bool ColorSpace::GetTransferFunction(TransferID transfer,
                                     skcms_TransferFunction* fn) {
  // Default to F(x) = pow(x, 1)
  fn->a = 1;
  fn->b = 0;
  fn->c = 0;
  fn->d = 0;
  fn->e = 0;
  fn->f = 0;
  fn->g = 1;

  switch (transfer) {
    case ColorSpace::TransferID::LINEAR:
    case ColorSpace::TransferID::LINEAR_HDR:
      *fn = SkNamedTransferFn::kLinear;
      return true;
    case ColorSpace::TransferID::GAMMA18:
      fn->g = 1.801f;
      return true;
    case ColorSpace::TransferID::GAMMA22:
      *fn = SkNamedTransferFn::kRec470SystemM;
      return true;
    case ColorSpace::TransferID::GAMMA24:
      fn->g = 2.4f;
      return true;
    case ColorSpace::TransferID::GAMMA28:
      *fn = SkNamedTransferFn::kRec470SystemBG;
      return true;
    case ColorSpace::TransferID::SMPTE240M:
      *fn = SkNamedTransferFn::kSMPTE_ST_240;
      return true;
    case ColorSpace::TransferID::BT709:
    case ColorSpace::TransferID::SMPTE170M:
    case ColorSpace::TransferID::BT2020_10:
    case ColorSpace::TransferID::BT2020_12:
    // With respect to rendering BT709
    //  * SMPTE 1886 suggests that we should be using gamma 2.4.
    //  * Most displays actually use a gamma of 2.2, and most media playing
    //    software uses the sRGB transfer function.
    //  * User studies shows that users don't really care.
    //  * Apple's CoreVideo uses gamma=1.961.
    // Bearing all of that in mind, use the same transfer function as sRGB,
    // which will allow more optimization, and will more closely match other
    // media players.
    case ColorSpace::TransferID::SRGB:
    case ColorSpace::TransferID::SRGB_HDR:
      *fn = SkNamedTransferFn::kSRGB;
      return true;
    case ColorSpace::TransferID::BT709_APPLE:
      *fn = SkNamedTransferFnExt::kRec709Apple;
      return true;
    case ColorSpace::TransferID::SMPTEST428_1:
      *fn = SkNamedTransferFn::kSMPTE_ST_428_1;
      return true;
    case ColorSpace::TransferID::IEC61966_2_4:
      // This could potentially be represented the same as SRGB, but it handles
      // negative values differently.
      break;
    case ColorSpace::TransferID::HLG:
    case ColorSpace::TransferID::BT1361_ECG:
    case ColorSpace::TransferID::LOG:
    case ColorSpace::TransferID::LOG_SQRT:
    case ColorSpace::TransferID::PQ:
    case ColorSpace::TransferID::CUSTOM:
    case ColorSpace::TransferID::CUSTOM_HDR:
    case ColorSpace::TransferID::SCRGB_LINEAR_80_NITS:
    case ColorSpace::TransferID::INVALID:
      break;
  }

  return false;
}

bool ColorSpace::GetTransferFunction(
    skcms_TransferFunction* fn,
    std::optional<float> sdr_white_level) const {
  switch (transfer_) {
    case TransferID::CUSTOM:
    case TransferID::CUSTOM_HDR:
      fn->a = transfer_params_[0];
      fn->b = transfer_params_[1];
      fn->c = transfer_params_[2];
      fn->d = transfer_params_[3];
      fn->e = transfer_params_[4];
      fn->f = transfer_params_[5];
      fn->g = transfer_params_[6];
      return true;
    case TransferID::SCRGB_LINEAR_80_NITS:
      if (sdr_white_level) {
        fn->a = 80.f / *sdr_white_level;
        fn->b = 0;
        fn->c = 0;
        fn->d = 0;
        fn->e = 0;
        fn->f = 0;
        fn->g = 1;
        return true;
      } else {
        // Using SCRGB_LINEAR_80_NITS without specifying an SDR white level is
        // guaranteed to produce incorrect results.
        return false;
      }
    default:
      return GetTransferFunction(transfer_, fn);
  }
}

bool ColorSpace::GetInverseTransferFunction(
    skcms_TransferFunction* fn,
    std::optional<float> sdr_white_level) const {
  if (!GetTransferFunction(fn, sdr_white_level))
    return false;
  *fn = SkTransferFnInverse(*fn);
  return true;
}

SkM44 ColorSpace::GetTransferMatrix(int bit_depth) const {
  DCHECK_GE(bit_depth, 8);
  // If chroma samples are real numbers in the range of −0.5 to 0.5, an offset
  // of 0.5 is added to get real numbers in the range of 0 to 1. When
  // represented as an unsigned |bit_depth|-bit integer, this 0.5 offset is
  // approximated by 1 << (bit_depth - 1). chroma_0_5 is this approximate value
  // converted to a real number in the range of 0 to 1.
  //
  // TODO(wtc): For now chroma_0_5 is only used for YCgCo. It should also be
  // used for YUV.
  const float chroma_0_5 =
      static_cast<float>(1 << (bit_depth - 1)) / ((1 << bit_depth) - 1);
  float Kr = 0;
  float Kb = 0;
  switch (matrix_) {
    case ColorSpace::MatrixID::RGB:
    case ColorSpace::MatrixID::INVALID:
      return SkM44();

    case ColorSpace::MatrixID::BT709:
      Kr = 0.2126f;
      Kb = 0.0722f;
      break;

    case ColorSpace::MatrixID::FCC:
      Kr = 0.30f;
      Kb = 0.11f;
      break;

    case ColorSpace::MatrixID::BT470BG:
    case ColorSpace::MatrixID::SMPTE170M:
      Kr = 0.299f;
      Kb = 0.114f;
      break;

    case ColorSpace::MatrixID::SMPTE240M:
      Kr = 0.212f;
      Kb = 0.087f;
      break;

    case ColorSpace::MatrixID::YCOCG: {
      float data[16] = {0.25f,  0.5f, 0.25f,  0.0f,        // Y
                        -0.25f, 0.5f, -0.25f, chroma_0_5,  // Cg
                        0.5f,   0.0f, -0.5f,  chroma_0_5,  // Co
                        0.0f,   0.0f, 0.0f,   1.0f};
      return SkM44::RowMajor(data);
    }

    case ColorSpace::MatrixID::BT2020_NCL:
      Kr = 0.2627f;
      Kb = 0.0593f;
      break;

    case ColorSpace::MatrixID::YDZDX: {
      // clang-format off
      float data[16] = {
          0.0f,              1.0f,             0.0f, 0.0f,  // Y
          0.0f,             -0.5f, 0.986566f / 2.0f, 0.5f,  // DX or DZ
          0.5f, -0.991902f / 2.0f,             0.0f, 0.5f,  // DZ or DX
          0.0f,              0.0f,             0.0f, 1.0f,
      };
      // clang-format on
      return SkM44::RowMajor(data);
    }
    case ColorSpace::MatrixID::GBR: {
      float data[16] = {0.0f, 1.0f, 0.0f, 0.0f,  // G
                        0.0f, 0.0f, 1.0f, 0.0f,  // B
                        1.0f, 0.0f, 0.0f, 0.0f,  // R
                        0.0f, 0.0f, 0.0f, 1.0f};
      return SkM44::RowMajor(data);
    }
  }
  float Kg = 1.0f - Kr - Kb;
  float u_m = 0.5f / (1.0f - Kb);
  float v_m = 0.5f / (1.0f - Kr);
  // clang-format off
  float data[16] = {
                     Kr,        Kg,                Kb, 0.0f,  // Y
              u_m * -Kr, u_m * -Kg, u_m * (1.0f - Kb), 0.5f,  // U
      v_m * (1.0f - Kr), v_m * -Kg,         v_m * -Kb, 0.5f,  // V
                   0.0f,      0.0f,              0.0f, 1.0f,
  };
  // clang-format on
  return SkM44::RowMajor(data);
}

SkM44 ColorSpace::GetRangeAdjustMatrix(int bit_depth) const {
  DCHECK_GE(bit_depth, 8);
  switch (range_) {
    case RangeID::FULL:
    case RangeID::INVALID:
      return SkM44();

    case RangeID::DERIVED:
    case RangeID::LIMITED:
      break;
  }

  // See ITU-T H.273 (2016), Section 8.3. The following is derived from
  // Equations 20-31.
  const int shift = bit_depth - 8;
  const float a_y = 219 << shift;
  const float c = (1 << bit_depth) - 1;
  const float scale_y = c / a_y;
  switch (matrix_) {
    case MatrixID::RGB:
    case MatrixID::GBR:
    case MatrixID::INVALID:
    case MatrixID::YCOCG:
      return SkM44::Scale(scale_y, scale_y, scale_y)
          .postTranslate(-16.0f / 219.0f, -16.0f / 219.0f, -16.0f / 219.0f);

    case MatrixID::BT709:
    case MatrixID::FCC:
    case MatrixID::BT470BG:
    case MatrixID::SMPTE170M:
    case MatrixID::SMPTE240M:
    case MatrixID::BT2020_NCL:
    case MatrixID::YDZDX: {
      const float a_uv = 224 << shift;
      const float scale_uv = c / a_uv;
      const float translate_uv = (a_uv - c) / (2.0f * a_uv);
      return SkM44::Scale(scale_y, scale_uv, scale_uv)
          .postTranslate(-16.0f / 219.0f, translate_uv, translate_uv);
    }
  }
  NOTREACHED();
}

bool ColorSpace::ToSkYUVColorSpace(int bit_depth, SkYUVColorSpace* out) const {
  // There should be no usages of RGB matrix for YUV conversion.
  if (matrix_ == gfx::ColorSpace::MatrixID::RGB) {
    [[maybe_unused]] static bool call_once = [&]() {
      SCOPED_CRASH_KEY_STRING256("ToSkYUVColorSpace", "ColorSpace", ToString());
      DUMP_WILL_BE_CHECK(false)
          << "ToSkYUVColorSpace called on RGB color space = " << ToString();
      return true;
    }();
  }

  switch (matrix_) {
    case MatrixID::BT709:
      *out = range_ == RangeID::FULL ? kRec709_Full_SkYUVColorSpace
                                     : kRec709_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::BT470BG:
    case MatrixID::SMPTE170M:
      *out = range_ == RangeID::FULL ? kJPEG_SkYUVColorSpace
                                     : kRec601_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::BT2020_NCL:
      if (bit_depth <= 8) {
        *out = range_ == RangeID::FULL ? kBT2020_8bit_Full_SkYUVColorSpace
                                       : kBT2020_8bit_Limited_SkYUVColorSpace;
      } else if (bit_depth <= 10) {
        *out = range_ == RangeID::FULL ? kBT2020_10bit_Full_SkYUVColorSpace
                                       : kBT2020_10bit_Limited_SkYUVColorSpace;
      } else if (bit_depth <= 12) {
        *out = range_ == RangeID::FULL ? kBT2020_12bit_Full_SkYUVColorSpace
                                       : kBT2020_12bit_Limited_SkYUVColorSpace;
      } else {
        *out = range_ == RangeID::FULL ? kBT2020_16bit_Full_SkYUVColorSpace
                                       : kBT2020_16bit_Limited_SkYUVColorSpace;
      }
      return true;

    case MatrixID::FCC:
      *out = range_ == RangeID::FULL ? kFCC_Full_SkYUVColorSpace
                                     : kFCC_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::SMPTE240M:
      *out = range_ == RangeID::FULL ? kSMPTE240_Full_SkYUVColorSpace
                                     : kSMPTE240_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::YDZDX:
      *out = range_ == RangeID::FULL ? kYDZDX_Full_SkYUVColorSpace
                                     : kYDZDX_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::GBR:
      *out = range_ == RangeID::FULL ? kGBR_Full_SkYUVColorSpace
                                     : kGBR_Limited_SkYUVColorSpace;
      return true;

    case MatrixID::YCOCG:
      if (bit_depth <= 8) {
        *out = range_ == RangeID::FULL ? kYCgCo_8bit_Full_SkYUVColorSpace
                                       : kYCgCo_8bit_Limited_SkYUVColorSpace;
      } else if (bit_depth <= 10) {
        *out = range_ == RangeID::FULL ? kYCgCo_10bit_Full_SkYUVColorSpace
                                       : kYCgCo_10bit_Limited_SkYUVColorSpace;
      } else if (bit_depth <= 12) {
        *out = range_ == RangeID::FULL ? kYCgCo_12bit_Full_SkYUVColorSpace
                                       : kYCgCo_12bit_Limited_SkYUVColorSpace;
      } else {
        *out = range_ == RangeID::FULL ? kYCgCo_16bit_Full_SkYUVColorSpace
                                       : kYCgCo_16bit_Limited_SkYUVColorSpace;
      }
      return true;
    default:
      break;
  }
  return false;
}

std::ostream& operator<<(std::ostream& out, const ColorSpace& color_space) {
  return out << color_space.ToString();
}

}  // namespace gfx