/src/libjxl/lib/jxl/cms/jxl_cms.cc

Source
// Copyright (c) the JPEG XL Project 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 <jxl/cms.h>

#ifndef JPEGXL_ENABLE_SKCMS
#define JPEGXL_ENABLE_SKCMS 0
#endif

#include <jxl/cms_interface.h>
#include <jxl/color_encoding.h>
#include <jxl/types.h>

#include <algorithm>
#include <array>
#include <cmath>
#include <cstddef>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>
#include <vector>

#undef HWY_TARGET_INCLUDE
#define HWY_TARGET_INCLUDE "lib/jxl/cms/jxl_cms.cc"
#include <hwy/foreach_target.h>
#include <hwy/highway.h>

#include "lib/jxl/base/common.h"
#include "lib/jxl/base/compiler_specific.h"
#include "lib/jxl/base/matrix_ops.h"
#include "lib/jxl/base/printf_macros.h"
#include "lib/jxl/base/status.h"
#include "lib/jxl/cms/color_encoding_cms.h"
#include "lib/jxl/cms/jxl_cms_internal.h"
#include "lib/jxl/cms/transfer_functions-inl.h"
#include "lib/jxl/color_encoding_internal.h"
#if JPEGXL_ENABLE_SKCMS
#include "skcms.h"
#else  // JPEGXL_ENABLE_SKCMS
#include "lcms2.h"
#include "lcms2_plugin.h"
#include "lib/jxl/base/span.h"
#endif  // JPEGXL_ENABLE_SKCMS

#define JXL_CMS_VERBOSE 0

// Define these only once. We can't use HWY_ONCE here because it is defined as
// 1 only on the last pass.
#ifndef LIB_JXL_JXL_CMS_CC
#define LIB_JXL_JXL_CMS_CC

namespace jxl {
namespace {

using ::jxl::cms::ColorEncoding;

struct JxlCms {
#if JPEGXL_ENABLE_SKCMS
  IccBytes icc_src, icc_dst;
  skcms_ICCProfile profile_src, profile_dst;
#else
  void* lcms_transform;
#endif

  // These fields are used when the HLG OOTF or inverse OOTF must be applied.
  bool apply_hlg_ootf;
  size_t hlg_ootf_num_channels;
  // Y component of the primaries.
  std::array<float, 3> hlg_ootf_luminances;

  size_t channels_src;
  size_t channels_dst;

  std::vector<float> src_storage;
  std::vector<float*> buf_src;
  std::vector<float> dst_storage;
  std::vector<float*> buf_dst;

  float intensity_target;
  bool skip_lcms = false;
  ExtraTF preprocess = ExtraTF::kNone;
  ExtraTF postprocess = ExtraTF::kNone;
};

Status ApplyHlgOotf(JxlCms* t, float* JXL_RESTRICT buf, size_t xsize,
                    bool forward);
}  // namespace
}  // namespace jxl

#endif  // LIB_JXL_JXL_CMS_CC

