1 /*
2 * Copyright 2018 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/core/SkColorSpaceXformSteps.h"
9
10 #include "include/core/SkColorSpace.h"
11 #include "include/core/SkTypes.h"
12 #include "include/private/base/SkFloatingPoint.h"
13 #include "modules/skcms/skcms.h"
14 #include "src/core/SkColorSpacePriv.h"
15 #include "src/core/SkRasterPipeline.h"
16 #include "src/core/SkVM.h"
17
18 // See skia.org/user/color (== site/user/color.md).
19
SkColorSpaceXformSteps(const SkColorSpace * src,SkAlphaType srcAT,const SkColorSpace * dst,SkAlphaType dstAT)20 SkColorSpaceXformSteps::SkColorSpaceXformSteps(const SkColorSpace* src, SkAlphaType srcAT,
21 const SkColorSpace* dst, SkAlphaType dstAT) {
22 // Opaque outputs are treated as the same alpha type as the source input.
23 // TODO: we'd really like to have a good way of explaining why we think this is useful.
24 if (dstAT == kOpaque_SkAlphaType) {
25 dstAT = srcAT;
26 }
27
28 // We have some options about what to do with null src or dst here.
29 // This pair seems to be the most consistent with legacy expectations.
30 if (!src) { src = sk_srgb_singleton(); }
31 if (!dst) { dst = src; }
32
33 if (src->hash() == dst->hash() && srcAT == dstAT) {
34 SkASSERT(SkColorSpace::Equals(src,dst));
35 return;
36 }
37
38 this->flags.unpremul = srcAT == kPremul_SkAlphaType;
39 this->flags.linearize = !src->gammaIsLinear();
40 this->flags.gamut_transform = src->toXYZD50Hash() != dst->toXYZD50Hash();
41 this->flags.encode = !dst->gammaIsLinear();
42 this->flags.premul = srcAT != kOpaque_SkAlphaType && dstAT == kPremul_SkAlphaType;
43
44 if (this->flags.gamut_transform) {
45 skcms_Matrix3x3 src_to_dst; // TODO: switch src_to_dst_matrix to row-major
46 src->gamutTransformTo(dst, &src_to_dst);
47
48 this->src_to_dst_matrix[0] = src_to_dst.vals[0][0];
49 this->src_to_dst_matrix[1] = src_to_dst.vals[1][0];
50 this->src_to_dst_matrix[2] = src_to_dst.vals[2][0];
51
52 this->src_to_dst_matrix[3] = src_to_dst.vals[0][1];
53 this->src_to_dst_matrix[4] = src_to_dst.vals[1][1];
54 this->src_to_dst_matrix[5] = src_to_dst.vals[2][1];
55
56 this->src_to_dst_matrix[6] = src_to_dst.vals[0][2];
57 this->src_to_dst_matrix[7] = src_to_dst.vals[1][2];
58 this->src_to_dst_matrix[8] = src_to_dst.vals[2][2];
59 } else {
60 #ifdef SK_DEBUG
61 skcms_Matrix3x3 srcM, dstM;
62 src->toXYZD50(&srcM);
63 dst->toXYZD50(&dstM);
64 SkASSERT(0 == memcmp(&srcM, &dstM, 9*sizeof(float)) && "Hash collision");
65 #endif
66 }
67
68 // Fill out all the transfer functions we'll use.
69 src-> transferFn(&this->srcTF );
70 dst->invTransferFn(&this->dstTFInv);
71
72 // If we linearize then immediately reencode with the same transfer function, skip both.
73 if ( this->flags.linearize &&
74 !this->flags.gamut_transform &&
75 this->flags.encode &&
76 src->transferFnHash() == dst->transferFnHash())
77 {
78 #ifdef SK_DEBUG
79 skcms_TransferFunction dstTF;
80 dst->transferFn(&dstTF);
81 for (int i = 0; i < 7; i++) {
82 SkASSERT( (&srcTF.g)[i] == (&dstTF.g)[i] && "Hash collision" );
83 }
84 #endif
85 this->flags.linearize = false;
86 this->flags.encode = false;
87 }
88
89 // Skip unpremul...premul if there are no non-linear operations between.
90 if ( this->flags.unpremul &&
91 !this->flags.linearize &&
92 !this->flags.encode &&
93 this->flags.premul)
94 {
95 this->flags.unpremul = false;
96 this->flags.premul = false;
97 }
98 }
99
apply(float * rgba) const100 void SkColorSpaceXformSteps::apply(float* rgba) const {
101 if (flags.unpremul) {
102 // I don't know why isfinite(x) stopped working on the Chromecast bots...
103 auto is_finite = [](float x) { return x*0 == 0; };
104
105 float invA = sk_ieee_float_divide(1.0f, rgba[3]);
106 invA = is_finite(invA) ? invA : 0;
107 rgba[0] *= invA;
108 rgba[1] *= invA;
109 rgba[2] *= invA;
110 }
111 if (flags.linearize) {
112 rgba[0] = skcms_TransferFunction_eval(&srcTF, rgba[0]);
113 rgba[1] = skcms_TransferFunction_eval(&srcTF, rgba[1]);
114 rgba[2] = skcms_TransferFunction_eval(&srcTF, rgba[2]);
115 }
116 if (flags.gamut_transform) {
117 float temp[3] = { rgba[0], rgba[1], rgba[2] };
118 for (int i = 0; i < 3; ++i) {
119 rgba[i] = src_to_dst_matrix[ i] * temp[0] +
120 src_to_dst_matrix[3 + i] * temp[1] +
121 src_to_dst_matrix[6 + i] * temp[2];
122 }
123 }
124 if (flags.encode) {
125 rgba[0] = skcms_TransferFunction_eval(&dstTFInv, rgba[0]);
126 rgba[1] = skcms_TransferFunction_eval(&dstTFInv, rgba[1]);
127 rgba[2] = skcms_TransferFunction_eval(&dstTFInv, rgba[2]);
128 }
129 if (flags.premul) {
130 rgba[0] *= rgba[3];
131 rgba[1] *= rgba[3];
132 rgba[2] *= rgba[3];
133 }
134 }
135
apply(SkRasterPipeline * p) const136 void SkColorSpaceXformSteps::apply(SkRasterPipeline* p) const {
137 if (flags.unpremul) { p->append(SkRasterPipelineOp::unpremul); }
138 if (flags.linearize) { p->append_transfer_function(srcTF); }
139 if (flags.gamut_transform) { p->append(SkRasterPipelineOp::matrix_3x3, &src_to_dst_matrix); }
140 if (flags.encode) { p->append_transfer_function(dstTFInv); }
141 if (flags.premul) { p->append(SkRasterPipelineOp::premul); }
142 }
143
sk_program_transfer_fn(skvm::F32 v,skcms_TFType tf_type,skvm::F32 G,skvm::F32 A,skvm::F32 B,skvm::F32 C,skvm::F32 D,skvm::F32 E,skvm::F32 F)144 skvm::F32 sk_program_transfer_fn(
145 skvm::F32 v, skcms_TFType tf_type,
146 skvm::F32 G, skvm::F32 A, skvm::F32 B, skvm::F32 C, skvm::F32 D, skvm::F32 E, skvm::F32 F)
147 {
148 // Strip off the sign bit and save it for later.
149 skvm::I32 bits = pun_to_I32(v),
150 sign = bits & 0x80000000;
151 v = pun_to_F32(bits ^ sign);
152
153 switch (tf_type) {
154 case skcms_TFType_Invalid: SkASSERT(false); break;
155
156 case skcms_TFType_sRGBish: {
157 v = select(v <= D, C*v + F
158 , approx_powf(A*v + B, G) + E);
159 } break;
160
161 case skcms_TFType_PQish: {
162 skvm::F32 vC = approx_powf(v, C);
163 v = approx_powf(max(B * vC + A, 0.0f) / (E * vC + D), F);
164 } break;
165
166 case skcms_TFType_HLGish: {
167 skvm::F32 vA = v*A,
168 K = F + 1.0f;
169 v = K*select(vA <= 1.0f, approx_powf(vA, B)
170 , approx_exp((v-E) * C + D));
171 } break;
172
173 case skcms_TFType_HLGinvish: {
174 skvm::F32 K = F + 1.0f;
175 v /= K;
176 v = select(v <= 1.0f, A * approx_powf(v, B)
177 , C * approx_log(v-D) + E);
178 } break;
179 }
180
181 // Re-apply the original sign bit on our way out the door.
182 return pun_to_F32(sign | pun_to_I32(v));
183 }
184
sk_program_transfer_fn(skvm::Builder * p,skvm::Uniforms * uniforms,const skcms_TransferFunction & tf,skvm::Color c)185 skvm::Color sk_program_transfer_fn(skvm::Builder* p, skvm::Uniforms* uniforms,
186 const skcms_TransferFunction& tf, skvm::Color c) {
187 skvm::F32 G = p->uniformF(uniforms->pushF(tf.g)),
188 A = p->uniformF(uniforms->pushF(tf.a)),
189 B = p->uniformF(uniforms->pushF(tf.b)),
190 C = p->uniformF(uniforms->pushF(tf.c)),
191 D = p->uniformF(uniforms->pushF(tf.d)),
192 E = p->uniformF(uniforms->pushF(tf.e)),
193 F = p->uniformF(uniforms->pushF(tf.f));
194 skcms_TFType tf_type = skcms_TransferFunction_getType(&tf);
195 return {
196 sk_program_transfer_fn(c.r, tf_type, G,A,B,C,D,E,F),
197 sk_program_transfer_fn(c.g, tf_type, G,A,B,C,D,E,F),
198 sk_program_transfer_fn(c.b, tf_type, G,A,B,C,D,E,F),
199 c.a,
200 };
201 }
202
program(skvm::Builder * p,skvm::Uniforms * uniforms,skvm::Color c) const203 skvm::Color SkColorSpaceXformSteps::program(skvm::Builder* p, skvm::Uniforms* uniforms,
204 skvm::Color c) const {
205 if (flags.unpremul) {
206 c = unpremul(c);
207 }
208 if (flags.linearize) {
209 c = sk_program_transfer_fn(p, uniforms, srcTF, c);
210 }
211 if (flags.gamut_transform) {
212 auto m = [&](int index) {
213 return p->uniformF(uniforms->pushF(src_to_dst_matrix[index]));
214 };
215 auto R = c.r * m(0) + c.g * m(3) + c.b * m(6),
216 G = c.r * m(1) + c.g * m(4) + c.b * m(7),
217 B = c.r * m(2) + c.g * m(5) + c.b * m(8);
218 c = {R, G, B, c.a};
219 }
220 if (flags.encode) {
221 c = sk_program_transfer_fn(p, uniforms, dstTFInv, c);
222 }
223 if (flags.premul) {
224 c = premul(c);
225 }
226 return c;
227 }
228