Debian Codegraph @

src/video/ciede/rgbtolab/mod.rs

raw
1 // Modified version of https://github.com/TooManyBees/lab
2
3 use lab::Lab;
4
5 // κ and ε parameters used in conversion between XYZ and La*b*. See
6 // http://www.brucelindbloom.com/LContinuity.html for explanation as to why
7 // those are different values than those provided by CIE standard.
8 const KAPPA: f32 = 24389.0 / 27.0;
9 const EPSILON: f32 = 216.0 / 24389.0;
10
11 pub fn rgb_to_lab(rgb: &[f32; 3]) -> Lab {
12 xyz_to_lab(rgb_to_xyz(rgb))
13 }
14
15 #[allow(clippy::excessive_precision)]
16 fn rgb_to_xyz(rgb: &[f32; 3]) -> [f32; 3] {
17 let r = rgb_to_xyz_map(rgb[0]);
18 let g = rgb_to_xyz_map(rgb[1]);
19 let b = rgb_to_xyz_map(rgb[2]);
20
21 [
22 r * 0.4124564390896921 + g * 0.357576077643909 + b * 0.18043748326639894,
23 r * 0.21267285140562248 + g * 0.715152155287818 + b * 0.07217499330655958,
24 r * 0.019333895582329317 + g * 0.119192025881303 + b * 0.9503040785363677,
25 ]
26 }
27
28 #[inline]
29 fn rgb_to_xyz_map(c: f32) -> f32 {
30 if c > 10. / 255. {
31 const A: f32 = 0.055;
32 const D: f32 = 1.0 / 1.055;
33 pow_2_4((c + A) * D)
34 } else {
35 const D: f32 = 1.0 / 12.92;
36 c * D
37 }
38 }
39
40 fn xyz_to_lab(xyz: [f32; 3]) -> Lab {
41 let x = xyz_to_lab_map(xyz[0] * (1.0 / 0.95047));
42 let y = xyz_to_lab_map(xyz[1]);
43 let z = xyz_to_lab_map(xyz[2] * (1.0 / 1.08883));
44
45 Lab {
46 l: (116.0 * y) - 16.0,
47 a: 500.0 * (x - y),
48 b: 200.0 * (y - z),
49 }
50 }
51
52 #[inline]
53 fn xyz_to_lab_map(c: f32) -> f32 {
54 if c > EPSILON {
55 cbrt_approx(c)
56 } else {
57 (KAPPA * c + 16.0) * (1.0 / 116.0)
58 }
59 }
60
61 macro_rules! lookup_table_8 {
62 (start: $start:expr, closure: $closure:expr) => {
63 [
64 $closure($start + 0),
65 $closure($start + 1),
66 $closure($start + 2),
67 $closure($start + 3),
68 $closure($start + 4),
69 $closure($start + 5),
70 $closure($start + 6),
71 $closure($start + 7),
72 ]
73 };
74 }
75
76 macro_rules! lookup_table_16 {
77 (start: $start:expr, closure: $closure:expr) => {
78 [
79 $closure($start + 0),
80 $closure($start + 1),
81 $closure($start + 2),
82 $closure($start + 3),
83 $closure($start + 4),
84 $closure($start + 5),
85 $closure($start + 6),
86 $closure($start + 7),
87 $closure($start + 8),
88 $closure($start + 9),
89 $closure($start + 10),
90 $closure($start + 11),
91 $closure($start + 12),
92 $closure($start + 13),
93 $closure($start + 14),
94 $closure($start + 15),
95 ]
96 };
97 }
98
99 fn pow_2_4(x: f32) -> f32 {
100 // Closely approximate x^2.4.
101 // Divide x by its exponent and a truncated version of itself to get it as close to 1 as
102 // possible. Calculate the power of 2.4 using the binomial method. Multiply what was divided to
103 // the power of 2.4.
104
105 // Lookup tables still have to be hardcoded.
106 const FRAC_BITS: u32 = 3;
107
108 // Cast x into an integer to manipulate its exponent and fractional parts into indexes for
109 // lookup tables.
110 let bits = x.to_bits();
111
112 // Get the integer log2 from the exponent part of bits
113 let log2 = (bits >> 23) as i32 - 0x7f;
114
115 // x is always >= (10/255 + A)*D so we only have to deal with a limited range in the exponent.
116 // log2 range is [-4, 3]
117 // Use a lookup table to offset for dividing by 2^log of x.
118 // x^2.4 = (2^log2)^2.4 * (x/(2^log2))^2.4
119 let lookup_entry_exp_pow_2_4 =
120 |log2: i32| (f32::from_bits(((log2 + 0x7f) << 23) as u32) as f64).powf(2.4) as f32;
121 let lookup_table_exp_pow_2_4 = lookup_table_8!(start: -4, closure: lookup_entry_exp_pow_2_4);
122 let exp_pow_2_4 = lookup_table_exp_pow_2_4[(log2 + 4) as usize];
123
124 // Zero the exponent of x or divide by 2^log.
125 let x = f32::from_bits((bits & 0x807fffff) | 0x3f800000);
126
127 // Use lookup tables to divide by a truncated version of x and get an offset for that division.
128 // x^2.4 = a^2.4 * (x/a)^2.4
129 let lookup_entry_inv_truncated = |fraction: i32| {
130 let truncated = 1.0 + (fraction as f64 + 0.5) / ((1 << FRAC_BITS) as f64);
131 (1.0 / truncated) as f32
132 };
133 let lookup_table_inv_truncated = lookup_table_8!(start: 0, closure: lookup_entry_inv_truncated);
134 let lookup_entry_truncated_pow_2_4 =
135 |fraction: i32| (lookup_entry_inv_truncated(fraction) as f64).powf(-2.4) as f32;
136 let lookup_table_truncated_pow_2_4 =
137 lookup_table_8!(start: 0, closure: lookup_entry_truncated_pow_2_4);
138
139 // Expose only FRAC_BITS of the fraction.
140 let fraction = (bits >> (23 - FRAC_BITS) & ((1 << FRAC_BITS) - 1)) as usize;
141 let truncated_pow_2_4 = lookup_table_truncated_pow_2_4[fraction];
142 let x = x * lookup_table_inv_truncated[fraction];
143
144 // Binomial series
145 // Greater than 12 bits of precision.
146 //let est = 7. / 25. - 24. / 25. * x + 42. / 25. * x.powi(2);
147 // Plenty of precision.
148 let est = 7. / 125. - 36. / 125. * x + 126. / 125. * x.powi(2) + 28. / 125. * x.powi(3);
149
150 est * (truncated_pow_2_4 * exp_pow_2_4)
151 }
152
153 fn cbrt_approx(x: f32) -> f32 {
154 // Closely approximate x^(1/3).
155 // Divide x by its exponent and a truncated version of itself to get it as close to 1 as
156 // possible. Calculate the power of 1/3 using the binomial method. Multiply what was divided to
157 // the power of 1/3.
158
159 // Lookup tables still have to be hardcoded.
160 const FRAC_BITS: u32 = 3;
161
162 // Cast x into an integer to manipulate its exponent and fractional parts into indexes for
163 // lookup tables.
164 let bits = x.to_bits();
165
166 // Get the integer log2 from the exponent part of bits
167 let log2 = (bits >> 23) as i32 - 0x7f;
168
169 // x is always > EPSILON so we only have to deal with a limited range in the exponent.
170 // log2 range is [-7, 8]
171 // Use a lookup table to offset for dividing by 2^log of x.
172 // x^(1/3) = (2^log2)^(1/3) * (x/(2^log2))^(1/3)
173 let lookup_entry_exp_cbrt =
174 |log2: i32| (f32::from_bits(((log2 + 0x7f) << 23) as u32) as f64).powf(1. / 3.) as f32;
175 let lookup_table_exp_cbrt = lookup_table_16!(start: -7, closure: lookup_entry_exp_cbrt);
176 let exp_pow_cbrt = lookup_table_exp_cbrt[(log2 + 7) as usize];
177
178 // Zero the exponent of x or divide by 2^log.
179 let x = f32::from_bits((bits & 0x807fffff) | 0x3f800000);
180
181 // Use lookup tables to divide by a truncated version of x and get an offset for that division.
182 // x^(1/3) = a^(1/3) * (x/a)^(1/3)
183 let lookup_entry_inv_truncated = |fraction: i32| {
184 let truncated = 1.0 + (fraction as f64 + 0.5) / ((1 << FRAC_BITS) as f64);
185 (1.0 / truncated) as f32
186 };
187 let lookup_table_inv_truncated = lookup_table_8!(start: 0, closure: lookup_entry_inv_truncated);
188 let lookup_entry_truncated_cbrt =
189 |fraction: i32| (lookup_entry_inv_truncated(fraction) as f64).powf(-1. / 3.) as f32;
190 let lookup_table_truncated_cbrt =
191 lookup_table_8!(start: 0, closure: lookup_entry_truncated_cbrt);
192
193 // Expose only FRAC_BITS of the fraction.
194 let fraction = (bits >> (23 - FRAC_BITS) & ((1 << FRAC_BITS) - 1)) as usize;
195 let truncated_pow_cbrt = lookup_table_truncated_cbrt[fraction];
196 let x = x * lookup_table_inv_truncated[fraction];
197
198 // Binomial series
199 let est = 40. / 81. + 60. / 81. * x - 24. / 81. * x.powi(2) + 5. / 81. * x.powi(3);
200
201 est * (truncated_pow_cbrt * exp_pow_cbrt)
202 }
203
204 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
205 pub use self::avx2::*;
206
207 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
208 mod avx2 {
209 use super::*;
210
211 #[cfg(target_arch = "x86")]
212 use std::arch::x86::*;
213 #[cfg(target_arch = "x86_64")]
214 use std::arch::x86_64::*;
215
216 macro_rules! lookup_table_8_avx2 {
217 (start: $start:expr, closure: $closure:expr) => {
218 _mm256_setr_ps(
219 $closure($start + 0),
220 $closure($start + 1),
221 $closure($start + 2),
222 $closure($start + 3),
223 $closure($start + 4),
224 $closure($start + 5),
225 $closure($start + 6),
226 $closure($start + 7),
227 )
228 };
229 }
230
231 macro_rules! lookup_table_16_avx2 {
232 (start: $start:expr, closure: $closure:expr) => {
233 (
234 lookup_table_8_avx2!(start: $start, closure: $closure),
235 lookup_table_8_avx2!(start: $start + 8, closure: $closure),
236 )
237 };
238 }
239
240 macro_rules! sum_mult_avx {
241 (($init:expr), $(($vec:expr, $mul:expr)),* ) => {
242 {
243 let mut sum = _mm256_set1_ps($init);
244 $(
245 sum = _mm256_add_ps(sum, _mm256_mul_ps($vec, _mm256_set1_ps($mul)));
246 )*
247 sum
248 }
249 };
250 ( $(($vec:expr, $mul:expr)),* ) => {
251 sum_mult_avx!((0.0), $(($vec, $mul)),*)
252 };
253 }
254
255 #[target_feature(enable = "avx2")]
256 pub unsafe fn rgb_to_lab_avx2(rgb: &[__m256; 3]) -> [Lab; 8] {
257 xyz_to_lab_avx2(rgb_to_xyz_avx2(rgb))
258 }
259
260 #[target_feature(enable = "avx2")]
261 #[allow(clippy::excessive_precision)]
262 #[allow(clippy::many_single_char_names)]
263 unsafe fn rgb_to_xyz_avx2(rgb: &[__m256; 3]) -> [__m256; 3] {
264 let r = rgb_to_xyz_map_avx2(rgb[0]);
265 let g = rgb_to_xyz_map_avx2(rgb[1]);
266 let b = rgb_to_xyz_map_avx2(rgb[2]);
267
268 let x = sum_mult_avx!(
269 (r, 0.4124564390896921),
270 (g, 0.357576077643909),
271 (b, 0.18043748326639894)
272 );
273 let y = sum_mult_avx!(
274 (r, 0.21267285140562248),
275 (g, 0.715152155287818),
276 (b, 0.07217499330655958)
277 );
278 let z = sum_mult_avx!(
279 (r, 0.019333895582329317),
280 (g, 0.119192025881303),
281 (b, 0.9503040785363677)
282 );
283
284 [x, y, z]
285 }
286
287 #[inline]
288 #[target_feature(enable = "avx2")]
289 unsafe fn rgb_to_xyz_map_avx2(c: __m256) -> __m256 {
290 let low = _mm256_mul_ps(c, _mm256_set1_ps(1.0 / 12.92));
291 let hi = pow_2_4_avx2(_mm256_mul_ps(
292 _mm256_add_ps(c, _mm256_set1_ps(0.055)),
293 _mm256_set1_ps(1.0 / 1.055),
294 ));
295 let select = _mm256_cmp_ps(c, _mm256_set1_ps(10. / 255.), _CMP_GT_OS);
296 _mm256_blendv_ps(low, hi, select)
297 }
298
299 #[inline]
300 #[target_feature(enable = "avx2")]
301 #[allow(clippy::many_single_char_names)]
302 unsafe fn xyz_to_lab_avx2(xyz: [__m256; 3]) -> [Lab; 8] {
303 let x = xyz_to_lab_map_avx2(_mm256_mul_ps(xyz[0], _mm256_set1_ps(1.0 / 0.95047)));
304 let y = xyz_to_lab_map_avx2(xyz[1]);
305 let z = xyz_to_lab_map_avx2(_mm256_mul_ps(xyz[2], _mm256_set1_ps(1.0 / 1.08883)));
306
307 let l = _mm256_sub_ps(
308 _mm256_mul_ps(_mm256_set1_ps(116.0), y),
309 _mm256_set1_ps(16.0),
310 );
311 let a = _mm256_mul_ps(_mm256_sub_ps(x, y), _mm256_set1_ps(500.0));
312 let b = _mm256_mul_ps(_mm256_sub_ps(y, z), _mm256_set1_ps(200.0));
313
314 #[target_feature(enable = "avx2")]
315 unsafe fn to_array(reg: __m256) -> [f32; 8] {
316 std::mem::transmute(reg)
317 }
318 let l = to_array(l);
319 let a = to_array(a);
320 let b = to_array(b);
321
322 let mut output = [Lab {
323 l: 0.,
324 a: 0.,
325 b: 0.,
326 }; 8];
327 for i in 0..8 {
328 output[i] = Lab {
329 l: l[i],
330 a: a[i],
331 b: b[i],
332 };
333 }
334 output
335 }
336
337 #[inline]
338 #[target_feature(enable = "avx2")]
339 unsafe fn xyz_to_lab_map_avx2(c: __m256) -> __m256 {
340 let low = _mm256_mul_ps(
341 _mm256_add_ps(
342 _mm256_mul_ps(c, _mm256_set1_ps(KAPPA)),
343 _mm256_set1_ps(16.0),
344 ),
345 _mm256_set1_ps(1.0 / 116.0),
346 );
347 let hi = cbrt_approx_avx2(c);
348 let select = _mm256_cmp_ps(c, _mm256_set1_ps(EPSILON), _CMP_GT_OS);
349 _mm256_blendv_ps(low, hi, select)
350 }
351
352 #[target_feature(enable = "avx2")]
353 unsafe fn pow_2_4_avx2(x: __m256) -> __m256 {
354 // See non-avx2 version
355
356 const FRAC_BITS: u32 = 3;
357
358 let bits = _mm256_castps_si256(x);
359
360 let log2_index =
361 _mm256_add_epi32(_mm256_srli_epi32(bits, 23), _mm256_set1_epi32(-0x7f + 4));
362
363 let lookup_entry_exp_pow_2_4 =
364 |log2: i32| (f32::from_bits(((log2 + 0x7f) << 23) as u32) as f64).powf(2.4) as f32;
365 let lookup_table_exp_pow_2_4 =
366 lookup_table_8_avx2!(start: -4, closure: lookup_entry_exp_pow_2_4);
367
368 let exp_pow_2_4 = _mm256_permutevar8x32_ps(lookup_table_exp_pow_2_4, log2_index);
369
370 let x = _mm256_or_ps(
371 _mm256_and_ps(
372 x,
373 _mm256_castsi256_ps(_mm256_set1_epi32(0x807fffffu32 as i32)),
374 ),
375 _mm256_castsi256_ps(_mm256_set1_epi32(0x3f800000)),
376 );
377
378 let lookup_entry_inv_truncated = |fraction: i32| {
379 let truncated = 1.0 + (fraction as f64 + 0.5) / ((1 << FRAC_BITS) as f64);
380 (1.0 / truncated) as f32
381 };
382 let lookup_table_inv_truncated =
383 lookup_table_8_avx2!(start: 0, closure: lookup_entry_inv_truncated);
384 let lookup_entry_truncated_pow_2_4 =
385 |fraction: i32| (lookup_entry_inv_truncated(fraction) as f64).powf(-2.4) as f32;
386 let lookup_table_truncated_pow_2_4 =
387 lookup_table_8_avx2!(start: 0, closure: lookup_entry_truncated_pow_2_4);
388
389 // No reason to mask the higher bits
390 let fraction = _mm256_srli_epi32(bits, 23 - FRAC_BITS as i32);
391 let truncated_pow_2_4 = _mm256_permutevar8x32_ps(lookup_table_truncated_pow_2_4, fraction);
392 let x = _mm256_mul_ps(
393 x,
394 _mm256_permutevar8x32_ps(lookup_table_inv_truncated, fraction),
395 );
396
397 let x2 = _mm256_mul_ps(x, x);
398 let x3 = _mm256_mul_ps(x2, x);
399 let est = sum_mult_avx!(
400 (7.0 / 125.0),
401 (x, -36. / 125.),
402 (x2, 126. / 125.),
403 (x3, 28. / 125.)
404 );
405
406 _mm256_mul_ps(est, _mm256_mul_ps(truncated_pow_2_4, exp_pow_2_4))
407 }
408
409 #[target_feature(enable = "avx2")]
410 unsafe fn cbrt_approx_avx2(x: __m256) -> __m256 {
411 // See non-avx2 version
412
413 const FRAC_BITS: u32 = 3;
414
415 let bits = _mm256_castps_si256(x);
416
417 let log2_index =
418 _mm256_add_epi32(_mm256_srli_epi32(bits, 23), _mm256_set1_epi32(-0x7f + 7));
419
420 let lookup_entry_exp_cbrt =
421 |log2: i32| (f32::from_bits(((log2 + 0x7f) << 23) as u32) as f64).powf(1. / 3.) as f32;
422 let lookup_table_exp_cbrt =
423 lookup_table_16_avx2!(start: -7, closure: lookup_entry_exp_cbrt);
424
425 let exp_cbrt = _mm256_blendv_ps(
426 _mm256_permutevar8x32_ps(lookup_table_exp_cbrt.0, log2_index),
427 _mm256_permutevar8x32_ps(lookup_table_exp_cbrt.1, log2_index),
428 // Check if log is greater than 7
429 _mm256_castsi256_ps(_mm256_slli_epi32(log2_index, 28)),
430 );
431
432 let x = _mm256_or_ps(
433 _mm256_and_ps(
434 x,
435 _mm256_castsi256_ps(_mm256_set1_epi32(0x807fffffu32 as i32)),
436 ),
437 _mm256_castsi256_ps(_mm256_set1_epi32(0x3f800000)),
438 );
439 let lookup_entry_inv_truncated = |fraction: i32| {
440 let truncated = 1.0 + (fraction as f64 + 0.5) / ((1 << FRAC_BITS) as f64);
441 (1.0 / truncated) as f32
442 };
443 let lookup_table_inv_truncated =
444 lookup_table_8_avx2!(start: 0, closure: lookup_entry_inv_truncated);
445 let lookup_entry_truncated_cbrt =
446 |fraction: i32| (lookup_entry_inv_truncated(fraction) as f64).powf(-1. / 3.) as f32;
447 let lookup_table_truncated_cbrt =
448 lookup_table_8_avx2!(start: 0, closure: lookup_entry_truncated_cbrt);
449
450 // No reason to mask the higher bits
451 let fraction = _mm256_srli_epi32(bits, 23 - FRAC_BITS as i32);
452 let truncated_cbrt = _mm256_permutevar8x32_ps(lookup_table_truncated_cbrt, fraction);
453 let x = _mm256_mul_ps(
454 x,
455 _mm256_permutevar8x32_ps(lookup_table_inv_truncated, fraction),
456 );
457
458 let x2 = _mm256_mul_ps(x, x);
459 let x3 = _mm256_mul_ps(x2, x);
460 let est = sum_mult_avx!(
461 (40. / 81.0),
462 (x, 60. / 81.),
463 (x2, -24. / 81.),
464 (x3, 5. / 81.)
465 );
466
467 _mm256_mul_ps(est, _mm256_mul_ps(truncated_cbrt, exp_cbrt))
468 }
469 }