HWY_BEFORE_NAMESPACE();
namespace jxl {
namespace HWY_NAMESPACE {

#if JXL_CMS_VERBOSE >= 2
const size_t kX = 0;  // pixel index, multiplied by 3 for RGB
#endif

// xform_src = UndoGammaCompression(buf_src).
Status BeforeTransform(JxlCms* t, const float* buf_src, float* xform_src,
                       size_t buf_size) {
  HWY_FULL(float) df;
  size_t tail = buf_size % Lanes(df);
  size_t vec_buf_end = buf_size - tail;
  switch (t->preprocess) {
    case ExtraTF::kNone:
      JXL_ENSURE(false);  // unreachable
      break;

    case ExtraTF::kPQ: {
      TF_PQ tf_pq(t->intensity_target);
      for (size_t i = 0; i < vec_buf_end; i += Lanes(df)) {
        const auto val = Load(df, buf_src + i);
        const auto result = tf_pq.DisplayFromEncoded(df, val);
        Store(result, df, xform_src + i);
      }
      if (tail != 0) {
        const auto val = LoadN(df, buf_src + vec_buf_end, tail);
        const auto result = tf_pq.DisplayFromEncoded(df, val);
        StoreN(result, df, xform_src + vec_buf_end, tail);
      }
#if JXL_CMS_VERBOSE >= 2
      printf("pre in %.4f %.4f %.4f undoPQ %.4f %.4f %.4f\n", buf_src[3 * kX],
             buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
             xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
#endif
      break;
    }

    case ExtraTF::kHLG:
      for (size_t i = 0; i < buf_size; ++i) {
        xform_src[i] = static_cast<float>(
            TF_HLG_Base::DisplayFromEncoded(static_cast<double>(buf_src[i])));
      }
      if (t->apply_hlg_ootf) {
        JXL_RETURN_IF_ERROR(
            ApplyHlgOotf(t, xform_src, buf_size, /*forward=*/true));
      }
#if JXL_CMS_VERBOSE >= 2
      printf("pre in %.4f %.4f %.4f undoHLG %.4f %.4f %.4f\n", buf_src[3 * kX],
             buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
             xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
#endif
      break;

    case ExtraTF::kSRGB:
      for (size_t i = 0; i < vec_buf_end; i += Lanes(df)) {
        const auto val = Load(df, buf_src + i);
        const auto result = TF_SRGB().DisplayFromEncoded(val);
        Store(result, df, xform_src + i);
      }
      if (tail != 0) {
        const auto val = LoadN(df, buf_src + vec_buf_end, tail);
        const auto result = TF_SRGB().DisplayFromEncoded(val);
        StoreN(result, df, xform_src + vec_buf_end, tail);
      }
#if JXL_CMS_VERBOSE >= 2
      printf("pre in %.4f %.4f %.4f undoSRGB %.4f %.4f %.4f\n", buf_src[3 * kX],
             buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
             xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
#endif
      break;
  }
  return true;
}

// Applies gamma compression in-place.
Status AfterTransform(JxlCms* t, float* JXL_RESTRICT buf_dst, size_t buf_size) {
  HWY_FULL(float) df;
  size_t tail = buf_size % Lanes(df);
  size_t vec_buf_end = buf_size - tail;
  switch (t->postprocess) {
    case ExtraTF::kNone:
      JXL_DEBUG_ABORT("Unreachable");
      break;
    case ExtraTF::kPQ: {
      TF_PQ tf_pq(t->intensity_target);
      for (size_t i = 0; i < vec_buf_end; i += Lanes(df)) {
        const auto val = Load(df, buf_dst + i);
        const auto result = tf_pq.EncodedFromDisplay(df, val);
        Store(result, df, buf_dst + i);
      }
      if (tail != 0) {
        const auto val = LoadN(df, buf_dst + vec_buf_end, tail);
        const auto result = tf_pq.EncodedFromDisplay(df, val);
        StoreN(result, df, buf_dst + vec_buf_end, tail);
      }
#if JXL_CMS_VERBOSE >= 2
      printf("after PQ enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
             buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
#endif
      break;
    }
    case ExtraTF::kHLG:
      if (t->apply_hlg_ootf) {
        JXL_RETURN_IF_ERROR(
            ApplyHlgOotf(t, buf_dst, buf_size, /*forward=*/false));
      }
      for (size_t i = 0; i < buf_size; ++i) {
        buf_dst[i] = static_cast<float>(
            TF_HLG_Base::EncodedFromDisplay(static_cast<double>(buf_dst[i])));
      }
#if JXL_CMS_VERBOSE >= 2
      printf("after HLG enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
             buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
#endif
      break;
    case ExtraTF::kSRGB:
      for (size_t i = 0; i < vec_buf_end; i += Lanes(df)) {
        const auto val = Load(df, buf_dst + i);
        const auto result = TF_SRGB().EncodedFromDisplay(df, val);
        Store(result, df, buf_dst + i);
      }
      if (tail != 0) {
        const auto val = LoadN(df, buf_dst + vec_buf_end, tail);
        const auto result = TF_SRGB().EncodedFromDisplay(df, val);
        StoreN(result, df, buf_dst + vec_buf_end, tail);
      }
#if JXL_CMS_VERBOSE >= 2
      printf("after SRGB enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
             buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
#endif
      break;
  }
  return true;
}

Status DoColorSpaceTransform(void* cms_data, const size_t thread,
                             const float* buf_src, float* buf_dst,
                             size_t xsize) {
  // No lock needed.
  JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);

  const float* xform_src = buf_src;  // Read-only.
  if (t->preprocess != ExtraTF::kNone) {
    float* mutable_xform_src = t->buf_src[thread];  // Writable buffer.
    JXL_RETURN_IF_ERROR(BeforeTransform(t, buf_src, mutable_xform_src,
                                        xsize * t->channels_src));
    xform_src = mutable_xform_src;
  }

#if JPEGXL_ENABLE_SKCMS
  if (t->channels_src == 1 && !t->skip_lcms) {
    // Expand from 1 to 3 channels, starting from the end in case
    // xform_src == t->buf_src[thread].
    float* mutable_xform_src = t->buf_src[thread];
    for (size_t i = 0; i < xsize; ++i) {
      const size_t x = xsize - i - 1;
      mutable_xform_src[x * 3] = mutable_xform_src[x * 3 + 1] =
          mutable_xform_src[x * 3 + 2] = xform_src[x];
    }
    xform_src = mutable_xform_src;
  }
#else
  if (t->channels_src == 4 && !t->skip_lcms) {
    // LCMS does CMYK in a weird way: 0 = white, 100 = max ink
    float* mutable_xform_src = t->buf_src[thread];
    for (size_t x = 0; x < xsize * 4; ++x) {
      mutable_xform_src[x] = 100.f - 100.f * mutable_xform_src[x];
    }
    xform_src = mutable_xform_src;
  }
#endif

#if JXL_CMS_VERBOSE >= 2
  // Save inputs for printing before in-place transforms overwrite them.
  const float in0 = xform_src[3 * kX + 0];
  const float in1 = xform_src[3 * kX + 1];
  const float in2 = xform_src[3 * kX + 2];
#endif

  if (t->skip_lcms) {
    if (buf_dst != xform_src) {
      memcpy(buf_dst, xform_src, xsize * t->channels_src * sizeof(*buf_dst));
    }  // else: in-place, no need to copy
  } else {
#if JPEGXL_ENABLE_SKCMS
    float* xform_dst = (t->channels_dst == 1) ? t->buf_dst[thread] : buf_dst;
    JXL_ENSURE(
        skcms_Transform(xform_src,
                        (t->channels_src == 4 ? skcms_PixelFormat_RGBA_ffff
                                              : skcms_PixelFormat_RGB_fff),
                        skcms_AlphaFormat_Opaque, &t->profile_src, xform_dst,
                        skcms_PixelFormat_RGB_fff, skcms_AlphaFormat_Opaque,
                        &t->profile_dst, xsize));
    if (t->channels_dst == 1) {
      // Contract back from 3 to 1 channel, this time forward.
      for (size_t x = 0; x < xsize; ++x) {
        buf_dst[x] = xform_dst[x * 3];
      }
    }
#else   // JPEGXL_ENABLE_SKCMS
    cmsDoTransform(t->lcms_transform, xform_src, buf_dst,
                   static_cast<cmsUInt32Number>(xsize));
#endif  // JPEGXL_ENABLE_SKCMS
  }
#if JXL_CMS_VERBOSE >= 2
  printf("xform skip%d: %.4f %.4f %.4f (%p) -> (%p) %.4f %.4f %.4f\n",
         t->skip_lcms, in0, in1, in2, xform_src, buf_dst, buf_dst[3 * kX],
         buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
#endif

  if (t->postprocess != ExtraTF::kNone) {
    JXL_RETURN_IF_ERROR(AfterTransform(t, buf_dst, xsize * t->channels_dst));
  }
  return true;
}

// NOLINTNEXTLINE(google-readability-namespace-comments)
}  // namespace HWY_NAMESPACE
}  // namespace jxl
HWY_AFTER_NAMESPACE();

#if HWY_ONCE
namespace jxl {
namespace {

HWY_EXPORT(DoColorSpaceTransform);
int DoColorSpaceTransform(void* t, size_t thread, const float* buf_src,
                          float* buf_dst, size_t xsize) {
  return HWY_DYNAMIC_DISPATCH(DoColorSpaceTransform)(t, thread, buf_src,
                                                     buf_dst, xsize);
}

// Define to 1 on OS X as a workaround for older LCMS lacking MD5.
#define JXL_CMS_OLD_VERSION 0

#if JPEGXL_ENABLE_SKCMS

JXL_MUST_USE_RESULT CIExy CIExyFromXYZ(const Color& XYZ) {
  const double factor = 1.0 / static_cast<double>(XYZ[0] + XYZ[1] + XYZ[2]);
  CIExy xy;
  xy.x = XYZ[0] * factor;
  xy.y = XYZ[1] * factor;
  return xy;
}

#else  // JPEGXL_ENABLE_SKCMS
// (LCMS interface requires xyY but we omit the Y for white points/primaries.)

JXL_MUST_USE_RESULT CIExy CIExyFromxyY(const cmsCIExyY& xyY) {
  CIExy xy;
  xy.x = xyY.x;
  xy.y = xyY.y;
  return xy;
}

JXL_MUST_USE_RESULT CIExy CIExyFromXYZ(const cmsCIEXYZ& XYZ) {
  cmsCIExyY xyY;
  cmsXYZ2xyY(/*Dest=*/&xyY, /*Source=*/&XYZ);
  return CIExyFromxyY(xyY);
}

JXL_MUST_USE_RESULT cmsCIEXYZ D50_XYZ() {
  // Quantized D50 as stored in ICC profiles.
  return {0.96420288, 1.0, 0.82490540};
}

// RAII

struct ContextDeleter {
  void operator()(void* p) { cmsDeleteContext(static_cast<cmsContext>(p)); }
};
using Context = std::unique_ptr<void, ContextDeleter>;

struct ProfileDeleter {
  void operator()(void* p) { cmsCloseProfile(p); }
};
using Profile = std::unique_ptr<void, ProfileDeleter>;

struct TransformDeleter {
  void operator()(void* p) { cmsDeleteTransform(p); }
};
using Transform = std::unique_ptr<void, TransformDeleter>;

struct CurveDeleter {
  void operator()(cmsToneCurve* p) { cmsFreeToneCurve(p); }
};
using Curve = std::unique_ptr<cmsToneCurve, CurveDeleter>;

Status CreateProfileXYZ(const cmsContext context,
                        Profile* JXL_RESTRICT profile) {
  profile->reset(cmsCreateXYZProfileTHR(context));
  if (profile->get() == nullptr) return JXL_FAILURE("Failed to create XYZ");
  return true;
}

#endif  // !JPEGXL_ENABLE_SKCMS

#if JPEGXL_ENABLE_SKCMS
// IMPORTANT: icc must outlive profile.
Status DecodeProfile(const uint8_t* icc, size_t size,
                     skcms_ICCProfile* const profile) {
  if (!skcms_Parse(icc, size, profile)) {
    return JXL_FAILURE("Failed to parse ICC profile with %" PRIuS " bytes",
                       size);
  }
  return true;
}
#else   // JPEGXL_ENABLE_SKCMS
Status DecodeProfile(const cmsContext context, Span<const uint8_t> icc,
                     Profile* profile) {
  profile->reset(cmsOpenProfileFromMemTHR(context, icc.data(), icc.size()));
  if (profile->get() == nullptr) {
    return JXL_FAILURE("Failed to decode profile");
  }

  // WARNING: due to the LCMS MD5 issue mentioned above, many existing
  // profiles have incorrect MD5, so do not even bother checking them nor
  // generating warning clutter.

  return true;
}
#endif  // JPEGXL_ENABLE_SKCMS

#if JPEGXL_ENABLE_SKCMS

ColorSpace ColorSpaceFromProfile(const skcms_ICCProfile& profile) {
  switch (profile.data_color_space) {
    case skcms_Signature_RGB:
    case skcms_Signature_CMYK:
      // spec says CMYK is encoded as RGB (the kBlack extra channel signals that
      // it is actually CMYK)
      return ColorSpace::kRGB;
    case skcms_Signature_Gray:
      return ColorSpace::kGray;
    default:
      return ColorSpace::kUnknown;
  }
}

// vector_out := matmul(matrix, vector_in)
void MatrixProduct(const skcms_Matrix3x3& matrix, const Color& vector_in,
                   Color& vector_out) {
  for (int i = 0; i < 3; ++i) {
    vector_out[i] = 0;
    for (int j = 0; j < 3; ++j) {
      vector_out[i] += matrix.vals[i][j] * vector_in[j];
    }
  }
}

bool IsAcceptableCHAD(const skcms_Matrix3x3& chad) {
  Matrix3x3d chad_double;
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < 3; ++j) {
      chad_double[i][j] = chad.vals[i][j];
    }
  }
  return Inv3x3Matrix(chad_double);
}

bool HasICCVersion4DisplayClass(const skcms_ICCProfile& profile) {
  return profile.buffer != nullptr && profile.size >= 128 &&
         profile.buffer[8] == 4 && profile.buffer[12] == 'm' &&
         profile.buffer[13] == 'n' && profile.buffer[14] == 't' &&
         profile.buffer[15] == 'r' && profile.buffer[36] == 'a' &&
         profile.buffer[37] == 'c' && profile.buffer[38] == 's' &&
         profile.buffer[39] == 'p';
}

bool HasTag(const skcms_ICCProfile& profile, const char* signature) {
  constexpr size_t kTagCountOffset = 128;
  constexpr size_t kTagTableOffset = 132;
  constexpr size_t kTagRecordSize = 12;
  if (profile.buffer == nullptr || profile.size < kTagCountOffset + 4) {
    return false;
  }
  const uint32_t tag_count =
      (static_cast<uint32_t>(profile.buffer[kTagCountOffset]) << 24) |
      (static_cast<uint32_t>(profile.buffer[kTagCountOffset + 1]) << 16) |
      (static_cast<uint32_t>(profile.buffer[kTagCountOffset + 2]) << 8) |
      static_cast<uint32_t>(profile.buffer[kTagCountOffset + 3]);
  if (tag_count > (profile.size - kTagTableOffset) / kTagRecordSize) {
    return false;
  }
  for (uint32_t i = 0; i < tag_count; ++i) {
    const size_t offset = kTagTableOffset + kTagRecordSize * i;
    if (std::memcmp(profile.buffer + offset, signature, 4) == 0) {
      return true;
    }
  }
  return false;
}

bool HasLUTTags(const skcms_ICCProfile& profile) {
  for (const char* signature :
       {"A2B0", "A2B1", "A2B2", "B2A0", "B2A1", "B2A2", "D2B0", "D2B1", "D2B2",
        "D2B3", "B2D0", "B2D1", "B2D2", "B2D3"}) {
    if (HasTag(profile, signature)) return true;
  }
  return false;
}

bool HasParametricTRCs(const skcms_ICCProfile& profile) {
  return profile.trc[0].table_entries == 0 &&
         profile.trc[1].table_entries == 0 && profile.trc[2].table_entries == 0;
}

bool IsApproximatelyD50(const Color& XYZ) {
  static constexpr Color kD50XYZ{0.96420288f, 1.0f, 0.82490540f};
  constexpr float kTolerance = 1e-3f;
  return std::abs(XYZ[0] - kD50XYZ[0]) < kTolerance &&
         std::abs(XYZ[1] - kD50XYZ[1]) < kTolerance &&
         std::abs(XYZ[2] - kD50XYZ[2]) < kTolerance;
}

bool GetNonconformingMatrixProfileWhitePoint(const skcms_ICCProfile& profile,
                                             const Color& media_white_point_XYZ,
                                             Color& adapted_white_point_XYZ) {
  // Some v4 display profiles contain a CHAD but retain the pre-v4 media
  // white point. For a matrix/TRC profile, the colorant column sum is the
  // adapted neutral and is a more reliable source for undoing that CHAD.
  if (!HasICCVersion4DisplayClass(profile) ||
      profile.data_color_space != skcms_Signature_RGB ||
      profile.pcs != skcms_Signature_XYZ || !profile.has_trc ||
      !profile.has_toXYZD50 || !HasTag(profile, "chad") ||
      HasLUTTags(profile) || IsApproximatelyD50(media_white_point_XYZ)) {
    return false;
  }
  Color matrix_white_point_XYZ;
  for (int i = 0; i < 3; ++i) {
    matrix_white_point_XYZ[i] = profile.toXYZD50.vals[i][0] +
                                profile.toXYZD50.vals[i][1] +
                                profile.toXYZD50.vals[i][2];
  }
  if (!IsApproximatelyD50(matrix_white_point_XYZ)) return false;
  adapted_white_point_XYZ = matrix_white_point_XYZ;
  return true;
}

bool RecoverMatrixProfileWhitePoint(const skcms_ICCProfile& profile,
                                    const Color& media_white_point_XYZ,
                                    Color& adapted_white_point_XYZ) {
  skcms_Matrix3x3 CHAD;
  return HasParametricTRCs(profile) &&
         GetNonconformingMatrixProfileWhitePoint(profile, media_white_point_XYZ,
                                                 adapted_white_point_XYZ) &&
         skcms_GetCHAD(&profile, &CHAD) && IsAcceptableCHAD(CHAD);
}

// Returns white point that was specified when creating the profile.
JXL_MUST_USE_RESULT Status UnadaptedWhitePoint(const skcms_ICCProfile& profile,
                                               CIExy* out) {
  Color media_white_point_XYZ;
  if (!skcms_GetWTPT(&profile, media_white_point_XYZ.data())) {
    return JXL_FAILURE("ICC profile does not contain WhitePoint tag");
  }
  skcms_Matrix3x3 CHAD;
  if (!skcms_GetCHAD(&profile, &CHAD)) {
    // If there is no chromatic adaptation matrix, it means that the white point
    // is already unadapted.
    *out = CIExyFromXYZ(media_white_point_XYZ);
    return true;
  }
  Color adapted_white_point_XYZ;
  if (RecoverMatrixProfileWhitePoint(profile, media_white_point_XYZ,
                                     adapted_white_point_XYZ)) {
    media_white_point_XYZ = adapted_white_point_XYZ;
  }
  // The media white point is expressed in the PCS after the chromatic
  // adaptation in the profile. Undo that adaptation to recover the source
  // white point. The compatibility path above replaces the inconsistent media
  // white point with the adapted neutral before applying the same operation.
  skcms_Matrix3x3 inverse_CHAD;
  if (!skcms_Matrix3x3_invert(&CHAD, &inverse_CHAD)) {
    return JXL_FAILURE("Non-invertible ChromaticAdaptation matrix");
  }
  Color unadapted_white_point_XYZ;
  MatrixProduct(inverse_CHAD, media_white_point_XYZ, unadapted_white_point_XYZ);
  *out = CIExyFromXYZ(unadapted_white_point_XYZ);
  return true;
}

Status IdentifyPrimaries(const skcms_ICCProfile& profile,
                         const CIExy& wp_unadapted, ColorEncoding* c) {
  if (!c->HasPrimaries()) return true;

  skcms_Matrix3x3 CHAD;
  skcms_Matrix3x3 inverse_CHAD;
  if (skcms_GetCHAD(&profile, &CHAD)) {
    JXL_RETURN_IF_ERROR(skcms_Matrix3x3_invert(&CHAD, &inverse_CHAD));
  } else {
    static constexpr skcms_Matrix3x3 kLMSFromXYZ = {
        {{0.8951, 0.2664, -0.1614},
         {-0.7502, 1.7135, 0.0367},
         {0.0389, -0.0685, 1.0296}}};
    static constexpr skcms_Matrix3x3 kXYZFromLMS = {
        {{0.9869929, -0.1470543, 0.1599627},
         {0.4323053, 0.5183603, 0.0492912},
         {-0.0085287, 0.0400428, 0.9684867}}};
    static constexpr Color kWpD50XYZ{0.96420288, 1.0, 0.82490540};
    Color wp_unadapted_XYZ;
    JXL_RETURN_IF_ERROR(
        CIEXYZFromWhiteCIExy(wp_unadapted.x, wp_unadapted.y, wp_unadapted_XYZ));
    Color wp_D50_LMS;
    Color wp_unadapted_LMS;
    MatrixProduct(kLMSFromXYZ, kWpD50XYZ, wp_D50_LMS);
    MatrixProduct(kLMSFromXYZ, wp_unadapted_XYZ, wp_unadapted_LMS);
    inverse_CHAD = {{{wp_unadapted_LMS[0] / wp_D50_LMS[0], 0, 0},
                     {0, wp_unadapted_LMS[1] / wp_D50_LMS[1], 0},
                     {0, 0, wp_unadapted_LMS[2] / wp_D50_LMS[2]}}};
    inverse_CHAD = skcms_Matrix3x3_concat(&kXYZFromLMS, &inverse_CHAD);
    inverse_CHAD = skcms_Matrix3x3_concat(&inverse_CHAD, &kLMSFromXYZ);
  }

  Color XYZ;
  PrimariesCIExy primaries;
  CIExy* const chromaticities[] = {&primaries.r, &primaries.g, &primaries.b};
  for (int i = 0; i < 3; ++i) {
    float RGB[3] = {};
    RGB[i] = 1;
    skcms_Transform(RGB, skcms_PixelFormat_RGB_fff, skcms_AlphaFormat_Opaque,
                    &profile, XYZ.data(), skcms_PixelFormat_RGB_fff,
                    skcms_AlphaFormat_Opaque, skcms_XYZD50_profile(), 1);
    Color unadapted_XYZ;
    MatrixProduct(inverse_CHAD, XYZ, unadapted_XYZ);
    *chromaticities[i] = CIExyFromXYZ(unadapted_XYZ);
  }
  return c->SetPrimaries(primaries);
}

bool IsApproximatelyEqual(const skcms_ICCProfile& profile,
                          const ColorEncoding& JXL_RESTRICT c) {
  IccBytes bytes;
  if (!MaybeCreateProfile(c.ToExternal(), &bytes)) {
    return false;
  }

  skcms_ICCProfile profile_test;
  if (!DecodeProfile(bytes.data(), bytes.size(), &profile_test)) {
    return false;
  }

  if (!skcms_ApproximatelyEqualProfiles(&profile_test, &profile)) {
    return false;
  }

  return true;
}

Status DetectTransferFunction(const skcms_ICCProfile& profile,
                              ColorEncoding* JXL_RESTRICT c) {
  JXL_ENSURE(c->color_space != ColorSpace::kXYB);

  Color media_white_point_XYZ;
  Color adapted_white_point_XYZ;
  if (!HasParametricTRCs(profile) &&
      skcms_GetWTPT(&profile, media_white_point_XYZ.data()) &&
      GetNonconformingMatrixProfileWhitePoint(profile, media_white_point_XYZ,
                                              adapted_white_point_XYZ)) {
    c->tf.SetTransferFunction(TransferFunction::kUnknown);
    return true;
  }

  float gamma[3] = {};
  if (profile.has_trc) {
    const auto IsGamma = [](const skcms_TransferFunction& tf) {
      return tf.a == 1 && tf.b == 0 &&
             /* if b and d are zero, it is fine for c not to be */ tf.d == 0 &&
             tf.e == 0 && tf.f == 0;
    };
    for (int i = 0; i < 3; ++i) {
      if (profile.trc[i].table_entries == 0 &&
          IsGamma(profile.trc->parametric)) {
        gamma[i] = 1.f / profile.trc->parametric.g;
      } else {
        skcms_TransferFunction approximate_tf;
        float max_error;
        if (skcms_ApproximateCurve(&profile.trc[i], &approximate_tf,
                                   &max_error)) {
          if (IsGamma(approximate_tf)) {
            gamma[i] = 1.f / approximate_tf.g;
          }
        }
      }
    }
  }
  if (gamma[0] != 0 && std::abs(gamma[0] - gamma[1]) < 1e-4f &&
      std::abs(gamma[1] - gamma[2]) < 1e-4f) {
    if (c->tf.SetGamma(gamma[0])) {
      if (IsApproximatelyEqual(profile, *c)) return true;
    }
  }

  for (TransferFunction tf : Values<TransferFunction>()) {
    // Can only create profile from known transfer function.
    if (tf == TransferFunction::kUnknown) continue;
    c->tf.SetTransferFunction(tf);
    if (IsApproximatelyEqual(profile, *c)) return true;
  }

  c->tf.SetTransferFunction(TransferFunction::kUnknown);
  return true;
}

#else  // JPEGXL_ENABLE_SKCMS

uint32_t Type32(const ColorEncoding& c, bool cmyk) {
  if (cmyk) return TYPE_CMYK_FLT;
  if (c.color_space == ColorSpace::kGray) return TYPE_GRAY_FLT;
  return TYPE_RGB_FLT;
}

uint32_t Type64(const ColorEncoding& c) {
  if (c.color_space == ColorSpace::kGray) return TYPE_GRAY_DBL;
  return TYPE_RGB_DBL;
}

ColorSpace ColorSpaceFromProfile(const Profile& profile) {
  switch (cmsGetColorSpace(profile.get())) {
    case cmsSigRgbData:
    case cmsSigCmykData:
      return ColorSpace::kRGB;
    case cmsSigGrayData:
      return ColorSpace::kGray;
    default:
      return ColorSpace::kUnknown;
  }
}

// "profile1" is pre-decoded to save time in DetectTransferFunction.
constexpr double kIccEquivalenceTolerance = 2E-4;
constexpr double kLegacyMatrixProfileEquivalenceTolerance = 3E-4;

Status ProfileEquivalentToICC(const cmsContext context, const Profile& profile1,
                              const IccBytes& icc, const ColorEncoding& c,
                              const double tolerance) {
  const uint32_t type_src = Type64(c);

  Profile profile2;
  JXL_RETURN_IF_ERROR(DecodeProfile(context, Bytes(icc), &profile2));

  Profile profile_xyz;
  JXL_RETURN_IF_ERROR(CreateProfileXYZ(context, &profile_xyz));

  const uint32_t intent = INTENT_RELATIVE_COLORIMETRIC;
  const uint32_t flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_BLACKPOINTCOMPENSATION |
                         cmsFLAGS_HIGHRESPRECALC;
  Transform xform1(cmsCreateTransformTHR(context, profile1.get(), type_src,
                                         profile_xyz.get(), TYPE_XYZ_DBL,
                                         intent, flags));
  Transform xform2(cmsCreateTransformTHR(context, profile2.get(), type_src,
                                         profile_xyz.get(), TYPE_XYZ_DBL,
                                         intent, flags));
  if (xform1 == nullptr || xform2 == nullptr) {
    return JXL_FAILURE("Failed to create transform");
  }

  double in[3];
  double out1[3];
  double out2[3];

  // Uniformly spaced samples from very dark to almost fully bright.
  const double init = 1E-3;
  const double step = 0.2;

  if (c.color_space == ColorSpace::kGray) {
    // Finer sampling and replicate each component.
    for (in[0] = init; in[0] < 1.0; in[0] += step / 8) {
      cmsDoTransform(xform1.get(), in, out1, 1);
      cmsDoTransform(xform2.get(), in, out2, 1);
      if (!cms::ApproxEq(out1[0], out2[0], tolerance)) {
        return false;
      }
    }
  } else {
    for (in[0] = init; in[0] < 1.0; in[0] += step) {
      for (in[1] = init; in[1] < 1.0; in[1] += step) {
        for (in[2] = init; in[2] < 1.0; in[2] += step) {
          cmsDoTransform(xform1.get(), in, out1, 1);
          cmsDoTransform(xform2.get(), in, out2, 1);
          for (size_t i = 0; i < 3; ++i) {
            if (!cms::ApproxEq(out1[i], out2[i], tolerance)) {
              return false;
            }
          }
        }
      }
    }
  }

  return true;
}

bool HasLUTTags(const Profile& profile) {
  for (const auto tag :
       {cmsSigAToB0Tag, cmsSigAToB1Tag, cmsSigAToB2Tag, cmsSigBToA0Tag,
        cmsSigBToA1Tag, cmsSigBToA2Tag, cmsSigDToB0Tag, cmsSigDToB1Tag,
        cmsSigDToB2Tag, cmsSigDToB3Tag, cmsSigBToD0Tag, cmsSigBToD1Tag,
        cmsSigBToD2Tag, cmsSigBToD3Tag}) {
    if (cmsIsTag(profile.get(), tag)) return true;
  }
  return false;
}

bool HasParametricTRCs(const Profile& profile) {
  for (const auto tag :
       {cmsSigRedTRCTag, cmsSigGreenTRCTag, cmsSigBlueTRCTag}) {
    const auto* trc =
        static_cast<const cmsToneCurve*>(cmsReadTag(profile.get(), tag));
    if (trc == nullptr || cmsGetToneCurveParametricType(trc) <= 0) return false;
  }
  return true;
}

bool IsApproximatelyD50(const cmsCIEXYZ& XYZ) {
  const cmsCIEXYZ d50 = D50_XYZ();
  constexpr cmsFloat64Number kTolerance = 1e-3;
  return std::abs(XYZ.X - d50.X) < kTolerance &&
         std::abs(XYZ.Y - d50.Y) < kTolerance &&
         std::abs(XYZ.Z - d50.Z) < kTolerance;
}

bool GetInverseCHAD(const Profile& profile, Matrix3x3d* inverse_chad) {
  const cmsMAT3* chad = static_cast<const cmsMAT3*>(
      cmsReadTag(profile.get(), cmsSigChromaticAdaptationTag));
  if (chad == nullptr) return false;
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < 3; ++j) {
      (*inverse_chad)[i][j] = chad->v[i].n[j];
    }
  }
  return Inv3x3Matrix(*inverse_chad);
}

bool GetNonconformingMatrixProfileWhitePoint(const Profile& profile,
                                             const cmsCIEXYZ& media_white_point,
                                             cmsCIEXYZ* matrix_white_point) {
  const double version = cmsGetProfileVersion(profile.get());
  if (version < 4.0 || version >= 5.0 ||
      cmsGetDeviceClass(profile.get()) != cmsSigDisplayClass ||
      cmsGetColorSpace(profile.get()) != cmsSigRgbData ||
      cmsGetPCS(profile.get()) != cmsSigXYZData ||
      cmsReadTag(profile.get(), cmsSigRedColorantTag) == nullptr ||
      cmsReadTag(profile.get(), cmsSigGreenColorantTag) == nullptr ||
      cmsReadTag(profile.get(), cmsSigBlueColorantTag) == nullptr ||
      cmsReadTag(profile.get(), cmsSigRedTRCTag) == nullptr ||
      cmsReadTag(profile.get(), cmsSigGreenTRCTag) == nullptr ||
      cmsReadTag(profile.get(), cmsSigBlueTRCTag) == nullptr ||
      HasLUTTags(profile) || IsApproximatelyD50(media_white_point)) {
    return false;
  }

  const cmsCIEXYZ* adapted_r = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigRedColorantTag));
  const cmsCIEXYZ* adapted_g = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigGreenColorantTag));
  const cmsCIEXYZ* adapted_b = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigBlueColorantTag));
  *matrix_white_point = {adapted_r->X + adapted_g->X + adapted_b->X,
                         adapted_r->Y + adapted_g->Y + adapted_b->Y,
                         adapted_r->Z + adapted_g->Z + adapted_b->Z};
  return IsApproximatelyD50(*matrix_white_point);
}

