Debian Codegraph @

lib/jxl/cms/jxl_cms.cc

raw
1 // Copyright (c) the JPEG XL Project Authors. All rights reserved.
2 //
3 // Use of this source code is governed by a BSD-style
4 // license that can be found in the LICENSE file.
5
6 #include <jxl/cms.h>
7
8 #ifndef JPEGXL_ENABLE_SKCMS
9 #define JPEGXL_ENABLE_SKCMS 0
10 #endif
11
12 #include <jxl/cms_interface.h>
13
14 #include <algorithm>
15 #include <array>
16 #include <cmath>
17 #include <cstddef>
18 #include <cstdint>
19 #include <cstring>
20 #include <memory>
21
22 #undef HWY_TARGET_INCLUDE
23 #define HWY_TARGET_INCLUDE "lib/jxl/cms/jxl_cms.cc"
24 #include <hwy/foreach_target.h>
25 #include <hwy/highway.h>
26
27 #include "lib/jxl/base/compiler_specific.h"
28 #include "lib/jxl/base/matrix_ops.h"
29 #include "lib/jxl/base/printf_macros.h"
30 #include "lib/jxl/base/status.h"
31 #include "lib/jxl/cms/jxl_cms_internal.h"
32 #include "lib/jxl/cms/transfer_functions-inl.h"
33 #include "lib/jxl/color_encoding_internal.h"
34 #if JPEGXL_ENABLE_SKCMS
35 #include "skcms.h"
36 #else // JPEGXL_ENABLE_SKCMS
37 #include "lcms2.h"
38 #include "lcms2_plugin.h"
39 #include "lib/jxl/base/span.h"
40 #endif // JPEGXL_ENABLE_SKCMS
41
42 #define JXL_CMS_VERBOSE 0
43
44 // Define these only once. We can't use HWY_ONCE here because it is defined as
45 // 1 only on the last pass.
46 #ifndef LIB_JXL_JXL_CMS_CC
47 #define LIB_JXL_JXL_CMS_CC
48
49 namespace jxl {
50 namespace {
51
52 using ::jxl::cms::ColorEncoding;
53
54 struct JxlCms {
55 #if JPEGXL_ENABLE_SKCMS
56 IccBytes icc_src, icc_dst;
57 skcms_ICCProfile profile_src, profile_dst;
58 #else
59 void* lcms_transform;
60 #endif
61
62 // These fields are used when the HLG OOTF or inverse OOTF must be applied.
63 bool apply_hlg_ootf;
64 size_t hlg_ootf_num_channels;
65 // Y component of the primaries.
66 std::array<float, 3> hlg_ootf_luminances;
67
68 size_t channels_src;
69 size_t channels_dst;
70
71 std::vector<float> src_storage;
72 std::vector<float*> buf_src;
73 std::vector<float> dst_storage;
74 std::vector<float*> buf_dst;
75
76 float intensity_target;
77 bool skip_lcms = false;
78 ExtraTF preprocess = ExtraTF::kNone;
79 ExtraTF postprocess = ExtraTF::kNone;
80 };
81
82 Status ApplyHlgOotf(JxlCms* t, float* JXL_RESTRICT buf, size_t xsize,
83 bool forward);
84 } // namespace
85 } // namespace jxl
86
87 #endif // LIB_JXL_JXL_CMS_CC
88
89 HWY_BEFORE_NAMESPACE();
90 namespace jxl {
91 namespace HWY_NAMESPACE {
92
93 #if JXL_CMS_VERBOSE >= 2
94 const size_t kX = 0; // pixel index, multiplied by 3 for RGB
95 #endif
96
97 // xform_src = UndoGammaCompression(buf_src).
98 Status BeforeTransform(JxlCms* t, const float* buf_src, float* xform_src,
99 size_t buf_size) {
100 switch (t->preprocess) {
101 case ExtraTF::kNone:
102 JXL_ENSURE(false); // unreachable
103 break;
104
105 case ExtraTF::kPQ: {
106 HWY_FULL(float) df;
107 TF_PQ tf_pq(t->intensity_target);
108 for (size_t i = 0; i < buf_size; i += Lanes(df)) {
109 const auto val = Load(df, buf_src + i);
110 const auto result = tf_pq.DisplayFromEncoded(df, val);
111 Store(result, df, xform_src + i);
112 }
113 #if JXL_CMS_VERBOSE >= 2
114 printf("pre in %.4f %.4f %.4f undoPQ %.4f %.4f %.4f\n", buf_src[3 * kX],
115 buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
116 xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
117 #endif
118 break;
119 }
120
121 case ExtraTF::kHLG:
122 for (size_t i = 0; i < buf_size; ++i) {
123 xform_src[i] = static_cast<float>(
124 TF_HLG_Base::DisplayFromEncoded(static_cast<double>(buf_src[i])));
125 }
126 if (t->apply_hlg_ootf) {
127 JXL_RETURN_IF_ERROR(
128 ApplyHlgOotf(t, xform_src, buf_size, /*forward=*/true));
129 }
130 #if JXL_CMS_VERBOSE >= 2
131 printf("pre in %.4f %.4f %.4f undoHLG %.4f %.4f %.4f\n", buf_src[3 * kX],
132 buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
133 xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
134 #endif
135 break;
136
137 case ExtraTF::kSRGB:
138 HWY_FULL(float) df;
139 for (size_t i = 0; i < buf_size; i += Lanes(df)) {
140 const auto val = Load(df, buf_src + i);
141 const auto result = TF_SRGB().DisplayFromEncoded(val);
142 Store(result, df, xform_src + i);
143 }
144 #if JXL_CMS_VERBOSE >= 2
145 printf("pre in %.4f %.4f %.4f undoSRGB %.4f %.4f %.4f\n", buf_src[3 * kX],
146 buf_src[3 * kX + 1], buf_src[3 * kX + 2], xform_src[3 * kX],
147 xform_src[3 * kX + 1], xform_src[3 * kX + 2]);
148 #endif
149 break;
150 }
151 return true;
152 }
153
154 // Applies gamma compression in-place.
155 Status AfterTransform(JxlCms* t, float* JXL_RESTRICT buf_dst, size_t buf_size) {
156 switch (t->postprocess) {
157 case ExtraTF::kNone:
158 JXL_DEBUG_ABORT("Unreachable");
159 break;
160 case ExtraTF::kPQ: {
161 HWY_FULL(float) df;
162 TF_PQ tf_pq(t->intensity_target);
163 for (size_t i = 0; i < buf_size; i += Lanes(df)) {
164 const auto val = Load(df, buf_dst + i);
165 const auto result = tf_pq.EncodedFromDisplay(df, val);
166 Store(result, df, buf_dst + i);
167 }
168 #if JXL_CMS_VERBOSE >= 2
169 printf("after PQ enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
170 buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
171 #endif
172 break;
173 }
174 case ExtraTF::kHLG:
175 if (t->apply_hlg_ootf) {
176 JXL_RETURN_IF_ERROR(
177 ApplyHlgOotf(t, buf_dst, buf_size, /*forward=*/false));
178 }
179 for (size_t i = 0; i < buf_size; ++i) {
180 buf_dst[i] = static_cast<float>(
181 TF_HLG_Base::EncodedFromDisplay(static_cast<double>(buf_dst[i])));
182 }
183 #if JXL_CMS_VERBOSE >= 2
184 printf("after HLG enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
185 buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
186 #endif
187 break;
188 case ExtraTF::kSRGB:
189 HWY_FULL(float) df;
190 for (size_t i = 0; i < buf_size; i += Lanes(df)) {
191 const auto val = Load(df, buf_dst + i);
192 const auto result = TF_SRGB().EncodedFromDisplay(df, val);
193 Store(result, df, buf_dst + i);
194 }
195 #if JXL_CMS_VERBOSE >= 2
196 printf("after SRGB enc %.4f %.4f %.4f\n", buf_dst[3 * kX],
197 buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
198 #endif
199 break;
200 }
201 return true;
202 }
203
204 Status DoColorSpaceTransform(void* cms_data, const size_t thread,
205 const float* buf_src, float* buf_dst,
206 size_t xsize) {
207 // No lock needed.
208 JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
209
210 const float* xform_src = buf_src; // Read-only.
211 if (t->preprocess != ExtraTF::kNone) {
212 float* mutable_xform_src = t->buf_src[thread]; // Writable buffer.
213 JXL_RETURN_IF_ERROR(BeforeTransform(t, buf_src, mutable_xform_src,
214 xsize * t->channels_src));
215 xform_src = mutable_xform_src;
216 }
217
218 #if JPEGXL_ENABLE_SKCMS
219 if (t->channels_src == 1 && !t->skip_lcms) {
220 // Expand from 1 to 3 channels, starting from the end in case
221 // xform_src == t->buf_src[thread].
222 float* mutable_xform_src = t->buf_src[thread];
223 for (size_t i = 0; i < xsize; ++i) {
224 const size_t x = xsize - i - 1;
225 mutable_xform_src[x * 3] = mutable_xform_src[x * 3 + 1] =
226 mutable_xform_src[x * 3 + 2] = xform_src[x];
227 }
228 xform_src = mutable_xform_src;
229 }
230 #else
231 if (t->channels_src == 4 && !t->skip_lcms) {
232 // LCMS does CMYK in a weird way: 0 = white, 100 = max ink
233 float* mutable_xform_src = t->buf_src[thread];
234 for (size_t x = 0; x < xsize * 4; ++x) {
235 mutable_xform_src[x] = 100.f - 100.f * mutable_xform_src[x];
236 }
237 xform_src = mutable_xform_src;
238 }
239 #endif
240
241 #if JXL_CMS_VERBOSE >= 2
242 // Save inputs for printing before in-place transforms overwrite them.
243 const float in0 = xform_src[3 * kX + 0];
244 const float in1 = xform_src[3 * kX + 1];
245 const float in2 = xform_src[3 * kX + 2];
246 #endif
247
248 if (t->skip_lcms) {
249 if (buf_dst != xform_src) {
250 memcpy(buf_dst, xform_src, xsize * t->channels_src * sizeof(*buf_dst));
251 } // else: in-place, no need to copy
252 } else {
253 #if JPEGXL_ENABLE_SKCMS
254 JXL_ENSURE(
255 skcms_Transform(xform_src,
256 (t->channels_src == 4 ? skcms_PixelFormat_RGBA_ffff
257 : skcms_PixelFormat_RGB_fff),
258 skcms_AlphaFormat_Opaque, &t->profile_src, buf_dst,
259 skcms_PixelFormat_RGB_fff, skcms_AlphaFormat_Opaque,
260 &t->profile_dst, xsize));
261 #else // JPEGXL_ENABLE_SKCMS
262 cmsDoTransform(t->lcms_transform, xform_src, buf_dst,
263 static_cast<cmsUInt32Number>(xsize));
264 #endif // JPEGXL_ENABLE_SKCMS
265 }
266 #if JXL_CMS_VERBOSE >= 2
267 printf("xform skip%d: %.4f %.4f %.4f (%p) -> (%p) %.4f %.4f %.4f\n",
268 t->skip_lcms, in0, in1, in2, xform_src, buf_dst, buf_dst[3 * kX],
269 buf_dst[3 * kX + 1], buf_dst[3 * kX + 2]);
270 #endif
271
272 #if JPEGXL_ENABLE_SKCMS
273 if (t->channels_dst == 1 && !t->skip_lcms) {
274 // Contract back from 3 to 1 channel, this time forward.
275 float* grayscale_buf_dst = t->buf_dst[thread];
276 for (size_t x = 0; x < xsize; ++x) {
277 grayscale_buf_dst[x] = buf_dst[x * 3];
278 }
279 buf_dst = grayscale_buf_dst;
280 }
281 #endif
282
283 if (t->postprocess != ExtraTF::kNone) {
284 JXL_RETURN_IF_ERROR(AfterTransform(t, buf_dst, xsize * t->channels_dst));
285 }
286 return true;
287 }
288
289 // NOLINTNEXTLINE(google-readability-namespace-comments)
290 } // namespace HWY_NAMESPACE
291 } // namespace jxl
292 HWY_AFTER_NAMESPACE();
293
294 #if HWY_ONCE
295 namespace jxl {
296 namespace {
297
298 HWY_EXPORT(DoColorSpaceTransform);
299 int DoColorSpaceTransform(void* t, size_t thread, const float* buf_src,
300 float* buf_dst, size_t xsize) {
301 return HWY_DYNAMIC_DISPATCH(DoColorSpaceTransform)(t, thread, buf_src,
302 buf_dst, xsize);
303 }
304
305 // Define to 1 on OS X as a workaround for older LCMS lacking MD5.
306 #define JXL_CMS_OLD_VERSION 0
307
308 #if JPEGXL_ENABLE_SKCMS
309
310 JXL_MUST_USE_RESULT CIExy CIExyFromXYZ(const Color& XYZ) {
311 const float factor = 1.f / (XYZ[0] + XYZ[1] + XYZ[2]);
312 CIExy xy;
313 xy.x = XYZ[0] * factor;
314 xy.y = XYZ[1] * factor;
315 return xy;
316 }
317
318 #else // JPEGXL_ENABLE_SKCMS
319 // (LCMS interface requires xyY but we omit the Y for white points/primaries.)
320
321 JXL_MUST_USE_RESULT CIExy CIExyFromxyY(const cmsCIExyY& xyY) {
322 CIExy xy;
323 xy.x = xyY.x;
324 xy.y = xyY.y;
325 return xy;
326 }
327
328 JXL_MUST_USE_RESULT CIExy CIExyFromXYZ(const cmsCIEXYZ& XYZ) {
329 cmsCIExyY xyY;
330 cmsXYZ2xyY(/*Dest=*/&xyY, /*Source=*/&XYZ);
331 return CIExyFromxyY(xyY);
332 }
333
334 JXL_MUST_USE_RESULT cmsCIEXYZ D50_XYZ() {
335 // Quantized D50 as stored in ICC profiles.
336 return {0.96420288, 1.0, 0.82490540};
337 }
338
339 // RAII
340
341 struct ProfileDeleter {
342 void operator()(void* p) { cmsCloseProfile(p); }
343 };
344 using Profile = std::unique_ptr<void, ProfileDeleter>;
345
346 struct TransformDeleter {
347 void operator()(void* p) { cmsDeleteTransform(p); }
348 };
349 using Transform = std::unique_ptr<void, TransformDeleter>;
350
351 struct CurveDeleter {
352 void operator()(cmsToneCurve* p) { cmsFreeToneCurve(p); }
353 };
354 using Curve = std::unique_ptr<cmsToneCurve, CurveDeleter>;
355
356 Status CreateProfileXYZ(const cmsContext context,
357 Profile* JXL_RESTRICT profile) {
358 profile->reset(cmsCreateXYZProfileTHR(context));
359 if (profile->get() == nullptr) return JXL_FAILURE("Failed to create XYZ");
360 return true;
361 }
362
363 #endif // !JPEGXL_ENABLE_SKCMS
364
365 #if JPEGXL_ENABLE_SKCMS
366 // IMPORTANT: icc must outlive profile.
367 Status DecodeProfile(const uint8_t* icc, size_t size,
368 skcms_ICCProfile* const profile) {
369 if (!skcms_Parse(icc, size, profile)) {
370 return JXL_FAILURE("Failed to parse ICC profile with %" PRIuS " bytes",
371 size);
372 }
373 return true;
374 }
375 #else // JPEGXL_ENABLE_SKCMS
376 Status DecodeProfile(const cmsContext context, Span<const uint8_t> icc,
377 Profile* profile) {
378 profile->reset(cmsOpenProfileFromMemTHR(context, icc.data(), icc.size()));
379 if (profile->get() == nullptr) {
380 return JXL_FAILURE("Failed to decode profile");
381 }
382
383 // WARNING: due to the LCMS MD5 issue mentioned above, many existing
384 // profiles have incorrect MD5, so do not even bother checking them nor
385 // generating warning clutter.
386
387 return true;
388 }
389 #endif // JPEGXL_ENABLE_SKCMS
390
391 #if JPEGXL_ENABLE_SKCMS
392
393 ColorSpace ColorSpaceFromProfile(const skcms_ICCProfile& profile) {
394 switch (profile.data_color_space) {
395 case skcms_Signature_RGB:
396 case skcms_Signature_CMYK:
397 // spec says CMYK is encoded as RGB (the kBlack extra channel signals that
398 // it is actually CMYK)
399 return ColorSpace::kRGB;
400 case skcms_Signature_Gray:
401 return ColorSpace::kGray;
402 default:
403 return ColorSpace::kUnknown;
404 }
405 }
406
407 // vector_out := matmul(matrix, vector_in)
408 void MatrixProduct(const skcms_Matrix3x3& matrix, const Color& vector_in,
409 Color& vector_out) {
410 for (int i = 0; i < 3; ++i) {
411 vector_out[i] = 0;
412 for (int j = 0; j < 3; ++j) {
413 vector_out[i] += matrix.vals[i][j] * vector_in[j];
414 }
415 }
416 }
417
418 // Returns white point that was specified when creating the profile.
419 JXL_MUST_USE_RESULT Status UnadaptedWhitePoint(const skcms_ICCProfile& profile,
420 CIExy* out) {
421 Color media_white_point_XYZ;
422 if (!skcms_GetWTPT(&profile, media_white_point_XYZ.data())) {
423 return JXL_FAILURE("ICC profile does not contain WhitePoint tag");
424 }
425 skcms_Matrix3x3 CHAD;
426 if (!skcms_GetCHAD(&profile, &CHAD)) {
427 // If there is no chromatic adaptation matrix, it means that the white point
428 // is already unadapted.
429 *out = CIExyFromXYZ(media_white_point_XYZ);
430 return true;
431 }
432 // Otherwise, it has been adapted to the PCS white point using said matrix,
433 // and the adaptation needs to be undone.
434 skcms_Matrix3x3 inverse_CHAD;
435 if (!skcms_Matrix3x3_invert(&CHAD, &inverse_CHAD)) {
436 return JXL_FAILURE("Non-invertible ChromaticAdaptation matrix");
437 }
438 Color unadapted_white_point_XYZ;
439 MatrixProduct(inverse_CHAD, media_white_point_XYZ, unadapted_white_point_XYZ);
440 *out = CIExyFromXYZ(unadapted_white_point_XYZ);
441 return true;
442 }
443
444 Status IdentifyPrimaries(const skcms_ICCProfile& profile,
445 const CIExy& wp_unadapted, ColorEncoding* c) {
446 if (!c->HasPrimaries()) return true;
447
448 skcms_Matrix3x3 CHAD;
449 skcms_Matrix3x3 inverse_CHAD;
450 if (skcms_GetCHAD(&profile, &CHAD)) {
451 JXL_RETURN_IF_ERROR(skcms_Matrix3x3_invert(&CHAD, &inverse_CHAD));
452 } else {
453 static constexpr skcms_Matrix3x3 kLMSFromXYZ = {
454 {{0.8951, 0.2664, -0.1614},
455 {-0.7502, 1.7135, 0.0367},
456 {0.0389, -0.0685, 1.0296}}};
457 static constexpr skcms_Matrix3x3 kXYZFromLMS = {
458 {{0.9869929, -0.1470543, 0.1599627},
459 {0.4323053, 0.5183603, 0.0492912},
460 {-0.0085287, 0.0400428, 0.9684867}}};
461 static constexpr Color kWpD50XYZ{0.96420288, 1.0, 0.82490540};
462 Color wp_unadapted_XYZ;
463 JXL_RETURN_IF_ERROR(
464 CIEXYZFromWhiteCIExy(wp_unadapted.x, wp_unadapted.y, wp_unadapted_XYZ));
465 Color wp_D50_LMS;
466 Color wp_unadapted_LMS;
467 MatrixProduct(kLMSFromXYZ, kWpD50XYZ, wp_D50_LMS);
468 MatrixProduct(kLMSFromXYZ, wp_unadapted_XYZ, wp_unadapted_LMS);
469 inverse_CHAD = {{{wp_unadapted_LMS[0] / wp_D50_LMS[0], 0, 0},
470 {0, wp_unadapted_LMS[1] / wp_D50_LMS[1], 0},
471 {0, 0, wp_unadapted_LMS[2] / wp_D50_LMS[2]}}};
472 inverse_CHAD = skcms_Matrix3x3_concat(&kXYZFromLMS, &inverse_CHAD);
473 inverse_CHAD = skcms_Matrix3x3_concat(&inverse_CHAD, &kLMSFromXYZ);
474 }
475
476 Color XYZ;
477 PrimariesCIExy primaries;
478 CIExy* const chromaticities[] = {&primaries.r, &primaries.g, &primaries.b};
479 for (int i = 0; i < 3; ++i) {
480 float RGB[3] = {};
481 RGB[i] = 1;
482 skcms_Transform(RGB, skcms_PixelFormat_RGB_fff, skcms_AlphaFormat_Opaque,
483 &profile, XYZ.data(), skcms_PixelFormat_RGB_fff,
484 skcms_AlphaFormat_Opaque, skcms_XYZD50_profile(), 1);
485 Color unadapted_XYZ;
486 MatrixProduct(inverse_CHAD, XYZ, unadapted_XYZ);
487 *chromaticities[i] = CIExyFromXYZ(unadapted_XYZ);
488 }
489 return c->SetPrimaries(primaries);
490 }
491
492 bool IsApproximatelyEqual(const skcms_ICCProfile& profile,
493 const ColorEncoding& JXL_RESTRICT c) {
494 IccBytes bytes;
495 if (!MaybeCreateProfile(c.ToExternal(), &bytes)) {
496 return false;
497 }
498
499 skcms_ICCProfile profile_test;
500 if (!DecodeProfile(bytes.data(), bytes.size(), &profile_test)) {
501 return false;
502 }
503
504 if (!skcms_ApproximatelyEqualProfiles(&profile_test, &profile)) {
505 return false;
506 }
507
508 return true;
509 }
510
511 Status DetectTransferFunction(const skcms_ICCProfile& profile,
512 ColorEncoding* JXL_RESTRICT c) {
513 JXL_ENSURE(c->color_space != ColorSpace::kXYB);
514
515 float gamma[3] = {};
516 if (profile.has_trc) {
517 const auto IsGamma = [](const skcms_TransferFunction& tf) {
518 return tf.a == 1 && tf.b == 0 &&
519 /* if b and d are zero, it is fine for c not to be */ tf.d == 0 &&
520 tf.e == 0 && tf.f == 0;
521 };
522 for (int i = 0; i < 3; ++i) {
523 if (profile.trc[i].table_entries == 0 &&
524 IsGamma(profile.trc->parametric)) {
525 gamma[i] = 1.f / profile.trc->parametric.g;
526 } else {
527 skcms_TransferFunction approximate_tf;
528 float max_error;
529 if (skcms_ApproximateCurve(&profile.trc[i], &approximate_tf,
530 &max_error)) {
531 if (IsGamma(approximate_tf)) {
532 gamma[i] = 1.f / approximate_tf.g;
533 }
534 }
535 }
536 }
537 }
538 if (gamma[0] != 0 && std::abs(gamma[0] - gamma[1]) < 1e-4f &&
539 std::abs(gamma[1] - gamma[2]) < 1e-4f) {
540 if (c->tf.SetGamma(gamma[0])) {
541 if (IsApproximatelyEqual(profile, *c)) return true;
542 }
543 }
544
545 for (TransferFunction tf : Values<TransferFunction>()) {
546 // Can only create profile from known transfer function.
547 if (tf == TransferFunction::kUnknown) continue;
548 c->tf.SetTransferFunction(tf);
549 if (IsApproximatelyEqual(profile, *c)) return true;
550 }
551
552 c->tf.SetTransferFunction(TransferFunction::kUnknown);
553 return true;
554 }
555
556 #else // JPEGXL_ENABLE_SKCMS
557
558 uint32_t Type32(const ColorEncoding& c, bool cmyk) {
559 if (cmyk) return TYPE_CMYK_FLT;
560 if (c.color_space == ColorSpace::kGray) return TYPE_GRAY_FLT;
561 return TYPE_RGB_FLT;
562 }
563
564 uint32_t Type64(const ColorEncoding& c) {
565 if (c.color_space == ColorSpace::kGray) return TYPE_GRAY_DBL;
566 return TYPE_RGB_DBL;
567 }
568
569 ColorSpace ColorSpaceFromProfile(const Profile& profile) {
570 switch (cmsGetColorSpace(profile.get())) {
571 case cmsSigRgbData:
572 case cmsSigCmykData:
573 return ColorSpace::kRGB;
574 case cmsSigGrayData:
575 return ColorSpace::kGray;
576 default:
577 return ColorSpace::kUnknown;
578 }
579 }
580
581 // "profile1" is pre-decoded to save time in DetectTransferFunction.
582 Status ProfileEquivalentToICC(const cmsContext context, const Profile& profile1,
583 const IccBytes& icc, const ColorEncoding& c) {
584 const uint32_t type_src = Type64(c);
585
586 Profile profile2;
587 JXL_RETURN_IF_ERROR(DecodeProfile(context, Bytes(icc), &profile2));
588
589 Profile profile_xyz;
590 JXL_RETURN_IF_ERROR(CreateProfileXYZ(context, &profile_xyz));
591
592 const uint32_t intent = INTENT_RELATIVE_COLORIMETRIC;
593 const uint32_t flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_BLACKPOINTCOMPENSATION |
594 cmsFLAGS_HIGHRESPRECALC;
595 Transform xform1(cmsCreateTransformTHR(context, profile1.get(), type_src,
596 profile_xyz.get(), TYPE_XYZ_DBL,
597 intent, flags));
598 Transform xform2(cmsCreateTransformTHR(context, profile2.get(), type_src,
599 profile_xyz.get(), TYPE_XYZ_DBL,
600 intent, flags));
601 if (xform1 == nullptr || xform2 == nullptr) {
602 return JXL_FAILURE("Failed to create transform");
603 }
604
605 double in[3];
606 double out1[3];
607 double out2[3];
608
609 // Uniformly spaced samples from very dark to almost fully bright.
610 const double init = 1E-3;
611 const double step = 0.2;
612
613 if (c.color_space == ColorSpace::kGray) {
614 // Finer sampling and replicate each component.
615 for (in[0] = init; in[0] < 1.0; in[0] += step / 8) {
616 cmsDoTransform(xform1.get(), in, out1, 1);
617 cmsDoTransform(xform2.get(), in, out2, 1);
618 if (!cms::ApproxEq(out1[0], out2[0], 2E-4)) {
619 return false;
620 }
621 }
622 } else {
623 for (in[0] = init; in[0] < 1.0; in[0] += step) {
624 for (in[1] = init; in[1] < 1.0; in[1] += step) {
625 for (in[2] = init; in[2] < 1.0; in[2] += step) {
626 cmsDoTransform(xform1.get(), in, out1, 1);
627 cmsDoTransform(xform2.get(), in, out2, 1);
628 for (size_t i = 0; i < 3; ++i) {
629 if (!cms::ApproxEq(out1[i], out2[i], 2E-4)) {
630 return false;
631 }
632 }
633 }
634 }
635 }
636 }
637
638 return true;
639 }
640
641 // Returns white point that was specified when creating the profile.
642 // NOTE: we can't just use cmsSigMediaWhitePointTag because its interpretation
643 // differs between ICC versions.
644 JXL_MUST_USE_RESULT cmsCIEXYZ UnadaptedWhitePoint(const cmsContext context,
645 const Profile& profile,
646 const ColorEncoding& c) {
647 const cmsCIEXYZ* white_point = static_cast<const cmsCIEXYZ*>(
648 cmsReadTag(profile.get(), cmsSigMediaWhitePointTag));
649 if (white_point != nullptr &&
650 cmsReadTag(profile.get(), cmsSigChromaticAdaptationTag) == nullptr) {
651 // No chromatic adaptation matrix: the white point is already unadapted.
652 return *white_point;
653 }
654
655 cmsCIEXYZ XYZ = {1.0, 1.0, 1.0};
656 Profile profile_xyz;
657 if (!CreateProfileXYZ(context, &profile_xyz)) return XYZ;
658 // Array arguments are one per profile.
659 cmsHPROFILE profiles[2] = {profile.get(), profile_xyz.get()};
660 // Leave white point unchanged - that is what we're trying to extract.
661 cmsUInt32Number intents[2] = {INTENT_ABSOLUTE_COLORIMETRIC,
662 INTENT_ABSOLUTE_COLORIMETRIC};
663 cmsBool black_compensation[2] = {0, 0};
664 cmsFloat64Number adaption[2] = {0.0, 0.0};
665 // Only transforming a single pixel, so skip expensive optimizations.
666 cmsUInt32Number flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_HIGHRESPRECALC;
667 Transform xform(cmsCreateExtendedTransform(
668 context, 2, profiles, black_compensation, intents, adaption, nullptr, 0,
669 Type64(c), TYPE_XYZ_DBL, flags));
670 if (!xform) return XYZ; // TODO(lode): return error
671
672 // xy are relative, so magnitude does not matter if we ignore output Y.
673 const cmsFloat64Number in[3] = {1.0, 1.0, 1.0};
674 cmsDoTransform(xform.get(), in, &XYZ.X, 1);
675 return XYZ;
676 }
677
678 Status IdentifyPrimaries(const cmsContext context, const Profile& profile,
679 const cmsCIEXYZ& wp_unadapted, ColorEncoding* c) {
680 if (!c->HasPrimaries()) return true;
681 if (ColorSpaceFromProfile(profile) == ColorSpace::kUnknown) return true;
682
683 // These were adapted to the profile illuminant before storing in the profile.
684 const cmsCIEXYZ* adapted_r = static_cast<const cmsCIEXYZ*>(
685 cmsReadTag(profile.get(), cmsSigRedColorantTag));
686 const cmsCIEXYZ* adapted_g = static_cast<const cmsCIEXYZ*>(
687 cmsReadTag(profile.get(), cmsSigGreenColorantTag));
688 const cmsCIEXYZ* adapted_b = static_cast<const cmsCIEXYZ*>(
689 cmsReadTag(profile.get(), cmsSigBlueColorantTag));
690
691 cmsCIEXYZ converted_rgb[3];
692 if (adapted_r == nullptr || adapted_g == nullptr || adapted_b == nullptr) {
693 // No colorant tag, determine the XYZ coordinates of the primaries by
694 // converting from the colorspace.
695 Profile profile_xyz;
696 if (!CreateProfileXYZ(context, &profile_xyz)) {
697 return JXL_FAILURE("Failed to retrieve colorants");
698 }
699 // Array arguments are one per profile.
700 cmsHPROFILE profiles[2] = {profile.get(), profile_xyz.get()};
701 cmsUInt32Number intents[2] = {INTENT_RELATIVE_COLORIMETRIC,
702 INTENT_RELATIVE_COLORIMETRIC};
703 cmsBool black_compensation[2] = {0, 0};
704 cmsFloat64Number adaption[2] = {0.0, 0.0};
705 // Only transforming three pixels, so skip expensive optimizations.
706 cmsUInt32Number flags = cmsFLAGS_NOOPTIMIZE | cmsFLAGS_HIGHRESPRECALC;
707 Transform xform(cmsCreateExtendedTransform(
708 context, 2, profiles, black_compensation, intents, adaption, nullptr, 0,
709 Type64(*c), TYPE_XYZ_DBL, flags));
710 if (!xform) return JXL_FAILURE("Failed to retrieve colorants");
711
712 const cmsFloat64Number in[9] = {1.0, 0.0, 0.0, 0.0, 1.0,
713 0.0, 0.0, 0.0, 1.0};
714 cmsDoTransform(xform.get(), in, &converted_rgb->X, 3);
715 adapted_r = &converted_rgb[0];
716 adapted_g = &converted_rgb[1];
717 adapted_b = &converted_rgb[2];
718 }
719
720 // TODO(janwas): no longer assume Bradford and D50.
721 // Undo the chromatic adaptation.
722 const cmsCIEXYZ d50 = D50_XYZ();
723
724 cmsCIEXYZ r, g, b;
725 cmsAdaptToIlluminant(&r, &d50, &wp_unadapted, adapted_r);
726 cmsAdaptToIlluminant(&g, &d50, &wp_unadapted, adapted_g);
727 cmsAdaptToIlluminant(&b, &d50, &wp_unadapted, adapted_b);
728
729 const PrimariesCIExy rgb = {CIExyFromXYZ(r), CIExyFromXYZ(g),
730 CIExyFromXYZ(b)};
731 return c->SetPrimaries(rgb);
732 }
733
734 Status DetectTransferFunction(const cmsContext context, const Profile& profile,
735 ColorEncoding* JXL_RESTRICT c) {
736 JXL_ENSURE(c->color_space != ColorSpace::kXYB);
737
738 float gamma = 0;
739 if (const auto* gray_trc = reinterpret_cast<const cmsToneCurve*>(
740 cmsReadTag(profile.get(), cmsSigGrayTRCTag))) {
741 const double estimated_gamma =
742 cmsEstimateGamma(gray_trc, /*precision=*/1e-4);
743 if (estimated_gamma > 0) {
744 gamma = 1. / estimated_gamma;
745 }
746 } else {
747 float rgb_gamma[3] = {};
748 int i = 0;
749 for (const auto tag :
750 {cmsSigRedTRCTag, cmsSigGreenTRCTag, cmsSigBlueTRCTag}) {
751 if (const auto* trc = reinterpret_cast<const cmsToneCurve*>(
752 cmsReadTag(profile.get(), tag))) {
753 const double estimated_gamma =
754 cmsEstimateGamma(trc, /*precision=*/1e-4);
755 if (estimated_gamma > 0) {
756 rgb_gamma[i] = 1. / estimated_gamma;
757 }
758 }
759 ++i;
760 }
761 if (rgb_gamma[0] != 0 && std::abs(rgb_gamma[0] - rgb_gamma[1]) < 1e-4f &&
762 std::abs(rgb_gamma[1] - rgb_gamma[2]) < 1e-4f) {
763 gamma = rgb_gamma[0];
764 }
765 }
766
767 if (gamma != 0 && c->tf.SetGamma(gamma)) {
768 IccBytes icc_test;
769 if (MaybeCreateProfile(c->ToExternal(), &icc_test) &&
770 ProfileEquivalentToICC(context, profile, icc_test, *c)) {
771 return true;
772 }
773 }
774
775 for (TransferFunction tf : Values<TransferFunction>()) {
776 // Can only create profile from known transfer function.
777 if (tf == TransferFunction::kUnknown) continue;
778
779 c->tf.SetTransferFunction(tf);
780
781 IccBytes icc_test;
782 if (MaybeCreateProfile(c->ToExternal(), &icc_test) &&
783 ProfileEquivalentToICC(context, profile, icc_test, *c)) {
784 return true;
785 }
786 }
787
788 c->tf.SetTransferFunction(TransferFunction::kUnknown);
789 return true;
790 }
791
792 void ErrorHandler(cmsContext context, cmsUInt32Number code, const char* text) {
793 JXL_WARNING("LCMS error %u: %s", code, text);
794 }
795
796 // Returns a context for the current thread, creating it if necessary.
797 cmsContext GetContext() {
798 static thread_local void* context_;
799 if (context_ == nullptr) {
800 context_ = cmsCreateContext(nullptr, nullptr);
801 JXL_DASSERT(context_ != nullptr);
802
803 cmsSetLogErrorHandlerTHR(static_cast<cmsContext>(context_), &ErrorHandler);
804 }
805 return static_cast<cmsContext>(context_);
806 }
807
808 #endif // JPEGXL_ENABLE_SKCMS
809
810 Status GetPrimariesLuminances(const ColorEncoding& encoding,
811 float luminances[3]) {
812 // Explanation:
813 // We know that the three primaries must sum to white:
814 //
815 // [Xr, Xg, Xb; [1; [Xw;
816 // Yr, Yg, Yb; × 1; = Yw;
817 // Zr, Zg, Zb] 1] Zw]
818 //
819 // By noting that X = x·(X+Y+Z), Y = y·(X+Y+Z) and Z = z·(X+Y+Z) (note the
820 // lower case indicating chromaticity), and factoring the totals (X+Y+Z) out
821 // of the left matrix and into the all-ones vector, we get:
822 //
823 // [xr, xg, xb; [Xr + Yr + Zr; [Xw;
824 // yr, yg, yb; × Xg + Yg + Zg; = Yw;
825 // zr, zg, zb] Xb + Yb + Zb] Zw]
826 //
827 // Which makes it apparent that we can compute those totals as:
828 //
829 // [Xr + Yr + Zr; inv([xr, xg, xb; [Xw;
830 // Xg + Yg + Zg; = yr, yg, yb; × Yw;
831 // Xb + Yb + Zb] zr, zg, zb]) Zw]
832 //
833 // From there, by multiplying each total by its corresponding y, we get Y for
834 // that primary.
835
836 Color white_XYZ;
837 CIExy wp = encoding.GetWhitePoint();
838 JXL_RETURN_IF_ERROR(CIEXYZFromWhiteCIExy(wp.x, wp.y, white_XYZ));
839
840 PrimariesCIExy primaries;
841 JXL_RETURN_IF_ERROR(encoding.GetPrimaries(primaries));
842 Matrix3x3d chromaticities{
843 {{primaries.r.x, primaries.g.x, primaries.b.x},
844 {primaries.r.y, primaries.g.y, primaries.b.y},
845 {1 - primaries.r.x - primaries.r.y, 1 - primaries.g.x - primaries.g.y,
846 1 - primaries.b.x - primaries.b.y}}};
847 JXL_RETURN_IF_ERROR(Inv3x3Matrix(chromaticities));
848 const double ys[3] = {primaries.r.y, primaries.g.y, primaries.b.y};
849 for (size_t i = 0; i < 3; ++i) {
850 luminances[i] = ys[i] * (chromaticities[i][0] * white_XYZ[0] +
851 chromaticities[i][1] * white_XYZ[1] +
852 chromaticities[i][2] * white_XYZ[2]);
853 }
854 return true;
855 }
856
857 Status ApplyHlgOotf(JxlCms* t, float* JXL_RESTRICT buf, size_t xsize,
858 bool forward) {
859 if (295 <= t->intensity_target && t->intensity_target <= 305) {
860 // The gamma is approximately 1 so this can essentially be skipped.
861 return true;
862 }
863 float gamma = 1.2f * std::pow(1.111f, std::log2(t->intensity_target * 1e-3f));
864 if (!forward) gamma = 1.f / gamma;
865
866 switch (t->hlg_ootf_num_channels) {
867 case 1:
868 for (size_t x = 0; x < xsize; ++x) {
869 buf[x] = std::pow(buf[x], gamma);
870 }
871 break;
872
873 case 3:
874 for (size_t x = 0; x < xsize; x += 3) {
875 const float luminance = buf[x] * t->hlg_ootf_luminances[0] +
876 buf[x + 1] * t->hlg_ootf_luminances[1] +
877 buf[x + 2] * t->hlg_ootf_luminances[2];
878 const float ratio = std::pow(luminance, gamma - 1);
879 if (std::isfinite(ratio)) {
880 buf[x] *= ratio;
881 buf[x + 1] *= ratio;
882 buf[x + 2] *= ratio;
883 if (forward && gamma < 1) {
884 // If gamma < 1, the ratio above will be > 1 which can push bright
885 // saturated highlights out of gamut. There are several possible
886 // ways to bring them back in-gamut; this one preserves hue and
887 // saturation at the slight expense of luminance. If !forward, the
888 // previously-applied forward OOTF with gamma > 1 already pushed
889 // those highlights down and we are simply putting them back where
890 // they were so this is not necessary.
891 const float maximum =
892 std::max(buf[x], std::max(buf[x + 1], buf[x + 2]));
893 if (maximum > 1) {
894 const float normalizer = 1.f / maximum;
895 buf[x] *= normalizer;
896 buf[x + 1] *= normalizer;
897 buf[x + 2] *= normalizer;
898 }
899 }
900 }
901 }
902 break;
903
904 default:
905 return JXL_FAILURE("HLG OOTF not implemented for %" PRIuS " channels",
906 t->hlg_ootf_num_channels);
907 }
908 return true;
909 }
910
911 bool IsKnownTransferFunction(jxl::cms::TransferFunction tf) {
912 using TF = jxl::cms::TransferFunction;
913 // All but kUnknown
914 return tf == TF::k709 || tf == TF::kLinear || tf == TF::kSRGB ||
915 tf == TF::kPQ || tf == TF::kDCI || tf == TF::kHLG;
916 }
917
918 constexpr uint8_t kColorPrimariesP3_D65 = 12;
919
920 bool IsKnownColorPrimaries(uint8_t color_primaries) {
921 using P = jxl::cms::Primaries;
922 // All but kCustom
923 if (color_primaries == kColorPrimariesP3_D65) return true;
924 const auto p = static_cast<Primaries>(color_primaries);
925 return p == P::kSRGB || p == P::k2100 || p == P::kP3;
926 }
927
928 bool ApplyCICP(const uint8_t color_primaries,
929 const uint8_t transfer_characteristics,
930 const uint8_t matrix_coefficients, const uint8_t full_range,
931 ColorEncoding* JXL_RESTRICT c) {
932 if (matrix_coefficients != 0) return false;
933 if (full_range != 1) return false;
934
935 const auto primaries = static_cast<Primaries>(color_primaries);
936 const auto tf = static_cast<TransferFunction>(transfer_characteristics);
937 if (!IsKnownTransferFunction(tf)) return false;
938 if (!IsKnownColorPrimaries(color_primaries)) return false;
939 c->color_space = ColorSpace::kRGB;
940 c->tf.SetTransferFunction(tf);
941 if (primaries == Primaries::kP3) {
942 c->white_point = WhitePoint::kDCI;
943 c->primaries = Primaries::kP3;
944 } else if (color_primaries == kColorPrimariesP3_D65) {
945 c->white_point = WhitePoint::kD65;
946 c->primaries = Primaries::kP3;
947 } else {
948 c->white_point = WhitePoint::kD65;
949 c->primaries = primaries;
950 }
951 return true;
952 }
953
954 JXL_BOOL JxlCmsSetFieldsFromICC(void* user_data, const uint8_t* icc_data,
955 size_t icc_size, JxlColorEncoding* c,
956 JXL_BOOL* cmyk) {
957 if (c == nullptr) return JXL_FALSE;
958 if (cmyk == nullptr) return JXL_FALSE;
959
960 *cmyk = JXL_FALSE;
961
962 // In case parsing fails, mark the ColorEncoding as invalid.
963 c->color_space = JXL_COLOR_SPACE_UNKNOWN;
964 c->transfer_function = JXL_TRANSFER_FUNCTION_UNKNOWN;
965
966 if (icc_size == 0) return JXL_FAILURE("Empty ICC profile");
967
968 ColorEncoding c_enc;
969
970 #if JPEGXL_ENABLE_SKCMS
971 if (icc_size < 128) {
972 return JXL_FAILURE("ICC file too small");
973 }
974
975 skcms_ICCProfile profile;
976 JXL_RETURN_IF_ERROR(skcms_Parse(icc_data, icc_size, &profile));
977
978 // skcms does not return the rendering intent, so get it from the file. It
979 // should be encoded as big-endian 32-bit integer in bytes 60..63.
980 uint32_t big_endian_rendering_intent = icc_data[67] + (icc_data[66] << 8) +
981 (icc_data[65] << 16) +
982 (icc_data[64] << 24);
983 // Some files encode rendering intent as little endian, which is not spec
984 // compliant. However we accept those with a warning.
985 uint32_t little_endian_rendering_intent = (icc_data[67] << 24) +
986 (icc_data[66] << 16) +
987 (icc_data[65] << 8) + icc_data[64];
988 uint32_t candidate_rendering_intent =
989 std::min(big_endian_rendering_intent, little_endian_rendering_intent);
990 if (candidate_rendering_intent != big_endian_rendering_intent) {
991 JXL_WARNING(
992 "Invalid rendering intent bytes: [0x%02X 0x%02X 0x%02X 0x%02X], "
993 "assuming %u was meant",
994 icc_data[64], icc_data[65], icc_data[66], icc_data[67],
995 candidate_rendering_intent);
996 }
997 if (candidate_rendering_intent > 3) {
998 return JXL_FAILURE("Invalid rendering intent %u\n",
999 candidate_rendering_intent);
1000 }
1001 // ICC and RenderingIntent have the same values (0..3).
1002 c_enc.rendering_intent =
1003 static_cast<RenderingIntent>(candidate_rendering_intent);
1004
1005 if (profile.has_CICP &&
1006 ApplyCICP(profile.CICP.color_primaries,
1007 profile.CICP.transfer_characteristics,
1008 profile.CICP.matrix_coefficients,
1009 profile.CICP.video_full_range_flag, &c_enc)) {
1010 *c = c_enc.ToExternal();
1011 return JXL_TRUE;
1012 }
1013
1014 c_enc.color_space = ColorSpaceFromProfile(profile);
1015 *cmyk = TO_JXL_BOOL(profile.data_color_space == skcms_Signature_CMYK);
1016
1017 CIExy wp_unadapted;
1018 JXL_RETURN_IF_ERROR(UnadaptedWhitePoint(profile, &wp_unadapted));
1019 JXL_RETURN_IF_ERROR(c_enc.SetWhitePoint(wp_unadapted));
1020
1021 // Relies on color_space.
1022 JXL_RETURN_IF_ERROR(IdentifyPrimaries(profile, wp_unadapted, &c_enc));
1023
1024 // Relies on color_space/white point/primaries being set already.
1025 JXL_RETURN_IF_ERROR(DetectTransferFunction(profile, &c_enc));
1026 #else // JPEGXL_ENABLE_SKCMS
1027
1028 const cmsContext context = GetContext();
1029
1030 Profile profile;
1031 JXL_RETURN_IF_ERROR(
1032 DecodeProfile(context, Bytes(icc_data, icc_size), &profile));
1033
1034 const cmsUInt32Number rendering_intent32 =
1035 cmsGetHeaderRenderingIntent(profile.get());
1036 if (rendering_intent32 > 3) {
1037 return JXL_FAILURE("Invalid rendering intent %u\n", rendering_intent32);
1038 }
1039 // ICC and RenderingIntent have the same values (0..3).
1040 c_enc.rendering_intent = static_cast<RenderingIntent>(rendering_intent32);
1041
1042 static constexpr size_t kCICPSize = 12;
1043 static constexpr auto kCICPSignature =
1044 static_cast<cmsTagSignature>(0x63696370);
1045 uint8_t cicp_buffer[kCICPSize];
1046 if (cmsReadRawTag(profile.get(), kCICPSignature, cicp_buffer, kCICPSize) ==
1047 kCICPSize &&
1048 ApplyCICP(cicp_buffer[8], cicp_buffer[9], cicp_buffer[10],
1049 cicp_buffer[11], &c_enc)) {
1050 *c = c_enc.ToExternal();
1051 return JXL_TRUE;
1052 }
1053
1054 c_enc.color_space = ColorSpaceFromProfile(profile);
1055 if (cmsGetColorSpace(profile.get()) == cmsSigCmykData) {
1056 *cmyk = JXL_TRUE;
1057 *c = c_enc.ToExternal();
1058 return JXL_TRUE;
1059 }
1060
1061 const cmsCIEXYZ wp_unadapted = UnadaptedWhitePoint(context, profile, c_enc);
1062 JXL_RETURN_IF_ERROR(c_enc.SetWhitePoint(CIExyFromXYZ(wp_unadapted)));
1063
1064 // Relies on color_space.
1065 JXL_RETURN_IF_ERROR(
1066 IdentifyPrimaries(context, profile, wp_unadapted, &c_enc));
1067
1068 // Relies on color_space/white point/primaries being set already.
1069 JXL_RETURN_IF_ERROR(DetectTransferFunction(context, profile, &c_enc));
1070
1071 #endif // JPEGXL_ENABLE_SKCMS
1072
1073 *c = c_enc.ToExternal();
1074 return JXL_TRUE;
1075 }
1076
1077 } // namespace
1078
1079 namespace {
1080
1081 void JxlCmsDestroy(void* cms_data) {
1082 if (cms_data == nullptr) return;
1083 JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
1084 #if !JPEGXL_ENABLE_SKCMS
1085 TransformDeleter()(t->lcms_transform);
1086 #endif
1087 delete t;
1088 }
1089
1090 void AllocateBuffer(size_t length, size_t num_threads,
1091 std::vector<float>* storage, std::vector<float*>* view) {
1092 constexpr size_t kAlign = 128 / sizeof(float);
1093 size_t stride = RoundUpTo(length, kAlign);
1094 storage->resize(stride * num_threads + kAlign);
1095 intptr_t addr = reinterpret_cast<intptr_t>(storage->data());
1096 size_t offset =
1097 (RoundUpTo(addr, kAlign * sizeof(float)) - addr) / sizeof(float);
1098 view->clear();
1099 view->reserve(num_threads);
1100 for (size_t i = 0; i < num_threads; ++i) {
1101 view->emplace_back(storage->data() + offset + i * stride);
1102 }
1103 }
1104
1105 void* JxlCmsInit(void* init_data, size_t num_threads, size_t xsize,
1106 const JxlColorProfile* input, const JxlColorProfile* output,
1107 float intensity_target) {
1108 if (init_data == nullptr) {
1109 JXL_NOTIFY_ERROR("JxlCmsInit: init_data is nullptr");
1110 return nullptr;
1111 }
1112 const auto* cms = static_cast<const JxlCmsInterface*>(init_data);
1113 auto t = jxl::make_unique<JxlCms>();
1114 IccBytes icc_src;
1115 IccBytes icc_dst;
1116 if (input->icc.size == 0) {
1117 JXL_NOTIFY_ERROR("JxlCmsInit: empty input ICC");
1118 return nullptr;
1119 }
1120 if (output->icc.size == 0) {
1121 JXL_NOTIFY_ERROR("JxlCmsInit: empty OUTPUT ICC");
1122 return nullptr;
1123 }
1124 icc_src.assign(input->icc.data, input->icc.data + input->icc.size);
1125 ColorEncoding c_src;
1126 if (!c_src.SetFieldsFromICC(std::move(icc_src), *cms)) {
1127 JXL_NOTIFY_ERROR("JxlCmsInit: failed to parse input ICC");
1128 return nullptr;
1129 }
1130 icc_dst.assign(output->icc.data, output->icc.data + output->icc.size);
1131 ColorEncoding c_dst;
1132 if (!c_dst.SetFieldsFromICC(std::move(icc_dst), *cms)) {
1133 JXL_NOTIFY_ERROR("JxlCmsInit: failed to parse output ICC");
1134 return nullptr;
1135 }
1136 #if JXL_CMS_VERBOSE
1137 printf("%s -> %s\n", Description(c_src).c_str(), Description(c_dst).c_str());
1138 #endif
1139
1140 #if JPEGXL_ENABLE_SKCMS
1141 if (!DecodeProfile(input->icc.data, input->icc.size, &t->profile_src)) {
1142 JXL_NOTIFY_ERROR("JxlCmsInit: skcms failed to parse input ICC");
1143 return nullptr;
1144 }
1145 if (!DecodeProfile(output->icc.data, output->icc.size, &t->profile_dst)) {
1146 JXL_NOTIFY_ERROR("JxlCmsInit: skcms failed to parse output ICC");
1147 return nullptr;
1148 }
1149 #else // JPEGXL_ENABLE_SKCMS
1150 const cmsContext context = GetContext();
1151 Profile profile_src, profile_dst;
1152 if (!DecodeProfile(context, Bytes(c_src.icc), &profile_src)) {
1153 JXL_NOTIFY_ERROR("JxlCmsInit: lcms failed to parse input ICC");
1154 return nullptr;
1155 }
1156 if (!DecodeProfile(context, Bytes(c_dst.icc), &profile_dst)) {
1157 JXL_NOTIFY_ERROR("JxlCmsInit: lcms failed to parse output ICC");
1158 return nullptr;
1159 }
1160 #endif // JPEGXL_ENABLE_SKCMS
1161
1162 t->skip_lcms = false;
1163 if (c_src.SameColorEncoding(c_dst)) {
1164 t->skip_lcms = true;
1165 #if JXL_CMS_VERBOSE
1166 printf("Skip CMS\n");
1167 #endif
1168 }
1169
1170 t->apply_hlg_ootf = c_src.tf.IsHLG() != c_dst.tf.IsHLG();
1171 if (t->apply_hlg_ootf) {
1172 const ColorEncoding* c_hlg = c_src.tf.IsHLG() ? &c_src : &c_dst;
1173 t->hlg_ootf_num_channels = c_hlg->Channels();
1174 if (t->hlg_ootf_num_channels == 3 &&
1175 !GetPrimariesLuminances(*c_hlg, t->hlg_ootf_luminances.data())) {
1176 JXL_NOTIFY_ERROR(
1177 "JxlCmsInit: failed to compute the luminances of primaries");
1178 return nullptr;
1179 }
1180 }
1181
1182 // Special-case SRGB <=> linear if the primaries / white point are the same,
1183 // or any conversion where PQ or HLG is involved:
1184 bool src_linear = c_src.tf.IsLinear();
1185 const bool dst_linear = c_dst.tf.IsLinear();
1186
1187 if (c_src.tf.IsPQ() || c_src.tf.IsHLG() ||
1188 (c_src.tf.IsSRGB() && dst_linear && c_src.SameColorSpace(c_dst))) {
1189 // Construct new profile as if the data were already/still linear.
1190 ColorEncoding c_linear_src = c_src;
1191 c_linear_src.tf.SetTransferFunction(TransferFunction::kLinear);
1192 #if JPEGXL_ENABLE_SKCMS
1193 skcms_ICCProfile new_src;
1194 #else // JPEGXL_ENABLE_SKCMS
1195 Profile new_src;
1196 #endif // JPEGXL_ENABLE_SKCMS
1197 // Only enable ExtraTF if profile creation succeeded.
1198 if (MaybeCreateProfile(c_linear_src.ToExternal(), &icc_src) &&
1199 #if JPEGXL_ENABLE_SKCMS
1200 DecodeProfile(icc_src.data(), icc_src.size(), &new_src)) {
1201 #else // JPEGXL_ENABLE_SKCMS
1202 DecodeProfile(context, Bytes(icc_src), &new_src)) {
1203 #endif // JPEGXL_ENABLE_SKCMS
1204 #if JXL_CMS_VERBOSE
1205 printf("Special HLG/PQ/sRGB -> linear\n");
1206 #endif
1207 #if JPEGXL_ENABLE_SKCMS
1208 t->icc_src = std::move(icc_src);
1209 t->profile_src = new_src;
1210 #else // JPEGXL_ENABLE_SKCMS
1211 profile_src.swap(new_src);
1212 #endif // JPEGXL_ENABLE_SKCMS
1213 t->preprocess = c_src.tf.IsSRGB()
1214 ? ExtraTF::kSRGB
1215 : (c_src.tf.IsPQ() ? ExtraTF::kPQ : ExtraTF::kHLG);
1216 c_src = c_linear_src;
1217 src_linear = true;
1218 } else {
1219 if (t->apply_hlg_ootf) {
1220 JXL_NOTIFY_ERROR(
1221 "Failed to create extra linear source profile, and HLG OOTF "
1222 "required");
1223 return nullptr;
1224 }
1225 JXL_WARNING("Failed to create extra linear destination profile");
1226 }
1227 }
1228
1229 if (c_dst.tf.IsPQ() || c_dst.tf.IsHLG() ||
1230 (c_dst.tf.IsSRGB() && src_linear && c_src.SameColorSpace(c_dst))) {
1231 ColorEncoding c_linear_dst = c_dst;
1232 c_linear_dst.tf.SetTransferFunction(TransferFunction::kLinear);
1233 #if JPEGXL_ENABLE_SKCMS
1234 skcms_ICCProfile new_dst;
1235 #else // JPEGXL_ENABLE_SKCMS
1236 Profile new_dst;
1237 #endif // JPEGXL_ENABLE_SKCMS
1238 // Only enable ExtraTF if profile creation succeeded.
1239 if (MaybeCreateProfile(c_linear_dst.ToExternal(), &icc_dst) &&
1240 #if JPEGXL_ENABLE_SKCMS
1241 DecodeProfile(icc_dst.data(), icc_dst.size(), &new_dst)) {
1242 #else // JPEGXL_ENABLE_SKCMS
1243 DecodeProfile(context, Bytes(icc_dst), &new_dst)) {
1244 #endif // JPEGXL_ENABLE_SKCMS
1245 #if JXL_CMS_VERBOSE
1246 printf("Special linear -> HLG/PQ/sRGB\n");
1247 #endif
1248 #if JPEGXL_ENABLE_SKCMS
1249 t->icc_dst = std::move(icc_dst);
1250 t->profile_dst = new_dst;
1251 #else // JPEGXL_ENABLE_SKCMS
1252 profile_dst.swap(new_dst);
1253 #endif // JPEGXL_ENABLE_SKCMS
1254 t->postprocess = c_dst.tf.IsSRGB()
1255 ? ExtraTF::kSRGB
1256 : (c_dst.tf.IsPQ() ? ExtraTF::kPQ : ExtraTF::kHLG);
1257 c_dst = c_linear_dst;
1258 } else {
1259 if (t->apply_hlg_ootf) {
1260 JXL_NOTIFY_ERROR(
1261 "Failed to create extra linear destination profile, and inverse "
1262 "HLG OOTF required");
1263 return nullptr;
1264 }
1265 JXL_WARNING("Failed to create extra linear destination profile");
1266 }
1267 }
1268
1269 if (c_src.SameColorEncoding(c_dst)) {
1270 #if JXL_CMS_VERBOSE
1271 printf("Same intermediary linear profiles, skipping CMS\n");
1272 #endif
1273 t->skip_lcms = true;
1274 }
1275
1276 #if JPEGXL_ENABLE_SKCMS
1277 if (!skcms_MakeUsableAsDestination(&t->profile_dst)) {
1278 JXL_NOTIFY_ERROR(
1279 "Failed to make %s usable as a color transform destination",
1280 ColorEncodingDescription(c_dst.ToExternal()).c_str());
1281 return nullptr;
1282 }
1283 #endif // JPEGXL_ENABLE_SKCMS
1284
1285 // Not including alpha channel (copied separately).
1286 const size_t channels_src = (c_src.cmyk ? 4 : c_src.Channels());
1287 const size_t channels_dst = c_dst.Channels();
1288 #if JXL_CMS_VERBOSE
1289 printf("Channels: %" PRIuS "; Threads: %" PRIuS "\n", channels_src,
1290 num_threads);
1291 #endif
1292
1293 #if !JPEGXL_ENABLE_SKCMS
1294 // Type includes color space (XYZ vs RGB), so can be different.
1295 const uint32_t type_src = Type32(c_src, channels_src == 4);
1296 const uint32_t type_dst = Type32(c_dst, false);
1297 const uint32_t intent = static_cast<uint32_t>(c_dst.rendering_intent);
1298 // Use cmsFLAGS_NOCACHE to disable the 1-pixel cache and make calling
1299 // cmsDoTransform() thread-safe.
1300 const uint32_t flags = cmsFLAGS_NOCACHE | cmsFLAGS_BLACKPOINTCOMPENSATION |
1301 cmsFLAGS_HIGHRESPRECALC;
1302 t->lcms_transform =
1303 cmsCreateTransformTHR(context, profile_src.get(), type_src,
1304 profile_dst.get(), type_dst, intent, flags);
1305 if (t->lcms_transform == nullptr) {
1306 JXL_NOTIFY_ERROR("Failed to create transform");
1307 return nullptr;
1308 }
1309 #endif // !JPEGXL_ENABLE_SKCMS
1310
1311 // Ideally LCMS would convert directly from External to Image3. However,
1312 // cmsDoTransformLineStride only accepts 32-bit BytesPerPlaneIn, whereas our
1313 // planes can be more than 4 GiB apart. Hence, transform inputs/outputs must
1314 // be interleaved. Calling cmsDoTransform for each pixel is expensive
1315 // (indirect call). We therefore transform rows, which requires per-thread
1316 // buffers. To avoid separate allocations, we use the rows of an image.
1317 // Because LCMS apparently also cannot handle <= 16 bit inputs and 32-bit
1318 // outputs (or vice versa), we use floating point input/output.
1319 t->channels_src = channels_src;
1320 t->channels_dst = channels_dst;
1321 #if !JPEGXL_ENABLE_SKCMS
1322 size_t actual_channels_src = channels_src;
1323 size_t actual_channels_dst = channels_dst;
1324 #else
1325 // SkiaCMS doesn't support grayscale float buffers, so we create space for RGB
1326 // float buffers anyway.
1327 size_t actual_channels_src = (channels_src == 4 ? 4 : 3);
1328 size_t actual_channels_dst = 3;
1329 #endif
1330 AllocateBuffer(xsize * actual_channels_src, num_threads, &t->src_storage,
1331 &t->buf_src);
1332 AllocateBuffer(xsize * actual_channels_dst, num_threads, &t->dst_storage,
1333 &t->buf_dst);
1334 t->intensity_target = intensity_target;
1335 return t.release();
1336 }
1337
1338 float* JxlCmsGetSrcBuf(void* cms_data, size_t thread) {
1339 JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
1340 return t->buf_src[thread];
1341 }
1342
1343 float* JxlCmsGetDstBuf(void* cms_data, size_t thread) {
1344 JxlCms* t = reinterpret_cast<JxlCms*>(cms_data);
1345 return t->buf_dst[thread];
1346 }
1347
1348 } // namespace
1349
1350 extern "C" {
1351
1352 JXL_CMS_EXPORT const JxlCmsInterface* JxlGetDefaultCms() {
1353 static constexpr JxlCmsInterface kInterface = {
1354 /*set_fields_data=*/nullptr,
1355 /*set_fields_from_icc=*/&JxlCmsSetFieldsFromICC,
1356 /*init_data=*/const_cast<void*>(static_cast<const void*>(&kInterface)),
1357 /*init=*/&JxlCmsInit,
1358 /*get_src_buf=*/&JxlCmsGetSrcBuf,
1359 /*get_dst_buf=*/&JxlCmsGetDstBuf,
1360 /*run=*/&DoColorSpaceTransform,
1361 /*destroy=*/&JxlCmsDestroy};
1362 return &kInterface;
1363 }
1364
1365 } // extern "C"
1366
1367 } // namespace jxl
1368 #endif // HWY_ONCE