tone_mapping-inl.h (7008B)
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 #if defined(LIB_JXL_CMS_TONE_MAPPING_INL_H_) == defined(HWY_TARGET_TOGGLE) 7 #ifdef LIB_JXL_CMS_TONE_MAPPING_INL_H_ 8 #undef LIB_JXL_CMS_TONE_MAPPING_INL_H_ 9 #else 10 #define LIB_JXL_CMS_TONE_MAPPING_INL_H_ 11 #endif 12 13 #include <hwy/highway.h> 14 15 #include "lib/jxl/cms/tone_mapping.h" 16 #include "lib/jxl/cms/transfer_functions-inl.h" 17 18 HWY_BEFORE_NAMESPACE(); 19 namespace jxl { 20 namespace HWY_NAMESPACE { 21 namespace { 22 23 // These templates are not found via ADL. 24 using hwy::HWY_NAMESPACE::Clamp; 25 using hwy::HWY_NAMESPACE::Max; 26 using hwy::HWY_NAMESPACE::ZeroIfNegative; 27 28 template <typename D> 29 class Rec2408ToneMapper : Rec2408ToneMapperBase { 30 private: 31 using V = hwy::HWY_NAMESPACE::Vec<D>; 32 33 public: 34 using Rec2408ToneMapperBase::Rec2408ToneMapperBase; 35 36 void ToneMap(V* red, V* green, V* blue) const { 37 const V luminance = Mul(Set(df_, source_range_.second), 38 (MulAdd(Set(df_, red_Y_), *red, 39 MulAdd(Set(df_, green_Y_), *green, 40 Mul(Set(df_, blue_Y_), *blue))))); 41 const V pq_mastering_min = Set(df_, pq_mastering_min_); 42 const V inv_pq_mastering_range = Set(df_, inv_pq_mastering_range_); 43 const V normalized_pq = Min( 44 Set(df_, 1.f), 45 Mul(Sub(InvEOTF(luminance), pq_mastering_min), inv_pq_mastering_range)); 46 const V ks = Set(df_, ks_); 47 const V e2 = 48 IfThenElse(Lt(normalized_pq, ks), normalized_pq, P(normalized_pq)); 49 const V one_minus_e2 = Sub(Set(df_, 1), e2); 50 const V one_minus_e2_2 = Mul(one_minus_e2, one_minus_e2); 51 const V one_minus_e2_4 = Mul(one_minus_e2_2, one_minus_e2_2); 52 const V b = Set(df_, min_lum_); 53 const V e3 = MulAdd(b, one_minus_e2_4, e2); 54 const V pq_mastering_range = Set(df_, pq_mastering_range_); 55 const V e4 = MulAdd(e3, pq_mastering_range, pq_mastering_min); 56 const V new_luminance = 57 Min(Set(df_, target_range_.second), 58 ZeroIfNegative(tf_pq_.DisplayFromEncoded(df_, e4))); 59 const V min_luminance = Set(df_, 1e-6f); 60 const auto use_cap = Le(luminance, min_luminance); 61 const V ratio = Div(new_luminance, Max(luminance, min_luminance)); 62 const V cap = Mul(new_luminance, Set(df_, inv_target_peak_)); 63 const V normalizer = Set(df_, normalizer_); 64 const V multiplier = Mul(ratio, normalizer); 65 for (V* const val : {red, green, blue}) { 66 *val = IfThenElse(use_cap, cap, Mul(*val, multiplier)); 67 } 68 } 69 70 private: 71 V InvEOTF(const V luminance) const { 72 return tf_pq_.EncodedFromDisplay(df_, luminance); 73 } 74 V T(const V a) const { 75 const V ks = Set(df_, ks_); 76 const V inv_one_minus_ks = Set(df_, inv_one_minus_ks_); 77 return Mul(Sub(a, ks), inv_one_minus_ks); 78 } 79 V P(const V b) const { 80 const V t_b = T(b); 81 const V t_b_2 = Mul(t_b, t_b); 82 const V t_b_3 = Mul(t_b_2, t_b); 83 const V ks = Set(df_, ks_); 84 const V max_lum = Set(df_, max_lum_); 85 return MulAdd( 86 MulAdd(Set(df_, 2), t_b_3, MulAdd(Set(df_, -3), t_b_2, Set(df_, 1))), 87 ks, 88 MulAdd(Add(t_b_3, MulAdd(Set(df_, -2), t_b_2, t_b)), 89 Sub(Set(df_, 1), ks), 90 Mul(MulAdd(Set(df_, -2), t_b_3, Mul(Set(df_, 3), t_b_2)), 91 max_lum))); 92 } 93 94 D df_; 95 const TF_PQ tf_pq_ = TF_PQ(/*display_intensity_target=*/1.0); 96 }; 97 98 class HlgOOTF : HlgOOTF_Base { 99 public: 100 using HlgOOTF_Base::HlgOOTF_Base; 101 102 static HlgOOTF FromSceneLight(float display_luminance, 103 const Vector3& primaries_luminances) { 104 return HlgOOTF(/*gamma=*/1.2f * 105 std::pow(1.111f, std::log2(display_luminance / 1000.f)), 106 primaries_luminances); 107 } 108 109 static HlgOOTF ToSceneLight(float display_luminance, 110 const Vector3& primaries_luminances) { 111 return HlgOOTF( 112 /*gamma=*/(1 / 1.2f) * 113 std::pow(1.111f, -std::log2(display_luminance / 1000.f)), 114 primaries_luminances); 115 } 116 117 template <typename V> 118 void Apply(V* red, V* green, V* blue) const { 119 hwy::HWY_NAMESPACE::DFromV<V> df; 120 if (!apply_ootf_) return; 121 const V luminance = 122 MulAdd(Set(df, red_Y_), *red, 123 MulAdd(Set(df, green_Y_), *green, Mul(Set(df, blue_Y_), *blue))); 124 const V ratio = 125 Min(FastPowf(df, luminance, Set(df, exponent_)), Set(df, 1e9)); 126 *red = Mul(*red, ratio); 127 *green = Mul(*green, ratio); 128 *blue = Mul(*blue, ratio); 129 } 130 131 bool WarrantsGamutMapping() const { return apply_ootf_ && exponent_ < 0; } 132 }; 133 134 template <typename V> 135 void GamutMap(V* red, V* green, V* blue, const Vector3& primaries_luminances, 136 float preserve_saturation = 0.1f) { 137 hwy::HWY_NAMESPACE::DFromV<V> df; 138 const V luminance = 139 MulAdd(Set(df, primaries_luminances[0]), *red, 140 MulAdd(Set(df, primaries_luminances[1]), *green, 141 Mul(Set(df, primaries_luminances[2]), *blue))); 142 143 // Desaturate out-of-gamut pixels. This is done by mixing each pixel 144 // with just enough gray of the target luminance to make all 145 // components non-negative. 146 // - For saturation preservation, if a component is still larger than 147 // 1 then the pixel is normalized to have a maximum component of 1. 148 // That will reduce its luminance. 149 // - For luminance preservation, getting all components below 1 is 150 // done by mixing in yet more gray. That will desaturate it further. 151 const V zero = Zero(df); 152 const V one = Set(df, 1); 153 V gray_mix_saturation = zero; 154 V gray_mix_luminance = zero; 155 for (const V* ch : {red, green, blue}) { 156 const V& val = *ch; 157 const V val_minus_gray = Sub(val, luminance); 158 const V inv_val_minus_gray = 159 Div(one, IfThenElse(Eq(val_minus_gray, zero), one, val_minus_gray)); 160 const V val_over_val_minus_gray = Mul(val, inv_val_minus_gray); 161 gray_mix_saturation = 162 IfThenElse(Ge(val_minus_gray, zero), gray_mix_saturation, 163 Max(gray_mix_saturation, val_over_val_minus_gray)); 164 gray_mix_luminance = 165 Max(gray_mix_luminance, 166 IfThenElse(Le(val_minus_gray, zero), gray_mix_saturation, 167 Sub(val_over_val_minus_gray, inv_val_minus_gray))); 168 } 169 const V gray_mix = Clamp( 170 MulAdd(Set(df, preserve_saturation), 171 Sub(gray_mix_saturation, gray_mix_luminance), gray_mix_luminance), 172 zero, one); 173 for (V* const ch : {red, green, blue}) { 174 V& val = *ch; 175 val = MulAdd(gray_mix, Sub(luminance, val), val); 176 } 177 const V max_clr = Max(Max(one, *red), Max(*green, *blue)); 178 const V normalizer = Div(one, max_clr); 179 for (V* const ch : {red, green, blue}) { 180 V& val = *ch; 181 val = Mul(val, normalizer); 182 } 183 } 184 185 } // namespace 186 // NOLINTNEXTLINE(google-readability-namespace-comments) 187 } // namespace HWY_NAMESPACE 188 } // namespace jxl 189 HWY_AFTER_NAMESPACE(); 190 191 #endif // LIB_JXL_CMS_TONE_MAPPING_INL_H_