Merge branch 'master' into blender2.8
[blender.git] / source / blender / blenlib / intern / math_color_inline.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: some of this file.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  * */
25
26 /** \file blender/blenlib/intern/math_color_inline.c
27  *  \ingroup bli
28  */
29
30
31 #include "BLI_math_base.h"
32 #include "BLI_math_color.h"
33 #include "BLI_utildefines.h"
34
35 #include "math.h"
36
37 #ifndef __MATH_COLOR_INLINE_C__
38 #define __MATH_COLOR_INLINE_C__
39
40 /******************************** Color Space ********************************/
41
42 #ifdef __SSE2__
43
44 MALWAYS_INLINE __m128 srgb_to_linearrgb_v4_simd(const __m128 c)
45 {
46         __m128 cmp = _mm_cmplt_ps(c, _mm_set1_ps(0.04045f));
47         __m128 lt = _mm_max_ps(_mm_mul_ps(c, _mm_set1_ps(1.0f / 12.92f)),
48                                _mm_set1_ps(0.0f));
49         __m128 gtebase = _mm_mul_ps(_mm_add_ps(c, _mm_set1_ps(0.055f)),
50                                     _mm_set1_ps(1.0f / 1.055f)); /* fma */
51         __m128 gte = _bli_math_fastpow24(gtebase);
52         return _bli_math_blend_sse(cmp, lt, gte);
53 }
54
55 MALWAYS_INLINE __m128 linearrgb_to_srgb_v4_simd(const __m128 c)
56 {
57         __m128 cmp = _mm_cmplt_ps(c, _mm_set1_ps(0.0031308f));
58         __m128 lt = _mm_max_ps(_mm_mul_ps(c, _mm_set1_ps(12.92f)),
59                                _mm_set1_ps(0.0f));
60         __m128 gte = _mm_add_ps(_mm_mul_ps(_mm_set1_ps(1.055f),
61                                            _bli_math_fastpow512(c)),
62                                 _mm_set1_ps(-0.055f));
63         return _bli_math_blend_sse(cmp, lt, gte);
64 }
65
66 MINLINE void srgb_to_linearrgb_v3_v3(float linear[3], const float srgb[3])
67 {
68         float r[4] = {srgb[0], srgb[1], srgb[2], 1.0f};
69         __m128 *rv = (__m128 *)&r;
70         *rv = srgb_to_linearrgb_v4_simd(*rv);
71         linear[0] = r[0];
72         linear[1] = r[1];
73         linear[2] = r[2];
74 }
75
76 MINLINE void linearrgb_to_srgb_v3_v3(float srgb[3], const float linear[3])
77 {
78         float r[4] = {linear[0], linear[1], linear[2], 1.0f};
79         __m128 *rv = (__m128 *)&r;
80         *rv = linearrgb_to_srgb_v4_simd(*rv);
81         srgb[0] = r[0];
82         srgb[1] = r[1];
83         srgb[2] = r[2];
84 }
85
86 #else  /* __SSE2__ */
87
88 MINLINE void srgb_to_linearrgb_v3_v3(float linear[3], const float srgb[3])
89 {
90         linear[0] = srgb_to_linearrgb(srgb[0]);
91         linear[1] = srgb_to_linearrgb(srgb[1]);
92         linear[2] = srgb_to_linearrgb(srgb[2]);
93 }
94
95 MINLINE void linearrgb_to_srgb_v3_v3(float srgb[3], const float linear[3])
96 {
97         srgb[0] = linearrgb_to_srgb(linear[0]);
98         srgb[1] = linearrgb_to_srgb(linear[1]);
99         srgb[2] = linearrgb_to_srgb(linear[2]);
100 }
101 #endif  /* __SSE2__ */
102
103 MINLINE void srgb_to_linearrgb_v4(float linear[4], const float srgb[4])
104 {
105         srgb_to_linearrgb_v3_v3(linear, srgb);
106         linear[3] = srgb[3];
107 }
108
109 MINLINE void linearrgb_to_srgb_v4(float srgb[4], const float linear[4])
110 {
111         linearrgb_to_srgb_v3_v3(srgb, linear);
112         srgb[3] = linear[3];
113 }
114
115 MINLINE void linearrgb_to_srgb_uchar3(unsigned char srgb[3], const float linear[3])
116 {
117         float srgb_f[3];
118
119         linearrgb_to_srgb_v3_v3(srgb_f, linear);
120         F3TOCHAR3(srgb_f, srgb);
121 }
122
123 MINLINE void linearrgb_to_srgb_uchar4(unsigned char srgb[4], const float linear[4])
124 {
125         float srgb_f[4];
126
127         linearrgb_to_srgb_v4(srgb_f, linear);
128         F4TOCHAR4(srgb_f, srgb);
129 }
130
131 /* predivide versions to work on associated/pre-multiplied alpha. if this should
132  * be done or not depends on the background the image will be composited over,
133  * ideally you would never do color space conversion on an image with alpha
134  * because it is ill defined */
135
136 MINLINE void srgb_to_linearrgb_predivide_v4(float linear[4], const float srgb[4])
137 {
138         float alpha, inv_alpha;
139
140         if (srgb[3] == 1.0f || srgb[3] == 0.0f) {
141                 alpha = 1.0f;
142                 inv_alpha = 1.0f;
143         }
144         else {
145                 alpha = srgb[3];
146                 inv_alpha = 1.0f / alpha;
147         }
148
149         linear[0] = srgb[0] * inv_alpha;
150         linear[1] = srgb[1] * inv_alpha;
151         linear[2] = srgb[2] * inv_alpha;
152         linear[3] = srgb[3];
153         srgb_to_linearrgb_v3_v3(linear, linear);
154         linear[0] *= alpha;
155         linear[1] *= alpha;
156         linear[2] *= alpha;
157 }
158
159 MINLINE void linearrgb_to_srgb_predivide_v4(float srgb[4], const float linear[4])
160 {
161         float alpha, inv_alpha;
162
163         if (linear[3] == 1.0f || linear[3] == 0.0f) {
164                 alpha = 1.0f;
165                 inv_alpha = 1.0f;
166         }
167         else {
168                 alpha = linear[3];
169                 inv_alpha = 1.0f / alpha;
170         }
171
172         srgb[0] = linear[0] * inv_alpha;
173         srgb[1] = linear[1] * inv_alpha;
174         srgb[2] = linear[2] * inv_alpha;
175         srgb[3] = linear[3];
176         linearrgb_to_srgb_v3_v3(srgb, srgb);
177         srgb[0] *= alpha;
178         srgb[1] *= alpha;
179         srgb[2] *= alpha;
180 }
181
182 /* LUT accelerated conversions */
183
184 extern float BLI_color_from_srgb_table[256];
185 extern unsigned short BLI_color_to_srgb_table[0x10000];
186
187 MINLINE unsigned short to_srgb_table_lookup(const float f)
188 {
189
190         union {
191                 float f;
192                 unsigned short us[2];
193         } tmp;
194         tmp.f = f;
195 #ifdef __BIG_ENDIAN__
196         return BLI_color_to_srgb_table[tmp.us[0]];
197 #else
198         return BLI_color_to_srgb_table[tmp.us[1]];
199 #endif
200 }
201
202 MINLINE void linearrgb_to_srgb_ushort4(unsigned short srgb[4], const float linear[4])
203 {
204         srgb[0] = to_srgb_table_lookup(linear[0]);
205         srgb[1] = to_srgb_table_lookup(linear[1]);
206         srgb[2] = to_srgb_table_lookup(linear[2]);
207         srgb[3] = FTOUSHORT(linear[3]);
208 }
209
210 MINLINE void srgb_to_linearrgb_uchar4(float linear[4], const unsigned char srgb[4])
211 {
212         linear[0] = BLI_color_from_srgb_table[srgb[0]];
213         linear[1] = BLI_color_from_srgb_table[srgb[1]];
214         linear[2] = BLI_color_from_srgb_table[srgb[2]];
215         linear[3] = srgb[3] * (1.0f / 255.0f);
216 }
217
218 MINLINE void srgb_to_linearrgb_uchar4_predivide(float linear[4], const unsigned char srgb[4])
219 {
220         float fsrgb[4];
221         int i;
222
223         if (srgb[3] == 255 || srgb[3] == 0) {
224                 srgb_to_linearrgb_uchar4(linear, srgb);
225                 return;
226         }
227
228         for (i = 0; i < 4; i++)
229                 fsrgb[i] = srgb[i] * (1.0f / 255.0f);
230
231         srgb_to_linearrgb_predivide_v4(linear, fsrgb);
232 }
233
234 MINLINE void rgba_char_args_set(char col[4], const char r, const char g, const char b, const char a)
235 {
236         col[0] = r;
237         col[1] = g;
238         col[2] = b;
239         col[3] = a;
240 }
241
242 MINLINE void rgba_float_args_set(float col[4], const float r, const float g, const float b, const float a)
243 {
244         col[0] = r;
245         col[1] = g;
246         col[2] = b;
247         col[3] = a;
248 }
249
250 MINLINE void rgba_char_args_test_set(char col[4], const char r, const char g, const char b, const char a)
251 {
252         if (col[3] == 0) {
253                 col[0] = r;
254                 col[1] = g;
255                 col[2] = b;
256                 col[3] = a;
257         }
258 }
259
260 MINLINE void cpack_cpy_3ub(unsigned char r_col[3], const unsigned int pack)
261 {
262         r_col[0] = ((pack) >>  0) & 0xFF;
263         r_col[1] = ((pack) >>  8) & 0xFF;
264         r_col[2] = ((pack) >> 16) & 0xFF;
265 }
266
267
268 /** \name RGB/Grayscale Functions
269  *
270  * \warning
271  * These are only an approximation,
272  * in almost _all_ cases, #IMB_colormanagement_get_luminance should be used instead.
273  * however for screen-only colors which don't depend on the currently loaded profile - this is preferred.
274  * Checking theme colors for contrast, etc. Basically anything outside the render pipeline.
275  *
276  * \{ */
277
278 /**
279  * ITU-R BT.709 primaries
280  * https://en.wikipedia.org/wiki/Relative_luminance
281  *
282  * Real values are:
283  * ``Y = 0.2126390059(R) + 0.7151686788(G) + 0.0721923154(B)``
284  * according to: "Derivation of Basic Television Color Equations", RP 177-1993
285  *
286  * As this sums slightly above 1.0, the document recommends to use:
287  * ``0.2126(R) + 0.7152(G) + 0.0722(B)``, as used here.
288  *
289  * The high precision values are used to calculate the rounded byte weights so they add up to 255:
290  * ``54(R) + 182(G) + 19(B)``
291  */
292 MINLINE float rgb_to_grayscale(const float rgb[3])
293 {
294         return  (0.2126f * rgb[0]) + (0.7152f * rgb[1]) + (0.0722f * rgb[2]);
295 }
296
297 MINLINE unsigned char rgb_to_grayscale_byte(const unsigned char rgb[3])
298 {
299         return (unsigned char)(((54  * (unsigned short)rgb[0]) +
300                                 (182 * (unsigned short)rgb[1]) +
301                                 (19  * (unsigned short)rgb[2])) / 255);
302 }
303
304 /** \} */
305
306
307
308 MINLINE int compare_rgb_uchar(const unsigned char col_a[3], const unsigned char col_b[3], const int limit)
309 {
310         const int r = (int)col_a[0] - (int)col_b[0];
311         if (ABS(r) < limit) {
312                 const int g = (int)col_a[1] - (int)col_b[1];
313                 if (ABS(g) < limit) {
314                         const int b = (int)col_a[2] - (int)col_b[2];
315                         if (ABS(b) < limit) {
316                                 return 1;
317                         }
318                 }
319         }
320
321         return 0;
322 }
323
324 MINLINE float dither_random_value(float s, float t)
325 {
326         static float vec[2] = {12.9898f, 78.233f};
327         float value;
328
329         value = sinf(s * vec[0] + t * vec[1]) * 43758.5453f;
330         return value - floorf(value);
331 }
332
333 MINLINE void float_to_byte_dither_v3(unsigned char b[3], const float f[3], float dither, float s, float t)
334 {
335         float dither_value = dither_random_value(s, t) * 0.005f * dither;
336
337         b[0] = FTOCHAR(dither_value + f[0]);
338         b[1] = FTOCHAR(dither_value + f[1]);
339         b[2] = FTOCHAR(dither_value + f[2]);
340 }
341
342 /**************** Alpha Transformations *****************/
343
344 MINLINE void premul_to_straight_v4_v4(float straight[4], const float premul[4])
345 {
346         if (premul[3] == 0.0f || premul[3] == 1.0f) {
347                 straight[0] = premul[0];
348                 straight[1] = premul[1];
349                 straight[2] = premul[2];
350                 straight[3] = premul[3];
351         }
352         else {
353                 const float alpha_inv = 1.0f / premul[3];
354                 straight[0] = premul[0] * alpha_inv;
355                 straight[1] = premul[1] * alpha_inv;
356                 straight[2] = premul[2] * alpha_inv;
357                 straight[3] = premul[3];
358         }
359 }
360
361 MINLINE void premul_to_straight_v4(float color[4])
362 {
363         premul_to_straight_v4_v4(color, color);
364 }
365
366 MINLINE void straight_to_premul_v4_v4(float premul[4], const float straight[4])
367 {
368         const float alpha = straight[3];
369         premul[0] = straight[0] * alpha;
370         premul[1] = straight[1] * alpha;
371         premul[2] = straight[2] * alpha;
372         premul[3] = straight[3];
373 }
374
375 MINLINE void straight_to_premul_v4(float color[4])
376 {
377         straight_to_premul_v4_v4(color, color);
378 }
379
380 MINLINE void straight_uchar_to_premul_float(float result[4], const unsigned char color[4])
381 {
382         const float alpha = color[3] * (1.0f / 255.0f);
383         const float fac = alpha * (1.0f / 255.0f);
384
385         result[0] = color[0] * fac;
386         result[1] = color[1] * fac;
387         result[2] = color[2] * fac;
388         result[3] = alpha;
389 }
390
391 MINLINE void premul_float_to_straight_uchar(unsigned char *result, const float color[4])
392 {
393         if (color[3] == 0.0f || color[3] == 1.0f) {
394                 result[0] = FTOCHAR(color[0]);
395                 result[1] = FTOCHAR(color[1]);
396                 result[2] = FTOCHAR(color[2]);
397                 result[3] = FTOCHAR(color[3]);
398         }
399         else {
400                 const float alpha_inv = 1.0f / color[3];
401
402                 /* hopefully this would be optimized */
403                 result[0] = FTOCHAR(color[0] * alpha_inv);
404                 result[1] = FTOCHAR(color[1] * alpha_inv);
405                 result[2] = FTOCHAR(color[2] * alpha_inv);
406                 result[3] = FTOCHAR(color[3]);
407         }
408 }
409
410 #endif /* __MATH_COLOR_INLINE_C__ */