bool RecoverMatrixProfileWhitePoint(const Profile& profile,
                                    const cmsCIEXYZ& media_white_point,
                                    cmsCIEXYZ* unadapted_white_point) {
  cmsCIEXYZ matrix_white_point;
  if (!HasParametricTRCs(profile) ||
      !GetNonconformingMatrixProfileWhitePoint(profile, media_white_point,
                                               &matrix_white_point)) {
    return false;
  }

  Matrix3x3d inverse_chad = {};
  if (!GetInverseCHAD(profile, &inverse_chad)) return false;
  const Vector3d adapted = {matrix_white_point.X, matrix_white_point.Y,
                            matrix_white_point.Z};
  Vector3d unadapted = {};
  Mul3x3Vector(inverse_chad, adapted, unadapted);
  unadapted_white_point->X = unadapted[0];
  unadapted_white_point->Y = unadapted[1];
  unadapted_white_point->Z = unadapted[2];
  return true;
}

bool HasNonconformingMatrixProfileShape(const Profile& profile) {
  const cmsCIEXYZ* white_point = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigMediaWhitePointTag));
  const cmsMAT3* chad = static_cast<const cmsMAT3*>(
      cmsReadTag(profile.get(), cmsSigChromaticAdaptationTag));
  cmsCIEXYZ matrix_white_point;
  return white_point != nullptr && chad != nullptr &&
         GetNonconformingMatrixProfileWhitePoint(profile, *white_point,
                                                 &matrix_white_point);
}

