Debian Codegraph @

media_softlet/agnostic/common/vp/hal/packet/vp_render_hdr_kernel.cpp

raw
1 /*
2 * Copyright (c) 2022-2023, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file vp_render_hdr_kernel.cpp
24 //! \brief render packet which used in by mediapipline.
25 //! \details render packet provide the structures and generate the cmd buffer which mediapipline will used.
26 //!
27 #include "vp_render_hdr_kernel.h"
28 #include "vp_render_kernel_obj.h"
29 #include "hal_kerneldll_next.h"
30 #include "hal_oca_interface_next.h"
31 #include "vp_user_feature_control.h"
32 #include "vp_hal_ddi_utils.h"
33
34 using namespace vp;
35
36 #define VP_COMP_SOURCE_DEPTH 16
37 #define VP_COMP_P010_DEPTH 0
38
39 // Compositing surface binding table index
40 #define VP_COMP_BTINDEX_LAYER0 0
41 #define VP_COMP_BTINDEX_LAYER0_FIELD0 0
42 #define VP_COMP_BTINDEX_LAYER1 3
43 #define VP_COMP_BTINDEX_LAYER2 6
44 #define VP_COMP_BTINDEX_LAYER3 9
45 #define VP_COMP_BTINDEX_LAYER4 12
46 #define VP_COMP_BTINDEX_LAYER5 15
47 #define VP_COMP_BTINDEX_LAYER6 18
48 #define VP_COMP_BTINDEX_LAYER7 21
49 #define VP_COMP_BTINDEX_RENDERTARGET 24
50 #define VP_COMP_BTINDEX_RT_SECOND 27 // Pre-SKL
51 #define VP_COMP_BTINDEX_L0_FIELD1_DUAL 48 // Pre-SKL
52 #define VP_HDR_SAMPLER_STATE_NUM 16
53
54 // CMFC macro
55 #define VP_COMP_BTINDEX_CSC_COEFF 34
56
57 #define VP_MAX_HDR_INPUT_LAYER 8
58 #define VP_MAX_HDR_OUTPUT_LAYER 1
59
60 #define DETAIL_STRONG_EDGE_WEIGHT 7
61 #define DETAIL_NON_EDGE_WEIGHT 1
62 #define DETAIL_REGULAR_EDGE_WEIGHT 2
63 #define DETAIL_WEAK_EDGE_THRESHOLD 1
64 #define DETAIL_STRONG_EDGE_THRESHOLD 8
65
66 #define VP_SAMPLER_INDEX_Y_NEAREST 1
67 #define VP_SAMPLER_INDEX_U_NEAREST 2
68 #define VP_SAMPLER_INDEX_V_NEAREST 3
69
70 #define VP_SAMPLER_INDEX_Y_BILINEAR 4
71 #define VP_SAMPLER_INDEX_U_BILINEAR 5
72 #define VP_SAMPLER_INDEX_V_BILINEAR 6
73
74 #define VP_HDR_DUMP_INPUT_LAYER0 "InputLayer0"
75 #define VP_HDR_DUMP_OETF1DLUT_SURFACE0 "OETF1DLUTSurfacce0"
76 #define VP_HDR_DUMP_COEFF_SURFACE "CoeffSurfacce"
77 #define VP_HDR_DUMP_TARGET_SURFACE0 "TargetSurface0"
78 #define VP_HDR_DUMP_RENDER_INPUT "RenderInput"
79
80 MEDIA_WALKER_HDR_STATIC_DATA g_cInit_MEDIA_STATIC_HDR =
81 {
82 // DWORD 0
83 {
84 { 0.0 }
85 },
86
87 // DWORD 1
88 {
89 { 0.0 }
90 },
91
92 // DWORD 2
93 {
94 { 0.0 }
95 },
96
97 // DWORD 3
98 {
99 { 0.0 }
100 },
101
102 // DWORD 4
103 {
104 { 0.0 }
105 },
106
107 // DWORD 5
108 {
109 { 0.0 }
110 },
111
112 // DWORD 6
113 {
114 { 0.0 }
115 },
116
117 // DWORD 7
118 {
119 { 0.0 }
120 },
121
122 // DWORD 8
123 {
124 { 0.0 }
125 },
126
127 // DWORD 9
128 {
129 { 0.0 }
130 },
131
132 // DWORD 10
133 {
134 { 0.0 }
135 },
136
137 // DWORD 11
138 {
139 { 0.0 }
140 },
141
142 // DWORD 12
143 {
144 { 0.0 }
145 },
146
147 // DWORD 13
148 {
149 { 0.0 }
150 },
151
152 // DWORD 14
153 {
154 { 0.0 }
155 },
156
157 // DWORD 15
158 {
159 { 0.0 }
160 },
161
162 // DWORD 16
163 {
164 { 0.0 }
165 },
166
167 // DWORD 17
168 {
169 { 0.0 }
170 },
171
172 // DWORD 18
173 {
174 { 0.0 }
175 },
176
177 // DWORD 19
178 {
179 { 0.0 }
180 },
181
182 // DWORD 20
183 {
184 { 0.0 }
185 },
186
187 // DWORD 21
188 {
189 { 0.0 }
190 },
191
192 // DWORD 22
193 {
194 { 0.0 }
195 },
196
197 // DWORD 23
198 {
199 { 0.0 }
200 },
201
202 // DWORD 24
203 {
204 { 0.0 }
205 },
206
207 // DWORD 25
208 {
209 { 0.0 }
210 },
211
212 // DWORD 26
213 {
214 { 0.0 }
215 },
216
217 // DWORD 27
218 {
219 { 0.0 }
220 },
221
222 // DWORD 28
223 {
224 { 0.0 }
225 },
226
227 // DWORD 29
228 {
229 { 0.0 }
230 },
231
232 // DWORD 30
233 {
234 { 0.0 }
235 },
236
237 // DWORD 31
238 {
239 { 0.0 }
240 },
241
242 // DWORD 32
243 {
244 { 0, 0 }
245 },
246
247 // DWORD 33
248 {
249 { 0, 0 }
250 },
251
252 // DWORD 34
253 {
254 { 0, 0 }
255 },
256
257 // DWORD 35
258 {
259 { 0, 0 }
260 },
261
262 // DWORD 36
263 {
264 { 0, 0 }
265 },
266
267 // DWORD 37
268 {
269 { 0, 0 }
270 },
271
272 // DWORD 38
273 {
274 { 0, 0 }
275 },
276
277 // DWORD 39
278 {
279 { 0, 0 }
280 },
281
282 // DWORD 40
283 {
284 { 0, 0 }
285 },
286
287 // DWORD 41
288 {
289 { 0, 0 }
290 },
291
292 // DWORD 42
293 {
294 { 0, 0 }
295 },
296
297 // DWORD 43
298 {
299 { 0, 0 }
300 },
301
302 // DWORD 44
303 {
304 { 0, 0 }
305 },
306
307 // DWORD 45
308 {
309 { 0, 0 }
310 },
311
312 // DWORD 46
313 {
314 { 0, 0 }
315 },
316
317 // DWORD 47
318 {
319 { 0, 0 }
320 },
321
322 // DWORD 48
323 {
324 {
325 0, // FormatDescriptorLayer0
326 0, // ChromaSittingLocationLayer0
327 0, // ChannelSwapEnablingFlagLayer0
328 0, // IEFBypassEnablingFlagLayer0
329 0, // RotationAngleMirrorDirectionLayer0
330 0, // SamplerIndexFirstPlaneLayer0
331 0, // SamplerIndexSecondThirdPlaneLayer0
332 0, // Reserved
333 0, // PriorCSCEnablingFlagLayer0
334 0, // EOTF1DLUTEnablingFlagLayer0
335 0, // CCMEnablingFlagLayer0
336 0, // OETF1DLUTEnablingFlagLayer0
337 0, // PostCSCEnablingFlagLayer0
338 0 // Enabling3DLUTFlagLayer0
339 }
340 },
341
342 // DWORD 49
343 {
344 {
345 0, // FormatDescriptorLayer1
346 0, // ChromaSittingLocationLayer1
347 0, // ChannelSwapEnablingFlagLayer1
348 0, // IEFBypassEnablingFlagLayer1
349 0, // RotationAngleMirrorDirectionLayer1
350 0, // SamplerIndexFirstPlaneLayer1
351 0, // SamplerIndexSecondThirdPlaneLayer1
352 0, // Reserved
353 0, // PriorCSCEnablingFlagLayer1
354 0, // EOTF1DLUTEnablingFlagLayer1
355 0, // CCMEnablingFlagLayer1
356 0, // OETF1DLUTEnablingFlagLayer1
357 0, // PostCSCEnablingFlagLayer1
358 0 // Enabling3DLUTFlagLayer1
359 }
360 },
361
362 // DWORD 50
363 {
364 {
365 0, // FormatDescriptorLayer2
366 0, // ChromaSittingLocationLayer2
367 0, // ChannelSwapEnablingFlagLayer2
368 0, // IEFBypassEnablingFlagLayer2
369 0, // RotationAngleMirrorDirectionLayer2
370 0, // SamplerIndexFirstPlaneLayer2
371 0, // SamplerIndexSecondThirdPlaneLayer2
372 0, // Reserved
373 0, // PriorCSCEnablingFlagLayer2
374 0, // EOTF1DLUTEnablingFlagLayer2
375 0, // CCMEnablingFlagLayer2
376 0, // OETF1DLUTEnablingFlagLayer2
377 0, // PostCSCEnablingFlagLayer2
378 0 // Enabling3DLUTFlagLayer2
379 }
380 },
381
382 // DWORD 51
383 {
384 {
385 0, // FormatDescriptorLayer3
386 0, // ChromaSittingLocationLayer3
387 0, // ChannelSwapEnablingFlagLayer3
388 0, // IEFBypassEnablingFlagLayer3
389 0, // RotationAngleMirrorDirectionLayer3
390 0, // SamplerIndexFirstPlaneLayer3
391 0, // SamplerIndexSecondThirdPlaneLayer3
392 0, // Reserved
393 0, // PriorCSCEnablingFlagLayer3
394 0, // EOTF1DLUTEnablingFlagLayer3
395 0, // CCMEnablingFlagLayer3
396 0, // OETF1DLUTEnablingFlagLayer3
397 0, // PostCSCEnablingFlagLayer3
398 0 // Enabling3DLUTFlagLayer3
399 }
400 },
401
402 // DWORD 52
403 {
404 {
405 0, // FormatDescriptorLayer4
406 0, // ChromaSittingLocationLayer4
407 0, // ChannelSwapEnablingFlagLayer4
408 0, // IEFBypassEnablingFlagLayer4
409 0, // RotationAngleMirrorDirectionLayer4
410 0, // SamplerIndexFirstPlaneLayer4
411 0, // SamplerIndexSecondThirdPlaneLayer4
412 0, // Reserved
413 0, // PriorCSCEnablingFlagLayer4
414 0, // EOTF1DLUTEnablingFlagLayer4
415 0, // CCMEnablingFlagLayer4
416 0, // OETF1DLUTEnablingFlagLayer4
417 0, // PostCSCEnablingFlagLayer4
418 0 // Enabling3DLUTFlagLayer4
419 }
420 },
421
422 // DWORD 53
423 {
424 {
425 0, // FormatDescriptorLayer5
426 0, // ChromaSittingLocationLayer5
427 0, // ChannelSwapEnablingFlagLayer5
428 0, // IEFBypassEnablingFlagLayer5
429 0, // RotationAngleMirrorDirectionLayer5
430 0, // SamplerIndexFirstPlaneLayer5
431 0, // SamplerIndexSecondThirdPlaneLayer5
432 0, // Reserved
433 0, // PriorCSCEnablingFlagLayer5
434 0, // EOTF1DLUTEnablingFlagLayer5
435 0, // CCMEnablingFlagLayer5
436 0, // OETF1DLUTEnablingFlagLayer5
437 0, // PostCSCEnablingFlagLayer5
438 0 // Enabling3DLUTFlagLayer5
439 }
440 },
441
442 // DWORD 54
443 {
444 {
445 0, // FormatDescriptorLayer6
446 0, // ChromaSittingLocationLayer6
447 0, // ChannelSwapEnablingFlagLayer6
448 0, // IEFBypassEnablingFlagLayer6
449 0, // RotationAngleMirrorDirectionLayer6
450 0, // SamplerIndexFirstPlaneLayer6
451 0, // SamplerIndexSecondThirdPlaneLayer6
452 0, // Reserved
453 0, // PriorCSCEnablingFlagLayer6
454 0, // EOTF1DLUTEnablingFlagLayer6
455 0, // CCMEnablingFlagLayer6
456 0, // OETF1DLUTEnablingFlagLayer6
457 0, // PostCSCEnablingFlagLayer6
458 0 // Enabling3DLUTFlagLayer6
459 }
460 },
461
462 // DWORD 55
463 {
464 {
465 0, // FormatDescriptorLayer7
466 0, // ChromaSittingLocationLayer7
467 0, // ChannelSwapEnablingFlagLayer7
468 0, // IEFBypassEnablingFlagLayer7
469 0, // RotationAngleMirrorDirectionLayer7
470 0, // SamplerIndexFirstPlaneLayer7
471 0, // SamplerIndexSecondThirdPlaneLayer7
472 0, // Reserved
473 0, // PriorCSCEnablingFlagLayer7
474 0, // EOTF1DLUTEnablingFlagLayer7
475 0, // CCMEnablingFlagLayer7
476 0, // OETF1DLUTEnablingFlagLayer7
477 0, // PostCSCEnablingFlagLayer7
478 0 // Enabling3DLUTFlagLayer7
479 }
480 },
481
482 // DWORD 56
483 {
484 { 0, 0, 0, 0 }
485 },
486
487 // DWORD 57
488 {
489 { 0, 0, 0, 0 }
490 },
491
492 // DWORD 58
493 {
494 {
495 0, // TwoLayerOperationLayer0
496 0, // TwoLayerOperationLayer1
497 0, // TwoLayerOperationLayer2
498 0 // TwoLayerOperationLayer3
499 }
500 },
501
502 // DWORD 59
503 {
504 {
505 0, // TwoLayerOperationLayer4
506 0, // TwoLayerOperationLayer5
507 0, // TwoLayerOperationLayer6
508 0 // TwoLayerOperationLayer7
509 }
510 },
511
512 // DWORD 60
513 {
514 { 0, 0 }
515 },
516
517 // DWORD 61
518 {
519 { 0, 0 }
520 },
521
522 // DWORD 62
523 {
524 { 0, 0 }
525 },
526
527 // DWORD 63
528 {
529 { 0, 0, 0, 0, 0, 0, 0 }
530 },
531 };
532
533
534 const int32_t VpRenderHdrKernel::s_bindingTableIndex[] =
535 {
536 VP_COMP_BTINDEX_LAYER0,
537 VP_COMP_BTINDEX_LAYER1,
538 VP_COMP_BTINDEX_LAYER2,
539 VP_COMP_BTINDEX_LAYER3,
540 VP_COMP_BTINDEX_LAYER4,
541 VP_COMP_BTINDEX_LAYER5,
542 VP_COMP_BTINDEX_LAYER6,
543 VP_COMP_BTINDEX_LAYER7
544 };
545
546 const int32_t VpRenderHdrKernel::s_bindingTableIndexField[] =
547 {
548 VP_COMP_BTINDEX_L0_FIELD1_DUAL,
549 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 1,
550 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 2,
551 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 3,
552 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 4,
553 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 5,
554 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 6,
555 VP_COMP_BTINDEX_L0_FIELD1_DUAL + 7
556 };
557
558 VpRenderHdrKernel::VpRenderHdrKernel(PVP_MHWINTERFACE hwInterface, PVpAllocator allocator) :
559 VpRenderKernelObj(hwInterface, (VpKernelID)kernelHdrMandatory, 0, VpRenderKernel::s_kernelNameNonAdvKernels, allocator)
560 {
561 VP_FUNC_CALL();
562
563 renderHal = hwInterface ? hwInterface->m_renderHal : nullptr;
564
565 m_kernelBinaryID = IDR_VP_HDR_mandatory;
566
567 m_renderHal = m_hwInterface ? m_hwInterface->m_renderHal : nullptr;
568 if (m_renderHal)
569 {
570 m_renderHal->bEnableP010SinglePass = false;
571 VP_RENDER_NORMALMESSAGE("m_renderHal->bEnableP010SinglePass %d", m_renderHal->bEnableP010SinglePass);
572 }
573 }
574
575 static inline RENDERHAL_SURFACE_TYPE ConvertVpSurfaceTypeToRenderSurfType(VPHAL_SURFACE_TYPE vpSurfType)
576 {
577 switch (vpSurfType)
578 {
579 case SURF_IN_BACKGROUND:
580 return RENDERHAL_SURF_IN_BACKGROUND;
581
582 case SURF_IN_PRIMARY:
583 return RENDERHAL_SURF_IN_PRIMARY;
584
585 case SURF_IN_SUBSTREAM:
586 return RENDERHAL_SURF_IN_SUBSTREAM;
587
588 case SURF_IN_REFERENCE:
589 return RENDERHAL_SURF_IN_REFERENCE;
590
591 case SURF_OUT_RENDERTARGET:
592 return RENDERHAL_SURF_OUT_RENDERTARGET;
593
594 case SURF_NONE:
595 default:
596 return RENDERHAL_SURF_NONE;
597 }
598 }
599
600 static inline RENDERHAL_SCALING_MODE ConvertVpScalingModeToRenderScalingMode(VPHAL_SCALING_MODE vpScalingMode)
601 {
602 switch (vpScalingMode)
603 {
604 case VPHAL_SCALING_NEAREST:
605 return RENDERHAL_SCALING_NEAREST;
606
607 case VPHAL_SCALING_BILINEAR:
608 return RENDERHAL_SCALING_BILINEAR;
609
610 case VPHAL_SCALING_AVS:
611 return RENDERHAL_SCALING_AVS;
612
613 default:
614 VP_RENDER_VERBOSEMESSAGE("Invalid VPHAL_SCALING_MODE %d, force to nearest mode.", vpScalingMode);
615 return RENDERHAL_SCALING_NEAREST;
616 }
617 }
618
619 static inline RENDERHAL_SAMPLE_TYPE ConvertVpSampleTypeToRenderSampleType(VPHAL_SAMPLE_TYPE SampleType)
620 {
621 switch (SampleType)
622 {
623 case SAMPLE_PROGRESSIVE:
624 return RENDERHAL_SAMPLE_PROGRESSIVE;
625
626 case SAMPLE_SINGLE_TOP_FIELD:
627 return RENDERHAL_SAMPLE_SINGLE_TOP_FIELD;
628
629 case SAMPLE_SINGLE_BOTTOM_FIELD:
630 return RENDERHAL_SAMPLE_SINGLE_BOTTOM_FIELD;
631
632 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
633 return RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD;
634
635 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
636 return RENDERHAL_SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD;
637
638 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
639 return RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD;
640
641 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
642 return RENDERHAL_SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD;
643
644 case SAMPLE_INVALID:
645 default:
646 VP_RENDER_VERBOSEMESSAGE("Invalid VPHAL_SAMPLE_TYPE %d.\n", SampleType);
647 return RENDERHAL_SAMPLE_INVALID;
648 }
649 }
650
651 static inline MHW_ROTATION VpRotationModeToRenderRotationMode(VPHAL_ROTATION Rotation)
652 {
653 MHW_ROTATION Mode = MHW_ROTATION_IDENTITY;
654
655 switch (Rotation)
656 {
657 case VPHAL_ROTATION_IDENTITY:
658 Mode = MHW_ROTATION_IDENTITY;
659 break;
660
661 case VPHAL_ROTATION_90:
662 Mode = MHW_ROTATION_90;
663 break;
664
665 case VPHAL_ROTATION_180:
666 Mode = MHW_ROTATION_180;
667 break;
668
669 case VPHAL_ROTATION_270:
670 Mode = MHW_ROTATION_270;
671 break;
672
673 case VPHAL_MIRROR_HORIZONTAL:
674 Mode = MHW_MIRROR_HORIZONTAL;
675 break;
676
677 case VPHAL_MIRROR_VERTICAL:
678 Mode = MHW_MIRROR_VERTICAL;
679 break;
680
681 case VPHAL_ROTATE_90_MIRROR_VERTICAL:
682 Mode = MHW_ROTATE_90_MIRROR_VERTICAL;
683 break;
684
685 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL:
686 Mode = MHW_ROTATE_90_MIRROR_HORIZONTAL;
687 break;
688
689 default:
690 VP_RENDER_VERBOSEMESSAGE("Invalid Rotation Angle.");
691 break;
692 }
693
694 return Mode;
695 }
696
697 static void Mat3MultiplyVec3(const Mat3 input, const Vec3 vec, Vec3 output)
698 {
699 output[0] = input[0][0] * vec[0] + input[0][1] * vec[1] + input[0][2] * vec[2];
700 output[1] = input[1][0] * vec[0] + input[1][1] * vec[1] + input[1][2] * vec[2];
701 output[2] = input[2][0] * vec[0] + input[2][1] * vec[1] + input[2][2] * vec[2];
702 }
703
704 static void Mat3Inverse(const Mat3 input, Mat3 output)
705 {
706 const float a0 = input[0][0];
707 const float a1 = input[0][1];
708 const float a2 = input[0][2];
709
710 const float b0 = input[1][0];
711 const float b1 = input[1][1];
712 const float b2 = input[1][2];
713
714 const float c0 = input[2][0];
715 const float c1 = input[2][1];
716 const float c2 = input[2][2];
717
718 float det = a0 * (b1 * c2 - b2 * c1) + a1 * (b2 * c0 - b0 * c2) + a2 * (b0 * c1 - b1 * c0);
719
720 if (det != 0.0f)
721 {
722 float det_recip = 1.0f / det;
723
724 output[0][0] = (b1 * c2 - b2 * c1) * det_recip;
725 output[0][1] = (a2 * c1 - a1 * c2) * det_recip;
726 output[0][2] = (a1 * b2 - a2 * b1) * det_recip;
727
728 output[1][0] = (b2 * c0 - b0 * c2) * det_recip;
729 output[1][1] = (a0 * c2 - a2 * c0) * det_recip;
730 output[1][2] = (a2 * b0 - a0 * b2) * det_recip;
731
732 output[2][0] = (b0 * c1 - b1 * c0) * det_recip;
733 output[2][1] = (a1 * c0 - a0 * c1) * det_recip;
734 output[2][2] = (a0 * b1 - a1 * b0) * det_recip;
735 }
736 else
737 {
738 // irreversible
739 output[0][0] = 1.0f;
740 output[0][1] = 0.0f;
741 output[0][2] = 0.0f;
742 output[1][0] = 0.0f;
743 output[1][1] = 1.0f;
744 output[1][2] = 0.0f;
745 output[2][0] = 0.0f;
746 output[2][1] = 0.0f;
747 output[2][2] = 1.0f;
748 }
749 }
750
751 static void RGB2CIEXYZMatrix(
752 const float xr, const float yr, const float xg, const float yg, const float xb, const float yb, const float xn, const float yn, Mat3 output)
753 {
754 const float zr = 1.0f - xr - yr;
755 const float zg = 1.0f - xg - yg;
756 const float zb = 1.0f - xb - yb;
757 const float zn = 1.0f - xn - yn;
758
759 // m * [ar, ag, ab]T = [xn / yn, 1.0f, zn / yn]T;
760 const Mat3 m =
761 {
762 xr, xg, xb, yr, yg, yb, zr, zg, zb};
763
764 Mat3 inversed_m;
765
766 Mat3Inverse(m, inversed_m);
767
768 const Vec3 XYZWithUnityY = {xn / yn, 1.0f, zn / yn};
769 float aragab[3];
770
771 Mat3MultiplyVec3(inversed_m, XYZWithUnityY, aragab);
772
773 output[0][0] = m[0][0] * aragab[0];
774 output[1][0] = m[1][0] * aragab[0];
775 output[2][0] = m[2][0] * aragab[0];
776 output[0][1] = m[0][1] * aragab[1];
777 output[1][1] = m[1][1] * aragab[1];
778 output[2][1] = m[2][1] * aragab[1];
779 output[0][2] = m[0][2] * aragab[2];
780 output[1][2] = m[1][2] * aragab[2];
781 output[2][2] = m[2][2] * aragab[2];
782 }
783
784 static void Mat3MultiplyMat3(const Mat3 left, const Mat3 right, Mat3 output)
785 {
786 output[0][0] = left[0][0] * right[0][0] + left[0][1] * right[1][0] + left[0][2] * right[2][0];
787 output[0][1] = left[0][0] * right[0][1] + left[0][1] * right[1][1] + left[0][2] * right[2][1];
788 output[0][2] = left[0][0] * right[0][2] + left[0][1] * right[1][2] + left[0][2] * right[2][2];
789 output[1][0] = left[1][0] * right[0][0] + left[1][1] * right[1][0] + left[1][2] * right[2][0];
790 output[1][1] = left[1][0] * right[0][1] + left[1][1] * right[1][1] + left[1][2] * right[2][1];
791 output[1][2] = left[1][0] * right[0][2] + left[1][1] * right[1][2] + left[1][2] * right[2][2];
792 output[2][0] = left[2][0] * right[0][0] + left[2][1] * right[1][0] + left[2][2] * right[2][0];
793 output[2][1] = left[2][0] * right[0][1] + left[2][1] * right[1][1] + left[2][2] * right[2][1];
794 output[2][2] = left[2][0] * right[0][2] + left[2][1] * right[1][2] + left[2][2] * right[2][2];
795 }
796
797 //!
798 //! \brief Calculate Yuv To Rgb Matrix
799 //! \details Calculate Yuv To Rgb Matrix
800 //! \param VPHAL_CSPACE src
801 //! [in] Source color space
802 //! \param VPHAL_CSPACE dst
803 //! [in] Dest color space
804 //! \param float* pTransferMatrix
805 //! [in] Pointer to input transfer matrix
806 //! \param float* pOutMatrix
807 //! [out] Pointer to output transfer matrix for curbe
808 //! \return MOS_STATUS
809 //!
810 MOS_STATUS VpRenderHdrKernel::VpHal_HdrCalcYuvToRgbMatrix(
811 VPHAL_CSPACE src,
812 VPHAL_CSPACE dst,
813 float *pTransferMatrix,
814 float *pOutMatrix)
815 {
816 VP_FUNC_CALL();
817
818 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
819 float Y_o = 0.0f, Y_e = 0.0f, C_z = 0.0f, C_e = 0.0f;
820 float R_o = 0.0f, R_e = 0.0f;
821
822 VP_PUBLIC_CHK_NULL_RETURN(pTransferMatrix);
823 VP_PUBLIC_CHK_NULL_RETURN(pOutMatrix);
824
825 VpHal_HdrGetRgbRangeAndOffset(dst, &R_o, &R_e);
826 VpHal_HdrGetYuvRangeAndOffset(src, &Y_o, &Y_e, &C_z, &C_e);
827
828 // after + (3x3)(3x3)
829 if (Y_e == 0.0f || C_e == 0.0f)
830 {
831 VP_RENDER_ASSERTMESSAGE("Y_e = %f and C_e = %f, should not be zero.", Y_e, C_e);
832 return MOS_STATUS_INVALID_PARAMETER;
833 }
834 pOutMatrix[0] = pTransferMatrix[0] * R_e / Y_e;
835 pOutMatrix[4] = pTransferMatrix[4] * R_e / Y_e;
836 pOutMatrix[8] = pTransferMatrix[8] * R_e / Y_e;
837 pOutMatrix[1] = pTransferMatrix[1] * R_e / C_e;
838 pOutMatrix[5] = pTransferMatrix[5] * R_e / C_e;
839 pOutMatrix[9] = pTransferMatrix[9] * R_e / C_e;
840 pOutMatrix[2] = pTransferMatrix[2] * R_e / C_e;
841 pOutMatrix[6] = pTransferMatrix[6] * R_e / C_e;
842 pOutMatrix[10] = pTransferMatrix[10] * R_e / C_e;
843
844 // (3x1) - (3x3)(3x3)(3x1)
845 pOutMatrix[3] = R_o - (pOutMatrix[0] * Y_o + pOutMatrix[1] * C_z + pOutMatrix[2] * C_z);
846 pOutMatrix[7] = R_o - (pOutMatrix[4] * Y_o + pOutMatrix[5] * C_z + pOutMatrix[6] * C_z);
847 pOutMatrix[11] = R_o - (pOutMatrix[8] * Y_o + pOutMatrix[9] * C_z + pOutMatrix[10] * C_z);
848
849 return eStatus;
850 }
851
852 //!
853 //! \brief Calculate Yuv Range and Offest
854 //! \details Calculate Yuv Range and Offest
855 //! \param VPHAL_CSPACE cspace
856 //! [in] Source color space
857 //! \param float* pLumaOffset
858 //! [out] Pointer to Luma Offset
859 //! \param float* pLumaExcursion
860 //! [out] Pointer to Luma Excursion
861 //! \param float* pChromaZero
862 //! [out] Pointer to Chroma Offset
863 //! \param float* pChromaExcursion
864 //! [out] Pointer to Chroma Excursion
865 //! \return MOS_STATUS
866 //!
867 MOS_STATUS VpRenderHdrKernel::VpHal_HdrGetYuvRangeAndOffset(
868 VPHAL_CSPACE cspace,
869 float *pLumaOffset,
870 float *pLumaExcursion,
871 float *pChromaZero,
872 float *pChromaExcursion)
873 {
874 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
875 VP_FUNC_CALL();
876 VP_PUBLIC_CHK_NULL_RETURN(pLumaOffset);
877 VP_PUBLIC_CHK_NULL_RETURN(pLumaExcursion);
878 VP_PUBLIC_CHK_NULL_RETURN(pChromaZero);
879 VP_PUBLIC_CHK_NULL_RETURN(pChromaExcursion);
880
881 switch (cspace)
882 {
883 case CSpace_BT601_FullRange:
884 case CSpace_BT709_FullRange:
885 case CSpace_BT601Gray_FullRange:
886 case CSpace_BT2020_FullRange:
887 *pLumaOffset = 0.0f;
888 *pLumaExcursion = 255.0f;
889 *pChromaZero = 128.0f;
890 *pChromaExcursion = 255.0f;
891 break;
892
893 case CSpace_BT601:
894 case CSpace_BT709:
895 case CSpace_xvYCC601: // since matrix is the same as 601, use the same range
896 case CSpace_xvYCC709: // since matrix is the same as 709, use the same range
897 case CSpace_BT601Gray:
898 case CSpace_BT2020:
899 *pLumaOffset = 16.0f;
900 *pLumaExcursion = 219.0f;
901 *pChromaZero = 128.0f;
902 *pChromaExcursion = 224.0f;
903 break;
904
905 default:
906 *pLumaOffset = 0.0f;
907 *pLumaExcursion = 255.0f;
908 *pChromaZero = 128.0f;
909 *pChromaExcursion = 255.0f;
910 break;
911 }
912
913 *pLumaOffset /= 255.0f;
914 *pLumaExcursion /= 255.0f;
915 *pChromaZero /= 255.0f;
916 *pChromaExcursion /= 255.0f;
917
918 return eStatus;
919 }
920
921 //!
922 //! \brief Calculate Rgb Range and Offest
923 //! \details Calculate Rgb Range and Offest
924 //! \param VPHAL_CSPACE cspace
925 //! [in] Source color space
926 //! \param float* pLumaOffset
927 //! [out] Pointer to Rgb Offset
928 //! \param float* pLumaExcursion
929 //! [out] Pointer to Rgb Excursion
930 //! \return MOS_STATUS
931 //!
932 MOS_STATUS VpRenderHdrKernel::VpHal_HdrGetRgbRangeAndOffset(
933 VPHAL_CSPACE cspace,
934 float *pRgbOffset,
935 float *pRgbExcursion)
936 {
937 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
938 VP_FUNC_CALL();
939 VP_PUBLIC_CHK_NULL_RETURN(pRgbOffset);
940 VP_PUBLIC_CHK_NULL_RETURN(pRgbExcursion);
941
942 switch (cspace)
943 {
944 case CSpace_sRGB:
945 case CSpace_BT2020_RGB:
946 *pRgbOffset = 0.0f;
947 *pRgbExcursion = 255.0f;
948 break;
949
950 case CSpace_stRGB:
951 case CSpace_BT2020_stRGB:
952 *pRgbOffset = 16.0f;
953 *pRgbExcursion = 219.0f;
954 break;
955
956 default:
957 *pRgbOffset = 0.0f;
958 *pRgbExcursion = 255.0f;
959 break;
960 }
961
962 *pRgbOffset /= 255.0f;
963 *pRgbExcursion /= 255.0f;
964
965 return eStatus;
966 }
967
968 //!
969 //! \brief Calculate Rgb To Yuv Matrix
970 //! \details Calculate Rgb To Yuv Matrix
971 //! \param VPHAL_CSPACE src
972 //! [in] Source color space
973 //! \param VPHAL_CSPACE dst
974 //! [in] Dest color space
975 //! \param float* pTransferMatrix
976 //! [in] Pointer to input transfer matrix
977 //! \param float* pOutMatrix
978 //! [out] Pointer to output transfer matrix for curbe
979 //! \return MOS_STATUS
980 //!
981 MOS_STATUS VpRenderHdrKernel::VpHal_HdrCalcRgbToYuvMatrix(
982 VPHAL_CSPACE src,
983 VPHAL_CSPACE dst,
984 float *pTransferMatrix,
985 float *pOutMatrix)
986 {
987 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
988 float Y_o = 0.0f, Y_e = 0.0f, C_z = 0.0f, C_e = 0.0f;
989 float R_o = 0.0f, R_e = 0.0f;
990 VP_FUNC_CALL();
991 VP_PUBLIC_CHK_NULL_RETURN(pTransferMatrix);
992 VP_PUBLIC_CHK_NULL_RETURN(pOutMatrix);
993
994 VpHal_HdrGetRgbRangeAndOffset(src, &R_o, &R_e);
995 VpHal_HdrGetYuvRangeAndOffset(dst, &Y_o, &Y_e, &C_z, &C_e);
996
997 if (R_e == 0.0f )
998 {
999 VP_RENDER_ASSERTMESSAGE("R_e = %f should not be zero.", R_e);
1000 return MOS_STATUS_INVALID_PARAMETER;
1001 }
1002 // multiplication of + onwards
1003 pOutMatrix[0] = pTransferMatrix[0] * Y_e / R_e;
1004 pOutMatrix[1] = pTransferMatrix[1] * Y_e / R_e;
1005 pOutMatrix[2] = pTransferMatrix[2] * Y_e / R_e;
1006 pOutMatrix[4] = pTransferMatrix[4] * C_e / R_e;
1007 pOutMatrix[5] = pTransferMatrix[5] * C_e / R_e;
1008 pOutMatrix[6] = pTransferMatrix[6] * C_e / R_e;
1009 pOutMatrix[8] = pTransferMatrix[8] * C_e / R_e;
1010 pOutMatrix[9] = pTransferMatrix[9] * C_e / R_e;
1011 pOutMatrix[10] = pTransferMatrix[10] * C_e / R_e;
1012
1013 pOutMatrix[7] = Y_o - Y_e * R_o / R_e;
1014 pOutMatrix[3] = C_z;
1015 pOutMatrix[11] = C_z;
1016
1017 return eStatus;
1018 }
1019
1020 //!
1021 //! \brief Calculate CCM Matrix
1022 //! \details Calculate CCM Matrix
1023 //! \param float* pTransferMatrix
1024 //! [in] Pointer to input transfer matrix
1025 //! \param float* pOutMatrix
1026 //! [out] Pointer to output transfer matrix for curbe
1027 //! \return MOS_STATUS
1028 //!
1029 MOS_STATUS VpRenderHdrKernel::VpHal_HdrCalcCCMMatrix(
1030 float *pTransferMatrix,
1031 float *pOutMatrix)
1032 {
1033 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1034 VP_FUNC_CALL();
1035 VP_PUBLIC_CHK_NULL_RETURN(pTransferMatrix);
1036 VP_PUBLIC_CHK_NULL_RETURN(pOutMatrix);
1037
1038 // multiplication of + onwards
1039 pOutMatrix[0] = pTransferMatrix[1];
1040 pOutMatrix[1] = pTransferMatrix[2];
1041 pOutMatrix[2] = pTransferMatrix[0];
1042 pOutMatrix[4] = pTransferMatrix[5];
1043 pOutMatrix[5] = pTransferMatrix[6];
1044 pOutMatrix[6] = pTransferMatrix[4];
1045 pOutMatrix[8] = pTransferMatrix[9];
1046 pOutMatrix[9] = pTransferMatrix[10];
1047 pOutMatrix[10] = pTransferMatrix[8];
1048
1049 pOutMatrix[3] = pTransferMatrix[11];
1050 pOutMatrix[7] = pTransferMatrix[3];
1051 pOutMatrix[11] = pTransferMatrix[7];
1052
1053 return eStatus;
1054 }
1055
1056 void VpRenderHdrKernel::HdrCalculateCCMWithMonitorGamut(
1057 VPHAL_HDR_CCM_TYPE CCMType,
1058 HDR_PARAMS Target,
1059 float TempMatrix[12])
1060 {
1061 float src_xr = 1.0f, src_yr = 1.0f;
1062 float src_xg = 1.0f, src_yg = 1.0f;
1063 float src_xb = 1.0f, src_yb = 1.0f;
1064 float src_xn = 1.0f, src_yn = 1.0f;
1065
1066 float dst_xr = 1.0f, dst_yr = 1.0f;
1067 float dst_xg = 1.0f, dst_yg = 1.0f;
1068 float dst_xb = 1.0f, dst_yb = 1.0f;
1069 float dst_xn = 1.0f, dst_yn = 1.0f;
1070
1071 Mat3 SrcMatrix = {1.0f};
1072 Mat3 DstMatrix = {1.0f};
1073 Mat3 DstMatrixInverse = {1.0f};
1074 Mat3 SrcToDstMatrix = {1.0f};
1075
1076 Mat3 BT709ToBT2020Matrix = {1.0f};
1077 Mat3 BT2020ToBT709Matrix = {1.0f};
1078
1079 if (CCMType == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX)
1080 {
1081 src_xr = 0.708f;
1082 src_yr = 0.292f;
1083 src_xg = 0.170f;
1084 src_yg = 0.797f;
1085 src_xb = 0.131f;
1086 src_yb = 0.046f;
1087 src_xn = 0.3127f;
1088 src_yn = 0.3290f;
1089
1090 dst_xr = Target.display_primaries_x[2] / 50000.0f;
1091 dst_yr = Target.display_primaries_y[2] / 50000.0f;
1092 dst_xg = Target.display_primaries_x[0] / 50000.0f;
1093 dst_yg = Target.display_primaries_y[0] / 50000.0f;
1094 dst_xb = Target.display_primaries_x[1] / 50000.0f;
1095 dst_yb = Target.display_primaries_y[1] / 50000.0f;
1096 dst_xn = Target.white_point_x / 50000.0f;
1097 dst_yn = Target.white_point_y / 50000.0f;
1098 }
1099 else if (CCMType == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX)
1100 {
1101 src_xr = Target.display_primaries_x[2] / 50000.0f;
1102 src_yr = Target.display_primaries_y[2] / 50000.0f;
1103 src_xg = Target.display_primaries_x[0] / 50000.0f;
1104 src_yg = Target.display_primaries_y[0] / 50000.0f;
1105 src_xb = Target.display_primaries_x[1] / 50000.0f;
1106 src_yb = Target.display_primaries_y[1] / 50000.0f;
1107 src_xn = Target.white_point_x / 50000.0f;
1108 src_yn = Target.white_point_y / 50000.0f;
1109
1110 dst_xr = 0.708f;
1111 dst_yr = 0.292f;
1112 dst_xg = 0.170f;
1113 dst_yg = 0.797f;
1114 dst_xb = 0.131f;
1115 dst_yb = 0.046f;
1116 dst_xn = 0.3127f;
1117 dst_yn = 0.3290f;
1118 }
1119 else
1120 {
1121 // VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX
1122 src_xr = Target.display_primaries_x[2] / 50000.0f;
1123 src_yr = Target.display_primaries_y[2] / 50000.0f;
1124 src_xg = Target.display_primaries_x[0] / 50000.0f;
1125 src_yg = Target.display_primaries_y[0] / 50000.0f;
1126 src_xb = Target.display_primaries_x[1] / 50000.0f;
1127 src_yb = Target.display_primaries_y[1] / 50000.0f;
1128 src_xn = Target.white_point_x / 50000.0f;
1129 src_yn = Target.white_point_y / 50000.0f;
1130
1131 dst_xr = 0.64f;
1132 dst_yr = 0.33f;
1133 dst_xg = 0.30f;
1134 dst_yg = 0.60f;
1135 dst_xb = 0.15f;
1136 dst_yb = 0.06f;
1137 dst_xn = 0.3127f;
1138 dst_yn = 0.3290f;
1139 }
1140
1141 RGB2CIEXYZMatrix(
1142 src_xr, src_yr, src_xg, src_yg, src_xb, src_yb, src_xn, src_yn, SrcMatrix);
1143
1144 RGB2CIEXYZMatrix(
1145 dst_xr, dst_yr, dst_xg, dst_yg, dst_xb, dst_yb, dst_xn, dst_yn, DstMatrix);
1146
1147 Mat3Inverse(DstMatrix, DstMatrixInverse);
1148 Mat3MultiplyMat3(DstMatrixInverse, SrcMatrix, SrcToDstMatrix);
1149
1150 TempMatrix[0] = SrcToDstMatrix[0][0];
1151 TempMatrix[1] = SrcToDstMatrix[0][1];
1152 TempMatrix[2] = SrcToDstMatrix[0][2];
1153 TempMatrix[3] = 0.0f;
1154 TempMatrix[4] = SrcToDstMatrix[1][0];
1155 TempMatrix[5] = SrcToDstMatrix[1][1];
1156 TempMatrix[6] = SrcToDstMatrix[1][2];
1157 TempMatrix[7] = 0.0f;
1158 TempMatrix[8] = SrcToDstMatrix[2][0];
1159 TempMatrix[9] = SrcToDstMatrix[2][1];
1160 TempMatrix[10] = SrcToDstMatrix[2][2];
1161 TempMatrix[11] = 0.0f;
1162
1163 return;
1164 }
1165
1166 CSC_COEFF_FORMAT HdrConvert_CSC_Coeff_To_Register_Format(double coeff)
1167 {
1168 VP_FUNC_CALL();
1169
1170 CSC_COEFF_FORMAT outVal = {0};
1171 uint32_t shift_factor = 0;
1172
1173 if (coeff < 0)
1174 {
1175 outVal.sign = 1;
1176 coeff = -coeff;
1177 }
1178
1179 // range check
1180 if (coeff > MAX_CSC_COEFF_VAL_ICL)
1181 coeff = MAX_CSC_COEFF_VAL_ICL;
1182
1183 if (coeff < 0.125) //0.000bbbbbbbbb
1184 {
1185 outVal.exponent = 3;
1186 shift_factor = 12;
1187 }
1188 else if (coeff >= 0.125 && coeff < 0.25) //0.00bbbbbbbbb
1189 {
1190 outVal.exponent = 2;
1191 shift_factor = 11;
1192 }
1193 else if (coeff >= 0.25 && coeff < 0.5) //0.0bbbbbbbbb
1194 {
1195 outVal.exponent = 1;
1196 shift_factor = 10;
1197 }
1198 else if (coeff >= 0.5 && coeff < 1.0) // 0.bbbbbbbbb
1199 {
1200 outVal.exponent = 0;
1201 shift_factor = 9;
1202 }
1203 else if (coeff >= 1.0 && coeff < 2.0) //b.bbbbbbbb
1204 {
1205 outVal.exponent = 7;
1206 shift_factor = 8;
1207 }
1208 else if (coeff >= 2.0) // bb.bbbbbbb
1209 {
1210 outVal.exponent = 6;
1211 shift_factor = 7;
1212 }
1213
1214 //Convert float to integer
1215 outVal.mantissa = static_cast<uint32_t>(round(coeff * (double)(1 << (int)shift_factor)));
1216
1217 return outVal;
1218 }
1219
1220 double HdrConvert_CSC_Coeff_Register_Format_To_Double(CSC_COEFF_FORMAT regVal)
1221 {
1222 VP_FUNC_CALL();
1223
1224 double outVal = 0;
1225
1226 switch (regVal.exponent)
1227 {
1228 case 0:
1229 outVal = (double)regVal.mantissa / 512.0;
1230 break;
1231 case 1:
1232 outVal = (double)regVal.mantissa / 1024.0;
1233 break;
1234 case 2:
1235 outVal = (double)regVal.mantissa / 2048.0;
1236 break;
1237 case 3:
1238 outVal = (double)regVal.mantissa / 4096.0;
1239 break;
1240 case 6:
1241 outVal = (double)regVal.mantissa / 128.0;
1242 break;
1243 case 7:
1244 outVal = (double)regVal.mantissa / 256.0;
1245 break;
1246 }
1247
1248 if (regVal.sign)
1249 {
1250 outVal = -outVal;
1251 }
1252
1253 return outVal;
1254 }
1255
1256 float HdrLimitFP32PrecisionToF3_9(float fp)
1257 {
1258 VP_FUNC_CALL();
1259
1260 double dbInput = static_cast<double>(fp);
1261 double dbOutput = HdrConvert_CSC_Coeff_Register_Format_To_Double(HdrConvert_CSC_Coeff_To_Register_Format(dbInput));
1262 return static_cast<float>(dbOutput);
1263 }
1264
1265 void VpRenderHdrKernel::HdrLimitFP32ArrayPrecisionToF3_9(float fps[], size_t size)
1266 {
1267 VP_FUNC_CALL();
1268
1269 for (size_t i = 0; i < size; i++)
1270 {
1271 fps[i] = HdrLimitFP32PrecisionToF3_9(fps[i]);
1272 }
1273 }
1274
1275 typedef float (*pfnOETFFunc)(float radiance);
1276
1277 float HdrOETF2084(float c)
1278 {
1279 static const double C1 = 0.8359375;
1280 static const double C2 = 18.8515625;
1281 static const double C3 = 18.6875;
1282 static const double M1 = 0.1593017578125;
1283 static const double M2 = 78.84375;
1284
1285 double tmp = c;
1286 double numerator = pow(tmp, M1);
1287 double denominator = numerator;
1288
1289 denominator = 1.0 + C3 * denominator;
1290 numerator = C1 + C2 * numerator;
1291 numerator = numerator / denominator;
1292
1293 return (float)pow(numerator, M2);
1294 }
1295
1296 float HdrOETFBT709(float c)
1297 {
1298 static const double E0 = 0.45;
1299 static const double C1 = 0.099;
1300 static const double C2 = 4.5;
1301 static const double P0 = 0.018;
1302
1303 double tmp = c;
1304 double result;
1305
1306 if (tmp <= P0)
1307 {
1308 result = C2 * tmp;
1309 }
1310 else
1311 {
1312 result = (C1 + 1.0) * pow(tmp, E0) - C1;
1313 }
1314 return (float)result;
1315 }
1316
1317 float HdrOETFsRGB(float c)
1318 {
1319 static const double E1 = 2.4;
1320 static const double C1 = 0.055;
1321 static const double C2 = 12.92;
1322 static const double P0 = 0.0031308;
1323
1324 double tmp = c;
1325 double result;
1326
1327 if (tmp <= P0)
1328 {
1329 result = C2 * tmp;
1330 }
1331 else
1332 {
1333 result = (C1 + 1.0) * pow(tmp, 1.0 / E1) - C1;
1334 }
1335 return (float)result;
1336 }
1337
1338 // Non-uniform OETF LUT generator.
1339 void HdrGenerate2SegmentsOETFLUT(float fStretchFactor, pfnOETFFunc oetfFunc, uint16_t *lut)
1340 {
1341 int i = 0, j = 0;
1342
1343 for (i = 0; i < VPHAL_HDR_OETF_1DLUT_HEIGHT; ++i)
1344 {
1345 for (j = 0; j < VPHAL_HDR_OETF_1DLUT_WIDTH; ++j)
1346 {
1347 int idx = j + i * (VPHAL_HDR_OETF_1DLUT_WIDTH - 1);
1348 float a = (idx < 32) ? ((1.0f / 1024.0f) * idx) : ((1.0f / 32.0f) * (idx - 31));
1349
1350 if (a > 1.0f)
1351 a = 1.0f;
1352
1353 a *= fStretchFactor;
1354 lut[i * VPHAL_HDR_OETF_1DLUT_WIDTH + j] = VpHal_FloatToHalfFloat(oetfFunc(a));
1355 }
1356 }
1357 }
1358
1359 //!
1360 //! \brief Color Transfer for Hdr 3d Lut
1361 //! \details Color Transfer for Hdr 3d Lut
1362 //! \param PVPHAL_HDR_STATE pHdrState
1363 //! [in] Pointer to Hdr State
1364 //! \param int32_t iIndex
1365 //! [in] Input Surface index
1366 //! \param float fInputX
1367 //! [in] Input color for x axis of 3D Lut
1368 //! \param float fInputY
1369 //! [in] Input color for y axis of 3D Lut
1370 //! \param float fInputZ
1371 //! [in] Input color for z axis of 3D Lut
1372 //! \param uint16_t *puOutputX
1373 //! [in] Output color for x axis of 3D Lut
1374 //! \param uint16_t *puOutputX
1375 //! [in] Output color for y axis of 3D Lut
1376 //! \param uint16_t *puOutputX
1377 //! [in] Output color for z axis of 3D Lut
1378 //! \return MOS_STATUS
1379 //!
1380 MOS_STATUS VpRenderHdrKernel::VpHal_HdrColorTransfer3dLut(
1381 PRENDER_HDR_PARAMS params,
1382 int32_t iIndex,
1383 float fInputX,
1384 float fInputY,
1385 float fInputZ,
1386 uint16_t *puOutputX,
1387 uint16_t *puOutputY,
1388 uint16_t *puOutputZ)
1389 {
1390 VP_FUNC_CALL();
1391
1392 float PriorCscMatrix[12] = {}, PostCscMatrix[12] = {};
1393 float TempMatrix[12] = {};
1394 double fTempX = 0, fTempY = 0, fTempZ = 0;
1395 double fTemp1X = 0, fTemp1Y = 0, fTemp1Z = 0;
1396 double fTemp = 0;
1397 double m1 = 0.1593017578125; // SMPTE ST2084 EOTF parameters
1398 double m2 = 78.84375; // SMPTE ST2084 EOTF parameters
1399 double c2 = 18.8515625; // SMPTE ST2084 EOTF parameters
1400 double c3 = 18.6875; // SMPTE ST2084 EOTF parameters
1401 double c1 = c3 - c2 + 1; // SMPTE ST2084 EOTF parameters
1402
1403 VP_PUBLIC_CHK_NULL_RETURN(params);
1404 VP_PUBLIC_CHK_NULL_RETURN(puOutputX);
1405 VP_PUBLIC_CHK_NULL_RETURN(puOutputX);
1406 VP_PUBLIC_CHK_NULL_RETURN(puOutputX);
1407
1408 fTempX = (double)fInputX;
1409 fTempY = (double)fInputY;
1410 fTempZ = (double)fInputZ;
1411
1412 #define SET_MATRIX(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _c10, _c11) \
1413 { \
1414 TempMatrix[0] = _c0; \
1415 TempMatrix[1] = _c1; \
1416 TempMatrix[2] = _c2; \
1417 TempMatrix[3] = _c3; \
1418 TempMatrix[4] = _c4; \
1419 TempMatrix[5] = _c5; \
1420 TempMatrix[6] = _c6; \
1421 TempMatrix[7] = _c7; \
1422 TempMatrix[8] = _c8; \
1423 TempMatrix[9] = _c9; \
1424 TempMatrix[10] = _c10; \
1425 TempMatrix[11] = _c11; \
1426 }
1427
1428 #define CLAMP_MIN_MAX(_a, _min, _max) \
1429 { \
1430 if (_a < _min) \
1431 { \
1432 _a = _min; \
1433 } \
1434 if (_a > _max) \
1435 { \
1436 _a = _max; \
1437 } \
1438 }
1439
1440 auto inputSurface = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrInputLayer0 + iIndex));
1441 VP_SURFACE *input = (m_surfaceGroup->end() != inputSurface) ? inputSurface->second : nullptr;
1442 // EOTF/CCM/Tone Mapping/OETF require RGB input
1443 // So if prior CSC is needed, it will always be YUV to RGB conversion
1444 if (params->StageEnableFlags[iIndex].PriorCSCEnable)
1445 {
1446 if (params->PriorCSC[iIndex] == VPHAL_HDR_CSC_YUV_TO_RGB_BT601)
1447 {
1448 SET_MATRIX(1.000000f, 0.000000f, 1.402000f, 0.000000f, 1.000000f, -0.344136f, -0.714136f, 0.000000f, 1.000000f, 1.772000f, 0.000000f, 0.000000f);
1449 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT601, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1450 }
1451 else if (params->PriorCSC[iIndex] == VPHAL_HDR_CSC_YUV_TO_RGB_BT709)
1452 {
1453 SET_MATRIX(1.000000f, 0.000000f, 1.574800f, 0.000000f, 1.000000f, -0.187324f, -0.468124f, 0.000000f, 1.000000f, 1.855600f, 0.000000f, 0.000000f);
1454 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT709, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1455 }
1456 else if (params->PriorCSC[iIndex] == VPHAL_HDR_CSC_YUV_TO_RGB_BT2020)
1457 {
1458 SET_MATRIX(1.000000f, 0.000000f, 1.474600f, 0.000000f, 1.000000f, -0.164550f, -0.571350f, 0.000000f, 1.000000f, 1.881400f, 0.000000f, 0.000000f);
1459 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT2020, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1460 }
1461 else
1462 {
1463 VP_RENDER_ASSERTMESSAGE("Invalid Prior CSC parameter.");
1464 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1465 }
1466
1467 fTemp1X = fTempX;
1468 fTemp1Y = fTempY;
1469 fTemp1Z = fTempZ;
1470
1471 if (input && (input->osSurface->Format == Format_AYUV))
1472 {
1473 fTempX = PriorCscMatrix[0] * fTemp1Y + PriorCscMatrix[1] * fTemp1Z + PriorCscMatrix[2] * fTemp1X + PriorCscMatrix[3];
1474 fTempY = PriorCscMatrix[4] * fTemp1Y + PriorCscMatrix[5] * fTemp1Z + PriorCscMatrix[6] * fTemp1X + PriorCscMatrix[7];
1475 fTempZ = PriorCscMatrix[8] * fTemp1Y + PriorCscMatrix[9] * fTemp1Z + PriorCscMatrix[10] * fTemp1X + PriorCscMatrix[11];
1476 }
1477 else
1478 {
1479 fTempX = PriorCscMatrix[0] * fTemp1Z + PriorCscMatrix[1] * fTemp1Y + PriorCscMatrix[2] * fTemp1X + PriorCscMatrix[3];
1480 fTempY = PriorCscMatrix[4] * fTemp1Z + PriorCscMatrix[5] * fTemp1Y + PriorCscMatrix[6] * fTemp1X + PriorCscMatrix[7];
1481 fTempZ = PriorCscMatrix[8] * fTemp1Z + PriorCscMatrix[9] * fTemp1Y + PriorCscMatrix[10] * fTemp1X + PriorCscMatrix[11];
1482 }
1483
1484 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1485 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1486 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1487 }
1488
1489 if (params->StageEnableFlags[iIndex].EOTFEnable)
1490 {
1491 if (params->EOTFGamma[iIndex] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
1492 {
1493 if (fTempX < 0.081)
1494 {
1495 fTempX = fTempX / 4.5;
1496 }
1497 else
1498 {
1499 fTempX = (fTempX + 0.099) / 1.099;
1500 fTempX = pow(fTempX, 1.0 / 0.45);
1501 }
1502
1503 if (fTempY < 0.081)
1504 {
1505 fTempY = fTempY / 4.5;
1506 }
1507 else
1508 {
1509 fTempY = (fTempY + 0.099) / 1.099;
1510 fTempY = pow(fTempY, 1.0 / 0.45);
1511 }
1512
1513 if (fTempZ < 0.081)
1514 {
1515 fTempZ = fTempZ / 4.5;
1516 }
1517 else
1518 {
1519 fTempZ = (fTempZ + 0.099) / 1.099;
1520 fTempZ = pow(fTempZ, 1.0 / 0.45);
1521 }
1522 }
1523 else if (params->EOTFGamma[iIndex] == VPHAL_GAMMA_SMPTE_ST2084)
1524 {
1525 fTempX = pow(fTempX, 1.0f / m2);
1526 fTemp = c2 - c3 * fTempX;
1527 fTempX = fTempX > c1 ? fTempX - c1 : 0;
1528 fTempX = fTempX / fTemp;
1529 fTempX = pow(fTempX, 1.0f / m1);
1530
1531 fTempY = pow(fTempY, 1.0f / m2);
1532 fTemp = c2 - c3 * fTempY;
1533 fTempY = fTempY > c1 ? fTempY - c1 : 0;
1534 fTempY = fTempY / fTemp;
1535 fTempY = pow(fTempY, 1.0f / m1);
1536
1537 fTempZ = pow(fTempZ, 1.0f / m2);
1538 fTemp = c2 - c3 * fTempZ;
1539 fTempZ = fTempZ > c1 ? fTempZ - c1 : 0;
1540 fTempZ = fTempZ / fTemp;
1541 fTempZ = pow(fTempZ, 1.0f / m1);
1542 }
1543 else if (params->EOTFGamma[iIndex] == VPHAL_GAMMA_BT1886)
1544 {
1545 if (fTempX < -0.0f)
1546 {
1547 fTempX = 0;
1548 }
1549 else
1550 {
1551 fTempX = pow(fTempX, 2.4);
1552 }
1553
1554 if (fTempY < -0.0f)
1555 {
1556 fTempY = 0;
1557 }
1558 else
1559 {
1560 fTempY = pow(fTempY, 2.4);
1561 }
1562
1563 if (fTempZ < -0.0f)
1564 {
1565 fTempZ = 0;
1566 }
1567 else
1568 {
1569 fTempZ = pow(fTempZ, 2.4);
1570 }
1571 }
1572 else
1573 {
1574 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
1575 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1576 }
1577
1578 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1579 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1580 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1581 }
1582
1583 if (params->StageEnableFlags[iIndex].CCMEnable)
1584 {
1585 // BT709 to BT2020 CCM
1586 if (params->CCM[iIndex] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1587 {
1588 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1589 }
1590 // BT2020 to BT709 CCM
1591 else if (params->CCM[iIndex] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1592 {
1593 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1594 }
1595 else
1596 {
1597 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
1598 }
1599
1600 fTemp1X = fTempX;
1601 fTemp1Y = fTempY;
1602 fTemp1Z = fTempZ;
1603
1604 fTempX = TempMatrix[0] * fTemp1X + TempMatrix[1] * fTemp1Y + TempMatrix[2] * fTemp1Z + TempMatrix[3];
1605 fTempY = TempMatrix[4] * fTemp1X + TempMatrix[5] * fTemp1Y + TempMatrix[6] * fTemp1Z + TempMatrix[7];
1606 fTempZ = TempMatrix[8] * fTemp1X + TempMatrix[9] * fTemp1Y + TempMatrix[10] * fTemp1Z + TempMatrix[11];
1607
1608 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1609 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1610 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1611 }
1612
1613 if (params->StageEnableFlags[iIndex].PWLFEnable)
1614 {
1615 VpHal_HdrToneMapping3dLut(params->HdrMode[iIndex], fTempX, fTempY, fTempZ, &fTempX, &fTempY, &fTempZ);
1616
1617 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1618 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1619 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1620 }
1621
1622 if (params->StageEnableFlags[iIndex].CCMExt1Enable)
1623 {
1624 // BT709 to BT2020 CCM
1625 if (params->CCMExt1[iIndex] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1626 {
1627 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1628 }
1629 // BT2020 to BT709 CCM
1630 else if (params->CCMExt1[iIndex] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1631 {
1632 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1633 }
1634 else if (params->CCMExt1[iIndex] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
1635 params->CCMExt1[iIndex] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
1636 params->CCMExt1[iIndex] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
1637 {
1638 HdrCalculateCCMWithMonitorGamut(params->CCMExt1[iIndex], params->targetHDRParams[0], TempMatrix);
1639 }
1640 else
1641 {
1642 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
1643 }
1644
1645 fTemp1X = fTempX;
1646 fTemp1Y = fTempY;
1647 fTemp1Z = fTempZ;
1648
1649 fTempX = TempMatrix[0] * fTemp1X + TempMatrix[1] * fTemp1Y + TempMatrix[2] * fTemp1Z + TempMatrix[3];
1650 fTempY = TempMatrix[4] * fTemp1X + TempMatrix[5] * fTemp1Y + TempMatrix[6] * fTemp1Z + TempMatrix[7];
1651 fTempZ = TempMatrix[8] * fTemp1X + TempMatrix[9] * fTemp1Y + TempMatrix[10] * fTemp1Z + TempMatrix[11];
1652
1653 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1654 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1655 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1656 }
1657
1658 if (params->StageEnableFlags[iIndex].CCMExt2Enable)
1659 {
1660 // BT709 to BT2020 CCM
1661 if (params->CCMExt2[iIndex] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1662 {
1663 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1664 }
1665 // BT2020 to BT709 CCM
1666 else if (params->CCMExt2[iIndex] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1667 {
1668 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1669 }
1670 else if (params->CCMExt2[iIndex] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
1671 params->CCMExt2[iIndex] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
1672 params->CCMExt2[iIndex] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
1673 {
1674 HdrCalculateCCMWithMonitorGamut(params->CCMExt2[iIndex], params->targetHDRParams[0], TempMatrix);
1675 }
1676 else
1677 {
1678 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
1679 }
1680
1681 fTemp1X = fTempX;
1682 fTemp1Y = fTempY;
1683 fTemp1Z = fTempZ;
1684
1685 fTempX = TempMatrix[0] * fTemp1X + TempMatrix[1] * fTemp1Y + TempMatrix[2] * fTemp1Z + TempMatrix[3];
1686 fTempY = TempMatrix[4] * fTemp1X + TempMatrix[5] * fTemp1Y + TempMatrix[6] * fTemp1Z + TempMatrix[7];
1687 fTempZ = TempMatrix[8] * fTemp1X + TempMatrix[9] * fTemp1Y + TempMatrix[10] * fTemp1Z + TempMatrix[11];
1688
1689 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1690 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1691 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1692 }
1693
1694 if (params->OETFGamma[iIndex] != VPHAL_GAMMA_NONE)
1695 {
1696 if (params->OETFGamma[iIndex] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
1697 {
1698 if (fTempX < 0.018)
1699 {
1700 fTempX = 4.5 * fTempX;
1701 }
1702 else
1703 {
1704 fTempX = pow(fTempX, 0.45);
1705 fTempX = 1.099 * fTempX - 0.099;
1706 }
1707
1708 if (fTempY < 0.018)
1709 {
1710 fTempY = 4.5 * fTempY;
1711 }
1712 else
1713 {
1714 fTempY = pow(fTempY, 0.45);
1715 fTempY = 1.099 * fTempY - 0.099;
1716 }
1717
1718 if (fTempZ < 0.018)
1719 {
1720 fTempZ = 4.5 * fTempZ;
1721 }
1722 else
1723 {
1724 fTempZ = pow(fTempZ, 0.45);
1725 fTempZ = 1.099 * fTempZ - 0.099;
1726 }
1727 }
1728 else if (params->OETFGamma[iIndex] == VPHAL_GAMMA_SMPTE_ST2084)
1729 {
1730 fTempX = pow(fTempX, m1);
1731 fTempX = (c1 + c2 * fTempX) / (1 + c3 * fTempX);
1732 fTempX = pow(fTempX, m2);
1733
1734 fTempY = pow(fTempY, m1);
1735 fTempY = (c1 + c2 * fTempY) / (1 + c3 * fTempY);
1736 fTempY = pow(fTempY, m2);
1737
1738 fTempZ = pow(fTempZ, m1);
1739 fTempZ = (c1 + c2 * fTempZ) / (1 + c3 * fTempZ);
1740 fTempZ = pow(fTempZ, m2);
1741 }
1742 else if (params->OETFGamma[iIndex] == VPHAL_GAMMA_SRGB)
1743 {
1744 if (fTempX < 0.0031308f)
1745 {
1746 fTempX = 12.92 * fTempX;
1747 }
1748 else
1749 {
1750 fTempX = pow(fTempX, (double)(1.0f / 2.4f));
1751 fTempX = 1.055 * fTempX - 0.055;
1752 }
1753
1754 if (fTempY < 0.0031308f)
1755 {
1756 fTempY = 12.92 * fTempY;
1757 }
1758 else
1759 {
1760 fTempY = pow(fTempY, (double)(1.0f / 2.4f));
1761 fTempY = 1.055 * fTempY - 0.055;
1762 }
1763
1764 if (fTempZ < 0.0031308f)
1765 {
1766 fTempZ = 12.92 * fTempZ;
1767 }
1768 else
1769 {
1770 fTempZ = pow(fTempZ, (double)(1.0f / 2.4f));
1771 fTempZ = 1.055 * fTempZ - 0.055;
1772 }
1773 }
1774 else
1775 {
1776 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
1777 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1778 }
1779
1780 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1781 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1782 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1783 }
1784
1785 // OETF will output RGB surface
1786 // So if post CSC is needed, it will always be RGB to YUV conversion
1787 if (params->PostCSC[iIndex] != VPHAL_HDR_CSC_NONE)
1788 {
1789 if (params->PostCSC[iIndex] == VPHAL_HDR_CSC_RGB_TO_YUV_BT601)
1790 {
1791 SET_MATRIX(-0.331264f, -0.168736f, 0.500000f, 0.000000f, 0.587000f, 0.299000f, 0.114000f, 0.000000f, -0.418688f, 0.500000f, -0.081312f, 0.000000f);
1792
1793 SET_MATRIX(0.500000f, -0.418688f, -0.081312f, 0.000000f, 0.299000f, 0.587000f, 0.114000f, 0.000000f, -0.168736f, -0.331264f, 0.500000f, 0.000000f);
1794
1795 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT601, TempMatrix, PostCscMatrix);
1796 }
1797 else if (params->PostCSC[iIndex] == VPHAL_HDR_CSC_RGB_TO_YUV_BT709)
1798 {
1799 SET_MATRIX(-0.385428f, -0.114572f, 0.500000f, 0.000000f, 0.715200f, 0.212600f, 0.072200f, 0.000000f, -0.454153f, 0.500000f, -0.045847f, 0.000000f);
1800
1801 SET_MATRIX(0.500000f, -0.454153f, -0.045847f, 0.000000f, 0.212600f, 0.715200f, 0.072200f, 0.000000f, -0.114572f, -0.385428f, 0.500000f, 0.000000f);
1802
1803 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT709, TempMatrix, PostCscMatrix);
1804 }
1805 else if (params->PostCSC[iIndex] == VPHAL_HDR_CSC_RGB_TO_YUV_BT2020)
1806 {
1807 SET_MATRIX(-0.360370f, -0.139630f, 0.500000f, 0.000000f, 0.678000f, 0.262700f, 0.059300f, 0.000000f, -0.459786f, 0.500000f, -0.040214f, 0.000000f);
1808
1809 SET_MATRIX(0.500000f, -0.459786f, -0.040214f, 0.000000f, 0.262700f, 0.678000f, 0.059300f, 0.000000f, -0.139630f, -0.360370f, 0.500000f, 0.000000f);
1810
1811 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT2020, TempMatrix, PostCscMatrix);
1812 }
1813 else
1814 {
1815 VP_RENDER_ASSERTMESSAGE("Color Space Not found.");
1816 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1817 }
1818
1819 fTemp1X = fTempX;
1820 fTemp1Y = fTempY;
1821 fTemp1Z = fTempZ;
1822
1823 fTempX = PostCscMatrix[0] * fTemp1X + PostCscMatrix[1] * fTemp1Y + PostCscMatrix[2] * fTemp1Z + PostCscMatrix[3];
1824 fTempY = PostCscMatrix[4] * fTemp1X + PostCscMatrix[5] * fTemp1Y + PostCscMatrix[6] * fTemp1Z + PostCscMatrix[7];
1825 fTempZ = PostCscMatrix[8] * fTemp1X + PostCscMatrix[9] * fTemp1Y + PostCscMatrix[10] * fTemp1Z + PostCscMatrix[11];
1826
1827 CLAMP_MIN_MAX(fTempX, 0.0f, 1.0f);
1828 CLAMP_MIN_MAX(fTempY, 0.0f, 1.0f);
1829 CLAMP_MIN_MAX(fTempZ, 0.0f, 1.0f);
1830 }
1831
1832 #undef SET_MATRIX
1833 #undef CLAMP_MIN_MAX
1834
1835 if (params->bGpuGenerate3DLUT)
1836 {
1837 params->f3DLUTNormalizationFactor = 1023.0f;
1838 }
1839 else
1840 {
1841 params->f3DLUTNormalizationFactor = 65535.0f;
1842 }
1843
1844 // Convert and round up the [0, 1] float color value to 16 bit integer value
1845 *puOutputX = (uint16_t)(fTempX * params->f3DLUTNormalizationFactor + 0.5f);
1846 *puOutputY = (uint16_t)(fTempY * params->f3DLUTNormalizationFactor + 0.5f);
1847 *puOutputZ = (uint16_t)(fTempZ * params->f3DLUTNormalizationFactor + 0.5f);
1848
1849 return MOS_STATUS_SUCCESS;
1850 }
1851
1852 //!
1853 //! \brief Color Transfer for Hdr 3d Lut
1854 //! \details Color Transfer for Hdr 3d Lut
1855 //! \param VPHAL_HDR_MODE HdrMode
1856 //! [in] Hdr mode
1857 //! \param double fInputX
1858 //! [in] Input color for Tone Mapping
1859 //! \param double fInputY
1860 //! [in] Input color for Tone Mapping
1861 //! \param double fInputZ
1862 //! [in] Input color for Tone Mapping
1863 //! \param double * pfOutputX
1864 //! [in/out] Output color for Tone Mapping
1865 //! \param double * pfOutputY
1866 //! [in/out] Output color for Tone Mapping
1867 //! \param double * pfOutputZ
1868 //! [in/out] Output color for Tone Mapping
1869 //! \return MOS_STATUS
1870 //!
1871 MOS_STATUS VpRenderHdrKernel::VpHal_HdrToneMapping3dLut(
1872 VPHAL_HDR_MODE HdrMode,
1873 double fInputX,
1874 double fInputY,
1875 double fInputZ,
1876 double *pfOutputX,
1877 double *pfOutputY,
1878 double *pfOutputZ)
1879 {
1880 VP_FUNC_CALL();
1881
1882 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1883 double fPivot[5] = {};
1884 double fSlope[6] = {};
1885 double fIntercept[6] = {};
1886
1887 VP_PUBLIC_CHK_NULL_RETURN(pfOutputX);
1888 VP_PUBLIC_CHK_NULL_RETURN(pfOutputX);
1889 VP_PUBLIC_CHK_NULL_RETURN(pfOutputX);
1890
1891 #define TONE_MAPPING(Input, Output) \
1892 { \
1893 if (Input < fPivot[0]) \
1894 { \
1895 Output = Input * fSlope[0] + fIntercept[0]; \
1896 } \
1897 else if (Input < fPivot[1]) \
1898 { \
1899 Output = Input * fSlope[1] + fIntercept[1]; \
1900 } \
1901 else if (Input < fPivot[2]) \
1902 { \
1903 Output = Input * fSlope[2] + fIntercept[2]; \
1904 } \
1905 else if (Input < fPivot[3]) \
1906 { \
1907 Output = Input * fSlope[3] + fIntercept[3]; \
1908 } \
1909 else if (Input < fPivot[4]) \
1910 { \
1911 Output = Input * fSlope[4] + fIntercept[4]; \
1912 } \
1913 else \
1914 { \
1915 Output = Input * fSlope[5] + fIntercept[5]; \
1916 } \
1917 if (Output > 1.0f) \
1918 { \
1919 Output = 1.0f; \
1920 } \
1921 }
1922
1923 if (HdrMode == VPHAL_HDR_MODE_TONE_MAPPING || HdrMode == VPHAL_HDR_MODE_TONE_MAPPING_AUTO_MODE)
1924 {
1925 // TODO: add auto mode support, i.e. read back the coeffs from audo mode output surface.
1926 fPivot[0] = VPHAL_HDR_TONE_MAPPING_PIVOT_POINT_X1;
1927 fPivot[1] = VPHAL_HDR_TONE_MAPPING_PIVOT_POINT_X2;
1928 fPivot[2] = VPHAL_HDR_TONE_MAPPING_PIVOT_POINT_X3;
1929 fPivot[3] = VPHAL_HDR_TONE_MAPPING_PIVOT_POINT_X4;
1930 fPivot[4] = VPHAL_HDR_TONE_MAPPING_PIVOT_POINT_X5;
1931 fSlope[0] = VPHAL_HDR_TONE_MAPPING_SLOPE0;
1932 fSlope[1] = VPHAL_HDR_TONE_MAPPING_SLOPE1;
1933 fSlope[2] = VPHAL_HDR_TONE_MAPPING_SLOPE2;
1934 fSlope[3] = VPHAL_HDR_TONE_MAPPING_SLOPE3;
1935 fSlope[4] = VPHAL_HDR_TONE_MAPPING_SLOPE4;
1936 fSlope[5] = VPHAL_HDR_TONE_MAPPING_SLOPE5;
1937 fIntercept[0] = VPHAL_HDR_TONE_MAPPING_INTERCEPT0;
1938 fIntercept[1] = VPHAL_HDR_TONE_MAPPING_INTERCEPT1;
1939 fIntercept[2] = VPHAL_HDR_TONE_MAPPING_INTERCEPT2;
1940 fIntercept[3] = VPHAL_HDR_TONE_MAPPING_INTERCEPT3;
1941 fIntercept[4] = VPHAL_HDR_TONE_MAPPING_INTERCEPT4;
1942 fIntercept[5] = VPHAL_HDR_TONE_MAPPING_INTERCEPT5;
1943
1944 TONE_MAPPING(fInputX, *pfOutputX);
1945 TONE_MAPPING(fInputY, *pfOutputY);
1946 TONE_MAPPING(fInputZ, *pfOutputZ);
1947 }
1948 else if (HdrMode == VPHAL_HDR_MODE_INVERSE_TONE_MAPPING)
1949 {
1950 // For inverse tone mapping in 3D LUT
1951 // PWLF function should not be applied
1952 // A simple / 100 devision should be performed
1953 *pfOutputX = fInputX / 100.0f;
1954 *pfOutputY = fInputY / 100.0f;
1955 *pfOutputZ = fInputZ / 100.0f;
1956 }
1957 else if (HdrMode == VPHAL_HDR_MODE_H2H)
1958 {
1959 // TODO: port the H2H mapping algorithm
1960 *pfOutputX = fInputX;
1961 *pfOutputY = fInputY;
1962 *pfOutputZ = fInputZ;
1963 }
1964
1965 #undef TONE_MAPPING
1966
1967 return eStatus;
1968 }
1969
1970
1971 //!
1972 //! \brief Initiate EOTF Surface for HDR
1973 //! \details Initiate EOTF Surface for HDR
1974 //! \param PVPHAL_HDR_STATE paramse
1975 //! [in] Pointer to HDR state
1976 //! \param int32_t iIndex
1977 //! [in] input surface index
1978 //! \param PVPHAL_SURFACE pOETF1DLUTSurface
1979 //! [in] Pointer to OETF 1D LUT Surface
1980 //! \return MOS_STATUS
1981 //!
1982 MOS_STATUS VpRenderHdrKernel::InitOETF1DLUT(
1983 PRENDER_HDR_PARAMS params,
1984 int32_t iIndex,
1985 VP_SURFACE *pOETF1DLUTSurface)
1986 {
1987 VP_FUNC_CALL();
1988
1989 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1990 uint32_t i = 0;
1991 uint16_t *pSrcOetfLut = nullptr;
1992 uint8_t *pDstOetfLut = nullptr;
1993 MOS_LOCK_PARAMS LockFlags = {};
1994
1995 VP_PUBLIC_CHK_NULL_RETURN(pOETF1DLUTSurface);
1996 VP_PUBLIC_CHK_NULL_RETURN(pOETF1DLUTSurface->osSurface);
1997
1998 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
1999
2000 LockFlags.WriteOnly = 1;
2001
2002 // Lock the surface for writing
2003 pDstOetfLut = (uint8_t *)m_allocator->Lock(
2004 &(pOETF1DLUTSurface->osSurface->OsResource),
2005 &LockFlags);
2006
2007 VP_PUBLIC_CHK_NULL_RETURN(pDstOetfLut);
2008
2009 // Hdr kernel require 0 to 1 floating point color value
2010 // To transfer the value of 16bit integer OETF table to 0 to 1 floating point
2011 // We need to divide the table with 2^16 - 1
2012 if ((params->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
2013 params->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR))
2014 {
2015 if (params->OETFGamma[iIndex] == VPHAL_GAMMA_SRGB)
2016 {
2017 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_sRGB_FP16;
2018 }
2019 else
2020 {
2021 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_BT709_FP16;
2022 }
2023
2024 for (i = 0;
2025 i < pOETF1DLUTSurface->osSurface->dwHeight;
2026 i++, pDstOetfLut += pOETF1DLUTSurface->osSurface->dwPitch, pSrcOetfLut += pOETF1DLUTSurface->osSurface->dwWidth)
2027 {
2028 MOS_SecureMemcpy(pDstOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->osSurface->dwWidth, pSrcOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->osSurface->dwWidth);
2029 }
2030 }
2031 else if (params->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
2032 {
2033 if (params->HdrMode[iIndex] == VPHAL_HDR_MODE_INVERSE_TONE_MAPPING)
2034 {
2035 const float fStretchFactor = 0.01f;
2036 HdrGenerate2SegmentsOETFLUT(fStretchFactor, HdrOETF2084, params->OetfSmpteSt2084);
2037 pSrcOetfLut = params->OetfSmpteSt2084;
2038 }
2039 else // params->HdrMode[iIndex] == VPHAL_HDR_MODE_H2H
2040 {
2041 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_SMPTE_ST2084_3Segs_FP16;
2042 }
2043
2044 for (i = 0;
2045 i < pOETF1DLUTSurface->osSurface->dwHeight;
2046 i++, pDstOetfLut += pOETF1DLUTSurface->osSurface->dwPitch, pSrcOetfLut += pOETF1DLUTSurface->osSurface->dwWidth)
2047 {
2048 MOS_SecureMemcpy(pDstOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->osSurface->dwWidth, pSrcOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->osSurface->dwWidth);
2049 }
2050 }
2051 else
2052 {
2053 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
2054 return MOS_STATUS_INVALID_PARAMETER;
2055 }
2056
2057 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->UnLock(&pOETF1DLUTSurface->osSurface->OsResource));
2058
2059 eStatus = MOS_STATUS_SUCCESS;
2060
2061 return eStatus;
2062 }
2063
2064 //!
2065 //! \brief Initiate Cri 3D Lut Surface for HDR
2066 //! \details Initiate Cri 3D Lut Surface for HDR
2067 //! \param PVPHAL_HDR_STATE pHdrStatee
2068 //! [in] Pointer to HDR state
2069 //! \param int32_t iIndex
2070 //! [in] input surface index
2071 //! \param PVPHAL_SURFACE pCRI3DLUTSurface
2072 //! [in/out] Pointer to Cri 3D Lut Surface
2073 //! \return MOS_STATUS
2074 //!
2075 MOS_STATUS VpRenderHdrKernel::InitCri3DLUT(
2076 PRENDER_HDR_PARAMS params,
2077 int32_t iIndex,
2078 VP_SURFACE *pCRI3DLUTSurface)
2079 {
2080 VP_FUNC_CALL();
2081
2082 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2083 uint32_t i = 0, j = 0, k = 0;
2084 uint16_t u3dLutOutputX = 0, u3dLutOutputY = 0, u3dLutOutputZ = 0;
2085 uint16_t *pwDst3dLut = nullptr;
2086 uint32_t *puiDst3dLut = nullptr;
2087 uint8_t *pByte = nullptr;
2088 MOS_LOCK_PARAMS LockFlags = {};
2089 uint8_t bBytePerPixel = 0;
2090
2091 VP_PUBLIC_CHK_NULL_RETURN(pCRI3DLUTSurface);
2092 VP_PUBLIC_CHK_NULL_RETURN(pCRI3DLUTSurface->osSurface);
2093
2094 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
2095
2096 LockFlags.WriteOnly = 1;
2097
2098 // Lock the surface for writing
2099 pByte = (uint8_t *)m_allocator->Lock(
2100 &(pCRI3DLUTSurface->osSurface->OsResource),
2101 &LockFlags);
2102
2103 VP_PUBLIC_CHK_NULL_RETURN(pByte);
2104
2105 if (pCRI3DLUTSurface->osSurface->Format == Format_A16B16G16R16)
2106 {
2107 bBytePerPixel = 8;
2108
2109 for (i = 0; i < params->Cri3DLUTSize; i++)
2110 {
2111 for (j = 0; j < params->Cri3DLUTSize; j++)
2112 {
2113 for (k = 0; k < params->Cri3DLUTSize; k++)
2114 {
2115 pwDst3dLut = (uint16_t *)(pByte +
2116 i * params->Cri3DLUTSize * pCRI3DLUTSurface->osSurface->dwPitch +
2117 j * pCRI3DLUTSurface->osSurface->dwPitch +
2118 k * bBytePerPixel);
2119
2120 u3dLutOutputX = u3dLutOutputY = u3dLutOutputZ = 0;
2121
2122 VpHal_HdrColorTransfer3dLut(params,
2123 iIndex,
2124 (float)k / (float)(params->Cri3DLUTSize - 1),
2125 (float)j / (float)(params->Cri3DLUTSize - 1),
2126 (float)i / (float)(params->Cri3DLUTSize - 1),
2127 &u3dLutOutputX,
2128 &u3dLutOutputY,
2129 &u3dLutOutputZ);
2130
2131 *pwDst3dLut++ = u3dLutOutputX;
2132 *pwDst3dLut++ = u3dLutOutputY;
2133 *pwDst3dLut++ = u3dLutOutputZ;
2134 }
2135 }
2136 }
2137
2138 eStatus = MOS_STATUS_SUCCESS;
2139 }
2140 else if (pCRI3DLUTSurface->osSurface->Format == Format_R10G10B10A2)
2141 {
2142 bBytePerPixel = 4;
2143
2144 for (i = 0; i < params->Cri3DLUTSize; i++)
2145 {
2146 for (j = 0; j < params->Cri3DLUTSize; j++)
2147 {
2148 for (k = 0; k < params->Cri3DLUTSize; k++)
2149 {
2150 puiDst3dLut = (uint32_t *)(pByte +
2151 i * params->Cri3DLUTSize * pCRI3DLUTSurface->osSurface->dwPitch +
2152 j * pCRI3DLUTSurface->osSurface->dwPitch +
2153 k * bBytePerPixel);
2154
2155 u3dLutOutputX = u3dLutOutputY = u3dLutOutputZ = 0;
2156
2157 VpHal_HdrColorTransfer3dLut(params,
2158 iIndex,
2159 (float)k / (float)(params->Cri3DLUTSize - 1),
2160 (float)j / (float)(params->Cri3DLUTSize - 1),
2161 (float)i / (float)(params->Cri3DLUTSize - 1),
2162 &u3dLutOutputX,
2163 &u3dLutOutputY,
2164 &u3dLutOutputZ);
2165
2166 *puiDst3dLut = (uint32_t)u3dLutOutputX +
2167 ((uint32_t)u3dLutOutputY << 10) +
2168 ((uint32_t)u3dLutOutputZ << 20);
2169 }
2170 }
2171 }
2172
2173 eStatus = MOS_STATUS_SUCCESS;
2174 }
2175 else
2176 {
2177 VP_RENDER_ASSERTMESSAGE("Unexpected HDR 3DLUT format.");
2178 eStatus = MOS_STATUS_INVALID_PARAMETER;
2179 }
2180
2181 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->UnLock(&pCRI3DLUTSurface->osSurface->OsResource));
2182
2183 return eStatus;
2184 }
2185
2186 //!
2187 //! \brief Calculate H2H PWLF Coefficients
2188 //! \details Calculate H2H PWLF Coefficients
2189 //! \param PVPHAL_HDR_PARAMS pSource
2190 //! [in] Pointer to source surface HDR params
2191 //! \param PVPHAL_HDR_PARAMS pTarget
2192 //! [in] Pointer to target surface HDR params
2193 //! \param FLOAT* pTarget
2194 //! [in] Pointer to target surface
2195 //! \param float* pPivotPoint
2196 //! [out] Pointer to output pivot positions.
2197 //! \param uint16_t* pSlopeIntercept
2198 //! [out] Pointer to output slope and intercepts.
2199 //! \param PMOS_INTERFACE pOsInterface
2200 //! [in] Pointer to MOS interface for HDR key report.
2201 //! \return void
2202 //!
2203 void VpRenderHdrKernel::CalculateH2HPWLFCoefficients(
2204 HDR_PARAMS *pSource,
2205 HDR_PARAMS *pTarget,
2206 float *pPivotPoint,
2207 uint16_t *pSlopeIntercept,
2208 PMOS_INTERFACE pOsInterface)
2209 {
2210 VP_FUNC_CALL();
2211
2212 float pivot0_x;
2213 float pivot1_x;
2214 float pivot2_x;
2215 float pivot3_x;
2216 float pivot4_x;
2217 float pivot5_x;
2218
2219 float pivot0_y;
2220 float pivot1_y;
2221 float pivot2_y;
2222 float pivot3_y;
2223 float pivot4_y;
2224 float pivot5_y;
2225
2226 float sf1;
2227 float sf2;
2228 float sf3;
2229 float sf4;
2230 float sf5;
2231
2232 float in1f;
2233 float in2f;
2234 float in3f;
2235 float in4f;
2236 float in5f;
2237
2238 const float minLumDisp = pTarget->min_display_mastering_luminance / 10000.0f / 10000.0f;
2239 const float maxLumDisp = pTarget->max_display_mastering_luminance / 10000.0f;
2240 const bool align33Lut = true;
2241 const int lutEntries = 32;
2242 const float lutStep = 1.0f / lutEntries;
2243 const float split = 0.7f;
2244
2245 pivot0_x = 0.0f;
2246 pivot1_x = 0.0313f;
2247 pivot5_x = pSource->MaxCLL / 10000.0f;
2248
2249 //pivot0_y = minLumDisp;
2250 pivot0_y = 0.0f; // Force Y0 to zero to workaround a green bar issue.
2251 pivot1_y = 0.0313f;
2252 pivot5_y = maxLumDisp;
2253
2254 if (pTarget->max_display_mastering_luminance >= pSource->MaxCLL)
2255 {
2256 pivot2_x = pivot3_x = pivot4_x = pivot5_x = pivot2_y = pivot3_y = pivot4_y = maxLumDisp;
2257 }
2258 else
2259 {
2260 if (align33Lut)
2261 {
2262 pivot5_x = ceil(pivot5_x / lutStep) * lutStep;
2263 }
2264
2265 pivot2_x = pivot1_x + (pivot5_x - pivot1_x) / 5.0f;
2266 pivot3_x = pivot1_x + (pivot5_x - pivot1_x) * 2.0f / 5.0f;
2267 pivot4_x = pivot1_x + (pivot5_x - pivot1_x) * 3.0f / 5.0f;
2268
2269 if (align33Lut)
2270 {
2271 pivot2_x = floor(pivot2_x / lutStep) * lutStep;
2272 pivot3_x = floor(pivot3_x / lutStep) * lutStep;
2273 pivot4_x = floor(pivot4_x / lutStep) * lutStep;
2274 }
2275
2276 pivot4_y = pivot5_y * 0.95f;
2277 if (pivot4_y > pivot4_x)
2278 {
2279 pivot4_y = pivot4_x;
2280 }
2281
2282 pivot2_y = pivot1_y + (pivot4_y - pivot1_y) * split;
2283 if (pivot2_y > pivot2_x)
2284 {
2285 pivot2_y = pivot2_x;
2286 }
2287
2288 pivot3_y = pivot2_y + (pivot4_y - pivot2_y) * split;
2289 if (pivot3_y > pivot3_x)
2290 {
2291 pivot3_y = pivot3_x;
2292 }
2293 }
2294
2295
2296 // Calculate Gradient and Intercepts
2297 sf1 = (pivot1_x - pivot0_x) > 0.0f ? (float)(pivot1_y - pivot0_y) / (pivot1_x - pivot0_x) : 0.0f;
2298 pivot1_y = sf1 * (pivot1_x - pivot0_x) + pivot0_y;
2299
2300 sf2 = (pivot2_x - pivot1_x) > 0.0f ? (float)(pivot2_y - pivot1_y) / (pivot2_x - pivot1_x) : 0.0f;
2301 pivot2_y = sf2 * (pivot2_x - pivot1_x) + pivot1_y;
2302
2303 sf3 = (pivot3_x - pivot2_x) > 0.0f ? (float)(pivot3_y - pivot2_y) / (pivot3_x - pivot2_x) : 0.0f;
2304 pivot3_y = sf3 * (pivot3_x - pivot2_x) + pivot2_y;
2305
2306 sf4 = (pivot4_x - pivot3_x) > 0.0f ? (float)(pivot4_y - pivot3_y) / (pivot4_x - pivot3_x) : 0.0f;
2307 pivot4_y = sf4 * (pivot4_x - pivot3_x) + pivot3_y;
2308
2309 sf5 = (pivot5_x - pivot4_x) > 0.0f ? (float)(pivot5_y - pivot4_y) / (pivot5_x - pivot4_x) : 0.0f;
2310 pivot5_y = sf5 * (pivot5_x - pivot4_x) + pivot4_y;
2311
2312 // Calculating Intercepts
2313 in1f = pivot0_y;
2314 in2f = pivot1_y - (sf2 * pivot1_x);
2315 in3f = pivot2_y - (sf3 * pivot2_x);
2316 in4f = pivot3_y - (sf4 * pivot3_x);
2317 in5f = pivot4_y - (sf5 * pivot4_x);
2318
2319 pPivotPoint[0] = pivot1_x;
2320 pPivotPoint[1] = pivot2_x;
2321 pPivotPoint[2] = pivot3_x;
2322 pPivotPoint[3] = pivot4_x;
2323 pPivotPoint[4] = pivot5_x;
2324
2325 pSlopeIntercept[0] = VpHal_FloatToHalfFloat(sf1);
2326 pSlopeIntercept[1] = VpHal_FloatToHalfFloat(in1f);
2327 pSlopeIntercept[2] = VpHal_FloatToHalfFloat(sf2);
2328 pSlopeIntercept[3] = VpHal_FloatToHalfFloat(in2f);
2329 pSlopeIntercept[4] = VpHal_FloatToHalfFloat(sf3);
2330 pSlopeIntercept[5] = VpHal_FloatToHalfFloat(in3f);
2331 pSlopeIntercept[6] = VpHal_FloatToHalfFloat(sf4);
2332 pSlopeIntercept[7] = VpHal_FloatToHalfFloat(in4f);
2333 pSlopeIntercept[8] = VpHal_FloatToHalfFloat(sf5);
2334 pSlopeIntercept[9] = VpHal_FloatToHalfFloat(in5f);
2335 pSlopeIntercept[10] = VpHal_FloatToHalfFloat(0.0f); // Saturation
2336 pSlopeIntercept[11] = VpHal_FloatToHalfFloat(pivot5_y);
2337 }
2338 //!
2339
2340 //!
2341 //! \brief Initiate EOTF Surface for HDR
2342 //! \details Initiate EOTF Surface for HDR
2343 //! \param PVPHAL_HDR_STATE pHdrStatee
2344 //! [in] Pointer to HDR state
2345 //! \param PVPHAL_SURFACE pCoeffSurface
2346 //! [in] Pointer to CSC/CCM Surface
2347 //! \return MOS_STATUS
2348 //!
2349 MOS_STATUS VpRenderHdrKernel::HdrInitCoeff(
2350 PRENDER_HDR_PARAMS params,
2351 VP_SURFACE *pCoeffSurface)
2352 {
2353 VP_FUNC_CALL();
2354
2355 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2356 MOS_INTERFACE *pOsInterface = nullptr;
2357 uint32_t i = 0;
2358 float *pFloat = nullptr;
2359 float *pCoeff = nullptr;
2360 uint32_t *pEOTFType = nullptr;
2361 float *pEOTFCoeff = nullptr;
2362 float *pPivotPoint = nullptr;
2363 uint32_t *pTMType = nullptr;
2364 float *pFP16Normalizer = nullptr;
2365 uint32_t *pOETFNeqType = nullptr;
2366 uint32_t *pCCMEnable = nullptr;
2367 float *pPWLFStretch = nullptr;
2368 float *pCoeffR = nullptr;
2369 float *pCoeffG = nullptr;
2370 float *pCoeffB = nullptr;
2371 uint16_t *pSlopeIntercept = nullptr;
2372 MOS_LOCK_PARAMS LockFlags = {};
2373 float PriorCscMatrix[12] = {};
2374 float PostCscMatrix[12] = {};
2375 float CcmMatrix[12] = {};
2376 float TempMatrix[12] = {};
2377 uint8_t *pByte = nullptr;
2378
2379 MediaUserSettingSharedPtr userSettingPtr = nullptr;
2380 uint32_t coeffR = 0, coeffG = 0, coeffB = 0;
2381 uint32_t pivot0x = 0, pivot1x = 0, pivot2x = 0, pivot3x = 0, pivot4x = 0, pivot5x = 0;
2382 uint32_t pivot0y = 0, pivot1y = 0, pivot2y = 0, pivot3y = 0, pivot4y = 0, pivot5y = 0;
2383
2384 VP_PUBLIC_CHK_NULL_RETURN(params);
2385 VP_PUBLIC_CHK_NULL_RETURN(pCoeffSurface);
2386 VP_PUBLIC_CHK_NULL_RETURN(pCoeffSurface->osSurface);
2387
2388 eStatus = MOS_STATUS_SUCCESS;
2389 pOsInterface = m_hwInterface->m_osInterface;
2390 VP_PUBLIC_CHK_NULL_RETURN(pOsInterface);
2391
2392 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
2393
2394 LockFlags.WriteOnly = 1;
2395
2396 pFloat = (float *)m_allocator->Lock(
2397 &pCoeffSurface->osSurface->OsResource,
2398 &LockFlags);
2399 VP_PUBLIC_CHK_NULL_RETURN(pFloat);
2400
2401 #define SET_MATRIX(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _c10, _c11) \
2402 { \
2403 TempMatrix[0] = _c0; \
2404 TempMatrix[1] = _c1; \
2405 TempMatrix[2] = _c2; \
2406 TempMatrix[3] = _c3; \
2407 TempMatrix[4] = _c4; \
2408 TempMatrix[5] = _c5; \
2409 TempMatrix[6] = _c6; \
2410 TempMatrix[7] = _c7; \
2411 TempMatrix[8] = _c8; \
2412 TempMatrix[9] = _c9; \
2413 TempMatrix[10] = _c10; \
2414 TempMatrix[11] = _c11; \
2415 }
2416
2417 #define SET_EOTF_COEFF(_c1, _c2, _c3, _c4, _c5) \
2418 { \
2419 *pEOTFCoeff = _c1; \
2420 pEOTFCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float); \
2421 *pEOTFCoeff = _c2; \
2422 pEOTFCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float); \
2423 *pEOTFCoeff = _c3; \
2424 pEOTFCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float); \
2425 *pEOTFCoeff = _c4; \
2426 pEOTFCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float); \
2427 *pEOTFCoeff = _c5; \
2428 }
2429
2430 #define WRITE_MATRIX(Matrix) \
2431 { \
2432 *pCoeff++ = Matrix[0]; \
2433 *pCoeff++ = Matrix[1]; \
2434 *pCoeff++ = Matrix[2]; \
2435 *pCoeff++ = Matrix[3]; \
2436 *pCoeff++ = Matrix[4]; \
2437 *pCoeff++ = Matrix[5]; \
2438 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) - 6; \
2439 *pCoeff++ = Matrix[6]; \
2440 *pCoeff++ = Matrix[7]; \
2441 *pCoeff++ = Matrix[8]; \
2442 *pCoeff++ = Matrix[9]; \
2443 *pCoeff++ = Matrix[10]; \
2444 *pCoeff++ = Matrix[11]; \
2445 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) - 6; \
2446 }
2447
2448 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++, pFloat += VPHAL_HDR_COEF_LINES_PER_LAYER_BASIC * pCoeffSurface->osSurface->dwPitch / (sizeof(float)))
2449 {
2450 if (params->InputSrc[i] == false)
2451 {
2452 continue;
2453 }
2454
2455 pCoeff = pFloat;
2456
2457 // EOTF/CCM/Tone Mapping/OETF require RGB input
2458 // So if prior CSC is needed, it will always be YUV to RGB conversion
2459 if (params->StageEnableFlags[i].PriorCSCEnable)
2460 {
2461 if (params->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT601)
2462 {
2463 SET_MATRIX(1.000000f, 0.000000f, 1.402000f, 0.000000f, 1.000000f, -0.344136f, -0.714136f, 0.000000f, 1.000000f, 1.772000f, 0.000000f, 0.000000f);
2464
2465 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT601, CSpace_sRGB, TempMatrix, PriorCscMatrix);
2466 }
2467 else if (params->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT709)
2468 {
2469 SET_MATRIX(1.000000f, 0.000000f, 1.574800f, 0.000000f, 1.000000f, -0.187324f, -0.468124f, 0.000000f, 1.000000f, 1.855600f, 0.000000f, 0.000000f);
2470 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT709, CSpace_sRGB, TempMatrix, PriorCscMatrix);
2471 }
2472 else if (params->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT2020)
2473 {
2474 SET_MATRIX(1.000000f, 0.000000f, 1.474600f, 0.000000f, 1.000000f, -0.164550f, -0.571350f, 0.000000f, 1.000000f, 1.881400f, 0.000000f, 0.000000f);
2475 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT2020, CSpace_sRGB, TempMatrix, PriorCscMatrix);
2476 }
2477 else
2478 {
2479 VP_RENDER_ASSERTMESSAGE("Color Space Not found.");
2480 return MOS_STATUS_INVALID_PARAMETER;
2481 }
2482 HdrLimitFP32ArrayPrecisionToF3_9(PriorCscMatrix, ARRAY_SIZE(PriorCscMatrix));
2483 WRITE_MATRIX(PriorCscMatrix);
2484 }
2485 else
2486 {
2487 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2488 }
2489
2490 if (params->StageEnableFlags[i].CCMEnable)
2491 {
2492 // BT709 to BT2020 CCM
2493 if (params->CCM[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
2494 {
2495 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
2496 }
2497 // BT2020 to BT709 CCM
2498 else if (params->CCM[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
2499 {
2500 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
2501 }
2502 else
2503 {
2504 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
2505 }
2506
2507 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
2508 HdrLimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
2509 WRITE_MATRIX(CcmMatrix);
2510 }
2511 else
2512 {
2513 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2514 }
2515
2516 // OETF will output RGB surface
2517 // So if post CSC is needed, it will always be RGB to YUV conversion
2518 if (params->StageEnableFlags[i].PostCSCEnable)
2519 {
2520 if (params->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT601)
2521 {
2522 SET_MATRIX(-0.331264f, -0.168736f, 0.500000f, 0.000000f, 0.587000f, 0.299000f, 0.114000f, 0.000000f, -0.418688f, 0.500000f, -0.081312f, 0.000000f);
2523 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT601, TempMatrix, PostCscMatrix);
2524 }
2525 else if (params->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT709)
2526 {
2527 SET_MATRIX(-0.385428f, -0.114572f, 0.500000f, 0.000000f, 0.715200f, 0.212600f, 0.072200f, 0.000000f, -0.454153f, 0.500000f, -0.045847f, 0.000000f);
2528 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT709, TempMatrix, PostCscMatrix);
2529 }
2530 else if (params->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT709_FULLRANGE)
2531 {
2532 SET_MATRIX(-0.385428f, -0.114572f, 0.500000f, 0.000000f, 0.715200f, 0.212600f, 0.072200f, 0.000000f, -0.454153f, 0.500000f, -0.045847f, 0.000000f);
2533 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT709_FullRange, TempMatrix, PostCscMatrix);
2534 }
2535 else if (params->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT2020)
2536 {
2537 SET_MATRIX(-0.360370f, -0.139630f, 0.500000f, 0.000000f, 0.678000f, 0.262700f, 0.059300f, 0.000000f, -0.459786f, 0.500000f, -0.040214f, 0.000000f);
2538 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT2020, TempMatrix, PostCscMatrix);
2539 }
2540 else
2541 {
2542 VP_RENDER_ASSERTMESSAGE("Color Space Not found.");
2543 return MOS_STATUS_INVALID_PARAMETER;
2544 }
2545 HdrLimitFP32ArrayPrecisionToF3_9(PostCscMatrix, ARRAY_SIZE(PostCscMatrix));
2546 WRITE_MATRIX(PostCscMatrix);
2547 }
2548 else
2549 {
2550 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2551 }
2552
2553 pEOTFType = (uint32_t *)(pFloat + VPHAL_HDR_COEF_EOTF_OFFSET);
2554 pEOTFCoeff = pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) + VPHAL_HDR_COEF_EOTF_OFFSET;
2555
2556 if (params->StageEnableFlags[i].EOTFEnable)
2557 {
2558 if (params->EOTFGamma[i] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
2559 {
2560 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA;
2561 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA,
2562 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA,
2563 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA,
2564 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA,
2565 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA);
2566 }
2567 else if (params->EOTFGamma[i] == VPHAL_GAMMA_SMPTE_ST2084)
2568 {
2569 *pEOTFType = VPHAL_HDR_KERNEL_SMPTE_ST2084;
2570 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_SMPTE_ST2084,
2571 VPHAL_HDR_EOTF_COEFF2_SMPTE_ST2084,
2572 VPHAL_HDR_EOTF_COEFF3_SMPTE_ST2084,
2573 VPHAL_HDR_EOTF_COEFF4_SMPTE_ST2084,
2574 VPHAL_HDR_EOTF_COEFF5_SMPTE_ST2084);
2575 }
2576 else if (params->EOTFGamma[i] == VPHAL_GAMMA_BT1886)
2577 {
2578 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA;
2579 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA_BT1886,
2580 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA_BT1886,
2581 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA_BT1886,
2582 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA_BT1886,
2583 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA_BT1886);
2584 }
2585 else if (params->EOTFGamma[i] == VPHAL_GAMMA_SRGB)
2586 {
2587 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA;
2588 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA_SRGB,
2589 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA_SRGB,
2590 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA_SRGB,
2591 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA_SRGB,
2592 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA_SRGB);
2593 }
2594 else
2595 {
2596 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
2597 return MOS_STATUS_INVALID_PARAMETER;
2598 }
2599 }
2600
2601 pEOTFType++;
2602 pEOTFCoeff = pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) + VPHAL_HDR_COEF_EOTF_OFFSET + 1;
2603
2604 if (params->StageEnableFlags[i].OETFEnable)
2605 {
2606 if (params->OETFGamma[i] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
2607 {
2608 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA;
2609 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_TRADITIONNAL_GAMMA,
2610 VPHAL_HDR_OETF_COEFF2_TRADITIONNAL_GAMMA,
2611 VPHAL_HDR_OETF_COEFF3_TRADITIONNAL_GAMMA,
2612 VPHAL_HDR_OETF_COEFF4_TRADITIONNAL_GAMMA,
2613 VPHAL_HDR_OETF_COEFF5_TRADITIONNAL_GAMMA);
2614 }
2615 else if (params->OETFGamma[i] == VPHAL_GAMMA_SRGB)
2616 {
2617 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA;
2618 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_TRADITIONNAL_GAMMA_SRGB,
2619 VPHAL_HDR_OETF_COEFF2_TRADITIONNAL_GAMMA_SRGB,
2620 VPHAL_HDR_OETF_COEFF3_TRADITIONNAL_GAMMA_SRGB,
2621 VPHAL_HDR_OETF_COEFF4_TRADITIONNAL_GAMMA_SRGB,
2622 VPHAL_HDR_OETF_COEFF5_TRADITIONNAL_GAMMA_SRGB);
2623 }
2624 else if (params->OETFGamma[i] == VPHAL_GAMMA_SMPTE_ST2084)
2625 {
2626 *pEOTFType = VPHAL_HDR_KERNEL_SMPTE_ST2084;
2627 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_SMPTE_ST2084,
2628 VPHAL_HDR_OETF_COEFF2_SMPTE_ST2084,
2629 VPHAL_HDR_OETF_COEFF3_SMPTE_ST2084,
2630 VPHAL_HDR_OETF_COEFF4_SMPTE_ST2084,
2631 VPHAL_HDR_OETF_COEFF5_SMPTE_ST2084);
2632 }
2633 else
2634 {
2635 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
2636 return MOS_STATUS_INVALID_PARAMETER;
2637 }
2638 }
2639
2640 // NOTE:
2641 // Pitch is not equal to width usually. So please be careful when using pointer addition.
2642 // Only do this when operands are in the same row.
2643 pPivotPoint = pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_PIVOT_POINT_LINE_OFFSET;
2644 pSlopeIntercept = (uint16_t *)(pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET);
2645 pPWLFStretch = pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_PIVOT_POINT_LINE_OFFSET + 5;
2646 pTMType = (uint32_t *)(pPWLFStretch);
2647 pCoeffR = pPWLFStretch + 1;
2648 pCoeffG = pCoeffR + 1;
2649 pCoeffB = pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET + 6;
2650 pOETFNeqType = (uint32_t *)(pFloat + pCoeffSurface->osSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET + 7);
2651
2652 if (params->HdrMode[i] == VPHAL_HDR_MODE_TONE_MAPPING)
2653 {
2654 *pTMType = 1; // TMtype
2655 *pOETFNeqType = 0 | (10000 << 16); // OETFNEQ
2656 *pCoeffR = 0.25f;
2657 *pCoeffG = 0.625f;
2658 *pCoeffB = 0.125f;
2659
2660 float pivot0_x = 0.0f, pivot1_x = 0.03125f, pivot2_x = 0.09375f, pivot3_x = 0.125f, pivot4_x = 0.21875f, pivot5_x = 0.40625f;
2661 float pivot0_y = 0.0f, pivot1_y = 0.7f, pivot2_y = 0.9f, pivot3_y = 0.95f, pivot4_y = 0.99f, pivot5_y = 1.0f;
2662 float sf1, sf2, sf3, sf4, sf5;
2663 float in1f, in2f, in3f, in4f, in5f;
2664
2665 pivot0_x = 0.0f;
2666 pivot0_y = 0.0f;
2667
2668 // Calculate Gradient and Intercepts
2669 sf1 = (pivot1_x - pivot0_x) > 0.0f ? (float)(pivot1_y - pivot0_y) / (pivot1_x - pivot0_x) : 0.0f;
2670 pivot1_y = sf1 * (pivot1_x - pivot0_x) + pivot0_y;
2671
2672 sf2 = (pivot2_x - pivot1_x) > 0.0f ? (float)(pivot2_y - pivot1_y) / (pivot2_x - pivot1_x) : 0.0f;
2673 pivot2_y = sf2 * (pivot2_x - pivot1_x) + pivot1_y;
2674
2675 sf3 = (pivot3_x - pivot2_x) > 0.0f ? (float)(pivot3_y - pivot2_y) / (pivot3_x - pivot2_x) : 0.0f;
2676 pivot3_y = sf3 * (pivot3_x - pivot2_x) + pivot2_y;
2677
2678 sf4 = (pivot4_x - pivot3_x) > 0.0f ? (float)(pivot4_y - pivot3_y) / (pivot4_x - pivot3_x) : 0.0f;
2679 pivot4_y = sf4 * (pivot4_x - pivot3_x) + pivot3_y;
2680
2681 sf5 = (pivot5_x - pivot4_x) > 0.0f ? (float)(pivot5_y - pivot4_y) / (pivot5_x - pivot4_x) : 0.0f;
2682 pivot5_y = sf5 * (pivot5_x - pivot4_x) + pivot4_y;
2683
2684 // Calculating Intercepts
2685 in1f = pivot0_y;
2686 in2f = pivot1_y - (sf2 * pivot1_x);
2687 in3f = pivot2_y - (sf3 * pivot2_x);
2688 in4f = pivot3_y - (sf4 * pivot3_x);
2689 in5f = pivot4_y - (sf5 * pivot4_x);
2690
2691 // Pivot Point
2692 *pPivotPoint++ = pivot1_x;
2693 *pPivotPoint++ = pivot2_x;
2694 *pPivotPoint++ = pivot3_x;
2695 *pPivotPoint++ = pivot4_x;
2696 *pPivotPoint++ = pivot5_x;
2697
2698 // Slope and Intercept
2699 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(sf1);
2700 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(in1f);
2701 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(sf2);
2702 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(in2f);
2703 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(sf3);
2704 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(in3f);
2705 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(sf4);
2706 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(in4f);
2707 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(sf5);
2708 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(in5f);
2709 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(0.0f);
2710 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(pivot5_y);
2711 }
2712 else if (params->HdrMode[i] == VPHAL_HDR_MODE_INVERSE_TONE_MAPPING)
2713 {
2714 *pPWLFStretch = 0.01f; // Stretch
2715 *pOETFNeqType = 1 | ((uint32_t)100 << 16); // OETFNEQ
2716 *pCoeffR = 0.0f;
2717 *pCoeffG = 0.0f;
2718 *pCoeffB = 0.0f;
2719
2720 // Pivot Point
2721 *pPivotPoint++ = VPHAL_HDR_INVERSE_TONE_MAPPING_PIVOT_POINT_X1;
2722 *pPivotPoint++ = VPHAL_HDR_INVERSE_TONE_MAPPING_PIVOT_POINT_X2;
2723 *pPivotPoint++ = VPHAL_HDR_INVERSE_TONE_MAPPING_PIVOT_POINT_X3;
2724 *pPivotPoint++ = VPHAL_HDR_INVERSE_TONE_MAPPING_PIVOT_POINT_X4;
2725 *pPivotPoint++ = VPHAL_HDR_INVERSE_TONE_MAPPING_PIVOT_POINT_X5;
2726
2727 // Slope and Intercept
2728 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE0);
2729 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT0);
2730 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE1);
2731 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT1);
2732 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE2);
2733 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT2);
2734 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE3);
2735 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT3);
2736 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE4);
2737 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT4);
2738 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_SLOPE5);
2739 *pSlopeIntercept++ = VpHal_FloatToHalfFloat(VPHAL_HDR_INVERSE_TONE_MAPPING_INTERCEPT5);
2740 }
2741 else if (params->HdrMode[i] == VPHAL_HDR_MODE_H2H ||
2742 params->HdrMode[i] == VPHAL_HDR_MODE_H2H_AUTO_MODE)
2743 {
2744 *pTMType = 1; // TMtype
2745 *pOETFNeqType = 2 | (((uint32_t)(params->uiMaxDisplayLum)) << 16); // OETFNEQ
2746 *pCoeffR = 0.25f;
2747 *pCoeffG = 0.625f;
2748 *pCoeffB = 0.125f;
2749
2750 CalculateH2HPWLFCoefficients(&params->srcHDRParams[0], &params->targetHDRParams[0], pPivotPoint, pSlopeIntercept, pOsInterface);
2751
2752 }
2753 else
2754 {
2755 *pPivotPoint = 0.0f;
2756 *pTMType = 0; // TMtype
2757 *pOETFNeqType = 0; // OETFNEQ
2758 }
2759 }
2760
2761 // Coef[64][7] is to normalize the fp16 input value
2762 pFP16Normalizer = pFloat + 7;
2763 *pFP16Normalizer = 1.0f / 125.0f;
2764
2765 // Skip the Dst CSC area
2766 pFloat += 2 * pCoeffSurface->osSurface->dwPitch / sizeof(float);
2767
2768 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++, pFloat += VPHAL_HDR_COEF_LINES_PER_LAYER_EXT * pCoeffSurface->osSurface->dwPitch / (sizeof(float)))
2769 {
2770 pCCMEnable = (uint32_t *)pFloat;
2771 *(pCCMEnable + VPHAL_HDR_COEF_CCMEXT_OFFSET) = params->StageEnableFlags[i].CCMExt1Enable;
2772 *(pCCMEnable + VPHAL_HDR_COEF_CLAMP_OFFSET) = params->StageEnableFlags[i].GamutClamp1Enable;
2773
2774 pCCMEnable += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2775 *(pCCMEnable + VPHAL_HDR_COEF_CCMEXT_OFFSET) = params->StageEnableFlags[i].CCMExt2Enable;
2776 *(pCCMEnable + VPHAL_HDR_COEF_CLAMP_OFFSET) = params->StageEnableFlags[i].GamutClamp2Enable;
2777
2778 if (params->InputSrc[i] == false)
2779 {
2780 continue;
2781 }
2782
2783 pCoeff = pFloat;
2784 if (params->StageEnableFlags[i].CCMExt1Enable)
2785 {
2786 // BT709 to BT2020 CCM
2787 if (params->CCMExt1[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
2788 {
2789 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
2790 }
2791 // BT2020 to BT709 CCM
2792 else if (params->CCMExt1[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
2793 {
2794 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
2795 }
2796 else if (params->CCMExt1[i] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
2797 params->CCMExt1[i] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
2798 params->CCMExt1[i] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
2799 {
2800 HdrCalculateCCMWithMonitorGamut(params->CCMExt1[i], params->targetHDRParams[0], TempMatrix);
2801 }
2802 else
2803 {
2804 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
2805 }
2806
2807 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
2808 HdrLimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
2809 WRITE_MATRIX(CcmMatrix);
2810 }
2811 else
2812 {
2813 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2814 }
2815
2816 if (params->StageEnableFlags[i].CCMExt2Enable)
2817 {
2818 // BT709 to BT2020 CCM
2819 if (params->CCMExt2[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
2820 {
2821 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f, 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f, 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
2822 }
2823 // BT2020 to BT709 CCM
2824 else if (params->CCMExt2[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
2825 {
2826 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f, -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f, -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
2827 }
2828 else if (params->CCMExt2[i] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
2829 params->CCMExt2[i] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
2830 params->CCMExt2[i] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
2831 {
2832 HdrCalculateCCMWithMonitorGamut(params->CCMExt2[i], params->targetHDRParams[0], TempMatrix);
2833 }
2834 else
2835 {
2836 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
2837 }
2838
2839 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
2840 HdrLimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
2841 WRITE_MATRIX(CcmMatrix);
2842 }
2843 else
2844 {
2845 pCoeff += pCoeffSurface->osSurface->dwPitch / sizeof(float) * 2;
2846 }
2847 }
2848
2849 VP_PUBLIC_CHK_STATUS_RETURN(m_allocator->UnLock(&pCoeffSurface->osSurface->OsResource));
2850
2851 eStatus = MOS_STATUS_SUCCESS;
2852
2853 #undef SET_MATRIX
2854 #undef SET_EOTF_COEFF
2855 #undef WRITE_MATRIX
2856
2857 return eStatus;
2858 }
2859
2860 //!
2861 //! \brief Assemble the HDR kernel per layer stages
2862 //! \details Contruct a case id from the input information, and look up the configuration entry in the table.
2863 //! \param HDRStageConfigEntry *pConfigEntry
2864 //! [out] Pointer to configuration entry
2865 //! \return bool
2866 //! True if find proper configuration entry, otherwise false
2867 //!
2868 bool VpRenderHdrKernel::ToneMappingStagesAssemble(
2869 HDR_PARAMS *srcHDRParams,
2870 HDR_PARAMS *targetHDRParams,
2871 HDRStageConfigEntry *pConfigEntry,
2872 uint32_t index)
2873 {
2874 HDRCaseID id = {0};
2875 VP_FUNC_CALL();
2876 VP_RENDER_ASSERT(pConfigEntry);
2877 VP_RENDER_ASSERT(m_hdrParams);
2878 VP_RENDER_ASSERT(srcHDRParams);
2879 VP_RENDER_ASSERT(targetHDRParams);
2880
2881 auto inputSurface = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrInputLayer0 + index));
2882 VP_SURFACE *input = (m_surfaceGroup->end() != inputSurface) ? inputSurface->second : nullptr;
2883 if (input == nullptr)
2884 {
2885 VP_RENDER_ASSERTMESSAGE("input surface creat failed, skip process");
2886 return false;
2887 }
2888 if (input->osSurface == nullptr)
2889 {
2890 VP_RENDER_ASSERTMESSAGE("input surface creat failed, skip process");
2891 return false;
2892 }
2893
2894 auto targetSurface = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
2895 VP_SURFACE *target = (m_surfaceGroup->end() != targetSurface) ? targetSurface->second : nullptr;
2896 if (target == nullptr)
2897 {
2898 VP_RENDER_ASSERTMESSAGE("target surface creat failed, skip process");
2899 return false;
2900 }
2901 if (target->osSurface == nullptr)
2902 {
2903 VP_RENDER_ASSERTMESSAGE("input surface creat failed, skip process");
2904 return false;
2905 }
2906
2907 // Because FP16 format can represent both SDR or HDR, we need do judgement here.
2908 // We need this information because we dont have unified tone mapping algorithm for various scenarios(H2S/H2H).
2909 // To do this, we make two assumptions:
2910 // 1. This colorspace will be set to BT709/Gamma1.0 from APP, so such information can NOT be used to check HDR.
2911 // 2. If APP pass any HDR metadata, it indicates this is HDR.
2912 id.InputXDR = (srcHDRParams &&
2913 ((srcHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084) || IS_RGB64_FLOAT_FORMAT(input->osSurface->Format)))
2914 ? 1
2915 : 0;
2916 id.InputGamut = IS_COLOR_SPACE_BT2020(input->ColorSpace);
2917 id.OutputXDR = (targetHDRParams &&
2918 ((targetHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084) || IS_RGB64_FLOAT_FORMAT(target->osSurface->Format)))
2919 ? 1
2920 : 0;
2921 id.OutputGamut = IS_COLOR_SPACE_BT2020(target->ColorSpace);
2922 id.OutputLinear = IS_RGB64_FLOAT_FORMAT(target->osSurface->Format) ? 1 : 0;
2923
2924 if (m_hdrParams->pHDRStageConfigTable)
2925 {
2926 pConfigEntry->value = m_hdrParams->pHDRStageConfigTable[id.index];
2927 }
2928 else
2929 {
2930 pConfigEntry->Invalid = 1;
2931 }
2932
2933 if (pConfigEntry->Invalid == 1)
2934 {
2935 VP_RENDER_ASSERTMESSAGE(
2936 "Tone mapping stages assembling failed, please reexamine the usage case(case id %d)! "
2937 "If it is definitely a correct usage, please add an entry in HDRStageEnableTable.",
2938 id.index);
2939 }
2940
2941 return (pConfigEntry->Invalid != 1);
2942 }
2943
2944
2945 //!
2946 //! \brief Update per layer pipeline states and return update mask for each layer
2947 //! \details Update per layer pipeline states and return update mask for each layer
2948 //! \param uint32_t* pdwUpdateMask
2949 //! [out] Pointer to update mask
2950 //! \return MOS_STATUS
2951 //!
2952 MOS_STATUS VpRenderHdrKernel::UpdatePerLayerPipelineStates(
2953 uint32_t *pdwUpdateMask)
2954 {
2955 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2956 uint32_t i = 0;
2957 PVPHAL_SURFACE pSrc = nullptr;
2958 PVPHAL_SURFACE pTarget = nullptr;
2959 VPHAL_HDR_LUT_MODE CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
2960 VPHAL_GAMMA_TYPE CurrentEOTF = VPHAL_GAMMA_NONE; //!< EOTF
2961 VPHAL_GAMMA_TYPE CurrentOETF = VPHAL_GAMMA_NONE; //!< OETF
2962 VPHAL_HDR_MODE CurrentHdrMode = VPHAL_HDR_MODE_NONE; //!< Hdr Mode
2963 VPHAL_HDR_CCM_TYPE CurrentCCM = VPHAL_HDR_CCM_NONE; //!< CCM Mode
2964 VPHAL_HDR_CCM_TYPE CurrentCCMExt1 = VPHAL_HDR_CCM_NONE; //!< CCM Ext1 Mode
2965 VPHAL_HDR_CCM_TYPE CurrentCCMExt2 = VPHAL_HDR_CCM_NONE; //!< CCM Ext2 Mode
2966 VPHAL_HDR_CSC_TYPE CurrentPriorCSC = VPHAL_HDR_CSC_NONE; //!< Prior CSC Mode
2967 VPHAL_HDR_CSC_TYPE CurrentPostCSC = VPHAL_HDR_CSC_NONE; //!< Post CSC Mode
2968 HDRStageConfigEntry ConfigEntry = { 0 };
2969 HDRStageEnables StageEnables = { 0 };
2970
2971 VP_FUNC_CALL();
2972 VP_RENDER_CHK_NULL_RETURN(pdwUpdateMask);
2973 VP_RENDER_CHK_NULL_RETURN(m_hdrParams);
2974
2975 //VP_PUBLIC_CHK_NULL(m_hdrParams->pTarget[0]);
2976
2977 *pdwUpdateMask = 0;
2978
2979 auto targetSurface = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
2980 VP_SURFACE *target = (m_surfaceGroup->end() != targetSurface) ? targetSurface->second : nullptr;
2981 if (target == nullptr)
2982 {
2983 VP_RENDER_ASSERTMESSAGE("target surface creat failed, skip process");
2984 return MOS_STATUS_NULL_POINTER;
2985 }
2986 VP_RENDER_CHK_NULL_RETURN(target->osSurface);
2987
2988 for (i = 0; i < m_hdrParams->uSourceCount; i++)
2989 {
2990 auto inputSurface = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrInputLayer0 + i));
2991 VP_SURFACE *input = (m_surfaceGroup->end() != inputSurface) ? inputSurface->second : nullptr;
2992 if (input == nullptr)
2993 {
2994 VP_RENDER_ASSERTMESSAGE("input surface creat failed, skip process");
2995 return MOS_STATUS_NULL_POINTER;
2996 }
2997 VP_RENDER_CHK_NULL_RETURN(input->osSurface);
2998 if (m_hdrParams->InputSrc[i] == false)
2999 {
3000 m_hdrParams->LUTMode[i] = VPHAL_HDR_LUT_MODE_NONE;
3001 m_hdrParams->EOTFGamma[i] = VPHAL_GAMMA_NONE;
3002 m_hdrParams->OETFGamma[i] = VPHAL_GAMMA_NONE;
3003 m_hdrParams->CCM[i] = VPHAL_HDR_CCM_NONE;
3004 m_hdrParams->CCMExt1[i] = VPHAL_HDR_CCM_NONE;
3005 m_hdrParams->CCMExt2[i] = VPHAL_HDR_CCM_NONE;
3006 m_hdrParams->HdrMode[i] = VPHAL_HDR_MODE_NONE;
3007 m_hdrParams->PriorCSC[i] = VPHAL_HDR_CSC_NONE;
3008 m_hdrParams->PostCSC[i] = VPHAL_HDR_CSC_NONE;
3009
3010 m_hdrParams->StageEnableFlags[i].value = 0;
3011 MOS_ZeroMemory(&m_hdrParams->HDRLastFrameSourceParams[i], sizeof(VPHAL_HDR_PARAMS));
3012
3013 continue;
3014 }
3015
3016 //pSrc = (PVPHAL_SURFACE)m_hdrParams->pSrc[i];
3017
3018 CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
3019 CurrentEOTF = VPHAL_GAMMA_NONE;
3020 CurrentOETF = VPHAL_GAMMA_NONE;
3021 CurrentHdrMode = VPHAL_HDR_MODE_NONE;
3022 CurrentCCM = VPHAL_HDR_CCM_NONE;
3023 CurrentCCMExt1 = VPHAL_HDR_CCM_NONE;
3024 CurrentCCMExt2 = VPHAL_HDR_CCM_NONE;
3025 CurrentPriorCSC = VPHAL_HDR_CSC_NONE;
3026 CurrentPostCSC = VPHAL_HDR_CSC_NONE;
3027
3028 m_hdrParams->Cri3DLUTSize = VPHAL_HDR_CRI_3DLUT_SIZE;
3029
3030 if (!ToneMappingStagesAssemble(&m_hdrParams->srcHDRParams[i], &m_hdrParams->targetHDRParams[0], &ConfigEntry, i))
3031 {
3032 eStatus = MOS_STATUS_INVALID_PARAMETER;
3033 return eStatus;
3034 }
3035
3036 CurrentHdrMode = (VPHAL_HDR_MODE)ConfigEntry.PWLF;
3037 CurrentCCM = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCM;
3038 CurrentCCMExt1 = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCMExt1;
3039 CurrentCCMExt2 = (VPHAL_HDR_CCM_TYPE)ConfigEntry.CCMExt2;
3040
3041 // So far only enable auto mode in H2S cases.
3042 if (CurrentHdrMode == VPHAL_HDR_MODE_TONE_MAPPING &&
3043 m_hdrParams->srcHDRParams[i].bAutoMode &&
3044 input->SurfType == SURF_IN_PRIMARY)
3045 {
3046 CurrentHdrMode = VPHAL_HDR_MODE_TONE_MAPPING_AUTO_MODE;
3047 }
3048
3049 StageEnables.value = 0;
3050 StageEnables.CCMEnable = (CurrentCCM != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
3051 StageEnables.PWLFEnable = (CurrentHdrMode != VPHAL_HDR_MODE_NONE) ? 1 : 0;
3052 StageEnables.CCMExt1Enable = (CurrentCCMExt1 != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
3053 StageEnables.CCMExt2Enable = (CurrentCCMExt2 != VPHAL_HDR_CCM_NONE ) ? 1 : 0;
3054 StageEnables.GamutClamp1Enable = ConfigEntry.GamutClamp1;
3055 StageEnables.GamutClamp2Enable = ConfigEntry.GamutClamp2;
3056
3057 if (IS_YUV_FORMAT(input->osSurface->Format) || IS_ALPHA_YUV_FORMAT(input->osSurface->Format))
3058 {
3059 StageEnables.PriorCSCEnable = 1;
3060 }
3061
3062 if (!IS_RGB64_FLOAT_FORMAT(input->osSurface->Format) &&
3063 (StageEnables.CCMEnable || StageEnables.PWLFEnable || StageEnables.CCMExt1Enable || StageEnables.CCMExt2Enable))
3064 {
3065 StageEnables.EOTFEnable = 1;
3066 }
3067
3068 if (!IS_RGB64_FLOAT_FORMAT(target->osSurface->Format) && (StageEnables.EOTFEnable || IS_RGB64_FLOAT_FORMAT(input->osSurface->Format)))
3069 {
3070 StageEnables.OETFEnable = 1;
3071 }
3072
3073 if (IS_YUV_FORMAT(target->osSurface->Format))
3074 {
3075 StageEnables.PostCSCEnable = 1;
3076 }
3077
3078 if (input->SurfType == SURF_IN_PRIMARY && m_hdrParams->GlobalLutMode != VPHAL_HDR_LUT_MODE_3D)
3079 {
3080 CurrentLUTMode = VPHAL_HDR_LUT_MODE_2D;
3081 }
3082 else
3083 {
3084 CurrentLUTMode = VPHAL_HDR_LUT_MODE_3D;
3085 }
3086
3087 // Neither 1D nor 3D LUT is needed in linear output case.
3088 if (IS_RGB64_FLOAT_FORMAT(target->osSurface->Format))
3089 {
3090 CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
3091 }
3092
3093 // EOTF/CCM/Tone Mapping/OETF require RGB input
3094 // So if prior CSC is needed, it will always be YUV to RGB conversion
3095 if (StageEnables.PriorCSCEnable)
3096 {
3097 if (input->ColorSpace == CSpace_BT601)
3098 {
3099 CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT601;
3100 }
3101 else if (input->ColorSpace == CSpace_BT709)
3102 {
3103 CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT709;
3104 }
3105 else if (input->ColorSpace == CSpace_BT2020)
3106 {
3107 CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT2020;
3108 }
3109 else if (input->ColorSpace == CSpace_BT2020_FullRange)
3110 {
3111 CurrentPriorCSC = VPHAL_HDR_CSC_YUV_TO_RGB_BT2020;
3112 }
3113 else
3114 {
3115 VP_RENDER_ASSERTMESSAGE("Color Space %d Not found.", input->ColorSpace);
3116 eStatus = MOS_STATUS_INVALID_PARAMETER;
3117 return eStatus;
3118 }
3119 }
3120
3121 if (StageEnables.EOTFEnable)
3122 {
3123 if (m_hdrParams->srcHDRParams[i].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
3124 m_hdrParams->srcHDRParams[i].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR)
3125 {
3126 // Mark tranditional HDR/SDR gamma as the same type
3127 CurrentEOTF = VPHAL_GAMMA_TRADITIONAL_GAMMA;
3128 }
3129 else if (m_hdrParams->srcHDRParams[i].EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
3130 {
3131 CurrentEOTF = VPHAL_GAMMA_SMPTE_ST2084;
3132 }
3133 else if (m_hdrParams->srcHDRParams[i].EOTF == VPHAL_HDR_EOTF_BT1886)
3134 {
3135 CurrentEOTF = VPHAL_GAMMA_BT1886;
3136 }
3137 else
3138 {
3139 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
3140 eStatus = MOS_STATUS_INVALID_PARAMETER;
3141 return eStatus;
3142 }
3143 }
3144
3145 if (StageEnables.OETFEnable)
3146 {
3147 if (m_hdrParams->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
3148 m_hdrParams->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR)
3149 {
3150 CurrentOETF = VPHAL_GAMMA_SRGB;
3151 }
3152 else if (m_hdrParams->targetHDRParams[0].EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
3153 {
3154 CurrentOETF = VPHAL_GAMMA_SMPTE_ST2084;
3155 }
3156 else
3157 {
3158 VP_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
3159 eStatus = MOS_STATUS_INVALID_PARAMETER;
3160 return eStatus;
3161 }
3162 }
3163
3164 // OETF will output RGB surface
3165 // So if post CSC is needed, it will always be RGB to YUV conversion
3166 if (StageEnables.PostCSCEnable)
3167 {
3168 if (target->ColorSpace == CSpace_BT601)
3169 {
3170 CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT601;
3171 }
3172 else if (target->ColorSpace == CSpace_BT709)
3173 {
3174 CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT709;
3175 }
3176 else if (target->ColorSpace == CSpace_BT709_FullRange)
3177 {
3178 // CSC for target BT709_FULLRANGE is only exposed to Vebox Preprocessed HDR cases.
3179 CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT709_FULLRANGE;
3180 }
3181 else if (target->ColorSpace == CSpace_BT2020 ||
3182 target->ColorSpace == CSpace_BT2020_FullRange)
3183 {
3184 CurrentPostCSC = VPHAL_HDR_CSC_RGB_TO_YUV_BT2020;
3185 }
3186 else
3187 {
3188 VP_RENDER_ASSERTMESSAGE("Color Space %d Not found.", target->ColorSpace);
3189 eStatus = MOS_STATUS_INVALID_PARAMETER;
3190 return eStatus;
3191 }
3192 }
3193
3194 if (m_hdrParams->LUTMode[i] != CurrentLUTMode ||
3195 m_hdrParams->EOTFGamma[i] != CurrentEOTF ||
3196 m_hdrParams->OETFGamma[i] != CurrentOETF ||
3197 m_hdrParams->CCM[i] != CurrentCCM ||
3198 m_hdrParams->CCMExt1[i] != CurrentCCMExt1 ||
3199 m_hdrParams->CCMExt2[i] != CurrentCCMExt2 ||
3200 m_hdrParams->HdrMode[i] != CurrentHdrMode ||
3201 m_hdrParams->PriorCSC[i] != CurrentPriorCSC ||
3202 m_hdrParams->PostCSC[i] != CurrentPostCSC)
3203 {
3204 *pdwUpdateMask |= (1 << i);
3205 }
3206
3207 if (memcmp(&m_hdrParams->srcHDRParams[i], &m_hdrParams->HDRLastFrameSourceParams[i], sizeof(HDR_PARAMS)))
3208 {
3209 *pdwUpdateMask |= (1 << i);
3210 m_hdrParams->HDRLastFrameSourceParams[i] = m_hdrParams->srcHDRParams[i];
3211 }
3212
3213 m_hdrParams->LUTMode[i] = CurrentLUTMode;
3214 m_hdrParams->EOTFGamma[i] = CurrentEOTF;
3215 m_hdrParams->OETFGamma[i] = CurrentOETF;
3216 m_hdrParams->CCM[i] = CurrentCCM;
3217 m_hdrParams->CCMExt1[i] = CurrentCCMExt1;
3218 m_hdrParams->CCMExt2[i] = CurrentCCMExt2;
3219 m_hdrParams->HdrMode[i] = CurrentHdrMode;
3220 m_hdrParams->PriorCSC[i] = CurrentPriorCSC;
3221 m_hdrParams->PostCSC[i] = CurrentPostCSC;
3222 m_hdrParams->StageEnableFlags[i] = StageEnables;
3223 }
3224
3225 if (memcmp(&m_hdrParams->targetHDRParams[0], &m_hdrParams->HDRLastFrameTargetParams, sizeof(HDR_PARAMS)))
3226 {
3227 *pdwUpdateMask |= (1 << VPHAL_MAX_HDR_INPUT_LAYER);
3228 m_hdrParams->HDRLastFrameTargetParams = m_hdrParams->targetHDRParams[0];
3229 }
3230
3231 m_hdrParams->dwUpdateMask = *pdwUpdateMask;
3232 eStatus = MOS_STATUS_SUCCESS;
3233
3234 return eStatus;
3235 }
3236
3237 MOS_STATUS VpRenderHdrKernel::SetCacheCntl(PVP_RENDER_CACHE_CNTL surfMemCacheCtl)
3238 {
3239 VP_FUNC_CALL();
3240 VP_RENDER_CHK_NULL_RETURN(surfMemCacheCtl);
3241
3242 if (!surfMemCacheCtl->bHdr)
3243 {
3244 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
3245 }
3246 m_surfMemCacheCtl = surfMemCacheCtl->Hdr;
3247
3248 return MOS_STATUS_SUCCESS;
3249 }
3250
3251 MOS_STATUS VpRenderHdrKernel::InitRenderHalSurface(
3252 VP_SURFACE *surf,
3253 PRENDERHAL_SURFACE renderHalSurface)
3254 {
3255 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3256 //---------------------------------------
3257 VP_RENDER_CHK_NULL_RETURN(surf);
3258 VP_RENDER_CHK_NULL_RETURN(surf->osSurface);
3259 VP_RENDER_CHK_NULL_RETURN(renderHalSurface);
3260 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
3261 //---------------------------------------
3262
3263 auto osInterface = m_hwInterface->m_osInterface;
3264
3265 VP_RENDER_CHK_NULL_RETURN(osInterface);
3266 VP_RENDER_CHK_NULL_RETURN(osInterface->pfnGetMemoryCompressionMode);
3267 VP_RENDER_CHK_NULL_RETURN(osInterface->pfnGetMemoryCompressionFormat);
3268
3269 MOS_ZeroMemory(renderHalSurface, sizeof(*renderHalSurface));
3270
3271 renderHalSurface->OsSurface = *surf->osSurface;
3272
3273 if (0 == renderHalSurface->OsSurface.dwQPitch)
3274 {
3275 renderHalSurface->OsSurface.dwQPitch = renderHalSurface->OsSurface.dwHeight;
3276 }
3277
3278 VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnGetMemoryCompressionMode(osInterface,
3279 &surf->osSurface->OsResource, &renderHalSurface->OsSurface.MmcState));
3280
3281 if (m_hwInterface->m_waTable && MEDIA_IS_WA(m_hwInterface->m_waTable, Wa_16023363837))
3282 {
3283 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurfaceCMF(surf->osSurface, renderHalSurface));
3284 }
3285 else
3286 {
3287 VP_RENDER_CHK_STATUS_RETURN(osInterface->pfnGetMemoryCompressionFormat(osInterface,
3288 &surf->osSurface->OsResource, &renderHalSurface->OsSurface.CompressionFormat));
3289 }
3290
3291 renderHalSurface->rcSrc = surf->rcSrc;
3292 renderHalSurface->rcDst = surf->rcDst;
3293 renderHalSurface->rcMaxSrc = surf->rcMaxSrc;
3294 renderHalSurface->SurfType =
3295 ConvertVpSurfaceTypeToRenderSurfType(surf->SurfType);
3296 renderHalSurface->ScalingMode =
3297 ConvertVpScalingModeToRenderScalingMode(m_hdrParams->ScalingMode);
3298 renderHalSurface->ChromaSiting = surf->ChromaSiting;
3299 renderHalSurface->SampleType =
3300 ConvertVpSampleTypeToRenderSampleType(surf->SampleType);
3301
3302 return eStatus;
3303 }
3304
3305 MOS_STATUS VpRenderHdrKernel::InitRenderHalSurface(
3306 SurfaceType type,
3307 VP_SURFACE *surf,
3308 PRENDERHAL_SURFACE renderHalSurface)
3309 {
3310 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3311
3312 VP_RENDER_CHK_NULL_RETURN(surf);
3313 VP_RENDER_CHK_NULL_RETURN(m_hdrParams);
3314
3315 if (type >= SurfaceTypeHdrInputLayer0 && type <= SurfaceTypeHdrInputLayerMax)
3316 {
3317 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(surf, renderHalSurface));
3318 return MOS_STATUS_SUCCESS;
3319 }
3320 else if (SurfaceTypeHdrTarget0 == type)
3321 {
3322 auto outputputSurface = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
3323 VP_SURFACE *outputSrc = (m_surfaceGroup->end() != outputputSurface) ? outputputSurface->second : nullptr;
3324 if (outputSrc == nullptr)
3325 {
3326 VP_RENDER_ASSERTMESSAGE("input surface creat failed, skip process");
3327 return MOS_STATUS_NULL_POINTER;
3328 }
3329
3330 VP_RENDER_CHK_STATUS_RETURN(InitRenderHalSurface(outputSrc, renderHalSurface));
3331 return MOS_STATUS_SUCCESS;
3332 }
3333
3334 return MOS_STATUS_UNIMPLEMENTED;
3335 }
3336
3337 MOS_STATUS VpRenderHdrKernel::GetScoreboardParams(PMHW_VFE_SCOREBOARD &scoreboardParams)
3338 {
3339 VP_FUNC_CALL();
3340
3341 MOS_ZeroMemory(&m_scoreboardParams, sizeof(MHW_VFE_SCOREBOARD));
3342 m_scoreboardParams.ScoreboardMask = 0;
3343 m_scoreboardParams.ScoreboardType = 1;
3344 scoreboardParams = &m_scoreboardParams;
3345 return MOS_STATUS_SUCCESS;
3346 }
3347
3348 MOS_STATUS VpRenderHdrKernel::SetSurfaceParams(KERNEL_SURFACE_STATE_PARAM &surfParam, VP_SURFACE *layer, bool is32MWColorFillKern)
3349 {
3350 VP_FUNC_CALL();
3351 VP_RENDER_CHK_NULL_RETURN(layer);
3352
3353 auto &renderSurfParams = surfParam.surfaceOverwriteParams.renderSurfaceParams;
3354 MOS_ZeroMemory(&renderSurfParams, sizeof(renderSurfParams));
3355
3356 surfParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
3357
3358 // Render target or private surface
3359 if (layer->SurfType == SURF_OUT_RENDERTARGET)
3360 {
3361 // Set flags for RT
3362 surfParam.isOutput = true;
3363 renderSurfParams.isOutput = true;
3364 renderSurfParams.bWidthInDword_Y = true;
3365 renderSurfParams.bWidthInDword_UV = true;
3366 renderSurfParams.Boundary = RENDERHAL_SS_BOUNDARY_DSTRECT;
3367 }
3368 // other surfaces
3369 else
3370 {
3371 surfParam.isOutput = false;
3372 renderSurfParams.isOutput = false;
3373 renderSurfParams.bWidthInDword_Y = false;
3374 renderSurfParams.bWidthInDword_UV = false;
3375 renderSurfParams.Boundary = RENDERHAL_SS_BOUNDARY_SRCRECT;
3376 }
3377
3378 renderSurfParams.b32MWColorFillKern = is32MWColorFillKern;
3379 renderSurfParams.Type = m_hwInterface->m_renderHal->SurfaceTypeDefault;
3380 renderSurfParams.bAVS = false;
3381
3382 // Set interlacing flags
3383 switch (layer->SampleType)
3384 {
3385 case SAMPLE_INTERLEAVED_EVEN_FIRST_TOP_FIELD:
3386 case SAMPLE_INTERLEAVED_ODD_FIRST_TOP_FIELD:
3387 renderSurfParams.bVertStride = true;
3388 renderSurfParams.bVertStrideOffs = 0;
3389 break;
3390 case SAMPLE_INTERLEAVED_EVEN_FIRST_BOTTOM_FIELD:
3391 case SAMPLE_INTERLEAVED_ODD_FIRST_BOTTOM_FIELD:
3392 renderSurfParams.bVertStride = true;
3393 renderSurfParams.bVertStrideOffs = 1;
3394 break;
3395 default:
3396 renderSurfParams.bVertStride = false;
3397 renderSurfParams.bVertStrideOffs = 0;
3398 break;
3399 }
3400
3401 renderSurfParams.b2PlaneNV12NeededByKernel = true;
3402
3403 VP_RENDER_NORMALMESSAGE("SurfaceTYpe %d, bAVS %d, b2PlaneNV12NeededByKernel %d",
3404 renderSurfParams.Type,
3405 renderSurfParams.bAVS,
3406 renderSurfParams.b2PlaneNV12NeededByKernel);
3407
3408 return MOS_STATUS_SUCCESS;
3409 }
3410
3411 MOS_STATUS VpRenderHdrKernel::SetupSurfaceState()
3412 {
3413 VP_FUNC_CALL();
3414
3415 PRENDERHAL_INTERFACE renderHal = nullptr;
3416 int32_t iBTentry = 0;
3417 bool bHasAutoModeLayer = false;
3418 uint32_t i = 0;
3419 uint32_t dwUpdateMask = 0;
3420
3421 VP_RENDER_CHK_NULL_RETURN(m_hwInterface);
3422 VP_RENDER_CHK_NULL_RETURN(m_hwInterface->m_renderHal);
3423 renderHal = m_hwInterface->m_renderHal;
3424 m_surfaceBindingIndex.clear();
3425 m_surfaceState.clear();
3426 UpdatePerLayerPipelineStates(&dwUpdateMask);
3427
3428 for (i = 0; i < m_hdrParams->uSourceCount && i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
3429 {
3430 KERNEL_SURFACE_STATE_PARAM surfParam = {};
3431 auto inputSrc = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrInputLayer0 + i));
3432 VP_SURFACE *layer = (m_surfaceGroup->end() != inputSrc) ? inputSrc->second : nullptr;
3433 VP_RENDER_CHK_NULL_RETURN(layer);
3434
3435 // Only need to specify binding index in surface parameters.
3436 surfParam.surfaceOverwriteParams.updatedSurfaceParams = true;
3437 surfParam.surfaceOverwriteParams.bindedKernel = true;
3438
3439 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeHdrInputLayer0 + i), m_hdrParams->uSourceBindingTableIndex[i]);
3440 iBTentry = m_hdrParams->uSourceBindingTableIndex[i];
3441
3442 SetSurfaceParams(surfParam, layer, false);
3443
3444 surfParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.SourceSurfMemObjCtl;
3445
3446 m_surfaceState.emplace(SurfaceType(SurfaceTypeHdrInputLayer0 + i), surfParam);
3447
3448 auto OETF1DLUT = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrOETF1DLUTSurface0 + i));
3449 VP_SURFACE *OETF1DLUTSrc = (m_surfaceGroup->end() != OETF1DLUT) ? OETF1DLUT->second : nullptr;
3450
3451 if (OETF1DLUTSrc && (m_hdrParams->OETF1DLUTAllocated || (dwUpdateMask & (1 << i)) || (dwUpdateMask & (1 << VPHAL_MAX_HDR_INPUT_LAYER))))
3452 {
3453 InitOETF1DLUT(m_hdrParams, i, OETF1DLUTSrc);
3454 }
3455
3456 auto Cri3DLUT = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrCRI3DLUTSurface0 + i));
3457 VP_SURFACE *Cri3DLUTSrc = (m_surfaceGroup->end() != Cri3DLUT) ? Cri3DLUT->second : nullptr;
3458
3459 if (Cri3DLUTSrc && (m_hdrParams->Cri3DLUTAllocated || (dwUpdateMask & (1 << i)) || (dwUpdateMask & (1 << VPHAL_MAX_HDR_INPUT_LAYER))) ||
3460 m_hdrParams->HdrMode[i] == VPHAL_HDR_MODE_TONE_MAPPING_AUTO_MODE)
3461 {
3462 InitCri3DLUT(m_hdrParams, i, Cri3DLUTSrc);
3463 }
3464
3465 KERNEL_SURFACE_STATE_PARAM surfaceResource = {};
3466 surfaceResource.surfaceOverwriteParams.updatedSurfaceParams = true;
3467 surfaceResource.surfaceOverwriteParams.updatedRenderSurfaces = true;
3468 surfaceResource.surfaceOverwriteParams.bufferResource = false;
3469 surfaceResource.surfaceOverwriteParams.bindedKernel = true;
3470
3471 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = false;
3472 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.Type = RENDERHAL_SURFACE_TYPE_G10;
3473 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.isOutput = false;
3474 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.bWidth16Align = false;
3475 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
3476
3477 if (m_hdrParams->LUTMode[i] == VPHAL_HDR_LUT_MODE_2D)
3478 {
3479 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.Lut2DSurfMemObjCtl;
3480 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeHdrOETF1DLUTSurface0 + i), iBTentry + VPHAL_HDR_BTINDEX_OETF1DLUT_OFFSET);
3481 m_surfaceState.emplace(SurfaceType(SurfaceTypeHdrOETF1DLUTSurface0 + i), surfaceResource);
3482 }
3483 else if (m_hdrParams->LUTMode[i] == VPHAL_HDR_LUT_MODE_3D)
3484 {
3485 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.Lut3DSurfMemObjCtl;
3486 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeHdrCRI3DLUTSurface0 + i), iBTentry + VPHAL_HDR_BTINDEX_CRI3DLUT_OFFSET);
3487 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.bWidthInDword_Y = false;
3488 surfaceResource.surfaceOverwriteParams.renderSurfaceParams.bWidthInDword_UV = false;
3489 m_surfaceState.emplace(SurfaceType(SurfaceTypeHdrCRI3DLUTSurface0 + i), surfaceResource);
3490 }
3491 }
3492
3493 for (i = 0; i < m_hdrParams->uTargetCount; ++i)
3494 {
3495 KERNEL_SURFACE_STATE_PARAM surfParam = {};
3496
3497 surfParam.surfaceOverwriteParams.updatedSurfaceParams = true;
3498
3499 // Only need to specify binding index in surface parameters.
3500 surfParam.surfaceOverwriteParams.bindedKernel = true;
3501 UpdateCurbeBindingIndex(SurfaceType(SurfaceTypeHdrTarget0 + i), m_hdrParams->uTargetBindingTableIndex[i]);
3502
3503 iBTentry = m_hdrParams->uTargetBindingTableIndex[i];
3504 auto outputSrc = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
3505 VP_SURFACE *layer = (m_surfaceGroup->end() != outputSrc) ? outputSrc->second : nullptr;
3506 VP_RENDER_CHK_NULL_RETURN(layer);
3507 VP_RENDER_CHK_NULL_RETURN(layer->osSurface);
3508
3509 layer->SurfType = SURF_OUT_RENDERTARGET;
3510
3511 // Used for 32x32 Media walker kernel + Color fill kernel
3512 // Not valid for media object.
3513 bool is32MWColorFillKern =
3514 (m_hdrParams->pColorFillParams != nullptr &&
3515 m_hdrParams->uSourceCount == 0 &&
3516 m_renderHal->pHwSizes->dwSizeMediaWalkerBlock == 32);
3517
3518 SetSurfaceParams(surfParam, layer, is32MWColorFillKern);
3519
3520 surfParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.TargetSurfMemObjCtl;
3521
3522 m_surfaceState.emplace(SurfaceType(SurfaceTypeHdrTarget0 + i), surfParam);
3523
3524 //update render GMM resource usage type
3525 m_allocator->UpdateResourceUsageType(&layer->osSurface->OsResource, MOS_HW_RESOURCE_USAGE_VP_OUTPUT_PICTURE_RENDER);
3526 }
3527
3528 if (m_hdrParams->HdrMode[i] == VPHAL_HDR_MODE_TONE_MAPPING_AUTO_MODE)
3529 {
3530 bHasAutoModeLayer = true;
3531 }
3532
3533 auto coeff = m_surfaceGroup->find(SurfaceTypeHdrCoeff);
3534 VP_SURFACE *coeffSrc = (m_surfaceGroup->end() != coeff) ? coeff->second : nullptr;
3535 VP_RENDER_CHK_NULL_RETURN(coeffSrc);
3536
3537 if (dwUpdateMask || m_hdrParams->coeffAllocated)
3538 {
3539 HdrInitCoeff(m_hdrParams, coeffSrc);
3540 }
3541
3542 KERNEL_SURFACE_STATE_PARAM surfCoeffParam = {};
3543
3544 surfCoeffParam.surfaceOverwriteParams.updatedSurfaceParams = true;
3545 // Only need to specify binding index in surface parameters.
3546 surfCoeffParam.surfaceOverwriteParams.bindedKernel = true;
3547
3548 surfCoeffParam.surfaceOverwriteParams.updatedRenderSurfaces = true;
3549 surfCoeffParam.surfaceOverwriteParams.renderSurfaceParams.Type = RENDERHAL_SURFACE_TYPE_G10;
3550 surfCoeffParam.surfaceOverwriteParams.renderSurfaceParams.isOutput = false;
3551 surfCoeffParam.surfaceOverwriteParams.renderSurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
3552 surfCoeffParam.surfaceOverwriteParams.renderSurfaceParams.bWidth16Align = false;
3553 surfCoeffParam.surfaceOverwriteParams.renderSurfaceParams.MemObjCtl = m_surfMemCacheCtl.CoeffSurfMemObjCtl;
3554
3555 if (m_hdrParams->bUsingAutoModePipe && bHasAutoModeLayer)
3556 {
3557 UpdateCurbeBindingIndex(SurfaceTypeHdrAutoModeCoeff, VPHAL_HDR_BTINDEX_COEFF);
3558 m_surfaceState.emplace(SurfaceTypeHdrAutoModeCoeff, surfCoeffParam);
3559 }
3560 else
3561 {
3562 UpdateCurbeBindingIndex(SurfaceTypeHdrCoeff, VPHAL_HDR_BTINDEX_COEFF);
3563 m_surfaceState.emplace(SurfaceTypeHdrCoeff, surfCoeffParam);
3564 }
3565
3566 return MOS_STATUS_SUCCESS;
3567 }
3568
3569 MOS_STATUS VpRenderHdrKernel::GetCurbeState(void *&curbe, uint32_t &curbeLength)
3570 {
3571 VP_FUNC_CALL();
3572
3573 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3574 PRENDERHAL_INTERFACE pRenderHal = nullptr;
3575 PVP_SURFACE pSource = nullptr;
3576 VPHAL_HDR_FORMAT_DESCRIPTOR FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW;
3577 VPHAL_HDR_ROTATION HdrRotation = VPHAL_HDR_LAYER_ROTATION_0;
3578 VPHAL_HDR_TWO_LAYER_OPTION HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND;
3579 uint32_t ChromaSiting = 0;
3580 bool bChannelSwap = false;
3581 bool bBypassIEF = true;
3582 bool b3dLut = false;
3583 uint32_t uiSamplerStateIndex = 0;
3584 uint32_t uiSamplerStateIndex2= 0;
3585 uint16_t wAlpha = 0;
3586 uint32_t i = 0;
3587 uint32_t dwDestRectWidth = 0;
3588 uint32_t dwDestRectHeight = 0; // Target rectangle Width Height
3589
3590 float fScaleX = 0.0f, fScaleY = 0.0f; // x,y scaling factor
3591 float fStepX = 0.0f, fStepY = 0.0f; // x,y scaling steps
3592 float fOriginX = 0.0f, fOriginY = 0.0f; // x,y layer origin
3593 float fShiftX = 0.0f, fShiftY = 0.0f; // x,y shift
3594
3595 m_hdrCurbe = g_cInit_MEDIA_STATIC_HDR;
3596 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND;
3597 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0;
3598 wAlpha = 0x0ff;
3599 uiSamplerStateIndex = uiSamplerStateIndex2 = 0;
3600
3601 auto target = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
3602 VP_SURFACE *targetSurf = (m_surfaceGroup->end() != target) ? target->second : nullptr;
3603 VP_RENDER_CHK_NULL_RETURN(targetSurf);
3604 VP_RENDER_CHK_NULL_RETURN(targetSurf->osSurface);
3605
3606 for (i = 0; i < m_hdrParams->uSourceCount; i++)
3607 {
3608 if (i >= VPHAL_MAX_HDR_INPUT_LAYER)
3609 {
3610 return MOS_STATUS_INVALID_PARAMETER;
3611 }
3612 auto it = m_surfaceGroup->find(SurfaceType(SurfaceTypeHdrInputLayer0 + i));
3613 pSource = (m_surfaceGroup->end() != it) ? it->second : nullptr;
3614 VP_RENDER_CHK_NULL_RETURN(pSource);
3615 VP_RENDER_CHK_NULL_RETURN(pSource->osSurface);
3616
3617 bChannelSwap = false;
3618 bBypassIEF = true;
3619
3620 fShiftX = 0;
3621 fShiftY = 0;
3622
3623 // Source rectangle is pre-rotated, destination rectangle is post-rotated.
3624 if (m_hdrParams->Rotation == VPHAL_ROTATION_IDENTITY ||
3625 m_hdrParams->Rotation == VPHAL_ROTATION_180 ||
3626 m_hdrParams->Rotation == VPHAL_MIRROR_HORIZONTAL ||
3627 m_hdrParams->Rotation == VPHAL_MIRROR_VERTICAL)
3628 {
3629 fScaleX = (float)(pSource->rcDst.right - pSource->rcDst.left) /
3630 (float)(pSource->rcSrc.right - pSource->rcSrc.left);
3631 fScaleY = (float)(pSource->rcDst.bottom - pSource->rcDst.top) /
3632 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top);
3633 }
3634 else
3635 {
3636 // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 ||
3637 // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
3638 fScaleX = (float)(pSource->rcDst.right - pSource->rcDst.left) /
3639 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top);
3640 fScaleY = (float)(pSource->rcDst.bottom - pSource->rcDst.top) /
3641 (float)(pSource->rcSrc.right - pSource->rcSrc.left);
3642 }
3643
3644 if (fScaleX == 1.0f && fScaleY == 1.0f && m_hdrParams->ScalingMode == VPHAL_SCALING_BILINEAR)
3645 {
3646 m_hdrParams->ScalingMode = VPHAL_SCALING_NEAREST;
3647 }
3648
3649 if (m_hdrParams->ScalingMode == VPHAL_SCALING_AVS)
3650 {
3651 uiSamplerStateIndex = VPHAL_HDR_AVS_SAMPLER_STATE_ADAPTIVE;
3652
3653 if (pSource->osSurface->Format == Format_P010 ||
3654 pSource->osSurface->Format == Format_P016)
3655 {
3656 uiSamplerStateIndex2 = VPHAL_HDR_AVS_SAMPLER_STATE_ADAPTIVE;
3657 }
3658 }
3659 else if (m_hdrParams->ScalingMode == VPHAL_SCALING_BILINEAR)
3660 {
3661 uiSamplerStateIndex = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
3662
3663 if (pSource->osSurface->Format == Format_P010 ||
3664 pSource->osSurface->Format == Format_P016)
3665 {
3666 uiSamplerStateIndex2 = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
3667 }
3668
3669 fShiftX = VP_HW_LINEAR_SHIFT;
3670 fShiftY = VP_HW_LINEAR_SHIFT;
3671 }
3672 else
3673 {
3674 uiSamplerStateIndex = VPHAL_HDR_3D_SAMPLER_STATE_NEAREST;
3675
3676 if (pSource->osSurface->Format == Format_P010 ||
3677 pSource->osSurface->Format == Format_P016)
3678 {
3679 uiSamplerStateIndex2 = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
3680 }
3681
3682 fShiftX = VP_HW_LINEAR_SHIFT;
3683 fShiftY = VP_HW_LINEAR_SHIFT;
3684 }
3685
3686 // Normalize source co-ordinates using the width and height programmed
3687 // in surface state. step X, Y pre-rotated
3688 // Source rectangle is pre-rotated, destination rectangle is post-rotated.
3689 if (m_hdrParams->Rotation == VPHAL_ROTATION_IDENTITY ||
3690 m_hdrParams->Rotation == VPHAL_ROTATION_180 ||
3691 m_hdrParams->Rotation == VPHAL_MIRROR_HORIZONTAL ||
3692 m_hdrParams->Rotation == VPHAL_MIRROR_VERTICAL)
3693 {
3694 fStepX = ((pSource->rcSrc.right - pSource->rcSrc.left) * 1.0f) /
3695 ((pSource->rcDst.right - pSource->rcDst.left) > 0 ?
3696 (pSource->rcDst.right - pSource->rcDst.left) : 1);
3697 fStepY = ((float)(pSource->rcSrc.bottom - pSource->rcSrc.top)) /
3698 ((pSource->rcDst.bottom - pSource->rcDst.top) > 0 ?
3699 (float)(pSource->rcDst.bottom - pSource->rcDst.top) : 1.0f);
3700 }
3701 else
3702 {
3703 // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 ||
3704 // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
3705 fStepX = ((pSource->rcSrc.right - pSource->rcSrc.left) * 1.0f) /
3706 ((pSource->rcDst.bottom - pSource->rcDst.top) > 0 ?
3707 (pSource->rcDst.bottom - pSource->rcDst.top) : 1);
3708 fStepY = ((float)(pSource->rcSrc.bottom - pSource->rcSrc.top)) /
3709 ((pSource->rcDst.right - pSource->rcDst.left) > 0 ?
3710 (float)(pSource->rcDst.right - pSource->rcDst.left) : 1.0f);
3711 }
3712
3713 dwDestRectWidth = targetSurf->osSurface->dwWidth;
3714 dwDestRectHeight = targetSurf->osSurface->dwHeight;
3715
3716 switch (m_hdrParams->Rotation)
3717 {
3718 case VPHAL_ROTATION_IDENTITY:
3719 // Coordinate adjustment for render target coordinates (0,0)
3720 fShiftX -= pSource->rcDst.left;
3721 fShiftY -= pSource->rcDst.top;
3722 break;
3723 case VPHAL_ROTATION_90:
3724 // Coordinate adjustment for 90 degree rotation
3725 fShiftX -= (float)pSource->rcDst.top;
3726 fShiftY -= (float)dwDestRectWidth -
3727 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleX -
3728 (float)pSource->rcDst.left;
3729 break;
3730 case VPHAL_ROTATION_180:
3731 // Coordinate adjustment for 180 degree rotation
3732 fShiftX -= (float)dwDestRectWidth -
3733 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleX -
3734 (float)pSource->rcDst.left;
3735 fShiftY -= (float)dwDestRectHeight -
3736 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleY -
3737 (float)pSource->rcDst.top;
3738 break;
3739 case VPHAL_ROTATION_270:
3740 // Coordinate adjustment for 270 degree rotation
3741 fShiftX -= (float)dwDestRectHeight -
3742 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleY -
3743 (float)pSource->rcDst.top;
3744 fShiftY -= (float)pSource->rcDst.left;
3745 break;
3746 case VPHAL_MIRROR_HORIZONTAL:
3747 // Coordinate adjustment for horizontal mirroring
3748 fShiftX -= (float)dwDestRectWidth -
3749 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleX -
3750 (float)pSource->rcDst.left;
3751 fShiftY -= pSource->rcDst.top;
3752 break;
3753 case VPHAL_MIRROR_VERTICAL:
3754 // Coordinate adjustment for vertical mirroring
3755 fShiftX -= pSource->rcDst.left;
3756 fShiftY -= (float)dwDestRectHeight -
3757 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleY -
3758 (float)pSource->rcDst.top;
3759 break;
3760 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL:
3761 // Coordinate adjustment for rotating 90 and horizontal mirroring
3762 fShiftX -= (float)pSource->rcDst.top;
3763 fShiftY -= (float)pSource->rcDst.left;
3764 break;
3765 case VPHAL_ROTATE_90_MIRROR_VERTICAL:
3766 default:
3767 // Coordinate adjustment for rotating 90 and vertical mirroring
3768 fShiftX -= (float)dwDestRectHeight -
3769 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleY -
3770 (float)pSource->rcDst.top;
3771 fShiftY -= (float)dwDestRectWidth -
3772 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleX -
3773 (float)pSource->rcDst.left;
3774 break;
3775 } // switch
3776
3777 fOriginX = ((float)pSource->rcSrc.left + fShiftX * fStepX) / (float)MOS_MIN(pSource->osSurface->dwWidth, (uint32_t)pSource->rcSrc.right);
3778 fOriginY = ((float)pSource->rcSrc.top + fShiftY * fStepY) / (float)MOS_MIN(pSource->osSurface->dwHeight, (uint32_t)pSource->rcSrc.bottom);
3779
3780 fStepX /= MOS_MIN(pSource->osSurface->dwWidth, (uint32_t)pSource->rcSrc.right);
3781 fStepY /= MOS_MIN(pSource->osSurface->dwHeight, (uint32_t)pSource->rcSrc.bottom);
3782
3783 FormatDescriptor = GetFormatDescriptor(pSource->osSurface->Format);
3784
3785 if (FormatDescriptor == VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW)
3786 {
3787 VP_RENDER_VERBOSEMESSAGE("Unsupported hdr input format");
3788 return MOS_STATUS_INVALID_PARAMETER;
3789 }
3790
3791 // Chroma siting setting in curbe data will only take effect in 1x scaling case when 3D sampler is being used
3792 // For other cases, Chroma siting will be performed by AVS coefficients, and the here will be ignored by kernel
3793 ChromaSiting = GetHdrChromaSiting(pSource->ChromaSiting);
3794
3795 if (pSource->osSurface->Format == Format_B10G10R10A2 ||
3796 pSource->osSurface->Format == Format_A8R8G8B8 ||
3797 pSource->osSurface->Format == Format_X8R8G8B8 ||
3798 pSource->osSurface->Format == Format_A16R16G16B16F)
3799 {
3800 bChannelSwap = true;
3801 }
3802
3803 if (m_hdrParams->pIEFParams)
3804 {
3805 if (m_hdrParams->pIEFParams->bEnabled)
3806 {
3807 bBypassIEF = false;
3808 }
3809 }
3810
3811 HdrRotation = GetHdrRotation(m_hdrParams->Rotation);
3812
3813 b3dLut = (m_hdrParams->LUTMode[i] == VPHAL_HDR_LUT_MODE_3D ? true : false);
3814
3815 switch (i)
3816 {
3817 case 0:
3818 m_hdrCurbe.DW0.HorizontalFrameOriginLayer0 = fOriginX;
3819 m_hdrCurbe.DW8.VerticalFrameOriginLayer0 = fOriginY;
3820 m_hdrCurbe.DW16.HorizontalScalingStepRatioLayer0 = fStepX;
3821 m_hdrCurbe.DW24.VerticalScalingStepRatioLayer0 = fStepY;
3822 m_hdrCurbe.DW32.LeftCoordinateRectangleLayer0 = pSource->rcDst.left;
3823 m_hdrCurbe.DW32.TopCoordinateRectangleLayer0 = pSource->rcDst.top;
3824 m_hdrCurbe.DW40.RightCoordinateRectangleLayer0 = pSource->rcDst.right - 1;
3825 m_hdrCurbe.DW40.BottomCoordinateRectangleLayer0 = pSource->rcDst.bottom - 1;
3826 m_hdrCurbe.DW48.FormatDescriptorLayer0 = FormatDescriptor;
3827 m_hdrCurbe.DW48.ChromaSittingLocationLayer0 = ChromaSiting;
3828 m_hdrCurbe.DW48.ChannelSwapEnablingFlagLayer0 = bChannelSwap;
3829 m_hdrCurbe.DW48.IEFBypassEnablingFlagLayer0 = bBypassIEF;
3830 m_hdrCurbe.DW48.RotationAngleMirrorDirectionLayer0 = HdrRotation;
3831 m_hdrCurbe.DW48.SamplerIndexFirstPlaneLayer0 = uiSamplerStateIndex;
3832 if (pSource->osSurface->Format == Format_P010 ||
3833 pSource->osSurface->Format == Format_P016)
3834 {
3835 m_hdrCurbe.DW48.SamplerIndexSecondThirdPlaneLayer0 = uiSamplerStateIndex2;
3836 }
3837 m_hdrCurbe.DW48.CCMExtensionEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
3838 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
3839 m_hdrCurbe.DW48.ToneMappingEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
3840 m_hdrCurbe.DW48.PriorCSCEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
3841 m_hdrCurbe.DW48.EOTF1DLUTEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
3842 m_hdrCurbe.DW48.CCMEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].CCMEnable;
3843 m_hdrCurbe.DW48.OETF1DLUTEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].OETFEnable;
3844 m_hdrCurbe.DW48.PostCSCEnablingFlagLayer0 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
3845 m_hdrCurbe.DW48.Enabling3DLUTFlagLayer0 = b3dLut;
3846 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
3847 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
3848 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
3849 {
3850 m_hdrCurbe.DW56.ConstantBlendingAlphaFillColorLayer0 = wAlpha;
3851 }
3852 m_hdrCurbe.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_COMP;
3853 if (pSource->SurfType == SURF_IN_PRIMARY &&
3854 m_hdrParams->pBlendingParams &&
3855 m_hdrParams->pBlendingParams->BlendType == BLEND_SOURCE &&
3856 (IS_RGB_CSPACE(pSource->ColorSpace) || IS_COLOR_SPACE_BT2020_RGB(pSource->ColorSpace)))
3857 {
3858 // For PDVD alpha blending issue:
3859 // If first frame is sRGB/stRGB/BT2020RGB format delivered as primary layer
3860 // (which means main video content is in the first layer)
3861 // and blend-type set as source blending,
3862 // do source blending w/ bg, instead of setting as composite.
3863 m_hdrCurbe.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND;
3864 }
3865 break;
3866 case 1:
3867 m_hdrCurbe.DW1.HorizontalFrameOriginLayer1 = fOriginX;
3868 m_hdrCurbe.DW9.VerticalFrameOriginLayer1 = fOriginY;
3869 m_hdrCurbe.DW17.HorizontalScalingStepRatioLayer1 = fStepX;
3870 m_hdrCurbe.DW25.VerticalScalingStepRatioLayer1 = fStepY;
3871 m_hdrCurbe.DW33.LeftCoordinateRectangleLayer1 = pSource->rcDst.left;
3872 m_hdrCurbe.DW33.TopCoordinateRectangleLayer1 = pSource->rcDst.top;
3873 m_hdrCurbe.DW41.RightCoordinateRectangleLayer1 = pSource->rcDst.right - 1;
3874 m_hdrCurbe.DW41.BottomCoordinateRectangleLayer1 = pSource->rcDst.bottom - 1;
3875 m_hdrCurbe.DW49.FormatDescriptorLayer1 = FormatDescriptor;
3876 m_hdrCurbe.DW49.ChromaSittingLocationLayer1 = ChromaSiting;
3877 m_hdrCurbe.DW49.ChannelSwapEnablingFlagLayer1 = bChannelSwap;
3878 m_hdrCurbe.DW49.IEFBypassEnablingFlagLayer1 = bBypassIEF;
3879 m_hdrCurbe.DW49.RotationAngleMirrorDirectionLayer1 = HdrRotation;
3880 m_hdrCurbe.DW49.SamplerIndexFirstPlaneLayer1 = uiSamplerStateIndex;
3881 if (pSource->osSurface->Format == Format_P010 ||
3882 pSource->osSurface->Format == Format_P016)
3883 {
3884 m_hdrCurbe.DW49.SamplerIndexSecondThirdPlaneLayer1 = uiSamplerStateIndex2;
3885 }
3886 m_hdrCurbe.DW49.CCMExtensionEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
3887 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
3888 m_hdrCurbe.DW49.ToneMappingEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
3889 m_hdrCurbe.DW49.PriorCSCEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
3890 m_hdrCurbe.DW49.EOTF1DLUTEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
3891 m_hdrCurbe.DW49.CCMEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].CCMEnable;
3892 m_hdrCurbe.DW49.OETF1DLUTEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].OETFEnable;
3893 m_hdrCurbe.DW49.PostCSCEnablingFlagLayer1 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
3894 m_hdrCurbe.DW49.Enabling3DLUTFlagLayer1 = b3dLut;
3895 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
3896 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
3897 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
3898 {
3899 m_hdrCurbe.DW56.ConstantBlendingAlphaFillColorLayer1 = wAlpha;
3900 }
3901 m_hdrCurbe.DW58.TwoLayerOperationLayer1 = HdrTwoLayerOp;
3902 break;
3903 case 2:
3904 m_hdrCurbe.DW2.HorizontalFrameOriginLayer2 = fOriginX;
3905 m_hdrCurbe.DW10.VerticalFrameOriginLayer2 = fOriginY;
3906 m_hdrCurbe.DW18.HorizontalScalingStepRatioLayer2 = fStepX;
3907 m_hdrCurbe.DW26.VerticalScalingStepRatioLayer2 = fStepY;
3908 m_hdrCurbe.DW34.LeftCoordinateRectangleLayer2 = pSource->rcDst.left;
3909 m_hdrCurbe.DW34.TopCoordinateRectangleLayer2 = pSource->rcDst.top;
3910 m_hdrCurbe.DW42.RightCoordinateRectangleLayer2 = pSource->rcDst.right - 1;
3911 m_hdrCurbe.DW42.BottomCoordinateRectangleLayer2 = pSource->rcDst.bottom - 1;
3912 m_hdrCurbe.DW50.FormatDescriptorLayer2 = FormatDescriptor;
3913 m_hdrCurbe.DW50.ChromaSittingLocationLayer2 = ChromaSiting;
3914 m_hdrCurbe.DW50.ChannelSwapEnablingFlagLayer2 = bChannelSwap;
3915 m_hdrCurbe.DW50.IEFBypassEnablingFlagLayer2 = bBypassIEF;
3916 m_hdrCurbe.DW50.RotationAngleMirrorDirectionLayer2 = HdrRotation;
3917 m_hdrCurbe.DW50.SamplerIndexFirstPlaneLayer2 = uiSamplerStateIndex;
3918 if (pSource->osSurface->Format == Format_P010 ||
3919 pSource->osSurface->Format == Format_P016)
3920 {
3921 m_hdrCurbe.DW50.SamplerIndexSecondThirdPlaneLayer2 = uiSamplerStateIndex2;
3922 }
3923 m_hdrCurbe.DW50.CCMExtensionEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
3924 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
3925 m_hdrCurbe.DW50.ToneMappingEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
3926 m_hdrCurbe.DW50.PriorCSCEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
3927 m_hdrCurbe.DW50.EOTF1DLUTEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
3928 m_hdrCurbe.DW50.CCMEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].CCMEnable;
3929 m_hdrCurbe.DW50.OETF1DLUTEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].OETFEnable;
3930 m_hdrCurbe.DW50.PostCSCEnablingFlagLayer2 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
3931 m_hdrCurbe.DW50.Enabling3DLUTFlagLayer2 = b3dLut;
3932 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
3933 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
3934 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
3935 {
3936 m_hdrCurbe.DW56.ConstantBlendingAlphaFillColorLayer2 = wAlpha;
3937 }
3938 m_hdrCurbe.DW58.TwoLayerOperationLayer2 = HdrTwoLayerOp;
3939 break;
3940 case 3:
3941 m_hdrCurbe.DW3.HorizontalFrameOriginLayer3 = fOriginX;
3942 m_hdrCurbe.DW11.VerticalFrameOriginLayer3 = fOriginY;
3943 m_hdrCurbe.DW19.HorizontalScalingStepRatioLayer3 = fStepX;
3944 m_hdrCurbe.DW27.VerticalScalingStepRatioLayer3 = fStepY;
3945 m_hdrCurbe.DW35.LeftCoordinateRectangleLayer3 = pSource->rcDst.left;
3946 m_hdrCurbe.DW35.TopCoordinateRectangleLayer3 = pSource->rcDst.top;
3947 m_hdrCurbe.DW43.RightCoordinateRectangleLayer3 = pSource->rcDst.right - 1;
3948 m_hdrCurbe.DW43.BottomCoordinateRectangleLayer3 = pSource->rcDst.bottom - 1;
3949 m_hdrCurbe.DW51.FormatDescriptorLayer3 = FormatDescriptor;
3950 m_hdrCurbe.DW51.ChromaSittingLocationLayer3 = ChromaSiting;
3951 m_hdrCurbe.DW51.ChannelSwapEnablingFlagLayer3 = bChannelSwap;
3952 m_hdrCurbe.DW51.IEFBypassEnablingFlagLayer3 = bBypassIEF;
3953 m_hdrCurbe.DW51.RotationAngleMirrorDirectionLayer3 = HdrRotation;
3954 m_hdrCurbe.DW51.SamplerIndexFirstPlaneLayer3 = uiSamplerStateIndex;
3955 if (pSource->osSurface->Format == Format_P010 ||
3956 pSource->osSurface->Format == Format_P016)
3957 {
3958 m_hdrCurbe.DW51.SamplerIndexSecondThirdPlaneLayer3 = uiSamplerStateIndex2;
3959 }
3960 m_hdrCurbe.DW51.CCMExtensionEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
3961 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
3962 m_hdrCurbe.DW51.ToneMappingEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
3963 m_hdrCurbe.DW51.PriorCSCEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
3964 m_hdrCurbe.DW51.EOTF1DLUTEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
3965 m_hdrCurbe.DW51.CCMEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].CCMEnable;
3966 m_hdrCurbe.DW51.OETF1DLUTEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].OETFEnable;
3967 m_hdrCurbe.DW51.PostCSCEnablingFlagLayer3 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
3968 m_hdrCurbe.DW51.Enabling3DLUTFlagLayer3 = b3dLut;
3969 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
3970 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
3971 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
3972 {
3973 m_hdrCurbe.DW56.ConstantBlendingAlphaFillColorLayer3 = wAlpha;
3974 }
3975 m_hdrCurbe.DW58.TwoLayerOperationLayer3 = HdrTwoLayerOp;
3976 break;
3977 case 4:
3978 m_hdrCurbe.DW4.HorizontalFrameOriginLayer4 = fOriginX;
3979 m_hdrCurbe.DW12.VerticalFrameOriginLayer4 = fOriginY;
3980 m_hdrCurbe.DW20.HorizontalScalingStepRatioLayer4 = fStepX;
3981 m_hdrCurbe.DW28.VerticalScalingStepRatioLayer4 = fStepY;
3982 m_hdrCurbe.DW36.LeftCoordinateRectangleLayer4 = pSource->rcDst.left;
3983 m_hdrCurbe.DW36.TopCoordinateRectangleLayer4 = pSource->rcDst.top;
3984 m_hdrCurbe.DW44.RightCoordinateRectangleLayer4 = pSource->rcDst.right - 1;
3985 m_hdrCurbe.DW44.BottomCoordinateRectangleLayer4 = pSource->rcDst.bottom - 1;
3986 m_hdrCurbe.DW52.FormatDescriptorLayer4 = FormatDescriptor;
3987 m_hdrCurbe.DW52.ChromaSittingLocationLayer4 = ChromaSiting;
3988 m_hdrCurbe.DW52.ChannelSwapEnablingFlagLayer4 = bChannelSwap;
3989 m_hdrCurbe.DW52.IEFBypassEnablingFlagLayer4 = bBypassIEF;
3990 m_hdrCurbe.DW52.RotationAngleMirrorDirectionLayer4 = HdrRotation;
3991 m_hdrCurbe.DW52.SamplerIndexFirstPlaneLayer4 = uiSamplerStateIndex;
3992 if (pSource->osSurface->Format == Format_P010 ||
3993 pSource->osSurface->Format == Format_P016)
3994 {
3995 m_hdrCurbe.DW52.SamplerIndexSecondThirdPlaneLayer4 = uiSamplerStateIndex2;
3996 }
3997 m_hdrCurbe.DW52.CCMExtensionEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
3998 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
3999 m_hdrCurbe.DW52.ToneMappingEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
4000 m_hdrCurbe.DW52.PriorCSCEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
4001 m_hdrCurbe.DW52.EOTF1DLUTEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
4002 m_hdrCurbe.DW52.CCMEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].CCMEnable;
4003 m_hdrCurbe.DW52.OETF1DLUTEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].OETFEnable;
4004 m_hdrCurbe.DW52.PostCSCEnablingFlagLayer4 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
4005 m_hdrCurbe.DW52.Enabling3DLUTFlagLayer4 = b3dLut;
4006 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
4007 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
4008 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
4009 {
4010 m_hdrCurbe.DW57.ConstantBlendingAlphaFillColorLayer4 = wAlpha;
4011 }
4012 m_hdrCurbe.DW59.TwoLayerOperationLayer4 = HdrTwoLayerOp;
4013 break;
4014 case 5:
4015 m_hdrCurbe.DW5.HorizontalFrameOriginLayer5 = fOriginX;
4016 m_hdrCurbe.DW13.VerticalFrameOriginLayer5 = fOriginY;
4017 m_hdrCurbe.DW21.HorizontalScalingStepRatioLayer5 = fStepX;
4018 m_hdrCurbe.DW29.VerticalScalingStepRatioLayer5 = fStepY;
4019 m_hdrCurbe.DW37.LeftCoordinateRectangleLayer5 = pSource->rcDst.left;
4020 m_hdrCurbe.DW37.TopCoordinateRectangleLayer5 = pSource->rcDst.top;
4021 m_hdrCurbe.DW45.RightCoordinateRectangleLayer5 = pSource->rcDst.right - 1;
4022 m_hdrCurbe.DW45.BottomCoordinateRectangleLayer5 = pSource->rcDst.bottom - 1;
4023 m_hdrCurbe.DW53.FormatDescriptorLayer5 = FormatDescriptor;
4024 m_hdrCurbe.DW53.ChromaSittingLocationLayer5 = ChromaSiting;
4025 m_hdrCurbe.DW53.ChannelSwapEnablingFlagLayer5 = bChannelSwap;
4026 m_hdrCurbe.DW53.IEFBypassEnablingFlagLayer5 = bBypassIEF;
4027 m_hdrCurbe.DW53.RotationAngleMirrorDirectionLayer5 = HdrRotation;
4028 m_hdrCurbe.DW53.SamplerIndexFirstPlaneLayer5 = uiSamplerStateIndex;
4029 if (pSource->osSurface->Format == Format_P010 ||
4030 pSource->osSurface->Format == Format_P016)
4031 {
4032 m_hdrCurbe.DW53.SamplerIndexSecondThirdPlaneLayer5 = uiSamplerStateIndex2;
4033 }
4034 m_hdrCurbe.DW53.CCMExtensionEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
4035 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
4036 m_hdrCurbe.DW53.ToneMappingEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
4037 m_hdrCurbe.DW53.PriorCSCEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
4038 m_hdrCurbe.DW53.EOTF1DLUTEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
4039 m_hdrCurbe.DW53.CCMEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].CCMEnable;
4040 m_hdrCurbe.DW53.OETF1DLUTEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].OETFEnable;
4041 m_hdrCurbe.DW53.PostCSCEnablingFlagLayer5 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
4042 m_hdrCurbe.DW53.Enabling3DLUTFlagLayer5 = b3dLut;
4043 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
4044 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
4045 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
4046 {
4047 m_hdrCurbe.DW57.ConstantBlendingAlphaFillColorLayer5 = wAlpha;
4048 }
4049 m_hdrCurbe.DW59.TwoLayerOperationLayer5 = HdrTwoLayerOp;
4050 break;
4051 case 6:
4052 m_hdrCurbe.DW6.HorizontalFrameOriginLayer6 = fOriginX;
4053 m_hdrCurbe.DW14.VerticalFrameOriginLayer6 = fOriginY;
4054 m_hdrCurbe.DW22.HorizontalScalingStepRatioLayer6 = fStepX;
4055 m_hdrCurbe.DW30.VerticalScalingStepRatioLayer6 = fStepY;
4056 m_hdrCurbe.DW38.LeftCoordinateRectangleLayer6 = pSource->rcDst.left;
4057 m_hdrCurbe.DW38.TopCoordinateRectangleLayer6 = pSource->rcDst.top;
4058 m_hdrCurbe.DW46.RightCoordinateRectangleLayer6 = pSource->rcDst.right - 1;
4059 m_hdrCurbe.DW46.BottomCoordinateRectangleLayer6 = pSource->rcDst.bottom - 1;
4060 m_hdrCurbe.DW54.FormatDescriptorLayer6 = FormatDescriptor;
4061 m_hdrCurbe.DW54.ChromaSittingLocationLayer6 = ChromaSiting;
4062 m_hdrCurbe.DW54.ChannelSwapEnablingFlagLayer6 = bChannelSwap;
4063 m_hdrCurbe.DW54.IEFBypassEnablingFlagLayer6 = bBypassIEF;
4064 m_hdrCurbe.DW54.RotationAngleMirrorDirectionLayer6 = HdrRotation;
4065 m_hdrCurbe.DW54.SamplerIndexFirstPlaneLayer6 = uiSamplerStateIndex;
4066 if (pSource->osSurface->Format == Format_P010 ||
4067 pSource->osSurface->Format == Format_P016)
4068 {
4069 m_hdrCurbe.DW54.SamplerIndexSecondThirdPlaneLayer6 = uiSamplerStateIndex2;
4070 }
4071 m_hdrCurbe.DW54.CCMExtensionEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
4072 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
4073 m_hdrCurbe.DW54.ToneMappingEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
4074 m_hdrCurbe.DW54.PriorCSCEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
4075 m_hdrCurbe.DW54.EOTF1DLUTEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
4076 m_hdrCurbe.DW54.CCMEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].CCMEnable;
4077 m_hdrCurbe.DW54.OETF1DLUTEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].OETFEnable;
4078 m_hdrCurbe.DW54.PostCSCEnablingFlagLayer6 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
4079 m_hdrCurbe.DW54.Enabling3DLUTFlagLayer6 = b3dLut;
4080 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
4081 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
4082 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
4083 {
4084 m_hdrCurbe.DW57.ConstantBlendingAlphaFillColorLayer6 = wAlpha;
4085 }
4086 m_hdrCurbe.DW59.TwoLayerOperationLayer6 = HdrTwoLayerOp;
4087 break;
4088 case 7:
4089 m_hdrCurbe.DW7.HorizontalFrameOriginLayer7 = fOriginX;
4090 m_hdrCurbe.DW15.VerticalFrameOriginLayer7 = fOriginY;
4091 m_hdrCurbe.DW23.HorizontalScalingStepRatioLayer7 = fStepX;
4092 m_hdrCurbe.DW31.VerticalScalingStepRatioLayer7 = fStepY;
4093 m_hdrCurbe.DW39.LeftCoordinateRectangleLayer7 = pSource->rcDst.left;
4094 m_hdrCurbe.DW39.TopCoordinateRectangleLayer7 = pSource->rcDst.top;
4095 m_hdrCurbe.DW47.RightCoordinateRectangleLayer7 = pSource->rcDst.right - 1;
4096 m_hdrCurbe.DW47.BottomCoordinateRectangleLayer7 = pSource->rcDst.bottom - 1;
4097 m_hdrCurbe.DW55.FormatDescriptorLayer7 = FormatDescriptor;
4098 m_hdrCurbe.DW55.ChromaSittingLocationLayer7 = ChromaSiting;
4099 m_hdrCurbe.DW55.ChannelSwapEnablingFlagLayer7 = bChannelSwap;
4100 m_hdrCurbe.DW55.IEFBypassEnablingFlagLayer7 = bBypassIEF;
4101 m_hdrCurbe.DW55.RotationAngleMirrorDirectionLayer7 = HdrRotation;
4102 m_hdrCurbe.DW55.SamplerIndexFirstPlaneLayer7 = uiSamplerStateIndex;
4103 if (pSource->osSurface->Format == Format_P010 ||
4104 pSource->osSurface->Format == Format_P016)
4105 {
4106 m_hdrCurbe.DW55.SamplerIndexSecondThirdPlaneLayer7 = uiSamplerStateIndex2;
4107 }
4108 m_hdrCurbe.DW55.CCMExtensionEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].CCMExt1Enable ||
4109 m_hdrParams->StageEnableFlags[i].CCMExt2Enable;
4110 m_hdrCurbe.DW55.ToneMappingEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].PWLFEnable;
4111 m_hdrCurbe.DW55.PriorCSCEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].PriorCSCEnable;
4112 m_hdrCurbe.DW55.EOTF1DLUTEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].EOTFEnable;
4113 m_hdrCurbe.DW55.CCMEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].CCMEnable;
4114 m_hdrCurbe.DW55.OETF1DLUTEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].OETFEnable;
4115 m_hdrCurbe.DW55.PostCSCEnablingFlagLayer7 = m_hdrParams->StageEnableFlags[i].PostCSCEnable;
4116 m_hdrCurbe.DW55.Enabling3DLUTFlagLayer7 = b3dLut;
4117 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND ||
4118 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND ||
4119 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND)
4120 {
4121 m_hdrCurbe.DW57.ConstantBlendingAlphaFillColorLayer7 = wAlpha;
4122 }
4123 m_hdrCurbe.DW59.TwoLayerOperationLayer7 = HdrTwoLayerOp;
4124 break;
4125 default:
4126 VP_RENDER_VERBOSEMESSAGE("Invalid input layer number.");
4127 break;
4128 }
4129 }
4130
4131 FormatDescriptor = GetFormatDescriptor(targetSurf->osSurface->Format);
4132 ChromaSiting = GetHdrChromaSiting(targetSurf->ChromaSiting);
4133
4134 if (targetSurf->osSurface->Format == Format_B10G10R10A2 ||
4135 targetSurf->osSurface->Format == Format_A8R8G8B8 ||
4136 targetSurf->osSurface->Format == Format_X8R8G8B8 ||
4137 targetSurf->osSurface->Format == Format_A16R16G16B16F)
4138 {
4139 bChannelSwap = true;
4140 }
4141 else
4142 {
4143 bChannelSwap = false;
4144 }
4145
4146 m_hdrCurbe.DW62.DestinationWidth = targetSurf->osSurface->dwWidth;
4147 m_hdrCurbe.DW62.DestinationHeight = targetSurf->osSurface->dwHeight;
4148 m_hdrCurbe.DW63.TotalNumberInputLayers = m_hdrParams->uSourceCount;
4149
4150 if (0 == m_hdrParams->uSourceCount)
4151 {
4152 m_hdrCurbe.DW32.LeftCoordinateRectangleLayer0 = targetSurf->osSurface->dwWidth + 16;
4153 m_hdrCurbe.DW32.TopCoordinateRectangleLayer0 = targetSurf->osSurface->dwHeight + 16;
4154 m_hdrCurbe.DW40.RightCoordinateRectangleLayer0 = targetSurf->osSurface->dwWidth + 16;
4155 m_hdrCurbe.DW40.BottomCoordinateRectangleLayer0 = targetSurf->osSurface->dwHeight + 16;
4156 m_hdrCurbe.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_COMP;
4157 }
4158
4159 m_hdrCurbe.DW63.FormatDescriptorDestination = (uint32_t)FormatDescriptor;
4160 m_hdrCurbe.DW63.ChromaSittingLocationDestination = ChromaSiting;
4161 m_hdrCurbe.DW63.ChannelSwapEnablingFlagDestination = bChannelSwap;
4162
4163 // Set Background color (use cspace of first layer)
4164 if (m_hdrParams->pColorFillParams)
4165 {
4166 VPHAL_COLOR_SAMPLE_8 Src, Dst;
4167 VPHAL_CSPACE src_cspace, dst_cspace;
4168
4169 Src.dwValue = m_hdrParams->pColorFillParams->Color;
4170
4171 // get src and dst colorspaces
4172 src_cspace = m_hdrParams->pColorFillParams->CSpace;
4173 dst_cspace = targetSurf->ColorSpace;
4174
4175 // Convert BG color only if not done so before. CSC is expensive!
4176 if (VpUtils::GetCscMatrixForRender8Bit(&Dst, &Src, src_cspace, dst_cspace))
4177 {
4178 m_hdrCurbe.DW60.FixedPointFillColorRVChannel = Dst.R << 8;
4179 m_hdrCurbe.DW60.FixedPointFillColorGYChannel = Dst.G << 8;
4180 m_hdrCurbe.DW61.FixedPointFillColorBUChannel = Dst.B << 8;
4181 m_hdrCurbe.DW61.FixedPointFillColorAlphaChannel = Dst.A << 8;
4182 }
4183 else
4184 {
4185 m_hdrCurbe.DW60.FixedPointFillColorRVChannel = Src.R << 8;
4186 m_hdrCurbe.DW60.FixedPointFillColorGYChannel = Src.G << 8;
4187 m_hdrCurbe.DW61.FixedPointFillColorBUChannel = Src.B << 8;
4188 m_hdrCurbe.DW61.FixedPointFillColorAlphaChannel = Src.A << 8;
4189 }
4190 }
4191
4192 curbe = (void*)(&m_hdrCurbe);
4193 curbeLength = (uint32_t)sizeof(MEDIA_WALKER_HDR_STATIC_DATA);
4194
4195 //DumpCurbe(&m_hdrCurbe, sizeof(MEDIA_WALKER_HDR_STATIC_DATA));
4196
4197 PrintCurbeDataUnified(&m_hdrCurbe);
4198
4199 return eStatus;
4200 }
4201
4202 uint32_t VpRenderHdrKernel::GetInlineDataSize()
4203 {
4204 VP_FUNC_CALL();
4205
4206 return 0;
4207 }
4208
4209 MOS_STATUS VpRenderHdrKernel::GetWalkerSetting(KERNEL_WALKER_PARAMS& walkerParam, KERNEL_PACKET_RENDER_DATA &renderData)
4210 {
4211 VP_FUNC_CALL();
4212
4213 RENDERHAL_KERNEL_PARAM kernelSettings;
4214 int32_t iBlocksX, iBlocksY;
4215 int32_t iBlockWd; // Block width
4216 int32_t iBlockHt; // Block Height
4217 uint32_t uiMediaWalkerBlockSize;
4218 bool bVerticalPattern = false;
4219 RECT AlignedRect = {};
4220 uint32_t dwSrcWidth;
4221 uint32_t dwSrcHeight;
4222
4223 walkerParam.iBindingTable = renderData.bindingTable;
4224 walkerParam.iMediaID = renderData.mediaID;
4225 walkerParam.iCurbeOffset = renderData.iCurbeOffset;
4226 walkerParam.iCurbeLength = renderData.iCurbeLength;
4227 // iBlocksX/iBlocksY will be calculated during prepare walker parameters in RenderCmdPacket
4228 walkerParam.calculateBlockXYByAlignedRect = false;
4229
4230 auto it = m_surfaceGroup->find(SurfaceTypeHdrInputLayer0);
4231 VP_SURFACE *surf = (m_surfaceGroup->end() != it) ? it->second : nullptr;
4232 if (surf == nullptr)
4233 {
4234 VP_RENDER_ASSERTMESSAGE("input surf was not found");
4235 return MOS_STATUS_NULL_POINTER;
4236 }
4237 VP_RENDER_CHK_NULL_RETURN(surf->osSurface);
4238
4239 auto OutputIt = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
4240 VP_SURFACE *outputSurf = (m_surfaceGroup->end() != OutputIt) ? OutputIt->second : nullptr;
4241 if (outputSurf == nullptr)
4242 {
4243 VP_RENDER_ASSERTMESSAGE("output surf was not found");
4244 return MOS_STATUS_NULL_POINTER;
4245 }
4246
4247 if (0 == m_hdrParams->uTargetCount || m_hdrParams->uTargetCount > 1)
4248 {
4249 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
4250 }
4251
4252 walkerParam.alignedRect = outputSurf->rcDst;
4253
4254 if (m_hdrParams->uSourceCount == 1 &&
4255 surf->osSurface->TileType == MOS_TILE_LINEAR &&
4256 (m_hdrParams->Rotation == VPHAL_ROTATION_90 ||
4257 m_hdrParams->Rotation == VPHAL_ROTATION_270))
4258 {
4259 walkerParam.isVerticalPattern = true;
4260 }
4261
4262 walkerParam.bSyncFlag = 0;
4263 walkerParam.isGroupStartInvolvedInGroupSize = true;
4264
4265 if (m_hdrParams->uSourceCount == 1 &&
4266 surf->osSurface->TileType == MOS_TILE_LINEAR &&
4267 (m_hdrParams->Rotation == VPHAL_ROTATION_90 || m_hdrParams->Rotation == VPHAL_ROTATION_270))
4268 {
4269 walkerParam.isVerticalPattern = true;
4270 }
4271
4272 iBlockWd = renderData.KernelParam.block_width;
4273 iBlockHt = renderData.KernelParam.block_height;
4274
4275 dwSrcWidth = outputSurf->rcDst.right - outputSurf->rcDst.left;
4276 dwSrcHeight = outputSurf->rcSrc.bottom - outputSurf->rcDst.top;
4277 iBlocksX = (dwSrcWidth + iBlockWd - 1) / iBlockWd;
4278 iBlocksY = (dwSrcHeight + iBlockHt - 1) / iBlockHt;
4279 walkerParam.iBlocksX = iBlocksX;
4280 walkerParam.iBlocksY = iBlocksY;
4281
4282 return MOS_STATUS_SUCCESS;
4283 }
4284
4285 MOS_STATUS VpRenderHdrKernel::SetKernelConfigs(KERNEL_CONFIGS& kernelConfigs)
4286 {
4287 VP_FUNC_CALL();
4288
4289 if (m_hdrParams == nullptr)
4290 {
4291 m_hdrParams = (RENDER_HDR_PARAMS *)MOS_AllocAndZeroMemory(sizeof(RENDER_HDR_PARAMS));
4292 }
4293 VP_RENDER_CHK_NULL_RETURN(m_hdrParams);
4294
4295 PRENDER_HDR_PARAMS hdrParams = nullptr;
4296 if (kernelConfigs.find(m_kernelId) != kernelConfigs.end())
4297 {
4298 hdrParams = (PRENDER_HDR_PARAMS)kernelConfigs.find(m_kernelId)->second;
4299 }
4300
4301 VP_RENDER_CHK_NULL_RETURN(hdrParams);
4302
4303 MOS_SecureMemcpy(m_hdrParams, sizeof(RENDER_HDR_PARAMS), hdrParams, sizeof(RENDER_HDR_PARAMS));
4304
4305 return MOS_STATUS_SUCCESS;
4306
4307 }
4308
4309 //! \brief Get the HDR format descriptor of a format
4310 //! \details Get the HDR format descriptor of a format and return.
4311 //! \param MOS_FORMAT Format
4312 //! [in] MOS_FORMAT of a surface
4313 //! \return VPHAL_HDR_FORMAT_DESCRIPTOR
4314 //! HDR format descriptor
4315 //!
4316 VPHAL_HDR_FORMAT_DESCRIPTOR VpRenderHdrKernel::GetFormatDescriptor(
4317 MOS_FORMAT Format)
4318 {
4319 VP_FUNC_CALL();
4320
4321 VPHAL_HDR_FORMAT_DESCRIPTOR FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW;
4322
4323 switch (Format)
4324 {
4325 case Format_R10G10B10A2:
4326 case Format_B10G10R10A2:
4327 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_R10G10B10A2_UNORM;
4328 break;
4329
4330 case Format_X8R8G8B8:
4331 case Format_A8R8G8B8:
4332 case Format_A8B8G8R8:
4333 case Format_X8B8G8R8:
4334 case Format_AYUV:
4335 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_R8G8B8A8_UNORM;
4336 break;
4337
4338 case Format_NV12:
4339 case Format_NV21:
4340 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_NV12;
4341 break;
4342
4343 case Format_YUY2:
4344 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_YUY2;
4345 break;
4346
4347 case Format_P010:
4348 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_P010;
4349 break;
4350
4351 case Format_P016:
4352 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_P016;
4353 break;
4354
4355 case Format_A16R16G16B16F:
4356 case Format_A16B16G16R16F:
4357 FormatDescriptor = VPHAL_HDR_FORMAT_R16G16B16A16_FLOAT;
4358 break;
4359
4360 default:
4361 VP_RENDER_ASSERTMESSAGE("Unsupported input format.");
4362 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW;
4363 break;
4364 }
4365
4366 return FormatDescriptor;
4367 }
4368
4369 //! \brief Get the HDR Chroma siting
4370 //! \details Get the HDR Chroma siting and return.
4371 //! \param uint32_t ChromaSiting
4372 //! [in] ChromaSiting of a surface
4373 //! \return VPHAL_HDR_CHROMA_SITING
4374 //! HDR Chroma siting
4375 //!
4376 VPHAL_HDR_CHROMA_SITING VpRenderHdrKernel::GetHdrChromaSiting(
4377 uint32_t ChromaSiting)
4378 {
4379 VP_FUNC_CALL();
4380
4381 VPHAL_HDR_CHROMA_SITING HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A;
4382
4383 switch (ChromaSiting)
4384 {
4385 case CHROMA_SITING_HORZ_LEFT :
4386 HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A;
4387 break;
4388 default:
4389 HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A;
4390 break;
4391 }
4392
4393 return HdrChromaSiting;
4394 }
4395
4396 //! \brief Get the HDR rotation
4397 //! \details Get the HDR rotation and return.
4398 //! \param VPHAL_ROTATION Rotation
4399 //! [in] Rotation of a surface
4400 //! \return VPHAL_HDR_ROTATION
4401 //! HDR Chroma siting
4402 //!
4403 VPHAL_HDR_ROTATION VpRenderHdrKernel::GetHdrRotation(
4404 VPHAL_ROTATION Rotation)
4405 {
4406 VP_FUNC_CALL();
4407
4408 VPHAL_HDR_ROTATION HdrRotation = VPHAL_HDR_LAYER_ROTATION_0;
4409
4410 switch (Rotation)
4411 {
4412 case VPHAL_ROTATION_IDENTITY :
4413 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0;
4414 break;
4415 case VPHAL_ROTATION_90 :
4416 HdrRotation = VPHAL_HDR_LAYER_ROTATION_90;
4417 break;
4418 case VPHAL_ROTATION_180 :
4419 HdrRotation = VPHAL_HDR_LAYER_ROTATION_180;
4420 break;
4421 case VPHAL_ROTATION_270 :
4422 HdrRotation = VPHAL_HDR_LAYER_ROTATION_270;
4423 break;
4424 case VPHAL_MIRROR_HORIZONTAL :
4425 HdrRotation = VPHAL_HDR_LAYER_MIRROR_H;
4426 break;
4427 case VPHAL_MIRROR_VERTICAL :
4428 HdrRotation = VPHAL_HDR_LAYER_MIRROR_V;
4429 break;
4430 case VPHAL_ROTATE_90_MIRROR_VERTICAL :
4431 HdrRotation = VPHAL_HDR_LAYER_ROT_90_MIR_V;
4432 break;
4433 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL :
4434 HdrRotation = VPHAL_HDR_LAYER_ROT_90_MIR_H;
4435 break;
4436 default:
4437 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0;
4438 break;
4439 }
4440
4441 return HdrRotation;
4442 }
4443
4444 //!
4445 //! \brief Recalculate Sampler Avs 8x8 Horizontal/Vertical scaling table
4446 //! \details Recalculate Sampler Avs 8x8 Horizontal/Vertical scaling table
4447 //! \param MOS_FORMAT SrcFormat
4448 //! [in] Source Format
4449 //! \param float fScale
4450 //! [in] Horizontal or Vertical Scale Factor
4451 //! \param bool bVertical
4452 //! [in] true if Vertical Scaling, else Horizontal Scaling
4453 //! \param uint32_t dwChromaSiting
4454 //! [in] Chroma Siting
4455 //! \param bool bBalancedFilter
4456 //! [in] true if Gen9+, balanced filter
4457 //! \param bool b8TapAdaptiveEnable
4458 //! [in] true if 8Tap Adaptive Enable
4459 //! \param PVPHAL_AVS_PARAMS pAvsParams
4460 //! [in/out] Pointer to AVS Params
4461 //! \return MOS_STATUS
4462 //!
4463 MOS_STATUS VpRenderHdrKernel::SamplerAvsCalcScalingTable(
4464 MOS_FORMAT SrcFormat,
4465 float fScale,
4466 bool bVertical,
4467 uint32_t dwChromaSiting,
4468 bool bBalancedFilter,
4469 bool b8TapAdaptiveEnable,
4470 PMHW_AVS_PARAMS pAvsParams)
4471 {
4472 VP_FUNC_CALL();
4473
4474 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4475 MHW_PLANE Plane = MHW_GENERIC_PLANE;
4476 int32_t iUvPhaseOffset = 0;
4477 uint32_t dwHwPhrase = 0;
4478 uint32_t YCoefTableSize = 0;
4479 uint32_t UVCoefTableSize = 0;
4480 float fScaleParam = 0.0f;
4481 int32_t* piYCoefsParam = nullptr;
4482 int32_t* piUVCoefsParam = nullptr;
4483 float fHPStrength = 0.0f;
4484
4485 VP_RENDER_CHK_NULL_RETURN(pAvsParams);
4486 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piYCoefsY);
4487 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piYCoefsX);
4488 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piUVCoefsY);
4489 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piUVCoefsX);
4490
4491 if (bBalancedFilter)
4492 {
4493 YCoefTableSize = POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9;
4494 UVCoefTableSize = POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9;
4495 dwHwPhrase = NUM_HW_POLYPHASE_TABLES;
4496 }
4497 else
4498 {
4499 YCoefTableSize = POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G8;
4500 UVCoefTableSize = POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G8;
4501 dwHwPhrase = MHW_NUM_HW_POLYPHASE_TABLES;
4502 }
4503
4504 fHPStrength = 0.0F;
4505 piYCoefsParam = bVertical ? pAvsParams->piYCoefsY : pAvsParams->piYCoefsX;
4506 piUVCoefsParam = bVertical ? pAvsParams->piUVCoefsY : pAvsParams->piUVCoefsX;
4507 fScaleParam = bVertical ? pAvsParams->fScaleY : pAvsParams->fScaleX;
4508
4509 // Recalculate Horizontal or Vertical scaling table
4510 if (SrcFormat != pAvsParams->Format || fScale != fScaleParam)
4511 {
4512 MOS_ZeroMemory(piYCoefsParam, YCoefTableSize);
4513 MOS_ZeroMemory(piUVCoefsParam, UVCoefTableSize);
4514
4515 // 4-tap filtering for RGB format G-channel if 8tap adaptive filter is not enabled.
4516 Plane = (IS_RGB32_FORMAT(SrcFormat) && !b8TapAdaptiveEnable) ? MHW_U_PLANE : MHW_Y_PLANE;
4517 if (bVertical)
4518 {
4519 pAvsParams->fScaleY = fScale;
4520 }
4521 else
4522 {
4523 pAvsParams->fScaleX = fScale;
4524 }
4525
4526 // For 1x scaling in horizontal direction, use special coefficients for filtering
4527 // we don't do this when bForcePolyPhaseCoefs flag is set
4528 if (fScale == 1.0F && !pAvsParams->bForcePolyPhaseCoefs)
4529 {
4530 VP_RENDER_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
4531 piYCoefsParam,
4532 Plane,
4533 bBalancedFilter));
4534 // If the 8-tap adaptive is enabled for all channel, then UV/RB use the same coefficient as Y/G
4535 // So, coefficient for UV/RB channels caculation can be passed
4536 if (!b8TapAdaptiveEnable)
4537 {
4538 VP_RENDER_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
4539 piUVCoefsParam,
4540 MHW_U_PLANE,
4541 bBalancedFilter));
4542 }
4543 }
4544 else
4545 {
4546 // Clamp the Scaling Factor if > 1.0x
4547 fScale = MOS_MIN(1.0F, fScale);
4548
4549 VP_RENDER_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesY(
4550 piYCoefsParam,
4551 fScale,
4552 Plane,
4553 SrcFormat,
4554 fHPStrength,
4555 true,
4556 dwHwPhrase,
4557 0));
4558
4559 // If the 8-tap adaptive is enabled for all channel, then UV/RB use the same coefficient as Y/G
4560 // So, coefficient for UV/RB channels caculation can be passed
4561 if (!b8TapAdaptiveEnable)
4562 {
4563 if (!bBalancedFilter)
4564 {
4565 VP_RENDER_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesY(
4566 piUVCoefsParam,
4567 fScale,
4568 MHW_U_PLANE,
4569 SrcFormat,
4570 fHPStrength,
4571 true,
4572 dwHwPhrase,
4573 0));
4574 }
4575 else
4576 {
4577 // If Chroma Siting info is present
4578 if (dwChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_TOP : MHW_CHROMA_SITING_HORZ_LEFT))
4579 {
4580 // No Chroma Siting
4581 VP_RENDER_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUV(
4582 piUVCoefsParam,
4583 2.0F,
4584 fScale));
4585 }
4586 else
4587 {
4588 // Chroma siting offset needs to be added
4589 if (dwChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_CENTER : MHW_CHROMA_SITING_HORZ_CENTER))
4590 {
4591 iUvPhaseOffset = MOS_UF_ROUND(0.5F * 16.0F); // U0.4
4592 }
4593 else //if (ChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_BOTTOM : MHW_CHROMA_SITING_HORZ_RIGHT))
4594 {
4595 iUvPhaseOffset = MOS_UF_ROUND(1.0F * 16.0F); // U0.4
4596 }
4597
4598 VP_RENDER_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUVOffset(
4599 piUVCoefsParam,
4600 3.0F,
4601 fScale,
4602 iUvPhaseOffset));
4603 }
4604 }
4605 }
4606 }
4607 }
4608
4609 return eStatus;
4610 }
4611
4612
4613 //!
4614 //! \brief Set Sampler8x8 Table for Gen9 Hdr AVS
4615 //! \details Set sampler8x8 table based on format, scale and chroma siting
4616 //! \param PRENDERHAL_INTERFACE pRenderHal
4617 //! [in] Pointer to RenderHal interface
4618 //! \param PMHW_SAMPLER_STATE_PARAM pSamplerStateParams,
4619 //! [in] Pointer to sampler state params
4620 //! \param PVPHAL_AVS_PARAMS pAvsParams
4621 //! [in] Pointer to avs parameters
4622 //! \param MOS_FORMAT SrcFormat
4623 //! [in] source format
4624 //! \param float fScaleX
4625 //! [in] Scale X
4626 //! \param float fScaleY
4627 //! [in] Scale Y
4628 //! \param uint32_t dwChromaSiting
4629 //! [in] Chroma siting
4630 //! \return void
4631 //!
4632 MOS_STATUS VpRenderHdrKernel::SetSamplerAvsTableParam(
4633 PRENDERHAL_INTERFACE pRenderHal,
4634 PMHW_SAMPLER_STATE_PARAM pSamplerStateParams,
4635 PMHW_AVS_PARAMS pAvsParams,
4636 MOS_FORMAT SrcFormat,
4637 float fScaleX,
4638 float fScaleY,
4639 uint32_t dwChromaSiting)
4640 {
4641 VP_FUNC_CALL();
4642
4643 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4644 bool bBalancedFilter = false;
4645 PMHW_SAMPLER_AVS_TABLE_PARAM pMhwSamplerAvsTableParam = nullptr;
4646
4647 VP_RENDER_CHK_NULL_RETURN(pRenderHal);
4648 VP_RENDER_CHK_NULL_RETURN(pSamplerStateParams);
4649 VP_RENDER_CHK_NULL_RETURN(pAvsParams);
4650 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piYCoefsY);
4651 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piYCoefsX);
4652 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piUVCoefsY);
4653 VP_RENDER_CHK_NULL_RETURN(pAvsParams->piUVCoefsX);
4654
4655 pMhwSamplerAvsTableParam = pSamplerStateParams->Avs.pMhwSamplerAvsTableParam;
4656
4657 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable = pSamplerStateParams->Avs.b8TapAdaptiveEnable;
4658 pMhwSamplerAvsTableParam->byteTransitionArea8Pixels = MEDIASTATE_AVS_TRANSITION_AREA_8_PIXELS;
4659 pMhwSamplerAvsTableParam->byteTransitionArea4Pixels = MEDIASTATE_AVS_TRANSITION_AREA_4_PIXELS;
4660 pMhwSamplerAvsTableParam->byteMaxDerivative8Pixels = MEDIASTATE_AVS_MAX_DERIVATIVE_8_PIXELS;
4661 pMhwSamplerAvsTableParam->byteMaxDerivative4Pixels = MEDIASTATE_AVS_MAX_DERIVATIVE_4_PIXELS;
4662 pMhwSamplerAvsTableParam->byteDefaultSharpnessLevel = MEDIASTATE_AVS_SHARPNESS_LEVEL_SHARP;
4663
4664 // Enable Adaptive Filtering, if it is being upscaled
4665 // in either direction. we must check for this before clamping the SF.
4666 if ((IS_YUV_FORMAT(SrcFormat) && (fScaleX > 1.0F || fScaleY > 1.0F)) ||
4667 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable)
4668 {
4669 pMhwSamplerAvsTableParam->bBypassXAdaptiveFiltering = false;
4670 pMhwSamplerAvsTableParam->bBypassYAdaptiveFiltering = false;
4671 if (pMhwSamplerAvsTableParam->b8TapAdaptiveEnable)
4672 {
4673 pMhwSamplerAvsTableParam->bAdaptiveFilterAllChannels = true;
4674
4675 if (IS_RGB_FORMAT(SrcFormat))
4676 {
4677 pMhwSamplerAvsTableParam->bEnableRGBAdaptive = true;
4678 }
4679 }
4680 }
4681 else
4682 {
4683 pMhwSamplerAvsTableParam->bBypassXAdaptiveFiltering = true;
4684 pMhwSamplerAvsTableParam->bBypassYAdaptiveFiltering = true;
4685 }
4686
4687 // No changes to AVS parameters -> skip
4688 if (SrcFormat == pAvsParams->Format &&
4689 fScaleX == pAvsParams->fScaleX &&
4690 fScaleY == pAvsParams->fScaleY)
4691 {
4692 return MOS_STATUS_SUCCESS;
4693 }
4694
4695 // AVS Coefficients don't change for Scaling Factors > 1.0x
4696 // Hence recalculation is avoided
4697 if (fScaleX > 1.0F && pAvsParams->fScaleX > 1.0F)
4698 {
4699 pAvsParams->fScaleX = fScaleX;
4700 }
4701
4702 // AVS Coefficients don't change for Scaling Factors > 1.0x
4703 // Hence recalculation is avoided
4704 if (fScaleY > 1.0F && pAvsParams->fScaleY > 1.0F)
4705 {
4706 pAvsParams->fScaleY = fScaleY;
4707 }
4708
4709 bBalancedFilter = true;
4710 // Recalculate Horizontal scaling table
4711 VP_RENDER_CHK_STATUS_RETURN(SamplerAvsCalcScalingTable(
4712 SrcFormat,
4713 fScaleX,
4714 false,
4715 dwChromaSiting,
4716 bBalancedFilter,
4717 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable ? true : false,
4718 pAvsParams));
4719
4720 // Recalculate Vertical scaling table
4721 VP_RENDER_CHK_STATUS_RETURN(SamplerAvsCalcScalingTable(
4722 SrcFormat,
4723 fScaleY,
4724 true,
4725 dwChromaSiting,
4726 bBalancedFilter,
4727 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable ? true : false,
4728 pAvsParams));
4729
4730 pMhwSamplerAvsTableParam->bIsCoeffExtraEnabled = true;
4731 // Save format used to calculate AVS parameters
4732 pAvsParams->Format = SrcFormat;
4733 pMhwSamplerAvsTableParam->b4TapGY = (IS_RGB32_FORMAT(SrcFormat) && !pMhwSamplerAvsTableParam->b8TapAdaptiveEnable);
4734 pMhwSamplerAvsTableParam->b4TapRBUV = (!pMhwSamplerAvsTableParam->b8TapAdaptiveEnable);
4735
4736 return eStatus;
4737 }
4738
4739 MOS_STATUS VpRenderHdrKernel::GetSamplerIndex(
4740 VPHAL_SCALING_MODE scalingMode,
4741 uint32_t yuvPlane,
4742 int32_t &samplerIndex,
4743 MHW_SAMPLER_TYPE &samplerType)
4744 {
4745 const int32_t samplerindex[2][3] = {{VP_SAMPLER_INDEX_Y_NEAREST, VP_SAMPLER_INDEX_U_NEAREST, VP_SAMPLER_INDEX_V_NEAREST},
4746 {VP_SAMPLER_INDEX_Y_BILINEAR, VP_SAMPLER_INDEX_U_BILINEAR, VP_SAMPLER_INDEX_V_BILINEAR}};
4747
4748 if (scalingMode == VPHAL_SCALING_AVS)
4749 {
4750 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
4751 }
4752
4753 // if Scalingmode is BILINEAR, use the 4,5,6. if NEAREST, use 1,2,3
4754 samplerType = MHW_SAMPLER_TYPE_3D;
4755 samplerIndex = samplerindex[scalingMode][yuvPlane];
4756
4757 return MOS_STATUS_SUCCESS;
4758 }
4759
4760 MOS_STATUS VpRenderHdrKernel::SetSamplerStates(KERNEL_SAMPLER_STATE_GROUP& samplerStateGroup)
4761 {
4762 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4763 MHW_SAMPLER_STATE_PARAM samplerStateParam = {};
4764 uint32_t i = 0;
4765 uint32_t entryIndex = 0;
4766 int32_t samplerIndex = 0;
4767 MHW_SAMPLER_TYPE samplerType = MHW_SAMPLER_TYPE_INVALID;
4768
4769 m_samplerStateGroup = &samplerStateGroup;
4770 m_samplerIndexes.clear();
4771 m_samplerIndexes.push_back(0);
4772
4773 return eStatus;
4774 }
4775
4776 void VpRenderHdrKernel::DumpSurfaces()
4777 {
4778 VP_FUNC_CALL();
4779
4780 PMOS_INTERFACE pOsInterface = m_hwInterface->m_osInterface;
4781
4782 auto inputSurface = m_surfaceGroup->find(SurfaceTypeHdrInputLayer0);
4783 VP_SURFACE* surf1 = (m_surfaceGroup->end() != inputSurface) ? inputSurface->second : nullptr;
4784
4785 auto OETF1DLUTSurface = m_surfaceGroup->find(SurfaceTypeHdrOETF1DLUTSurface0);
4786 VP_SURFACE* surf2 = (m_surfaceGroup->end() != OETF1DLUTSurface) ? OETF1DLUTSurface->second : nullptr;
4787
4788 auto coeffSurface = m_surfaceGroup->find(SurfaceTypeHdrCoeff);
4789 VP_SURFACE* surf3 = (m_surfaceGroup->end() != coeffSurface) ? coeffSurface->second : nullptr;
4790
4791 auto targetSurface = m_surfaceGroup->find(SurfaceTypeHdrTarget0);
4792 VP_SURFACE* surf4 = (m_surfaceGroup->end() != targetSurface) ? targetSurface->second : nullptr;
4793
4794 auto RenderInputSurface = m_surfaceGroup->find(SurfaceTypeHdrInputLayer0);
4795 VP_SURFACE *surf5 = (m_surfaceGroup->end() != RenderInputSurface) ? RenderInputSurface->second : nullptr;
4796
4797 if (surf1)
4798 {
4799 DumpSurface(surf1,VP_HDR_DUMP_INPUT_LAYER0);
4800 }
4801 if (surf5)
4802 {
4803 DumpSurface(surf5, VP_HDR_DUMP_RENDER_INPUT);
4804 }
4805
4806 if (surf2)
4807 {
4808 DumpSurface(surf2,VP_HDR_DUMP_OETF1DLUT_SURFACE0);
4809 }
4810 if (surf3)
4811 {
4812 DumpSurface(surf3,VP_HDR_DUMP_COEFF_SURFACE);
4813 }
4814 if (surf4)
4815 {
4816 DumpSurface(surf4,VP_HDR_DUMP_TARGET_SURFACE0);
4817 }
4818
4819 return;
4820 }
4821
4822 void VpRenderHdrKernel::DumpCurbe(void *pCurbe, int32_t iSize)
4823 {
4824 VP_FUNC_CALL();
4825 char CurbeName[MAX_PATH];
4826
4827 MOS_SecureStringPrint(
4828 CurbeName,
4829 sizeof(CurbeName),
4830 sizeof(CurbeName),
4831 "c:\\\\dump\\f[%04d]hdr_Curbe.dat",
4832 1);
4833 MosUtilities::MosWriteFileFromPtr(
4834 (const char *)CurbeName,
4835 pCurbe,
4836 iSize);
4837 }
4838
4839 void VpRenderHdrKernel::PrintCurbeData(PMEDIA_WALKER_HDR_STATIC_DATA curbeData)
4840 {
4841 #if (_DEBUG || _RELEASE_INTERNAL)
4842 if (curbeData == nullptr)
4843 {
4844 VP_RENDER_ASSERTMESSAGE("The curbeData pointer is null");
4845 return;
4846 }
4847 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW0.Value = %x", curbeData->DW0.Value);
4848 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer0 = %x",
4849 curbeData->DW0.HorizontalFrameOriginLayer0);
4850 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW1.Value = %x", curbeData->DW1.Value);
4851 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer1 = %x",
4852 curbeData->DW1.HorizontalFrameOriginLayer1);
4853 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW2.Value = %x", curbeData->DW2.Value);
4854 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer2 = %x",
4855 curbeData->DW2.HorizontalFrameOriginLayer2);
4856 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW3.Value = %x", curbeData->DW3.Value);
4857 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer3 = %x",
4858 curbeData->DW3.HorizontalFrameOriginLayer3);
4859 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW4.Value = %x", curbeData->DW4.Value);
4860 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer4 = %x",
4861 curbeData->DW4.HorizontalFrameOriginLayer4);
4862 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW5.Value = %x", curbeData->DW5.Value);
4863 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer5 = %x",
4864 curbeData->DW5.HorizontalFrameOriginLayer5);
4865 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW6.Value = %x", curbeData->DW6.Value);
4866 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer6 = %x",
4867 curbeData->DW6.HorizontalFrameOriginLayer6);
4868 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW7.Value = %x", curbeData->DW7.Value);
4869 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalFrameOriginLayer7 = %x",
4870 curbeData->DW7.HorizontalFrameOriginLayer7);
4871 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW8.Value = %x", curbeData->DW8.Value);
4872 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer0 = %x",
4873 curbeData->DW8.VerticalFrameOriginLayer0);
4874 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW9.Value = %x", curbeData->DW9.Value);
4875 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer1 = %x",
4876 curbeData->DW9.VerticalFrameOriginLayer1);
4877 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW10.Value = %x", curbeData->DW10.Value);
4878 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer2 = %x",
4879 curbeData->DW10.VerticalFrameOriginLayer2);
4880 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW11.Value = %x", curbeData->DW11.Value);
4881 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer3 = %x",
4882 curbeData->DW11.VerticalFrameOriginLayer3);
4883 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW12.Value = %x", curbeData->DW12.Value);
4884 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer4 = %x",
4885 curbeData->DW12.VerticalFrameOriginLayer4);
4886 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW13.Value = %x", curbeData->DW13.Value);
4887 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer5 = %x",
4888 curbeData->DW13.VerticalFrameOriginLayer5);
4889 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW14.Value = %x", curbeData->DW14.Value);
4890 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer6 = %x",
4891 curbeData->DW14.VerticalFrameOriginLayer6);
4892 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW15.Value = %x", curbeData->DW15.Value);
4893 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalFrameOriginLayer7 = %x",
4894 curbeData->DW15.VerticalFrameOriginLayer7);
4895 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW16.Value = %x", curbeData->DW16.Value);
4896 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer0 = %x",
4897 curbeData->DW16.HorizontalScalingStepRatioLayer0);
4898 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW17.Value = %x", curbeData->DW17.Value);
4899 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer1 = %x",
4900 curbeData->DW17.HorizontalScalingStepRatioLayer1);
4901 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW18.Value = %x", curbeData->DW18.Value);
4902 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer2 = %x",
4903 curbeData->DW18.HorizontalScalingStepRatioLayer2);
4904 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW19.Value = %x", curbeData->DW19.Value);
4905 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer3 = %x",
4906 curbeData->DW19.HorizontalScalingStepRatioLayer3);
4907 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW20.Value = %x", curbeData->DW20.Value);
4908 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer4 = %x",
4909 curbeData->DW20.HorizontalScalingStepRatioLayer4);
4910 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW21.Value = %x", curbeData->DW21.Value);
4911 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer5 = %x",
4912 curbeData->DW21.HorizontalScalingStepRatioLayer5);
4913 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW22.Value = %x", curbeData->DW22.Value);
4914 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer6 = %x",
4915 curbeData->DW22.HorizontalScalingStepRatioLayer6);
4916 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW23.Value = %x", curbeData->DW23.Value);
4917 VP_RENDER_VERBOSEMESSAGE("CurbeData: HorizontalScalingStepRatioLayer7 = %x",
4918 curbeData->DW23.HorizontalScalingStepRatioLayer7);
4919 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW24.Value = %x", curbeData->DW24.Value);
4920 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer0 = %x",
4921 curbeData->DW24.VerticalScalingStepRatioLayer0);
4922 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW25.Value = %x", curbeData->DW25.Value);
4923 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer1 = %x",
4924 curbeData->DW25.VerticalScalingStepRatioLayer1);
4925 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW26.Value = %x", curbeData->DW26.Value);
4926 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer2 = %x",
4927 curbeData->DW26.VerticalScalingStepRatioLayer2);
4928 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW27.Value = %x", curbeData->DW27.Value);
4929 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer3 = %x",
4930 curbeData->DW27.VerticalScalingStepRatioLayer3);
4931 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW28.Value = %x", curbeData->DW28.Value);
4932 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer4 = %x",
4933 curbeData->DW28.VerticalScalingStepRatioLayer4);
4934 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW29.Value = %x", curbeData->DW29.Value);
4935 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer5 = %x",
4936 curbeData->DW29.VerticalScalingStepRatioLayer5);
4937 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW30.Value = %x", curbeData->DW30.Value);
4938 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer6 = %x",
4939 curbeData->DW30.VerticalScalingStepRatioLayer6);
4940 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW31.Value = %x", curbeData->DW31.Value);
4941 VP_RENDER_VERBOSEMESSAGE("CurbeData: VerticalScalingStepRatioLayer7 = %x",
4942 curbeData->DW31.VerticalScalingStepRatioLayer7);
4943 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW32.Value = %d", curbeData->DW32.Value);
4944 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer0 = 0x%d, TopCoordinateRectangleLayer0 = 0x%d",
4945 curbeData->DW32.LeftCoordinateRectangleLayer0,
4946 curbeData->DW32.TopCoordinateRectangleLayer0);
4947 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW33.Value = %d", curbeData->DW33.Value);
4948 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer1 = 0x%d, TopCoordinateRectangleLayer2 = 0x%d",
4949 curbeData->DW33.LeftCoordinateRectangleLayer1,
4950 curbeData->DW33.TopCoordinateRectangleLayer1);
4951 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW34.Value = %d", curbeData->DW34.Value);
4952 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer2 = 0x%d, TopCoordinateRectangleLayer2 = 0x%d",
4953 curbeData->DW34.LeftCoordinateRectangleLayer2,
4954 curbeData->DW34.TopCoordinateRectangleLayer2);
4955 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW35.Value = %d", curbeData->DW35.Value);
4956 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer3 = 0x%d, TopCoordinateRectangleLayer3 = 0x%d",
4957 curbeData->DW35.LeftCoordinateRectangleLayer3,
4958 curbeData->DW35.TopCoordinateRectangleLayer3);
4959 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW36.Value = %d", curbeData->DW36.Value);
4960 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer4 = 0x%d, TopCoordinateRectangleLayer4 = 0x%d",
4961 curbeData->DW36.LeftCoordinateRectangleLayer4,
4962 curbeData->DW36.TopCoordinateRectangleLayer4);
4963 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW37.Value = %d", curbeData->DW37.Value);
4964 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer5 = 0x%d, TopCoordinateRectangleLayer5 = 0x%d",
4965 curbeData->DW37.LeftCoordinateRectangleLayer5,
4966 curbeData->DW37.TopCoordinateRectangleLayer5);
4967 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW38.Value = %d", curbeData->DW38.Value);
4968 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer6 = 0x%d, TopCoordinateRectangleLayer6 = 0x%d",
4969 curbeData->DW38.LeftCoordinateRectangleLayer6,
4970 curbeData->DW38.TopCoordinateRectangleLayer6);
4971 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW39.Value = %d", curbeData->DW39.Value);
4972 VP_RENDER_VERBOSEMESSAGE("CurbeData: LeftCoordinateRectangleLayer7 = 0x%d, TopCoordinateRectangleLayer7 = 0x%d",
4973 curbeData->DW39.LeftCoordinateRectangleLayer7,
4974 curbeData->DW39.TopCoordinateRectangleLayer7);
4975 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW40.Value = %d", curbeData->DW40.Value);
4976 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer0 = 0x%d, RightCoordinateRectangleLayer0 = 0x%d",
4977 curbeData->DW40.BottomCoordinateRectangleLayer0,
4978 curbeData->DW40.RightCoordinateRectangleLayer0);
4979 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW41.Value = %d", curbeData->DW41.Value);
4980 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer1 = 0x%d, RightCoordinateRectangleLayer1 = 0x%d",
4981 curbeData->DW41.BottomCoordinateRectangleLayer1,
4982 curbeData->DW41.RightCoordinateRectangleLayer1);
4983 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW42.Value = %d", curbeData->DW42.Value);
4984 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer2 = 0x%d, RightCoordinateRectangleLayer2 = 0x%d",
4985 curbeData->DW42.BottomCoordinateRectangleLayer2,
4986 curbeData->DW42.RightCoordinateRectangleLayer2);
4987 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW43.Value = %d", curbeData->DW43.Value);
4988 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer3 = 0x%d, RightCoordinateRectangleLayer3 = 0x%d",
4989 curbeData->DW43.BottomCoordinateRectangleLayer3,
4990 curbeData->DW43.RightCoordinateRectangleLayer3);
4991 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW44.Value = %d", curbeData->DW44.Value);
4992 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer4 = 0x%d, RightCoordinateRectangleLayer4 = 0x%d",
4993 curbeData->DW44.BottomCoordinateRectangleLayer4,
4994 curbeData->DW44.RightCoordinateRectangleLayer4);
4995 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW45.Value = %d", curbeData->DW45.Value);
4996 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer5 = 0x%d, RightCoordinateRectangleLayer5 = 0x%d",
4997 curbeData->DW45.BottomCoordinateRectangleLayer5,
4998 curbeData->DW45.RightCoordinateRectangleLayer5);
4999 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW46.Value = %d", curbeData->DW46.Value);
5000 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer6 = 0x%d, RightCoordinateRectangleLayer6 = 0x%d",
5001 curbeData->DW46.BottomCoordinateRectangleLayer6,
5002 curbeData->DW46.RightCoordinateRectangleLayer6);
5003 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW47.Value = %d", curbeData->DW47.Value);
5004 VP_RENDER_VERBOSEMESSAGE("CurbeData: BottomCoordinateRectangleLayer7 = 0x%d, RightCoordinateRectangleLayer7 = 0x%d",
5005 curbeData->DW47.BottomCoordinateRectangleLayer7,
5006 curbeData->DW47.RightCoordinateRectangleLayer7);
5007 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW48.Value = %d", curbeData->DW48.Value);
5008 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer0 = %d, CCMExtensionEnablingFlagLayer0 = %d, ChannelSwapEnablingFlagLayer0 = %d, ChromaSittingLocationLayer0 = %d, Enabling3DLUTFlagLayer0 = %d, EOTF1DLUTEnablingFlagLayer0 = %d, FormatDescriptorLayer0 = %d, IEFBypassEnablingFlagLayer0 = %d, OETF1DLUTEnablingFlagLayer0 = %d, PostCSCEnablingFlagLayer0 = %d, PriorCSCEnablingFlagLayer0 = %d, RotationAngleMirrorDirectionLayer0 = %d, SamplerIndexFirstPlaneLayer0 = %d, SamplerIndexSecondThirdPlaneLayer0 = %d, ToneMappingEnablingFlagLayer0 = %d",
5009 curbeData->DW48.CCMEnablingFlagLayer0,
5010 curbeData->DW48.CCMExtensionEnablingFlagLayer0,
5011 curbeData->DW48.ChannelSwapEnablingFlagLayer0,
5012 curbeData->DW48.ChromaSittingLocationLayer0,
5013 curbeData->DW48.Enabling3DLUTFlagLayer0,
5014 curbeData->DW48.EOTF1DLUTEnablingFlagLayer0,
5015 curbeData->DW48.FormatDescriptorLayer0,
5016 curbeData->DW48.IEFBypassEnablingFlagLayer0,
5017 curbeData->DW48.OETF1DLUTEnablingFlagLayer0,
5018 curbeData->DW48.PostCSCEnablingFlagLayer0,
5019 curbeData->DW48.PriorCSCEnablingFlagLayer0,
5020 curbeData->DW48.RotationAngleMirrorDirectionLayer0,
5021 curbeData->DW48.SamplerIndexFirstPlaneLayer0,
5022 curbeData->DW48.SamplerIndexSecondThirdPlaneLayer0,
5023 curbeData->DW48.ToneMappingEnablingFlagLayer0);
5024 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW49.Value = %d", curbeData->DW49.Value);
5025 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer1 = %d, CCMExtensionEnablingFlagLayer1 = %d, ChannelSwapEnablingFlagLayer1 = %d, ChromaSittingLocationLayer1 = %d, Enabling3DLUTFlagLayer1 = %d, EOTF1DLUTEnablingFlagLayer1 = %d, FormatDescriptorLayer1 = %d, IEFBypassEnablingFlagLayer1 = %d, OETF1DLUTEnablingFlagLayer0 = %d, PostCSCEnablingFlagLayer1 = %d, PriorCSCEnablingFlagLayer1 = %d, RotationAngleMirrorDirectionLayer1 = %d, SamplerIndexFirstPlaneLayer0 = %d, SamplerIndexSecondThirdPlaneLayer1 = %d, ToneMappingEnablingFlagLayer1 = %d",
5026 curbeData->DW49.CCMEnablingFlagLayer1,
5027 curbeData->DW49.CCMExtensionEnablingFlagLayer1,
5028 curbeData->DW49.ChannelSwapEnablingFlagLayer1,
5029 curbeData->DW49.ChromaSittingLocationLayer1,
5030 curbeData->DW49.Enabling3DLUTFlagLayer1,
5031 curbeData->DW49.EOTF1DLUTEnablingFlagLayer1,
5032 curbeData->DW49.FormatDescriptorLayer1,
5033 curbeData->DW49.IEFBypassEnablingFlagLayer1,
5034 curbeData->DW49.OETF1DLUTEnablingFlagLayer1,
5035 curbeData->DW49.PostCSCEnablingFlagLayer1,
5036 curbeData->DW49.PriorCSCEnablingFlagLayer1,
5037 curbeData->DW49.RotationAngleMirrorDirectionLayer1,
5038 curbeData->DW49.SamplerIndexFirstPlaneLayer1,
5039 curbeData->DW49.SamplerIndexSecondThirdPlaneLayer1,
5040 curbeData->DW49.ToneMappingEnablingFlagLayer1);
5041 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW50.Value = %d", curbeData->DW50.Value);
5042 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer2 = %d, CCMExtensionEnablingFlagLayer2 = %d, ChannelSwapEnablingFlagLayer2 = %d, ChromaSittingLocationLayer2 = %d, Enabling3DLUTFlagLayer2 = %d, EOTF1DLUTEnablingFlagLayer2 = %d, FormatDescriptorLayer2 = %d, IEFBypassEnablingFlagLayer2 = %d, OETF1DLUTEnablingFlagLayer2 = %d, PostCSCEnablingFlagLayer2 = %d, PriorCSCEnablingFlagLayer2 = %d, RotationAngleMirrorDirectionLayer2 = %d, SamplerIndexFirstPlaneLayer2 = %d, SamplerIndexSecondThirdPlaneLayer2 = %d, ToneMappingEnablingFlagLayer2 = %d",
5043 curbeData->DW50.CCMEnablingFlagLayer2,
5044 curbeData->DW50.CCMExtensionEnablingFlagLayer2,
5045 curbeData->DW50.ChannelSwapEnablingFlagLayer2,
5046 curbeData->DW50.ChromaSittingLocationLayer2,
5047 curbeData->DW50.Enabling3DLUTFlagLayer2,
5048 curbeData->DW50.EOTF1DLUTEnablingFlagLayer2,
5049 curbeData->DW50.FormatDescriptorLayer2,
5050 curbeData->DW50.IEFBypassEnablingFlagLayer2,
5051 curbeData->DW50.OETF1DLUTEnablingFlagLayer2,
5052 curbeData->DW50.PostCSCEnablingFlagLayer2,
5053 curbeData->DW50.PriorCSCEnablingFlagLayer2,
5054 curbeData->DW50.RotationAngleMirrorDirectionLayer2,
5055 curbeData->DW50.SamplerIndexFirstPlaneLayer2,
5056 curbeData->DW50.SamplerIndexSecondThirdPlaneLayer2,
5057 curbeData->DW50.ToneMappingEnablingFlagLayer2);
5058 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW51.Value = %d", curbeData->DW51.Value);
5059 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer3 = %d, CCMExtensionEnablingFlagLayer3 = %d, ChannelSwapEnablingFlagLayer3 = %d, ChromaSittingLocationLayer3 = %d, Enabling3DLUTFlagLayer3 = %d, EOTF1DLUTEnablingFlagLayer3 = %d, FormatDescriptorLayer3 = %d, IEFBypassEnablingFlagLayer3 = %d, OETF1DLUTEnablingFlagLayer3 = %d, PostCSCEnablingFlagLayer3 = %d, PriorCSCEnablingFlagLayer3 = %d, RotationAngleMirrorDirectionLayer3 = %d, SamplerIndexFirstPlaneLayer3 = %d, SamplerIndexSecondThirdPlaneLayer3 = %d, ToneMappingEnablingFlagLayer3 = %d",
5060 curbeData->DW51.CCMEnablingFlagLayer3,
5061 curbeData->DW51.CCMExtensionEnablingFlagLayer3,
5062 curbeData->DW51.ChannelSwapEnablingFlagLayer3,
5063 curbeData->DW51.ChromaSittingLocationLayer3,
5064 curbeData->DW51.Enabling3DLUTFlagLayer3,
5065 curbeData->DW51.EOTF1DLUTEnablingFlagLayer3,
5066 curbeData->DW51.FormatDescriptorLayer3,
5067 curbeData->DW51.IEFBypassEnablingFlagLayer3,
5068 curbeData->DW51.OETF1DLUTEnablingFlagLayer3,
5069 curbeData->DW51.PostCSCEnablingFlagLayer3,
5070 curbeData->DW51.PriorCSCEnablingFlagLayer3,
5071 curbeData->DW51.RotationAngleMirrorDirectionLayer3,
5072 curbeData->DW51.SamplerIndexFirstPlaneLayer3,
5073 curbeData->DW51.SamplerIndexSecondThirdPlaneLayer3,
5074 curbeData->DW51.ToneMappingEnablingFlagLayer3);
5075 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW52.Value = %d", curbeData->DW52.Value);
5076 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer4 = %d, CCMExtensionEnablingFlagLayer4 = %d, ChannelSwapEnablingFlagLayer4 = %d, ChromaSittingLocationLayer4 = %d, Enabling3DLUTFlagLayer4 = %d, EOTF1DLUTEnablingFlagLayer4 = %d, FormatDescriptorLayer4 = %d, IEFBypassEnablingFlagLayer4 = %d, OETF1DLUTEnablingFlagLayer4 = %d, PostCSCEnablingFlagLayer4 = %d, PriorCSCEnablingFlagLayer4 = %d, RotationAngleMirrorDirectionLayer4 = %d, SamplerIndexFirstPlaneLayer4 = %d, SamplerIndexSecondThirdPlaneLayer4 = %d, ToneMappingEnablingFlagLayer4 = %d",
5077 curbeData->DW52.CCMEnablingFlagLayer4,
5078 curbeData->DW52.CCMExtensionEnablingFlagLayer4,
5079 curbeData->DW52.ChannelSwapEnablingFlagLayer4,
5080 curbeData->DW52.ChromaSittingLocationLayer4,
5081 curbeData->DW52.Enabling3DLUTFlagLayer4,
5082 curbeData->DW52.EOTF1DLUTEnablingFlagLayer4,
5083 curbeData->DW52.FormatDescriptorLayer4,
5084 curbeData->DW52.IEFBypassEnablingFlagLayer4,
5085 curbeData->DW52.OETF1DLUTEnablingFlagLayer4,
5086 curbeData->DW52.PostCSCEnablingFlagLayer4,
5087 curbeData->DW52.PriorCSCEnablingFlagLayer4,
5088 curbeData->DW52.RotationAngleMirrorDirectionLayer4,
5089 curbeData->DW52.SamplerIndexFirstPlaneLayer4,
5090 curbeData->DW52.SamplerIndexSecondThirdPlaneLayer4,
5091 curbeData->DW52.ToneMappingEnablingFlagLayer4);
5092 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW53.Value = %d", curbeData->DW53.Value);
5093 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer5 = %d, CCMExtensionEnablingFlagLayer5 = %d, ChannelSwapEnablingFlagLayer5 = %d, ChromaSittingLocationLayer5 = %d, Enabling3DLUTFlagLayer5 = %d, EOTF1DLUTEnablingFlagLayer5 = %d, FormatDescriptorLayer5 = %d, IEFBypassEnablingFlagLayer5 = %d, OETF1DLUTEnablingFlagLayer5 = %d, PostCSCEnablingFlagLayer5 = %d, PriorCSCEnablingFlagLayer5 = %d, RotationAngleMirrorDirectionLayer5 = %d, SamplerIndexFirstPlaneLayer5 = %d, SamplerIndexSecondThirdPlaneLayer5 = %d, ToneMappingEnablingFlagLayer5 = %d",
5094 curbeData->DW53.CCMEnablingFlagLayer5,
5095 curbeData->DW53.CCMExtensionEnablingFlagLayer5,
5096 curbeData->DW53.ChannelSwapEnablingFlagLayer5,
5097 curbeData->DW53.ChromaSittingLocationLayer5,
5098 curbeData->DW53.Enabling3DLUTFlagLayer5,
5099 curbeData->DW53.EOTF1DLUTEnablingFlagLayer5,
5100 curbeData->DW53.FormatDescriptorLayer5,
5101 curbeData->DW53.IEFBypassEnablingFlagLayer5,
5102 curbeData->DW53.OETF1DLUTEnablingFlagLayer5,
5103 curbeData->DW53.PostCSCEnablingFlagLayer5,
5104 curbeData->DW53.PriorCSCEnablingFlagLayer5,
5105 curbeData->DW53.RotationAngleMirrorDirectionLayer5,
5106 curbeData->DW53.SamplerIndexFirstPlaneLayer5,
5107 curbeData->DW53.SamplerIndexSecondThirdPlaneLayer5,
5108 curbeData->DW53.ToneMappingEnablingFlagLayer5);
5109 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW54.Value = %d", curbeData->DW54.Value);
5110 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer6 = %d, CCMExtensionEnablingFlagLayer6 = %d, ChannelSwapEnablingFlagLayer6 = %d, ChromaSittingLocationLayer6 = %d, Enabling3DLUTFlagLayer6 = %d, EOTF1DLUTEnablingFlagLayer6 = %d, FormatDescriptorLayer6 = %d, IEFBypassEnablingFlagLayer6 = %d, OETF1DLUTEnablingFlagLayer6 = %d, PostCSCEnablingFlagLayer6 = %d, PriorCSCEnablingFlagLayer6 = %d, RotationAngleMirrorDirectionLayer6 = %d, SamplerIndexFirstPlaneLayer6 = %d, SamplerIndexSecondThirdPlaneLayer6 = %d, ToneMappingEnablingFlagLayer6 = %d",
5111 curbeData->DW54.CCMEnablingFlagLayer6,
5112 curbeData->DW54.CCMExtensionEnablingFlagLayer6,
5113 curbeData->DW54.ChannelSwapEnablingFlagLayer6,
5114 curbeData->DW54.ChromaSittingLocationLayer6,
5115 curbeData->DW54.Enabling3DLUTFlagLayer6,
5116 curbeData->DW54.EOTF1DLUTEnablingFlagLayer6,
5117 curbeData->DW54.FormatDescriptorLayer6,
5118 curbeData->DW54.IEFBypassEnablingFlagLayer6,
5119 curbeData->DW54.OETF1DLUTEnablingFlagLayer6,
5120 curbeData->DW54.PostCSCEnablingFlagLayer6,
5121 curbeData->DW54.PriorCSCEnablingFlagLayer6,
5122 curbeData->DW54.RotationAngleMirrorDirectionLayer6,
5123 curbeData->DW54.SamplerIndexFirstPlaneLayer6,
5124 curbeData->DW54.SamplerIndexSecondThirdPlaneLayer6,
5125 curbeData->DW54.ToneMappingEnablingFlagLayer6);
5126 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW55.Value = %x", curbeData->DW55.Value);
5127 VP_RENDER_VERBOSEMESSAGE("CurbeData: CCMEnablingFlagLayer7 = %d, CCMExtensionEnablingFlagLayer7 = %d, ChannelSwapEnablingFlagLayer7 = %d, ChromaSittingLocationLayer7 = %d, Enabling3DLUTFlagLayer7 = %d, EOTF1DLUTEnablingFlagLayer7 = %d, FormatDescriptorLayer7 = %d, IEFBypassEnablingFlagLayer7 = %d, OETF1DLUTEnablingFlagLayer7 = %d, PostCSCEnablingFlagLayer7 = %d, PriorCSCEnablingFlagLayer7 = %d, RotationAngleMirrorDirectionLayer7 = %d, SamplerIndexFirstPlaneLayer7 = %d, SamplerIndexSecondThirdPlaneLayer7 = %d, ToneMappingEnablingFlagLayer7 = %d",
5128 curbeData->DW55.CCMEnablingFlagLayer7,
5129 curbeData->DW55.CCMExtensionEnablingFlagLayer7,
5130 curbeData->DW55.ChannelSwapEnablingFlagLayer7,
5131 curbeData->DW55.ChromaSittingLocationLayer7,
5132 curbeData->DW55.Enabling3DLUTFlagLayer7,
5133 curbeData->DW55.EOTF1DLUTEnablingFlagLayer7,
5134 curbeData->DW55.FormatDescriptorLayer7,
5135 curbeData->DW55.IEFBypassEnablingFlagLayer7,
5136 curbeData->DW55.OETF1DLUTEnablingFlagLayer7,
5137 curbeData->DW55.PostCSCEnablingFlagLayer7,
5138 curbeData->DW55.PriorCSCEnablingFlagLayer7,
5139 curbeData->DW55.RotationAngleMirrorDirectionLayer7,
5140 curbeData->DW55.SamplerIndexFirstPlaneLayer7,
5141 curbeData->DW55.SamplerIndexSecondThirdPlaneLayer7,
5142 curbeData->DW55.ToneMappingEnablingFlagLayer7);
5143 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW56.Value = %d", curbeData->DW56.Value);
5144 VP_RENDER_VERBOSEMESSAGE("CurbeData: ConstantBlendingAlphaFillColorLayer0 = %d, ConstantBlendingAlphaFillColorLayer1 = %d, ConstantBlendingAlphaFillColorLayer2 = %d, ConstantBlendingAlphaFillColorLayer3 = %d",
5145 curbeData->DW56.ConstantBlendingAlphaFillColorLayer0,
5146 curbeData->DW56.ConstantBlendingAlphaFillColorLayer1,
5147 curbeData->DW56.ConstantBlendingAlphaFillColorLayer2,
5148 curbeData->DW56.ConstantBlendingAlphaFillColorLayer3);
5149 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW57.Value = %d", curbeData->DW57.Value);
5150 VP_RENDER_VERBOSEMESSAGE("CurbeData: ConstantBlendingAlphaFillColorLayer4 = %d, ConstantBlendingAlphaFillColorLayer5 = %d, ConstantBlendingAlphaFillColorLayer6 = %d, ConstantBlendingAlphaFillColorLayer7 = %d",
5151 curbeData->DW57.ConstantBlendingAlphaFillColorLayer4,
5152 curbeData->DW57.ConstantBlendingAlphaFillColorLayer5,
5153 curbeData->DW57.ConstantBlendingAlphaFillColorLayer6,
5154 curbeData->DW57.ConstantBlendingAlphaFillColorLayer7);
5155 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW58.Value = %d", curbeData->DW58.Value);
5156 VP_RENDER_VERBOSEMESSAGE("CurbeData: TwoLayerOperationLayer0 = %d, TwoLayerOperationLayer1 = %d, TwoLayerOperationLayer2 = %d, TwoLayerOperationLayer3 = %d",
5157 curbeData->DW58.TwoLayerOperationLayer0,
5158 curbeData->DW58.TwoLayerOperationLayer1,
5159 curbeData->DW58.TwoLayerOperationLayer2,
5160 curbeData->DW58.TwoLayerOperationLayer3);
5161 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW59.Value = %d", curbeData->DW59.Value);
5162 VP_RENDER_VERBOSEMESSAGE("CurbeData: TwoLayerOperationLayer4 = %d, TwoLayerOperationLayer5 = %d, TwoLayerOperationLayer6 = %d, TwoLayerOperationLayer7 = %d",
5163 curbeData->DW59.TwoLayerOperationLayer4,
5164 curbeData->DW59.TwoLayerOperationLayer5,
5165 curbeData->DW59.TwoLayerOperationLayer6,
5166 curbeData->DW59.TwoLayerOperationLayer7);
5167 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW60.Value = %d", curbeData->DW60.Value);
5168 VP_RENDER_VERBOSEMESSAGE("CurbeData: FixedPointFillColorGYChannel = %d, FixedPointFillColorRVChannel = %d",
5169 curbeData->DW60.FixedPointFillColorGYChannel,
5170 curbeData->DW60.FixedPointFillColorRVChannel);
5171 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW61.Value = %x", curbeData->DW61.Value);
5172 VP_RENDER_VERBOSEMESSAGE("CurbeData: FixedPointFillColorAlphaChannel = %d, FixedPointFillColorBUChannel = %d",
5173 curbeData->DW61.FixedPointFillColorAlphaChannel,
5174 curbeData->DW61.FixedPointFillColorBUChannel);
5175 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW62.Value = %d", curbeData->DW62.Value);
5176 VP_RENDER_VERBOSEMESSAGE("CurbeData: DestinationHeight = %d, DestinationWidth = %d",
5177 curbeData->DW62.DestinationHeight,
5178 curbeData->DW62.DestinationWidth);
5179 VP_RENDER_VERBOSEMESSAGE("CurbeData: DW63.Value = %d", curbeData->DW63.Value);
5180 VP_RENDER_VERBOSEMESSAGE("CurbeData: ChannelSwapEnablingFlagDestination = %d, ChromaSittingLocationDestination = %d, DitherRoundEnablingFlagDestinationSurface = %d, DstCSCEnablingFlagDestination = %d, FormatDescriptorDestination = %d, Reserved = %d, TotalNumberInputLayers = %d",
5181 curbeData->DW63.ChannelSwapEnablingFlagDestination,
5182 curbeData->DW63.ChromaSittingLocationDestination,
5183 curbeData->DW63.DitherRoundEnablingFlagDestinationSurface,
5184 curbeData->DW63.DstCSCEnablingFlagDestination,
5185 curbeData->DW63.FormatDescriptorDestination,
5186 curbeData->DW63.Reserved,
5187 curbeData->DW63.TotalNumberInputLayers);
5188 #endif
5189 }
5190
5191 void VpRenderHdrKernel::PrintCurbeDataUnified(PMEDIA_WALKER_HDR_STATIC_DATA curbeData)
5192 {
5193 if (curbeData == nullptr)
5194 {
5195 VP_RENDER_ASSERTMESSAGE("The curbeData pointer is null");
5196 return;
5197 }
5198
5199 // Use arrays of pointers to access per-layer DW fields uniformly
5200 const float *horizOrigin[8] = {
5201 &curbeData->DW0.HorizontalFrameOriginLayer0,
5202 &curbeData->DW1.HorizontalFrameOriginLayer1,
5203 &curbeData->DW2.HorizontalFrameOriginLayer2,
5204 &curbeData->DW3.HorizontalFrameOriginLayer3,
5205 &curbeData->DW4.HorizontalFrameOriginLayer4,
5206 &curbeData->DW5.HorizontalFrameOriginLayer5,
5207 &curbeData->DW6.HorizontalFrameOriginLayer6,
5208 &curbeData->DW7.HorizontalFrameOriginLayer7};
5209 const float *vertOrigin[8] = {
5210 &curbeData->DW8.VerticalFrameOriginLayer0,
5211 &curbeData->DW9.VerticalFrameOriginLayer1,
5212 &curbeData->DW10.VerticalFrameOriginLayer2,
5213 &curbeData->DW11.VerticalFrameOriginLayer3,
5214 &curbeData->DW12.VerticalFrameOriginLayer4,
5215 &curbeData->DW13.VerticalFrameOriginLayer5,
5216 &curbeData->DW14.VerticalFrameOriginLayer6,
5217 &curbeData->DW15.VerticalFrameOriginLayer7};
5218 const float *horizStep[8] = {
5219 &curbeData->DW16.HorizontalScalingStepRatioLayer0,
5220 &curbeData->DW17.HorizontalScalingStepRatioLayer1,
5221 &curbeData->DW18.HorizontalScalingStepRatioLayer2,
5222 &curbeData->DW19.HorizontalScalingStepRatioLayer3,
5223 &curbeData->DW20.HorizontalScalingStepRatioLayer4,
5224 &curbeData->DW21.HorizontalScalingStepRatioLayer5,
5225 &curbeData->DW22.HorizontalScalingStepRatioLayer6,
5226 &curbeData->DW23.HorizontalScalingStepRatioLayer7};
5227 const float *vertStep[8] = {
5228 &curbeData->DW24.VerticalScalingStepRatioLayer0,
5229 &curbeData->DW25.VerticalScalingStepRatioLayer1,
5230 &curbeData->DW26.VerticalScalingStepRatioLayer2,
5231 &curbeData->DW27.VerticalScalingStepRatioLayer3,
5232 &curbeData->DW28.VerticalScalingStepRatioLayer4,
5233 &curbeData->DW29.VerticalScalingStepRatioLayer5,
5234 &curbeData->DW30.VerticalScalingStepRatioLayer6,
5235 &curbeData->DW31.VerticalScalingStepRatioLayer7};
5236
5237 // Access DW32-DW47 as raw uint32_t array for coordinate extraction
5238 const uint32_t *dwArray = reinterpret_cast<const uint32_t *>(curbeData);
5239
5240 for (int i = 0; i < 8; i++)
5241 {
5242 uint32_t hexVal = 0;
5243 MOS_SecureMemcpy(&hexVal, sizeof(uint32_t), horizOrigin[i], sizeof(uint32_t));
5244 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] HorizontalFrameOrigin[%d] = %f (0x%08x)", i, *horizOrigin[i], hexVal);
5245 MOS_SecureMemcpy(&hexVal, sizeof(uint32_t), vertOrigin[i], sizeof(uint32_t));
5246 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] VerticalFrameOrigin[%d] = %f (0x%08x)", i, *vertOrigin[i], hexVal);
5247 MOS_SecureMemcpy(&hexVal, sizeof(uint32_t), horizStep[i], sizeof(uint32_t));
5248 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] HorizontalScalingStepRatio[%d] = %f (0x%08x)", i, *horizStep[i], hexVal);
5249 MOS_SecureMemcpy(&hexVal, sizeof(uint32_t), vertStep[i], sizeof(uint32_t));
5250 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] VerticalScalingStepRatio[%d] = %f (0x%08x)", i, *vertStep[i], hexVal);
5251
5252 // DW32+i: left(0:15), top(16:31)
5253 uint32_t topLeftDw = dwArray[32 + i];
5254 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] LeftCoordinateRectangle[%d] = %d", i, topLeftDw & 0xFFFF);
5255 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] TopCoordinateRectangle[%d] = %d", i, (topLeftDw >> 16) & 0xFFFF);
5256 // DW40+i: right(0:15), bottom(16:31)
5257 uint32_t bottomRightDw = dwArray[40 + i];
5258 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] RightCoordinateRectangle[%d] = %d", i, bottomRightDw & 0xFFFF);
5259 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] BottomCoordinateRectangle[%d] = %d", i, (bottomRightDw >> 16) & 0xFFFF);
5260
5261 // DW48+i: layerInfo bitfields
5262 uint32_t layerDw = dwArray[48 + i];
5263 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FormatDescriptor[%d] = %d", i, layerDw & 0xFF);
5264 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ChromaSittingLocation[%d] = %d", i, (layerDw >> 8) & 0x7);
5265 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ChannelSwapEnablingFlag[%d] = %d", i, (layerDw >> 11) & 0x1);
5266 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] IEFBypassEnablingFlag[%d] = %d", i, (layerDw >> 12) & 0x1);
5267 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] RotationAngleMirrorDirection[%d] = %d", i, (layerDw >> 13) & 0x7);
5268 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] SamplerIndexFirstPlane[%d] = %d", i, (layerDw >> 16) & 0xF);
5269 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] SamplerIndexSecondThirdPlane[%d] = %d", i, (layerDw >> 20) & 0xF);
5270 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] CCMExtensionEnablingFlag[%d] = %d", i, (layerDw >> 24) & 0x1);
5271 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ToneMappingEnablingFlag[%d] = %d", i, (layerDw >> 25) & 0x1);
5272 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] PriorCSCEnablingFlag[%d] = %d", i, (layerDw >> 26) & 0x1);
5273 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] EOTF1DLUTEnablingFlag[%d] = %d", i, (layerDw >> 27) & 0x1);
5274 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] CCMEnablingFlag[%d] = %d", i, (layerDw >> 28) & 0x1);
5275 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] OETF1DLUTEnablingFlag[%d] = %d", i, (layerDw >> 29) & 0x1);
5276 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] PostCSCEnablingFlag[%d] = %d", i, (layerDw >> 30) & 0x1);
5277 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] Enabling3DLUTFlag[%d] = %d", i, (layerDw >> 31) & 0x1);
5278
5279 // DW56-DW57: constantAlpha (8 bits per layer, packed 4 per DW)
5280 uint32_t alphaDw = dwArray[56 + i / 4];
5281 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ConstantBlendingAlpha[%d] = %d", i, (alphaDw >> ((i % 4) * 8)) & 0xFF);
5282
5283 // DW58-DW59: twoLayerOperation (8 bits per layer, packed 4 per DW)
5284 uint32_t opDw = dwArray[58 + i / 4];
5285 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] TwoLayerOperation[%d] = %d", i, (opDw >> ((i % 4) * 8)) & 0xFF);
5286 }
5287
5288 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FillColorRV = %d", curbeData->DW60.FixedPointFillColorRVChannel);
5289 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FillColorGY = %d", curbeData->DW60.FixedPointFillColorGYChannel);
5290 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FillColorBU = %d", curbeData->DW61.FixedPointFillColorBUChannel);
5291 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FillColorAlpha = %d", curbeData->DW61.FixedPointFillColorAlphaChannel);
5292 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] DestinationWidth = %d", curbeData->DW62.DestinationWidth);
5293 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] DestinationHeight = %d", curbeData->DW62.DestinationHeight);
5294 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] TotalNumberInputLayers = %d", curbeData->DW63.TotalNumberInputLayers);
5295 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] FormatDescriptorDst = %d", curbeData->DW63.FormatDescriptorDestination);
5296 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ChromaSittingLocationDst = %d", curbeData->DW63.ChromaSittingLocationDestination);
5297 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] ChannelSwapEnablingFlagDst = %d", curbeData->DW63.ChannelSwapEnablingFlagDestination);
5298 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] DstCSCEnablingFlag = %d", curbeData->DW63.DstCSCEnablingFlagDestination);
5299 VP_RENDER_VERBOSEMESSAGE("[HDR Curbe] DitherRoundEnablingFlag = %d", curbeData->DW63.DitherRoundEnablingFlagDestinationSurface);
5300 }