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

source code of linux/drivers/gpu/drm/amd/display/dc/sspl/dc_spl.c