bool IsMatrixProfileWithNonconformingWhitePoint(const Profile& profile) {
  Matrix3x3d inverse_chad = {};
  return HasNonconformingMatrixProfileShape(profile) &&
         GetInverseCHAD(profile, &inverse_chad);
}

// Returns white point that was specified when creating the profile.
// NOTE: we can't just use cmsSigMediaWhitePointTag because its interpretation
// differs between ICC versions.
JXL_MUST_USE_RESULT cmsCIEXYZ UnadaptedWhitePoint(const cmsContext context,
                                                  const Profile& profile,
                                                  const ColorEncoding& c) {
  const cmsCIEXYZ* white_point = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigMediaWhitePointTag));
  const cmsMAT3* chad = static_cast<const cmsMAT3*>(
      cmsReadTag(profile.get(), cmsSigChromaticAdaptationTag));
  if (white_point != nullptr && chad == nullptr) {
    // No chromatic adaptation matrix: the white point is already unadapted.
    return *white_point;
  }
  if (white_point != nullptr && chad != nullptr) {
    cmsCIEXYZ unadapted_white_point;
    if (RecoverMatrixProfileWhitePoint(profile, *white_point,
                                       &unadapted_white_point)) {
      return unadapted_white_point;
    }
  }

  cmsCIEXYZ XYZ = {1.0, 1.0, 1.0};
  Profile profile_xyz;
  if (!CreateProfileXYZ(context, &profile_xyz)) return XYZ;
  // Array arguments are one per profile.
  cmsHPROFILE profiles[2] = {profile.get(), profile_xyz.get()};
  // Leave white point unchanged - that is what we're trying to extract.
  cmsUInt32Number intents[2] = {INTENT_ABSOLUTE_COLORIMETRIC,
                                INTENT_ABSOLUTE_COLORIMETRIC};
  cmsBool black_compensation[2] = {0, 0};
  cmsFloat64Number adaption[2] = {0.0, 0.0};
  // Only transforming a single pixel, so skip expensive optimizations.
  cmsUInt32Number flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_HIGHRESPRECALC;
  Transform xform(cmsCreateExtendedTransform(
      context, 2, profiles, black_compensation, intents, adaption, nullptr, 0,
      Type64(c), TYPE_XYZ_DBL, flags));
  if (!xform) return XYZ;  // TODO(lode): return error

  // xy are relative, so magnitude does not matter if we ignore output Y.
  const cmsFloat64Number in[3] = {1.0, 1.0, 1.0};
  cmsDoTransform(xform.get(), in, &XYZ.X, 1);
  return XYZ;
}

