1 // SPDX-License-Identifier: MIT 2 // 3 // Copyright 2024 Advanced Micro Devices, Inc. 4 5 #include "dc_spl.h" 6 #include "dc_spl_scl_filters.h" 7 #include "dc_spl_scl_easf_filters.h" 8 #include "dc_spl_isharp_filters.h" 9 #include "spl_debug.h" 10 11 #define IDENTITY_RATIO(ratio) (spl_fixpt_u2d19(ratio) == (1 << 19)) 12 #define MIN_VIEWPORT_SIZE 12 13 14 static struct spl_rect intersect_rec(const struct spl_rect *r0, const struct spl_rect *r1) 15 { 16 struct spl_rect rec; 17 int r0_x_end = r0->x + r0->width; 18 int r1_x_end = r1->x + r1->width; 19 int r0_y_end = r0->y + r0->height; 20 int r1_y_end = r1->y + r1->height; 21 22 rec.x = r0->x > r1->x ? r0->x : r1->x; 23 rec.width = r0_x_end > r1_x_end ? r1_x_end - rec.x : r0_x_end - rec.x; 24 rec.y = r0->y > r1->y ? r0->y : r1->y; 25 rec.height = r0_y_end > r1_y_end ? r1_y_end - rec.y : r0_y_end - rec.y; 26 27 /* in case that there is no intersection */ 28 if (rec.width < 0 || rec.height < 0) 29 memset(&rec, 0, sizeof(rec)); 30 31 return rec; 32 } 33 34 static struct spl_rect shift_rec(const struct spl_rect *rec_in, int x, int y) 35 { 36 struct spl_rect rec_out = *rec_in; 37 38 rec_out.x += x; 39 rec_out.y += y; 40 41 return rec_out; 42 } 43 44 static struct spl_rect calculate_plane_rec_in_timing_active( 45 struct spl_in *spl_in, 46 const struct spl_rect *rec_in) 47 { 48 /* 49 * The following diagram shows an example where we map a 1920x1200 50 * desktop to a 2560x1440 timing with a plane rect in the middle 51 * of the screen. To map a plane rect from Stream Source to Timing 52 * Active space, we first multiply stream scaling ratios (i.e 2304/1920 53 * horizontal and 1440/1200 vertical) to the plane's x and y, then 54 * we add stream destination offsets (i.e 128 horizontal, 0 vertical). 55 * This will give us a plane rect's position in Timing Active. However 56 * we have to remove the fractional. The rule is that we find left/right 57 * and top/bottom positions and round the value to the adjacent integer. 58 * 59 * Stream Source Space 60 * ------------ 61 * __________________________________________________ 62 * |Stream Source (1920 x 1200) ^ | 63 * | y | 64 * | <------- w --------|> | 65 * | __________________V | 66 * |<-- x -->|Plane//////////////| ^ | 67 * | |(pre scale)////////| | | 68 * | |///////////////////| | | 69 * | |///////////////////| h | 70 * | |///////////////////| | | 71 * | |///////////////////| | | 72 * | |///////////////////| V | 73 * | | 74 * | | 75 * |__________________________________________________| 76 * 77 * 78 * Timing Active Space 79 * --------------------------------- 80 * 81 * Timing Active (2560 x 1440) 82 * __________________________________________________ 83 * |*****| Stteam Destination (2304 x 1440) |*****| 84 * |*****| |*****| 85 * |<128>| |*****| 86 * |*****| __________________ |*****| 87 * |*****| |Plane/////////////| |*****| 88 * |*****| |(post scale)//////| |*****| 89 * |*****| |//////////////////| |*****| 90 * |*****| |//////////////////| |*****| 91 * |*****| |//////////////////| |*****| 92 * |*****| |//////////////////| |*****| 93 * |*****| |*****| 94 * |*****| |*****| 95 * |*****| |*****| 96 * |*****|______________________________________|*****| 97 * 98 * So the resulting formulas are shown below: 99 * 100 * recout_x = 128 + round(plane_x * 2304 / 1920) 101 * recout_w = 128 + round((plane_x + plane_w) * 2304 / 1920) - recout_x 102 * recout_y = 0 + round(plane_y * 1440 / 1280) 103 * recout_h = 0 + round((plane_y + plane_h) * 1440 / 1200) - recout_y 104 * 105 * NOTE: fixed point division is not error free. To reduce errors 106 * introduced by fixed point division, we divide only after 107 * multiplication is complete. 108 */ 109 const struct spl_rect *stream_src = &spl_in->basic_out.src_rect; 110 const struct spl_rect *stream_dst = &spl_in->basic_out.dst_rect; 111 struct spl_rect rec_out = {0}; 112 struct spl_fixed31_32 temp; 113 114 115 temp = spl_fixpt_from_fraction(rec_in->x * (long long)stream_dst->width, 116 stream_src->width); 117 rec_out.x = stream_dst->x + spl_fixpt_round(temp); 118 119 temp = spl_fixpt_from_fraction( 120 (rec_in->x + rec_in->width) * (long long)stream_dst->width, 121 stream_src->width); 122 rec_out.width = stream_dst->x + spl_fixpt_round(temp) - rec_out.x; 123 124 temp = spl_fixpt_from_fraction(rec_in->y * (long long)stream_dst->height, 125 stream_src->height); 126 rec_out.y = stream_dst->y + spl_fixpt_round(temp); 127 128 temp = spl_fixpt_from_fraction( 129 (rec_in->y + rec_in->height) * (long long)stream_dst->height, 130 stream_src->height); 131 rec_out.height = stream_dst->y + spl_fixpt_round(temp) - rec_out.y; 132 133 return rec_out; 134 } 135 136 static struct spl_rect calculate_mpc_slice_in_timing_active( 137 struct spl_in *spl_in, 138 struct spl_rect *plane_clip_rec) 139 { 140 int mpc_slice_count = spl_in->basic_in.mpc_combine_h; 141 int mpc_slice_idx = spl_in->basic_in.mpc_combine_v; 142 int epimo = mpc_slice_count - plane_clip_rec->width % mpc_slice_count - 1; 143 struct spl_rect mpc_rec; 144 145 mpc_rec.width = plane_clip_rec->width / mpc_slice_count; 146 mpc_rec.x = plane_clip_rec->x + mpc_rec.width * mpc_slice_idx; 147 mpc_rec.height = plane_clip_rec->height; 148 mpc_rec.y = plane_clip_rec->y; 149 SPL_ASSERT(mpc_slice_count == 1 || 150 spl_in->basic_out.view_format != SPL_VIEW_3D_SIDE_BY_SIDE || 151 mpc_rec.width % 2 == 0); 152 153 /* extra pixels in the division remainder need to go to pipes after 154 * the extra pixel index minus one(epimo) defined here as: 155 */ 156 if (mpc_slice_idx > epimo) { 157 mpc_rec.x += mpc_slice_idx - epimo - 1; 158 mpc_rec.width += 1; 159 } 160 161 if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM) { 162 SPL_ASSERT(mpc_rec.height % 2 == 0); 163 mpc_rec.height /= 2; 164 } 165 return mpc_rec; 166 } 167 168 static struct spl_rect calculate_odm_slice_in_timing_active(struct spl_in *spl_in) 169 { 170 int odm_slice_count = spl_in->basic_out.odm_combine_factor; 171 int odm_slice_idx = spl_in->odm_slice_index; 172 bool is_last_odm_slice = (odm_slice_idx + 1) == odm_slice_count; 173 int h_active = spl_in->basic_out.output_size.width; 174 int v_active = spl_in->basic_out.output_size.height; 175 int odm_slice_width; 176 struct spl_rect odm_rec; 177 178 if (spl_in->basic_out.odm_combine_factor > 0) { 179 odm_slice_width = h_active / odm_slice_count; 180 /* 181 * deprecated, caller must pass in odm slice rect i.e OPP input 182 * rect in timing active for the new interface. 183 */ 184 if (spl_in->basic_out.use_two_pixels_per_container && (odm_slice_width % 2)) 185 odm_slice_width++; 186 187 odm_rec.x = odm_slice_width * odm_slice_idx; 188 odm_rec.width = is_last_odm_slice ? 189 /* last slice width is the reminder of h_active */ 190 h_active - odm_slice_width * (odm_slice_count - 1) : 191 /* odm slice width is the floor of h_active / count */ 192 odm_slice_width; 193 odm_rec.y = 0; 194 odm_rec.height = v_active; 195 196 return odm_rec; 197 } 198 199 return spl_in->basic_out.odm_slice_rect; 200 } 201 202 static void spl_calculate_recout(struct spl_in *spl_in, struct spl_scratch *spl_scratch, struct spl_out *spl_out) 203 { 204 /* 205 * A plane clip represents the desired plane size and position in Stream 206 * Source Space. Stream Source is the destination where all planes are 207 * blended (i.e. positioned, scaled and overlaid). It is a canvas where 208 * all planes associated with the current stream are drawn together. 209 * After Stream Source is completed, we will further scale and 210 * reposition the entire canvas of the stream source to Stream 211 * Destination in Timing Active Space. This could be due to display 212 * overscan adjustment where we will need to rescale and reposition all 213 * the planes so they can fit into a TV with overscan or downscale 214 * upscale features such as GPU scaling or VSR. 215 * 216 * This two step blending is a virtual procedure in software. In 217 * hardware there is no such thing as Stream Source. all planes are 218 * blended once in Timing Active Space. Software virtualizes a Stream 219 * Source space to decouple the math complicity so scaling param 220 * calculation focuses on one step at a time. 221 * 222 * In the following two diagrams, user applied 10% overscan adjustment 223 * so the Stream Source needs to be scaled down a little before mapping 224 * to Timing Active Space. As a result the Plane Clip is also scaled 225 * down by the same ratio, Plane Clip position (i.e. x and y) with 226 * respect to Stream Source is also scaled down. To map it in Timing 227 * Active Space additional x and y offsets from Stream Destination are 228 * added to Plane Clip as well. 229 * 230 * Stream Source Space 231 * ------------ 232 * __________________________________________________ 233 * |Stream Source (3840 x 2160) ^ | 234 * | y | 235 * | | | 236 * | __________________V | 237 * |<-- x -->|Plane Clip/////////| | 238 * | |(pre scale)////////| | 239 * | |///////////////////| | 240 * | |///////////////////| | 241 * | |///////////////////| | 242 * | |///////////////////| | 243 * | |///////////////////| | 244 * | | 245 * | | 246 * |__________________________________________________| 247 * 248 * 249 * Timing Active Space (3840 x 2160) 250 * --------------------------------- 251 * 252 * Timing Active 253 * __________________________________________________ 254 * | y_____________________________________________ | 255 * |x |Stream Destination (3456 x 1944) | | 256 * | | | | 257 * | | __________________ | | 258 * | | |Plane Clip////////| | | 259 * | | |(post scale)//////| | | 260 * | | |//////////////////| | | 261 * | | |//////////////////| | | 262 * | | |//////////////////| | | 263 * | | |//////////////////| | | 264 * | | | | 265 * | | | | 266 * | |____________________________________________| | 267 * |__________________________________________________| 268 * 269 * 270 * In Timing Active Space a plane clip could be further sliced into 271 * pieces called MPC slices. Each Pipe Context is responsible for 272 * processing only one MPC slice so the plane processing workload can be 273 * distributed to multiple DPP Pipes. MPC slices could be blended 274 * together to a single ODM slice. Each ODM slice is responsible for 275 * processing a portion of Timing Active divided horizontally so the 276 * output pixel processing workload can be distributed to multiple OPP 277 * pipes. All ODM slices are mapped together in ODM block so all MPC 278 * slices belong to different ODM slices could be pieced together to 279 * form a single image in Timing Active. MPC slices must belong to 280 * single ODM slice. If an MPC slice goes across ODM slice boundary, it 281 * needs to be divided into two MPC slices one for each ODM slice. 282 * 283 * In the following diagram the output pixel processing workload is 284 * divided horizontally into two ODM slices one for each OPP blend tree. 285 * OPP0 blend tree is responsible for processing left half of Timing 286 * Active, while OPP2 blend tree is responsible for processing right 287 * half. 288 * 289 * The plane has two MPC slices. However since the right MPC slice goes 290 * across ODM boundary, two DPP pipes are needed one for each OPP blend 291 * tree. (i.e. DPP1 for OPP0 blend tree and DPP2 for OPP2 blend tree). 292 * 293 * Assuming that we have a Pipe Context associated with OPP0 and DPP1 294 * working on processing the plane in the diagram. We want to know the 295 * width and height of the shaded rectangle and its relative position 296 * with respect to the ODM slice0. This is called the recout of the pipe 297 * context. 298 * 299 * Planes can be at arbitrary size and position and there could be an 300 * arbitrary number of MPC and ODM slices. The algorithm needs to take 301 * all scenarios into account. 302 * 303 * Timing Active Space (3840 x 2160) 304 * --------------------------------- 305 * 306 * Timing Active 307 * __________________________________________________ 308 * |OPP0(ODM slice0)^ |OPP2(ODM slice1) | 309 * | y | | 310 * | | <- w -> | 311 * | _____V________|____ | 312 * | |DPP0 ^ |DPP1 |DPP2| | 313 * |<------ x |-----|->|/////| | | 314 * | | | |/////| | | 315 * | | h |/////| | | 316 * | | | |/////| | | 317 * | |_____V__|/////|____| | 318 * | | | 319 * | | | 320 * | | | 321 * |_________________________|________________________| 322 * 323 * 324 */ 325 struct spl_rect plane_clip; 326 struct spl_rect mpc_slice_of_plane_clip; 327 struct spl_rect odm_slice; 328 struct spl_rect overlapping_area; 329 330 plane_clip = calculate_plane_rec_in_timing_active(spl_in, 331 &spl_in->basic_in.clip_rect); 332 /* guard plane clip from drawing beyond stream dst here */ 333 plane_clip = intersect_rec(&plane_clip, 334 &spl_in->basic_out.dst_rect); 335 mpc_slice_of_plane_clip = calculate_mpc_slice_in_timing_active( 336 spl_in, &plane_clip); 337 odm_slice = calculate_odm_slice_in_timing_active(spl_in); 338 overlapping_area = intersect_rec(&mpc_slice_of_plane_clip, &odm_slice); 339 340 if (overlapping_area.height > 0 && 341 overlapping_area.width > 0) { 342 /* shift the overlapping area so it is with respect to current 343 * ODM slice's position 344 */ 345 spl_scratch->scl_data.recout = shift_rec( 346 &overlapping_area, 347 -odm_slice.x, -odm_slice.y); 348 spl_scratch->scl_data.recout.height -= 349 spl_in->debug.visual_confirm_base_offset; 350 spl_scratch->scl_data.recout.height -= 351 spl_in->debug.visual_confirm_dpp_offset; 352 } else 353 /* if there is no overlap, zero recout */ 354 memset(&spl_scratch->scl_data.recout, 0, 355 sizeof(struct spl_rect)); 356 } 357 358 /* Calculate scaling ratios */ 359 static void spl_calculate_scaling_ratios(struct spl_in *spl_in, 360 struct spl_scratch *spl_scratch, 361 struct spl_out *spl_out) 362 { 363 const int in_w = spl_in->basic_out.src_rect.width; 364 const int in_h = spl_in->basic_out.src_rect.height; 365 const int out_w = spl_in->basic_out.dst_rect.width; 366 const int out_h = spl_in->basic_out.dst_rect.height; 367 struct spl_rect surf_src = spl_in->basic_in.src_rect; 368 369 /*Swap surf_src height and width since scaling ratios are in recout rotation*/ 370 if (spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_90 || 371 spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_270) 372 spl_swap(surf_src.height, surf_src.width); 373 374 spl_scratch->scl_data.ratios.horz = spl_fixpt_from_fraction( 375 surf_src.width, 376 spl_in->basic_in.dst_rect.width); 377 spl_scratch->scl_data.ratios.vert = spl_fixpt_from_fraction( 378 surf_src.height, 379 spl_in->basic_in.dst_rect.height); 380 381 if (spl_in->basic_out.view_format == SPL_VIEW_3D_SIDE_BY_SIDE) 382 spl_scratch->scl_data.ratios.horz.value *= 2; 383 else if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM) 384 spl_scratch->scl_data.ratios.vert.value *= 2; 385 386 spl_scratch->scl_data.ratios.vert.value = spl_div64_s64( 387 spl_scratch->scl_data.ratios.vert.value * in_h, out_h); 388 spl_scratch->scl_data.ratios.horz.value = spl_div64_s64( 389 spl_scratch->scl_data.ratios.horz.value * in_w, out_w); 390 391 spl_scratch->scl_data.ratios.horz_c = spl_scratch->scl_data.ratios.horz; 392 spl_scratch->scl_data.ratios.vert_c = spl_scratch->scl_data.ratios.vert; 393 394 if (spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP8 395 || spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP10) { 396 spl_scratch->scl_data.ratios.horz_c.value /= 2; 397 spl_scratch->scl_data.ratios.vert_c.value /= 2; 398 } 399 spl_scratch->scl_data.ratios.horz = spl_fixpt_truncate( 400 spl_scratch->scl_data.ratios.horz, 19); 401 spl_scratch->scl_data.ratios.vert = spl_fixpt_truncate( 402 spl_scratch->scl_data.ratios.vert, 19); 403 spl_scratch->scl_data.ratios.horz_c = spl_fixpt_truncate( 404 spl_scratch->scl_data.ratios.horz_c, 19); 405 spl_scratch->scl_data.ratios.vert_c = spl_fixpt_truncate( 406 spl_scratch->scl_data.ratios.vert_c, 19); 407 408 /* 409 * Coefficient table and some registers are different based on ratio 410 * that is output/input. Currently we calculate input/output 411 * Store 1/ratio in recip_ratio for those lookups 412 */ 413 spl_scratch->scl_data.recip_ratios.horz = spl_fixpt_recip( 414 spl_scratch->scl_data.ratios.horz); 415 spl_scratch->scl_data.recip_ratios.vert = spl_fixpt_recip( 416 spl_scratch->scl_data.ratios.vert); 417 spl_scratch->scl_data.recip_ratios.horz_c = spl_fixpt_recip( 418 spl_scratch->scl_data.ratios.horz_c); 419 spl_scratch->scl_data.recip_ratios.vert_c = spl_fixpt_recip( 420 spl_scratch->scl_data.ratios.vert_c); 421 } 422 423 /* Calculate Viewport size */ 424 static void spl_calculate_viewport_size(struct spl_in *spl_in, struct spl_scratch *spl_scratch) 425 { 426 spl_scratch->scl_data.viewport.width = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.horz, 427 spl_scratch->scl_data.recout.width)); 428 spl_scratch->scl_data.viewport.height = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.vert, 429 spl_scratch->scl_data.recout.height)); 430 spl_scratch->scl_data.viewport_c.width = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.horz_c, 431 spl_scratch->scl_data.recout.width)); 432 spl_scratch->scl_data.viewport_c.height = spl_fixpt_ceil(spl_fixpt_mul_int(spl_scratch->scl_data.ratios.vert_c, 433 spl_scratch->scl_data.recout.height)); 434 if (spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_90 || 435 spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_270) { 436 spl_swap(spl_scratch->scl_data.viewport.width, spl_scratch->scl_data.viewport.height); 437 spl_swap(spl_scratch->scl_data.viewport_c.width, spl_scratch->scl_data.viewport_c.height); 438 } 439 } 440 441 static void spl_get_vp_scan_direction(enum spl_rotation_angle rotation, 442 bool horizontal_mirror, 443 bool *orthogonal_rotation, 444 bool *flip_vert_scan_dir, 445 bool *flip_horz_scan_dir) 446 { 447 *orthogonal_rotation = false; 448 *flip_vert_scan_dir = false; 449 *flip_horz_scan_dir = false; 450 if (rotation == SPL_ROTATION_ANGLE_180) { 451 *flip_vert_scan_dir = true; 452 *flip_horz_scan_dir = true; 453 } else if (rotation == SPL_ROTATION_ANGLE_90) { 454 *orthogonal_rotation = true; 455 *flip_horz_scan_dir = true; 456 } else if (rotation == SPL_ROTATION_ANGLE_270) { 457 *orthogonal_rotation = true; 458 *flip_vert_scan_dir = true; 459 } 460 461 if (horizontal_mirror) 462 *flip_horz_scan_dir = !*flip_horz_scan_dir; 463 } 464 465 /* 466 * We completely calculate vp offset, size and inits here based entirely on scaling 467 * ratios and recout for pixel perfect pipe combine. 468 */ 469 static void spl_calculate_init_and_vp(bool flip_scan_dir, 470 int recout_offset_within_recout_full, 471 int recout_size, 472 int src_size, 473 int taps, 474 struct spl_fixed31_32 ratio, 475 struct spl_fixed31_32 init_adj, 476 struct spl_fixed31_32 *init, 477 int *vp_offset, 478 int *vp_size) 479 { 480 struct spl_fixed31_32 temp; 481 int int_part; 482 483 /* 484 * First of the taps starts sampling pixel number <init_int_part> corresponding to recout 485 * pixel 1. Next recout pixel samples int part of <init + scaling ratio> and so on. 486 * All following calculations are based on this logic. 487 * 488 * Init calculated according to formula: 489 * init = (scaling_ratio + number_of_taps + 1) / 2 490 * init_bot = init + scaling_ratio 491 * to get pixel perfect combine add the fraction from calculating vp offset 492 */ 493 temp = spl_fixpt_mul_int(ratio, recout_offset_within_recout_full); 494 *vp_offset = spl_fixpt_floor(temp); 495 temp.value &= 0xffffffff; 496 *init = spl_fixpt_add(spl_fixpt_div_int(spl_fixpt_add_int(ratio, taps + 1), 2), temp); 497 *init = spl_fixpt_add(*init, init_adj); 498 *init = spl_fixpt_truncate(*init, 19); 499 500 /* 501 * If viewport has non 0 offset and there are more taps than covered by init then 502 * we should decrease the offset and increase init so we are never sampling 503 * outside of viewport. 504 */ 505 int_part = spl_fixpt_floor(*init); 506 if (int_part < taps) { 507 int_part = taps - int_part; 508 if (int_part > *vp_offset) 509 int_part = *vp_offset; 510 *vp_offset -= int_part; 511 *init = spl_fixpt_add_int(*init, int_part); 512 } 513 /* 514 * If taps are sampling outside of viewport at end of recout and there are more pixels 515 * available in the surface we should increase the viewport size, regardless set vp to 516 * only what is used. 517 */ 518 temp = spl_fixpt_add(*init, spl_fixpt_mul_int(ratio, recout_size - 1)); 519 *vp_size = spl_fixpt_floor(temp); 520 if (*vp_size + *vp_offset > src_size) 521 *vp_size = src_size - *vp_offset; 522 523 /* We did all the math assuming we are scanning same direction as display does, 524 * however mirror/rotation changes how vp scans vs how it is offset. If scan direction 525 * is flipped we simply need to calculate offset from the other side of plane. 526 * Note that outside of viewport all scaling hardware works in recout space. 527 */ 528 if (flip_scan_dir) 529 *vp_offset = src_size - *vp_offset - *vp_size; 530 } 531 532 static bool spl_is_yuv420(enum spl_pixel_format format) 533 { 534 if ((format >= SPL_PIXEL_FORMAT_420BPP8) && 535 (format <= SPL_PIXEL_FORMAT_420BPP10)) 536 return true; 537 538 return false; 539 } 540 541 static bool spl_is_rgb8(enum spl_pixel_format format) 542 { 543 if (format == SPL_PIXEL_FORMAT_ARGB8888) 544 return true; 545 546 return false; 547 } 548 549 /*Calculate inits and viewport */ 550 static void spl_calculate_inits_and_viewports(struct spl_in *spl_in, 551 struct spl_scratch *spl_scratch) 552 { 553 struct spl_rect src = spl_in->basic_in.src_rect; 554 struct spl_rect recout_dst_in_active_timing; 555 struct spl_rect recout_clip_in_active_timing; 556 struct spl_rect recout_clip_in_recout_dst; 557 struct spl_rect overlap_in_active_timing; 558 struct spl_rect odm_slice = calculate_odm_slice_in_timing_active(spl_in); 559 int vpc_div = (spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP8 560 || spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP10) ? 2 : 1; 561 bool orthogonal_rotation, flip_vert_scan_dir, flip_horz_scan_dir; 562 struct spl_fixed31_32 init_adj_h = spl_fixpt_zero; 563 struct spl_fixed31_32 init_adj_v = spl_fixpt_zero; 564 565 recout_clip_in_active_timing = shift_rec( 566 &spl_scratch->scl_data.recout, odm_slice.x, odm_slice.y); 567 recout_dst_in_active_timing = calculate_plane_rec_in_timing_active( 568 spl_in, &spl_in->basic_in.dst_rect); 569 overlap_in_active_timing = intersect_rec(&recout_clip_in_active_timing, 570 &recout_dst_in_active_timing); 571 if (overlap_in_active_timing.width > 0 && 572 overlap_in_active_timing.height > 0) 573 recout_clip_in_recout_dst = shift_rec(&overlap_in_active_timing, 574 -recout_dst_in_active_timing.x, 575 -recout_dst_in_active_timing.y); 576 else 577 memset(&recout_clip_in_recout_dst, 0, sizeof(struct spl_rect)); 578 /* 579 * Work in recout rotation since that requires less transformations 580 */ 581 spl_get_vp_scan_direction( 582 spl_in->basic_in.rotation, 583 spl_in->basic_in.horizontal_mirror, 584 &orthogonal_rotation, 585 &flip_vert_scan_dir, 586 &flip_horz_scan_dir); 587 588 if (orthogonal_rotation) { 589 spl_swap(src.width, src.height); 590 spl_swap(flip_vert_scan_dir, flip_horz_scan_dir); 591 } 592 593 if (spl_is_yuv420(spl_in->basic_in.format)) { 594 /* this gives the direction of the cositing (negative will move 595 * left, right otherwise) 596 */ 597 int sign = 1; 598 599 switch (spl_in->basic_in.cositing) { 600 601 case CHROMA_COSITING_LEFT: 602 init_adj_h = spl_fixpt_zero; 603 init_adj_v = spl_fixpt_from_fraction(sign, 4); 604 break; 605 case CHROMA_COSITING_NONE: 606 init_adj_h = spl_fixpt_from_fraction(sign, 4); 607 init_adj_v = spl_fixpt_from_fraction(sign, 4); 608 break; 609 case CHROMA_COSITING_TOPLEFT: 610 default: 611 init_adj_h = spl_fixpt_zero; 612 init_adj_v = spl_fixpt_zero; 613 break; 614 } 615 } 616 617 spl_calculate_init_and_vp( 618 flip_horz_scan_dir, 619 recout_clip_in_recout_dst.x, 620 spl_scratch->scl_data.recout.width, 621 src.width, 622 spl_scratch->scl_data.taps.h_taps, 623 spl_scratch->scl_data.ratios.horz, 624 spl_fixpt_zero, 625 &spl_scratch->scl_data.inits.h, 626 &spl_scratch->scl_data.viewport.x, 627 &spl_scratch->scl_data.viewport.width); 628 spl_calculate_init_and_vp( 629 flip_horz_scan_dir, 630 recout_clip_in_recout_dst.x, 631 spl_scratch->scl_data.recout.width, 632 src.width / vpc_div, 633 spl_scratch->scl_data.taps.h_taps_c, 634 spl_scratch->scl_data.ratios.horz_c, 635 init_adj_h, 636 &spl_scratch->scl_data.inits.h_c, 637 &spl_scratch->scl_data.viewport_c.x, 638 &spl_scratch->scl_data.viewport_c.width); 639 spl_calculate_init_and_vp( 640 flip_vert_scan_dir, 641 recout_clip_in_recout_dst.y, 642 spl_scratch->scl_data.recout.height, 643 src.height, 644 spl_scratch->scl_data.taps.v_taps, 645 spl_scratch->scl_data.ratios.vert, 646 spl_fixpt_zero, 647 &spl_scratch->scl_data.inits.v, 648 &spl_scratch->scl_data.viewport.y, 649 &spl_scratch->scl_data.viewport.height); 650 spl_calculate_init_and_vp( 651 flip_vert_scan_dir, 652 recout_clip_in_recout_dst.y, 653 spl_scratch->scl_data.recout.height, 654 src.height / vpc_div, 655 spl_scratch->scl_data.taps.v_taps_c, 656 spl_scratch->scl_data.ratios.vert_c, 657 init_adj_v, 658 &spl_scratch->scl_data.inits.v_c, 659 &spl_scratch->scl_data.viewport_c.y, 660 &spl_scratch->scl_data.viewport_c.height); 661 if (orthogonal_rotation) { 662 spl_swap(spl_scratch->scl_data.viewport.x, spl_scratch->scl_data.viewport.y); 663 spl_swap(spl_scratch->scl_data.viewport.width, spl_scratch->scl_data.viewport.height); 664 spl_swap(spl_scratch->scl_data.viewport_c.x, spl_scratch->scl_data.viewport_c.y); 665 spl_swap(spl_scratch->scl_data.viewport_c.width, spl_scratch->scl_data.viewport_c.height); 666 } 667 spl_scratch->scl_data.viewport.x += src.x; 668 spl_scratch->scl_data.viewport.y += src.y; 669 SPL_ASSERT(src.x % vpc_div == 0 && src.y % vpc_div == 0); 670 spl_scratch->scl_data.viewport_c.x += src.x / vpc_div; 671 spl_scratch->scl_data.viewport_c.y += src.y / vpc_div; 672 } 673 674 static void spl_handle_3d_recout(struct spl_in *spl_in, struct spl_rect *recout) 675 { 676 /* 677 * Handle side by side and top bottom 3d recout offsets after vp calculation 678 * since 3d is special and needs to calculate vp as if there is no recout offset 679 * This may break with rotation, good thing we aren't mixing hw rotation and 3d 680 */ 681 if (spl_in->basic_in.mpc_combine_v) { 682 SPL_ASSERT(spl_in->basic_in.rotation == SPL_ROTATION_ANGLE_0 || 683 (spl_in->basic_out.view_format != SPL_VIEW_3D_TOP_AND_BOTTOM && 684 spl_in->basic_out.view_format != SPL_VIEW_3D_SIDE_BY_SIDE)); 685 if (spl_in->basic_out.view_format == SPL_VIEW_3D_TOP_AND_BOTTOM) 686 recout->y += recout->height; 687 else if (spl_in->basic_out.view_format == SPL_VIEW_3D_SIDE_BY_SIDE) 688 recout->x += recout->width; 689 } 690 } 691 692 static void spl_clamp_viewport(struct spl_rect *viewport) 693 { 694 /* Clamp minimum viewport size */ 695 if (viewport->height < MIN_VIEWPORT_SIZE) 696 viewport->height = MIN_VIEWPORT_SIZE; 697 if (viewport->width < MIN_VIEWPORT_SIZE) 698 viewport->width = MIN_VIEWPORT_SIZE; 699 } 700 701 static bool spl_dscl_is_420_format(enum spl_pixel_format format) 702 { 703 if (format == SPL_PIXEL_FORMAT_420BPP8 || 704 format == SPL_PIXEL_FORMAT_420BPP10) 705 return true; 706 else 707 return false; 708 } 709 710 static bool spl_dscl_is_video_format(enum spl_pixel_format format) 711 { 712 if (format >= SPL_PIXEL_FORMAT_VIDEO_BEGIN 713 && format <= SPL_PIXEL_FORMAT_VIDEO_END) 714 return true; 715 else 716 return false; 717 } 718 719 static enum scl_mode spl_get_dscl_mode(const struct spl_in *spl_in, 720 const struct spl_scaler_data *data, 721 bool enable_isharp, bool enable_easf) 722 { 723 const long long one = spl_fixpt_one.value; 724 enum spl_pixel_format pixel_format = spl_in->basic_in.format; 725 726 /* Bypass if ratio is 1:1 with no ISHARP or force scale on */ 727 if (data->ratios.horz.value == one 728 && data->ratios.vert.value == one 729 && data->ratios.horz_c.value == one 730 && data->ratios.vert_c.value == one 731 && !spl_in->basic_out.always_scale 732 && !enable_isharp) 733 return SCL_MODE_SCALING_444_BYPASS; 734 735 if (!spl_dscl_is_420_format(pixel_format)) { 736 if (spl_dscl_is_video_format(pixel_format)) 737 return SCL_MODE_SCALING_444_YCBCR_ENABLE; 738 else 739 return SCL_MODE_SCALING_444_RGB_ENABLE; 740 } 741 742 /* Bypass YUV if at 1:1 with no ISHARP or if doing 2:1 YUV 743 * downscale without EASF 744 */ 745 if ((!enable_isharp) && (!enable_easf)) { 746 if (data->ratios.horz.value == one && data->ratios.vert.value == one) 747 return SCL_MODE_SCALING_420_LUMA_BYPASS; 748 if (data->ratios.horz_c.value == one && data->ratios.vert_c.value == one) 749 return SCL_MODE_SCALING_420_CHROMA_BYPASS; 750 } 751 752 return SCL_MODE_SCALING_420_YCBCR_ENABLE; 753 } 754 755 static bool spl_choose_lls_policy(enum spl_pixel_format format, 756 enum spl_transfer_func_type tf_type, 757 enum spl_transfer_func_predefined tf_predefined_type, 758 enum linear_light_scaling *lls_pref) 759 { 760 if (spl_is_yuv420(format)) { 761 *lls_pref = LLS_PREF_NO; 762 if ((tf_type == SPL_TF_TYPE_PREDEFINED) || 763 (tf_type == SPL_TF_TYPE_DISTRIBUTED_POINTS)) 764 return true; 765 } else { /* RGB or YUV444 */ 766 if ((tf_type == SPL_TF_TYPE_PREDEFINED) || 767 (tf_type == SPL_TF_TYPE_BYPASS)) { 768 *lls_pref = LLS_PREF_YES; 769 return true; 770 } 771 } 772 *lls_pref = LLS_PREF_NO; 773 return false; 774 } 775 776 /* Enable EASF ?*/ 777 static bool enable_easf(struct spl_in *spl_in, struct spl_scratch *spl_scratch) 778 { 779 int vratio = 0; 780 int hratio = 0; 781 bool skip_easf = false; 782 bool lls_enable_easf = true; 783 784 if (spl_in->disable_easf) 785 skip_easf = true; 786 787 vratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert); 788 hratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz); 789 790 /* 791 * No EASF support for downscaling > 2:1 792 * EASF support for upscaling or downscaling up to 2:1 793 */ 794 if ((vratio > 2) || (hratio > 2)) 795 skip_easf = true; 796 797 /* 798 * If lls_pref is LLS_PREF_DONT_CARE, then use pixel format and transfer 799 * function to determine whether to use LINEAR or NONLINEAR scaling 800 */ 801 if (spl_in->lls_pref == LLS_PREF_DONT_CARE) 802 lls_enable_easf = spl_choose_lls_policy(spl_in->basic_in.format, 803 spl_in->basic_in.tf_type, spl_in->basic_in.tf_predefined_type, 804 &spl_in->lls_pref); 805 806 if (!lls_enable_easf) 807 skip_easf = true; 808 809 /* Check for linear scaling or EASF preferred */ 810 if (spl_in->lls_pref != LLS_PREF_YES && !spl_in->prefer_easf) 811 skip_easf = true; 812 813 return skip_easf; 814 } 815 816 /* Check if video is in fullscreen mode */ 817 static bool spl_is_video_fullscreen(struct spl_in *spl_in) 818 { 819 if (spl_is_yuv420(spl_in->basic_in.format) && spl_in->is_fullscreen) 820 return true; 821 return false; 822 } 823 824 static bool spl_get_isharp_en(struct spl_in *spl_in, 825 struct spl_scratch *spl_scratch) 826 { 827 bool enable_isharp = false; 828 int vratio = 0; 829 int hratio = 0; 830 struct spl_taps taps = spl_scratch->scl_data.taps; 831 bool fullscreen = spl_is_video_fullscreen(spl_in); 832 833 /* Return if adaptive sharpness is disabled */ 834 if (spl_in->adaptive_sharpness.enable == false) 835 return enable_isharp; 836 837 vratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert); 838 hratio = spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz); 839 840 /* No iSHARP support for downscaling */ 841 if (vratio > 1 || hratio > 1) 842 return enable_isharp; 843 844 // Scaling is up to 1:1 (no scaling) or upscaling 845 846 /* 847 * Apply sharpness to RGB and YUV (NV12/P010) 848 * surfaces based on policy setting 849 */ 850 if (!spl_is_yuv420(spl_in->basic_in.format) && 851 (spl_in->sharpen_policy == SHARPEN_YUV)) 852 return enable_isharp; 853 else if ((spl_is_yuv420(spl_in->basic_in.format) && !fullscreen) && 854 (spl_in->sharpen_policy == SHARPEN_RGB_FULLSCREEN_YUV)) 855 return enable_isharp; 856 else if (!spl_in->is_fullscreen && 857 spl_in->sharpen_policy == SHARPEN_FULLSCREEN_ALL) 858 return enable_isharp; 859 860 /* 861 * Apply sharpness if supports horizontal taps 4,6 AND 862 * vertical taps 3, 4, 6 863 */ 864 if ((taps.h_taps == 4 || taps.h_taps == 6) && 865 (taps.v_taps == 3 || taps.v_taps == 4 || taps.v_taps == 6)) 866 enable_isharp = true; 867 868 return enable_isharp; 869 } 870 871 /* Calculate number of tap with adaptive scaling off */ 872 static void spl_get_taps_non_adaptive_scaler( 873 struct spl_scratch *spl_scratch, const struct spl_taps *in_taps) 874 { 875 if (in_taps->h_taps == 0) { 876 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz) > 1) 877 spl_scratch->scl_data.taps.h_taps = spl_min(2 * spl_fixpt_ceil( 878 spl_scratch->scl_data.ratios.horz), 8); 879 else 880 spl_scratch->scl_data.taps.h_taps = 4; 881 } else 882 spl_scratch->scl_data.taps.h_taps = in_taps->h_taps; 883 884 if (in_taps->v_taps == 0) { 885 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) > 1) 886 spl_scratch->scl_data.taps.v_taps = spl_min(spl_fixpt_ceil(spl_fixpt_mul_int( 887 spl_scratch->scl_data.ratios.vert, 2)), 8); 888 else 889 spl_scratch->scl_data.taps.v_taps = 4; 890 } else 891 spl_scratch->scl_data.taps.v_taps = in_taps->v_taps; 892 893 if (in_taps->v_taps_c == 0) { 894 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) > 1) 895 spl_scratch->scl_data.taps.v_taps_c = spl_min(spl_fixpt_ceil(spl_fixpt_mul_int( 896 spl_scratch->scl_data.ratios.vert_c, 2)), 8); 897 else 898 spl_scratch->scl_data.taps.v_taps_c = 4; 899 } else 900 spl_scratch->scl_data.taps.v_taps_c = in_taps->v_taps_c; 901 902 if (in_taps->h_taps_c == 0) { 903 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.horz_c) > 1) 904 spl_scratch->scl_data.taps.h_taps_c = spl_min(2 * spl_fixpt_ceil( 905 spl_scratch->scl_data.ratios.horz_c), 8); 906 else 907 spl_scratch->scl_data.taps.h_taps_c = 4; 908 } else if ((in_taps->h_taps_c % 2) != 0 && in_taps->h_taps_c != 1) 909 /* Only 1 and even h_taps_c are supported by hw */ 910 spl_scratch->scl_data.taps.h_taps_c = in_taps->h_taps_c - 1; 911 else 912 spl_scratch->scl_data.taps.h_taps_c = in_taps->h_taps_c; 913 914 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz)) 915 spl_scratch->scl_data.taps.h_taps = 1; 916 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert)) 917 spl_scratch->scl_data.taps.v_taps = 1; 918 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c)) 919 spl_scratch->scl_data.taps.h_taps_c = 1; 920 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c)) 921 spl_scratch->scl_data.taps.v_taps_c = 1; 922 923 } 924 925 /* Calculate optimal number of taps */ 926 static bool spl_get_optimal_number_of_taps( 927 int max_downscale_src_width, struct spl_in *spl_in, struct spl_scratch *spl_scratch, 928 const struct spl_taps *in_taps, bool *enable_easf_v, bool *enable_easf_h, 929 bool *enable_isharp) 930 { 931 int num_part_y, num_part_c; 932 int max_taps_y, max_taps_c; 933 int min_taps_y, min_taps_c; 934 enum lb_memory_config lb_config; 935 bool skip_easf = false; 936 937 if (spl_scratch->scl_data.viewport.width > spl_scratch->scl_data.h_active && 938 max_downscale_src_width != 0 && 939 spl_scratch->scl_data.viewport.width > max_downscale_src_width) { 940 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps); 941 *enable_easf_v = false; 942 *enable_easf_h = false; 943 *enable_isharp = false; 944 return false; 945 } 946 947 /* Disable adaptive scaler and sharpener when integer scaling is enabled */ 948 if (spl_in->scaling_quality.integer_scaling) { 949 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps); 950 *enable_easf_v = false; 951 *enable_easf_h = false; 952 *enable_isharp = false; 953 return true; 954 } 955 956 /* Check if we are using EASF or not */ 957 skip_easf = enable_easf(spl_in, spl_scratch); 958 959 /* 960 * Set default taps if none are provided 961 * From programming guide: taps = min{ ceil(2*H_RATIO,1), 8} for downscaling 962 * taps = 4 for upscaling 963 */ 964 if (skip_easf) 965 spl_get_taps_non_adaptive_scaler(spl_scratch, in_taps); 966 else { 967 if (spl_is_yuv420(spl_in->basic_in.format)) { 968 spl_scratch->scl_data.taps.h_taps = 6; 969 spl_scratch->scl_data.taps.v_taps = 6; 970 spl_scratch->scl_data.taps.h_taps_c = 4; 971 spl_scratch->scl_data.taps.v_taps_c = 4; 972 } else { /* RGB */ 973 spl_scratch->scl_data.taps.h_taps = 6; 974 spl_scratch->scl_data.taps.v_taps = 6; 975 spl_scratch->scl_data.taps.h_taps_c = 6; 976 spl_scratch->scl_data.taps.v_taps_c = 6; 977 } 978 } 979 980 /*Ensure we can support the requested number of vtaps*/ 981 min_taps_y = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert); 982 min_taps_c = spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c); 983 984 /* Use LB_MEMORY_CONFIG_3 for 4:2:0 */ 985 if ((spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP8) 986 || (spl_in->basic_in.format == SPL_PIXEL_FORMAT_420BPP10)) 987 lb_config = LB_MEMORY_CONFIG_3; 988 else 989 lb_config = LB_MEMORY_CONFIG_0; 990 // Determine max vtap support by calculating how much line buffer can fit 991 spl_in->callbacks.spl_calc_lb_num_partitions(spl_in->basic_out.alpha_en, &spl_scratch->scl_data, 992 lb_config, &num_part_y, &num_part_c); 993 /* MAX_V_TAPS = MIN (NUM_LINES - MAX(CEILING(V_RATIO,1)-2, 0), 8) */ 994 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) > 2) 995 max_taps_y = num_part_y - (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert) - 2); 996 else 997 max_taps_y = num_part_y; 998 999 if (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) > 2) 1000 max_taps_c = num_part_c - (spl_fixpt_ceil(spl_scratch->scl_data.ratios.vert_c) - 2); 1001 else 1002 max_taps_c = num_part_c; 1003 1004 if (max_taps_y < min_taps_y) 1005 return false; 1006 else if (max_taps_c < min_taps_c) 1007 return false; 1008 1009 if (spl_scratch->scl_data.taps.v_taps > max_taps_y) 1010 spl_scratch->scl_data.taps.v_taps = max_taps_y; 1011 1012 if (spl_scratch->scl_data.taps.v_taps_c > max_taps_c) 1013 spl_scratch->scl_data.taps.v_taps_c = max_taps_c; 1014 1015 if (!skip_easf) { 1016 /* 1017 * RGB ( L + NL ) and Linear HDR support 6x6, 6x4, 6x3, 4x4, 4x3 1018 * NL YUV420 only supports 6x6, 6x4 for Y and 4x4 for UV 1019 * 1020 * If LB does not support 3, 4, or 6 taps, then disable EASF_V 1021 * and only enable EASF_H. So for RGB, support 6x2, 4x2 1022 * and for NL YUV420, support 6x2 for Y and 4x2 for UV 1023 * 1024 * All other cases, have to disable EASF_V and EASF_H 1025 * 1026 * If optimal no of taps is 5, then set it to 4 1027 * If optimal no of taps is 7 or 8, then fine since max tap is 6 1028 * 1029 */ 1030 if (spl_scratch->scl_data.taps.v_taps == 5) 1031 spl_scratch->scl_data.taps.v_taps = 4; 1032 1033 if (spl_scratch->scl_data.taps.v_taps_c == 5) 1034 spl_scratch->scl_data.taps.v_taps_c = 4; 1035 1036 if (spl_scratch->scl_data.taps.h_taps == 5) 1037 spl_scratch->scl_data.taps.h_taps = 4; 1038 1039 if (spl_scratch->scl_data.taps.h_taps_c == 5) 1040 spl_scratch->scl_data.taps.h_taps_c = 4; 1041 1042 if (spl_is_yuv420(spl_in->basic_in.format)) { 1043 if ((spl_scratch->scl_data.taps.h_taps <= 4) || 1044 (spl_scratch->scl_data.taps.h_taps_c <= 3)) { 1045 *enable_easf_v = false; 1046 *enable_easf_h = false; 1047 } else if ((spl_scratch->scl_data.taps.v_taps <= 3) || 1048 (spl_scratch->scl_data.taps.v_taps_c <= 3)) { 1049 *enable_easf_v = false; 1050 *enable_easf_h = true; 1051 } else { 1052 *enable_easf_v = true; 1053 *enable_easf_h = true; 1054 } 1055 SPL_ASSERT((spl_scratch->scl_data.taps.v_taps > 1) && 1056 (spl_scratch->scl_data.taps.v_taps_c > 1)); 1057 } else { /* RGB */ 1058 if (spl_scratch->scl_data.taps.h_taps <= 3) { 1059 *enable_easf_v = false; 1060 *enable_easf_h = false; 1061 } else if (spl_scratch->scl_data.taps.v_taps < 3) { 1062 *enable_easf_v = false; 1063 *enable_easf_h = true; 1064 } else { 1065 *enable_easf_v = true; 1066 *enable_easf_h = true; 1067 } 1068 SPL_ASSERT(spl_scratch->scl_data.taps.v_taps > 1); 1069 } 1070 } else { 1071 *enable_easf_v = false; 1072 *enable_easf_h = false; 1073 } // end of if prefer_easf 1074 1075 /* Sharpener requires scaler to be enabled, including for 1:1 1076 * Check if ISHARP can be enabled 1077 * If ISHARP is not enabled, for 1:1, set taps to 1 and disable 1078 * EASF 1079 * For case of 2:1 YUV where chroma is 1:1, set taps to 1 if 1080 * EASF is not enabled 1081 */ 1082 1083 *enable_isharp = spl_get_isharp_en(spl_in, spl_scratch); 1084 if (!*enable_isharp && !spl_in->basic_out.always_scale) { 1085 if ((IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz)) && 1086 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert))) { 1087 spl_scratch->scl_data.taps.h_taps = 1; 1088 spl_scratch->scl_data.taps.v_taps = 1; 1089 1090 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c)) 1091 spl_scratch->scl_data.taps.h_taps_c = 1; 1092 1093 if (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c)) 1094 spl_scratch->scl_data.taps.v_taps_c = 1; 1095 1096 *enable_easf_v = false; 1097 *enable_easf_h = false; 1098 } else { 1099 if ((!*enable_easf_h) && 1100 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.horz_c))) 1101 spl_scratch->scl_data.taps.h_taps_c = 1; 1102 1103 if ((!*enable_easf_v) && 1104 (IDENTITY_RATIO(spl_scratch->scl_data.ratios.vert_c))) 1105 spl_scratch->scl_data.taps.v_taps_c = 1; 1106 } 1107 } 1108 return true; 1109 } 1110 1111 static void spl_set_black_color_data(enum spl_pixel_format format, 1112 struct scl_black_color *scl_black_color) 1113 { 1114 bool ycbcr = format >= SPL_PIXEL_FORMAT_VIDEO_BEGIN 1115 && format <= SPL_PIXEL_FORMAT_VIDEO_END; 1116 if (ycbcr) { 1117 scl_black_color->offset_rgb_y = BLACK_OFFSET_RGB_Y; 1118 scl_black_color->offset_rgb_cbcr = BLACK_OFFSET_CBCR; 1119 } else { 1120 scl_black_color->offset_rgb_y = 0x0; 1121 scl_black_color->offset_rgb_cbcr = 0x0; 1122 } 1123 } 1124 1125 static void spl_set_manual_ratio_init_data(struct dscl_prog_data *dscl_prog_data, 1126 const struct spl_scaler_data *scl_data) 1127 { 1128 struct spl_fixed31_32 bot; 1129 1130 dscl_prog_data->ratios.h_scale_ratio = spl_fixpt_u3d19(scl_data->ratios.horz) << 5; 1131 dscl_prog_data->ratios.v_scale_ratio = spl_fixpt_u3d19(scl_data->ratios.vert) << 5; 1132 dscl_prog_data->ratios.h_scale_ratio_c = spl_fixpt_u3d19(scl_data->ratios.horz_c) << 5; 1133 dscl_prog_data->ratios.v_scale_ratio_c = spl_fixpt_u3d19(scl_data->ratios.vert_c) << 5; 1134 /* 1135 * 0.24 format for fraction, first five bits zeroed 1136 */ 1137 dscl_prog_data->init.h_filter_init_frac = 1138 spl_fixpt_u0d19(scl_data->inits.h) << 5; 1139 dscl_prog_data->init.h_filter_init_int = 1140 spl_fixpt_floor(scl_data->inits.h); 1141 dscl_prog_data->init.h_filter_init_frac_c = 1142 spl_fixpt_u0d19(scl_data->inits.h_c) << 5; 1143 dscl_prog_data->init.h_filter_init_int_c = 1144 spl_fixpt_floor(scl_data->inits.h_c); 1145 dscl_prog_data->init.v_filter_init_frac = 1146 spl_fixpt_u0d19(scl_data->inits.v) << 5; 1147 dscl_prog_data->init.v_filter_init_int = 1148 spl_fixpt_floor(scl_data->inits.v); 1149 dscl_prog_data->init.v_filter_init_frac_c = 1150 spl_fixpt_u0d19(scl_data->inits.v_c) << 5; 1151 dscl_prog_data->init.v_filter_init_int_c = 1152 spl_fixpt_floor(scl_data->inits.v_c); 1153 1154 bot = spl_fixpt_add(scl_data->inits.v, scl_data->ratios.vert); 1155 dscl_prog_data->init.v_filter_init_bot_frac = spl_fixpt_u0d19(bot) << 5; 1156 dscl_prog_data->init.v_filter_init_bot_int = spl_fixpt_floor(bot); 1157 bot = spl_fixpt_add(scl_data->inits.v_c, scl_data->ratios.vert_c); 1158 dscl_prog_data->init.v_filter_init_bot_frac_c = spl_fixpt_u0d19(bot) << 5; 1159 dscl_prog_data->init.v_filter_init_bot_int_c = spl_fixpt_floor(bot); 1160 } 1161 1162 static void spl_set_taps_data(struct dscl_prog_data *dscl_prog_data, 1163 const struct spl_scaler_data *scl_data) 1164 { 1165 dscl_prog_data->taps.v_taps = scl_data->taps.v_taps - 1; 1166 dscl_prog_data->taps.h_taps = scl_data->taps.h_taps - 1; 1167 dscl_prog_data->taps.v_taps_c = scl_data->taps.v_taps_c - 1; 1168 dscl_prog_data->taps.h_taps_c = scl_data->taps.h_taps_c - 1; 1169 } 1170 1171 /* Populate dscl prog data structure from scaler data calculated by SPL */ 1172 static void spl_set_dscl_prog_data(struct spl_in *spl_in, struct spl_scratch *spl_scratch, 1173 struct spl_out *spl_out, bool enable_easf_v, bool enable_easf_h, bool enable_isharp) 1174 { 1175 struct dscl_prog_data *dscl_prog_data = spl_out->dscl_prog_data; 1176 1177 const struct spl_scaler_data *data = &spl_scratch->scl_data; 1178 1179 struct scl_black_color *scl_black_color = &dscl_prog_data->scl_black_color; 1180 1181 bool enable_easf = enable_easf_v || enable_easf_h; 1182 1183 // Set values for recout 1184 dscl_prog_data->recout = spl_scratch->scl_data.recout; 1185 // Set values for MPC Size 1186 dscl_prog_data->mpc_size.width = spl_scratch->scl_data.h_active; 1187 dscl_prog_data->mpc_size.height = spl_scratch->scl_data.v_active; 1188 1189 // SCL_MODE - Set SCL_MODE data 1190 dscl_prog_data->dscl_mode = spl_get_dscl_mode(spl_in, data, enable_isharp, 1191 enable_easf); 1192 1193 // SCL_BLACK_COLOR 1194 spl_set_black_color_data(spl_in->basic_in.format, scl_black_color); 1195 1196 /* Manually calculate scale ratio and init values */ 1197 spl_set_manual_ratio_init_data(dscl_prog_data, data); 1198 1199 // Set HTaps/VTaps 1200 spl_set_taps_data(dscl_prog_data, data); 1201 // Set viewport 1202 dscl_prog_data->viewport = spl_scratch->scl_data.viewport; 1203 // Set viewport_c 1204 dscl_prog_data->viewport_c = spl_scratch->scl_data.viewport_c; 1205 // Set filters data 1206 spl_set_filters_data(dscl_prog_data, data, enable_easf_v, enable_easf_h); 1207 } 1208 1209 /* Calculate C0-C3 coefficients based on HDR_mult */ 1210 static void spl_calculate_c0_c3_hdr(struct dscl_prog_data *dscl_prog_data, uint32_t sdr_white_level_nits) 1211 { 1212 struct spl_fixed31_32 hdr_mult, c0_mult, c1_mult, c2_mult; 1213 struct spl_fixed31_32 c0_calc, c1_calc, c2_calc; 1214 struct spl_custom_float_format fmt; 1215 uint32_t hdr_multx100_int; 1216 1217 if ((sdr_white_level_nits >= 80) && (sdr_white_level_nits <= 480)) 1218 hdr_multx100_int = sdr_white_level_nits * 100 / 80; 1219 else 1220 hdr_multx100_int = 100; /* default for 80 nits otherwise */ 1221 1222 hdr_mult = spl_fixpt_from_fraction((long long)hdr_multx100_int, 100LL); 1223 c0_mult = spl_fixpt_from_fraction(2126LL, 10000LL); 1224 c1_mult = spl_fixpt_from_fraction(7152LL, 10000LL); 1225 c2_mult = spl_fixpt_from_fraction(722LL, 10000LL); 1226 1227 c0_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c0_mult, spl_fixpt_from_fraction( 1228 16384LL, 125LL))); 1229 c1_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c1_mult, spl_fixpt_from_fraction( 1230 16384LL, 125LL))); 1231 c2_calc = spl_fixpt_mul(hdr_mult, spl_fixpt_mul(c2_mult, spl_fixpt_from_fraction( 1232 16384LL, 125LL))); 1233 1234 fmt.exponenta_bits = 5; 1235 fmt.mantissa_bits = 10; 1236 fmt.sign = true; 1237 1238 // fp1.5.10, C0 coefficient (LN_rec709: HDR_MULT * 0.212600 * 2^14/125) 1239 spl_convert_to_custom_float_format(c0_calc, &fmt, &dscl_prog_data->easf_matrix_c0); 1240 // fp1.5.10, C1 coefficient (LN_rec709: HDR_MULT * 0.715200 * 2^14/125) 1241 spl_convert_to_custom_float_format(c1_calc, &fmt, &dscl_prog_data->easf_matrix_c1); 1242 // fp1.5.10, C2 coefficient (LN_rec709: HDR_MULT * 0.072200 * 2^14/125) 1243 spl_convert_to_custom_float_format(c2_calc, &fmt, &dscl_prog_data->easf_matrix_c2); 1244 dscl_prog_data->easf_matrix_c3 = 0x0; // fp1.5.10, C3 coefficient 1245 } 1246 1247 /* Set EASF data */ 1248 static void spl_set_easf_data(struct spl_scratch *spl_scratch, struct spl_out *spl_out, bool enable_easf_v, 1249 bool enable_easf_h, enum linear_light_scaling lls_pref, 1250 enum spl_pixel_format format, enum system_setup setup, 1251 uint32_t sdr_white_level_nits) 1252 { 1253 struct dscl_prog_data *dscl_prog_data = spl_out->dscl_prog_data; 1254 if (enable_easf_v) { 1255 dscl_prog_data->easf_v_en = true; 1256 dscl_prog_data->easf_v_ring = 0; 1257 dscl_prog_data->easf_v_sharp_factor = 0; 1258 dscl_prog_data->easf_v_bf1_en = 1; // 1-bit, BF1 calculation enable, 0=disable, 1=enable 1259 dscl_prog_data->easf_v_bf2_mode = 0xF; // 4-bit, BF2 calculation mode 1260 /* 2-bit, BF3 chroma mode correction calculation mode */ 1261 dscl_prog_data->easf_v_bf3_mode = spl_get_v_bf3_mode( 1262 spl_scratch->scl_data.recip_ratios.vert); 1263 /* FP1.5.10 [ minCoef ]*/ 1264 dscl_prog_data->easf_v_ringest_3tap_dntilt_uptilt = 1265 spl_get_3tap_dntilt_uptilt_offset(spl_scratch->scl_data.taps.v_taps, 1266 spl_scratch->scl_data.recip_ratios.vert); 1267 /* FP1.5.10 [ upTiltMaxVal ]*/ 1268 dscl_prog_data->easf_v_ringest_3tap_uptilt_max = 1269 spl_get_3tap_uptilt_maxval(spl_scratch->scl_data.taps.v_taps, 1270 spl_scratch->scl_data.recip_ratios.vert); 1271 /* FP1.5.10 [ dnTiltSlope ]*/ 1272 dscl_prog_data->easf_v_ringest_3tap_dntilt_slope = 1273 spl_get_3tap_dntilt_slope(spl_scratch->scl_data.taps.v_taps, 1274 spl_scratch->scl_data.recip_ratios.vert); 1275 /* FP1.5.10 [ upTilt1Slope ]*/ 1276 dscl_prog_data->easf_v_ringest_3tap_uptilt1_slope = 1277 spl_get_3tap_uptilt1_slope(spl_scratch->scl_data.taps.v_taps, 1278 spl_scratch->scl_data.recip_ratios.vert); 1279 /* FP1.5.10 [ upTilt2Slope ]*/ 1280 dscl_prog_data->easf_v_ringest_3tap_uptilt2_slope = 1281 spl_get_3tap_uptilt2_slope(spl_scratch->scl_data.taps.v_taps, 1282 spl_scratch->scl_data.recip_ratios.vert); 1283 /* FP1.5.10 [ upTilt2Offset ]*/ 1284 dscl_prog_data->easf_v_ringest_3tap_uptilt2_offset = 1285 spl_get_3tap_uptilt2_offset(spl_scratch->scl_data.taps.v_taps, 1286 spl_scratch->scl_data.recip_ratios.vert); 1287 /* FP1.5.10; (2.0) Ring reducer gain for 4 or 6-tap mode [H_REDUCER_GAIN4] */ 1288 dscl_prog_data->easf_v_ringest_eventap_reduceg1 = 1289 spl_get_reducer_gain4(spl_scratch->scl_data.taps.v_taps, 1290 spl_scratch->scl_data.recip_ratios.vert); 1291 /* FP1.5.10; (2.5) Ring reducer gain for 6-tap mode [V_REDUCER_GAIN6] */ 1292 dscl_prog_data->easf_v_ringest_eventap_reduceg2 = 1293 spl_get_reducer_gain6(spl_scratch->scl_data.taps.v_taps, 1294 spl_scratch->scl_data.recip_ratios.vert); 1295 /* FP1.5.10; (-0.135742) Ring gain for 6-tap set to -139/1024 */ 1296 dscl_prog_data->easf_v_ringest_eventap_gain1 = 1297 spl_get_gainRing4(spl_scratch->scl_data.taps.v_taps, 1298 spl_scratch->scl_data.recip_ratios.vert); 1299 /* FP1.5.10; (-0.024414) Ring gain for 6-tap set to -25/1024 */ 1300 dscl_prog_data->easf_v_ringest_eventap_gain2 = 1301 spl_get_gainRing6(spl_scratch->scl_data.taps.v_taps, 1302 spl_scratch->scl_data.recip_ratios.vert); 1303 dscl_prog_data->easf_v_bf_maxa = 63; //Vertical Max BF value A in U0.6 format.Selected if V_FCNTL == 0 1304 dscl_prog_data->easf_v_bf_maxb = 63; //Vertical Max BF value A in U0.6 format.Selected if V_FCNTL == 1 1305 dscl_prog_data->easf_v_bf_mina = 0; //Vertical Min BF value A in U0.6 format.Selected if V_FCNTL == 0 1306 dscl_prog_data->easf_v_bf_minb = 0; //Vertical Min BF value A in U0.6 format.Selected if V_FCNTL == 1 1307 if (lls_pref == LLS_PREF_YES) { 1308 dscl_prog_data->easf_v_bf2_flat1_gain = 4; // U1.3, BF2 Flat1 Gain control 1309 dscl_prog_data->easf_v_bf2_flat2_gain = 8; // U4.0, BF2 Flat2 Gain control 1310 dscl_prog_data->easf_v_bf2_roc_gain = 4; // U2.2, Rate Of Change control 1311 1312 dscl_prog_data->easf_v_bf1_pwl_in_seg0 = 0x600; // S0.10, BF1 PWL Segment 0 = -512 1313 dscl_prog_data->easf_v_bf1_pwl_base_seg0 = 0; // U0.6, BF1 Base PWL Segment 0 1314 dscl_prog_data->easf_v_bf1_pwl_slope_seg0 = 3; // S7.3, BF1 Slope PWL Segment 0 1315 dscl_prog_data->easf_v_bf1_pwl_in_seg1 = 0x7EC; // S0.10, BF1 PWL Segment 1 = -20 1316 dscl_prog_data->easf_v_bf1_pwl_base_seg1 = 12; // U0.6, BF1 Base PWL Segment 1 1317 dscl_prog_data->easf_v_bf1_pwl_slope_seg1 = 326; // S7.3, BF1 Slope PWL Segment 1 1318 dscl_prog_data->easf_v_bf1_pwl_in_seg2 = 0; // S0.10, BF1 PWL Segment 2 1319 dscl_prog_data->easf_v_bf1_pwl_base_seg2 = 63; // U0.6, BF1 Base PWL Segment 2 1320 dscl_prog_data->easf_v_bf1_pwl_slope_seg2 = 0; // S7.3, BF1 Slope PWL Segment 2 1321 dscl_prog_data->easf_v_bf1_pwl_in_seg3 = 16; // S0.10, BF1 PWL Segment 3 1322 dscl_prog_data->easf_v_bf1_pwl_base_seg3 = 63; // U0.6, BF1 Base PWL Segment 3 1323 dscl_prog_data->easf_v_bf1_pwl_slope_seg3 = 0x7C8; // S7.3, BF1 Slope PWL Segment 3 = -56 1324 dscl_prog_data->easf_v_bf1_pwl_in_seg4 = 32; // S0.10, BF1 PWL Segment 4 1325 dscl_prog_data->easf_v_bf1_pwl_base_seg4 = 56; // U0.6, BF1 Base PWL Segment 4 1326 dscl_prog_data->easf_v_bf1_pwl_slope_seg4 = 0x7D0; // S7.3, BF1 Slope PWL Segment 4 = -48 1327 dscl_prog_data->easf_v_bf1_pwl_in_seg5 = 48; // S0.10, BF1 PWL Segment 5 1328 dscl_prog_data->easf_v_bf1_pwl_base_seg5 = 50; // U0.6, BF1 Base PWL Segment 5 1329 dscl_prog_data->easf_v_bf1_pwl_slope_seg5 = 0x710; // S7.3, BF1 Slope PWL Segment 5 = -240 1330 dscl_prog_data->easf_v_bf1_pwl_in_seg6 = 64; // S0.10, BF1 PWL Segment 6 1331 dscl_prog_data->easf_v_bf1_pwl_base_seg6 = 20; // U0.6, BF1 Base PWL Segment 6 1332 dscl_prog_data->easf_v_bf1_pwl_slope_seg6 = 0x760; // S7.3, BF1 Slope PWL Segment 6 = -160 1333 dscl_prog_data->easf_v_bf1_pwl_in_seg7 = 80; // S0.10, BF1 PWL Segment 7 1334 dscl_prog_data->easf_v_bf1_pwl_base_seg7 = 0; // U0.6, BF1 Base PWL Segment 7 1335 1336 dscl_prog_data->easf_v_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0 1337 dscl_prog_data->easf_v_bf3_pwl_base_set0 = 63; // S0.6, BF3 Base PWL Segment 0 1338 dscl_prog_data->easf_v_bf3_pwl_slope_set0 = 0x12C5; // FP1.6.6, BF3 Slope PWL Segment 0 1339 dscl_prog_data->easf_v_bf3_pwl_in_set1 = 1340 0x0B37; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0078125 * 125^3) 1341 dscl_prog_data->easf_v_bf3_pwl_base_set1 = 62; // S0.6, BF3 Base PWL Segment 1 1342 dscl_prog_data->easf_v_bf3_pwl_slope_set1 = 1343 0x13B8; // FP1.6.6, BF3 Slope PWL Segment 1 1344 dscl_prog_data->easf_v_bf3_pwl_in_set2 = 1345 0x0BB7; // FP0.6.6, BF3 Input value PWL Segment 2 (0.03125 * 125^3) 1346 dscl_prog_data->easf_v_bf3_pwl_base_set2 = 20; // S0.6, BF3 Base PWL Segment 2 1347 dscl_prog_data->easf_v_bf3_pwl_slope_set2 = 1348 0x1356; // FP1.6.6, BF3 Slope PWL Segment 2 1349 dscl_prog_data->easf_v_bf3_pwl_in_set3 = 1350 0x0BF7; // FP0.6.6, BF3 Input value PWL Segment 3 (0.0625 * 125^3) 1351 dscl_prog_data->easf_v_bf3_pwl_base_set3 = 0; // S0.6, BF3 Base PWL Segment 3 1352 dscl_prog_data->easf_v_bf3_pwl_slope_set3 = 1353 0x136B; // FP1.6.6, BF3 Slope PWL Segment 3 1354 dscl_prog_data->easf_v_bf3_pwl_in_set4 = 1355 0x0C37; // FP0.6.6, BF3 Input value PWL Segment 4 (0.125 * 125^3) 1356 dscl_prog_data->easf_v_bf3_pwl_base_set4 = 0x4E; // S0.6, BF3 Base PWL Segment 4 = -50 1357 dscl_prog_data->easf_v_bf3_pwl_slope_set4 = 1358 0x1200; // FP1.6.6, BF3 Slope PWL Segment 4 1359 dscl_prog_data->easf_v_bf3_pwl_in_set5 = 1360 0x0CF7; // FP0.6.6, BF3 Input value PWL Segment 5 (1.0 * 125^3) 1361 dscl_prog_data->easf_v_bf3_pwl_base_set5 = 0x41; // S0.6, BF3 Base PWL Segment 5 = -63 1362 } else { 1363 dscl_prog_data->easf_v_bf2_flat1_gain = 13; // U1.3, BF2 Flat1 Gain control 1364 dscl_prog_data->easf_v_bf2_flat2_gain = 15; // U4.0, BF2 Flat2 Gain control 1365 dscl_prog_data->easf_v_bf2_roc_gain = 14; // U2.2, Rate Of Change control 1366 1367 dscl_prog_data->easf_v_bf1_pwl_in_seg0 = 0x440; // S0.10, BF1 PWL Segment 0 = -960 1368 dscl_prog_data->easf_v_bf1_pwl_base_seg0 = 0; // U0.6, BF1 Base PWL Segment 0 1369 dscl_prog_data->easf_v_bf1_pwl_slope_seg0 = 2; // S7.3, BF1 Slope PWL Segment 0 1370 dscl_prog_data->easf_v_bf1_pwl_in_seg1 = 0x7C4; // S0.10, BF1 PWL Segment 1 = -60 1371 dscl_prog_data->easf_v_bf1_pwl_base_seg1 = 12; // U0.6, BF1 Base PWL Segment 1 1372 dscl_prog_data->easf_v_bf1_pwl_slope_seg1 = 109; // S7.3, BF1 Slope PWL Segment 1 1373 dscl_prog_data->easf_v_bf1_pwl_in_seg2 = 0; // S0.10, BF1 PWL Segment 2 1374 dscl_prog_data->easf_v_bf1_pwl_base_seg2 = 63; // U0.6, BF1 Base PWL Segment 2 1375 dscl_prog_data->easf_v_bf1_pwl_slope_seg2 = 0; // S7.3, BF1 Slope PWL Segment 2 1376 dscl_prog_data->easf_v_bf1_pwl_in_seg3 = 48; // S0.10, BF1 PWL Segment 3 1377 dscl_prog_data->easf_v_bf1_pwl_base_seg3 = 63; // U0.6, BF1 Base PWL Segment 3 1378 dscl_prog_data->easf_v_bf1_pwl_slope_seg3 = 0x7ED; // S7.3, BF1 Slope PWL Segment 3 = -19 1379 dscl_prog_data->easf_v_bf1_pwl_in_seg4 = 96; // S0.10, BF1 PWL Segment 4 1380 dscl_prog_data->easf_v_bf1_pwl_base_seg4 = 56; // U0.6, BF1 Base PWL Segment 4 1381 dscl_prog_data->easf_v_bf1_pwl_slope_seg4 = 0x7F0; // S7.3, BF1 Slope PWL Segment 4 = -16 1382 dscl_prog_data->easf_v_bf1_pwl_in_seg5 = 144; // S0.10, BF1 PWL Segment 5 1383 dscl_prog_data->easf_v_bf1_pwl_base_seg5 = 50; // U0.6, BF1 Base PWL Segment 5 1384 dscl_prog_data->easf_v_bf1_pwl_slope_seg5 = 0x7B0; // S7.3, BF1 Slope PWL Segment 5 = -80 1385 dscl_prog_data->easf_v_bf1_pwl_in_seg6 = 192; // S0.10, BF1 PWL Segment 6 1386 dscl_prog_data->easf_v_bf1_pwl_base_seg6 = 20; // U0.6, BF1 Base PWL Segment 6 1387 dscl_prog_data->easf_v_bf1_pwl_slope_seg6 = 0x7CB; // S7.3, BF1 Slope PWL Segment 6 = -53 1388 dscl_prog_data->easf_v_bf1_pwl_in_seg7 = 240; // S0.10, BF1 PWL Segment 7 1389 dscl_prog_data->easf_v_bf1_pwl_base_seg7 = 0; // U0.6, BF1 Base PWL Segment 7 1390 1391 dscl_prog_data->easf_v_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0 1392 dscl_prog_data->easf_v_bf3_pwl_base_set0 = 63; // S0.6, BF3 Base PWL Segment 0 1393 dscl_prog_data->easf_v_bf3_pwl_slope_set0 = 0x0000; // FP1.6.6, BF3 Slope PWL Segment 0 1394 dscl_prog_data->easf_v_bf3_pwl_in_set1 = 1395 0x06C0; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0625) 1396 dscl_prog_data->easf_v_bf3_pwl_base_set1 = 63; // S0.6, BF3 Base PWL Segment 1 1397 dscl_prog_data->easf_v_bf3_pwl_slope_set1 = 0x1896; // FP1.6.6, BF3 Slope PWL Segment 1 1398 dscl_prog_data->easf_v_bf3_pwl_in_set2 = 1399 0x0700; // FP0.6.6, BF3 Input value PWL Segment 2 (0.125) 1400 dscl_prog_data->easf_v_bf3_pwl_base_set2 = 20; // S0.6, BF3 Base PWL Segment 2 1401 dscl_prog_data->easf_v_bf3_pwl_slope_set2 = 0x1810; // FP1.6.6, BF3 Slope PWL Segment 2 1402 dscl_prog_data->easf_v_bf3_pwl_in_set3 = 1403 0x0740; // FP0.6.6, BF3 Input value PWL Segment 3 (0.25) 1404 dscl_prog_data->easf_v_bf3_pwl_base_set3 = 0; // S0.6, BF3 Base PWL Segment 3 1405 dscl_prog_data->easf_v_bf3_pwl_slope_set3 = 1406 0x1878; // FP1.6.6, BF3 Slope PWL Segment 3 1407 dscl_prog_data->easf_v_bf3_pwl_in_set4 = 1408 0x0761; // FP0.6.6, BF3 Input value PWL Segment 4 (0.375) 1409 dscl_prog_data->easf_v_bf3_pwl_base_set4 = 0x44; // S0.6, BF3 Base PWL Segment 4 = -60 1410 dscl_prog_data->easf_v_bf3_pwl_slope_set4 = 0x1760; // FP1.6.6, BF3 Slope PWL Segment 4 1411 dscl_prog_data->easf_v_bf3_pwl_in_set5 = 1412 0x0780; // FP0.6.6, BF3 Input value PWL Segment 5 (0.5) 1413 dscl_prog_data->easf_v_bf3_pwl_base_set5 = 0x41; // S0.6, BF3 Base PWL Segment 5 = -63 1414 } 1415 } else 1416 dscl_prog_data->easf_v_en = false; 1417 1418 if (enable_easf_h) { 1419 dscl_prog_data->easf_h_en = true; 1420 dscl_prog_data->easf_h_ring = 0; 1421 dscl_prog_data->easf_h_sharp_factor = 0; 1422 dscl_prog_data->easf_h_bf1_en = 1423 1; // 1-bit, BF1 calculation enable, 0=disable, 1=enable 1424 dscl_prog_data->easf_h_bf2_mode = 1425 0xF; // 4-bit, BF2 calculation mode 1426 /* 2-bit, BF3 chroma mode correction calculation mode */ 1427 dscl_prog_data->easf_h_bf3_mode = spl_get_h_bf3_mode( 1428 spl_scratch->scl_data.recip_ratios.horz); 1429 /* FP1.5.10; (2.0) Ring reducer gain for 4 or 6-tap mode [H_REDUCER_GAIN4] */ 1430 dscl_prog_data->easf_h_ringest_eventap_reduceg1 = 1431 spl_get_reducer_gain4(spl_scratch->scl_data.taps.h_taps, 1432 spl_scratch->scl_data.recip_ratios.horz); 1433 /* FP1.5.10; (2.5) Ring reducer gain for 6-tap mode [V_REDUCER_GAIN6] */ 1434 dscl_prog_data->easf_h_ringest_eventap_reduceg2 = 1435 spl_get_reducer_gain6(spl_scratch->scl_data.taps.h_taps, 1436 spl_scratch->scl_data.recip_ratios.horz); 1437 /* FP1.5.10; (-0.135742) Ring gain for 6-tap set to -139/1024 */ 1438 dscl_prog_data->easf_h_ringest_eventap_gain1 = 1439 spl_get_gainRing4(spl_scratch->scl_data.taps.h_taps, 1440 spl_scratch->scl_data.recip_ratios.horz); 1441 /* FP1.5.10; (-0.024414) Ring gain for 6-tap set to -25/1024 */ 1442 dscl_prog_data->easf_h_ringest_eventap_gain2 = 1443 spl_get_gainRing6(spl_scratch->scl_data.taps.h_taps, 1444 spl_scratch->scl_data.recip_ratios.horz); 1445 dscl_prog_data->easf_h_bf_maxa = 63; //Horz Max BF value A in U0.6 format.Selected if H_FCNTL==0 1446 dscl_prog_data->easf_h_bf_maxb = 63; //Horz Max BF value B in U0.6 format.Selected if H_FCNTL==1 1447 dscl_prog_data->easf_h_bf_mina = 0; //Horz Min BF value B in U0.6 format.Selected if H_FCNTL==0 1448 dscl_prog_data->easf_h_bf_minb = 0; //Horz Min BF value B in U0.6 format.Selected if H_FCNTL==1 1449 if (lls_pref == LLS_PREF_YES) { 1450 dscl_prog_data->easf_h_bf2_flat1_gain = 4; // U1.3, BF2 Flat1 Gain control 1451 dscl_prog_data->easf_h_bf2_flat2_gain = 8; // U4.0, BF2 Flat2 Gain control 1452 dscl_prog_data->easf_h_bf2_roc_gain = 4; // U2.2, Rate Of Change control 1453 1454 dscl_prog_data->easf_h_bf1_pwl_in_seg0 = 0x600; // S0.10, BF1 PWL Segment 0 = -512 1455 dscl_prog_data->easf_h_bf1_pwl_base_seg0 = 0; // U0.6, BF1 Base PWL Segment 0 1456 dscl_prog_data->easf_h_bf1_pwl_slope_seg0 = 3; // S7.3, BF1 Slope PWL Segment 0 1457 dscl_prog_data->easf_h_bf1_pwl_in_seg1 = 0x7EC; // S0.10, BF1 PWL Segment 1 = -20 1458 dscl_prog_data->easf_h_bf1_pwl_base_seg1 = 12; // U0.6, BF1 Base PWL Segment 1 1459 dscl_prog_data->easf_h_bf1_pwl_slope_seg1 = 326; // S7.3, BF1 Slope PWL Segment 1 1460 dscl_prog_data->easf_h_bf1_pwl_in_seg2 = 0; // S0.10, BF1 PWL Segment 2 1461 dscl_prog_data->easf_h_bf1_pwl_base_seg2 = 63; // U0.6, BF1 Base PWL Segment 2 1462 dscl_prog_data->easf_h_bf1_pwl_slope_seg2 = 0; // S7.3, BF1 Slope PWL Segment 2 1463 dscl_prog_data->easf_h_bf1_pwl_in_seg3 = 16; // S0.10, BF1 PWL Segment 3 1464 dscl_prog_data->easf_h_bf1_pwl_base_seg3 = 63; // U0.6, BF1 Base PWL Segment 3 1465 dscl_prog_data->easf_h_bf1_pwl_slope_seg3 = 0x7C8; // S7.3, BF1 Slope PWL Segment 3 = -56 1466 dscl_prog_data->easf_h_bf1_pwl_in_seg4 = 32; // S0.10, BF1 PWL Segment 4 1467 dscl_prog_data->easf_h_bf1_pwl_base_seg4 = 56; // U0.6, BF1 Base PWL Segment 4 1468 dscl_prog_data->easf_h_bf1_pwl_slope_seg4 = 0x7D0; // S7.3, BF1 Slope PWL Segment 4 = -48 1469 dscl_prog_data->easf_h_bf1_pwl_in_seg5 = 48; // S0.10, BF1 PWL Segment 5 1470 dscl_prog_data->easf_h_bf1_pwl_base_seg5 = 50; // U0.6, BF1 Base PWL Segment 5 1471 dscl_prog_data->easf_h_bf1_pwl_slope_seg5 = 0x710; // S7.3, BF1 Slope PWL Segment 5 = -240 1472 dscl_prog_data->easf_h_bf1_pwl_in_seg6 = 64; // S0.10, BF1 PWL Segment 6 1473 dscl_prog_data->easf_h_bf1_pwl_base_seg6 = 20; // U0.6, BF1 Base PWL Segment 6 1474 dscl_prog_data->easf_h_bf1_pwl_slope_seg6 = 0x760; // S7.3, BF1 Slope PWL Segment 6 = -160 1475 dscl_prog_data->easf_h_bf1_pwl_in_seg7 = 80; // S0.10, BF1 PWL Segment 7 1476 dscl_prog_data->easf_h_bf1_pwl_base_seg7 = 0; // U0.6, BF1 Base PWL Segment 7 1477 1478 dscl_prog_data->easf_h_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0 1479 dscl_prog_data->easf_h_bf3_pwl_base_set0 = 63; // S0.6, BF3 Base PWL Segment 0 1480 dscl_prog_data->easf_h_bf3_pwl_slope_set0 = 0x12C5; // FP1.6.6, BF3 Slope PWL Segment 0 1481 dscl_prog_data->easf_h_bf3_pwl_in_set1 = 1482 0x0B37; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0078125 * 125^3) 1483 dscl_prog_data->easf_h_bf3_pwl_base_set1 = 62; // S0.6, BF3 Base PWL Segment 1 1484 dscl_prog_data->easf_h_bf3_pwl_slope_set1 = 0x13B8; // FP1.6.6, BF3 Slope PWL Segment 1 1485 dscl_prog_data->easf_h_bf3_pwl_in_set2 = 1486 0x0BB7; // FP0.6.6, BF3 Input value PWL Segment 2 (0.03125 * 125^3) 1487 dscl_prog_data->easf_h_bf3_pwl_base_set2 = 20; // S0.6, BF3 Base PWL Segment 2 1488 dscl_prog_data->easf_h_bf3_pwl_slope_set2 = 0x1356; // FP1.6.6, BF3 Slope PWL Segment 2 1489 dscl_prog_data->easf_h_bf3_pwl_in_set3 = 1490 0x0BF7; // FP0.6.6, BF3 Input value PWL Segment 3 (0.0625 * 125^3) 1491 dscl_prog_data->easf_h_bf3_pwl_base_set3 = 0; // S0.6, BF3 Base PWL Segment 3 1492 dscl_prog_data->easf_h_bf3_pwl_slope_set3 = 0x136B; // FP1.6.6, BF3 Slope PWL Segment 3 1493 dscl_prog_data->easf_h_bf3_pwl_in_set4 = 1494 0x0C37; // FP0.6.6, BF3 Input value PWL Segment 4 (0.125 * 125^3) 1495 dscl_prog_data->easf_h_bf3_pwl_base_set4 = 0x4E; // S0.6, BF3 Base PWL Segment 4 = -50 1496 dscl_prog_data->easf_h_bf3_pwl_slope_set4 = 0x1200; // FP1.6.6, BF3 Slope PWL Segment 4 1497 dscl_prog_data->easf_h_bf3_pwl_in_set5 = 1498 0x0CF7; // FP0.6.6, BF3 Input value PWL Segment 5 (1.0 * 125^3) 1499 dscl_prog_data->easf_h_bf3_pwl_base_set5 = 0x41; // S0.6, BF3 Base PWL Segment 5 = -63 1500 } else { 1501 dscl_prog_data->easf_h_bf2_flat1_gain = 13; // U1.3, BF2 Flat1 Gain control 1502 dscl_prog_data->easf_h_bf2_flat2_gain = 15; // U4.0, BF2 Flat2 Gain control 1503 dscl_prog_data->easf_h_bf2_roc_gain = 14; // U2.2, Rate Of Change control 1504 1505 dscl_prog_data->easf_h_bf1_pwl_in_seg0 = 0x440; // S0.10, BF1 PWL Segment 0 = -960 1506 dscl_prog_data->easf_h_bf1_pwl_base_seg0 = 0; // U0.6, BF1 Base PWL Segment 0 1507 dscl_prog_data->easf_h_bf1_pwl_slope_seg0 = 2; // S7.3, BF1 Slope PWL Segment 0 1508 dscl_prog_data->easf_h_bf1_pwl_in_seg1 = 0x7C4; // S0.10, BF1 PWL Segment 1 = -60 1509 dscl_prog_data->easf_h_bf1_pwl_base_seg1 = 12; // U0.6, BF1 Base PWL Segment 1 1510 dscl_prog_data->easf_h_bf1_pwl_slope_seg1 = 109; // S7.3, BF1 Slope PWL Segment 1 1511 dscl_prog_data->easf_h_bf1_pwl_in_seg2 = 0; // S0.10, BF1 PWL Segment 2 1512 dscl_prog_data->easf_h_bf1_pwl_base_seg2 = 63; // U0.6, BF1 Base PWL Segment 2 1513 dscl_prog_data->easf_h_bf1_pwl_slope_seg2 = 0; // S7.3, BF1 Slope PWL Segment 2 1514 dscl_prog_data->easf_h_bf1_pwl_in_seg3 = 48; // S0.10, BF1 PWL Segment 3 1515 dscl_prog_data->easf_h_bf1_pwl_base_seg3 = 63; // U0.6, BF1 Base PWL Segment 3 1516 dscl_prog_data->easf_h_bf1_pwl_slope_seg3 = 0x7ED; // S7.3, BF1 Slope PWL Segment 3 = -19 1517 dscl_prog_data->easf_h_bf1_pwl_in_seg4 = 96; // S0.10, BF1 PWL Segment 4 1518 dscl_prog_data->easf_h_bf1_pwl_base_seg4 = 56; // U0.6, BF1 Base PWL Segment 4 1519 dscl_prog_data->easf_h_bf1_pwl_slope_seg4 = 0x7F0; // S7.3, BF1 Slope PWL Segment 4 = -16 1520 dscl_prog_data->easf_h_bf1_pwl_in_seg5 = 144; // S0.10, BF1 PWL Segment 5 1521 dscl_prog_data->easf_h_bf1_pwl_base_seg5 = 50; // U0.6, BF1 Base PWL Segment 5 1522 dscl_prog_data->easf_h_bf1_pwl_slope_seg5 = 0x7B0; // S7.3, BF1 Slope PWL Segment 5 = -80 1523 dscl_prog_data->easf_h_bf1_pwl_in_seg6 = 192; // S0.10, BF1 PWL Segment 6 1524 dscl_prog_data->easf_h_bf1_pwl_base_seg6 = 20; // U0.6, BF1 Base PWL Segment 6 1525 dscl_prog_data->easf_h_bf1_pwl_slope_seg6 = 0x7CB; // S7.3, BF1 Slope PWL Segment 6 = -53 1526 dscl_prog_data->easf_h_bf1_pwl_in_seg7 = 240; // S0.10, BF1 PWL Segment 7 1527 dscl_prog_data->easf_h_bf1_pwl_base_seg7 = 0; // U0.6, BF1 Base PWL Segment 7 1528 1529 dscl_prog_data->easf_h_bf3_pwl_in_set0 = 0x000; // FP0.6.6, BF3 Input value PWL Segment 0 1530 dscl_prog_data->easf_h_bf3_pwl_base_set0 = 63; // S0.6, BF3 Base PWL Segment 0 1531 dscl_prog_data->easf_h_bf3_pwl_slope_set0 = 0x0000; // FP1.6.6, BF3 Slope PWL Segment 0 1532 dscl_prog_data->easf_h_bf3_pwl_in_set1 = 1533 0x06C0; // FP0.6.6, BF3 Input value PWL Segment 1 (0.0625) 1534 dscl_prog_data->easf_h_bf3_pwl_base_set1 = 63; // S0.6, BF3 Base PWL Segment 1 1535 dscl_prog_data->easf_h_bf3_pwl_slope_set1 = 0x1896; // FP1.6.6, BF3 Slope PWL Segment 1 1536 dscl_prog_data->easf_h_bf3_pwl_in_set2 = 1537 0x0700; // FP0.6.6, BF3 Input value PWL Segment 2 (0.125) 1538 dscl_prog_data->easf_h_bf3_pwl_base_set2 = 20; // S0.6, BF3 Base PWL Segment 2 1539 dscl_prog_data->easf_h_bf3_pwl_slope_set2 = 0x1810; // FP1.6.6, BF3 Slope PWL Segment 2 1540 dscl_prog_data->easf_h_bf3_pwl_in_set3 = 1541 0x0740; // FP0.6.6, BF3 Input value PWL Segment 3 (0.25) 1542 dscl_prog_data->easf_h_bf3_pwl_base_set3 = 0; // S0.6, BF3 Base PWL Segment 3 1543 dscl_prog_data->easf_h_bf3_pwl_slope_set3 = 0x1878; // FP1.6.6, BF3 Slope PWL Segment 3 1544 dscl_prog_data->easf_h_bf3_pwl_in_set4 = 1545 0x0761; // FP0.6.6, BF3 Input value PWL Segment 4 (0.375) 1546 dscl_prog_data->easf_h_bf3_pwl_base_set4 = 0x44; // S0.6, BF3 Base PWL Segment 4 = -60 1547 dscl_prog_data->easf_h_bf3_pwl_slope_set4 = 0x1760; // FP1.6.6, BF3 Slope PWL Segment 4 1548 dscl_prog_data->easf_h_bf3_pwl_in_set5 = 1549 0x0780; // FP0.6.6, BF3 Input value PWL Segment 5 (0.5) 1550 dscl_prog_data->easf_h_bf3_pwl_base_set5 = 0x41; // S0.6, BF3 Base PWL Segment 5 = -63 1551 } // if (lls_pref == LLS_PREF_YES) 1552 } else 1553 dscl_prog_data->easf_h_en = false; 1554 1555 if (lls_pref == LLS_PREF_YES) { 1556 dscl_prog_data->easf_ltonl_en = 1; // Linear input 1557 if ((setup == HDR_L) && (spl_is_rgb8(format))) { 1558 /* Calculate C0-C3 coefficients based on HDR multiplier */ 1559 spl_calculate_c0_c3_hdr(dscl_prog_data, sdr_white_level_nits); 1560 } else { // HDR_L ( DWM ) and SDR_L 1561 dscl_prog_data->easf_matrix_c0 = 1562 0x4EF7; // fp1.5.10, C0 coefficient (LN_rec709: 0.2126 * (2^14)/125 = 27.86590720) 1563 dscl_prog_data->easf_matrix_c1 = 1564 0x55DC; // fp1.5.10, C1 coefficient (LN_rec709: 0.7152 * (2^14)/125 = 93.74269440) 1565 dscl_prog_data->easf_matrix_c2 = 1566 0x48BB; // fp1.5.10, C2 coefficient (LN_rec709: 0.0722 * (2^14)/125 = 9.46339840) 1567 dscl_prog_data->easf_matrix_c3 = 1568 0x0; // fp1.5.10, C3 coefficient 1569 } 1570 } else { 1571 dscl_prog_data->easf_ltonl_en = 0; // Non-Linear input 1572 dscl_prog_data->easf_matrix_c0 = 1573 0x3434; // fp1.5.10, C0 coefficient (LN_BT2020: 0.262695312500000) 1574 dscl_prog_data->easf_matrix_c1 = 1575 0x396D; // fp1.5.10, C1 coefficient (LN_BT2020: 0.678222656250000) 1576 dscl_prog_data->easf_matrix_c2 = 1577 0x2B97; // fp1.5.10, C2 coefficient (LN_BT2020: 0.059295654296875) 1578 dscl_prog_data->easf_matrix_c3 = 1579 0x0; // fp1.5.10, C3 coefficient 1580 } 1581 1582 if (spl_is_yuv420(format)) { /* TODO: 0 = RGB, 1 = YUV */ 1583 dscl_prog_data->easf_matrix_mode = 1; 1584 /* 1585 * 2-bit, BF3 chroma mode correction calculation mode 1586 * Needs to be disabled for YUV420 mode 1587 * Override lookup value 1588 */ 1589 dscl_prog_data->easf_v_bf3_mode = 0; 1590 dscl_prog_data->easf_h_bf3_mode = 0; 1591 } else 1592 dscl_prog_data->easf_matrix_mode = 0; 1593 1594 } 1595 1596 /*Set isharp noise detection */ 1597 static void spl_set_isharp_noise_det_mode(struct dscl_prog_data *dscl_prog_data, 1598 const struct spl_scaler_data *data) 1599 { 1600 // ISHARP_NOISEDET_MODE 1601 // 0: 3x5 as VxH 1602 // 1: 4x5 as VxH 1603 // 2: 1604 // 3: 5x5 as VxH 1605 if (data->taps.v_taps == 6) 1606 dscl_prog_data->isharp_noise_det.mode = 3; 1607 else if (data->taps.v_taps == 4) 1608 dscl_prog_data->isharp_noise_det.mode = 1; 1609 else if (data->taps.v_taps == 3) 1610 dscl_prog_data->isharp_noise_det.mode = 0; 1611 }; 1612 /* Set Sharpener data */ 1613 static void spl_set_isharp_data(struct dscl_prog_data *dscl_prog_data, 1614 struct adaptive_sharpness adp_sharpness, bool enable_isharp, 1615 enum linear_light_scaling lls_pref, enum spl_pixel_format format, 1616 const struct spl_scaler_data *data, struct spl_fixed31_32 ratio, 1617 enum system_setup setup, enum scale_to_sharpness_policy scale_to_sharpness_policy) 1618 { 1619 /* Turn off sharpener if not required */ 1620 if (!enable_isharp) { 1621 dscl_prog_data->isharp_en = 0; 1622 return; 1623 } 1624 1625 spl_build_isharp_1dlut_from_reference_curve(ratio, setup, adp_sharpness, 1626 scale_to_sharpness_policy); 1627 memcpy(dscl_prog_data->isharp_delta, spl_get_pregen_filter_isharp_1D_lut(setup), 1628 sizeof(uint32_t) * ISHARP_LUT_TABLE_SIZE); 1629 dscl_prog_data->sharpness_level = adp_sharpness.sharpness_level; 1630 1631 dscl_prog_data->isharp_en = 1; // ISHARP_EN 1632 // Set ISHARP_NOISEDET_MODE if htaps = 6-tap 1633 if (data->taps.h_taps == 6) { 1634 dscl_prog_data->isharp_noise_det.enable = 1; /* ISHARP_NOISEDET_EN */ 1635 spl_set_isharp_noise_det_mode(dscl_prog_data, data); /* ISHARP_NOISEDET_MODE */ 1636 } else 1637 dscl_prog_data->isharp_noise_det.enable = 0; // ISHARP_NOISEDET_EN 1638 // Program noise detection threshold 1639 dscl_prog_data->isharp_noise_det.uthreshold = 24; // ISHARP_NOISEDET_UTHRE 1640 dscl_prog_data->isharp_noise_det.dthreshold = 4; // ISHARP_NOISEDET_DTHRE 1641 // Program noise detection gain 1642 dscl_prog_data->isharp_noise_det.pwl_start_in = 3; // ISHARP_NOISEDET_PWL_START_IN 1643 dscl_prog_data->isharp_noise_det.pwl_end_in = 13; // ISHARP_NOISEDET_PWL_END_IN 1644 dscl_prog_data->isharp_noise_det.pwl_slope = 1623; // ISHARP_NOISEDET_PWL_SLOPE 1645 1646 if (lls_pref == LLS_PREF_NO) /* ISHARP_FMT_MODE */ 1647 dscl_prog_data->isharp_fmt.mode = 1; 1648 else 1649 dscl_prog_data->isharp_fmt.mode = 0; 1650 1651 dscl_prog_data->isharp_fmt.norm = 0x3C00; // ISHARP_FMT_NORM 1652 dscl_prog_data->isharp_lba.mode = 0; // ISHARP_LBA_MODE 1653 1654 if (setup == SDR_L) { 1655 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0 1656 dscl_prog_data->isharp_lba.in_seg[0] = 0; // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format 1657 dscl_prog_data->isharp_lba.base_seg[0] = 0; // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format 1658 dscl_prog_data->isharp_lba.slope_seg[0] = 62; // ISHARP LBA for Seg 0. SLOPE value in S5.3 format 1659 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1 1660 dscl_prog_data->isharp_lba.in_seg[1] = 130; // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format 1661 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format 1662 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format 1663 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2 1664 dscl_prog_data->isharp_lba.in_seg[2] = 450; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format 1665 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format 1666 dscl_prog_data->isharp_lba.slope_seg[2] = 0x18D; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -115 1667 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3 1668 dscl_prog_data->isharp_lba.in_seg[3] = 520; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format 1669 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format 1670 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format 1671 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4 1672 dscl_prog_data->isharp_lba.in_seg[4] = 520; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format 1673 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format 1674 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format 1675 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5 1676 dscl_prog_data->isharp_lba.in_seg[5] = 520; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format 1677 dscl_prog_data->isharp_lba.base_seg[5] = 0; // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format 1678 } else if (setup == HDR_L) { 1679 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0 1680 dscl_prog_data->isharp_lba.in_seg[0] = 0; // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format 1681 dscl_prog_data->isharp_lba.base_seg[0] = 0; // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format 1682 dscl_prog_data->isharp_lba.slope_seg[0] = 32; // ISHARP LBA for Seg 0. SLOPE value in S5.3 format 1683 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1 1684 dscl_prog_data->isharp_lba.in_seg[1] = 254; // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format 1685 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format 1686 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format 1687 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2 1688 dscl_prog_data->isharp_lba.in_seg[2] = 559; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format 1689 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format 1690 dscl_prog_data->isharp_lba.slope_seg[2] = 0x10C; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -244 1691 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3 1692 dscl_prog_data->isharp_lba.in_seg[3] = 592; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format 1693 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format 1694 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format 1695 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4 1696 dscl_prog_data->isharp_lba.in_seg[4] = 1023; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format 1697 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format 1698 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format 1699 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5 1700 dscl_prog_data->isharp_lba.in_seg[5] = 1023; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format 1701 dscl_prog_data->isharp_lba.base_seg[5] = 0; // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format 1702 } else { 1703 // ISHARP_LBA_PWL_SEG0: ISHARP Local Brightness Adjustment PWL Segment 0 1704 dscl_prog_data->isharp_lba.in_seg[0] = 0; // ISHARP LBA PWL for Seg 0. INPUT value in U0.10 format 1705 dscl_prog_data->isharp_lba.base_seg[0] = 0; // ISHARP LBA PWL for Seg 0. BASE value in U0.6 format 1706 dscl_prog_data->isharp_lba.slope_seg[0] = 40; // ISHARP LBA for Seg 0. SLOPE value in S5.3 format 1707 // ISHARP_LBA_PWL_SEG1: ISHARP LBA PWL Segment 1 1708 dscl_prog_data->isharp_lba.in_seg[1] = 204; // ISHARP LBA PWL for Seg 1. INPUT value in U0.10 format 1709 dscl_prog_data->isharp_lba.base_seg[1] = 63; // ISHARP LBA PWL for Seg 1. BASE value in U0.6 format 1710 dscl_prog_data->isharp_lba.slope_seg[1] = 0; // ISHARP LBA for Seg 1. SLOPE value in S5.3 format 1711 // ISHARP_LBA_PWL_SEG2: ISHARP LBA PWL Segment 2 1712 dscl_prog_data->isharp_lba.in_seg[2] = 818; // ISHARP LBA PWL for Seg 2. INPUT value in U0.10 format 1713 dscl_prog_data->isharp_lba.base_seg[2] = 63; // ISHARP LBA PWL for Seg 2. BASE value in U0.6 format 1714 dscl_prog_data->isharp_lba.slope_seg[2] = 0x1D9; // ISHARP LBA for Seg 2. SLOPE value in S5.3 format = -39 1715 // ISHARP_LBA_PWL_SEG3: ISHARP LBA PWL Segment 3 1716 dscl_prog_data->isharp_lba.in_seg[3] = 1023; // ISHARP LBA PWL for Seg 3.INPUT value in U0.10 format 1717 dscl_prog_data->isharp_lba.base_seg[3] = 0; // ISHARP LBA PWL for Seg 3. BASE value in U0.6 format 1718 dscl_prog_data->isharp_lba.slope_seg[3] = 0; // ISHARP LBA for Seg 3. SLOPE value in S5.3 format 1719 // ISHARP_LBA_PWL_SEG4: ISHARP LBA PWL Segment 4 1720 dscl_prog_data->isharp_lba.in_seg[4] = 1023; // ISHARP LBA PWL for Seg 4.INPUT value in U0.10 format 1721 dscl_prog_data->isharp_lba.base_seg[4] = 0; // ISHARP LBA PWL for Seg 4. BASE value in U0.6 format 1722 dscl_prog_data->isharp_lba.slope_seg[4] = 0; // ISHARP LBA for Seg 4. SLOPE value in S5.3 format 1723 // ISHARP_LBA_PWL_SEG5: ISHARP LBA PWL Segment 5 1724 dscl_prog_data->isharp_lba.in_seg[5] = 1023; // ISHARP LBA PWL for Seg 5.INPUT value in U0.10 format 1725 dscl_prog_data->isharp_lba.base_seg[5] = 0; // ISHARP LBA PWL for Seg 5. BASE value in U0.6 format 1726 } 1727 1728 // Program the nldelta soft clip values 1729 if (lls_pref == LLS_PREF_YES) { 1730 dscl_prog_data->isharp_nldelta_sclip.enable_p = 0; /* ISHARP_NLDELTA_SCLIP_EN_P */ 1731 dscl_prog_data->isharp_nldelta_sclip.pivot_p = 0; /* ISHARP_NLDELTA_SCLIP_PIVOT_P */ 1732 dscl_prog_data->isharp_nldelta_sclip.slope_p = 0; /* ISHARP_NLDELTA_SCLIP_SLOPE_P */ 1733 dscl_prog_data->isharp_nldelta_sclip.enable_n = 1; /* ISHARP_NLDELTA_SCLIP_EN_N */ 1734 dscl_prog_data->isharp_nldelta_sclip.pivot_n = 71; /* ISHARP_NLDELTA_SCLIP_PIVOT_N */ 1735 dscl_prog_data->isharp_nldelta_sclip.slope_n = 16; /* ISHARP_NLDELTA_SCLIP_SLOPE_N */ 1736 } else { 1737 dscl_prog_data->isharp_nldelta_sclip.enable_p = 1; /* ISHARP_NLDELTA_SCLIP_EN_P */ 1738 dscl_prog_data->isharp_nldelta_sclip.pivot_p = 70; /* ISHARP_NLDELTA_SCLIP_PIVOT_P */ 1739 dscl_prog_data->isharp_nldelta_sclip.slope_p = 24; /* ISHARP_NLDELTA_SCLIP_SLOPE_P */ 1740 dscl_prog_data->isharp_nldelta_sclip.enable_n = 1; /* ISHARP_NLDELTA_SCLIP_EN_N */ 1741 dscl_prog_data->isharp_nldelta_sclip.pivot_n = 70; /* ISHARP_NLDELTA_SCLIP_PIVOT_N */ 1742 dscl_prog_data->isharp_nldelta_sclip.slope_n = 24; /* ISHARP_NLDELTA_SCLIP_SLOPE_N */ 1743 } 1744 1745 // Set the values as per lookup table 1746 spl_set_blur_scale_data(dscl_prog_data, data); 1747 } 1748 1749 /* Calculate scaler parameters */ 1750 bool spl_calculate_scaler_params(struct spl_in *spl_in, struct spl_out *spl_out) 1751 { 1752 bool res = false; 1753 bool enable_easf_v = false; 1754 bool enable_easf_h = false; 1755 int vratio = 0; 1756 int hratio = 0; 1757 struct spl_scratch spl_scratch; 1758 struct spl_fixed31_32 isharp_scale_ratio; 1759 enum system_setup setup; 1760 bool enable_isharp = false; 1761 const struct spl_scaler_data *data = &spl_scratch.scl_data; 1762 1763 memset(&spl_scratch, 0, sizeof(struct spl_scratch)); 1764 spl_scratch.scl_data.h_active = spl_in->h_active; 1765 spl_scratch.scl_data.v_active = spl_in->v_active; 1766 1767 // All SPL calls 1768 /* recout calculation */ 1769 /* depends on h_active */ 1770 spl_calculate_recout(spl_in, &spl_scratch, spl_out); 1771 /* depends on pixel format */ 1772 spl_calculate_scaling_ratios(spl_in, &spl_scratch, spl_out); 1773 /* depends on scaling ratios and recout, does not calculate offset yet */ 1774 spl_calculate_viewport_size(spl_in, &spl_scratch); 1775 1776 res = spl_get_optimal_number_of_taps( 1777 spl_in->basic_out.max_downscale_src_width, spl_in, 1778 &spl_scratch, &spl_in->scaling_quality, &enable_easf_v, 1779 &enable_easf_h, &enable_isharp); 1780 /* 1781 * Depends on recout, scaling ratios, h_active and taps 1782 * May need to re-check lb size after this in some obscure scenario 1783 */ 1784 if (res) 1785 spl_calculate_inits_and_viewports(spl_in, &spl_scratch); 1786 // Handle 3d recout 1787 spl_handle_3d_recout(spl_in, &spl_scratch.scl_data.recout); 1788 // Clamp 1789 spl_clamp_viewport(&spl_scratch.scl_data.viewport); 1790 1791 // Save all calculated parameters in dscl_prog_data structure to program hw registers 1792 spl_set_dscl_prog_data(spl_in, &spl_scratch, spl_out, enable_easf_v, enable_easf_h, enable_isharp); 1793 1794 if (!res) 1795 return res; 1796 1797 if (spl_in->lls_pref == LLS_PREF_YES) { 1798 if (spl_in->is_hdr_on) 1799 setup = HDR_L; 1800 else 1801 setup = SDR_L; 1802 } else { 1803 if (spl_in->is_hdr_on) 1804 setup = HDR_NL; 1805 else 1806 setup = SDR_NL; 1807 } 1808 1809 // Set EASF 1810 spl_set_easf_data(&spl_scratch, spl_out, enable_easf_v, enable_easf_h, spl_in->lls_pref, 1811 spl_in->basic_in.format, setup, spl_in->sdr_white_level_nits); 1812 1813 // Set iSHARP 1814 vratio = spl_fixpt_ceil(spl_scratch.scl_data.ratios.vert); 1815 hratio = spl_fixpt_ceil(spl_scratch.scl_data.ratios.horz); 1816 if (vratio <= hratio) 1817 isharp_scale_ratio = spl_scratch.scl_data.recip_ratios.vert; 1818 else 1819 isharp_scale_ratio = spl_scratch.scl_data.recip_ratios.horz; 1820 1821 spl_set_isharp_data(spl_out->dscl_prog_data, spl_in->adaptive_sharpness, enable_isharp, 1822 spl_in->lls_pref, spl_in->basic_in.format, data, isharp_scale_ratio, setup, 1823 spl_in->debug.scale_to_sharpness_policy); 1824 1825 return res; 1826 } 1827