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_START 224 36 #define PRECISE_LUT_REGION_END 239 37 38 static struct hw_x_point coordinates_x[MAX_HW_POINTS + 2]; 39 40 // Hardcoded table that depends on setup_x_points_distribution and sdr_level=80 41 // If x points are changed, then PQ Y points will be misaligned and a new 42 // table would need to be generated. Or use old method that calls compute_pq. 43 // The last point is above PQ formula range (0-125 in normalized FP16) 44 // The value for the last point (128) is such that interpolation from 45 // 120 to 128 will give 1.0 for X = 125.0 46 // first couple points are 0 - HW LUT is mirrored around zero, so making first 47 // segment 0 to 0 will effectively clip it, and these are very low PQ codes 48 // min nonzero value below (216825) is a little under 12-bit PQ code 1. 49 static const unsigned long long pq_divider = 1000000000; 50 static const unsigned long long pq_numerator[MAX_HW_POINTS + 1] = { 51 0, 0, 0, 0, 216825, 222815, 52 228691, 234460, 240128, 245702, 251187, 256587, 53 261908, 267152, 272324, 277427, 282465, 292353, 54 302011, 311456, 320704, 329768, 338661, 347394, 55 355975, 364415, 372721, 380900, 388959, 396903, 56 404739, 412471, 420104, 435089, 449727, 464042, 57 478060, 491800, 505281, 518520, 531529, 544324, 58 556916, 569316, 581533, 593576, 605454, 617175, 59 628745, 651459, 673643, 695337, 716578, 737395, 60 757817, 777869, 797572, 816947, 836012, 854782, 61 873274, 891500, 909474, 927207, 944709, 979061, 62 1012601, 1045391, 1077485, 1108931, 1139770, 1170042, 63 1199778, 1229011, 1257767, 1286071, 1313948, 1341416, 64 1368497, 1395207, 1421563, 1473272, 1523733, 1573041, 65 1621279, 1668520, 1714828, 1760262, 1804874, 1848710, 66 1891814, 1934223, 1975973, 2017096, 2057622, 2097578, 67 2136989, 2214269, 2289629, 2363216, 2435157, 2505564, 68 2574539, 2642169, 2708536, 2773711, 2837760, 2900742, 69 2962712, 3023719, 3083810, 3143025, 3201405, 3315797, 70 3427246, 3535974, 3642181, 3746038, 3847700, 3947305, 71 4044975, 4140823, 4234949, 4327445, 4418394, 4507872, 72 4595951, 4682694, 4768161, 4935487, 5098326, 5257022, 73 5411878, 5563161, 5711107, 5855928, 5997812, 6136929, 74 6273436, 6407471, 6539163, 6668629, 6795976, 6921304, 75 7044703, 7286050, 7520623, 7748950, 7971492, 8188655, 76 8400800, 8608247, 8811286, 9010175, 9205149, 9396421, 77 9584186, 9768620, 9949889, 10128140, 10303513, 10646126, 78 10978648, 11301874, 11616501, 11923142, 12222340, 12514578, 79 12800290, 13079866, 13353659, 13621988, 13885144, 14143394, 80 14396982, 14646132, 14891052, 15368951, 15832050, 16281537, 81 16718448, 17143696, 17558086, 17962337, 18357092, 18742927, 82 19120364, 19489877, 19851894, 20206810, 20554983, 20896745, 83 21232399, 21886492, 22519276, 23132491, 23727656, 24306104, 84 24869013, 25417430, 25952292, 26474438, 26984626, 27483542, 85 27971811, 28450000, 28918632, 29378184, 29829095, 30706591, 86 31554022, 32373894, 33168387, 33939412, 34688657, 35417620, 87 36127636, 36819903, 37495502, 38155408, 38800507, 39431607, 88 40049446, 40654702, 41247996, 42400951, 43512407, 44585892, 89 45624474, 46630834, 47607339, 48556082, 49478931, 50377558, 90 51253467, 52108015, 52942436, 53757848, 54555277, 55335659, 91 56099856, 57582802, 59009766, 60385607, 61714540, 63000246, 92 64245964, 65454559, 66628579, 67770304, 68881781, 69964856, 93 71021203, 72052340, 73059655, 74044414, 75007782, 76874537, 94 78667536, 80393312, 82057522, 83665098, 85220372, 86727167, 95 88188883, 89608552, 90988895, 92332363, 93641173, 94917336, 96 96162685, 97378894, 98567496, 100867409, 103072439, 105191162, 97 107230989, 109198368, 111098951, 112937723, 114719105, 116447036, 98 118125045, 119756307, 121343688, 122889787, 124396968, 125867388, 99 127303021, 130077030, 132731849, 135278464, 137726346, 140083726, 100 142357803, 144554913, 146680670, 148740067, 150737572, 152677197, 101 154562560, 156396938, 158183306, 159924378, 161622632, 164899602, 102 168030318, 171028513, 173906008, 176673051, 179338593, 181910502, 103 184395731, 186800463, 189130216, 191389941, 193584098, 195716719, 104 197791463, 199811660, 201780351, 205574133, 209192504, 212652233, 105 215967720, 219151432, 222214238, 225165676, 228014163, 230767172, 106 233431363, 236012706, 238516569, 240947800, 243310793, 245609544, 107 247847696, 252155270, 256257056, 260173059, 263920427, 267513978, 108 270966613, 274289634, 277493001, 280585542, 283575118, 286468763, 109 289272796, 291992916, 294634284, 297201585, 299699091, 304500003, 110 309064541, 313416043, 317574484, 321557096, 325378855, 329052864, 111 332590655, 336002433, 339297275, 342483294, 345567766, 348557252, 112 351457680, 354274432, 357012407, 362269536, 367260561, 372012143, 113 376547060, 380884936, 385042798, 389035522, 392876185, 396576344, 114 400146265, 403595112, 406931099, 410161619, 413293351, 416332348, 115 419284117, 424945627, 430313203, 435416697, 440281572, 444929733, 116 449380160, 453649415, 457752035, 461700854, 465507260, 469181407, 117 472732388, 476168376, 479496748, 482724188, 485856764, 491858986, 118 497542280, 502939446, 508078420, 512983199, 517674549, 522170569, 119 526487126, 530638214, 534636233, 538492233, 542216094, 545816693, 120 549302035, 552679362, 555955249, 562226134, 568156709, 573782374, 121 579133244, 584235153, 589110430, 593778512, 598256421, 602559154, 122 606699989, 610690741, 614541971, 618263157, 621862836, 625348729, 123 628727839, 635190643, 641295921, 647081261, 652578597, 657815287, 124 662814957, 667598146, 672182825, 676584810, 680818092, 684895111, 125 688826974, 692623643, 696294085, 699846401, 703287935, 709864782, 126 716071394, 721947076, 727525176, 732834238, 737898880, 742740485, 127 747377745, 751827095, 756103063, 760218552, 764185078, 768012958, 128 771711474, 775289005, 778753144, 785368225, 791604988, 797503949, 129 803099452, 808420859, 813493471, 818339244, 822977353, 827424644, 130 831695997, 835804619, 839762285, 843579541, 847265867, 850829815, 131 854279128, 860861356, 867061719, 872921445, 878475444, 883753534, 132 888781386, 893581259, 898172578, 902572393, 906795754, 910856010, 133 914765057, 918533538, 922171018, 925686119, 929086644, 935571664, 134 941675560, 947439782, 952899395, 958084324, 963020312, 967729662, 135 972231821, 976543852, 980680801, 984656009, 988481353, 992167459, 136 995723865, 999159168, 1002565681}; 137 138 // these are helpers for calculations to reduce stack usage 139 // do not depend on these being preserved across calls 140 141 /* Helper to optimize gamma calculation, only use in translate_from_linear, in 142 * particular the dc_fixpt_pow function which is very expensive 143 * The idea is that our regions for X points are exponential and currently they all use 144 * the same number of points (NUM_PTS_IN_REGION) and in each region every point 145 * is exactly 2x the one at the same index in the previous region. In other words 146 * X[i] = 2 * X[i-NUM_PTS_IN_REGION] for i>=16 147 * The other fact is that (2x)^gamma = 2^gamma * x^gamma 148 * So we compute and save x^gamma for the first 16 regions, and for every next region 149 * just multiply with 2^gamma which can be computed once, and save the result so we 150 * recursively compute all the values. 151 */ 152 153 /* 154 * Regamma coefficients are used for both regamma and degamma. Degamma 155 * coefficients are calculated in our formula using the regamma coefficients. 156 */ 157 /*sRGB 709 2.2 2.4 P3*/ 158 static const int32_t numerator01[] = { 31308, 180000, 0, 0, 0}; 159 static const int32_t numerator02[] = { 12920, 4500, 0, 0, 0}; 160 static const int32_t numerator03[] = { 55, 99, 0, 0, 0}; 161 static const int32_t numerator04[] = { 55, 99, 0, 0, 0}; 162 static const int32_t numerator05[] = { 2400, 2222, 2200, 2400, 2600}; 163 164 /* one-time setup of X points */ setup_x_points_distribution(void)165 void setup_x_points_distribution(void) 166 { 167 struct fixed31_32 region_size = dc_fixpt_from_int(128); 168 int32_t segment; 169 uint32_t seg_offset; 170 uint32_t index; 171 struct fixed31_32 increment; 172 173 coordinates_x[MAX_HW_POINTS].x = region_size; 174 coordinates_x[MAX_HW_POINTS + 1].x = region_size; 175 176 for (segment = 6; segment > (6 - NUM_REGIONS); segment--) { 177 region_size = dc_fixpt_div_int(region_size, 2); 178 increment = dc_fixpt_div_int(region_size, 179 NUM_PTS_IN_REGION); 180 seg_offset = (segment + (NUM_REGIONS - 7)) * NUM_PTS_IN_REGION; 181 coordinates_x[seg_offset].x = region_size; 182 183 for (index = seg_offset + 1; 184 index < seg_offset + NUM_PTS_IN_REGION; 185 index++) { 186 coordinates_x[index].x = dc_fixpt_add 187 (coordinates_x[index-1].x, increment); 188 } 189 } 190 } 191 log_x_points_distribution(struct dal_logger * logger)192 void log_x_points_distribution(struct dal_logger *logger) 193 { 194 int i = 0; 195 196 if (logger != NULL) { 197 LOG_GAMMA_WRITE("Log X Distribution\n"); 198 199 for (i = 0; i < MAX_HW_POINTS; i++) 200 LOG_GAMMA_WRITE("%llu\n", coordinates_x[i].x.value); 201 } 202 } 203 compute_pq(struct fixed31_32 in_x,struct fixed31_32 * out_y)204 static void compute_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y) 205 { 206 /* consts for PQ gamma formula. */ 207 const struct fixed31_32 m1 = 208 dc_fixpt_from_fraction(159301758, 1000000000); 209 const struct fixed31_32 m2 = 210 dc_fixpt_from_fraction(7884375, 100000); 211 const struct fixed31_32 c1 = 212 dc_fixpt_from_fraction(8359375, 10000000); 213 const struct fixed31_32 c2 = 214 dc_fixpt_from_fraction(188515625, 10000000); 215 const struct fixed31_32 c3 = 216 dc_fixpt_from_fraction(186875, 10000); 217 218 struct fixed31_32 l_pow_m1; 219 struct fixed31_32 base; 220 221 if (dc_fixpt_lt(in_x, dc_fixpt_zero)) 222 in_x = dc_fixpt_zero; 223 224 l_pow_m1 = dc_fixpt_pow(in_x, m1); 225 base = dc_fixpt_div( 226 dc_fixpt_add(c1, 227 (dc_fixpt_mul(c2, l_pow_m1))), 228 dc_fixpt_add(dc_fixpt_one, 229 (dc_fixpt_mul(c3, l_pow_m1)))); 230 *out_y = dc_fixpt_pow(base, m2); 231 } 232 compute_de_pq(struct fixed31_32 in_x,struct fixed31_32 * out_y)233 static void compute_de_pq(struct fixed31_32 in_x, struct fixed31_32 *out_y) 234 { 235 /* consts for dePQ gamma formula. */ 236 const struct fixed31_32 m1 = 237 dc_fixpt_from_fraction(159301758, 1000000000); 238 const struct fixed31_32 m2 = 239 dc_fixpt_from_fraction(7884375, 100000); 240 const struct fixed31_32 c1 = 241 dc_fixpt_from_fraction(8359375, 10000000); 242 const struct fixed31_32 c2 = 243 dc_fixpt_from_fraction(188515625, 10000000); 244 const struct fixed31_32 c3 = 245 dc_fixpt_from_fraction(186875, 10000); 246 247 struct fixed31_32 l_pow_m1; 248 struct fixed31_32 base, div; 249 struct fixed31_32 base2; 250 251 252 if (dc_fixpt_lt(in_x, dc_fixpt_zero)) 253 in_x = dc_fixpt_zero; 254 255 l_pow_m1 = dc_fixpt_pow(in_x, 256 dc_fixpt_div(dc_fixpt_one, m2)); 257 base = dc_fixpt_sub(l_pow_m1, c1); 258 259 div = dc_fixpt_sub(c2, dc_fixpt_mul(c3, l_pow_m1)); 260 261 base2 = dc_fixpt_div(base, div); 262 // avoid complex numbers 263 if (dc_fixpt_lt(base2, dc_fixpt_zero)) 264 base2 = dc_fixpt_sub(dc_fixpt_zero, base2); 265 266 267 *out_y = dc_fixpt_pow(base2, dc_fixpt_div(dc_fixpt_one, m1)); 268 269 } 270 271 272 /* de gamma, non-linear to linear */ compute_hlg_eotf(struct fixed31_32 in_x,struct fixed31_32 * out_y,uint32_t sdr_white_level,uint32_t max_luminance_nits)273 static void compute_hlg_eotf(struct fixed31_32 in_x, 274 struct fixed31_32 *out_y, 275 uint32_t sdr_white_level, uint32_t max_luminance_nits) 276 { 277 struct fixed31_32 a; 278 struct fixed31_32 b; 279 struct fixed31_32 c; 280 struct fixed31_32 threshold; 281 struct fixed31_32 x; 282 283 struct fixed31_32 scaling_factor = 284 dc_fixpt_from_fraction(max_luminance_nits, sdr_white_level); 285 a = dc_fixpt_from_fraction(17883277, 100000000); 286 b = dc_fixpt_from_fraction(28466892, 100000000); 287 c = dc_fixpt_from_fraction(55991073, 100000000); 288 threshold = dc_fixpt_from_fraction(1, 2); 289 290 if (dc_fixpt_lt(in_x, threshold)) { 291 x = dc_fixpt_mul(in_x, in_x); 292 x = dc_fixpt_div_int(x, 3); 293 } else { 294 x = dc_fixpt_sub(in_x, c); 295 x = dc_fixpt_div(x, a); 296 x = dc_fixpt_exp(x); 297 x = dc_fixpt_add(x, b); 298 x = dc_fixpt_div_int(x, 12); 299 } 300 *out_y = dc_fixpt_mul(x, scaling_factor); 301 302 } 303 304 /* re gamma, linear to non-linear */ compute_hlg_oetf(struct fixed31_32 in_x,struct fixed31_32 * out_y,uint32_t sdr_white_level,uint32_t max_luminance_nits)305 static void compute_hlg_oetf(struct fixed31_32 in_x, struct fixed31_32 *out_y, 306 uint32_t sdr_white_level, uint32_t max_luminance_nits) 307 { 308 struct fixed31_32 a; 309 struct fixed31_32 b; 310 struct fixed31_32 c; 311 struct fixed31_32 threshold; 312 struct fixed31_32 x; 313 314 struct fixed31_32 scaling_factor = 315 dc_fixpt_from_fraction(sdr_white_level, max_luminance_nits); 316 a = dc_fixpt_from_fraction(17883277, 100000000); 317 b = dc_fixpt_from_fraction(28466892, 100000000); 318 c = dc_fixpt_from_fraction(55991073, 100000000); 319 threshold = dc_fixpt_from_fraction(1, 12); 320 x = dc_fixpt_mul(in_x, scaling_factor); 321 322 323 if (dc_fixpt_lt(x, threshold)) { 324 x = dc_fixpt_mul(x, dc_fixpt_from_fraction(3, 1)); 325 *out_y = dc_fixpt_pow(x, dc_fixpt_half); 326 } else { 327 x = dc_fixpt_mul(x, dc_fixpt_from_fraction(12, 1)); 328 x = dc_fixpt_sub(x, b); 329 x = dc_fixpt_log(x); 330 x = dc_fixpt_mul(a, x); 331 *out_y = dc_fixpt_add(x, c); 332 } 333 } 334 335 336 /* one-time pre-compute PQ values - only for sdr_white_level 80 */ precompute_pq(void)337 void precompute_pq(void) 338 { 339 int i; 340 struct fixed31_32 *pq_table = mod_color_get_table(type_pq_table); 341 342 for (i = 0; i <= MAX_HW_POINTS; i++) 343 pq_table[i] = dc_fixpt_from_fraction(pq_numerator[i], pq_divider); 344 345 /* below is old method that uses run-time calculation in fixed pt space */ 346 /* pow function has problems with arguments too small */ 347 /* 348 struct fixed31_32 x; 349 const struct hw_x_point *coord_x = coordinates_x + 32; 350 struct fixed31_32 scaling_factor = 351 dc_fixpt_from_fraction(80, 10000); 352 353 for (i = 0; i < 32; i++) 354 pq_table[i] = dc_fixpt_zero; 355 356 for (i = 32; i <= MAX_HW_POINTS; i++) { 357 x = dc_fixpt_mul(coord_x->x, scaling_factor); 358 compute_pq(x, &pq_table[i]); 359 ++coord_x; 360 } 361 */ 362 } 363 364 /* one-time pre-compute dePQ values - only for max pixel value 125 FP16 */ precompute_de_pq(void)365 void precompute_de_pq(void) 366 { 367 int i; 368 struct fixed31_32 y; 369 uint32_t begin_index, end_index; 370 371 struct fixed31_32 scaling_factor = dc_fixpt_from_int(125); 372 struct fixed31_32 *de_pq_table = mod_color_get_table(type_de_pq_table); 373 /* X points is 2^-25 to 2^7 374 * De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions 375 */ 376 begin_index = 13 * NUM_PTS_IN_REGION; 377 end_index = begin_index + 12 * NUM_PTS_IN_REGION; 378 379 for (i = 0; i <= begin_index; i++) 380 de_pq_table[i] = dc_fixpt_zero; 381 382 for (; i <= end_index; i++) { 383 compute_de_pq(coordinates_x[i].x, &y); 384 de_pq_table[i] = dc_fixpt_mul(y, scaling_factor); 385 } 386 387 for (; i <= MAX_HW_POINTS; i++) 388 de_pq_table[i] = de_pq_table[i-1]; 389 } 390 struct dividers { 391 struct fixed31_32 divider1; 392 struct fixed31_32 divider2; 393 struct fixed31_32 divider3; 394 }; 395 396 build_coefficients(struct gamma_coefficients * coefficients,enum dc_transfer_func_predefined type)397 static bool build_coefficients(struct gamma_coefficients *coefficients, 398 enum dc_transfer_func_predefined type) 399 { 400 401 uint32_t i = 0; 402 uint32_t index = 0; 403 bool ret = true; 404 405 if (type == TRANSFER_FUNCTION_SRGB) 406 index = 0; 407 else if (type == TRANSFER_FUNCTION_BT709) 408 index = 1; 409 else if (type == TRANSFER_FUNCTION_GAMMA22) 410 index = 2; 411 else if (type == TRANSFER_FUNCTION_GAMMA24) 412 index = 3; 413 else if (type == TRANSFER_FUNCTION_GAMMA26) 414 index = 4; 415 else { 416 ret = false; 417 goto release; 418 } 419 420 do { 421 coefficients->a0[i] = dc_fixpt_from_fraction( 422 numerator01[index], 10000000); 423 coefficients->a1[i] = dc_fixpt_from_fraction( 424 numerator02[index], 1000); 425 coefficients->a2[i] = dc_fixpt_from_fraction( 426 numerator03[index], 1000); 427 coefficients->a3[i] = dc_fixpt_from_fraction( 428 numerator04[index], 1000); 429 coefficients->user_gamma[i] = dc_fixpt_from_fraction( 430 numerator05[index], 1000); 431 432 ++i; 433 } while (i != ARRAY_SIZE(coefficients->a0)); 434 release: 435 return ret; 436 } 437 translate_from_linear_space(struct translate_from_linear_space_args * args)438 static struct fixed31_32 translate_from_linear_space( 439 struct translate_from_linear_space_args *args) 440 { 441 const struct fixed31_32 one = dc_fixpt_from_int(1); 442 443 struct fixed31_32 scratch_1, scratch_2; 444 struct calculate_buffer *cal_buffer = args->cal_buffer; 445 446 if (dc_fixpt_le(one, args->arg)) 447 return one; 448 449 if (dc_fixpt_le(args->arg, dc_fixpt_neg(args->a0))) { 450 scratch_1 = dc_fixpt_add(one, args->a3); 451 scratch_2 = dc_fixpt_pow( 452 dc_fixpt_neg(args->arg), 453 dc_fixpt_recip(args->gamma)); 454 scratch_1 = dc_fixpt_mul(scratch_1, scratch_2); 455 scratch_1 = dc_fixpt_sub(args->a2, scratch_1); 456 457 return scratch_1; 458 } else if (dc_fixpt_le(args->a0, args->arg)) { 459 if (cal_buffer->buffer_index == 0) { 460 cal_buffer->gamma_of_2 = dc_fixpt_pow(dc_fixpt_from_int(2), 461 dc_fixpt_recip(args->gamma)); 462 } 463 scratch_1 = dc_fixpt_add(one, args->a3); 464 /* In the first region (first 16 points) and in the 465 * region delimited by START/END we calculate with 466 * full precision to avoid error accumulation. 467 */ 468 if ((cal_buffer->buffer_index >= PRECISE_LUT_REGION_START && 469 cal_buffer->buffer_index <= PRECISE_LUT_REGION_END) || 470 (cal_buffer->buffer_index < 16)) 471 scratch_2 = dc_fixpt_pow(args->arg, 472 dc_fixpt_recip(args->gamma)); 473 else 474 scratch_2 = dc_fixpt_mul(cal_buffer->gamma_of_2, 475 cal_buffer->buffer[cal_buffer->buffer_index%16]); 476 477 if (cal_buffer->buffer_index != -1) { 478 cal_buffer->buffer[cal_buffer->buffer_index%16] = scratch_2; 479 cal_buffer->buffer_index++; 480 } 481 482 scratch_1 = dc_fixpt_mul(scratch_1, scratch_2); 483 scratch_1 = dc_fixpt_sub(scratch_1, args->a2); 484 485 return scratch_1; 486 } else 487 return dc_fixpt_mul(args->arg, args->a1); 488 } 489 490 translate_from_linear_space_long(struct translate_from_linear_space_args * args)491 static struct fixed31_32 translate_from_linear_space_long( 492 struct translate_from_linear_space_args *args) 493 { 494 const struct fixed31_32 one = dc_fixpt_from_int(1); 495 496 if (dc_fixpt_lt(one, args->arg)) 497 return one; 498 499 if (dc_fixpt_le(args->arg, dc_fixpt_neg(args->a0))) 500 return dc_fixpt_sub( 501 args->a2, 502 dc_fixpt_mul( 503 dc_fixpt_add( 504 one, 505 args->a3), 506 dc_fixpt_pow( 507 dc_fixpt_neg(args->arg), 508 dc_fixpt_recip(args->gamma)))); 509 else if (dc_fixpt_le(args->a0, args->arg)) 510 return dc_fixpt_sub( 511 dc_fixpt_mul( 512 dc_fixpt_add( 513 one, 514 args->a3), 515 dc_fixpt_pow( 516 args->arg, 517 dc_fixpt_recip(args->gamma))), 518 args->a2); 519 else 520 return dc_fixpt_mul(args->arg, args->a1); 521 } 522 calculate_gamma22(struct fixed31_32 arg,bool use_eetf,struct calculate_buffer * cal_buffer)523 static struct fixed31_32 calculate_gamma22(struct fixed31_32 arg, bool use_eetf, struct calculate_buffer *cal_buffer) 524 { 525 struct fixed31_32 gamma = dc_fixpt_from_fraction(22, 10); 526 struct translate_from_linear_space_args scratch_gamma_args; 527 528 scratch_gamma_args.arg = arg; 529 scratch_gamma_args.a0 = dc_fixpt_zero; 530 scratch_gamma_args.a1 = dc_fixpt_zero; 531 scratch_gamma_args.a2 = dc_fixpt_zero; 532 scratch_gamma_args.a3 = dc_fixpt_zero; 533 scratch_gamma_args.cal_buffer = cal_buffer; 534 scratch_gamma_args.gamma = gamma; 535 536 if (use_eetf) 537 return translate_from_linear_space_long(&scratch_gamma_args); 538 539 return translate_from_linear_space(&scratch_gamma_args); 540 } 541 542 translate_to_linear_space(struct fixed31_32 arg,struct fixed31_32 a0,struct fixed31_32 a1,struct fixed31_32 a2,struct fixed31_32 a3,struct fixed31_32 gamma)543 static struct fixed31_32 translate_to_linear_space( 544 struct fixed31_32 arg, 545 struct fixed31_32 a0, 546 struct fixed31_32 a1, 547 struct fixed31_32 a2, 548 struct fixed31_32 a3, 549 struct fixed31_32 gamma) 550 { 551 struct fixed31_32 linear; 552 553 a0 = dc_fixpt_mul(a0, a1); 554 if (dc_fixpt_le(arg, dc_fixpt_neg(a0))) 555 556 linear = dc_fixpt_neg( 557 dc_fixpt_pow( 558 dc_fixpt_div( 559 dc_fixpt_sub(a2, arg), 560 dc_fixpt_add( 561 dc_fixpt_one, a3)), gamma)); 562 563 else if (dc_fixpt_le(dc_fixpt_neg(a0), arg) && 564 dc_fixpt_le(arg, a0)) 565 linear = dc_fixpt_div(arg, a1); 566 else 567 linear = dc_fixpt_pow( 568 dc_fixpt_div( 569 dc_fixpt_add(a2, arg), 570 dc_fixpt_add( 571 dc_fixpt_one, a3)), gamma); 572 573 return linear; 574 } 575 translate_from_linear_space_ex(struct fixed31_32 arg,struct gamma_coefficients * coeff,uint32_t color_index,struct calculate_buffer * cal_buffer)576 static struct fixed31_32 translate_from_linear_space_ex( 577 struct fixed31_32 arg, 578 struct gamma_coefficients *coeff, 579 uint32_t color_index, 580 struct calculate_buffer *cal_buffer) 581 { 582 struct translate_from_linear_space_args scratch_gamma_args; 583 584 scratch_gamma_args.arg = arg; 585 scratch_gamma_args.a0 = coeff->a0[color_index]; 586 scratch_gamma_args.a1 = coeff->a1[color_index]; 587 scratch_gamma_args.a2 = coeff->a2[color_index]; 588 scratch_gamma_args.a3 = coeff->a3[color_index]; 589 scratch_gamma_args.gamma = coeff->user_gamma[color_index]; 590 scratch_gamma_args.cal_buffer = cal_buffer; 591 592 return translate_from_linear_space(&scratch_gamma_args); 593 } 594 595 translate_to_linear_space_ex(struct fixed31_32 arg,struct gamma_coefficients * coeff,uint32_t color_index)596 static inline struct fixed31_32 translate_to_linear_space_ex( 597 struct fixed31_32 arg, 598 struct gamma_coefficients *coeff, 599 uint32_t color_index) 600 { 601 return translate_to_linear_space( 602 arg, 603 coeff->a0[color_index], 604 coeff->a1[color_index], 605 coeff->a2[color_index], 606 coeff->a3[color_index], 607 coeff->user_gamma[color_index]); 608 } 609 610 find_software_points(const struct dc_gamma * ramp,const struct gamma_pixel * axis_x,struct fixed31_32 hw_point,enum channel_name channel,uint32_t * index_to_start,uint32_t * index_left,uint32_t * index_right,enum hw_point_position * pos)611 static bool find_software_points( 612 const struct dc_gamma *ramp, 613 const struct gamma_pixel *axis_x, 614 struct fixed31_32 hw_point, 615 enum channel_name channel, 616 uint32_t *index_to_start, 617 uint32_t *index_left, 618 uint32_t *index_right, 619 enum hw_point_position *pos) 620 { 621 const uint32_t max_number = ramp->num_entries + 3; 622 623 struct fixed31_32 left, right; 624 625 uint32_t i = *index_to_start; 626 627 while (i < max_number) { 628 if (channel == CHANNEL_NAME_RED) { 629 left = axis_x[i].r; 630 631 if (i < max_number - 1) 632 right = axis_x[i + 1].r; 633 else 634 right = axis_x[max_number - 1].r; 635 } else if (channel == CHANNEL_NAME_GREEN) { 636 left = axis_x[i].g; 637 638 if (i < max_number - 1) 639 right = axis_x[i + 1].g; 640 else 641 right = axis_x[max_number - 1].g; 642 } else { 643 left = axis_x[i].b; 644 645 if (i < max_number - 1) 646 right = axis_x[i + 1].b; 647 else 648 right = axis_x[max_number - 1].b; 649 } 650 651 if (dc_fixpt_le(left, hw_point) && 652 dc_fixpt_le(hw_point, right)) { 653 *index_to_start = i; 654 *index_left = i; 655 656 if (i < max_number - 1) 657 *index_right = i + 1; 658 else 659 *index_right = max_number - 1; 660 661 *pos = HW_POINT_POSITION_MIDDLE; 662 663 return true; 664 } else if ((i == *index_to_start) && 665 dc_fixpt_le(hw_point, left)) { 666 *index_to_start = i; 667 *index_left = i; 668 *index_right = i; 669 670 *pos = HW_POINT_POSITION_LEFT; 671 672 return true; 673 } else if ((i == max_number - 1) && 674 dc_fixpt_le(right, hw_point)) { 675 *index_to_start = i; 676 *index_left = i; 677 *index_right = i; 678 679 *pos = HW_POINT_POSITION_RIGHT; 680 681 return true; 682 } 683 684 ++i; 685 } 686 687 return false; 688 } 689 build_custom_gamma_mapping_coefficients_worker(const struct dc_gamma * ramp,struct pixel_gamma_point * coeff,const struct hw_x_point * coordinates_x,const struct gamma_pixel * axis_x,enum channel_name channel,uint32_t number_of_points)690 static bool build_custom_gamma_mapping_coefficients_worker( 691 const struct dc_gamma *ramp, 692 struct pixel_gamma_point *coeff, 693 const struct hw_x_point *coordinates_x, 694 const struct gamma_pixel *axis_x, 695 enum channel_name channel, 696 uint32_t number_of_points) 697 { 698 uint32_t i = 0; 699 700 while (i <= number_of_points) { 701 struct fixed31_32 coord_x; 702 703 uint32_t index_to_start = 0; 704 uint32_t index_left = 0; 705 uint32_t index_right = 0; 706 707 enum hw_point_position hw_pos; 708 709 struct gamma_point *point; 710 711 struct fixed31_32 left_pos; 712 struct fixed31_32 right_pos; 713 714 if (channel == CHANNEL_NAME_RED) 715 coord_x = coordinates_x[i].regamma_y_red; 716 else if (channel == CHANNEL_NAME_GREEN) 717 coord_x = coordinates_x[i].regamma_y_green; 718 else 719 coord_x = coordinates_x[i].regamma_y_blue; 720 721 if (!find_software_points( 722 ramp, axis_x, coord_x, channel, 723 &index_to_start, &index_left, &index_right, &hw_pos)) { 724 BREAK_TO_DEBUGGER(); 725 return false; 726 } 727 728 if (index_left >= ramp->num_entries + 3) { 729 BREAK_TO_DEBUGGER(); 730 return false; 731 } 732 733 if (index_right >= ramp->num_entries + 3) { 734 BREAK_TO_DEBUGGER(); 735 return false; 736 } 737 738 if (channel == CHANNEL_NAME_RED) { 739 point = &coeff[i].r; 740 741 left_pos = axis_x[index_left].r; 742 right_pos = axis_x[index_right].r; 743 } else if (channel == CHANNEL_NAME_GREEN) { 744 point = &coeff[i].g; 745 746 left_pos = axis_x[index_left].g; 747 right_pos = axis_x[index_right].g; 748 } else { 749 point = &coeff[i].b; 750 751 left_pos = axis_x[index_left].b; 752 right_pos = axis_x[index_right].b; 753 } 754 755 if (hw_pos == HW_POINT_POSITION_MIDDLE) 756 point->coeff = dc_fixpt_div( 757 dc_fixpt_sub( 758 coord_x, 759 left_pos), 760 dc_fixpt_sub( 761 right_pos, 762 left_pos)); 763 else if (hw_pos == HW_POINT_POSITION_LEFT) 764 point->coeff = dc_fixpt_zero; 765 else if (hw_pos == HW_POINT_POSITION_RIGHT) 766 point->coeff = dc_fixpt_from_int(2); 767 else { 768 BREAK_TO_DEBUGGER(); 769 return false; 770 } 771 772 point->left_index = index_left; 773 point->right_index = index_right; 774 point->pos = hw_pos; 775 776 ++i; 777 } 778 779 return true; 780 } 781 calculate_mapped_value(struct pwl_float_data * rgb,const struct pixel_gamma_point * coeff,enum channel_name channel,uint32_t max_index)782 static struct fixed31_32 calculate_mapped_value( 783 struct pwl_float_data *rgb, 784 const struct pixel_gamma_point *coeff, 785 enum channel_name channel, 786 uint32_t max_index) 787 { 788 const struct gamma_point *point; 789 790 struct fixed31_32 result; 791 792 if (channel == CHANNEL_NAME_RED) 793 point = &coeff->r; 794 else if (channel == CHANNEL_NAME_GREEN) 795 point = &coeff->g; 796 else 797 point = &coeff->b; 798 799 if ((point->left_index < 0) || (point->left_index > max_index)) { 800 BREAK_TO_DEBUGGER(); 801 return dc_fixpt_zero; 802 } 803 804 if ((point->right_index < 0) || (point->right_index > max_index)) { 805 BREAK_TO_DEBUGGER(); 806 return dc_fixpt_zero; 807 } 808 809 if (point->pos == HW_POINT_POSITION_MIDDLE) 810 if (channel == CHANNEL_NAME_RED) 811 result = dc_fixpt_add( 812 dc_fixpt_mul( 813 point->coeff, 814 dc_fixpt_sub( 815 rgb[point->right_index].r, 816 rgb[point->left_index].r)), 817 rgb[point->left_index].r); 818 else if (channel == CHANNEL_NAME_GREEN) 819 result = dc_fixpt_add( 820 dc_fixpt_mul( 821 point->coeff, 822 dc_fixpt_sub( 823 rgb[point->right_index].g, 824 rgb[point->left_index].g)), 825 rgb[point->left_index].g); 826 else 827 result = dc_fixpt_add( 828 dc_fixpt_mul( 829 point->coeff, 830 dc_fixpt_sub( 831 rgb[point->right_index].b, 832 rgb[point->left_index].b)), 833 rgb[point->left_index].b); 834 else if (point->pos == HW_POINT_POSITION_LEFT) { 835 BREAK_TO_DEBUGGER(); 836 result = dc_fixpt_zero; 837 } else { 838 result = dc_fixpt_one; 839 } 840 841 return result; 842 } 843 build_pq(struct pwl_float_data_ex * rgb_regamma,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,uint32_t sdr_white_level)844 static void build_pq(struct pwl_float_data_ex *rgb_regamma, 845 uint32_t hw_points_num, 846 const struct hw_x_point *coordinate_x, 847 uint32_t sdr_white_level) 848 { 849 uint32_t i, start_index; 850 851 struct pwl_float_data_ex *rgb = rgb_regamma; 852 const struct hw_x_point *coord_x = coordinate_x; 853 struct fixed31_32 x; 854 struct fixed31_32 output; 855 struct fixed31_32 scaling_factor = 856 dc_fixpt_from_fraction(sdr_white_level, 10000); 857 struct fixed31_32 *pq_table = mod_color_get_table(type_pq_table); 858 859 if (!mod_color_is_table_init(type_pq_table) && sdr_white_level == 80) { 860 precompute_pq(); 861 mod_color_set_table_init_state(type_pq_table, true); 862 } 863 864 /* TODO: start index is from segment 2^-24, skipping first segment 865 * due to x values too small for power calculations 866 */ 867 start_index = 32; 868 rgb += start_index; 869 coord_x += start_index; 870 871 for (i = start_index; i <= hw_points_num; i++) { 872 /* Multiply 0.008 as regamma is 0-1 and FP16 input is 0-125. 873 * FP 1.0 = 80nits 874 */ 875 if (sdr_white_level == 80) { 876 output = pq_table[i]; 877 } else { 878 x = dc_fixpt_mul(coord_x->x, scaling_factor); 879 compute_pq(x, &output); 880 } 881 882 /* should really not happen? */ 883 if (dc_fixpt_lt(output, dc_fixpt_zero)) 884 output = dc_fixpt_zero; 885 886 rgb->r = output; 887 rgb->g = output; 888 rgb->b = output; 889 890 ++coord_x; 891 ++rgb; 892 } 893 } 894 build_de_pq(struct pwl_float_data_ex * de_pq,uint32_t hw_points_num,const struct hw_x_point * coordinate_x)895 static void build_de_pq(struct pwl_float_data_ex *de_pq, 896 uint32_t hw_points_num, 897 const struct hw_x_point *coordinate_x) 898 { 899 uint32_t i; 900 struct fixed31_32 output; 901 struct fixed31_32 *de_pq_table = mod_color_get_table(type_de_pq_table); 902 struct fixed31_32 scaling_factor = dc_fixpt_from_int(125); 903 904 if (!mod_color_is_table_init(type_de_pq_table)) { 905 precompute_de_pq(); 906 mod_color_set_table_init_state(type_de_pq_table, true); 907 } 908 909 910 for (i = 0; i <= hw_points_num; i++) { 911 output = de_pq_table[i]; 912 /* should really not happen? */ 913 if (dc_fixpt_lt(output, dc_fixpt_zero)) 914 output = dc_fixpt_zero; 915 else if (dc_fixpt_lt(scaling_factor, output)) 916 output = scaling_factor; 917 de_pq[i].r = output; 918 de_pq[i].g = output; 919 de_pq[i].b = output; 920 } 921 } 922 build_regamma(struct pwl_float_data_ex * rgb_regamma,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,enum dc_transfer_func_predefined type,struct calculate_buffer * cal_buffer)923 static bool build_regamma(struct pwl_float_data_ex *rgb_regamma, 924 uint32_t hw_points_num, 925 const struct hw_x_point *coordinate_x, 926 enum dc_transfer_func_predefined type, 927 struct calculate_buffer *cal_buffer) 928 { 929 uint32_t i; 930 bool ret = false; 931 932 struct gamma_coefficients *coeff; 933 struct pwl_float_data_ex *rgb = rgb_regamma; 934 const struct hw_x_point *coord_x = coordinate_x; 935 936 coeff = kvzalloc(sizeof(*coeff), GFP_KERNEL); 937 if (!coeff) 938 goto release; 939 940 if (!build_coefficients(coeff, type)) 941 goto release; 942 943 memset(cal_buffer->buffer, 0, NUM_PTS_IN_REGION * sizeof(struct fixed31_32)); 944 cal_buffer->buffer_index = 0; // see variable definition for more info 945 946 i = 0; 947 while (i <= hw_points_num) { 948 /* TODO use y vs r,g,b */ 949 rgb->r = translate_from_linear_space_ex( 950 coord_x->x, coeff, 0, cal_buffer); 951 rgb->g = rgb->r; 952 rgb->b = rgb->r; 953 ++coord_x; 954 ++rgb; 955 ++i; 956 } 957 cal_buffer->buffer_index = -1; 958 ret = true; 959 release: 960 kvfree(coeff); 961 return ret; 962 } 963 hermite_spline_eetf(struct fixed31_32 input_x,struct fixed31_32 max_display,struct fixed31_32 min_display,struct fixed31_32 max_content,struct fixed31_32 * out_x)964 static void hermite_spline_eetf(struct fixed31_32 input_x, 965 struct fixed31_32 max_display, 966 struct fixed31_32 min_display, 967 struct fixed31_32 max_content, 968 struct fixed31_32 *out_x) 969 { 970 struct fixed31_32 min_lum_pq; 971 struct fixed31_32 max_lum_pq; 972 struct fixed31_32 max_content_pq; 973 struct fixed31_32 ks; 974 struct fixed31_32 E1; 975 struct fixed31_32 E2; 976 struct fixed31_32 E3; 977 struct fixed31_32 t; 978 struct fixed31_32 t2; 979 struct fixed31_32 t3; 980 struct fixed31_32 two; 981 struct fixed31_32 three; 982 struct fixed31_32 temp1; 983 struct fixed31_32 temp2; 984 struct fixed31_32 a = dc_fixpt_from_fraction(15, 10); 985 struct fixed31_32 b = dc_fixpt_from_fraction(5, 10); 986 struct fixed31_32 epsilon = dc_fixpt_from_fraction(1, 1000000); // dc_fixpt_epsilon is a bit too small 987 988 if (dc_fixpt_eq(max_content, dc_fixpt_zero)) { 989 *out_x = dc_fixpt_zero; 990 return; 991 } 992 993 compute_pq(input_x, &E1); 994 compute_pq(dc_fixpt_div(min_display, max_content), &min_lum_pq); 995 compute_pq(dc_fixpt_div(max_display, max_content), &max_lum_pq); 996 compute_pq(dc_fixpt_one, &max_content_pq); // always 1? DAL2 code is weird 997 a = dc_fixpt_div(dc_fixpt_add(dc_fixpt_one, b), max_content_pq); // (1+b)/maxContent 998 ks = dc_fixpt_sub(dc_fixpt_mul(a, max_lum_pq), b); // a * max_lum_pq - b 999 1000 if (dc_fixpt_lt(E1, ks)) 1001 E2 = E1; 1002 else if (dc_fixpt_le(ks, E1) && dc_fixpt_le(E1, dc_fixpt_one)) { 1003 if (dc_fixpt_lt(epsilon, dc_fixpt_sub(dc_fixpt_one, ks))) 1004 // t = (E1 - ks) / (1 - ks) 1005 t = dc_fixpt_div(dc_fixpt_sub(E1, ks), 1006 dc_fixpt_sub(dc_fixpt_one, ks)); 1007 else 1008 t = dc_fixpt_zero; 1009 1010 two = dc_fixpt_from_int(2); 1011 three = dc_fixpt_from_int(3); 1012 1013 t2 = dc_fixpt_mul(t, t); 1014 t3 = dc_fixpt_mul(t2, t); 1015 temp1 = dc_fixpt_mul(two, t3); 1016 temp2 = dc_fixpt_mul(three, t2); 1017 1018 // (2t^3 - 3t^2 + 1) * ks 1019 E2 = dc_fixpt_mul(ks, dc_fixpt_add(dc_fixpt_one, 1020 dc_fixpt_sub(temp1, temp2))); 1021 1022 // (-2t^3 + 3t^2) * max_lum_pq 1023 E2 = dc_fixpt_add(E2, dc_fixpt_mul(max_lum_pq, 1024 dc_fixpt_sub(temp2, temp1))); 1025 1026 temp1 = dc_fixpt_mul(two, t2); 1027 temp2 = dc_fixpt_sub(dc_fixpt_one, ks); 1028 1029 // (t^3 - 2t^2 + t) * (1-ks) 1030 E2 = dc_fixpt_add(E2, dc_fixpt_mul(temp2, 1031 dc_fixpt_add(t, dc_fixpt_sub(t3, temp1)))); 1032 } else 1033 E2 = dc_fixpt_one; 1034 1035 temp1 = dc_fixpt_sub(dc_fixpt_one, E2); 1036 temp2 = dc_fixpt_mul(temp1, temp1); 1037 temp2 = dc_fixpt_mul(temp2, temp2); 1038 // temp2 = (1-E2)^4 1039 1040 E3 = dc_fixpt_add(E2, dc_fixpt_mul(min_lum_pq, temp2)); 1041 compute_de_pq(E3, out_x); 1042 1043 *out_x = dc_fixpt_div(*out_x, dc_fixpt_div(max_display, max_content)); 1044 } 1045 build_freesync_hdr(struct pwl_float_data_ex * rgb_regamma,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,const struct hdr_tm_params * fs_params,struct calculate_buffer * cal_buffer)1046 static bool build_freesync_hdr(struct pwl_float_data_ex *rgb_regamma, 1047 uint32_t hw_points_num, 1048 const struct hw_x_point *coordinate_x, 1049 const struct hdr_tm_params *fs_params, 1050 struct calculate_buffer *cal_buffer) 1051 { 1052 uint32_t i; 1053 struct pwl_float_data_ex *rgb = rgb_regamma; 1054 const struct hw_x_point *coord_x = coordinate_x; 1055 const struct hw_x_point *prv_coord_x = coord_x; 1056 struct fixed31_32 scaledX = dc_fixpt_zero; 1057 struct fixed31_32 scaledX1 = dc_fixpt_zero; 1058 struct fixed31_32 max_display; 1059 struct fixed31_32 min_display; 1060 struct fixed31_32 max_content; 1061 struct fixed31_32 clip = dc_fixpt_one; 1062 struct fixed31_32 output = dc_fixpt_zero; 1063 bool use_eetf = false; 1064 bool is_clipped = false; 1065 struct fixed31_32 sdr_white_level; 1066 struct fixed31_32 coordX_diff; 1067 struct fixed31_32 out_dist_max; 1068 struct fixed31_32 bright_norm; 1069 1070 if (fs_params->max_content == 0 || 1071 fs_params->max_display == 0) 1072 return false; 1073 1074 max_display = dc_fixpt_from_int(fs_params->max_display); 1075 min_display = dc_fixpt_from_fraction(fs_params->min_display, 10000); 1076 max_content = dc_fixpt_from_int(fs_params->max_content); 1077 sdr_white_level = dc_fixpt_from_int(fs_params->sdr_white_level); 1078 1079 if (fs_params->min_display > 1000) // cap at 0.1 at the bottom 1080 min_display = dc_fixpt_from_fraction(1, 10); 1081 if (fs_params->max_display < 100) // cap at 100 at the top 1082 max_display = dc_fixpt_from_int(100); 1083 1084 // only max used, we don't adjust min luminance 1085 if (fs_params->max_content > fs_params->max_display) 1086 use_eetf = true; 1087 else 1088 max_content = max_display; 1089 1090 if (!use_eetf) 1091 cal_buffer->buffer_index = 0; // see var definition for more info 1092 rgb += 32; // first 32 points have problems with fixed point, too small 1093 coord_x += 32; 1094 1095 for (i = 32; i <= hw_points_num; i++) { 1096 if (!is_clipped) { 1097 if (use_eetf) { 1098 /* max content is equal 1 */ 1099 scaledX1 = dc_fixpt_div(coord_x->x, 1100 dc_fixpt_div(max_content, sdr_white_level)); 1101 hermite_spline_eetf(scaledX1, max_display, min_display, 1102 max_content, &scaledX); 1103 } else 1104 scaledX = dc_fixpt_div(coord_x->x, 1105 dc_fixpt_div(max_display, sdr_white_level)); 1106 1107 if (dc_fixpt_lt(scaledX, clip)) { 1108 if (dc_fixpt_lt(scaledX, dc_fixpt_zero)) 1109 output = dc_fixpt_zero; 1110 else 1111 output = calculate_gamma22(scaledX, use_eetf, cal_buffer); 1112 1113 // Ensure output respects reasonable boundaries 1114 output = dc_fixpt_clamp(output, dc_fixpt_zero, dc_fixpt_one); 1115 1116 rgb->r = output; 1117 rgb->g = output; 1118 rgb->b = output; 1119 } else { 1120 /* Here clipping happens for the first time */ 1121 is_clipped = true; 1122 1123 /* The next few lines implement the equation 1124 * output = prev_out + 1125 * (coord_x->x - prev_coord_x->x) * 1126 * (1.0 - prev_out) / 1127 * (maxDisp/sdr_white_level - prevCoordX) 1128 * 1129 * This equation interpolates the first point 1130 * after max_display/80 so that the slope from 1131 * hw_x_before_max and hw_x_after_max is such 1132 * that we hit Y=1.0 at max_display/80. 1133 */ 1134 1135 coordX_diff = dc_fixpt_sub(coord_x->x, prv_coord_x->x); 1136 out_dist_max = dc_fixpt_sub(dc_fixpt_one, output); 1137 bright_norm = dc_fixpt_div(max_display, sdr_white_level); 1138 1139 output = dc_fixpt_add( 1140 output, dc_fixpt_mul( 1141 coordX_diff, dc_fixpt_div( 1142 out_dist_max, 1143 dc_fixpt_sub(bright_norm, prv_coord_x->x) 1144 ) 1145 ) 1146 ); 1147 1148 /* Relaxing the maximum boundary to 1.07 (instead of 1.0) 1149 * because the last point in the curve must be such that 1150 * the maximum display pixel brightness interpolates to 1151 * exactly 1.0. The worst case scenario was calculated 1152 * around 1.057, so the limit of 1.07 leaves some safety 1153 * margin. 1154 */ 1155 output = dc_fixpt_clamp(output, dc_fixpt_zero, 1156 dc_fixpt_from_fraction(107, 100)); 1157 1158 rgb->r = output; 1159 rgb->g = output; 1160 rgb->b = output; 1161 } 1162 } else { 1163 /* Every other clipping after the first 1164 * one is dealt with here 1165 */ 1166 rgb->r = clip; 1167 rgb->g = clip; 1168 rgb->b = clip; 1169 } 1170 1171 prv_coord_x = coord_x; 1172 ++coord_x; 1173 ++rgb; 1174 } 1175 cal_buffer->buffer_index = -1; 1176 1177 return true; 1178 } 1179 build_degamma(struct pwl_float_data_ex * curve,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,enum dc_transfer_func_predefined type)1180 static bool build_degamma(struct pwl_float_data_ex *curve, 1181 uint32_t hw_points_num, 1182 const struct hw_x_point *coordinate_x, enum dc_transfer_func_predefined type) 1183 { 1184 uint32_t i; 1185 struct gamma_coefficients coeff; 1186 uint32_t begin_index, end_index; 1187 bool ret = false; 1188 1189 if (!build_coefficients(&coeff, type)) 1190 goto release; 1191 1192 i = 0; 1193 1194 /* X points is 2^-25 to 2^7 1195 * De-gamma X is 2^-12 to 2^0 – we are skipping first -12-(-25) = 13 regions 1196 */ 1197 begin_index = 13 * NUM_PTS_IN_REGION; 1198 end_index = begin_index + 12 * NUM_PTS_IN_REGION; 1199 1200 while (i != begin_index) { 1201 curve[i].r = dc_fixpt_zero; 1202 curve[i].g = dc_fixpt_zero; 1203 curve[i].b = dc_fixpt_zero; 1204 i++; 1205 } 1206 1207 while (i != end_index) { 1208 curve[i].r = translate_to_linear_space_ex( 1209 coordinate_x[i].x, &coeff, 0); 1210 curve[i].g = curve[i].r; 1211 curve[i].b = curve[i].r; 1212 i++; 1213 } 1214 while (i != hw_points_num + 1) { 1215 curve[i].r = dc_fixpt_one; 1216 curve[i].g = dc_fixpt_one; 1217 curve[i].b = dc_fixpt_one; 1218 i++; 1219 } 1220 ret = true; 1221 release: 1222 return ret; 1223 } 1224 1225 1226 1227 1228 build_hlg_degamma(struct pwl_float_data_ex * degamma,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,uint32_t sdr_white_level,uint32_t max_luminance_nits)1229 static void build_hlg_degamma(struct pwl_float_data_ex *degamma, 1230 uint32_t hw_points_num, 1231 const struct hw_x_point *coordinate_x, 1232 uint32_t sdr_white_level, uint32_t max_luminance_nits) 1233 { 1234 uint32_t i; 1235 1236 struct pwl_float_data_ex *rgb = degamma; 1237 const struct hw_x_point *coord_x = coordinate_x; 1238 1239 i = 0; 1240 // check when i == 434 1241 while (i != hw_points_num + 1) { 1242 compute_hlg_eotf(coord_x->x, &rgb->r, sdr_white_level, max_luminance_nits); 1243 rgb->g = rgb->r; 1244 rgb->b = rgb->r; 1245 ++coord_x; 1246 ++rgb; 1247 ++i; 1248 } 1249 } 1250 1251 build_hlg_regamma(struct pwl_float_data_ex * regamma,uint32_t hw_points_num,const struct hw_x_point * coordinate_x,uint32_t sdr_white_level,uint32_t max_luminance_nits)1252 static void build_hlg_regamma(struct pwl_float_data_ex *regamma, 1253 uint32_t hw_points_num, 1254 const struct hw_x_point *coordinate_x, 1255 uint32_t sdr_white_level, uint32_t max_luminance_nits) 1256 { 1257 uint32_t i; 1258 1259 struct pwl_float_data_ex *rgb = regamma; 1260 const struct hw_x_point *coord_x = coordinate_x; 1261 1262 i = 0; 1263 1264 // when i == 471 1265 while (i != hw_points_num + 1) { 1266 compute_hlg_oetf(coord_x->x, &rgb->r, sdr_white_level, max_luminance_nits); 1267 rgb->g = rgb->r; 1268 rgb->b = rgb->r; 1269 ++coord_x; 1270 ++rgb; 1271 ++i; 1272 } 1273 } 1274 scale_gamma(struct pwl_float_data * pwl_rgb,const struct dc_gamma * ramp,struct dividers dividers)1275 static void scale_gamma(struct pwl_float_data *pwl_rgb, 1276 const struct dc_gamma *ramp, 1277 struct dividers dividers) 1278 { 1279 const struct fixed31_32 max_driver = dc_fixpt_from_int(0xFFFF); 1280 const struct fixed31_32 max_os = dc_fixpt_from_int(0xFF00); 1281 struct fixed31_32 scaler = max_os; 1282 uint32_t i; 1283 struct pwl_float_data *rgb = pwl_rgb; 1284 struct pwl_float_data *rgb_last = rgb + ramp->num_entries - 1; 1285 1286 i = 0; 1287 1288 do { 1289 if (dc_fixpt_lt(max_os, ramp->entries.red[i]) || 1290 dc_fixpt_lt(max_os, ramp->entries.green[i]) || 1291 dc_fixpt_lt(max_os, ramp->entries.blue[i])) { 1292 scaler = max_driver; 1293 break; 1294 } 1295 ++i; 1296 } while (i != ramp->num_entries); 1297 1298 i = 0; 1299 1300 do { 1301 rgb->r = dc_fixpt_div( 1302 ramp->entries.red[i], scaler); 1303 rgb->g = dc_fixpt_div( 1304 ramp->entries.green[i], scaler); 1305 rgb->b = dc_fixpt_div( 1306 ramp->entries.blue[i], scaler); 1307 1308 ++rgb; 1309 ++i; 1310 } while (i != ramp->num_entries); 1311 1312 rgb->r = dc_fixpt_mul(rgb_last->r, 1313 dividers.divider1); 1314 rgb->g = dc_fixpt_mul(rgb_last->g, 1315 dividers.divider1); 1316 rgb->b = dc_fixpt_mul(rgb_last->b, 1317 dividers.divider1); 1318 1319 ++rgb; 1320 1321 rgb->r = dc_fixpt_mul(rgb_last->r, 1322 dividers.divider2); 1323 rgb->g = dc_fixpt_mul(rgb_last->g, 1324 dividers.divider2); 1325 rgb->b = dc_fixpt_mul(rgb_last->b, 1326 dividers.divider2); 1327 1328 ++rgb; 1329 1330 rgb->r = dc_fixpt_mul(rgb_last->r, 1331 dividers.divider3); 1332 rgb->g = dc_fixpt_mul(rgb_last->g, 1333 dividers.divider3); 1334 rgb->b = dc_fixpt_mul(rgb_last->b, 1335 dividers.divider3); 1336 } 1337 scale_gamma_dx(struct pwl_float_data * pwl_rgb,const struct dc_gamma * ramp,struct dividers dividers)1338 static void scale_gamma_dx(struct pwl_float_data *pwl_rgb, 1339 const struct dc_gamma *ramp, 1340 struct dividers dividers) 1341 { 1342 uint32_t i; 1343 struct fixed31_32 min = dc_fixpt_zero; 1344 struct fixed31_32 max = dc_fixpt_one; 1345 1346 struct fixed31_32 delta = dc_fixpt_zero; 1347 struct fixed31_32 offset = dc_fixpt_zero; 1348 1349 for (i = 0 ; i < ramp->num_entries; i++) { 1350 if (dc_fixpt_lt(ramp->entries.red[i], min)) 1351 min = ramp->entries.red[i]; 1352 1353 if (dc_fixpt_lt(ramp->entries.green[i], min)) 1354 min = ramp->entries.green[i]; 1355 1356 if (dc_fixpt_lt(ramp->entries.blue[i], min)) 1357 min = ramp->entries.blue[i]; 1358 1359 if (dc_fixpt_lt(max, ramp->entries.red[i])) 1360 max = ramp->entries.red[i]; 1361 1362 if (dc_fixpt_lt(max, ramp->entries.green[i])) 1363 max = ramp->entries.green[i]; 1364 1365 if (dc_fixpt_lt(max, ramp->entries.blue[i])) 1366 max = ramp->entries.blue[i]; 1367 } 1368 1369 if (dc_fixpt_lt(min, dc_fixpt_zero)) 1370 delta = dc_fixpt_neg(min); 1371 1372 offset = dc_fixpt_add(min, max); 1373 1374 for (i = 0 ; i < ramp->num_entries; i++) { 1375 pwl_rgb[i].r = dc_fixpt_div( 1376 dc_fixpt_add( 1377 ramp->entries.red[i], delta), offset); 1378 pwl_rgb[i].g = dc_fixpt_div( 1379 dc_fixpt_add( 1380 ramp->entries.green[i], delta), offset); 1381 pwl_rgb[i].b = dc_fixpt_div( 1382 dc_fixpt_add( 1383 ramp->entries.blue[i], delta), offset); 1384 1385 } 1386 1387 pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int( 1388 pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r); 1389 pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int( 1390 pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g); 1391 pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int( 1392 pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b); 1393 ++i; 1394 pwl_rgb[i].r = dc_fixpt_sub(dc_fixpt_mul_int( 1395 pwl_rgb[i-1].r, 2), pwl_rgb[i-2].r); 1396 pwl_rgb[i].g = dc_fixpt_sub(dc_fixpt_mul_int( 1397 pwl_rgb[i-1].g, 2), pwl_rgb[i-2].g); 1398 pwl_rgb[i].b = dc_fixpt_sub(dc_fixpt_mul_int( 1399 pwl_rgb[i-1].b, 2), pwl_rgb[i-2].b); 1400 } 1401 1402 /* todo: all these scale_gamma functions are inherently the same but 1403 * take different structures as params or different format for ramp 1404 * values. We could probably implement it in a more generic fashion 1405 */ scale_user_regamma_ramp(struct pwl_float_data * pwl_rgb,const struct regamma_ramp * ramp,struct dividers dividers)1406 static void scale_user_regamma_ramp(struct pwl_float_data *pwl_rgb, 1407 const struct regamma_ramp *ramp, 1408 struct dividers dividers) 1409 { 1410 unsigned short max_driver = 0xFFFF; 1411 unsigned short max_os = 0xFF00; 1412 unsigned short scaler = max_os; 1413 uint32_t i; 1414 struct pwl_float_data *rgb = pwl_rgb; 1415 struct pwl_float_data *rgb_last = rgb + GAMMA_RGB_256_ENTRIES - 1; 1416 1417 i = 0; 1418 do { 1419 if (ramp->gamma[i] > max_os || 1420 ramp->gamma[i + 256] > max_os || 1421 ramp->gamma[i + 512] > max_os) { 1422 scaler = max_driver; 1423 break; 1424 } 1425 i++; 1426 } while (i != GAMMA_RGB_256_ENTRIES); 1427 1428 i = 0; 1429 do { 1430 rgb->r = dc_fixpt_from_fraction( 1431 ramp->gamma[i], scaler); 1432 rgb->g = dc_fixpt_from_fraction( 1433 ramp->gamma[i + 256], scaler); 1434 rgb->b = dc_fixpt_from_fraction( 1435 ramp->gamma[i + 512], scaler); 1436 1437 ++rgb; 1438 ++i; 1439 } while (i != GAMMA_RGB_256_ENTRIES); 1440 1441 rgb->r = dc_fixpt_mul(rgb_last->r, 1442 dividers.divider1); 1443 rgb->g = dc_fixpt_mul(rgb_last->g, 1444 dividers.divider1); 1445 rgb->b = dc_fixpt_mul(rgb_last->b, 1446 dividers.divider1); 1447 1448 ++rgb; 1449 1450 rgb->r = dc_fixpt_mul(rgb_last->r, 1451 dividers.divider2); 1452 rgb->g = dc_fixpt_mul(rgb_last->g, 1453 dividers.divider2); 1454 rgb->b = dc_fixpt_mul(rgb_last->b, 1455 dividers.divider2); 1456 1457 ++rgb; 1458 1459 rgb->r = dc_fixpt_mul(rgb_last->r, 1460 dividers.divider3); 1461 rgb->g = dc_fixpt_mul(rgb_last->g, 1462 dividers.divider3); 1463 rgb->b = dc_fixpt_mul(rgb_last->b, 1464 dividers.divider3); 1465 } 1466 1467 /* 1468 * RS3+ color transform DDI - 1D LUT adjustment is composed with regamma here 1469 * Input is evenly distributed in the output color space as specified in 1470 * SetTimings 1471 * 1472 * Interpolation details: 1473 * 1D LUT has 4096 values which give curve correction in 0-1 float range 1474 * for evenly spaced points in 0-1 range. lut1D[index] gives correction 1475 * for index/4095. 1476 * First we find index for which: 1477 * index/4095 < regamma_y < (index+1)/4095 => 1478 * index < 4095*regamma_y < index + 1 1479 * norm_y = 4095*regamma_y, and index is just truncating to nearest integer 1480 * lut1 = lut1D[index], lut2 = lut1D[index+1] 1481 * 1482 * adjustedY is then linearly interpolating regamma Y between lut1 and lut2 1483 * 1484 * Custom degamma on Linux uses the same interpolation math, so is handled here 1485 */ apply_lut_1d(const struct dc_gamma * ramp,uint32_t num_hw_points,struct dc_transfer_func_distributed_points * tf_pts)1486 static void apply_lut_1d( 1487 const struct dc_gamma *ramp, 1488 uint32_t num_hw_points, 1489 struct dc_transfer_func_distributed_points *tf_pts) 1490 { 1491 int i = 0; 1492 int color = 0; 1493 struct fixed31_32 *regamma_y; 1494 struct fixed31_32 norm_y; 1495 struct fixed31_32 lut1; 1496 struct fixed31_32 lut2; 1497 const int max_lut_index = 4095; 1498 const struct fixed31_32 penult_lut_index_f = 1499 dc_fixpt_from_int(max_lut_index-1); 1500 const struct fixed31_32 max_lut_index_f = 1501 dc_fixpt_from_int(max_lut_index); 1502 int32_t index = 0, index_next = 0; 1503 struct fixed31_32 index_f; 1504 struct fixed31_32 delta_lut; 1505 struct fixed31_32 delta_index; 1506 1507 if (ramp->type != GAMMA_CS_TFM_1D && ramp->type != GAMMA_CUSTOM) 1508 return; // this is not expected 1509 1510 for (i = 0; i < num_hw_points; i++) { 1511 for (color = 0; color < 3; color++) { 1512 if (color == 0) 1513 regamma_y = &tf_pts->red[i]; 1514 else if (color == 1) 1515 regamma_y = &tf_pts->green[i]; 1516 else 1517 regamma_y = &tf_pts->blue[i]; 1518 1519 norm_y = dc_fixpt_mul(max_lut_index_f, 1520 *regamma_y); 1521 index = dc_fixpt_floor(norm_y); 1522 index_f = dc_fixpt_from_int(index); 1523 1524 if (index < 0) 1525 continue; 1526 1527 if (index <= max_lut_index) 1528 index_next = (index == max_lut_index) ? index : index+1; 1529 else { 1530 /* Here we are dealing with the last point in the curve, 1531 * which in some cases might exceed the range given by 1532 * max_lut_index. So we interpolate the value using 1533 * max_lut_index and max_lut_index - 1. 1534 */ 1535 index = max_lut_index - 1; 1536 index_next = max_lut_index; 1537 index_f = penult_lut_index_f; 1538 } 1539 1540 if (color == 0) { 1541 lut1 = ramp->entries.red[index]; 1542 lut2 = ramp->entries.red[index_next]; 1543 } else if (color == 1) { 1544 lut1 = ramp->entries.green[index]; 1545 lut2 = ramp->entries.green[index_next]; 1546 } else { 1547 lut1 = ramp->entries.blue[index]; 1548 lut2 = ramp->entries.blue[index_next]; 1549 } 1550 1551 // we have everything now, so interpolate 1552 delta_lut = dc_fixpt_sub(lut2, lut1); 1553 delta_index = dc_fixpt_sub(norm_y, index_f); 1554 1555 *regamma_y = dc_fixpt_add(lut1, 1556 dc_fixpt_mul(delta_index, delta_lut)); 1557 } 1558 } 1559 } 1560 build_evenly_distributed_points(struct gamma_pixel * points,uint32_t numberof_points,struct dividers dividers)1561 static void build_evenly_distributed_points( 1562 struct gamma_pixel *points, 1563 uint32_t numberof_points, 1564 struct dividers dividers) 1565 { 1566 struct gamma_pixel *p = points; 1567 struct gamma_pixel *p_last; 1568 1569 uint32_t i = 0; 1570 1571 // This function should not gets called with 0 as a parameter 1572 ASSERT(numberof_points > 0); 1573 p_last = p + numberof_points - 1; 1574 1575 do { 1576 struct fixed31_32 value = dc_fixpt_from_fraction(i, 1577 numberof_points - 1); 1578 1579 p->r = value; 1580 p->g = value; 1581 p->b = value; 1582 1583 ++p; 1584 ++i; 1585 } while (i < numberof_points); 1586 1587 p->r = dc_fixpt_div(p_last->r, dividers.divider1); 1588 p->g = dc_fixpt_div(p_last->g, dividers.divider1); 1589 p->b = dc_fixpt_div(p_last->b, dividers.divider1); 1590 1591 ++p; 1592 1593 p->r = dc_fixpt_div(p_last->r, dividers.divider2); 1594 p->g = dc_fixpt_div(p_last->g, dividers.divider2); 1595 p->b = dc_fixpt_div(p_last->b, dividers.divider2); 1596 1597 ++p; 1598 1599 p->r = dc_fixpt_div(p_last->r, dividers.divider3); 1600 p->g = dc_fixpt_div(p_last->g, dividers.divider3); 1601 p->b = dc_fixpt_div(p_last->b, dividers.divider3); 1602 } 1603 copy_rgb_regamma_to_coordinates_x(struct hw_x_point * coordinates_x,uint32_t hw_points_num,const struct pwl_float_data_ex * rgb_ex)1604 static inline void copy_rgb_regamma_to_coordinates_x( 1605 struct hw_x_point *coordinates_x, 1606 uint32_t hw_points_num, 1607 const struct pwl_float_data_ex *rgb_ex) 1608 { 1609 struct hw_x_point *coords = coordinates_x; 1610 uint32_t i = 0; 1611 const struct pwl_float_data_ex *rgb_regamma = rgb_ex; 1612 1613 while (i <= hw_points_num + 1) { 1614 coords->regamma_y_red = rgb_regamma->r; 1615 coords->regamma_y_green = rgb_regamma->g; 1616 coords->regamma_y_blue = rgb_regamma->b; 1617 1618 ++coords; 1619 ++rgb_regamma; 1620 ++i; 1621 } 1622 } 1623 calculate_interpolated_hardware_curve(const struct dc_gamma * ramp,struct pixel_gamma_point * coeff128,struct pwl_float_data * rgb_user,const struct hw_x_point * coordinates_x,const struct gamma_pixel * axis_x,uint32_t number_of_points,struct dc_transfer_func_distributed_points * tf_pts)1624 static bool calculate_interpolated_hardware_curve( 1625 const struct dc_gamma *ramp, 1626 struct pixel_gamma_point *coeff128, 1627 struct pwl_float_data *rgb_user, 1628 const struct hw_x_point *coordinates_x, 1629 const struct gamma_pixel *axis_x, 1630 uint32_t number_of_points, 1631 struct dc_transfer_func_distributed_points *tf_pts) 1632 { 1633 1634 const struct pixel_gamma_point *coeff = coeff128; 1635 uint32_t max_entries = 3 - 1; 1636 1637 uint32_t i = 0; 1638 1639 for (i = 0; i < 3; i++) { 1640 if (!build_custom_gamma_mapping_coefficients_worker( 1641 ramp, coeff128, coordinates_x, axis_x, i, 1642 number_of_points)) 1643 return false; 1644 } 1645 1646 i = 0; 1647 max_entries += ramp->num_entries; 1648 1649 /* TODO: float point case */ 1650 1651 while (i <= number_of_points) { 1652 tf_pts->red[i] = calculate_mapped_value( 1653 rgb_user, coeff, CHANNEL_NAME_RED, max_entries); 1654 tf_pts->green[i] = calculate_mapped_value( 1655 rgb_user, coeff, CHANNEL_NAME_GREEN, max_entries); 1656 tf_pts->blue[i] = calculate_mapped_value( 1657 rgb_user, coeff, CHANNEL_NAME_BLUE, max_entries); 1658 1659 ++coeff; 1660 ++i; 1661 } 1662 1663 return true; 1664 } 1665 1666 /* The "old" interpolation uses a complicated scheme to build an array of 1667 * coefficients while also using an array of 0-255 normalized to 0-1 1668 * Then there's another loop using both of the above + new scaled user ramp 1669 * and we concatenate them. It also searches for points of interpolation and 1670 * uses enums for positions. 1671 * 1672 * This function uses a different approach: 1673 * user ramp is always applied on X with 0/255, 1/255, 2/255, ..., 255/255 1674 * To find index for hwX , we notice the following: 1675 * i/255 <= hwX < (i+1)/255 <=> i <= 255*hwX < i+1 1676 * See apply_lut_1d which is the same principle, but on 4K entry 1D LUT 1677 * 1678 * Once the index is known, combined Y is simply: 1679 * user_ramp(index) + (hwX-index/255)*(user_ramp(index+1) - user_ramp(index) 1680 * 1681 * We should switch to this method in all cases, it's simpler and faster 1682 * ToDo one day - for now this only applies to ADL regamma to avoid regression 1683 * for regular use cases (sRGB and PQ) 1684 */ interpolate_user_regamma(uint32_t hw_points_num,struct pwl_float_data * rgb_user,bool apply_degamma,struct dc_transfer_func_distributed_points * tf_pts)1685 static void interpolate_user_regamma(uint32_t hw_points_num, 1686 struct pwl_float_data *rgb_user, 1687 bool apply_degamma, 1688 struct dc_transfer_func_distributed_points *tf_pts) 1689 { 1690 uint32_t i; 1691 uint32_t color = 0; 1692 int32_t index; 1693 int32_t index_next; 1694 struct fixed31_32 *tf_point; 1695 struct fixed31_32 hw_x; 1696 struct fixed31_32 norm_factor = 1697 dc_fixpt_from_int(255); 1698 struct fixed31_32 norm_x; 1699 struct fixed31_32 index_f; 1700 struct fixed31_32 lut1; 1701 struct fixed31_32 lut2; 1702 struct fixed31_32 delta_lut; 1703 struct fixed31_32 delta_index; 1704 const struct fixed31_32 one = dc_fixpt_from_int(1); 1705 1706 i = 0; 1707 /* fixed_pt library has problems handling too small values */ 1708 while (i != 32) { 1709 tf_pts->red[i] = dc_fixpt_zero; 1710 tf_pts->green[i] = dc_fixpt_zero; 1711 tf_pts->blue[i] = dc_fixpt_zero; 1712 ++i; 1713 } 1714 while (i <= hw_points_num + 1) { 1715 for (color = 0; color < 3; color++) { 1716 if (color == 0) 1717 tf_point = &tf_pts->red[i]; 1718 else if (color == 1) 1719 tf_point = &tf_pts->green[i]; 1720 else 1721 tf_point = &tf_pts->blue[i]; 1722 1723 if (apply_degamma) { 1724 if (color == 0) 1725 hw_x = coordinates_x[i].regamma_y_red; 1726 else if (color == 1) 1727 hw_x = coordinates_x[i].regamma_y_green; 1728 else 1729 hw_x = coordinates_x[i].regamma_y_blue; 1730 } else 1731 hw_x = coordinates_x[i].x; 1732 1733 if (dc_fixpt_le(one, hw_x)) 1734 hw_x = one; 1735 1736 norm_x = dc_fixpt_mul(norm_factor, hw_x); 1737 index = dc_fixpt_floor(norm_x); 1738 if (index < 0 || index > 255) 1739 continue; 1740 1741 index_f = dc_fixpt_from_int(index); 1742 index_next = (index == 255) ? index : index + 1; 1743 1744 if (color == 0) { 1745 lut1 = rgb_user[index].r; 1746 lut2 = rgb_user[index_next].r; 1747 } else if (color == 1) { 1748 lut1 = rgb_user[index].g; 1749 lut2 = rgb_user[index_next].g; 1750 } else { 1751 lut1 = rgb_user[index].b; 1752 lut2 = rgb_user[index_next].b; 1753 } 1754 1755 // we have everything now, so interpolate 1756 delta_lut = dc_fixpt_sub(lut2, lut1); 1757 delta_index = dc_fixpt_sub(norm_x, index_f); 1758 1759 *tf_point = dc_fixpt_add(lut1, 1760 dc_fixpt_mul(delta_index, delta_lut)); 1761 } 1762 ++i; 1763 } 1764 } 1765 build_new_custom_resulted_curve(uint32_t hw_points_num,struct dc_transfer_func_distributed_points * tf_pts)1766 static void build_new_custom_resulted_curve( 1767 uint32_t hw_points_num, 1768 struct dc_transfer_func_distributed_points *tf_pts) 1769 { 1770 uint32_t i = 0; 1771 1772 while (i != hw_points_num + 1) { 1773 tf_pts->red[i] = dc_fixpt_clamp( 1774 tf_pts->red[i], dc_fixpt_zero, 1775 dc_fixpt_one); 1776 tf_pts->green[i] = dc_fixpt_clamp( 1777 tf_pts->green[i], dc_fixpt_zero, 1778 dc_fixpt_one); 1779 tf_pts->blue[i] = dc_fixpt_clamp( 1780 tf_pts->blue[i], dc_fixpt_zero, 1781 dc_fixpt_one); 1782 1783 ++i; 1784 } 1785 } 1786 apply_degamma_for_user_regamma(struct pwl_float_data_ex * rgb_regamma,uint32_t hw_points_num,struct calculate_buffer * cal_buffer)1787 static void apply_degamma_for_user_regamma(struct pwl_float_data_ex *rgb_regamma, 1788 uint32_t hw_points_num, struct calculate_buffer *cal_buffer) 1789 { 1790 uint32_t i; 1791 1792 struct gamma_coefficients coeff; 1793 struct pwl_float_data_ex *rgb = rgb_regamma; 1794 const struct hw_x_point *coord_x = coordinates_x; 1795 1796 build_coefficients(&coeff, TRANSFER_FUNCTION_SRGB); 1797 1798 i = 0; 1799 while (i != hw_points_num + 1) { 1800 rgb->r = translate_from_linear_space_ex( 1801 coord_x->x, &coeff, 0, cal_buffer); 1802 rgb->g = rgb->r; 1803 rgb->b = rgb->r; 1804 ++coord_x; 1805 ++rgb; 1806 ++i; 1807 } 1808 } 1809 map_regamma_hw_to_x_user(const struct dc_gamma * ramp,struct pixel_gamma_point * coeff128,struct pwl_float_data * rgb_user,struct hw_x_point * coords_x,const struct gamma_pixel * axis_x,const struct pwl_float_data_ex * rgb_regamma,uint32_t hw_points_num,struct dc_transfer_func_distributed_points * tf_pts,bool map_user_ramp,bool do_clamping)1810 static bool map_regamma_hw_to_x_user( 1811 const struct dc_gamma *ramp, 1812 struct pixel_gamma_point *coeff128, 1813 struct pwl_float_data *rgb_user, 1814 struct hw_x_point *coords_x, 1815 const struct gamma_pixel *axis_x, 1816 const struct pwl_float_data_ex *rgb_regamma, 1817 uint32_t hw_points_num, 1818 struct dc_transfer_func_distributed_points *tf_pts, 1819 bool map_user_ramp, 1820 bool do_clamping) 1821 { 1822 /* setup to spare calculated ideal regamma values */ 1823 1824 int i = 0; 1825 struct hw_x_point *coords = coords_x; 1826 const struct pwl_float_data_ex *regamma = rgb_regamma; 1827 1828 if (ramp && map_user_ramp) { 1829 copy_rgb_regamma_to_coordinates_x(coords, 1830 hw_points_num, 1831 rgb_regamma); 1832 1833 calculate_interpolated_hardware_curve( 1834 ramp, coeff128, rgb_user, coords, axis_x, 1835 hw_points_num, tf_pts); 1836 } else { 1837 /* just copy current rgb_regamma into tf_pts */ 1838 while (i <= hw_points_num) { 1839 tf_pts->red[i] = regamma->r; 1840 tf_pts->green[i] = regamma->g; 1841 tf_pts->blue[i] = regamma->b; 1842 1843 ++regamma; 1844 ++i; 1845 } 1846 } 1847 1848 if (do_clamping) { 1849 /* this should be named differently, all it does is clamp to 0-1 */ 1850 build_new_custom_resulted_curve(hw_points_num, tf_pts); 1851 } 1852 1853 return true; 1854 } 1855 1856 #define _EXTRA_POINTS 3 1857 calculate_user_regamma_coeff(struct dc_transfer_func * output_tf,const struct regamma_lut * regamma,struct calculate_buffer * cal_buffer,const struct dc_gamma * ramp)1858 bool calculate_user_regamma_coeff(struct dc_transfer_func *output_tf, 1859 const struct regamma_lut *regamma, 1860 struct calculate_buffer *cal_buffer, 1861 const struct dc_gamma *ramp) 1862 { 1863 struct gamma_coefficients coeff; 1864 const struct hw_x_point *coord_x = coordinates_x; 1865 uint32_t i = 0; 1866 1867 do { 1868 coeff.a0[i] = dc_fixpt_from_fraction( 1869 regamma->coeff.A0[i], 10000000); 1870 coeff.a1[i] = dc_fixpt_from_fraction( 1871 regamma->coeff.A1[i], 1000); 1872 coeff.a2[i] = dc_fixpt_from_fraction( 1873 regamma->coeff.A2[i], 1000); 1874 coeff.a3[i] = dc_fixpt_from_fraction( 1875 regamma->coeff.A3[i], 1000); 1876 coeff.user_gamma[i] = dc_fixpt_from_fraction( 1877 regamma->coeff.gamma[i], 1000); 1878 1879 ++i; 1880 } while (i != 3); 1881 1882 i = 0; 1883 /* fixed_pt library has problems handling too small values */ 1884 while (i != 32) { 1885 output_tf->tf_pts.red[i] = dc_fixpt_zero; 1886 output_tf->tf_pts.green[i] = dc_fixpt_zero; 1887 output_tf->tf_pts.blue[i] = dc_fixpt_zero; 1888 ++coord_x; 1889 ++i; 1890 } 1891 while (i != MAX_HW_POINTS + 1) { 1892 output_tf->tf_pts.red[i] = translate_from_linear_space_ex( 1893 coord_x->x, &coeff, 0, cal_buffer); 1894 output_tf->tf_pts.green[i] = translate_from_linear_space_ex( 1895 coord_x->x, &coeff, 1, cal_buffer); 1896 output_tf->tf_pts.blue[i] = translate_from_linear_space_ex( 1897 coord_x->x, &coeff, 2, cal_buffer); 1898 ++coord_x; 1899 ++i; 1900 } 1901 1902 if (ramp && ramp->type == GAMMA_CS_TFM_1D) 1903 apply_lut_1d(ramp, MAX_HW_POINTS, &output_tf->tf_pts); 1904 1905 // this function just clamps output to 0-1 1906 build_new_custom_resulted_curve(MAX_HW_POINTS, &output_tf->tf_pts); 1907 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS; 1908 1909 return true; 1910 } 1911 calculate_user_regamma_ramp(struct dc_transfer_func * output_tf,const struct regamma_lut * regamma,struct calculate_buffer * cal_buffer,const struct dc_gamma * ramp)1912 bool calculate_user_regamma_ramp(struct dc_transfer_func *output_tf, 1913 const struct regamma_lut *regamma, 1914 struct calculate_buffer *cal_buffer, 1915 const struct dc_gamma *ramp) 1916 { 1917 struct dc_transfer_func_distributed_points *tf_pts = &output_tf->tf_pts; 1918 struct dividers dividers; 1919 1920 struct pwl_float_data *rgb_user = NULL; 1921 struct pwl_float_data_ex *rgb_regamma = NULL; 1922 bool ret = false; 1923 1924 if (regamma == NULL) 1925 return false; 1926 1927 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS; 1928 1929 rgb_user = kcalloc(GAMMA_RGB_256_ENTRIES + _EXTRA_POINTS, 1930 sizeof(*rgb_user), 1931 GFP_KERNEL); 1932 if (!rgb_user) 1933 goto rgb_user_alloc_fail; 1934 1935 rgb_regamma = kcalloc(MAX_HW_POINTS + _EXTRA_POINTS, 1936 sizeof(*rgb_regamma), 1937 GFP_KERNEL); 1938 if (!rgb_regamma) 1939 goto rgb_regamma_alloc_fail; 1940 1941 dividers.divider1 = dc_fixpt_from_fraction(3, 2); 1942 dividers.divider2 = dc_fixpt_from_int(2); 1943 dividers.divider3 = dc_fixpt_from_fraction(5, 2); 1944 1945 scale_user_regamma_ramp(rgb_user, ®amma->ramp, dividers); 1946 1947 if (regamma->flags.bits.applyDegamma == 1) { 1948 apply_degamma_for_user_regamma(rgb_regamma, MAX_HW_POINTS, cal_buffer); 1949 copy_rgb_regamma_to_coordinates_x(coordinates_x, 1950 MAX_HW_POINTS, rgb_regamma); 1951 } 1952 1953 interpolate_user_regamma(MAX_HW_POINTS, rgb_user, 1954 regamma->flags.bits.applyDegamma, tf_pts); 1955 1956 // no custom HDR curves! 1957 tf_pts->end_exponent = 0; 1958 tf_pts->x_point_at_y1_red = 1; 1959 tf_pts->x_point_at_y1_green = 1; 1960 tf_pts->x_point_at_y1_blue = 1; 1961 1962 if (ramp && ramp->type == GAMMA_CS_TFM_1D) 1963 apply_lut_1d(ramp, MAX_HW_POINTS, &output_tf->tf_pts); 1964 1965 // this function just clamps output to 0-1 1966 build_new_custom_resulted_curve(MAX_HW_POINTS, tf_pts); 1967 1968 ret = true; 1969 1970 kfree(rgb_regamma); 1971 rgb_regamma_alloc_fail: 1972 kfree(rgb_user); 1973 rgb_user_alloc_fail: 1974 return ret; 1975 } 1976 mod_color_calculate_degamma_params(struct dc_color_caps * dc_caps,struct dc_transfer_func * input_tf,const struct dc_gamma * ramp,bool map_user_ramp)1977 bool mod_color_calculate_degamma_params(struct dc_color_caps *dc_caps, 1978 struct dc_transfer_func *input_tf, 1979 const struct dc_gamma *ramp, bool map_user_ramp) 1980 { 1981 struct dc_transfer_func_distributed_points *tf_pts = &input_tf->tf_pts; 1982 struct dividers dividers; 1983 struct pwl_float_data *rgb_user = NULL; 1984 struct pwl_float_data_ex *curve = NULL; 1985 struct gamma_pixel *axis_x = NULL; 1986 struct pixel_gamma_point *coeff = NULL; 1987 enum dc_transfer_func_predefined tf; 1988 uint32_t i; 1989 bool ret = false; 1990 1991 if (input_tf->type == TF_TYPE_BYPASS) 1992 return false; 1993 1994 /* we can use hardcoded curve for plain SRGB TF 1995 * If linear, it's bypass if no user ramp 1996 */ 1997 if (input_tf->type == TF_TYPE_PREDEFINED) { 1998 if ((input_tf->tf == TRANSFER_FUNCTION_SRGB || 1999 input_tf->tf == TRANSFER_FUNCTION_LINEAR) && 2000 !map_user_ramp) 2001 return true; 2002 2003 if (dc_caps != NULL && 2004 dc_caps->dpp.dcn_arch == 1) { 2005 2006 if (input_tf->tf == TRANSFER_FUNCTION_PQ && 2007 dc_caps->dpp.dgam_rom_caps.pq == 1) 2008 return true; 2009 2010 if (input_tf->tf == TRANSFER_FUNCTION_GAMMA22 && 2011 dc_caps->dpp.dgam_rom_caps.gamma2_2 == 1) 2012 return true; 2013 2014 // HLG OOTF not accounted for 2015 if (input_tf->tf == TRANSFER_FUNCTION_HLG && 2016 dc_caps->dpp.dgam_rom_caps.hlg == 1) 2017 return true; 2018 } 2019 } 2020 2021 input_tf->type = TF_TYPE_DISTRIBUTED_POINTS; 2022 2023 if (map_user_ramp && ramp && ramp->type == GAMMA_RGB_256) { 2024 rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS, 2025 sizeof(*rgb_user), 2026 GFP_KERNEL); 2027 if (!rgb_user) 2028 goto rgb_user_alloc_fail; 2029 2030 axis_x = kvcalloc(ramp->num_entries + _EXTRA_POINTS, sizeof(*axis_x), 2031 GFP_KERNEL); 2032 if (!axis_x) 2033 goto axis_x_alloc_fail; 2034 2035 dividers.divider1 = dc_fixpt_from_fraction(3, 2); 2036 dividers.divider2 = dc_fixpt_from_int(2); 2037 dividers.divider3 = dc_fixpt_from_fraction(5, 2); 2038 2039 build_evenly_distributed_points( 2040 axis_x, 2041 ramp->num_entries, 2042 dividers); 2043 2044 scale_gamma(rgb_user, ramp, dividers); 2045 } 2046 2047 curve = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*curve), 2048 GFP_KERNEL); 2049 if (!curve) 2050 goto curve_alloc_fail; 2051 2052 coeff = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*coeff), 2053 GFP_KERNEL); 2054 if (!coeff) 2055 goto coeff_alloc_fail; 2056 2057 tf = input_tf->tf; 2058 2059 if (tf == TRANSFER_FUNCTION_PQ) 2060 build_de_pq(curve, 2061 MAX_HW_POINTS, 2062 coordinates_x); 2063 else if (tf == TRANSFER_FUNCTION_SRGB || 2064 tf == TRANSFER_FUNCTION_BT709 || 2065 tf == TRANSFER_FUNCTION_GAMMA22 || 2066 tf == TRANSFER_FUNCTION_GAMMA24 || 2067 tf == TRANSFER_FUNCTION_GAMMA26) 2068 build_degamma(curve, 2069 MAX_HW_POINTS, 2070 coordinates_x, 2071 tf); 2072 else if (tf == TRANSFER_FUNCTION_HLG) 2073 build_hlg_degamma(curve, 2074 MAX_HW_POINTS, 2075 coordinates_x, 2076 80, 1000); 2077 else if (tf == TRANSFER_FUNCTION_LINEAR) { 2078 // just copy coordinates_x into curve 2079 i = 0; 2080 while (i != MAX_HW_POINTS + 1) { 2081 curve[i].r = coordinates_x[i].x; 2082 curve[i].g = curve[i].r; 2083 curve[i].b = curve[i].r; 2084 i++; 2085 } 2086 } else 2087 goto invalid_tf_fail; 2088 2089 tf_pts->end_exponent = 0; 2090 tf_pts->x_point_at_y1_red = 1; 2091 tf_pts->x_point_at_y1_green = 1; 2092 tf_pts->x_point_at_y1_blue = 1; 2093 2094 if (input_tf->tf == TRANSFER_FUNCTION_PQ) { 2095 /* just copy current rgb_regamma into tf_pts */ 2096 struct pwl_float_data_ex *curvePt = curve; 2097 int i = 0; 2098 2099 while (i <= MAX_HW_POINTS) { 2100 tf_pts->red[i] = curvePt->r; 2101 tf_pts->green[i] = curvePt->g; 2102 tf_pts->blue[i] = curvePt->b; 2103 ++curvePt; 2104 ++i; 2105 } 2106 } else { 2107 // clamps to 0-1 2108 map_regamma_hw_to_x_user(ramp, coeff, rgb_user, 2109 coordinates_x, axis_x, curve, 2110 MAX_HW_POINTS, tf_pts, 2111 map_user_ramp && ramp && ramp->type == GAMMA_RGB_256, 2112 true); 2113 } 2114 2115 2116 2117 if (ramp && ramp->type == GAMMA_CUSTOM) 2118 apply_lut_1d(ramp, MAX_HW_POINTS, tf_pts); 2119 2120 ret = true; 2121 2122 invalid_tf_fail: 2123 kvfree(coeff); 2124 coeff_alloc_fail: 2125 kvfree(curve); 2126 curve_alloc_fail: 2127 kvfree(axis_x); 2128 axis_x_alloc_fail: 2129 kvfree(rgb_user); 2130 rgb_user_alloc_fail: 2131 2132 return ret; 2133 } 2134 calculate_curve(enum dc_transfer_func_predefined trans,struct dc_transfer_func_distributed_points * points,struct pwl_float_data_ex * rgb_regamma,const struct hdr_tm_params * fs_params,uint32_t sdr_ref_white_level,struct calculate_buffer * cal_buffer)2135 static bool calculate_curve(enum dc_transfer_func_predefined trans, 2136 struct dc_transfer_func_distributed_points *points, 2137 struct pwl_float_data_ex *rgb_regamma, 2138 const struct hdr_tm_params *fs_params, 2139 uint32_t sdr_ref_white_level, 2140 struct calculate_buffer *cal_buffer) 2141 { 2142 uint32_t i; 2143 bool ret = false; 2144 2145 if (trans == TRANSFER_FUNCTION_UNITY || 2146 trans == TRANSFER_FUNCTION_LINEAR) { 2147 points->end_exponent = 0; 2148 points->x_point_at_y1_red = 1; 2149 points->x_point_at_y1_green = 1; 2150 points->x_point_at_y1_blue = 1; 2151 2152 for (i = 0; i <= MAX_HW_POINTS ; i++) { 2153 rgb_regamma[i].r = coordinates_x[i].x; 2154 rgb_regamma[i].g = coordinates_x[i].x; 2155 rgb_regamma[i].b = coordinates_x[i].x; 2156 } 2157 2158 ret = true; 2159 } else if (trans == TRANSFER_FUNCTION_PQ) { 2160 points->end_exponent = 7; 2161 points->x_point_at_y1_red = 125; 2162 points->x_point_at_y1_green = 125; 2163 points->x_point_at_y1_blue = 125; 2164 2165 build_pq(rgb_regamma, 2166 MAX_HW_POINTS, 2167 coordinates_x, 2168 sdr_ref_white_level); 2169 2170 ret = true; 2171 } else if (trans == TRANSFER_FUNCTION_GAMMA22 && 2172 fs_params != NULL && fs_params->skip_tm == 0) { 2173 build_freesync_hdr(rgb_regamma, 2174 MAX_HW_POINTS, 2175 coordinates_x, 2176 fs_params, 2177 cal_buffer); 2178 2179 ret = true; 2180 } else if (trans == TRANSFER_FUNCTION_HLG) { 2181 points->end_exponent = 4; 2182 points->x_point_at_y1_red = 12; 2183 points->x_point_at_y1_green = 12; 2184 points->x_point_at_y1_blue = 12; 2185 2186 build_hlg_regamma(rgb_regamma, 2187 MAX_HW_POINTS, 2188 coordinates_x, 2189 80, 1000); 2190 2191 ret = true; 2192 } else { 2193 // trans == TRANSFER_FUNCTION_SRGB 2194 // trans == TRANSFER_FUNCTION_BT709 2195 // trans == TRANSFER_FUNCTION_GAMMA22 2196 // trans == TRANSFER_FUNCTION_GAMMA24 2197 // trans == TRANSFER_FUNCTION_GAMMA26 2198 points->end_exponent = 0; 2199 points->x_point_at_y1_red = 1; 2200 points->x_point_at_y1_green = 1; 2201 points->x_point_at_y1_blue = 1; 2202 2203 build_regamma(rgb_regamma, 2204 MAX_HW_POINTS, 2205 coordinates_x, 2206 trans, 2207 cal_buffer); 2208 2209 ret = true; 2210 } 2211 2212 return ret; 2213 } 2214 mod_color_calculate_regamma_params(struct dc_transfer_func * output_tf,const struct dc_gamma * ramp,bool map_user_ramp,bool can_rom_be_used,const struct hdr_tm_params * fs_params,struct calculate_buffer * cal_buffer)2215 bool mod_color_calculate_regamma_params(struct dc_transfer_func *output_tf, 2216 const struct dc_gamma *ramp, 2217 bool map_user_ramp, 2218 bool can_rom_be_used, 2219 const struct hdr_tm_params *fs_params, 2220 struct calculate_buffer *cal_buffer) 2221 { 2222 struct dc_transfer_func_distributed_points *tf_pts = &output_tf->tf_pts; 2223 struct dividers dividers; 2224 2225 struct pwl_float_data *rgb_user = NULL; 2226 struct pwl_float_data_ex *rgb_regamma = NULL; 2227 struct gamma_pixel *axis_x = NULL; 2228 struct pixel_gamma_point *coeff = NULL; 2229 enum dc_transfer_func_predefined tf; 2230 bool do_clamping = true; 2231 bool ret = false; 2232 2233 if (output_tf->type == TF_TYPE_BYPASS) 2234 return false; 2235 2236 /* we can use hardcoded curve for plain SRGB TF */ 2237 if (output_tf->type == TF_TYPE_PREDEFINED && can_rom_be_used == true && 2238 output_tf->tf == TRANSFER_FUNCTION_SRGB) { 2239 if (ramp == NULL) 2240 return true; 2241 if ((ramp->is_identity && ramp->type != GAMMA_CS_TFM_1D) || 2242 (!map_user_ramp && ramp->type == GAMMA_RGB_256)) 2243 return true; 2244 } 2245 2246 output_tf->type = TF_TYPE_DISTRIBUTED_POINTS; 2247 2248 if (ramp && ramp->type != GAMMA_CS_TFM_1D && 2249 (map_user_ramp || ramp->type != GAMMA_RGB_256)) { 2250 rgb_user = kvcalloc(ramp->num_entries + _EXTRA_POINTS, 2251 sizeof(*rgb_user), 2252 GFP_KERNEL); 2253 if (!rgb_user) 2254 goto rgb_user_alloc_fail; 2255 2256 axis_x = kvcalloc(ramp->num_entries + 3, sizeof(*axis_x), 2257 GFP_KERNEL); 2258 if (!axis_x) 2259 goto axis_x_alloc_fail; 2260 2261 dividers.divider1 = dc_fixpt_from_fraction(3, 2); 2262 dividers.divider2 = dc_fixpt_from_int(2); 2263 dividers.divider3 = dc_fixpt_from_fraction(5, 2); 2264 2265 build_evenly_distributed_points( 2266 axis_x, 2267 ramp->num_entries, 2268 dividers); 2269 2270 if (ramp->type == GAMMA_RGB_256 && map_user_ramp) 2271 scale_gamma(rgb_user, ramp, dividers); 2272 else if (ramp->type == GAMMA_RGB_FLOAT_1024) 2273 scale_gamma_dx(rgb_user, ramp, dividers); 2274 } 2275 2276 rgb_regamma = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, 2277 sizeof(*rgb_regamma), 2278 GFP_KERNEL); 2279 if (!rgb_regamma) 2280 goto rgb_regamma_alloc_fail; 2281 2282 coeff = kvcalloc(MAX_HW_POINTS + _EXTRA_POINTS, sizeof(*coeff), 2283 GFP_KERNEL); 2284 if (!coeff) 2285 goto coeff_alloc_fail; 2286 2287 tf = output_tf->tf; 2288 2289 ret = calculate_curve(tf, 2290 tf_pts, 2291 rgb_regamma, 2292 fs_params, 2293 output_tf->sdr_ref_white_level, 2294 cal_buffer); 2295 2296 if (ret) { 2297 do_clamping = !(output_tf->tf == TRANSFER_FUNCTION_PQ) && 2298 !(output_tf->tf == TRANSFER_FUNCTION_GAMMA22 && 2299 fs_params != NULL && fs_params->skip_tm == 0); 2300 2301 map_regamma_hw_to_x_user(ramp, coeff, rgb_user, 2302 coordinates_x, axis_x, rgb_regamma, 2303 MAX_HW_POINTS, tf_pts, 2304 (map_user_ramp || (ramp && ramp->type != GAMMA_RGB_256)) && 2305 (ramp && ramp->type != GAMMA_CS_TFM_1D), 2306 do_clamping); 2307 2308 if (ramp && ramp->type == GAMMA_CS_TFM_1D) 2309 apply_lut_1d(ramp, MAX_HW_POINTS, tf_pts); 2310 } 2311 2312 kvfree(coeff); 2313 coeff_alloc_fail: 2314 kvfree(rgb_regamma); 2315 rgb_regamma_alloc_fail: 2316 kvfree(axis_x); 2317 axis_x_alloc_fail: 2318 kvfree(rgb_user); 2319 rgb_user_alloc_fail: 2320 return ret; 2321 } 2322