Status IdentifyPrimaries(const cmsContext context, const Profile& profile,
                         const cmsCIEXYZ& wp_unadapted, ColorEncoding* c) {
  if (!c->HasPrimaries()) return true;
  if (ColorSpaceFromProfile(profile) == ColorSpace::kUnknown) return true;

  // These were adapted to the profile illuminant before storing in the profile.
  const cmsCIEXYZ* adapted_r = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigRedColorantTag));
  const cmsCIEXYZ* adapted_g = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigGreenColorantTag));
  const cmsCIEXYZ* adapted_b = static_cast<const cmsCIEXYZ*>(
      cmsReadTag(profile.get(), cmsSigBlueColorantTag));

  cmsCIEXYZ converted_rgb[3];
  if (adapted_r == nullptr || adapted_g == nullptr || adapted_b == nullptr) {
    // No colorant tag, determine the XYZ coordinates of the primaries by
    // converting from the colorspace.
    Profile profile_xyz;
    if (!CreateProfileXYZ(context, &profile_xyz)) {
      return JXL_FAILURE("Failed to retrieve colorants");
    }
    // Array arguments are one per profile.
    cmsHPROFILE profiles[2] = {profile.get(), profile_xyz.get()};
    cmsUInt32Number intents[2] = {INTENT_RELATIVE_COLORIMETRIC,
                                  INTENT_RELATIVE_COLORIMETRIC};
    cmsBool black_compensation[2] = {0, 0};
    cmsFloat64Number adaption[2] = {0.0, 0.0};
    // Only transforming three pixels, so skip expensive optimizations.
    cmsUInt32Number flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_HIGHRESPRECALC;
    Transform xform(cmsCreateExtendedTransform(
        context, 2, profiles, black_compensation, intents, adaption, nullptr, 0,
        Type64(*c), TYPE_XYZ_DBL, flags));
    if (!xform) return JXL_FAILURE("Failed to retrieve colorants");

    const cmsFloat64Number in[9] = {1.0, 0.0, 0.0, 0.0, 1.0,
                                    0.0, 0.0, 0.0, 1.0};
    cmsDoTransform(xform.get(), in, &converted_rgb->X, 3);
    adapted_r = &converted_rgb[0];
    adapted_g = &converted_rgb[1];
    adapted_b = &converted_rgb[2];
  }

  cmsCIEXYZ r, g, b;
  Matrix3x3d inverse_chad = {};
  if (HasParametricTRCs(profile) &&
      IsMatrixProfileWithNonconformingWhitePoint(profile) &&
      GetInverseCHAD(profile, &inverse_chad)) {
    const cmsCIEXYZ* adapted[] = {adapted_r, adapted_g, adapted_b};
    cmsCIEXYZ* unadapted[] = {&r, &g, &b};
    for (size_t i = 0; i < 3; ++i) {
      const Vector3d in = {adapted[i]->X, adapted[i]->Y, adapted[i]->Z};
      Vector3d out = {};
      Mul3x3Vector(inverse_chad, in, out);
      *unadapted[i] = {out[0], out[1], out[2]};
    }
  } else {
    // TODO(janwas): no longer assume Bradford and D50 for other profiles.
    const cmsCIEXYZ d50 = D50_XYZ();
    cmsAdaptToIlluminant(&r, &d50, &wp_unadapted, adapted_r);
    cmsAdaptToIlluminant(&g, &d50, &wp_unadapted, adapted_g);
    cmsAdaptToIlluminant(&b, &d50, &wp_unadapted, adapted_b);
  }

  const PrimariesCIExy rgb = {CIExyFromXYZ(r), CIExyFromXYZ(g),
                              CIExyFromXYZ(b)};
  return c->SetPrimaries(rgb);
}

