Bug Summary

File:dev/pci/drm/amd/display/include/fixed31_32.h
Warning:line 274, column 2
The left operand of '>=' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name color_gamma.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/pci/drm/amd/display/modules/color/color_gamma.c

/usr/src/sys/dev/pci/drm/amd/display/modules/color/color_gamma.c

→
1/*
2 * Copyright 2016 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: AMD
23 *
24 */
25
26#include "dc.h"
27#include "opp.h"
28#include "color_gamma.h"
29
30/* When calculating LUT values the first region and at least one subsequent
31 * region are calculated with full precision. These defines are a demarcation
32 * of where the second region starts and ends.
33 * These are hardcoded values to avoid recalculating them in loops.
34 */
35#define PRECISE_LUT_REGION_START224 224
36#define PRECISE_LUT_REGION_END239 239
37
38static struct hw_x_point coordinates_x[MAX_HW_POINTS(16*32) + 2];
39
40// these are helpers for calculations to reduce stack usage
41// do not depend on these being preserved across calls
42
43/* Helper to optimize gamma calculation, only use in translate_from_linear, in
44 * particular the dc_fixpt_pow function which is very expensive
45 * The idea is that our regions for X points are exponential and currently they all use
46 * the same number of points (NUM_PTS_IN_REGION) and in each region every point
47 * is exactly 2x the one at the same index in the previous region. In other words
48 * X[i] = 2 * X[i-NUM_PTS_IN_REGION] for i>=16
49 * The other fact is that (2x)^gamma = 2^gamma * x^gamma
50 * So we compute and save x^gamma for the first 16 regions, and for every next region
51 * just multiply with 2^gamma which can be computed once, and save the result so we
52 * recursively compute all the values.
53 */
54
55/*
56 * Regamma coefficients are used for both regamma and degamma. Degamma
57 * coefficients are calculated in our formula using the regamma coefficients.
58 */
59 /*sRGB 709 2.2 2.4 P3*/
60static const int32_t numerator01[] = { 31308, 180000, 0, 0, 0};
61static const int32_t numerator02[] = { 12920, 4500, 0, 0, 0};
62static const int32_t numerator03[] = { 55, 99, 0, 0, 0};
63static const int32_t numerator04[] = { 55, 99, 0, 0, 0};
64static const int32_t numerator05[] = { 2400, 2200, 2200, 2400, 2600};
65
66/* one-time setup of X points */
67void setup_x_points_distribution(void)
68{
69 struct fixed31_32 region_size = dc_fixpt_from_int(128);
70 int32_t segment;
71 uint32_t seg_offset;
72 uint32_t index;
73 struct fixed31_32 increment;
74
75 coordinates_x[MAX_HW_POINTS(16*32)].x = region_size;
76 coordinates_x[MAX_HW_POINTS(16*32) + 1].x = region_size;
77
78 for (segment = 6; segment > (6 - NUM_REGIONS32); segment--) {
79 region_size = dc_fixpt_div_int(region_size, 2);
80 increment = dc_fixpt_div_int(region_size,
81 NUM_PTS_IN_REGION16);
82 seg_offset = (segment + (NUM_REGIONS32 - 7)) * NUM_PTS_IN_REGION16;
83 coordinates_x[seg_offset].x = region_size;
84
85 for (index = seg_offset + 1;
86 index < seg_offset + NUM_PTS_IN_REGION16;
87 index++) {
88 coordinates_x[index].x = dc_fixpt_add
89 (coordinates_x[index-1].x, increment);
90 }
91 }
92}
93
94void log_x_points_distribution(struct dal_logger *logger)
95{
96 int i = 0;
97
98 if (logger != NULL((void *)0)) {
99 LOG_GAMMA_WRITE("Log X Distribution\n");
100
101 for (i = 0; i < MAX_HW_POINTS(16*32); i++)
102 LOG_GAMMA_WRITE("%llu\n", coordinates_x[i].x.value);
103 }
104}
105
106static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
107{
108 /* consts for PQ gamma formula. */
109 const struct fixed31_32 m1 =
110 dc_fixpt_from_fraction(159301758, 1000000000);
111 const struct fixed31_32 m2 =
112 dc_fixpt_from_fraction(7884375, 100000);
113 const struct fixed31_32 c1 =
114 dc_fixpt_from_fraction(8359375, 10000000);
115 const struct fixed31_32 c2 =
116 dc_fixpt_from_fraction(188515625, 10000000);
117 const struct fixed31_32 c3 =
118 dc_fixpt_from_fraction(186875, 10000);
119
120 struct fixed31_32 l_pow_m1;
121 struct fixed31_32 base;
122
123 if (dc_fixpt_lt(in_x, dc_fixpt_zero))
124 in_x = dc_fixpt_zero;
125
126 l_pow_m1 = dc_fixpt_pow(in_x, m1);
127 base = dc_fixpt_div(
128 dc_fixpt_add(c1,
129 (dc_fixpt_mul(c2, l_pow_m1))),
130 dc_fixpt_add(dc_fixpt_one,
131 (dc_fixpt_mul(c3, l_pow_m1))));
132 *out_y = dc_fixpt_pow(base, m2);
133}
134
135static void compute_de_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y)
136{
137 /* consts for dePQ gamma formula. */
138 const struct fixed31_32 m1 =
139 dc_fixpt_from_fraction(159301758, 1000000000);
140 const struct fixed31_32 m2 =
141 dc_fixpt_from_fraction(7884375, 100000);
142 const struct fixed31_32 c1 =
143 dc_fixpt_from_fraction(8359375, 10000000);
144 const struct fixed31_32 c2 =
145 dc_fixpt_from_fraction(188515625, 10000000);
146 const struct fixed31_32 c3 =
147 dc_fixpt_from_fraction(186875, 10000);
148
149 struct fixed31_32 l_pow_m1;
150 struct fixed31_32 base, div;
151 struct fixed31_32 base2;
152
153
154 if (dc_fixpt_lt(in_x, dc_fixpt_zero))
155 in_x = dc_fixpt_zero;
156
157 l_pow_m1 = dc_fixpt_pow(in_x,
158 dc_fixpt_div(dc_fixpt_one, m2));
159 base = dc_fixpt_sub(l_pow_m1, c1);
160
161 div = dc_fixpt_sub(c2, dc_fixpt_mul(c3, l_pow_m1));
162
163 base2 = dc_fixpt_div(base, div);
164 // avoid complex numbers
165 if (dc_fixpt_lt(base2, dc_fixpt_zero))
166 base2 = dc_fixpt_sub(dc_fixpt_zero, base2);
167
168
169 *out_y = dc_fixpt_pow(base2, dc_fixpt_div(dc_fixpt_one, m1));
170
171}
172
173
174/* de gamma, non-linear to linear */
175static void compute_hlg_eotf(struct fixed31_32 in_x,
176 struct fixed31_32 *out_y,
177 uint32_t sdr_white_level, uint32_t max_luminance_nits)
178{
179 struct fixed31_32 a;
180 struct fixed31_32 b;
181 struct fixed31_32 c;
182 struct fixed31_32 threshold;
183 struct fixed31_32 x;
184
185 struct fixed31_32 scaling_factor =
186 dc_fixpt_from_fraction(max_luminance_nits, sdr_white_level);
187 a = dc_fixpt_from_fraction(17883277, 100000000);
188 b = dc_fixpt_from_fraction(28466892, 100000000);
189 c = dc_fixpt_from_fraction(55991073, 100000000);
190 threshold = dc_fixpt_from_fraction(1, 2);
191
192 if (dc_fixpt_lt(in_x, threshold)) {
193 x = dc_fixpt_mul(in_x, in_x);
194 x = dc_fixpt_div_int(x, 3);
195 } else {
196 x = dc_fixpt_sub(in_x, c);
197 x = dc_fixpt_div(x, a);
198 x = dc_fixpt_exp(x);
199 x = dc_fixpt_add(x, b);
200 x = dc_fixpt_div_int(x, 12);
201 }
202 *out_y = dc_fixpt_mul(x, scaling_factor);
203
204}
205
206/* re gamma, linear to non-linear */
207static void compute_hlg_oetf(struct fixed31_32 in_x, struct fixed31_32 *out_y,
208 uint32_t sdr_white_level, uint32_t max_luminance_nits)
209{
210 struct fixed31_32 a;
211 struct fixed31_32 b;
212 struct fixed31_32 c;
213 struct fixed31_32 threshold;
214 struct fixed31_32 x;
215
216 struct fixed31_32 scaling_factor =
217 dc_fixpt_from_fraction(sdr_white_level, max_luminance_nits);
218 a = dc_fixpt_from_fraction(17883277, 100000000);
219 b = dc_fixpt_from_fraction(28466892, 100000000);
220 c = dc_fixpt_from_fraction(55991073, 100000000);
221 threshold = dc_fixpt_from_fraction(1, 12);
222 x = dc_fixpt_mul(in_x, scaling_factor);
223
224
225 if (dc_fixpt_lt(x, threshold)) {
226 x = dc_fixpt_mul(x, dc_fixpt_from_fraction(3, 1));
227 *out_y = dc_fixpt_pow(x, dc_fixpt_half);
228 } else {
229 x = dc_fixpt_mul(x, dc_fixpt_from_fraction(12, 1));
230 x = dc_fixpt_sub(x, b);
231 x = dc_fixpt_log(x);
232 x = dc_fixpt_mul(a, x);
233 *out_y = dc_fixpt_add(x, c);
234 }
235}
236
237
238/* one-time pre-compute PQ values - only for sdr_white_level 80 */
239void precompute_pq(void)
240{
241 int i;
242 struct fixed31_32 x;
243 const struct hw_x_point *coord_x = coordinates_x + 32;
244 struct fixed31_32 scaling_factor =
245 dc_fixpt_from_fraction(80, 10000);
246
247 struct fixed31_32 *pq_table = mod_color_get_table(type_pq_table);
248
249 /* pow function has problems with arguments too small */
250 for (i = 0; i < 32; i++)
251 pq_table[i] = dc_fixpt_zero;
252
253 for (i = 32; i <= MAX_HW_POINTS(16*32); i++) {
254 x = dc_fixpt_mul(coord_x->x, scaling_factor);
255 compute_pq(x, &pq_table[i]);
256 ++coord_x;
257 }
258}
259
260/* one-time pre-compute dePQ values - only for max pixel value 125 FP16 */
261void precompute_de_pq(void)
262{
263 int i;
264 struct fixed31_32 y;
265 uint32_t begin_index, end_index;
266
267 struct fixed31_32 scaling_factor = dc_fixpt_from_int(125);
268 struct fixed31_32 *de_pq_table = mod_color_get_table(type_de_pq_table);
269 /* X points is 2^-25 to 2^7
270 * De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions
271 */
272 begin_index = 13 * NUM_PTS_IN_REGION16;
273 end_index = begin_index + 12 * NUM_PTS_IN_REGION16;
274
275 for (i = 0; i <= begin_index; i++)
276 de_pq_table[i] = dc_fixpt_zero;
277
278 for (; i <= end_index; i++) {
279 compute_de_pq(coordinates_x[i].x, &y);
280 de_pq_table[i] = dc_fixpt_mul(y, scaling_factor);
281 }
282
283 for (; i <= MAX_HW_POINTS(16*32); i++)
284 de_pq_table[i] = de_pq_table[i-1];
285}
286struct dividers {
287 struct fixed31_32 divider1;
288 struct fixed31_32 divider2;
289 struct fixed31_32 divider3;
290};
291
292
293static bool_Bool build_coefficients(struct gamma_coefficients *coefficients,
294 enum dc_transfer_func_predefined type)
295{
296
297 uint32_t i = 0;
298 uint32_t index = 0;
299 bool_Bool ret = true1;
300
301 if (type == TRANSFER_FUNCTION_SRGB)
302 index = 0;
303 else if (type == TRANSFER_FUNCTION_BT709)
304 index = 1;
305 else if (type == TRANSFER_FUNCTION_GAMMA22)
306 index = 2;
307 else if (type == TRANSFER_FUNCTION_GAMMA24)
308 index = 3;
309 else if (type == TRANSFER_FUNCTION_GAMMA26)
310 index = 4;
311 else {
312 ret = false0;
313 goto release;
314 }
315
316 do {
317 coefficients->a0[i] = dc_fixpt_from_fraction(
318 numerator01[index], 10000000);
319 coefficients->a1[i] = dc_fixpt_from_fraction(
320 numerator02[index], 1000);
321 coefficients->a2[i] = dc_fixpt_from_fraction(
322 numerator03[index], 1000);
323 coefficients->a3[i] = dc_fixpt_from_fraction(
324 numerator04[index], 1000);
325 coefficients->user_gamma[i] = dc_fixpt_from_fraction(
326 numerator05[index], 1000);
327
328 ++i;
329 } while (i != ARRAY_SIZE(coefficients->a0)(sizeof((coefficients->a0)) / sizeof((coefficients->a0)
[0])));
330release:
331 return ret;
332}
333
334static struct fixed31_32 translate_from_linear_space(
335 struct translate_from_linear_space_args *args)
336{
337 const struct fixed31_32 one = dc_fixpt_from_int(1);
338
339 struct fixed31_32 scratch_1, scratch_2;
340 struct calculate_buffer *cal_buffer = args->cal_buffer;
341
342 if (dc_fixpt_le(one, args->arg))
343 return one;
344
345 if (dc_fixpt_le(args->arg, dc_fixpt_neg(args->a0))) {
346 scratch_1 = dc_fixpt_add(one, args->a3);
347 scratch_2 = dc_fixpt_pow(
348 dc_fixpt_neg(args->arg),
349 dc_fixpt_recip(args->gamma));
350 scratch_1 = dc_fixpt_mul(scratch_1, scratch_2);
351 scratch_1 = dc_fixpt_sub(args->a2, scratch_1);
352
353 return scratch_1;
354 } else if (dc_fixpt_le(args->a0, args->arg)) {
355 if (cal_buffer->buffer_index == 0) {
356 cal_buffer->gamma_of_2 = dc_fixpt_pow(dc_fixpt_from_int(2),
357 dc_fixpt_recip(args->gamma));
358 }
359 scratch_1 = dc_fixpt_add(one, args->a3);
360 /* In the first region (first 16 points) and in the
361 * region delimited by START/END we calculate with
362 * full precision to avoid error accumulation.
363 */
364 if ((cal_buffer->buffer_index >= PRECISE_LUT_REGION_START224 &&
365 cal_buffer->buffer_index <= PRECISE_LUT_REGION_END239) ||
366 (cal_buffer->buffer_index < 16))
367 scratch_2 = dc_fixpt_pow(args->arg,
368 dc_fixpt_recip(args->gamma));
369 else
370 scratch_2 = dc_fixpt_mul(cal_buffer->gamma_of_2,
371 cal_buffer->buffer[cal_buffer->buffer_index%16]);
372
373 if (cal_buffer->buffer_index != -1) {
374 cal_buffer->buffer[cal_buffer->buffer_index%16] = scratch_2;
375 cal_buffer->buffer_index++;
376 }
377
378 scratch_1 = dc_fixpt_mul(scratch_1, scratch_2);
379 scratch_1 = dc_fixpt_sub(scratch_1, args->a2);
380
381 return scratch_1;
382 }
383 else
384 return dc_fixpt_mul(args->arg, args->a1);
385}
386
387
388static struct fixed31_32 translate_from_linear_space_long(
389 struct translate_from_linear_space_args *args)
390{
391 const struct fixed31_32 one = dc_fixpt_from_int(1);
392
393 if (dc_fixpt_lt(one, args->arg))
394 return one;
395
396 if (dc_fixpt_le(args->arg, dc_fixpt_neg(args->a0)))
397 return dc_fixpt_sub(
398 args->a2,
399 dc_fixpt_mul(
400 dc_fixpt_add(
401 one,
402 args->a3),
403 dc_fixpt_pow(
404 dc_fixpt_neg(args->arg),
405 dc_fixpt_recip(args->gamma))));
406 else if (dc_fixpt_le(args->a0, args->arg))
407 return dc_fixpt_sub(
408 dc_fixpt_mul(
409 dc_fixpt_add(
410 one,
411 args->a3),
412 dc_fixpt_pow(
413 args->arg,
414 dc_fixpt_recip(args->gamma))),
415 args->a2);
416 else
417 return dc_fixpt_mul(args->arg, args->a1);
418}
419
420static struct fixed31_32 calculate_gamma22(struct fixed31_32 arg, bool_Bool use_eetf, struct calculate_buffer *cal_buffer)
421{
422 struct fixed31_32 gamma = dc_fixpt_from_fraction(22, 10);
423 struct translate_from_linear_space_args scratch_gamma_args;
424
425 scratch_gamma_args.arg = arg;
426 scratch_gamma_args.a0 = dc_fixpt_zero;
427 scratch_gamma_args.a1 = dc_fixpt_zero;
428 scratch_gamma_args.a2 = dc_fixpt_zero;
429 scratch_gamma_args.a3 = dc_fixpt_zero;
430 scratch_gamma_args.cal_buffer = cal_buffer;
431 scratch_gamma_args.gamma = gamma;
432
433 if (use_eetf)
434 return translate_from_linear_space_long(&scratch_gamma_args);
435
436 return translate_from_linear_space(&scratch_gamma_args);
437}
438
439
440static struct fixed31_32 translate_to_linear_space(
441 struct fixed31_32 arg,
442 struct fixed31_32 a0,
443 struct fixed31_32 a1,
444 struct fixed31_32 a2,
445 struct fixed31_32 a3,
446 struct fixed31_32 gamma)
447{
448 struct fixed31_32 linear;
449
450 a0 = dc_fixpt_mul(a0, a1);
451 if (dc_fixpt_le(arg, dc_fixpt_neg(a0)))
452
453 linear = dc_fixpt_neg(
454 dc_fixpt_pow(
455 dc_fixpt_div(
456 dc_fixpt_sub(a2, arg),
457 dc_fixpt_add(
458 dc_fixpt_one, a3)), gamma));
459
460 else if (dc_fixpt_le(dc_fixpt_neg(a0), arg) &&
461 dc_fixpt_le(arg, a0))
462 linear = dc_fixpt_div(arg, a1);
463 else
464 linear = dc_fixpt_pow(
465 dc_fixpt_div(
466 dc_fixpt_add(a2, arg),
467 dc_fixpt_add(
468 dc_fixpt_one, a3)), gamma);
469
470 return linear;
471}
472
473static struct fixed31_32 translate_from_linear_space_ex(
474 struct fixed31_32 arg,
475 struct gamma_coefficients *coeff,
476 uint32_t color_index,
477 struct calculate_buffer *cal_buffer)
478{
479 struct translate_from_linear_space_args scratch_gamma_args;
480
481 scratch_gamma_args.arg = arg;
482 scratch_gamma_args.a0 = coeff->a0[color_index];
483 scratch_gamma_args.a1 = coeff->a1[color_index];
484 scratch_gamma_args.a2 = coeff->a2[color_index];
485 scratch_gamma_args.a3 = coeff->a3[color_index];
486 scratch_gamma_args.gamma = coeff->user_gamma[color_index];
487 scratch_gamma_args.cal_buffer = cal_buffer;
488
489 return translate_from_linear_space(&scratch_gamma_args);
490}
491
492
493static inline struct fixed31_32 translate_to_linear_space_ex(
494 struct fixed31_32 arg,
495 struct gamma_coefficients *coeff,
496 uint32_t color_index)
497{
498 return translate_to_linear_space(
499 arg,
500 coeff->a0[color_index],
501 coeff->a1[color_index],
502 coeff->a2[color_index],
503 coeff->a3[color_index],
504 coeff->user_gamma[color_index]);
505}
506
507
508static bool_Bool find_software_points(
509 const struct dc_gamma *ramp,
510 const struct gamma_pixel *axis_x,
511 struct fixed31_32 hw_point,
512 enum channel_name channel,
513 uint32_t *index_to_start,
514 uint32_t *index_left,
515 uint32_t *index_right,
516 enum hw_point_position *pos)
517{
518 const uint32_t max_number = ramp->num_entries + 3;
519
520 struct fixed31_32 left, right;
521
522 uint32_t i = *index_to_start;
523
524 while (i < max_number) {
525 if (channel == CHANNEL_NAME_RED) {
526 left = axis_x[i].r;
527
528 if (i < max_number - 1)
529 right = axis_x[i + 1].r;
530 else
531 right = axis_x[max_number - 1].r;
532 } else if (channel == CHANNEL_NAME_GREEN) {
533 left = axis_x[i].g;
534
535 if (i < max_number - 1)
536 right = axis_x[i + 1].g;
537 else
538 right = axis_x[max_number - 1].g;
539 } else {
540 left = axis_x[i].b;
541
542 if (i < max_number - 1)
543 right = axis_x[i + 1].b;
544 else
545 right = axis_x[max_number - 1].b;
546 }
547
548 if (dc_fixpt_le(left, hw_point) &&
549 dc_fixpt_le(hw_point, right)) {
550 *index_to_start = i;
551 *index_left = i;
552
553 if (i < max_number - 1)
554 *index_right = i + 1;
555 else
556 *index_right = max_number - 1;
557
558 *pos = HW_POINT_POSITION_MIDDLE;
559
560 return true1;
561 } else if ((i == *index_to_start) &&
562 dc_fixpt_le(hw_point, left)) {
563 *index_to_start = i;
564 *index_left = i;
565 *index_right = i;
566
567 *pos = HW_POINT_POSITION_LEFT;
568
569 return true1;
570 } else if ((i == max_number - 1) &&
571 dc_fixpt_le(right, hw_point)) {
572 *index_to_start = i;
573 *index_left = i;
574 *index_right = i;
575
576 *pos = HW_POINT_POSITION_RIGHT;
577
578 return true1;
579 }
580
581 ++i;
582 }
583
584 return false0;
585}
586
587static bool_Bool build_custom_gamma_mapping_coefficients_worker(
588 const struct dc_gamma *ramp,
589 struct pixel_gamma_point *coeff,
590 const struct hw_x_point *coordinates_x,
591 const struct gamma_pixel *axis_x,
592 enum channel_name channel,
593 uint32_t number_of_points)
594{
595 uint32_t i = 0;
596
597 while (i <= number_of_points) {
598 struct fixed31_32 coord_x;
599
600 uint32_t index_to_start = 0;
601 uint32_t index_left = 0;
602 uint32_t index_right = 0;
603
604 enum hw_point_position hw_pos;
605
606 struct gamma_point *point;
607
608 struct fixed31_32 left_pos;
609 struct fixed31_32 right_pos;
610
611 if (channel == CHANNEL_NAME_RED)
612 coord_x = coordinates_x[i].regamma_y_red;
613 else if (channel == CHANNEL_NAME_GREEN)
614 coord_x = coordinates_x[i].regamma_y_green;
615 else
616 coord_x = coordinates_x[i].regamma_y_blue;
617
618 if (!find_software_points(
619 ramp, axis_x, coord_x, channel,
620 &index_to_start, &index_left, &index_right, &hw_pos)) {
621 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 621); do {} while (0); } while (0);
622 return false0;
623 }
624
625 if (index_left >= ramp->num_entries + 3) {
626 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 626); do {} while (0); } while (0);
627 return false0;
628 }
629
630 if (index_right >= ramp->num_entries + 3) {
631 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 631); do {} while (0); } while (0);
632 return false0;
633 }
634
635 if (channel == CHANNEL_NAME_RED) {
636 point = &coeff[i].r;
637
638 left_pos = axis_x[index_left].r;
639 right_pos = axis_x[index_right].r;
640 } else if (channel == CHANNEL_NAME_GREEN) {
641 point = &coeff[i].g;
642
643 left_pos = axis_x[index_left].g;
644 right_pos = axis_x[index_right].g;
645 } else {
646 point = &coeff[i].b;
647
648 left_pos = axis_x[index_left].b;
649 right_pos = axis_x[index_right].b;
650 }
651
652 if (hw_pos == HW_POINT_POSITION_MIDDLE)
653 point->coeff = dc_fixpt_div(
654 dc_fixpt_sub(
655 coord_x,
656 left_pos),
657 dc_fixpt_sub(
658 right_pos,
659 left_pos));
660 else if (hw_pos == HW_POINT_POSITION_LEFT)
661 point->coeff = dc_fixpt_zero;
662 else if (hw_pos == HW_POINT_POSITION_RIGHT)
663 point->coeff = dc_fixpt_from_int(2);
664 else {
665 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 665); do {} while (0); } while (0);
666 return false0;
667 }
668
669 point->left_index = index_left;
670 point->right_index = index_right;
671 point->pos = hw_pos;
672
673 ++i;
674 }
675
676 return true1;
677}
678
679static struct fixed31_32 calculate_mapped_value(
680 struct pwl_float_data *rgb,
681 const struct pixel_gamma_point *coeff,
682 enum channel_name channel,
683 uint32_t max_index)
684{
685 const struct gamma_point *point;
686
687 struct fixed31_32 result;
688
689 if (channel == CHANNEL_NAME_RED)
690 point = &coeff->r;
691 else if (channel == CHANNEL_NAME_GREEN)
692 point = &coeff->g;
693 else
694 point = &coeff->b;
695
696 if ((point->left_index < 0) || (point->left_index > max_index)) {
697 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 697); do {} while (0); } while (0);
698 return dc_fixpt_zero;
699 }
700
701 if ((point->right_index < 0) || (point->right_index > max_index)) {
702 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 702); do {} while (0); } while (0);
703 return dc_fixpt_zero;
704 }
705
706 if (point->pos == HW_POINT_POSITION_MIDDLE)
707 if (channel == CHANNEL_NAME_RED)
708 result = dc_fixpt_add(
709 dc_fixpt_mul(
710 point->coeff,
711 dc_fixpt_sub(
712 rgb[point->right_index].r,
713 rgb[point->left_index].r)),
714 rgb[point->left_index].r);
715 else if (channel == CHANNEL_NAME_GREEN)
716 result = dc_fixpt_add(
717 dc_fixpt_mul(
718 point->coeff,
719 dc_fixpt_sub(
720 rgb[point->right_index].g,
721 rgb[point->left_index].g)),
722 rgb[point->left_index].g);
723 else
724 result = dc_fixpt_add(
725 dc_fixpt_mul(
726 point->coeff,
727 dc_fixpt_sub(
728 rgb[point->right_index].b,
729 rgb[point->left_index].b)),
730 rgb[point->left_index].b);
731 else if (point->pos == HW_POINT_POSITION_LEFT) {
732 BREAK_TO_DEBUGGER()do { ___drm_dbg(((void *)0), DRM_UT_DRIVER, "%s():%d\n", __func__
, 732); do {} while (0); } while (0);
733 result = dc_fixpt_zero;
734 } else {
735 result = dc_fixpt_one;
736 }
737
738 return result;
739}
740
741static void build_pq(struct pwl_float_data_ex *rgb_regamma,
742 uint32_t hw_points_num,
743 const struct hw_x_point *coordinate_x,
744 uint32_t sdr_white_level)
745{
746 uint32_t i, start_index;
747
748 struct pwl_float_data_ex *rgb = rgb_regamma;
749 const struct hw_x_point *coord_x = coordinate_x;
750 struct fixed31_32 x;
751 struct fixed31_32 output;
752 struct fixed31_32 scaling_factor =
753 dc_fixpt_from_fraction(sdr_white_level, 10000);
754 struct fixed31_32 *pq_table = mod_color_get_table(type_pq_table);
755
756 if (!mod_color_is_table_init(type_pq_table) && sdr_white_level == 80) {
757 precompute_pq();
758 mod_color_set_table_init_state(type_pq_table, true1);
759 }
760
761 /* TODO: start index is from segment 2^-24, skipping first segment
762 * due to x values too small for power calculations
763 */
764 start_index = 32;
765 rgb += start_index;
766 coord_x += start_index;
767
768 for (i = start_index; i <= hw_points_num; i++) {
769 /* Multiply 0.008 as regamma is 0-1 and FP16 input is 0-125.
770 * FP 1.0 = 80nits
771 */
772 if (sdr_white_level == 80) {
773 output = pq_table[i];
774 } else {
775 x = dc_fixpt_mul(coord_x->x, scaling_factor);
776 compute_pq(x, &output);
777 }
778
779 /* should really not happen? */
780 if (dc_fixpt_lt(output, dc_fixpt_zero))
781 output = dc_fixpt_zero;
782 else if (dc_fixpt_lt(dc_fixpt_one, output))
783 output = dc_fixpt_one;
784
785 rgb->r = output;
786 rgb->g = output;
787 rgb->b = output;
788
789 ++coord_x;
790 ++rgb;
791 }
792}
793
794static void build_de_pq(struct pwl_float_data_ex *de_pq,
795 uint32_t hw_points_num,
796 const struct hw_x_point *coordinate_x)
797{
798 uint32_t i;
799 struct fixed31_32 output;
800 struct fixed31_32 *de_pq_table = mod_color_get_table(type_de_pq_table);
801 struct fixed31_32 scaling_factor = dc_fixpt_from_int(125);
802
803 if (!mod_color_is_table_init(type_de_pq_table)) {
804 precompute_de_pq();
805 mod_color_set_table_init_state(type_de_pq_table, true1);
806 }
807
808
809 for (i = 0; i <= hw_points_num; i++) {
810 output = de_pq_table[i];
811 /* should really not happen? */
812 if (dc_fixpt_lt(output, dc_fixpt_zero))
813 output = dc_fixpt_zero;
814 else if (dc_fixpt_lt(scaling_factor, output))
815 output = scaling_factor;
816 de_pq[i].r = output;
817 de_pq[i].g = output;
818 de_pq[i].b = output;
819 }
820}
821
822static bool_Bool build_regamma(struct pwl_float_data_ex *rgb_regamma,
823 uint32_t hw_points_num,
824 const struct hw_x_point *coordinate_x,
825 enum dc_transfer_func_predefined type,
826 struct calculate_buffer *cal_buffer)
827{
828 uint32_t i;
829 bool_Bool ret = false0;
830
831 struct gamma_coefficients *coeff;
832 struct pwl_float_data_ex *rgb = rgb_regamma;
833 const struct hw_x_point *coord_x = coordinate_x;
834
835 coeff = kvzalloc(sizeof(*coeff), GFP_KERNEL(0x0001 | 0x0004));
836 if (!coeff)
837 goto release;
838
839 if (!build_coefficients(coeff, type))
840 goto release;
841
842 memset(cal_buffer->buffer, 0, NUM_PTS_IN_REGION * sizeof(struct fixed31_32))__builtin_memset((cal_buffer->buffer), (0), (16 * sizeof(struct
fixed31_32)));
843 cal_buffer->buffer_index = 0; // see variable definition for more info
844
845 i = 0;
846 while (i <= hw_points_num) {
847 /* TODO use y vs r,g,b */
848 rgb->r = translate_from_linear_space_ex(
849 coord_x->x, coeff, 0, cal_buffer);
850 rgb->g = rgb->r;
851 rgb->b = rgb->r;
852 ++coord_x;
853 ++rgb;
854 ++i;
855 }
856 cal_buffer->buffer_index = -1;
857 ret = true1;
858release:
859 kvfree(coeff);
860 return ret;
861}
862
863static void hermite_spline_eetf(struct fixed31_32 input_x,
864 struct fixed31_32 max_display,
865 struct fixed31_32 min_display,
866 struct fixed31_32 max_content,
867 struct fixed31_32 *out_x)
868{
869 struct fixed31_32 min_lum_pq;
870 struct fixed31_32 max_lum_pq;
871 struct fixed31_32 max_content_pq;
872 struct fixed31_32 ks;
873 struct fixed31_32 E1;
874 struct fixed31_32 E2;
875 struct fixed31_32 E3;
876 struct fixed31_32 t;
877 struct fixed31_32 t2;
878 struct fixed31_32 t3;
879 struct fixed31_32 two;
880 struct fixed31_32 three;
881 struct fixed31_32 temp1;
882 struct fixed31_32 temp2;
883 struct fixed31_32 a = dc_fixpt_from_fraction(15, 10);
884 struct fixed31_32 b = dc_fixpt_from_fraction(5, 10);
885 struct fixed31_32 epsilon = dc_fixpt_from_fraction(1, 1000000); // dc_fixpt_epsilon is a bit too small
886
887 if (dc_fixpt_eq(max_content, dc_fixpt_zero)) {
888 *out_x = dc_fixpt_zero;
889 return;
890 }
891
892 compute_pq(input_x, &E1);
893 compute_pq(dc_fixpt_div(min_display, max_content), &min_lum_pq);
894 compute_pq(dc_fixpt_div(max_display, max_content), &max_lum_pq);
895 compute_pq(dc_fixpt_one, &max_content_pq); // always 1? DAL2 code is weird
896 a = dc_fixpt_div(dc_fixpt_add(dc_fixpt_one, b), max_content_pq); // (1+b)/maxContent
897 ks = dc_fixpt_sub(dc_fixpt_mul(a, max_lum_pq), b); // a * max_lum_pq - b
898
899 if (dc_fixpt_lt(E1, ks))
900 E2 = E1;
901 else if (dc_fixpt_le(ks, E1) && dc_fixpt_le(E1, dc_fixpt_one)) {
902 if (dc_fixpt_lt(epsilon, dc_fixpt_sub(dc_fixpt_one, ks)))
903 // t = (E1 - ks) / (1 - ks)
904 t = dc_fixpt_div(dc_fixpt_sub(E1, ks),
905 dc_fixpt_sub(dc_fixpt_one, ks));
906 else
907 t = dc_fixpt_zero;
908
909 two = dc_fixpt_from_int(2);
910 three = dc_fixpt_from_int(3);
911
912 t2 = dc_fixpt_mul(t, t);
913 t3 = dc_fixpt_mul(t2, t);
914 temp1 = dc_fixpt_mul(two, t3);
915 temp2 = dc_fixpt_mul(three, t2);
916
917 // (2t^3 - 3t^2 + 1) * ks
918 E2 = dc_fixpt_mul(ks, dc_fixpt_add(dc_fixpt_one,
919 dc_fixpt_sub(temp1, temp2)));
920
921 // (-2t^3 + 3t^2) * max_lum_pq
922 E2 = dc_fixpt_add(E2, dc_fixpt_mul(max_lum_pq,
923 dc_fixpt_sub(temp2, temp1)));
924
925 temp1 = dc_fixpt_mul(two, t2);
926 temp2 = dc_fixpt_sub(dc_fixpt_one, ks);
927
928 // (t^3 - 2t^2 + t) * (1-ks)
929 E2 = dc_fixpt_add(E2, dc_fixpt_mul(temp2,
930 dc_fixpt_add(t, dc_fixpt_sub(t3, temp1))));
931 } else
932 E2 = dc_fixpt_one;
933
934 temp1 = dc_fixpt_sub(dc_fixpt_one, E2);
935 temp2 = dc_fixpt_mul(temp1, temp1);
936 temp2 = dc_fixpt_mul(temp2, temp2);
937 // temp2 = (1-E2)^4
938
939 E3 = dc_fixpt_add(E2, dc_fixpt_mul(min_lum_pq, temp2));
940 compute_de_pq(E3, out_x);
941
942 *out_x = dc_fixpt_div(*out_x, dc_fixpt_div(max_display, max_content));
943}
944
945static bool_Bool build_freesync_hdr(struct pwl_float_data_ex *rgb_regamma,
946 uint32_t hw_points_num,
947 const struct hw_x_point *coordinate_x,
948 const struct hdr_tm_params *fs_params,
949 struct calculate_buffer *cal_buffer)
950{
951 uint32_t i;
952 struct pwl_float_data_ex *rgb = rgb_regamma;
953 const struct hw_x_point *coord_x = coordinate_x;
954 const struct hw_x_point *prv_coord_x = coord_x;
955 struct fixed31_32 scaledX = dc_fixpt_zero;
956 struct fixed31_32 scaledX1 = dc_fixpt_zero;
957 struct fixed31_32 max_display;
958 struct fixed31_32 min_display;
959 struct fixed31_32 max_content;
960 struct fixed31_32 clip = dc_fixpt_one;
961 struct fixed31_32 output;
962 bool_Bool use_eetf = false0;
963 bool_Bool is_clipped = false0;
964 struct fixed31_32 sdr_white_level;
965 struct fixed31_32 coordX_diff;
966 struct fixed31_32 out_dist_max;
967 struct fixed31_32 bright_norm;
968
969 if (fs_params->max_content == 0 ||
18
←
Assuming field 'max_content' is not equal to 0
→
20
←
Taking false branch
→
970 fs_params->max_display == 0)
19
←
Assuming field 'max_display' is not equal to 0
→
971 return false0;
972
973 max_display = dc_fixpt_from_int(fs_params->max_display);
974 min_display = dc_fixpt_from_fraction(fs_params->min_display, 10000);
975 max_content = dc_fixpt_from_int(fs_params->max_content);
976 sdr_white_level = dc_fixpt_from_int(fs_params->sdr_white_level);
977
978 if (fs_params->min_display > 1000) // cap at 0.1 at the bottom
21
←
Assuming field 'min_display' is <= 1000
→
22
←
Taking false branch
→
979 min_display = dc_fixpt_from_fraction(1, 10);
980 if (fs_params->max_display < 100) // cap at 100 at the top
23
←
Assuming field 'max_display' is >= 100
→
24
←
Taking false branch
→
981 max_display = dc_fixpt_from_int(100);
982
983 // only max used, we don't adjust min luminance
984 if (fs_params->max_content > fs_params->max_display)
25
←
Assuming field 'max_content' is <= field 'max_display'
→
26
←
Taking false branch
→
985 use_eetf = true1;
986 else
987 max_content = max_display;
988
989 if (!use_eetf
26.1
'use_eetf' is false
26.1
'use_eetf' is false
)
27
←
Taking true branch
→
990 cal_buffer->buffer_index = 0; // see var definition for more info
991 rgb += 32; // first 32 points have problems with fixed point, too small
992 coord_x += 32;
993
994 for (i = 32; i <= hw_points_num; i++) {
28
←
Loop condition is true. Entering loop body
→
995 if (!is_clipped
28.1
'is_clipped' is false
28.1
'is_clipped' is false
) {
29
←
Taking true branch
→
996 if (use_eetf
29.1
'use_eetf' is false
29.1
'use_eetf' is false
) {
30
←
Taking false branch
→
997 /* max content is equal 1 */
998 scaledX1 = dc_fixpt_div(coord_x->x,
999 dc_fixpt_div(max_content, sdr_white_level));
1000 hermite_spline_eetf(scaledX1, max_display, min_display,
1001 max_content, &scaledX);
1002 } else
1003 scaledX = dc_fixpt_div(coord_x->x,
1004 dc_fixpt_div(max_display, sdr_white_level));
1005
1006 if (dc_fixpt_lt(scaledX, clip)) {
31
←
Taking false branch
→
1007 if (dc_fixpt_lt(scaledX, dc_fixpt_zero))
1008 output = dc_fixpt_zero;
1009 else
1010 output = calculate_gamma22(scaledX, use_eetf, cal_buffer);
1011
1012 // Ensure output respects reasonable boundaries
1013 output = dc_fixpt_clamp(output, dc_fixpt_zero, dc_fixpt_one);
1014
1015 rgb->r = output;
1016 rgb->g = output;
1017 rgb->b = output;
1018 } else {
1019 /* Here clipping happens for the first time */
1020 is_clipped = true1;
1021
1022 /* The next few lines implement the equation
1023 * output = prev_out +
1024 * (coord_x->x - prev_coord_x->x) *
1025 * (1.0 - prev_out) /
1026 * (maxDisp/sdr_white_level - prevCoordX)
1027 *
1028 * This equation interpolates the first point
1029 * after max_display/80 so that the slope from
1030 * hw_x_before_max and hw_x_after_max is such
1031 * that we hit Y=1.0 at max_display/80.
1032 */
1033
1034 coordX_diff = dc_fixpt_sub(coord_x->x, prv_coord_x->x);
1035 out_dist_max = dc_fixpt_sub(dc_fixpt_one, output);
32
←
Uninitialized value stored to 'arg2.value'
→
33
←
Calling 'dc_fixpt_sub'
→
1036 bright_norm = dc_fixpt_div(max_display, sdr_white_level);
1037
1038 output = dc_fixpt_add(
1039 output, dc_fixpt_mul(
1040 coordX_diff, dc_fixpt_div(
1041 out_dist_max,
1042 dc_fixpt_sub(bright_norm, prv_coord_x->x)
1043 )
1044 )
1045 );
1046
1047 /* Relaxing the maximum boundary to 1.07 (instead of 1.0)
1048 * because the last point in the curve must be such that
1049 * the maximum display pixel brightness interpolates to
1050 * exactly 1.0. The worst case scenario was calculated
1051 * around 1.057, so the limit of 1.07 leaves some safety
1052 * margin.
1053 */
1054 output = dc_fixpt_clamp(output, dc_fixpt_zero,
1055 dc_fixpt_from_fraction(107, 100));
1056
1057 rgb->r = output;
1058 rgb->g = output;
1059 rgb->b = output;
1060 }
1061 } else {
1062 /* Every other clipping after the first
1063 * one is dealt with here
1064 */
1065 rgb->r = clip;
1066 rgb->g = clip;
1067 rgb->b = clip;
1068 }
1069
1070 prv_coord_x = coord_x;
1071 ++coord_x;
1072 ++rgb;
1073 }
1074 cal_buffer->buffer_index = -1;
1075
1076 return true1;
1077}
1078
1079static bool_Bool build_degamma(struct pwl_float_data_ex *curve,
1080 uint32_t hw_points_num,
1081 const struct hw_x_point *coordinate_x, enum dc_transfer_func_predefined type)
1082{
1083 uint32_t i;
1084 struct gamma_coefficients coeff;
1085 uint32_t begin_index, end_index;
1086 bool_Bool ret = false0;
1087
1088 if (!build_coefficients(&coeff, type))
1089 goto release;
1090
1091 i = 0;
1092
1093 /* X points is 2^-25 to 2^7
1094 * De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions
1095 */
1096 begin_index = 13 * NUM_PTS_IN_REGION16;
1097 end_index = begin_index + 12 * NUM_PTS_IN_REGION16;
1098
1099 while (i != begin_index) {
1100 curve[i].r = dc_fixpt_zero;
1101 curve[i].g = dc_fixpt_zero;
1102 curve[i].b = dc_fixpt_zero;
1103 i++;
1104 }
1105
1106 while (i != end_index) {
1107 curve[i].r = translate_to_linear_space_ex(
1108 coordinate_x[i].x, &coeff, 0);
1109 curve[i].g = curve[i].r;
1110 curve[i].b = curve[i].r;
1111 i++;
1112 }
1113 while (i != hw_points_num + 1) {
1114 curve[i].r = dc_fixpt_one;
1115 curve[i].g = dc_fixpt_one;
1116 curve[i].b = dc_fixpt_one;
1117 i++;
1118 }
1119 ret = true1;
1120release:
1121 return ret;
1122}
1123
1124
1125
1126
1127
1128static void build_hlg_degamma(struct pwl_float_data_ex *degamma,
1129 uint32_t hw_points_num,
1130 const struct hw_x_point *coordinate_x,
1131 uint32_t sdr_white_level, uint32_t max_luminance_nits)
1132{
1133 uint32_t i;
1134
1135 struct pwl_float_data_ex *rgb = degamma;
1136 const struct hw_x_point *coord_x = coordinate_x;
1137
1138 i = 0;
1139 // check when i == 434
1140 while (i != hw_points_num + 1) {
1141 compute_hlg_eotf(coord_x->x, &rgb->r, sdr_white_level, max_luminance_nits);
1142 rgb->g = rgb->r;
1143 rgb->b = rgb->r;
1144 ++coord_x;
1145 ++rgb;
1146 ++i;
1147 }
1148}
1149
1150
1151static void build_hlg_regamma(struct pwl_float_data_ex *regamma,
1152 uint32_t hw_points_num,
1153 const struct hw_x_point *coordinate_x,
1154 uint32_t sdr_white_level, uint32_t max_luminance_nits)
1155{
1156 uint32_t i;
1157
1158 struct pwl_float_data_ex *rgb = regamma;
1159 const struct hw_x_point *coord_x = coordinate_x;
1160
1161 i = 0;
1162
1163 // when i == 471
1164 while (i != hw_points_num + 1) {
1165 compute_hlg_oetf(coord_x->x, &rgb->r, sdr_white_level, max_luminance_nits);
1166 rgb->g = rgb->r;
1167 rgb->b = rgb->r;
1168 ++coord_x;
1169 ++rgb;
1170 ++i;
1171 }
1172}
1173
1174static void scale_gamma(struct pwl_float_data *pwl_rgb,
1175 const struct dc_gamma *ramp,
1176 struct dividers dividers)
1177{
1178 const struct fixed31_32 max_driver = dc_fixpt_from_int(0xFFFF);
1179 const struct fixed31_32 max_os = dc_fixpt_from_int(0xFF00);
1180 struct fixed31_32 scaler = max_os;
1181 uint32_t i;
1182 struct pwl_float_data *rgb = pwl_rgb;
1183 struct pwl_float_data *rgb_last = rgb + ramp->num_entries - 1;
1184
1185 i = 0;
1186
1187 do {
1188 if (dc_fixpt_lt(max_os, ramp->entries.red[i]) ||
1189 dc_fixpt_lt(max_os, ramp->entries.green[i]) ||
1190 dc_fixpt_lt(max_os, ramp->entries.blue[i])) {
1191 scaler = max_driver;
1192 break;
1193 }
1194 ++i;
1195 } while (i != ramp->num_entries);
1196
1197 i = 0;
1198
1199 do {
1200 rgb->r = dc_fixpt_div(
1201 ramp->entries.red[i], scaler);
1202 rgb->g = dc_fixpt_div(
1203 ramp->entries.green[i], scaler);
1204 rgb->b = dc_fixpt_div(
1205 ramp->entries.blue[i], scaler);
1206
1207 ++rgb;
1208 ++i;
1209 } while (i != ramp->num_entries);
1210
1211 rgb->r = dc_fixpt_mul(rgb_last->r,
1212 dividers.divider1);
1213 rgb->g = dc_fixpt_mul(rgb_last->g,
1214 dividers.divider1);
1215 rgb->b = dc_fixpt_mul(rgb_last->b,
1216 dividers.divider1);
1217
1218 ++rgb;
1219
1220 rgb->r = dc_fixpt_mul(rgb_last->r,
1221 dividers.divider2);
1222 rgb->g = dc_fixpt_mul(rgb_last->g,
1223 dividers.divider2);
1224 rgb->b = dc_fixpt_mul(rgb_last->b,
1225 dividers.divider2);
1226
1227 ++rgb;
1228
1229 rgb->r = dc_fixpt_mul(rgb_last->r,
1230 dividers.divider3);
1231 rgb->g = dc_fixpt_mul(rgb_last->g,
1232 dividers.divider3);
1233 rgb->b = dc_fixpt_mul(rgb_last->b,
1234 dividers.divider3);
1235}
1236
1237static void scale_gamma_dx(struct pwl_float_data *pwl_rgb,
1238 const struct dc_gamma *ramp,
1239 struct dividers dividers)
1240{
1241 uint32_t i;
1242 struct fixed31_32 min = dc_fixpt_zero;
1243 struct fixed31_32 max = dc_fixpt_one;
1244
1245 struct fixed31_32 delta = dc_fixpt_zero;
1246 struct fixed31_32 offset = dc_fixpt_zero;
1247
1248 for (i = 0 ; i < ramp->num_entries; i++) {
1249 if (dc_fixpt_lt(ramp->entries.red[i], min))
1250 min = ramp->entries.red[i];
1251
1252 if (dc_fixpt_lt(ramp->entries.green[i], min))
1253 min = ramp->entries.green[i];
1254
1255 if (dc_fixpt_lt(ramp->entries.blue[i], min))
1256 min = ramp->entries.blue[i];
1257
1258 if (dc_fixpt_lt(max, ramp->entries.red[i]))
1259 max = ramp->entries.red[i];
1260
1261 if (dc_fixpt_lt(max, ramp->entries.green[i]))
1262 max = ramp->entries.green[i];
1263
1264 if (dc_fixpt_lt(max, ramp->entries.blue[i]))
1265 max = ramp->entries.blue[i];
1266 }
1267
1268 if (dc_fixpt_lt(min, dc_fixpt_zero))
1269 delta = dc_fixpt_neg(min);
1270
1271 offset = dc_fixpt_add(min, max);
1272
1273 for (i = 0 ; i < ramp->num_entries; i++) {
1274 pwl_rgb[i].r = dc_fixpt_div(
1275 dc_fixpt_add(
1276 ramp->entries.red[i], delta), offset);
1277 pwl_rgb[i].g = dc_fixpt_div(
1278 dc_fixpt_add(
1279 ramp->entries.green[i], delta), offset);
1280 pwl_rgb[i].b = dc_fixpt_div(
1281 dc_fixpt_add(
1282 ramp->entries.blue[i], delta), offset);
1283
1284 }
1285
1286 pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int(
1287 pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r);
1288 pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int(
1289 pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g);
1290 pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int(
1291 pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b);
1292 ++i;
1293 pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int(
1294 pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r);
1295 pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int(
1296 pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g);
1297 pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int(
1298 pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b);
1299}
1300
1301/* todo: all these scale_gamma functions are inherently the same but
1302 * take different structures as params or different format for ramp
1303 * values. We could probably implement it in a more generic fashion
1304 */
1305static void scale_user_regamma_ramp(struct pwl_float_data *pwl_rgb,
1306 const struct regamma_ramp *ramp,
1307 struct dividers dividers)
1308{
1309 unsigned short max_driver = 0xFFFF;
1310 unsigned short max_os = 0xFF00;
1311 unsigned short scaler = max_os;
1312 uint32_t i;
1313 struct pwl_float_data *rgb = pwl_rgb;
1314 struct pwl_float_data *rgb_last = rgb + GAMMA_RGB_256_ENTRIES - 1;
1315
1316 i = 0;
1317 do {
1318 if (ramp->gamma[i] > max_os ||
1319 ramp->gamma[i + 256] > max_os ||
1320 ramp->gamma[i + 512] > max_os) {
1321 scaler = max_driver;
1322 break;
1323 }
1324 i++;
1325 } while (i != GAMMA_RGB_256_ENTRIES);
1326
1327 i = 0;
1328 do {
1329 rgb->r = dc_fixpt_from_fraction(
1330 ramp->gamma[i], scaler);
1331 rgb->g = dc_fixpt_from_fraction(
1332 ramp->gamma[i + 256], scaler);
1333 rgb->b = dc_fixpt_from_fraction(
1334 ramp->gamma[i + 512], scaler);
1335
1336 ++rgb;
1337 ++i;
1338 } while (i != GAMMA_RGB_256_ENTRIES);
1339
1340 rgb->r = dc_fixpt_mul(rgb_last->r,
1341 dividers.divider1);
1342 rgb->g = dc_fixpt_mul(rgb_last->g,
1343 dividers.divider1);
1344 rgb->b = dc_fixpt_mul(rgb_last->b,
1345 dividers.divider1);
1346
1347 ++rgb;
1348
1349 rgb->r = dc_fixpt_mul(rgb_last->r,
1350 dividers.divider2);
1351 rgb->g = dc_fixpt_mul(rgb_last->g,
1352 dividers.divider2);
1353 rgb->b = dc_fixpt_mul(rgb_last->b,
1354 dividers.divider2);
1355
1356 ++rgb;
1357
1358 rgb->r = dc_fixpt_mul(rgb_last->r,
1359 dividers.divider3);
1360 rgb->g = dc_fixpt_mul(rgb_last->g,
1361 dividers.divider3);
1362 rgb->b = dc_fixpt_mul(rgb_last->b,
1363 dividers.divider3);
1364}
1365
1366/*
1367 * RS3+ color transform DDI - 1D LUT adjustment is composed with regamma here
1368 * Input is evenly distributed in the output color space as specified in
1369 * SetTimings
1370 *
1371 * Interpolation details:
1372 * 1D LUT has 4096 values which give curve correction in 0-1 float range
1373 * for evenly spaced points in 0-1 range. lut1D[index] gives correction
1374 * for index/4095.
1375 * First we find index for which:
1376 * index/4095 < regamma_y < (index+1)/4095 =>
1377 * index < 4095*regamma_y < index + 1
1378 * norm_y = 4095*regamma_y, and index is just truncating to nearest integer
1379 * lut1 = lut1D[index], lut2 = lut1D[index+1]
1380 *
1381 * adjustedY is then linearly interpolating regamma Y between lut1 and lut2
1382 *
1383 * Custom degamma on Linux uses the same interpolation math, so is handled here
1384 */
1385static void apply_lut_1d(
1386 const struct dc_gamma *ramp,
1387 uint32_t num_hw_points,
1388 struct dc_transfer_func_distributed_points *tf_pts)
1389{
1390 int i = 0;
1391 int color = 0;
1392 struct fixed31_32 *regamma_y;
1393 struct fixed31_32 norm_y;
1394 struct fixed31_32 lut1;
1395 struct fixed31_32 lut2;
1396 const int max_lut_index = 4095;
1397 const struct fixed31_32 penult_lut_index_f =
1398 dc_fixpt_from_int(max_lut_index-1);
1399 const struct fixed31_32 max_lut_index_f =
1400 dc_fixpt_from_int(max_lut_index);
1401 int32_t index = 0, index_next = 0;
1402 struct fixed31_32 index_f;
1403 struct fixed31_32 delta_lut;
1404 struct fixed31_32 delta_index;
1405
1406 if (ramp->type != GAMMA_CS_TFM_1D && ramp->type != GAMMA_CUSTOM)
1407 return; // this is not expected
1408
1409 for (i = 0; i < num_hw_points; i++) {
1410 for (color = 0; color < 3; color++) {
1411 if (color == 0)
1412 regamma_y = &tf_pts->red[i];
1413 else if (color == 1)
1414 regamma_y = &tf_pts->green[i];
1415 else
1416 regamma_y = &tf_pts->blue[i];
1417
1418 norm_y = dc_fixpt_mul(max_lut_index_f,
1419 *regamma_y);
1420 index = dc_fixpt_floor(norm_y);
1421 index_f = dc_fixpt_from_int(index);
1422
1423 if (index < 0)
1424 continue;
1425
1426 if (index <= max_lut_index)
1427 index_next = (index == max_lut_index) ? index : index+1;
1428 else {
1429 /* Here we are dealing with the last point in the curve,
1430 * which in some cases might exceed the range given by
1431 * max_lut_index. So we interpolate the value using
1432 * max_lut_index and max_lut_index - 1.
1433 */
1434 index = max_lut_index - 1;
1435 index_next = max_lut_index;
1436 index_f = penult_lut_index_f;
1437 }
1438
1439 if (color == 0) {
1440 lut1 = ramp->entries.red[index];
1441 lut2 = ramp->entries.red[index_next];
1442 } else if (color == 1) {
1443 lut1 = ramp->entries.green[index];
1444 lut2 = ramp->entries.green[index_next];
1445 } else {
1446 lut1 = ramp->entries.blue[index];
1447 lut2 = ramp->entries.blue[index_next];
1448 }
1449
1450 // we have everything now, so interpolate
1451 delta_lut = dc_fixpt_sub(lut2, lut1);
1452 delta_index = dc_fixpt_sub(norm_y, index_f);
1453
1454 *regamma_y = dc_fixpt_add(lut1,
1455 dc_fixpt_mul(delta_index, delta_lut));
1456 }
1457 }
1458}
1459
1460static void build_evenly_distributed_points(
1461 struct gamma_pixel *points,
1462 uint32_t numberof_points,
1463 struct dividers dividers)
1464{
1465 struct gamma_pixel *p = points;
1466 struct gamma_pixel *p_last;
1467
1468 uint32_t i = 0;
1469
1470 // This function should not gets called with 0 as a parameter
1471 ASSERT(numberof_points > 0)do { if (({ static int __warned; int __ret = !!(!(numberof_points
> 0)); if (__ret && !__warned) { printf("WARNING %s failed at %s:%d\n"
, "!(numberof_points > 0)", "/usr/src/sys/dev/pci/drm/amd/display/modules/color/color_gamma.c"
, 1471); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
1472 p_last = p + numberof_points - 1;
1473
1474 do {
1475 struct fixed31_32 value = dc_fixpt_from_fraction(i,
1476 numberof_points - 1);
1477
1478 p->r = value;
1479 p->g = value;
1480 p->b = value;
1481
1482 ++p;
1483 ++i;
1484 } while (i < numberof_points);
1485
1486 p->r = dc_fixpt_div(p_last->r, dividers.divider1);
1487 p->g = dc_fixpt_div(p_last->g, dividers.divider1);
1488 p->b = dc_fixpt_div(p_last->b, dividers.divider1);
1489
1490 ++p;
1491
1492 p->r = dc_fixpt_div(p_last->r, dividers.divider2);
1493 p->g = dc_fixpt_div(p_last->g, dividers.divider2);
1494 p->b = dc_fixpt_div(p_last->b, dividers.divider2);
1495
1496 ++p;
1497
1498 p->r = dc_fixpt_div(p_last->r, dividers.divider3);
1499 p->g = dc_fixpt_div(p_last->g, dividers.divider3);
1500 p->b = dc_fixpt_div(p_last->b, dividers.divider3);
1501}
1502
1503static inline void copy_rgb_regamma_to_coordinates_x(
1504 struct hw_x_point *coordinates_x,
1505 uint32_t hw_points_num,
1506 const struct pwl_float_data_ex *rgb_ex)
1507{
1508 struct hw_x_point *coords = coordinates_x;
1509 uint32_t i = 0;
1510 const struct pwl_float_data_ex *rgb_regamma = rgb_ex;
1511
1512 while (i <= hw_points_num + 1) {
1513 coords->regamma_y_red = rgb_regamma->r;
1514 coords->regamma_y_green = rgb_regamma->g;
1515 coords->regamma_y_blue = rgb_regamma->b;
1516
1517 ++coords;
1518 ++rgb_regamma;
1519 ++i;
1520 }
1521}
1522
1523static bool_Bool calculate_interpolated_hardware_curve(
1524 const struct dc_gamma *ramp,
1525 struct pixel_gamma_point *coeff128,
1526 struct pwl_float_data *rgb_user,
1527 const struct hw_x_point *coordinates_x,
1528 const struct gamma_pixel *axis_x,
1529 uint32_t number_of_points,
1530 struct dc_transfer_func_distributed_points *tf_pts)
1531{
1532
1533 const struct pixel_gamma_point *coeff = coeff128;
1534 uint32_t max_entries = 3 - 1;
1535
1536 uint32_t i = 0;
1537
1538 for (i = 0; i < 3; i++) {
1539 if (!build_custom_gamma_mapping_coefficients_worker(
1540 ramp, coeff128, coordinates_x, axis_x, i,
1541 number_of_points))
1542 return false0;
1543 }
1544
1545 i = 0;
1546 max_entries += ramp->num_entries;
1547
1548 /* TODO: float point case */
1549
1550 while (i <= number_of_points) {
1551 tf_pts->red[i] = calculate_mapped_value(
1552 rgb_user, coeff, CHANNEL_NAME_RED, max_entries);
1553 tf_pts->green[i] = calculate_mapped_value(
1554 rgb_user, coeff, CHANNEL_NAME_GREEN, max_entries);
1555 tf_pts->blue[i] = calculate_mapped_value(
1556 rgb_user, coeff, CHANNEL_NAME_BLUE, max_entries);
1557
1558 ++coeff;
1559 ++i;
1560 }
1561
1562 return true1;
1563}
1564
1565/* The "old" interpolation uses a complicated scheme to build an array of
1566 * coefficients while also using an array of 0-255 normalized to 0-1
1567 * Then there's another loop using both of the above + new scaled user ramp
1568 * and we concatenate them. It also searches for points of interpolation and
1569 * uses enums for positions.
1570 *
1571 * This function uses a different approach:
1572 * user ramp is always applied on X with 0/255, 1/255, 2/255, ..., 255/255
1573 * To find index for hwX , we notice the following:
1574 * i/255 <= hwX < (i+1)/255 <=> i <= 255*hwX < i+1
1575 * See apply_lut_1d which is the same principle, but on 4K entry 1D LUT
1576 *
1577 * Once the index is known, combined Y is simply:
1578 * user_ramp(index) + (hwX-index/255)*(user_ramp(index+1) - user_ramp(index)
1579 *
1580 * We should switch to this method in all cases, it's simpler and faster
1581 * ToDo one day - for now this only applies to ADL regamma to avoid regression
1582 * for regular use cases (sRGB and PQ)
1583 */
1584static void interpolate_user_regamma(uint32_t hw_points_num,
1585 struct pwl_float_data *rgb_user,
1586 bool_Bool apply_degamma,
1587 struct dc_transfer_func_distributed_points *tf_pts)
1588{
1589 uint32_t i;
1590 uint32_t color = 0;
1591 int32_t index;
1592 int32_t index_next;
1593 struct fixed31_32 *tf_point;
1594 struct fixed31_32 hw_x;
1595 struct fixed31_32 norm_factor =
1596 dc_fixpt_from_int(255);
1597 struct fixed31_32 norm_x;
1598 struct fixed31_32 index_f;
1599 struct fixed31_32 lut1;
1600 struct fixed31_32 lut2;
1601 struct fixed31_32 delta_lut;
1602 struct fixed31_32 delta_index;
1603 const struct fixed31_32 one = dc_fixpt_from_int(1);
1604
1605 i = 0;
1606 /* fixed_pt library has problems handling too small values */
1607 while (i != 32) {
1608 tf_pts->red[i] = dc_fixpt_zero;
1609 tf_pts->green[i] = dc_fixpt_zero;
1610 tf_pts->blue[i] = dc_fixpt_zero;
1611 ++i;
1612 }
1613 while (i <= hw_points_num + 1) {
1614 for (color = 0; color < 3; color++) {
1615 if (color == 0)
1616 tf_point = &tf_pts->red[i];
1617 else if (color == 1)
1618 tf_point = &tf_pts->green[i];
1619 else
1620 tf_point = &tf_pts->blue[i];
1621
1622 if (apply_degamma) {
1623 if (color == 0)
1624 hw_x = coordinates_x[i].regamma_y_red;
1625 else if (color == 1)
1626 hw_x = coordinates_x[i].regamma_y_green;
1627 else
1628 hw_x = coordinates_x[i].regamma_y_blue;
1629 } else
1630 hw_x = coordinates_x[i].x;
1631
1632 if (dc_fixpt_le(one, hw_x))
1633 hw_x = one;
1634
1635 norm_x = dc_fixpt_mul(norm_factor, hw_x);
1636 index = dc_fixpt_floor(norm_x);
1637 if (index < 0 || index > 255)
1638 continue;
1639
1640 index_f = dc_fixpt_from_int(index);
1641 index_next = (index == 255) ? index : index + 1;
1642
1643 if (color == 0) {
1644 lut1 = rgb_user[index].r;
1645 lut2 = rgb_user[index_next].r;
1646 } else if (color == 1) {
1647 lut1 = rgb_user[index].g;
1648 lut2 = rgb_user[index_next].g;
1649 } else {
1650 lut1 = rgb_user[index].b;
1651 lut2 = rgb_user[index_next].b;
1652 }
1653
1654 // we have everything now, so interpolate
1655 delta_lut = dc_fixpt_sub(lut2, lut1);
1656 delta_index = dc_fixpt_sub(norm_x, index_f);
1657
1658 *tf_point = dc_fixpt_add(lut1,
1659 dc_fixpt_mul(delta_index, delta_lut));
1660 }
1661 ++i;
1662 }
1663}
1664
1665static void build_new_custom_resulted_curve(
1666 uint32_t hw_points_num,
1667 struct dc_transfer_func_distributed_points *tf_pts)
1668{
1669 uint32_t i = 0;
1670
1671 while (i != hw_points_num + 1) {
1672 tf_pts->red[i] = dc_fixpt_clamp(
1673 tf_pts->red[i], dc_fixpt_zero,
1674 dc_fixpt_one);
1675 tf_pts->green[i] = dc_fixpt_clamp(
1676 tf_pts->green[i], dc_fixpt_zero,
1677 dc_fixpt_one);
1678 tf_pts->blue[i] = dc_fixpt_clamp(
1679 tf_pts->blue[i], dc_fixpt_zero,
1680 dc_fixpt_one);
1681
1682 ++i;
1683 }
1684}
1685
1686static void apply_degamma_for_user_regamma(struct pwl_float_data_ex *rgb_regamma,
1687 uint32_t hw_points_num, struct calculate_buffer *cal_buffer)
1688{
1689 uint32_t i;
1690
1691 struct gamma_coefficients coeff;
1692 struct pwl_float_data_ex *rgb = rgb_regamma;
1693 const struct hw_x_point *coord_x = coordinates_x;
1694
1695 build_coefficients(&coeff, TRANSFER_FUNCTION_SRGB);
1696
1697 i = 0;
1698 while (i != hw_points_num + 1) {
1699 rgb->r = translate_from_linear_space_ex(
1700 coord_x->x, &coeff, 0, cal_buffer);
1701 rgb->g = rgb->r;
1702 rgb->b = rgb->r;
1703 ++coord_x;
1704 ++rgb;
1705 ++i;
1706 }
1707}
1708
1709static bool_Bool map_regamma_hw_to_x_user(
1710 const struct dc_gamma *ramp,
1711 struct pixel_gamma_point *coeff128,
1712 struct pwl_float_data *rgb_user,
1713 struct hw_x_point *coords_x,
1714 const struct gamma_pixel *axis_x,
1715 const struct pwl_float_data_ex *rgb_regamma,
1716 uint32_t hw_points_num,
1717 struct dc_transfer_func_distributed_points *tf_pts,
1718 bool_Bool mapUserRamp,
1719 bool_Bool doClamping)
1720{
1721 /* setup to spare calculated ideal regamma values */
1722
1723 int i = 0;
1724 struct hw_x_point *coords = coords_x;
1725 const struct pwl_float_data_ex *regamma = rgb_regamma;
1726
1727 if (ramp && mapUserRamp) {
1728 copy_rgb_regamma_to_coordinates_x(coords,
1729 hw_points_num,
1730 rgb_regamma);
1731
1732 calculate_interpolated_hardware_curve(
1733 ramp, coeff128, rgb_user, coords, axis_x,
1734 hw_points_num, tf_pts);
1735 } else {
1736 /* just copy current rgb_regamma into tf_pts */
1737 while (i <= hw_points_num) {
1738 tf_pts->red[i] = regamma->r;
1739 tf_pts->green[i] = regamma->g;
1740 tf_pts->blue[i] = regamma->b;
1741
1742 ++regamma;
1743 ++i;
1744 }
1745 }
1746
1747 if (doClamping) {
1748 /* this should be named differently, all it does is clamp to 0-1 */
1749 build_new_custom_resulted_curve(hw_points_num, tf_pts);
1750 }
1751
1752 return true1;
1753}
1754
1755#define _EXTRA_POINTS3 3
1756
1757bool_Bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf,
1758 const struct regamma_lut *regamma,
1759 struct calculate_buffer *cal_buffer,
1760 const struct dc_gamma *ramp)
1761{
1762 struct gamma_coefficients coeff;
1763 const struct hw_x_point *coord_x = coordinates_x;
1764 uint32_t i = 0;
1765
1766 do {
1767 coeff.a0[i] = dc_fixpt_from_fraction(
1768 regamma->coeff.A0[i], 10000000);
1769 coeff.a1[i] = dc_fixpt_from_fraction(
1770 regamma->coeff.A1[i], 1000);
1771 coeff.a2[i] = dc_fixpt_from_fraction(
1772 regamma->coeff.A2[i], 1000);
1773 coeff.a3[i] = dc_fixpt_from_fraction(
1774 regamma->coeff.A3[i], 1000);
1775 coeff.user_gamma[i] = dc_fixpt_from_fraction(
1776 regamma->coeff.gamma[i], 1000);
1777
1778 ++i;
1779 } while (i != 3);
1780
1781 i = 0;
1782 /* fixed_pt library has problems handling too small values */
1783 while (i != 32) {
1784 output_tf->tf_pts.red[i] = dc_fixpt_zero;
1785 output_tf->tf_pts.green[i] = dc_fixpt_zero;
1786 output_tf->tf_pts.blue[i] = dc_fixpt_zero;
1787 ++coord_x;
1788 ++i;
1789 }
1790 while (i != MAX_HW_POINTS(16*32) + 1) {
1791 output_tf->tf_pts.red[i] = translate_from_linear_space_ex(
1792 coord_x->x, &coeff, 0, cal_buffer);
1793 output_tf->tf_pts.green[i] = translate_from_linear_space_ex(
1794 coord_x->x, &coeff, 1, cal_buffer);
1795 output_tf->tf_pts.blue[i] = translate_from_linear_space_ex(
1796 coord_x->x, &coeff, 2, cal_buffer);
1797 ++coord_x;
1798 ++i;
1799 }
1800
1801 if (ramp && ramp->type == GAMMA_CS_TFM_1D)
1802 apply_lut_1d(ramp, MAX_HW_POINTS(16*32), &output_tf->tf_pts);
1803
1804 // this function just clamps output to 0-1
1805 build_new_custom_resulted_curve(MAX_HW_POINTS(16*32), &output_tf->tf_pts);
1806 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
1807
1808 return true1;
1809}
1810
1811bool_Bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf,
1812 const struct regamma_lut *regamma,
1813 struct calculate_buffer *cal_buffer,
1814 const struct dc_gamma *ramp)
1815{
1816 struct dc_transfer_func_distributed_points *tf_pts = &output_tf->tf_pts;
1817 struct dividers dividers;
1818
1819 struct pwl_float_data *rgb_user = NULL((void *)0);
1820 struct pwl_float_data_ex *rgb_regamma = NULL((void *)0);
1821 bool_Bool ret = false0;
1822
1823 if (regamma == NULL((void *)0))
1824 return false0;
1825
1826 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
1827
1828 rgb_user = kcalloc(GAMMA_RGB_256_ENTRIES + _EXTRA_POINTS3,
1829 sizeof(*rgb_user),
1830 GFP_KERNEL(0x0001 | 0x0004));
1831 if (!rgb_user)
1832 goto rgb_user_alloc_fail;
1833
1834 rgb_regamma = kcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3,
1835 sizeof(*rgb_regamma),
1836 GFP_KERNEL(0x0001 | 0x0004));
1837 if (!rgb_regamma)
1838 goto rgb_regamma_alloc_fail;
1839
1840 dividers.divider1 = dc_fixpt_from_fraction(3, 2);
1841 dividers.divider2 = dc_fixpt_from_int(2);
1842 dividers.divider3 = dc_fixpt_from_fraction(5, 2);
1843
1844 scale_user_regamma_ramp(rgb_user, &regamma->ramp, dividers);
1845
1846 if (regamma->flags.bits.applyDegamma == 1) {
1847 apply_degamma_for_user_regamma(rgb_regamma, MAX_HW_POINTS(16*32), cal_buffer);
1848 copy_rgb_regamma_to_coordinates_x(coordinates_x,
1849 MAX_HW_POINTS(16*32), rgb_regamma);
1850 }
1851
1852 interpolate_user_regamma(MAX_HW_POINTS(16*32), rgb_user,
1853 regamma->flags.bits.applyDegamma, tf_pts);
1854
1855 // no custom HDR curves!
1856 tf_pts->end_exponent = 0;
1857 tf_pts->x_point_at_y1_red = 1;
1858 tf_pts->x_point_at_y1_green = 1;
1859 tf_pts->x_point_at_y1_blue = 1;
1860
1861 if (ramp && ramp->type == GAMMA_CS_TFM_1D)
1862 apply_lut_1d(ramp, MAX_HW_POINTS(16*32), &output_tf->tf_pts);
1863
1864 // this function just clamps output to 0-1
1865 build_new_custom_resulted_curve(MAX_HW_POINTS(16*32), tf_pts);
1866
1867 ret = true1;
1868
1869 kfree(rgb_regamma);
1870rgb_regamma_alloc_fail:
1871 kfree(rgb_user);
1872rgb_user_alloc_fail:
1873 return ret;
1874}
1875
1876bool_Bool mod_color_calculate_degamma_params(struct dc_color_caps *dc_caps,
1877 struct dc_transfer_func *input_tf,
1878 const struct dc_gamma *ramp, bool_Bool mapUserRamp)
1879{
1880 struct dc_transfer_func_distributed_points *tf_pts = &input_tf->tf_pts;
1881 struct dividers dividers;
1882 struct pwl_float_data *rgb_user = NULL((void *)0);
1883 struct pwl_float_data_ex *curve = NULL((void *)0);
1884 struct gamma_pixel *axis_x = NULL((void *)0);
1885 struct pixel_gamma_point *coeff = NULL((void *)0);
1886 enum dc_transfer_func_predefined tf = TRANSFER_FUNCTION_SRGB;
1887 uint32_t i;
1888 bool_Bool ret = false0;
1889
1890 if (input_tf->type == TF_TYPE_BYPASS)
1891 return false0;
1892
1893 /* we can use hardcoded curve for plain SRGB TF
1894 * If linear, it's bypass if on user ramp
1895 */
1896 if (input_tf->type == TF_TYPE_PREDEFINED) {
1897 if ((input_tf->tf == TRANSFER_FUNCTION_SRGB ||
1898 input_tf->tf == TRANSFER_FUNCTION_LINEAR) &&
1899 !mapUserRamp)
1900 return true1;
1901
1902 if (dc_caps != NULL((void *)0) &&
1903 dc_caps->dpp.dcn_arch == 1) {
1904
1905 if (input_tf->tf == TRANSFER_FUNCTION_PQ &&
1906 dc_caps->dpp.dgam_rom_caps.pq == 1)
1907 return true1;
1908
1909 if (input_tf->tf == TRANSFER_FUNCTION_GAMMA22 &&
1910 dc_caps->dpp.dgam_rom_caps.gamma2_2 == 1)
1911 return true1;
1912
1913 // HLG OOTF not accounted for
1914 if (input_tf->tf == TRANSFER_FUNCTION_HLG &&
1915 dc_caps->dpp.dgam_rom_caps.hlg == 1)
1916 return true1;
1917 }
1918 }
1919
1920 input_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
1921
1922 if (mapUserRamp && ramp && ramp->type == GAMMA_RGB_256) {
1923 rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS3,
1924 sizeof(*rgb_user),
1925 GFP_KERNEL(0x0001 | 0x0004));
1926 if (!rgb_user)
1927 goto rgb_user_alloc_fail;
1928
1929 axis_x = kvcalloc(ramp->num_entries + _EXTRA_POINTS3, sizeof(*axis_x),
1930 GFP_KERNEL(0x0001 | 0x0004));
1931 if (!axis_x)
1932 goto axis_x_alloc_fail;
1933
1934 dividers.divider1 = dc_fixpt_from_fraction(3, 2);
1935 dividers.divider2 = dc_fixpt_from_int(2);
1936 dividers.divider3 = dc_fixpt_from_fraction(5, 2);
1937
1938 build_evenly_distributed_points(
1939 axis_x,
1940 ramp->num_entries,
1941 dividers);
1942
1943 scale_gamma(rgb_user, ramp, dividers);
1944 }
1945
1946 curve = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3, sizeof(*curve),
1947 GFP_KERNEL(0x0001 | 0x0004));
1948 if (!curve)
1949 goto curve_alloc_fail;
1950
1951 coeff = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3, sizeof(*coeff),
1952 GFP_KERNEL(0x0001 | 0x0004));
1953 if (!coeff)
1954 goto coeff_alloc_fail;
1955
1956 tf = input_tf->tf;
1957
1958 if (tf == TRANSFER_FUNCTION_PQ)
1959 build_de_pq(curve,
1960 MAX_HW_POINTS(16*32),
1961 coordinates_x);
1962 else if (tf == TRANSFER_FUNCTION_SRGB ||
1963 tf == TRANSFER_FUNCTION_BT709 ||
1964 tf == TRANSFER_FUNCTION_GAMMA22 ||
1965 tf == TRANSFER_FUNCTION_GAMMA24 ||
1966 tf == TRANSFER_FUNCTION_GAMMA26)
1967 build_degamma(curve,
1968 MAX_HW_POINTS(16*32),
1969 coordinates_x,
1970 tf);
1971 else if (tf == TRANSFER_FUNCTION_HLG)
1972 build_hlg_degamma(curve,
1973 MAX_HW_POINTS(16*32),
1974 coordinates_x,
1975 80, 1000);
1976 else if (tf == TRANSFER_FUNCTION_LINEAR) {
1977 // just copy coordinates_x into curve
1978 i = 0;
1979 while (i != MAX_HW_POINTS(16*32) + 1) {
1980 curve[i].r = coordinates_x[i].x;
1981 curve[i].g = curve[i].r;
1982 curve[i].b = curve[i].r;
1983 i++;
1984 }
1985 } else
1986 goto invalid_tf_fail;
1987
1988 tf_pts->end_exponent = 0;
1989 tf_pts->x_point_at_y1_red = 1;
1990 tf_pts->x_point_at_y1_green = 1;
1991 tf_pts->x_point_at_y1_blue = 1;
1992
1993 if (input_tf->tf == TRANSFER_FUNCTION_PQ) {
1994 /* just copy current rgb_regamma into tf_pts */
1995 struct pwl_float_data_ex *curvePt = curve;
1996 int i = 0;
1997
1998 while (i <= MAX_HW_POINTS(16*32)) {
1999 tf_pts->red[i] = curvePt->r;
2000 tf_pts->green[i] = curvePt->g;
2001 tf_pts->blue[i] = curvePt->b;
2002 ++curvePt;
2003 ++i;
2004 }
2005 } else {
2006 // clamps to 0-1
2007 map_regamma_hw_to_x_user(ramp, coeff, rgb_user,
2008 coordinates_x, axis_x, curve,
2009 MAX_HW_POINTS(16*32), tf_pts,
2010 mapUserRamp && ramp && ramp->type == GAMMA_RGB_256,
2011 true1);
2012 }
2013
2014
2015
2016 if (ramp && ramp->type == GAMMA_CUSTOM)
2017 apply_lut_1d(ramp, MAX_HW_POINTS(16*32), tf_pts);
2018
2019 ret = true1;
2020
2021invalid_tf_fail:
2022 kvfree(coeff);
2023coeff_alloc_fail:
2024 kvfree(curve);
2025curve_alloc_fail:
2026 kvfree(axis_x);
2027axis_x_alloc_fail:
2028 kvfree(rgb_user);
2029rgb_user_alloc_fail:
2030
2031 return ret;
2032}
2033
2034static bool_Bool calculate_curve(enum dc_transfer_func_predefined trans,
2035 struct dc_transfer_func_distributed_points *points,
2036 struct pwl_float_data_ex *rgb_regamma,
2037 const struct hdr_tm_params *fs_params,
2038 uint32_t sdr_ref_white_level,
2039 struct calculate_buffer *cal_buffer)
2040{
2041 uint32_t i;
2042 bool_Bool ret = false0;
2043
2044 if (trans == TRANSFER_FUNCTION_UNITY ||
9
←
Assuming 'trans' is not equal to TRANSFER_FUNCTION_UNITY
→
11
←
Taking false branch
→
2045 trans == TRANSFER_FUNCTION_LINEAR) {
10
←
Assuming 'trans' is not equal to TRANSFER_FUNCTION_LINEAR
→
2046 points->end_exponent = 0;
2047 points->x_point_at_y1_red = 1;
2048 points->x_point_at_y1_green = 1;
2049 points->x_point_at_y1_blue = 1;
2050
2051 for (i = 0; i <= MAX_HW_POINTS(16*32) ; i++) {
2052 rgb_regamma[i].r = coordinates_x[i].x;
2053 rgb_regamma[i].g = coordinates_x[i].x;
2054 rgb_regamma[i].b = coordinates_x[i].x;
2055 }
2056
2057 ret = true1;
2058 } else if (trans == TRANSFER_FUNCTION_PQ) {
12
←
Assuming 'trans' is not equal to TRANSFER_FUNCTION_PQ
→
2059 points->end_exponent = 7;
2060 points->x_point_at_y1_red = 125;
2061 points->x_point_at_y1_green = 125;
2062 points->x_point_at_y1_blue = 125;
2063
2064 build_pq(rgb_regamma,
2065 MAX_HW_POINTS(16*32),
2066 coordinates_x,
2067 sdr_ref_white_level);
2068
2069 ret = true1;
2070 } else if (trans == TRANSFER_FUNCTION_GAMMA22 &&
13
←
Assuming 'trans' is equal to TRANSFER_FUNCTION_GAMMA22
→
16
←
Taking true branch
→
2071 fs_params != NULL((void *)0) && fs_params->skip_tm == 0) {
14
←
Assuming 'fs_params' is not equal to NULL
→
15
←
Assuming field 'skip_tm' is equal to 0
→
2072 build_freesync_hdr(rgb_regamma,
17
←
Calling 'build_freesync_hdr'
→
2073 MAX_HW_POINTS(16*32),
2074 coordinates_x,
2075 fs_params,
2076 cal_buffer);
2077
2078 ret = true1;
2079 } else if (trans == TRANSFER_FUNCTION_HLG) {
2080 points->end_exponent = 4;
2081 points->x_point_at_y1_red = 12;
2082 points->x_point_at_y1_green = 12;
2083 points->x_point_at_y1_blue = 12;
2084
2085 build_hlg_regamma(rgb_regamma,
2086 MAX_HW_POINTS(16*32),
2087 coordinates_x,
2088 80, 1000);
2089
2090 ret = true1;
2091 } else {
2092 // trans == TRANSFER_FUNCTION_SRGB
2093 // trans == TRANSFER_FUNCTION_BT709
2094 // trans == TRANSFER_FUNCTION_GAMMA22
2095 // trans == TRANSFER_FUNCTION_GAMMA24
2096 // trans == TRANSFER_FUNCTION_GAMMA26
2097 points->end_exponent = 0;
2098 points->x_point_at_y1_red = 1;
2099 points->x_point_at_y1_green = 1;
2100 points->x_point_at_y1_blue = 1;
2101
2102 build_regamma(rgb_regamma,
2103 MAX_HW_POINTS(16*32),
2104 coordinates_x,
2105 trans,
2106 cal_buffer);
2107
2108 ret = true1;
2109 }
2110
2111 return ret;
2112}
2113
2114bool_Bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf,
2115 const struct dc_gamma *ramp, bool_Bool mapUserRamp, bool_Bool canRomBeUsed,
2116 const struct hdr_tm_params *fs_params,
2117 struct calculate_buffer *cal_buffer)
2118{
2119 struct dc_transfer_func_distributed_points *tf_pts = &output_tf->tf_pts;
2120 struct dividers dividers;
2121
2122 struct pwl_float_data *rgb_user = NULL((void *)0);
2123 struct pwl_float_data_ex *rgb_regamma = NULL((void *)0);
2124 struct gamma_pixel *axis_x = NULL((void *)0);
2125 struct pixel_gamma_point *coeff = NULL((void *)0);
2126 enum dc_transfer_func_predefined tf = TRANSFER_FUNCTION_SRGB;
2127 bool_Bool doClamping = true1;
2128 bool_Bool ret = false0;
2129
2130 if (output_tf->type == TF_TYPE_BYPASS)
1
Assuming field 'type' is not equal to TF_TYPE_BYPASS
→
2131 return false0;
2132
2133 /* we can use hardcoded curve for plain SRGB TF */
2134 if (output_tf->type == TF_TYPE_PREDEFINED && canRomBeUsed == true1 &&
2
←
Assuming field 'type' is not equal to TF_TYPE_PREDEFINED
→
2135 output_tf->tf == TRANSFER_FUNCTION_SRGB) {
2136 if (ramp == NULL((void *)0))
2137 return true1;
2138 if ((ramp->is_identity && ramp->type != GAMMA_CS_TFM_1D) ||
2139 (!mapUserRamp && ramp->type == GAMMA_RGB_256))
2140 return true1;
2141 }
2142
2143 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS;
2144
2145 if (ramp && ramp->type != GAMMA_CS_TFM_1D &&
3
←
Assuming 'ramp' is null
→
2146 (mapUserRamp || ramp->type != GAMMA_RGB_256)) {
2147 rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS3,
2148 sizeof(*rgb_user),
2149 GFP_KERNEL(0x0001 | 0x0004));
2150 if (!rgb_user)
2151 goto rgb_user_alloc_fail;
2152
2153 axis_x = kvcalloc(ramp->num_entries + 3, sizeof(*axis_x),
2154 GFP_KERNEL(0x0001 | 0x0004));
2155 if (!axis_x)
2156 goto axis_x_alloc_fail;
2157
2158 dividers.divider1 = dc_fixpt_from_fraction(3, 2);
2159 dividers.divider2 = dc_fixpt_from_int(2);
2160 dividers.divider3 = dc_fixpt_from_fraction(5, 2);
2161
2162 build_evenly_distributed_points(
2163 axis_x,
2164 ramp->num_entries,
2165 dividers);
2166
2167 if (ramp->type == GAMMA_RGB_256 && mapUserRamp)
2168 scale_gamma(rgb_user, ramp, dividers);
2169 else if (ramp->type == GAMMA_RGB_FLOAT_1024)
2170 scale_gamma_dx(rgb_user, ramp, dividers);
2171 }
2172
2173 rgb_regamma = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3,
2174 sizeof(*rgb_regamma),
2175 GFP_KERNEL(0x0001 | 0x0004));
2176 if (!rgb_regamma)
4
←
Assuming 'rgb_regamma' is non-null
→
5
←
Taking false branch
→
2177 goto rgb_regamma_alloc_fail;
2178
2179 coeff = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3, sizeof(*coeff),
2180 GFP_KERNEL(0x0001 | 0x0004));
2181 if (!coeff)
6
←
Assuming 'coeff' is non-null
→
7
←
Taking false branch
→
2182 goto coeff_alloc_fail;
2183
2184 tf = output_tf->tf;
2185
2186 ret = calculate_curve(tf,
8
←
Calling 'calculate_curve'
→
2187 tf_pts,
2188 rgb_regamma,
2189 fs_params,
2190 output_tf->sdr_ref_white_level,
2191 cal_buffer);
2192
2193 if (ret) {
2194 doClamping = !(output_tf->tf == TRANSFER_FUNCTION_GAMMA22 &&
2195 fs_params != NULL((void *)0) && fs_params->skip_tm == 0);
2196
2197 map_regamma_hw_to_x_user(ramp, coeff, rgb_user,
2198 coordinates_x, axis_x, rgb_regamma,
2199 MAX_HW_POINTS(16*32), tf_pts,
2200 (mapUserRamp || (ramp && ramp->type != GAMMA_RGB_256)) &&
2201 (ramp && ramp->type != GAMMA_CS_TFM_1D),
2202 doClamping);
2203
2204 if (ramp && ramp->type == GAMMA_CS_TFM_1D)
2205 apply_lut_1d(ramp, MAX_HW_POINTS(16*32), tf_pts);
2206 }
2207
2208 kvfree(coeff);
2209coeff_alloc_fail:
2210 kvfree(rgb_regamma);
2211rgb_regamma_alloc_fail:
2212 kvfree(axis_x);
2213axis_x_alloc_fail:
2214 kvfree(rgb_user);
2215rgb_user_alloc_fail:
2216 return ret;
2217}
2218
2219bool_Bool mod_color_calculate_degamma_curve(enum dc_transfer_func_predefined trans,
2220 struct dc_transfer_func_distributed_points *points)
2221{
2222 uint32_t i;
2223 bool_Bool ret = false0;
2224 struct pwl_float_data_ex *rgb_degamma = NULL((void *)0);
2225
2226 if (trans == TRANSFER_FUNCTION_UNITY ||
2227 trans == TRANSFER_FUNCTION_LINEAR) {
2228
2229 for (i = 0; i <= MAX_HW_POINTS(16*32) ; i++) {
2230 points->red[i] = coordinates_x[i].x;
2231 points->green[i] = coordinates_x[i].x;
2232 points->blue[i] = coordinates_x[i].x;
2233 }
2234 ret = true1;
2235 } else if (trans == TRANSFER_FUNCTION_PQ) {
2236 rgb_degamma = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3,
2237 sizeof(*rgb_degamma),
2238 GFP_KERNEL(0x0001 | 0x0004));
2239 if (!rgb_degamma)
2240 goto rgb_degamma_alloc_fail;
2241
2242
2243 build_de_pq(rgb_degamma,
2244 MAX_HW_POINTS(16*32),
2245 coordinates_x);
2246 for (i = 0; i <= MAX_HW_POINTS(16*32) ; i++) {
2247 points->red[i] = rgb_degamma[i].r;
2248 points->green[i] = rgb_degamma[i].g;
2249 points->blue[i] = rgb_degamma[i].b;
2250 }
2251 ret = true1;
2252
2253 kvfree(rgb_degamma);
2254 } else if (trans == TRANSFER_FUNCTION_SRGB ||
2255 trans == TRANSFER_FUNCTION_BT709 ||
2256 trans == TRANSFER_FUNCTION_GAMMA22 ||
2257 trans == TRANSFER_FUNCTION_GAMMA24 ||
2258 trans == TRANSFER_FUNCTION_GAMMA26) {
2259 rgb_degamma = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3,
2260 sizeof(*rgb_degamma),
2261 GFP_KERNEL(0x0001 | 0x0004));
2262 if (!rgb_degamma)
2263 goto rgb_degamma_alloc_fail;
2264
2265 build_degamma(rgb_degamma,
2266 MAX_HW_POINTS(16*32),
2267 coordinates_x,
2268 trans);
2269 for (i = 0; i <= MAX_HW_POINTS(16*32) ; i++) {
2270 points->red[i] = rgb_degamma[i].r;
2271 points->green[i] = rgb_degamma[i].g;
2272 points->blue[i] = rgb_degamma[i].b;
2273 }
2274 ret = true1;
2275
2276 kvfree(rgb_degamma);
2277 } else if (trans == TRANSFER_FUNCTION_HLG) {
2278 rgb_degamma = kvcalloc(MAX_HW_POINTS(16*32) + _EXTRA_POINTS3,
2279 sizeof(*rgb_degamma),
2280 GFP_KERNEL(0x0001 | 0x0004));
2281 if (!rgb_degamma)
2282 goto rgb_degamma_alloc_fail;
2283
2284 build_hlg_degamma(rgb_degamma,
2285 MAX_HW_POINTS(16*32),
2286 coordinates_x,
2287 80, 1000);
2288 for (i = 0; i <= MAX_HW_POINTS(16*32) ; i++) {
2289 points->red[i] = rgb_degamma[i].r;
2290 points->green[i] = rgb_degamma[i].g;
2291 points->blue[i] = rgb_degamma[i].b;
2292 }
2293 ret = true1;
2294 kvfree(rgb_degamma);
2295 }
2296 points->end_exponent = 0;
2297 points->x_point_at_y1_red = 1;
2298 points->x_point_at_y1_green = 1;
2299 points->x_point_at_y1_blue = 1;
2300
2301rgb_degamma_alloc_fail:
2302 return ret;
2303}
←