Status DetectTransferFunction(const cmsContext context, const Profile& profile,
                              ColorEncoding* JXL_RESTRICT c) {
  JXL_ENSURE(c->color_space != ColorSpace::kXYB);

  const bool nonconforming_matrix_profile =
      HasNonconformingMatrixProfileShape(profile);
  const bool compatibility_profile =
      IsMatrixProfileWithNonconformingWhitePoint(profile);
  if (nonconforming_matrix_profile &&
      (!compatibility_profile || !HasParametricTRCs(profile))) {
    c->tf.SetTransferFunction(TransferFunction::kUnknown);
    return true;
  }
  // Matrix/TRC coefficients and the canonical D50 white point are quantized
  // independently in ICC. Allow that small difference for this compatibility
  // case while retaining the functional equivalence check.
  const double equivalence_tolerance =
      compatibility_profile ? kLegacyMatrixProfileEquivalenceTolerance
                            : kIccEquivalenceTolerance;

  float gamma = 0;
  if (const auto* gray_trc = reinterpret_cast<const cmsToneCurve*>(
          cmsReadTag(profile.get(), cmsSigGrayTRCTag))) {
    const double estimated_gamma =
        cmsEstimateGamma(gray_trc, /*precision=*/1e-4);
    if (estimated_gamma > 0) {
      gamma = 1. / estimated_gamma;
    }
  } else {
    float rgb_gamma[3] = {};
    int i = 0;
    for (const auto tag :
         {cmsSigRedTRCTag, cmsSigGreenTRCTag, cmsSigBlueTRCTag}) {
      if (const auto* trc = reinterpret_cast<const cmsToneCurve*>(
              cmsReadTag(profile.get(), tag))) {
        const double estimated_gamma =
            cmsEstimateGamma(trc, /*precision=*/1e-4);
        if (estimated_gamma > 0) {
          rgb_gamma[i] = 1. / estimated_gamma;
        }
      }
      ++i;
    }
    if (rgb_gamma[0] != 0 && std::abs(rgb_gamma[0] - rgb_gamma[1]) < 1e-4f &&
        std::abs(rgb_gamma[1] - rgb_gamma[2]) < 1e-4f) {
      gamma = rgb_gamma[0];
    }
  }

  if (gamma != 0 && c->tf.SetGamma(gamma)) {
    IccBytes icc_test;
    if (MaybeCreateProfile(c->ToExternal(), &icc_test) &&
        ProfileEquivalentToICC(context, profile, icc_test, *c,
                               equivalence_tolerance)) {
      return true;
    }
  }

  for (TransferFunction tf : Values<TransferFunction>()) {
    // Can only create profile from known transfer function.
    if (tf == TransferFunction::kUnknown) continue;

    c->tf.SetTransferFunction(tf);

    IccBytes icc_test;
    if (MaybeCreateProfile(c->ToExternal(), &icc_test) &&
        ProfileEquivalentToICC(context, profile, icc_test, *c,
                               equivalence_tolerance)) {
      return true;
    }
  }

  c->tf.SetTransferFunction(TransferFunction::kUnknown);
  return true;
}

void ErrorHandler(cmsContext context, cmsUInt32Number code, const char* text) {
  JXL_WARNING("LCMS error %u: %s", code, text);
}

// Returns a context for the current thread, creating it if necessary.
cmsContext GetContext() {
  static thread_local Context context_;
  if (context_ == nullptr) {
    context_.reset(cmsCreateContext(nullptr, nullptr));
    JXL_DASSERT(context_ != nullptr);

    cmsSetLogErrorHandlerTHR(static_cast<cmsContext>(context_.get()),
                             &ErrorHandler);
  }
  return static_cast<cmsContext>(context_.get());
}

#endif  // JPEGXL_ENABLE_SKCMS

Status GetPrimariesLuminances(const ColorEncoding& encoding,
                              float luminances[3]) {
  // Explanation:
  // We know that the three primaries must sum to white:
  //
  // [Xr, Xg, Xb;     [1;     [Xw;
  //  Yr, Yg, Yb;  ×   1;  =   Yw;
  //  Zr, Zg, Zb]      1]      Zw]
  //
  // By noting that X = x·(X+Y+Z), Y = y·(X+Y+Z) and Z = z·(X+Y+Z) (note the
  // lower case indicating chromaticity), and factoring the totals (X+Y+Z) out
  // of the left matrix and into the all-ones vector, we get:
  //
  // [xr, xg, xb;     [Xr + Yr + Zr;     [Xw;
  //  yr, yg, yb;  ×   Xg + Yg + Zg;  =   Yw;
  //  zr, zg, zb]      Xb + Yb + Zb]      Zw]
  //
  // Which makes it apparent that we can compute those totals as:
  //
  //                  [Xr + Yr + Zr;     inv([xr, xg, xb;      [Xw;
  //                   Xg + Yg + Zg;  =       yr, yg, yb;   ×   Yw;
  //                   Xb + Yb + Zb]          zr, zg, zb])      Zw]
  //
  // From there, by multiplying each total by its corresponding y, we get Y for
  // that primary.

  Color white_XYZ;
  CIExy wp = encoding.GetWhitePoint();
  JXL_RETURN_IF_ERROR(CIEXYZFromWhiteCIExy(wp.x, wp.y, white_XYZ));

  PrimariesCIExy primaries;
  JXL_RETURN_IF_ERROR(encoding.GetPrimaries(primaries));
  Matrix3x3d chromaticities{
      {{primaries.r.x, primaries.g.x, primaries.b.x},
       {primaries.r.y, primaries.g.y, primaries.b.y},
       {1 - primaries.r.x - primaries.r.y, 1 - primaries.g.x - primaries.g.y,
        1 - primaries.b.x - primaries.b.y}}};
  JXL_RETURN_IF_ERROR(Inv3x3Matrix(chromaticities));
  const double ys[3] = {primaries.r.y, primaries.g.y, primaries.b.y};
  for (size_t i = 0; i < 3; ++i) {
    luminances[i] = ys[i] * (chromaticities[i][0] * white_XYZ[0] +
                             chromaticities[i][1] * white_XYZ[1] +
                             chromaticities[i][2] * white_XYZ[2]);
  }
  return true;
}

Status ApplyHlgOotf(JxlCms* t, float* JXL_RESTRICT buf, size_t xsize,
                    bool forward) {
  if (295 <= t->intensity_target && t->intensity_target <= 305) {
    // The gamma is approximately 1 so this can essentially be skipped.
    return true;
  }
  float gamma = 1.2f * std::pow(1.111f, std::log2(t->intensity_target * 1e-3f));
  if (!forward) gamma = 1.f / gamma;

  switch (t->hlg_ootf_num_channels) {
    case 1:
      for (size_t x = 0; x < xsize; ++x) {
        buf[x] = std::pow(buf[x], gamma);
      }
      break;

    case 3:
      for (size_t x = 0; x < xsize; x += 3) {
        const float luminance = buf[x] * t->hlg_ootf_luminances[0] +
                                buf[x + 1] * t->hlg_ootf_luminances[1] +
                                buf[x + 2] * t->hlg_ootf_luminances[2];
        const float ratio = std::pow(luminance, gamma - 1);
        if (std::isfinite(ratio)) {
          buf[x] *= ratio;
          buf[x + 1] *= ratio;
          buf[x + 2] *= ratio;
          if (forward && gamma < 1) {
            // If gamma < 1, the ratio above will be > 1 which can push bright
            // saturated highlights out of gamut. There are several possible
            // ways to bring them back in-gamut; this one preserves hue and
            // saturation at the slight expense of luminance. If !forward, the
            // previously-applied forward OOTF with gamma > 1 already pushed
            // those highlights down and we are simply putting them back where
            // they were so this is not necessary.
            const float maximum =
                std::max(buf[x], std::max(buf[x + 1], buf[x + 2]));
            if (maximum > 1) {
              const float normalizer = 1.f / maximum;
              buf[x] *= normalizer;
              buf[x + 1] *= normalizer;
              buf[x + 2] *= normalizer;
            }
          }
        }
      }
      break;

    default:
      return JXL_FAILURE("HLG OOTF not implemented for %" PRIuS " channels",
                         t->hlg_ootf_num_channels);
  }
  return true;
}

bool IsKnownTransferFunction(jxl::cms::TransferFunction tf) {
  using TF = jxl::cms::TransferFunction;
  // All but kUnknown
  return tf == TF::k709 || tf == TF::kLinear || tf == TF::kSRGB ||
         tf == TF::kPQ || tf == TF::kDCI || tf == TF::kHLG;
}

constexpr uint8_t kColorPrimariesP3_D65 = 12;

bool IsKnownColorPrimaries(uint8_t color_primaries) {
  using P = jxl::cms::Primaries;
  // All but kCustom
  if (color_primaries == kColorPrimariesP3_D65) return true;
  const auto p = static_cast<Primaries>(color_primaries);
  return p == P::kSRGB || p == P::k2100 || p == P::kP3;
}

bool ApplyCICP(const uint8_t color_primaries,
               const uint8_t transfer_characteristics,
               const uint8_t matrix_coefficients, const uint8_t full_range,
               ColorEncoding* JXL_RESTRICT c) {
  if (matrix_coefficients != 0) return false;
  if (full_range != 1) return false;

  const auto primaries = static_cast<Primaries>(color_primaries);
  const auto tf = static_cast<TransferFunction>(transfer_characteristics);
  if (!IsKnownTransferFunction(tf)) return false;
  if (!IsKnownColorPrimaries(color_primaries)) return false;
  c->color_space = ColorSpace::kRGB;
  c->tf.SetTransferFunction(tf);
  if (primaries == Primaries::kP3) {
    c->white_point = WhitePoint::kDCI;
    c->primaries = Primaries::kP3;
  } else if (color_primaries == kColorPrimariesP3_D65) {
    c->white_point = WhitePoint::kD65;
    c->primaries = Primaries::kP3;
  } else {
    c->white_point = WhitePoint::kD65;
    c->primaries = primaries;
  }
  return true;
}

JXL_BOOL JxlCmsSetFieldsFromICC(void* user_data, const uint8_t* icc_data,
                                size_t icc_size, JxlColorEncoding* c,
                                JXL_BOOL* cmyk) {
  if (c == nullptr) return JXL_FALSE;
  if (cmyk == nullptr) return JXL_FALSE;

  *cmyk = JXL_FALSE;

  // In case parsing fails, mark the ColorEncoding as invalid.
  c->color_space = JXL_COLOR_SPACE_UNKNOWN;
  c->transfer_function = JXL_TRANSFER_FUNCTION_UNKNOWN;

  if (icc_size == 0) return JXL_FAILURE("Empty ICC profile");

  ColorEncoding c_enc;

#if JPEGXL_ENABLE_SKCMS
  if (icc_size < 128) {
    return JXL_FAILURE("ICC file too small");
  }

  skcms_ICCProfile profile;
  JXL_RETURN_IF_ERROR(skcms_Parse(icc_data, icc_size, &profile));

  // skcms does not return the rendering intent, so get it from the file. It
  // should be encoded as big-endian 32-bit integer in bytes 60..63.
  uint32_t big_endian_rendering_intent = icc_data[67] + (icc_data[66] << 8) +
                                         (icc_data[65] << 16) +
                                         (icc_data[64] << 24);
  // Some files encode rendering intent as little endian, which is not spec
  // compliant. However we accept those with a warning.
  uint32_t little_endian_rendering_intent = (icc_data[67] << 24) +
                                            (icc_data[66] << 16) +
                                            (icc_data[65] << 8) + icc_data[64];
  uint32_t candidate_rendering_intent =
      std::min(big_endian_rendering_intent, little_endian_rendering_intent);
  if (candidate_rendering_intent != big_endian_rendering_intent) {
    JXL_WARNING(
        "Invalid rendering intent bytes: [0x%02X 0x%02X 0x%02X 0x%02X], "
        "assuming %u was meant",
        icc_data[64], icc_data[65], icc_data[66], icc_data[67],
        candidate_rendering_intent);
  }
  if (candidate_rendering_intent > 3) {
    return JXL_FAILURE("Invalid rendering intent %u\n",
                       candidate_rendering_intent);
  }
  // ICC and RenderingIntent have the same values (0..3).
  c_enc.rendering_intent =
      static_cast<RenderingIntent>(candidate_rendering_intent);

  if (profile.has_CICP &&
      ApplyCICP(profile.CICP.color_primaries,
                profile.CICP.transfer_characteristics,
                profile.CICP.matrix_coefficients,
                profile.CICP.video_full_range_flag, &c_enc)) {
    *c = c_enc.ToExternal();
    return JXL_TRUE;
  }

  c_enc.color_space = ColorSpaceFromProfile(profile);
  *cmyk = TO_JXL_BOOL(profile.data_color_space == skcms_Signature_CMYK);

  CIExy wp_unadapted;
  JXL_RETURN_IF_ERROR(UnadaptedWhitePoint(profile, &wp_unadapted));
  JXL_RETURN_IF_ERROR(c_enc.SetWhitePoint(wp_unadapted));

  // Relies on color_space.
  JXL_RETURN_IF_ERROR(IdentifyPrimaries(profile, wp_unadapted, &c_enc));

  // Relies on color_space/white point/primaries being set already.
  JXL_RETURN_IF_ERROR(DetectTransferFunction(profile, &c_enc));
#else  // JPEGXL_ENABLE_SKCMS

  const cmsContext context = GetContext();

  Profile profile;
  JXL_RETURN_IF_ERROR(
      DecodeProfile(context, Bytes(icc_data, icc_size), &profile));

  const cmsUInt32Number rendering_intent32 =
      cmsGetHeaderRenderingIntent(profile.get());
  if (rendering_intent32 > 3) {
    return JXL_FAILURE("Invalid rendering intent %u\n", rendering_intent32);
  }
  // ICC and RenderingIntent have the same values (0..3).
  c_enc.rendering_intent = static_cast<RenderingIntent>(rendering_intent32);

  static constexpr size_t kCICPSize = 12;
  static constexpr auto kCICPSignature =
      static_cast<cmsTagSignature>(0x63696370);
  uint8_t cicp_buffer[kCICPSize];
  if (cmsReadRawTag(profile.get(), kCICPSignature, cicp_buffer, kCICPSize) ==
          kCICPSize &&
      ApplyCICP(cicp_buffer[8], cicp_buffer[9], cicp_buffer[10],
                cicp_buffer[11], &c_enc)) {
    *c = c_enc.ToExternal();
    return JXL_TRUE;
  }

  c_enc.color_space = ColorSpaceFromProfile(profile);
  if (cmsGetColorSpace(profile.get()) == cmsSigCmykData) {
    *cmyk = JXL_TRUE;
    *c = c_enc.ToExternal();
    return JXL_TRUE;
  }

  const cmsCIEXYZ wp_unadapted = UnadaptedWhitePoint(context, profile, c_enc);
  JXL_RETURN_IF_ERROR(c_enc.SetWhitePoint(CIExyFromXYZ(wp_unadapted)));

  // Relies on color_space.
  JXL_RETURN_IF_ERROR(
      IdentifyPrimaries(context, profile, wp_unadapted, &c_enc));

  // Relies on color_space/white point/primaries being set already.
  JXL_RETURN_IF_ERROR(DetectTransferFunction(context, profile, &c_enc));

#endif  // JPEGXL_ENABLE_SKCMS

  *c = c_enc.ToExternal();
  return JXL_TRUE;
}

}  // namespace