/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h

1/*
2 * Copyright 2012-15 Advanced Micro Devices, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included in
12 * all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 *
22 * Authors: AMD
23 *
24 */
25
26#ifndef __DAL_FIXED31_32_H__
27#define __DAL_FIXED31_32_H__
28
29#ifndef LLONG_MAX0x7fffffffffffffffLL
30#define LLONG_MAX0x7fffffffffffffffLL 9223372036854775807ll
31#endif
32#ifndef LLONG_MIN(-0x7fffffffffffffffLL-1)
33#define LLONG_MIN(-0x7fffffffffffffffLL-1) (-LLONG_MAX0x7fffffffffffffffLL - 1ll)
34#endif
35
36#define FIXED31_32_BITS_PER_FRACTIONAL_PART32 32
37#ifndef LLONG_MIN(-0x7fffffffffffffffLL-1)
38#define LLONG_MIN(-0x7fffffffffffffffLL-1) (1LL<<63)
39#endif
40#ifndef LLONG_MAX0x7fffffffffffffffLL
41#define LLONG_MAX0x7fffffffffffffffLL (-1LL>>1)
42#endif
43
44/*
45 * @brief
46 * Arithmetic operations on real numbers
47 * represented as fixed-point numbers.
48 * There are: 1 bit for sign,
49 * 31 bit for integer part,
50 * 32 bits for fractional part.
51 *
52 * @note
53 * Currently, overflows and underflows are asserted;
54 * no special result returned.
55 */
56
57struct fixed31_32 {
58 long long value;
59};
60
61
62/*
63 * @brief
64 * Useful constants
65 */
66
67static const struct fixed31_32 dc_fixpt_zero = { 0 };
68static const struct fixed31_32 dc_fixpt_epsilon = { 1LL };
69static const struct fixed31_32 dc_fixpt_half = { 0x80000000LL };
70static const struct fixed31_32 dc_fixpt_one = { 0x100000000LL };
71
72/*
73 * @brief
74 * Initialization routines
75 */
76
77/*
78 * @brief
79 * result = numerator / denominator
80 */
81struct fixed31_32 dc_fixpt_from_fraction(long long numerator, long long denominator);
82
83/*
84 * @brief
85 * result = arg
86 */
87static inline struct fixed31_32 dc_fixpt_from_int(int arg)
88{
89 struct fixed31_32 res;
90
91 res.value = (long long) arg << FIXED31_32_BITS_PER_FRACTIONAL_PART32;
92
93 return res;
94}
95
96/*
97 * @brief
98 * Unary operators
99 */
100
101/*
102 * @brief
103 * result = -arg
104 */
105static inline struct fixed31_32 dc_fixpt_neg(struct fixed31_32 arg)
106{
107 struct fixed31_32 res;
108
109 res.value = -arg.value;
110
111 return res;
112}
113
114/*
115 * @brief
116 * result = abs(arg) := (arg >= 0) ? arg : -arg
117 */
118static inline struct fixed31_32 dc_fixpt_abs(struct fixed31_32 arg)
119{
120 if (arg.value < 0)
121 return dc_fixpt_neg(arg);
122 else
123 return arg;
124}
125
126/*
127 * @brief
128 * Binary relational operators
129 */
130
131/*
132 * @brief
133 * result = arg1 < arg2
134 */
135static inline bool_Bool dc_fixpt_lt(struct fixed31_32 arg1, struct fixed31_32 arg2)
136{
137 return arg1.value < arg2.value;
138}
139
140/*
141 * @brief
142 * result = arg1 <= arg2
143 */
144static inline bool_Bool dc_fixpt_le(struct fixed31_32 arg1, struct fixed31_32 arg2)
145{
146 return arg1.value <= arg2.value;
147}
148
149/*
150 * @brief
151 * result = arg1 == arg2
152 */
153static inline bool_Bool dc_fixpt_eq(struct fixed31_32 arg1, struct fixed31_32 arg2)
154{
155 return arg1.value == arg2.value;
156}
157
158/*
159 * @brief
160 * result = min(arg1, arg2) := (arg1 <= arg2) ? arg1 : arg2
161 */
162static inline struct fixed31_32 dc_fixpt_min(struct fixed31_32 arg1, struct fixed31_32 arg2)
163{
164 if (arg1.value <= arg2.value)
165 return arg1;
166 else
167 return arg2;
168}
169
170/*
171 * @brief
172 * result = max(arg1, arg2) := (arg1 <= arg2) ? arg2 : arg1
173 */
174static inline struct fixed31_32 dc_fixpt_max(struct fixed31_32 arg1, struct fixed31_32 arg2)
175{
176 if (arg1.value <= arg2.value)
177 return arg2;
178 else
179 return arg1;
180}
181
182/*
183 * @brief
184 * | min_value, when arg <= min_value
185 * result = | arg, when min_value < arg < max_value
186 * | max_value, when arg >= max_value
187 */
188static inline struct fixed31_32 dc_fixpt_clamp(
189 struct fixed31_32 arg,
190 struct fixed31_32 min_value,
191 struct fixed31_32 max_value)
192{
193 if (dc_fixpt_le(arg, min_value))
194 return min_value;
195 else if (dc_fixpt_le(max_value, arg))
196 return max_value;
197 else
198 return arg;
199}
200
201/*
202 * @brief
203 * Binary shift operators
204 */
205
206/*
207 * @brief
208 * result = arg << shift
209 */
210static inline struct fixed31_32 dc_fixpt_shl(struct fixed31_32 arg, unsigned char shift)
211{
212 ASSERT(((arg.value >= 0) && (arg.value <= LLONG_MAX >> shift)) ||do { if (({ static int __warned; int __ret = !!(!(((arg.value
>= 0) && (arg.value <= 0x7fffffffffffffffLL >>
shift)) || ((arg.value < 0) && (arg.value >= ~
(0x7fffffffffffffffLL >> shift))))); if (__ret &&
!__warned) { printf("WARNING %s failed at %s:%d\n", "!(((arg.value >= 0) && (arg.value <= 0x7fffffffffffffffLL >> shift)) || ((arg.value < 0) && (arg.value >= ~(0x7fffffffffffffffLL >> shift))))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 213); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0)
213 ((arg.value < 0) && (arg.value >= ~(LLONG_MAX >> shift))))do { if (({ static int __warned; int __ret = !!(!(((arg.value
>= 0) && (arg.value <= 0x7fffffffffffffffLL >>
shift)) || ((arg.value < 0) && (arg.value >= ~
(0x7fffffffffffffffLL >> shift))))); if (__ret &&
!__warned) { printf("WARNING %s failed at %s:%d\n", "!(((arg.value >= 0) && (arg.value <= 0x7fffffffffffffffLL >> shift)) || ((arg.value < 0) && (arg.value >= ~(0x7fffffffffffffffLL >> shift))))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 213); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
214
215 arg.value = arg.value << shift;
216
217 return arg;
218}
219
220/*
221 * @brief
222 * result = arg >> shift
223 */
224static inline struct fixed31_32 dc_fixpt_shr(struct fixed31_32 arg, unsigned char shift)
225{
226 bool_Bool negative = arg.value < 0;
227
228 if (negative)
229 arg.value = -arg.value;
230 arg.value = arg.value >> shift;
231 if (negative)
232 arg.value = -arg.value;
233 return arg;
234}
235
236/*
237 * @brief
238 * Binary additive operators
239 */
240
241/*
242 * @brief
243 * result = arg1 + arg2
244 */
245static inline struct fixed31_32 dc_fixpt_add(struct fixed31_32 arg1, struct fixed31_32 arg2)
246{
247 struct fixed31_32 res;
248
249 ASSERT(((arg1.value >= 0) && (LLONG_MAX - arg1.value >= arg2.value)) ||do { if (({ static int __warned; int __ret = !!(!(((arg1.value
>= 0) && (0x7fffffffffffffffLL - arg1.value >=
arg2.value)) || ((arg1.value < 0) && ((-0x7fffffffffffffffLL
-1) - arg1.value <= arg2.value)))); if (__ret && !
__warned) { printf("WARNING %s failed at %s:%d\n", "!(((arg1.value >= 0) && (0x7fffffffffffffffLL - arg1.value >= arg2.value)) || ((arg1.value < 0) && ((-0x7fffffffffffffffLL-1) - arg1.value <= arg2.value)))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 250); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0)
250 ((arg1.value < 0) && (LLONG_MIN - arg1.value <= arg2.value)))do { if (({ static int __warned; int __ret = !!(!(((arg1.value
>= 0) && (0x7fffffffffffffffLL - arg1.value >=
arg2.value)) || ((arg1.value < 0) && ((-0x7fffffffffffffffLL
-1) - arg1.value <= arg2.value)))); if (__ret && !
__warned) { printf("WARNING %s failed at %s:%d\n", "!(((arg1.value >= 0) && (0x7fffffffffffffffLL - arg1.value >= arg2.value)) || ((arg1.value < 0) && ((-0x7fffffffffffffffLL-1) - arg1.value <= arg2.value)))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 250); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
251
252 res.value = arg1.value + arg2.value;
253
254 return res;
255}
256
257/*
258 * @brief
259 * result = arg1 + arg2
260 */
261static inline struct fixed31_32 dc_fixpt_add_int(struct fixed31_32 arg1, int arg2)
262{
263 return dc_fixpt_add(arg1, dc_fixpt_from_int(arg2));
264}
265
266/*
267 * @brief
268 * result = arg1 - arg2
269 */
270static inline struct fixed31_32 dc_fixpt_sub(struct fixed31_32 arg1, struct fixed31_32 arg2)
271{
272 struct fixed31_32 res;
273
274 ASSERT(((arg2.value >= 0) && (LLONG_MIN + arg2.value <= arg1.value)) ||do { if (({ static int __warned; int __ret = !!(!(((arg2.value
>= 0) && ((-0x7fffffffffffffffLL-1) + arg2.value <=
arg1.value)) || ((arg2.value < 0) && (0x7fffffffffffffffLL
+ arg2.value >= arg1.value)))); if (__ret && !__warned
) { printf("WARNING %s failed at %s:%d\n", "!(((arg2.value >= 0) && ((-0x7fffffffffffffffLL-1) + arg2.value <= arg1.value)) || ((arg2.value < 0) && (0x7fffffffffffffffLL + arg2.value >= arg1.value)))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 275); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0)
34
←
The left operand of '>=' is a garbage value
275 ((arg2.value < 0) && (LLONG_MAX + arg2.value >= arg1.value)))do { if (({ static int __warned; int __ret = !!(!(((arg2.value
>= 0) && ((-0x7fffffffffffffffLL-1) + arg2.value <=
arg1.value)) || ((arg2.value < 0) && (0x7fffffffffffffffLL
+ arg2.value >= arg1.value)))); if (__ret && !__warned
) { printf("WARNING %s failed at %s:%d\n", "!(((arg2.value >= 0) && ((-0x7fffffffffffffffLL-1) + arg2.value <= arg1.value)) || ((arg2.value < 0) && (0x7fffffffffffffffLL + arg2.value >= arg1.value)))"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 275); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
276
277 res.value = arg1.value - arg2.value;
278
279 return res;
280}
281
282/*
283 * @brief
284 * result = arg1 - arg2
285 */
286static inline struct fixed31_32 dc_fixpt_sub_int(struct fixed31_32 arg1, int arg2)
287{
288 return dc_fixpt_sub(arg1, dc_fixpt_from_int(arg2));
289}
290
291
292/*
293 * @brief
294 * Binary multiplicative operators
295 */
296
297/*
298 * @brief
299 * result = arg1 * arg2
300 */
301struct fixed31_32 dc_fixpt_mul(struct fixed31_32 arg1, struct fixed31_32 arg2);
302
303
304/*
305 * @brief
306 * result = arg1 * arg2
307 */
308static inline struct fixed31_32 dc_fixpt_mul_int(struct fixed31_32 arg1, int arg2)
309{
310 return dc_fixpt_mul(arg1, dc_fixpt_from_int(arg2));
311}
312
313/*
314 * @brief
315 * result = square(arg) := arg * arg
316 */
317struct fixed31_32 dc_fixpt_sqr(struct fixed31_32 arg);
318
319/*
320 * @brief
321 * result = arg1 / arg2
322 */
323static inline struct fixed31_32 dc_fixpt_div_int(struct fixed31_32 arg1, long long arg2)
324{
325 return dc_fixpt_from_fraction(arg1.value, dc_fixpt_from_int((int)arg2).value);
326}
327
328/*
329 * @brief
330 * result = arg1 / arg2
331 */
332static inline struct fixed31_32 dc_fixpt_div(struct fixed31_32 arg1, struct fixed31_32 arg2)
333{
334 return dc_fixpt_from_fraction(arg1.value, arg2.value);
335}
336
337/*
338 * @brief
339 * Reciprocal function
340 */
341
342/*
343 * @brief
344 * result = reciprocal(arg) := 1 / arg
345 *
346 * @note
347 * No special actions taken in case argument is zero.
348 */
349struct fixed31_32 dc_fixpt_recip(struct fixed31_32 arg);
350
351/*
352 * @brief
353 * Trigonometric functions
354 */
355
356/*
357 * @brief
358 * result = sinc(arg) := sin(arg) / arg
359 *
360 * @note
361 * Argument specified in radians,
362 * internally it's normalized to [-2pi...2pi] range.
363 */
364struct fixed31_32 dc_fixpt_sinc(struct fixed31_32 arg);
365
366/*
367 * @brief
368 * result = sin(arg)
369 *
370 * @note
371 * Argument specified in radians,
372 * internally it's normalized to [-2pi...2pi] range.
373 */
374struct fixed31_32 dc_fixpt_sin(struct fixed31_32 arg);
375
376/*
377 * @brief
378 * result = cos(arg)
379 *
380 * @note
381 * Argument specified in radians
382 * and should be in [-2pi...2pi] range -
383 * passing arguments outside that range
384 * will cause incorrect result!
385 */
386struct fixed31_32 dc_fixpt_cos(struct fixed31_32 arg);
387
388/*
389 * @brief
390 * Transcendent functions
391 */
392
393/*
394 * @brief
395 * result = exp(arg)
396 *
397 * @note
398 * Currently, function is verified for abs(arg) <= 1.
399 */
400struct fixed31_32 dc_fixpt_exp(struct fixed31_32 arg);
401
402/*
403 * @brief
404 * result = log(arg)
405 *
406 * @note
407 * Currently, abs(arg) should be less than 1.
408 * No normalization is done.
409 * Currently, no special actions taken
410 * in case of invalid argument(s). Take care!
411 */
412struct fixed31_32 dc_fixpt_log(struct fixed31_32 arg);
413
414/*
415 * @brief
416 * Power function
417 */
418
419/*
420 * @brief
421 * result = pow(arg1, arg2)
422 *
423 * @note
424 * Currently, abs(arg1) should be less than 1. Take care!
425 */
426static inline struct fixed31_32 dc_fixpt_pow(struct fixed31_32 arg1, struct fixed31_32 arg2)
427{
428 if (arg1.value == 0)
429 return arg2.value == 0 ? dc_fixpt_one : dc_fixpt_zero;
430
431 return dc_fixpt_exp(
432 dc_fixpt_mul(
433 dc_fixpt_log(arg1),
434 arg2));
435}
436
437/*
438 * @brief
439 * Rounding functions
440 */
441
442/*
443 * @brief
444 * result = floor(arg) := greatest integer lower than or equal to arg
445 */
446static inline int dc_fixpt_floor(struct fixed31_32 arg)
447{
448 unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
449
450 if (arg.value >= 0)
451 return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
452 else
453 return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
454}
455
456/*
457 * @brief
458 * result = round(arg) := integer nearest to arg
459 */
460static inline int dc_fixpt_round(struct fixed31_32 arg)
461{
462 unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
463
464 const long long summand = dc_fixpt_half.value;
465
466 ASSERT(LLONG_MAX - (long long)arg_value >= summand)do { if (({ static int __warned; int __ret = !!(!(0x7fffffffffffffffLL
- (long long)arg_value >= summand)); if (__ret &&
!__warned) { printf("WARNING %s failed at %s:%d\n", "!(0x7fffffffffffffffLL - (long long)arg_value >= summand)"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 466); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
467
468 arg_value += summand;
469
470 if (arg.value >= 0)
471 return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
472 else
473 return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
474}
475
476/*
477 * @brief
478 * result = ceil(arg) := lowest integer greater than or equal to arg
479 */
480static inline int dc_fixpt_ceil(struct fixed31_32 arg)
481{
482 unsigned long long arg_value = arg.value > 0 ? arg.value : -arg.value;
483
484 const long long summand = dc_fixpt_one.value -
485 dc_fixpt_epsilon.value;
486
487 ASSERT(LLONG_MAX - (long long)arg_value >= summand)do { if (({ static int __warned; int __ret = !!(!(0x7fffffffffffffffLL
- (long long)arg_value >= summand)); if (__ret &&
!__warned) { printf("WARNING %s failed at %s:%d\n", "!(0x7fffffffffffffffLL - (long long)arg_value >= summand)"
, "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 487); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
488
489 arg_value += summand;
490
491 if (arg.value >= 0)
492 return (int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
493 else
494 return -(int)(arg_value >> FIXED31_32_BITS_PER_FRACTIONAL_PART32);
495}
496
497/* the following two function are used in scaler hw programming to convert fixed
498 * point value to format 2 bits from integer part and 19 bits from fractional
499 * part. The same applies for u0d19, 0 bits from integer part and 19 bits from
500 * fractional
501 */
502
503unsigned int dc_fixpt_u4d19(struct fixed31_32 arg);
504
505unsigned int dc_fixpt_u3d19(struct fixed31_32 arg);
506
507unsigned int dc_fixpt_u2d19(struct fixed31_32 arg);
508
509unsigned int dc_fixpt_u0d19(struct fixed31_32 arg);
510
511unsigned int dc_fixpt_clamp_u0d14(struct fixed31_32 arg);
512
513unsigned int dc_fixpt_clamp_u0d10(struct fixed31_32 arg);
514
515int dc_fixpt_s4d19(struct fixed31_32 arg);
516
517static inline struct fixed31_32 dc_fixpt_truncate(struct fixed31_32 arg, unsigned int frac_bits)
518{
519 bool_Bool negative = arg.value < 0;
520
521 if (frac_bits >= FIXED31_32_BITS_PER_FRACTIONAL_PART32) {
522 ASSERT(frac_bits == FIXED31_32_BITS_PER_FRACTIONAL_PART)do { if (({ static int __warned; int __ret = !!(!(frac_bits ==
32)); if (__ret && !__warned) { printf("WARNING %s failed at %s:%d\n"
, "!(frac_bits == 32)", "/usr/src/sys/dev/pci/drm/amd/display/include/fixed31_32.h"
, 522); __warned = 1; } __builtin_expect(!!(__ret), 0); })) do
{} while (0); } while (0);
523 return arg;
524 }
525
526 if (negative)
527 arg.value = -arg.value;
528 arg.value &= (~0LL) << (FIXED31_32_BITS_PER_FRACTIONAL_PART32 - frac_bits);
529 if (negative)
530 arg.value = -arg.value;
531 return arg;
532}
533
534#endif