namespace {

void JxlCmsDestroy(void* cms_data) {
  if (cms_data == nullptr) return;
  JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
#if !JPEGXL_ENABLE_SKCMS
  TransformDeleter()(t->lcms_transform);
#endif
  delete t;
}

void AllocateBuffer(size_t length, size_t num_threads,
                    std::vector<float>* storage, std::vector<float*>* view) {
  constexpr size_t kAlign = 128 / sizeof(float);
  size_t stride = RoundUpTo(length, kAlign);
  storage->resize(stride * num_threads + kAlign);
  intptr_t addr = reinterpret_cast<intptr_t>(storage->data());
  size_t offset =
      (RoundUpTo(addr, kAlign * sizeof(float)) - addr) / sizeof(float);
  view->clear();
  view->reserve(num_threads);
  for (size_t i = 0; i < num_threads; ++i) {
    view->emplace_back(storage->data() + offset + i * stride);
  }
}

void* JxlCmsInit(void* init_data, size_t num_threads, size_t xsize,
                 const JxlColorProfile* input, const JxlColorProfile* output,
                 float intensity_target) {
  if (init_data == nullptr) {
    JXL_NOTIFY_ERROR("JxlCmsInit: init_data is nullptr");
    return nullptr;
  }
  const auto* cms = static_cast<const JxlCmsInterface*>(init_data);
  auto t = jxl::make_unique<JxlCms>();
  IccBytes icc_src;
  IccBytes icc_dst;
  if (input->icc.size == 0) {
    JXL_NOTIFY_ERROR("JxlCmsInit: empty input ICC");
    return nullptr;
  }
  if (output->icc.size == 0) {
    JXL_NOTIFY_ERROR("JxlCmsInit: empty OUTPUT ICC");
    return nullptr;
  }
  icc_src.assign(input->icc.data, input->icc.data + input->icc.size);
  ColorEncoding c_src;
  if (!c_src.SetFieldsFromICC(std::move(icc_src), *cms)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: failed to parse input ICC");
    return nullptr;
  }
  icc_dst.assign(output->icc.data, output->icc.data + output->icc.size);
  ColorEncoding c_dst;
  if (!c_dst.SetFieldsFromICC(std::move(icc_dst), *cms)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: failed to parse output ICC");
    return nullptr;
  }
#if JXL_CMS_VERBOSE
  printf("%s -> %s\n", Description(c_src).c_str(), Description(c_dst).c_str());
#endif

#if JPEGXL_ENABLE_SKCMS
  if (!DecodeProfile(input->icc.data, input->icc.size, &t->profile_src)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: skcms failed to parse input ICC");
    return nullptr;
  }
  if (!DecodeProfile(output->icc.data, output->icc.size, &t->profile_dst)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: skcms failed to parse output ICC");
    return nullptr;
  }
#else   // JPEGXL_ENABLE_SKCMS
  const cmsContext context = GetContext();
  Profile profile_src, profile_dst;
  if (!DecodeProfile(context, Bytes(c_src.icc), &profile_src)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: lcms failed to parse input ICC");
    return nullptr;
  }
  if (!DecodeProfile(context, Bytes(c_dst.icc), &profile_dst)) {
    JXL_NOTIFY_ERROR("JxlCmsInit: lcms failed to parse output ICC");
    return nullptr;
  }
#endif  // JPEGXL_ENABLE_SKCMS

  t->skip_lcms = false;
  if (c_src.SameColorEncoding(c_dst)) {
    t->skip_lcms = true;
#if JXL_CMS_VERBOSE
    printf("Skip CMS\n");
#endif
  }

  t->apply_hlg_ootf = c_src.tf.IsHLG() != c_dst.tf.IsHLG();
  if (t->apply_hlg_ootf) {
    const ColorEncoding* c_hlg = c_src.tf.IsHLG() ? &c_src : &c_dst;
    t->hlg_ootf_num_channels = c_hlg->Channels();
    if (t->hlg_ootf_num_channels == 3 &&
        !GetPrimariesLuminances(*c_hlg, t->hlg_ootf_luminances.data())) {
      JXL_NOTIFY_ERROR(
          "JxlCmsInit: failed to compute the luminances of primaries");
      return nullptr;
    }
  }

  // Special-case SRGB <=> linear if the primaries / white point are the same,
  // or any conversion where PQ or HLG is involved:
  bool src_linear = c_src.tf.IsLinear();
  const bool dst_linear = c_dst.tf.IsLinear();

  if (c_src.tf.IsPQ() || c_src.tf.IsHLG() ||
      (c_src.tf.IsSRGB() && dst_linear && c_src.SameColorSpace(c_dst))) {
    // Construct new profile as if the data were already/still linear.
    ColorEncoding c_linear_src = c_src;
    c_linear_src.tf.SetTransferFunction(TransferFunction::kLinear);
#if JPEGXL_ENABLE_SKCMS
    skcms_ICCProfile new_src;
#else   // JPEGXL_ENABLE_SKCMS
    Profile new_src;
#endif  // JPEGXL_ENABLE_SKCMS
        // Only enable ExtraTF if profile creation succeeded.
    if (MaybeCreateProfile(c_linear_src.ToExternal(), &icc_src) &&
#if JPEGXL_ENABLE_SKCMS
        DecodeProfile(icc_src.data(), icc_src.size(), &new_src)) {
#else   // JPEGXL_ENABLE_SKCMS
        DecodeProfile(context, Bytes(icc_src), &new_src)) {
#endif  // JPEGXL_ENABLE_SKCMS
#if JXL_CMS_VERBOSE
      printf("Special HLG/PQ/sRGB -> linear\n");
#endif
#if JPEGXL_ENABLE_SKCMS
      t->icc_src = std::move(icc_src);
      t->profile_src = new_src;
#else   // JPEGXL_ENABLE_SKCMS
      profile_src.swap(new_src);
#endif  // JPEGXL_ENABLE_SKCMS
      t->preprocess = c_src.tf.IsSRGB()
                          ? ExtraTF::kSRGB
                          : (c_src.tf.IsPQ() ? ExtraTF::kPQ : ExtraTF::kHLG);
      c_src = c_linear_src;
      src_linear = true;
    } else {
      if (t->apply_hlg_ootf) {
        JXL_NOTIFY_ERROR(
            "Failed to create extra linear source profile, and HLG OOTF "
            "required");
        return nullptr;
      }
      JXL_WARNING("Failed to create extra linear destination profile");
    }
  }

  if (c_dst.tf.IsPQ() || c_dst.tf.IsHLG() ||
      (c_dst.tf.IsSRGB() && src_linear && c_src.SameColorSpace(c_dst))) {
    ColorEncoding c_linear_dst = c_dst;
    c_linear_dst.tf.SetTransferFunction(TransferFunction::kLinear);
#if JPEGXL_ENABLE_SKCMS
    skcms_ICCProfile new_dst;
#else   // JPEGXL_ENABLE_SKCMS
    Profile new_dst;
#endif  // JPEGXL_ENABLE_SKCMS
    // Only enable ExtraTF if profile creation succeeded.
    if (MaybeCreateProfile(c_linear_dst.ToExternal(), &icc_dst) &&
#if JPEGXL_ENABLE_SKCMS
        DecodeProfile(icc_dst.data(), icc_dst.size(), &new_dst)) {
#else   // JPEGXL_ENABLE_SKCMS
        DecodeProfile(context, Bytes(icc_dst), &new_dst)) {
#endif  // JPEGXL_ENABLE_SKCMS
#if JXL_CMS_VERBOSE
      printf("Special linear -> HLG/PQ/sRGB\n");
#endif
#if JPEGXL_ENABLE_SKCMS
      t->icc_dst = std::move(icc_dst);
      t->profile_dst = new_dst;
#else   // JPEGXL_ENABLE_SKCMS
      profile_dst.swap(new_dst);
#endif  // JPEGXL_ENABLE_SKCMS
      t->postprocess = c_dst.tf.IsSRGB()
                           ? ExtraTF::kSRGB
                           : (c_dst.tf.IsPQ() ? ExtraTF::kPQ : ExtraTF::kHLG);
      c_dst = c_linear_dst;
    } else {
      if (t->apply_hlg_ootf) {
        JXL_NOTIFY_ERROR(
            "Failed to create extra linear destination profile, and inverse "
            "HLG OOTF required");
        return nullptr;
      }
      JXL_WARNING("Failed to create extra linear destination profile");
    }
  }

  if (c_src.SameColorEncoding(c_dst)) {
#if JXL_CMS_VERBOSE
    printf("Same intermediary linear profiles, skipping CMS\n");
#endif
    t->skip_lcms = true;
  }

#if JPEGXL_ENABLE_SKCMS
  if (!skcms_MakeUsableAsDestination(&t->profile_dst)) {
    JXL_NOTIFY_ERROR(
        "Failed to make %s usable as a color transform destination",
        ColorEncodingDescription(c_dst.ToExternal()).c_str());
    return nullptr;
  }
#endif  // JPEGXL_ENABLE_SKCMS

  // Not including alpha channel (copied separately).
  const size_t channels_src = (c_src.cmyk ? 4 : c_src.Channels());
  const size_t channels_dst = c_dst.Channels();
#if JXL_CMS_VERBOSE
  printf("Channels: %" PRIuS "; Threads: %" PRIuS "\n", channels_src,
         num_threads);
#endif

#if !JPEGXL_ENABLE_SKCMS
  // Type includes color space (XYZ vs RGB), so can be different.
  const uint32_t type_src = Type32(c_src, channels_src == 4);
  const uint32_t type_dst = Type32(c_dst, false);
  const uint32_t intent = static_cast<uint32_t>(c_dst.rendering_intent);
  // Use cmsFLAGS_NOCACHE to disable the 1-pixel cache and make calling
  // cmsDoTransform() thread-safe.
  const uint32_t flags = cmsFLAGS_NOCACHE | cmsFLAGS_BLACKPOINTCOMPENSATION |
                         cmsFLAGS_HIGHRESPRECALC;
  t->lcms_transform =
      cmsCreateTransformTHR(context, profile_src.get(), type_src,
                            profile_dst.get(), type_dst, intent, flags);
  if (t->lcms_transform == nullptr) {
    JXL_NOTIFY_ERROR("Failed to create transform");
    return nullptr;
  }
#endif  // !JPEGXL_ENABLE_SKCMS

  // Ideally LCMS would convert directly from External to Image3. However,
  // cmsDoTransformLineStride only accepts 32-bit BytesPerPlaneIn, whereas our
  // planes can be more than 4 GiB apart. Hence, transform inputs/outputs must
  // be interleaved. Calling cmsDoTransform for each pixel is expensive
  // (indirect call). We therefore transform rows, which requires per-thread
  // buffers. To avoid separate allocations, we use the rows of an image.
  // Because LCMS apparently also cannot handle <= 16 bit inputs and 32-bit
  // outputs (or vice versa), we use floating point input/output.
  t->channels_src = channels_src;
  t->channels_dst = channels_dst;
#if !JPEGXL_ENABLE_SKCMS
  size_t actual_channels_src = channels_src;
  size_t actual_channels_dst = channels_dst;
#else
  // SkiaCMS doesn't support grayscale float buffers, so we create space for RGB
  // float buffers anyway.
  size_t actual_channels_src = (channels_src == 4 ? 4 : 3);
  size_t actual_channels_dst = 3;
#endif
  AllocateBuffer(xsize * actual_channels_src, num_threads, &t->src_storage,
                 &t->buf_src);
  AllocateBuffer(xsize * actual_channels_dst, num_threads, &t->dst_storage,
                 &t->buf_dst);
  t->intensity_target = intensity_target;
  return t.release();
}

float* JxlCmsGetSrcBuf(void* cms_data, size_t thread) {
  JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
  return t->buf_src[thread];
}

float* JxlCmsGetDstBuf(void* cms_data, size_t thread) {
  JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
  return t->buf_dst[thread];
}

}  // namespace

extern "C" {

JXL_CMS_EXPORT const JxlCmsInterface* JxlGetDefaultCms() {
  static constexpr JxlCmsInterface kInterface = {
      /*set_fields_data=*/nullptr,
      /*set_fields_from_icc=*/&JxlCmsSetFieldsFromICC,
      /*init_data=*/const_cast<void*>(static_cast<const void*>(&kInterface)),
      /*init=*/&JxlCmsInit,
      /*get_src_buf=*/&JxlCmsGetSrcBuf,
      /*get_dst_buf=*/&JxlCmsGetDstBuf,
      /*run=*/&DoColorSpaceTransform,
      /*destroy=*/&JxlCmsDestroy};
  return &kInterface;
}

}  // extern "C"

}  // namespace jxl
#endif  // HWY_ONCE

Coverage Report

Created: 2026-11-12 07:35