1 /*
2 * Copyright (c) 2010-2020, 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 vphal_render_hdr_g9.cpp
24 //! \brief Rendering definitions for Unified VP HAL HDR processing
25 //!
26
27 #include "vphal_render_hdr_base.h"
28 #include "vphal_render_hdr_g9_base.h"
29 #include "vphal_render_composite.h"
30 #include "renderhal_platform_interface.h"
31
32 #include "vphal_renderer.h"
33 #include "vphal_debug.h"
34 #include <fstream>
35 #include <string>
36
37 #include "hal_oca_interface.h"
38 #include "vphal_render_ief.h"
39
40 enum HDR_TMMODE {
41 PREPROCESS_TM_S2H,
42 PREPROCESS_TM_H2S,
43 PREPROCESS_TM_H2S_AUTO,
44 PREPROCESS_TM_H2H,
45 PREPROCESS_TM_MAX
46 };
47
48 MEDIA_WALKER_HDR_STATIC_DATA_G9 g_cInit_MEDIA_STATIC_HDR_g9 =
49 {
50 // DWORD 0
51 {
52 { 0.0 }
53 },
54
55 // DWORD 1
56 {
57 { 0.0 }
58 },
59
60 // DWORD 2
61 {
62 { 0.0 }
63 },
64
65 // DWORD 3
66 {
67 { 0.0 }
68 },
69
70 // DWORD 4
71 {
72 { 0.0 }
73 },
74
75 // DWORD 5
76 {
77 { 0.0 }
78 },
79
80 // DWORD 6
81 {
82 { 0.0 }
83 },
84
85 // DWORD 7
86 {
87 { 0.0 }
88 },
89
90 // DWORD 8
91 {
92 { 0.0 }
93 },
94
95 // DWORD 9
96 {
97 { 0.0 }
98 },
99
100 // DWORD 10
101 {
102 { 0.0 }
103 },
104
105 // DWORD 11
106 {
107 { 0.0 }
108 },
109
110 // DWORD 12
111 {
112 { 0.0 }
113 },
114
115 // DWORD 13
116 {
117 { 0.0 }
118 },
119
120 // DWORD 14
121 {
122 { 0.0 }
123 },
124
125 // DWORD 15
126 {
127 { 0.0 }
128 },
129
130 // DWORD 16
131 {
132 { 0.0 }
133 },
134
135 // DWORD 17
136 {
137 { 0.0 }
138 },
139
140 // DWORD 18
141 {
142 { 0.0 }
143 },
144
145 // DWORD 19
146 {
147 { 0.0 }
148 },
149
150 // DWORD 20
151 {
152 { 0.0 }
153 },
154
155 // DWORD 21
156 {
157 { 0.0 }
158 },
159
160 // DWORD 22
161 {
162 { 0.0 }
163 },
164
165 // DWORD 23
166 {
167 { 0.0 }
168 },
169
170 // DWORD 24
171 {
172 { 0.0 }
173 },
174
175 // DWORD 25
176 {
177 { 0.0 }
178 },
179
180 // DWORD 26
181 {
182 { 0.0 }
183 },
184
185 // DWORD 27
186 {
187 { 0.0 }
188 },
189
190 // DWORD 28
191 {
192 { 0.0 }
193 },
194
195 // DWORD 29
196 {
197 { 0.0 }
198 },
199
200 // DWORD 30
201 {
202 { 0.0 }
203 },
204
205 // DWORD 31
206 {
207 { 0.0 }
208 },
209
210 // DWORD 32
211 {
212 { 0, 0 }
213 },
214
215 // DWORD 33
216 {
217 { 0, 0 }
218 },
219
220 // DWORD 34
221 {
222 { 0, 0 }
223 },
224
225 // DWORD 35
226 {
227 { 0, 0 }
228 },
229
230 // DWORD 36
231 {
232 { 0, 0 }
233 },
234
235 // DWORD 37
236 {
237 { 0, 0 }
238 },
239
240 // DWORD 38
241 {
242 { 0, 0 }
243 },
244
245 // DWORD 39
246 {
247 { 0, 0 }
248 },
249
250 // DWORD 40
251 {
252 { 0, 0 }
253 },
254
255 // DWORD 41
256 {
257 { 0, 0 }
258 },
259
260 // DWORD 42
261 {
262 { 0, 0 }
263 },
264
265 // DWORD 43
266 {
267 { 0, 0 }
268 },
269
270 // DWORD 44
271 {
272 { 0, 0 }
273 },
274
275 // DWORD 45
276 {
277 { 0, 0 }
278 },
279
280 // DWORD 46
281 {
282 { 0, 0 }
283 },
284
285 // DWORD 47
286 {
287 { 0, 0 }
288 },
289
290 // DWORD 48
291 {
292 {
293 0, // FormatDescriptorLayer0
294 0, // ChromaSittingLocationLayer0
295 0, // ChannelSwapEnablingFlagLayer0
296 0, // IEFBypassEnablingFlagLayer0
297 0, // RotationAngleMirrorDirectionLayer0
298 0, // SamplerIndexFirstPlaneLayer0
299 0, // SamplerIndexSecondThirdPlaneLayer0
300 0, // Reserved
301 0, // PriorCSCEnablingFlagLayer0
302 0, // EOTF1DLUTEnablingFlagLayer0
303 0, // CCMEnablingFlagLayer0
304 0, // OETF1DLUTEnablingFlagLayer0
305 0, // PostCSCEnablingFlagLayer0
306 0 // Enabling3DLUTFlagLayer0
307 }
308 },
309
310 // DWORD 49
311 {
312 {
313 0, // FormatDescriptorLayer1
314 0, // ChromaSittingLocationLayer1
315 0, // ChannelSwapEnablingFlagLayer1
316 0, // IEFBypassEnablingFlagLayer1
317 0, // RotationAngleMirrorDirectionLayer1
318 0, // SamplerIndexFirstPlaneLayer1
319 0, // SamplerIndexSecondThirdPlaneLayer1
320 0, // Reserved
321 0, // PriorCSCEnablingFlagLayer1
322 0, // EOTF1DLUTEnablingFlagLayer1
323 0, // CCMEnablingFlagLayer1
324 0, // OETF1DLUTEnablingFlagLayer1
325 0, // PostCSCEnablingFlagLayer1
326 0 // Enabling3DLUTFlagLayer1
327 }
328 },
329
330 // DWORD 50
331 {
332 {
333 0, // FormatDescriptorLayer2
334 0, // ChromaSittingLocationLayer2
335 0, // ChannelSwapEnablingFlagLayer2
336 0, // IEFBypassEnablingFlagLayer2
337 0, // RotationAngleMirrorDirectionLayer2
338 0, // SamplerIndexFirstPlaneLayer2
339 0, // SamplerIndexSecondThirdPlaneLayer2
340 0, // Reserved
341 0, // PriorCSCEnablingFlagLayer2
342 0, // EOTF1DLUTEnablingFlagLayer2
343 0, // CCMEnablingFlagLayer2
344 0, // OETF1DLUTEnablingFlagLayer2
345 0, // PostCSCEnablingFlagLayer2
346 0 // Enabling3DLUTFlagLayer2
347 }
348 },
349
350 // DWORD 51
351 {
352 {
353 0, // FormatDescriptorLayer3
354 0, // ChromaSittingLocationLayer3
355 0, // ChannelSwapEnablingFlagLayer3
356 0, // IEFBypassEnablingFlagLayer3
357 0, // RotationAngleMirrorDirectionLayer3
358 0, // SamplerIndexFirstPlaneLayer3
359 0, // SamplerIndexSecondThirdPlaneLayer3
360 0, // Reserved
361 0, // PriorCSCEnablingFlagLayer3
362 0, // EOTF1DLUTEnablingFlagLayer3
363 0, // CCMEnablingFlagLayer3
364 0, // OETF1DLUTEnablingFlagLayer3
365 0, // PostCSCEnablingFlagLayer3
366 0 // Enabling3DLUTFlagLayer3
367 }
368 },
369
370 // DWORD 52
371 {
372 {
373 0, // FormatDescriptorLayer4
374 0, // ChromaSittingLocationLayer4
375 0, // ChannelSwapEnablingFlagLayer4
376 0, // IEFBypassEnablingFlagLayer4
377 0, // RotationAngleMirrorDirectionLayer4
378 0, // SamplerIndexFirstPlaneLayer4
379 0, // SamplerIndexSecondThirdPlaneLayer4
380 0, // Reserved
381 0, // PriorCSCEnablingFlagLayer4
382 0, // EOTF1DLUTEnablingFlagLayer4
383 0, // CCMEnablingFlagLayer4
384 0, // OETF1DLUTEnablingFlagLayer4
385 0, // PostCSCEnablingFlagLayer4
386 0 // Enabling3DLUTFlagLayer4
387 }
388 },
389
390 // DWORD 53
391 {
392 {
393 0, // FormatDescriptorLayer5
394 0, // ChromaSittingLocationLayer5
395 0, // ChannelSwapEnablingFlagLayer5
396 0, // IEFBypassEnablingFlagLayer5
397 0, // RotationAngleMirrorDirectionLayer5
398 0, // SamplerIndexFirstPlaneLayer5
399 0, // SamplerIndexSecondThirdPlaneLayer5
400 0, // Reserved
401 0, // PriorCSCEnablingFlagLayer5
402 0, // EOTF1DLUTEnablingFlagLayer5
403 0, // CCMEnablingFlagLayer5
404 0, // OETF1DLUTEnablingFlagLayer5
405 0, // PostCSCEnablingFlagLayer5
406 0 // Enabling3DLUTFlagLayer5
407 }
408 },
409
410 // DWORD 54
411 {
412 {
413 0, // FormatDescriptorLayer6
414 0, // ChromaSittingLocationLayer6
415 0, // ChannelSwapEnablingFlagLayer6
416 0, // IEFBypassEnablingFlagLayer6
417 0, // RotationAngleMirrorDirectionLayer6
418 0, // SamplerIndexFirstPlaneLayer6
419 0, // SamplerIndexSecondThirdPlaneLayer6
420 0, // Reserved
421 0, // PriorCSCEnablingFlagLayer6
422 0, // EOTF1DLUTEnablingFlagLayer6
423 0, // CCMEnablingFlagLayer6
424 0, // OETF1DLUTEnablingFlagLayer6
425 0, // PostCSCEnablingFlagLayer6
426 0 // Enabling3DLUTFlagLayer6
427 }
428 },
429
430 // DWORD 55
431 {
432 {
433 0, // FormatDescriptorLayer7
434 0, // ChromaSittingLocationLayer7
435 0, // ChannelSwapEnablingFlagLayer7
436 0, // IEFBypassEnablingFlagLayer7
437 0, // RotationAngleMirrorDirectionLayer7
438 0, // SamplerIndexFirstPlaneLayer7
439 0, // SamplerIndexSecondThirdPlaneLayer7
440 0, // Reserved
441 0, // PriorCSCEnablingFlagLayer7
442 0, // EOTF1DLUTEnablingFlagLayer7
443 0, // CCMEnablingFlagLayer7
444 0, // OETF1DLUTEnablingFlagLayer7
445 0, // PostCSCEnablingFlagLayer7
446 0 // Enabling3DLUTFlagLayer7
447 }
448 },
449
450 // DWORD 56
451 {
452 { 0, 0, 0, 0 }
453 },
454
455 // DWORD 57
456 {
457 { 0, 0, 0, 0 }
458 },
459
460 // DWORD 58
461 {
462 {
463 0, // TwoLayerOperationLayer0
464 0, // TwoLayerOperationLayer1
465 0, // TwoLayerOperationLayer2
466 0 // TwoLayerOperationLayer3
467 }
468 },
469
470 // DWORD 59
471 {
472 {
473 0, // TwoLayerOperationLayer4
474 0, // TwoLayerOperationLayer5
475 0, // TwoLayerOperationLayer6
476 0 // TwoLayerOperationLayer7
477 }
478 },
479
480 // DWORD 60
481 {
482 { 0, 0 }
483 },
484
485 // DWORD 61
486 {
487 { 0, 0 }
488 },
489
490 // DWORD 62
491 {
492 { 0, 0 }
493 },
494
495 // DWORD 63
496 {
497 { 0, 0, 0, 0, 0, 0, 0 }
498 },
499 };
500
501 const uint32_t g_Hdr_ColorCorrect_OETF_sRGB_FP16_g9[VPHAL_HDR_OETF_1DLUT_POINT_NUMBER] =
502 {
503 0x2ab90000, 0x2f5b2daa, 0x30f7305e, 0x31fb317f, 0x32d5326c, 0x33953338, 0x342133ed, 0x346f3449, 0x3494346f, 0x34db34b8, 0x351d34fc, 0x355b353c, 0x35963579, 0x35ce35b2, 0x360435e9, 0x3637361e,
504 0x36503637, 0x36813669, 0x36b03698, 0x36dd36c6, 0x370936f3, 0x3734371e, 0x375d3749, 0x37853771, 0x37993785, 0x37c037ad, 0x37e637d3, 0x380537f9, 0x3817380e, 0x38293820, 0x383a3832, 0x384b3843,
505 0x3854384b, 0x3864385c, 0x3875386d, 0x3885387d, 0x3894388c, 0x38a4389c, 0x38b338ab, 0x38c238ba, 0x38c938c2, 0x38d838d0, 0x38e638df, 0x38f438ed, 0x390238fb, 0x39103909, 0x391d3917, 0x392b3924,
506 0x3931392b, 0x393e3938, 0x394b3945, 0x39583952, 0x3965395f, 0x3971396b, 0x397e3978, 0x398a3984, 0x3990398a, 0x399c3996, 0x39a839a2, 0x39b439ae, 0x39bf39b9, 0x39cb39c5, 0x39d639d1, 0x39e239dc,
507 0x39e739e2, 0x39f239ed, 0x39fd39f8, 0x3a083a03, 0x3a133a0e, 0x3a1e3a18, 0x3a283a23, 0x3a333a2e, 0x3a383a33, 0x3a433a3d, 0x3a4d3a48, 0x3a573a52, 0x3a613a5c, 0x3a6b3a66, 0x3a753a70, 0x3a7f3a7a,
508 0x3a843a7f, 0x3a8e3a89, 0x3a983a93, 0x3aa13a9c, 0x3aab3aa6, 0x3ab43ab0, 0x3abe3ab9, 0x3ac73ac3, 0x3acc3ac7, 0x3ad53ad0, 0x3ade3ada, 0x3ae73ae3, 0x3af13aec, 0x3afa3af5, 0x3b033afe, 0x3b0b3b07,
509 0x3b103b0b, 0x3b193b14, 0x3b213b1d, 0x3b2a3b26, 0x3b333b2e, 0x3b3b3b37, 0x3b443b40, 0x3b4c3b48, 0x3b513b4c, 0x3b593b55, 0x3b613b5d, 0x3b6a3b66, 0x3b723b6e, 0x3b7a3b76, 0x3b823b7e, 0x3b8b3b87,
510 0x3b8f3b8b, 0x3b973b93, 0x3b9f3b9b, 0x3ba73ba3, 0x3baf3bab, 0x3bb73bb3, 0x3bbe3bba, 0x3bc63bc2, 0x3bca3bc6, 0x3bd23bce, 0x3bda3bd6, 0x3be13bdd, 0x3be93be5, 0x3bf03bed, 0x3bf83bf4, 0x3c003bfc
511 };
512
513 static const uint32_t g_Hdr_ColorCorrect_OETF_BT709_FP16_g9[VPHAL_HDR_OETF_1DLUT_POINT_NUMBER] =
514 {
515 0x24cc0000, 0x2b3328cc, 0x2dfb2ccc, 0x2fff2f09, 0x30db3071, 0x319d313f, 0x324d31f7, 0x32ee329f, 0x333a32ee, 0x33cb3384, 0x34293408, 0x346a344a, 0x34a73489, 0x34e234c5, 0x351a34fe, 0x35503535,
516 0x356a3550, 0x359d3584, 0x35cf35b6, 0x35ff35e7, 0x362d3616, 0x365a3644, 0x36863671, 0x36b1369c, 0x36c636b1, 0x36f036db, 0x37183704, 0x3740372c, 0x37673753, 0x378d377a, 0x37b2379f, 0x37d637c4,
517 0x37e837d6, 0x380637fa, 0x3817380e, 0x38283820, 0x38393831, 0x384a3842, 0x385a3852, 0x386a3862, 0x3872386a, 0x3882387a, 0x3892388a, 0x38a13899, 0x38b038a9, 0x38bf38b8, 0x38ce38c6, 0x38dc38d5,
518 0x38e438dc, 0x38f238eb, 0x390038f9, 0x390e3907, 0x391c3915, 0x39293923, 0x39373930, 0x3944393e, 0x394b3944, 0x39583952, 0x3965395f, 0x3972396c, 0x397f3978, 0x398b3985, 0x39983992, 0x39a4399e,
519 0x39ab39a4, 0x39b739b1, 0x39c339bd, 0x39cf39c9, 0x39db39d5, 0x39e739e1, 0x39f239ed, 0x39fe39f8, 0x3a0439fe, 0x3a0f3a0a, 0x3a1b3a15, 0x3a263a20, 0x3a313a2c, 0x3a3c3a37, 0x3a473a42, 0x3a523a4d,
520 0x3a583a52, 0x3a633a5d, 0x3a6e3a68, 0x3a783a73, 0x3a833a7e, 0x3a8d3a88, 0x3a983a93, 0x3aa23a9d, 0x3aa73aa2, 0x3ab23aad, 0x3abc3ab7, 0x3ac63ac1, 0x3ad03acb, 0x3ada3ad5, 0x3ae43adf, 0x3aee3ae9,
521 0x3af33aee, 0x3afd3af8, 0x3b073b02, 0x3b103b0c, 0x3b1a3b15, 0x3b243b1f, 0x3b2d3b28, 0x3b373b32, 0x3b3b3b37, 0x3b453b40, 0x3b4e3b4a, 0x3b583b53, 0x3b613b5c, 0x3b6a3b65, 0x3b733b6f, 0x3b7c3b78,
522 0x3b813b7c, 0x3b8a3b85, 0x3b933b8e, 0x3b9c3b97, 0x3ba53ba0, 0x3bad3ba9, 0x3bb63bb2, 0x3bbf3bbb, 0x3bc33bbf, 0x3bcc3bc8, 0x3bd53bd0, 0x3bdd3bd9, 0x3be63be2, 0x3bef3bea, 0x3bf73bf3, 0x3c003bfb
523 };
524
525 // So far assume max luminance to be 2000 nit, may change in the future.
526 static const uint32_t g_Hdr_ColorCorrect_OETF_SMPTE_ST2084_3Segs_FP16_g9[VPHAL_HDR_OETF_1DLUT_POINT_NUMBER] =
527 {
528 0x2832000c, 0x2ae829c6, 0x2c4a2bd0, 0x2ced2ca0, 0x2d722d33, 0x2de42dad, 0x2e492e18, 0x2ea22e77, 0x2ecc2ea2, 0x2f1a2ef4, 0x2f622f3f, 0x2fa52f84, 0x2fe32fc5, 0x300f3000, 0x302b301d, 0x30453038,
529 0x30523045, 0x306a305e, 0x30813076, 0x3098308d, 0x30ad30a3, 0x30c230b8, 0x31a730cc, 0x32c63247, 0x333132c6, 0x33dd338c, 0x34333413, 0x346d3451, 0x349f3487, 0x34cb34b6, 0x34f234df, 0x35163505,
530 0x35273516, 0x35463537, 0x35633555, 0x357e3571, 0x3598358b, 0x35af35a4, 0x35c635bb, 0x35db35d1, 0x35e535db, 0x35f935ef, 0x360c3603, 0x361e3615, 0x362f3627, 0x36403638, 0x36503648, 0x365f3657,
531 0x3666365f, 0x3675366e, 0x3683367c, 0x3691368a, 0x369e3697, 0x36ab36a4, 0x36b736b1, 0x36c336bd, 0x36c936c3, 0x36d436cf, 0x36e036da, 0x36eb36e5, 0x36f536f0, 0x370036fa, 0x370a3705, 0x3714370f,
532 0x37193714, 0x3722371d, 0x372c3727, 0x379b3730, 0x381c37f1, 0x3856383b, 0x3884386f, 0x38ab3898, 0x38bb38ab, 0x38da38cb, 0x38f538e8, 0x390d3901, 0x39223918, 0x3936392c, 0x3948393f, 0x39593951,
533 0x39613959, 0x39703969, 0x397e3977, 0x398b3985, 0x39983992, 0x39a4399e, 0x39af39aa, 0x39ba39b5, 0x39bf39ba, 0x39c939c4, 0x39d339ce, 0x39dc39d8, 0x39e539e1, 0x39ee39e9, 0x39f639f2, 0x39fe39fa,
534 0x3a0239fe, 0x3a093a06, 0x3a113a0d, 0x3a183a14, 0x3a1f3a1b, 0x3a253a22, 0x3a2c3a28, 0x3a323a2f, 0x3a353a32, 0x3a3b3a38, 0x3a413a3e, 0x3a473a44, 0x3a4c3a49, 0x3a523a4f, 0x3a573a54, 0x3a5c3a59,
535 0x3a5f3a5c, 0x3a643a61, 0x3a693a66, 0x3a6d3a6b, 0x3a723a70, 0x3a773a74, 0x3a7b3a79, 0x3a803a7d, 0x3a823a80, 0x3a863a84, 0x3a8a3a88, 0x3a8e3a8c, 0x3a923a90, 0x3a963a94, 0x3a9a3a98, 0x3a9e3a9c
536 };
537
DumpDataToFile(const std::string & fileName,const void * data,size_t size)538 inline void DumpDataToFile(const std::string &fileName, const void *data, size_t size)
539 {
540 std::ofstream blob(fileName, std::ofstream::out | std::ifstream::binary);
541
542 if (!blob.is_open())
543 {
544 VPHAL_RENDER_ASSERTMESSAGE("Error in opening raw data file: %s\n", fileName.c_str());
545 return;
546 }
547
548 blob.write((const char *)data, size);
549 }
550
Convert_CSC_Coeff_To_Register_Format(double coeff)551 CSC_COEFF_FORMAT Convert_CSC_Coeff_To_Register_Format(double coeff)
552 {
553 CSC_COEFF_FORMAT outVal = { 0 };
554 uint32_t shift_factor = 0;
555
556 if (coeff < 0)
557 {
558 outVal.sign = 1;
559 coeff = -coeff;
560 }
561
562 // range check
563 if (coeff > MAX_CSC_COEFF_VAL_ICL)
564 coeff = MAX_CSC_COEFF_VAL_ICL;
565
566 if (coeff < 0.125) //0.000bbbbbbbbb
567 {
568 outVal.exponent = 3;
569 shift_factor = 12;
570 }
571 else if (coeff >= 0.125 && coeff < 0.25) //0.00bbbbbbbbb
572 {
573 outVal.exponent = 2;
574 shift_factor = 11;
575 }
576 else if (coeff >= 0.25 && coeff < 0.5) //0.0bbbbbbbbb
577 {
578 outVal.exponent = 1;
579 shift_factor = 10;
580 }
581 else if (coeff >= 0.5 && coeff < 1.0) // 0.bbbbbbbbb
582 {
583 outVal.exponent = 0;
584 shift_factor = 9;
585 }
586 else if (coeff >= 1.0 && coeff < 2.0) //b.bbbbbbbb
587 {
588 outVal.exponent = 7;
589 shift_factor = 8;
590 }
591 else if (coeff >= 2.0) // bb.bbbbbbb
592 {
593 outVal.exponent = 6;
594 shift_factor = 7;
595 }
596
597 //Convert float to integer
598 outVal.mantissa = static_cast<uint32_t>(round(coeff * (double)(1 << (int)shift_factor)));
599
600 return outVal;
601 }
602
Convert_CSC_Coeff_Register_Format_To_Double(CSC_COEFF_FORMAT regVal)603 double Convert_CSC_Coeff_Register_Format_To_Double(CSC_COEFF_FORMAT regVal)
604 {
605 double outVal = 0;
606
607 switch (regVal.exponent)
608 {
609 case 0: outVal = (double)regVal.mantissa / 512.0; break;
610 case 1: outVal = (double)regVal.mantissa / 1024.0; break;
611 case 2: outVal = (double)regVal.mantissa / 2048.0; break;
612 case 3: outVal = (double)regVal.mantissa / 4096.0; break;
613 case 6: outVal = (double)regVal.mantissa / 128.0; break;
614 case 7: outVal = (double)regVal.mantissa / 256.0; break;
615 }
616
617 if (regVal.sign)
618 {
619 outVal = -outVal;
620 }
621
622 return outVal;
623 }
624
LimitFP32PrecisionToF3_9(float fp)625 float LimitFP32PrecisionToF3_9(float fp)
626 {
627 double dbInput = static_cast<double>(fp);
628 double dbOutput = Convert_CSC_Coeff_Register_Format_To_Double(Convert_CSC_Coeff_To_Register_Format(dbInput));
629 return static_cast<float>(dbOutput);
630 }
631
LimitFP32ArrayPrecisionToF3_9(float fps[],size_t size)632 void LimitFP32ArrayPrecisionToF3_9(float fps[], size_t size)
633 {
634 for (size_t i = 0; i < size; i++)
635 {
636 fps[i] = LimitFP32PrecisionToF3_9(fps[i]);
637 }
638 }
639
640 //! \brief Get the HDR format descriptor of a format
641 //! \details Get the HDR format descriptor of a format and return.
642 //! \param MOS_FORMAT Format
643 //! [in] MOS_FORMAT of a surface
644 //! \return VPHAL_HDR_FORMAT_DESCRIPTOR_G9
645 //! HDR format descriptor
646 //!
VpHal_HdrGetFormatDescriptor_g9(MOS_FORMAT Format)647 VPHAL_HDR_FORMAT_DESCRIPTOR_G9 VpHal_HdrGetFormatDescriptor_g9 (
648 MOS_FORMAT Format)
649 {
650 VPHAL_HDR_FORMAT_DESCRIPTOR_G9 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW_G9;
651
652 switch (Format)
653 {
654 case Format_R10G10B10A2:
655 case Format_B10G10R10A2:
656 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_R10G10B10A2_UNORM_G9;
657 break;
658
659 case Format_X8R8G8B8:
660 case Format_A8R8G8B8:
661 case Format_A8B8G8R8:
662 case Format_X8B8G8R8:
663 case Format_AYUV:
664 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_R8G8B8A8_UNORM_G9;
665 break;
666
667 case Format_NV12:
668 case Format_NV21:
669 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_NV12_G9;
670 break;
671
672 case Format_YUY2:
673 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_YUY2_G9;
674 break;
675
676 case Format_P010:
677 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_P010_G9;
678 break;
679
680 case Format_P016:
681 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_P016_G9;
682 break;
683
684 case Format_A16R16G16B16F:
685 case Format_A16B16G16R16F:
686 FormatDescriptor = VPHAL_HDR_FORMAT_R16G16B16A16_FLOAT_G9;
687 break;
688
689 default:
690 VPHAL_PUBLIC_ASSERTMESSAGE("Unsupported input format.");
691 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW_G9;
692 break;
693 }
694
695 return FormatDescriptor;
696 }
697 //! \brief Get the HDR Chroma siting
698 //! \details Get the HDR Chroma siting and return.
699 //! \param uint32_t ChromaSiting
700 //! [in] ChromaSiting of a surface
701 //! \return VPHAL_HDR_CHROMA_SITING_G9
702 //! HDR Chroma siting
703 //!
VpHal_HdrGetHdrChromaSiting_g9(uint32_t ChromaSiting)704 VPHAL_HDR_CHROMA_SITING_G9 VpHal_HdrGetHdrChromaSiting_g9 (
705 uint32_t ChromaSiting)
706 {
707 VPHAL_HDR_CHROMA_SITING_G9 HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A_G9;
708
709 switch (ChromaSiting)
710 {
711 case CHROMA_SITING_HORZ_LEFT :
712 HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A_G9;
713 break;
714 default:
715 HdrChromaSiting = VPHAL_HDR_CHROMA_SITTING_A_G9;
716 break;
717 }
718
719 return HdrChromaSiting;
720 }
721
722 //! \brief Get the HDR rotation
723 //! \details Get the HDR rotation and return.
724 //! \param VPHAL_ROTATION Rotation
725 //! [in] Rotation of a surface
726 //! \return VPHAL_HDR_ROTATION_G9
727 //! HDR Chroma siting
728 //!
VpHal_HdrGetHdrRotation_g9(VPHAL_ROTATION Rotation)729 VPHAL_HDR_ROTATION_G9 VpHal_HdrGetHdrRotation_g9 (
730 VPHAL_ROTATION Rotation)
731 {
732 VPHAL_HDR_ROTATION_G9 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0_G9;
733
734 switch (Rotation)
735 {
736 case VPHAL_ROTATION_IDENTITY :
737 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0_G9;
738 break;
739 case VPHAL_ROTATION_90 :
740 HdrRotation = VPHAL_HDR_LAYER_ROTATION_90_G9;
741 break;
742 case VPHAL_ROTATION_180 :
743 HdrRotation = VPHAL_HDR_LAYER_ROTATION_180_G9;
744 break;
745 case VPHAL_ROTATION_270 :
746 HdrRotation = VPHAL_HDR_LAYER_ROTATION_270_G9;
747 break;
748 case VPHAL_MIRROR_HORIZONTAL :
749 HdrRotation = VPHAL_HDR_LAYER_MIRROR_H_G9;
750 break;
751 case VPHAL_MIRROR_VERTICAL :
752 HdrRotation = VPHAL_HDR_LAYER_MIRROR_V_G9;
753 break;
754 case VPHAL_ROTATE_90_MIRROR_VERTICAL :
755 HdrRotation = VPHAL_HDR_LAYER_ROT_90_MIR_V_G9;
756 break;
757 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL :
758 HdrRotation = VPHAL_HDR_LAYER_ROT_90_MIR_H_G9;
759 break;
760 default:
761 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0_G9;
762 break;
763 }
764
765 return HdrRotation;
766 }
767
768 //! \brief Get the HDR Two Layer Option
769 //! \details Get the HDR Two Layer Option and return.
770 //! \param VPHAL_BLEND_TYPE BlendType
771 //! [in] Blending type of a surface
772 //! \return VPHAL_HDR_TWO_LAYER_OPTION_G9
773 //! HDR Two Layer Option
774 //!
VpHal_HdrGetHdrTwoLayerOption_g9(VPHAL_BLEND_TYPE BlendType)775 VPHAL_HDR_TWO_LAYER_OPTION_G9 VpHal_HdrGetHdrTwoLayerOption_g9(
776 VPHAL_BLEND_TYPE BlendType)
777 {
778 VPHAL_HDR_TWO_LAYER_OPTION_G9 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
779
780 switch (BlendType)
781 {
782 case BLEND_NONE:
783 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_COMP_G9;
784 break;
785 case BLEND_SOURCE:
786 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
787 break;
788 case BLEND_PARTIAL:
789 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_PBLEND_G9;
790 break;
791 case BLEND_CONSTANT:
792 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9;
793 break;
794 case BLEND_CONSTANT_SOURCE:
795 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9;
796 break;
797 case BLEND_CONSTANT_PARTIAL:
798 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9;
799 break;
800 default:
801 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
802 break;
803 }
804
805 return HdrTwoLayerOp;
806 }
807
808 //!
809 //! \brief Checks to see if HDR can be enabled for the formats
810 //! \details Checks to see if HDR can be enabled for the formats
811 //! \param PVPHAL_SURFACE pSrcSurface
812 //! [in] Pointer to source surface
813 //! \param bool* pbSupported
814 //! [out] true supported false not supported
815 //! \return MOS_STATUS
816 //! MOS_STATUS_SUCCESS if successful, otherwise failed
817 //!
VpHal_HdrIsInputFormatSupported_g9(PVPHAL_SURFACE pSrcSurface,bool * pbSupported)818 MOS_STATUS VpHal_HdrIsInputFormatSupported_g9(
819 PVPHAL_SURFACE pSrcSurface,
820 bool* pbSupported)
821 {
822 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
823
824 VPHAL_PUBLIC_CHK_NULL(pSrcSurface);
825 VPHAL_PUBLIC_CHK_NULL(pbSupported);
826
827 // HDR supported formats
828 if (pSrcSurface->Format == Format_A8R8G8B8 ||
829 pSrcSurface->Format == Format_X8R8G8B8 ||
830 pSrcSurface->Format == Format_A8B8G8R8 ||
831 pSrcSurface->Format == Format_X8B8G8R8 ||
832 pSrcSurface->Format == Format_R10G10B10A2 ||
833 pSrcSurface->Format == Format_B10G10R10A2 ||
834 pSrcSurface->Format == Format_A16B16G16R16 ||
835 pSrcSurface->Format == Format_A16R16G16B16 ||
836 pSrcSurface->Format == Format_P016 ||
837 pSrcSurface->Format == Format_NV12 ||
838 pSrcSurface->Format == Format_P010 ||
839 pSrcSurface->Format == Format_YUY2 ||
840 pSrcSurface->Format == Format_AYUV)
841 {
842 *pbSupported = true;
843 goto finish;
844 }
845 else
846 {
847 VPHAL_RENDER_ASSERTMESSAGE(
848 "HDR Unsupported Source Format: '0x%08x'\n",
849 pSrcSurface->Format);
850 *pbSupported = false;
851 }
852
853 finish:
854 return eStatus;
855 }
856
857 //!
858 //! \brief Checks to see if HDR can be enabled for the formats
859 //! \details Checks to see if HDR can be enabled for the formats
860 //! \param PVPHAL_SURFACE pTargetSurface
861 //! [in] Pointer to target surface
862 //! \param bool* pbSupported
863 //! [out] true supported false not supported
864 //! \return MOS_STATUS
865 //! MOS_STATUS_SUCCESS if successful, otherwise failed
866 //!
VpHal_HdrIsOutputFormatSupported_g9(PVPHAL_SURFACE pTargetSurface,bool * pbSupported)867 MOS_STATUS VpHal_HdrIsOutputFormatSupported_g9(
868 PVPHAL_SURFACE pTargetSurface,
869 bool* pbSupported)
870 {
871 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
872
873 VPHAL_PUBLIC_CHK_NULL(pTargetSurface);
874 VPHAL_PUBLIC_CHK_NULL(pbSupported);
875
876 // HDR supported formats
877 if (pTargetSurface->Format == Format_A8R8G8B8 ||
878 pTargetSurface->Format == Format_X8R8G8B8 ||
879 pTargetSurface->Format == Format_A8B8G8R8 ||
880 pTargetSurface->Format == Format_X8B8G8R8 ||
881 pTargetSurface->Format == Format_R10G10B10A2 ||
882 pTargetSurface->Format == Format_B10G10R10A2 ||
883 pTargetSurface->Format == Format_A16B16G16R16 ||
884 pTargetSurface->Format == Format_A16R16G16B16 ||
885 pTargetSurface->Format == Format_YUY2 ||
886 pTargetSurface->Format == Format_P016 ||
887 pTargetSurface->Format == Format_NV12 ||
888 pTargetSurface->Format == Format_P010 ||
889 pTargetSurface->Format == Format_P016 ||
890 pTargetSurface->Format == Format_A16R16G16B16F||
891 pTargetSurface->Format == Format_A16B16G16R16F)
892 {
893 *pbSupported = true;
894 goto finish;
895 }
896 else
897 {
898 VPHAL_RENDER_ASSERTMESSAGE(
899 "HDR Unsupported Target Format: '0x%08x'\n",
900 pTargetSurface->Format);
901 *pbSupported = false;
902 }
903
904 finish:
905 return eStatus;
906 }
907
908 //!
909 //! \brief Recalculate Sampler Avs 8x8 Horizontal/Vertical scaling table
910 //! \details Recalculate Sampler Avs 8x8 Horizontal/Vertical scaling table
911 //! \param MOS_FORMAT SrcFormat
912 //! [in] Source Format
913 //! \param float fScale
914 //! [in] Horizontal or Vertical Scale Factor
915 //! \param bool bVertical
916 //! [in] true if Vertical Scaling, else Horizontal Scaling
917 //! \param uint32_t dwChromaSiting
918 //! [in] Chroma Siting
919 //! \param bool bBalancedFilter
920 //! [in] true if Gen9+, balanced filter
921 //! \param bool b8TapAdaptiveEnable
922 //! [in] true if 8Tap Adaptive Enable
923 //! \param PVPHAL_AVS_PARAMS pAvsParams
924 //! [in/out] Pointer to AVS Params
925 //! \return MOS_STATUS
926 //!
VpHal_HdrSamplerAvsCalcScalingTable_g9(MOS_FORMAT SrcFormat,float fScale,bool bVertical,uint32_t dwChromaSiting,bool bBalancedFilter,bool b8TapAdaptiveEnable,PMHW_AVS_PARAMS pAvsParams)927 static MOS_STATUS VpHal_HdrSamplerAvsCalcScalingTable_g9(
928 MOS_FORMAT SrcFormat,
929 float fScale,
930 bool bVertical,
931 uint32_t dwChromaSiting,
932 bool bBalancedFilter,
933 bool b8TapAdaptiveEnable,
934 PMHW_AVS_PARAMS pAvsParams)
935 {
936 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
937 MHW_PLANE Plane = MHW_GENERIC_PLANE;
938 int32_t iUvPhaseOffset = 0;
939 uint32_t dwHwPhrase = 0;
940 uint32_t YCoefTableSize = 0;
941 uint32_t UVCoefTableSize = 0;
942 float fScaleParam = 0.0f;
943 int32_t* piYCoefsParam = nullptr;
944 int32_t* piUVCoefsParam = nullptr;
945 float fHPStrength = 0.0f;
946
947 VPHAL_RENDER_CHK_NULL(pAvsParams);
948 VPHAL_RENDER_CHK_NULL(pAvsParams->piYCoefsY);
949 VPHAL_RENDER_CHK_NULL(pAvsParams->piYCoefsX);
950 VPHAL_RENDER_CHK_NULL(pAvsParams->piUVCoefsY);
951 VPHAL_RENDER_CHK_NULL(pAvsParams->piUVCoefsX);
952
953 if (bBalancedFilter)
954 {
955 YCoefTableSize = POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9;
956 UVCoefTableSize = POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9;
957 dwHwPhrase = NUM_HW_POLYPHASE_TABLES_G9;
958 }
959 else
960 {
961 YCoefTableSize = POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G8;
962 UVCoefTableSize = POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G8;
963 dwHwPhrase = MHW_NUM_HW_POLYPHASE_TABLES;
964 }
965
966 fHPStrength = 0.0F;
967 piYCoefsParam = bVertical ? pAvsParams->piYCoefsY : pAvsParams->piYCoefsX;
968 piUVCoefsParam = bVertical ? pAvsParams->piUVCoefsY : pAvsParams->piUVCoefsX;
969 fScaleParam = bVertical ? pAvsParams->fScaleY : pAvsParams->fScaleX;
970
971 // Recalculate Horizontal or Vertical scaling table
972 if (SrcFormat != pAvsParams->Format || fScale != fScaleParam)
973 {
974 MOS_ZeroMemory(piYCoefsParam, YCoefTableSize);
975 MOS_ZeroMemory(piUVCoefsParam, UVCoefTableSize);
976
977 // 4-tap filtering for RGB format G-channel if 8tap adaptive filter is not enabled.
978 Plane = (IS_RGB32_FORMAT(SrcFormat) && !b8TapAdaptiveEnable) ? MHW_U_PLANE : MHW_Y_PLANE;
979 if (bVertical)
980 {
981 pAvsParams->fScaleY = fScale;
982 }
983 else
984 {
985 pAvsParams->fScaleX = fScale;
986 }
987
988 // For 1x scaling in horizontal direction, use special coefficients for filtering
989 // we don't do this when bForcePolyPhaseCoefs flag is set
990 if (fScale == 1.0F && !pAvsParams->bForcePolyPhaseCoefs)
991 {
992 VPHAL_RENDER_CHK_STATUS(Mhw_SetNearestModeTable(
993 piYCoefsParam,
994 Plane,
995 bBalancedFilter));
996 // If the 8-tap adaptive is enabled for all channel, then UV/RB use the same coefficient as Y/G
997 // So, coefficient for UV/RB channels caculation can be passed
998 if (!b8TapAdaptiveEnable)
999 {
1000 VPHAL_RENDER_CHK_STATUS(Mhw_SetNearestModeTable(
1001 piUVCoefsParam,
1002 MHW_U_PLANE,
1003 bBalancedFilter));
1004 }
1005 }
1006 else
1007 {
1008 // Clamp the Scaling Factor if > 1.0x
1009 fScale = MOS_MIN(1.0F, fScale);
1010
1011 VPHAL_RENDER_CHK_STATUS(Mhw_CalcPolyphaseTablesY(
1012 piYCoefsParam,
1013 fScale,
1014 Plane,
1015 SrcFormat,
1016 fHPStrength,
1017 true,
1018 dwHwPhrase,
1019 0));
1020
1021 // If the 8-tap adaptive is enabled for all channel, then UV/RB use the same coefficient as Y/G
1022 // So, coefficient for UV/RB channels caculation can be passed
1023 if (!b8TapAdaptiveEnable)
1024 {
1025 if (!bBalancedFilter)
1026 {
1027 VPHAL_RENDER_CHK_STATUS(Mhw_CalcPolyphaseTablesY(
1028 piUVCoefsParam,
1029 fScale,
1030 MHW_U_PLANE,
1031 SrcFormat,
1032 fHPStrength,
1033 true,
1034 dwHwPhrase,
1035 0));
1036 }
1037 else
1038 {
1039 // If Chroma Siting info is present
1040 if (dwChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_TOP : MHW_CHROMA_SITING_HORZ_LEFT))
1041 {
1042 // No Chroma Siting
1043 VPHAL_RENDER_CHK_STATUS(Mhw_CalcPolyphaseTablesUV(
1044 piUVCoefsParam,
1045 2.0F,
1046 fScale));
1047 }
1048 else
1049 {
1050 // Chroma siting offset needs to be added
1051 if (dwChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_CENTER : MHW_CHROMA_SITING_HORZ_CENTER))
1052 {
1053 iUvPhaseOffset = MOS_UF_ROUND(0.5F * 16.0F); // U0.4
1054 }
1055 else //if (ChromaSiting & (bVertical ? MHW_CHROMA_SITING_VERT_BOTTOM : MHW_CHROMA_SITING_HORZ_RIGHT))
1056 {
1057 iUvPhaseOffset = MOS_UF_ROUND(1.0F * 16.0F); // U0.4
1058 }
1059
1060 VPHAL_RENDER_CHK_STATUS(Mhw_CalcPolyphaseTablesUVOffset(
1061 piUVCoefsParam,
1062 3.0F,
1063 fScale,
1064 iUvPhaseOffset));
1065 }
1066 }
1067 }
1068 }
1069 }
1070
1071 finish:
1072 return eStatus;
1073 }
1074
1075 //!
1076 //! \brief Set Sampler8x8 Table for Gen9 Hdr AVS
1077 //! \details Set sampler8x8 table based on format, scale and chroma siting
1078 //! \param PRENDERHAL_INTERFACE pRenderHal
1079 //! [in] Pointer to RenderHal interface
1080 //! \param PMHW_SAMPLER_STATE_PARAM pSamplerStateParams,
1081 //! [in] Pointer to sampler state params
1082 //! \param PVPHAL_AVS_PARAMS pAvsParams
1083 //! [in] Pointer to avs parameters
1084 //! \param MOS_FORMAT SrcFormat
1085 //! [in] source format
1086 //! \param float fScaleX
1087 //! [in] Scale X
1088 //! \param float fScaleY
1089 //! [in] Scale Y
1090 //! \param uint32_t dwChromaSiting
1091 //! [in] Chroma siting
1092 //! \return void
1093 //!
VpHal_HdrSetSamplerAvsTableParam_g9(PRENDERHAL_INTERFACE pRenderHal,PMHW_SAMPLER_STATE_PARAM pSamplerStateParams,PMHW_AVS_PARAMS pAvsParams,MOS_FORMAT SrcFormat,float fScaleX,float fScaleY,uint32_t dwChromaSiting)1094 MOS_STATUS VpHal_HdrSetSamplerAvsTableParam_g9(
1095 PRENDERHAL_INTERFACE pRenderHal,
1096 PMHW_SAMPLER_STATE_PARAM pSamplerStateParams,
1097 PMHW_AVS_PARAMS pAvsParams,
1098 MOS_FORMAT SrcFormat,
1099 float fScaleX,
1100 float fScaleY,
1101 uint32_t dwChromaSiting)
1102 {
1103 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1104 bool bBalancedFilter = false;
1105 PMHW_SAMPLER_AVS_TABLE_PARAM pMhwSamplerAvsTableParam = nullptr;
1106
1107 VPHAL_HW_CHK_NULL(pRenderHal);
1108 VPHAL_HW_CHK_NULL(pSamplerStateParams);
1109 VPHAL_HW_CHK_NULL(pAvsParams);
1110 VPHAL_HW_CHK_NULL(pAvsParams->piYCoefsY);
1111 VPHAL_HW_CHK_NULL(pAvsParams->piYCoefsX);
1112 VPHAL_HW_CHK_NULL(pAvsParams->piUVCoefsY);
1113 VPHAL_HW_CHK_NULL(pAvsParams->piUVCoefsX);
1114
1115 pMhwSamplerAvsTableParam = pSamplerStateParams->Avs.pMhwSamplerAvsTableParam;
1116
1117 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable = pSamplerStateParams->Avs.b8TapAdaptiveEnable;
1118 pMhwSamplerAvsTableParam->byteTransitionArea8Pixels = MEDIASTATE_AVS_TRANSITION_AREA_8_PIXELS;
1119 pMhwSamplerAvsTableParam->byteTransitionArea4Pixels = MEDIASTATE_AVS_TRANSITION_AREA_4_PIXELS;
1120 pMhwSamplerAvsTableParam->byteMaxDerivative8Pixels = MEDIASTATE_AVS_MAX_DERIVATIVE_8_PIXELS;
1121 pMhwSamplerAvsTableParam->byteMaxDerivative4Pixels = MEDIASTATE_AVS_MAX_DERIVATIVE_4_PIXELS;
1122 pMhwSamplerAvsTableParam->byteDefaultSharpnessLevel = MEDIASTATE_AVS_SHARPNESS_LEVEL_SHARP;
1123
1124 // Enable Adaptive Filtering, if it is being upscaled
1125 // in either direction. we must check for this before clamping the SF.
1126 if ((IS_YUV_FORMAT(SrcFormat) && (fScaleX > 1.0F || fScaleY > 1.0F)) ||
1127 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable)
1128 {
1129 pMhwSamplerAvsTableParam->bBypassXAdaptiveFiltering = false;
1130 pMhwSamplerAvsTableParam->bBypassYAdaptiveFiltering = false;
1131 if (pMhwSamplerAvsTableParam->b8TapAdaptiveEnable)
1132 {
1133 pMhwSamplerAvsTableParam->bAdaptiveFilterAllChannels = true;
1134
1135 if (IS_RGB_FORMAT(SrcFormat))
1136 {
1137 pMhwSamplerAvsTableParam->bEnableRGBAdaptive = true;
1138 }
1139 }
1140 }
1141 else
1142 {
1143 pMhwSamplerAvsTableParam->bBypassXAdaptiveFiltering = true;
1144 pMhwSamplerAvsTableParam->bBypassYAdaptiveFiltering = true;
1145 }
1146
1147 // No changes to AVS parameters -> skip
1148 if (SrcFormat == pAvsParams->Format &&
1149 fScaleX == pAvsParams->fScaleX &&
1150 fScaleY == pAvsParams->fScaleY)
1151 {
1152 goto finish;
1153 }
1154
1155 // AVS Coefficients don't change for Scaling Factors > 1.0x
1156 // Hence recalculation is avoided
1157 if (fScaleX > 1.0F && pAvsParams->fScaleX > 1.0F)
1158 {
1159 pAvsParams->fScaleX = fScaleX;
1160 }
1161
1162 // AVS Coefficients don't change for Scaling Factors > 1.0x
1163 // Hence recalculation is avoided
1164 if (fScaleY > 1.0F && pAvsParams->fScaleY > 1.0F)
1165 {
1166 pAvsParams->fScaleY = fScaleY;
1167 }
1168
1169 bBalancedFilter = true;
1170 // Recalculate Horizontal scaling table
1171 VPHAL_HW_CHK_STATUS(VpHal_HdrSamplerAvsCalcScalingTable_g9(
1172 SrcFormat,
1173 fScaleX,
1174 false,
1175 dwChromaSiting,
1176 bBalancedFilter,
1177 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable ? true : false,
1178 pAvsParams));
1179
1180 // Recalculate Vertical scaling table
1181 VPHAL_HW_CHK_STATUS(VpHal_HdrSamplerAvsCalcScalingTable_g9(
1182 SrcFormat,
1183 fScaleY,
1184 true,
1185 dwChromaSiting,
1186 bBalancedFilter,
1187 pMhwSamplerAvsTableParam->b8TapAdaptiveEnable ? true : false,
1188 pAvsParams));
1189
1190 pMhwSamplerAvsTableParam->bIsCoeffExtraEnabled = true;
1191 // Save format used to calculate AVS parameters
1192 pAvsParams->Format = SrcFormat;
1193 pMhwSamplerAvsTableParam->b4TapGY = (IS_RGB32_FORMAT(SrcFormat) && !pMhwSamplerAvsTableParam->b8TapAdaptiveEnable);
1194 pMhwSamplerAvsTableParam->b4TapRBUV = (!pMhwSamplerAvsTableParam->b8TapAdaptiveEnable);
1195
1196 VpHal_RenderCommonSetAVSTableParam(pAvsParams, pMhwSamplerAvsTableParam);
1197
1198 finish:
1199 return eStatus;
1200 }
1201
1202
1203 typedef float (*pfnOETFFunc)(float radiance);
1204
OETF2084(float c)1205 float OETF2084(float c)
1206 {
1207 static const double C1 = 0.8359375;
1208 static const double C2 = 18.8515625;
1209 static const double C3 = 18.6875;
1210 static const double M1 = 0.1593017578125;
1211 static const double M2 = 78.84375;
1212
1213 double tmp = c;
1214 double numerator = pow(tmp, M1);
1215 double denominator = numerator;
1216
1217 denominator = 1.0 + C3 * denominator;
1218 numerator = C1 + C2 * numerator;
1219 numerator = numerator / denominator;
1220
1221 return (float)pow(numerator, M2);
1222 }
1223
OETFBT709(float c)1224 float OETFBT709(float c)
1225 {
1226 static const double E0 = 0.45;
1227 static const double C1 = 0.099;
1228 static const double C2 = 4.5;
1229 static const double P0 = 0.018;
1230
1231 double tmp = c;
1232 double result;
1233
1234 if (tmp <= P0)
1235 {
1236 result = C2 * tmp;
1237 }
1238 else
1239 {
1240 result = (C1 + 1.0) * pow(tmp, E0) - C1;
1241 }
1242 return (float)result;
1243 }
1244
OETFsRGB(float c)1245 float OETFsRGB(float c)
1246 {
1247 static const double E1 = 2.4;
1248 static const double C1 = 0.055;
1249 static const double C2 = 12.92;
1250 static const double P0 = 0.0031308;
1251
1252 double tmp = c;
1253 double result;
1254
1255 if (tmp <= P0)
1256 {
1257 result = C2 * tmp;
1258 }
1259 else
1260 {
1261 result = (C1 + 1.0) * pow(tmp, 1.0 / E1) - C1;
1262 }
1263 return (float)result;
1264 }
1265
1266 // Non-uniform OETF LUT generator.
VpHal_Generate2SegmentsOETFLUT(float fStretchFactor,pfnOETFFunc oetfFunc,uint16_t * lut)1267 void VpHal_Generate2SegmentsOETFLUT(float fStretchFactor, pfnOETFFunc oetfFunc, uint16_t *lut)
1268 {
1269 int i = 0, j = 0;
1270
1271 for (i = 0; i < VPHAL_HDR_OETF_1DLUT_HEIGHT; ++i)
1272 {
1273 for (j = 0; j < VPHAL_HDR_OETF_1DLUT_WIDTH; ++j)
1274 {
1275 int idx = j + i * (VPHAL_HDR_OETF_1DLUT_WIDTH - 1);
1276 float a = (idx < 32) ? ((1.0f / 1024.0f) * idx) : ((1.0f / 32.0f) * (idx - 31));
1277
1278 if (a > 1.0f)
1279 a = 1.0f;
1280
1281 a *= fStretchFactor;
1282 lut[i * VPHAL_HDR_OETF_1DLUT_WIDTH + j] = VpHal_FloatToHalfFloat(oetfFunc(a));
1283 }
1284 }
1285 }
1286
1287 typedef float Mat3[3][3];
1288 typedef float Vec3[3];
1289
Mat3MultiplyMat3(const Mat3 left,const Mat3 right,Mat3 output)1290 static void Mat3MultiplyMat3(const Mat3 left, const Mat3 right, Mat3 output)
1291 {
1292 output[0][0] = left[0][0] * right[0][0] + left[0][1] * right[1][0] + left[0][2] * right[2][0];
1293 output[0][1] = left[0][0] * right[0][1] + left[0][1] * right[1][1] + left[0][2] * right[2][1];
1294 output[0][2] = left[0][0] * right[0][2] + left[0][1] * right[1][2] + left[0][2] * right[2][2];
1295 output[1][0] = left[1][0] * right[0][0] + left[1][1] * right[1][0] + left[1][2] * right[2][0];
1296 output[1][1] = left[1][0] * right[0][1] + left[1][1] * right[1][1] + left[1][2] * right[2][1];
1297 output[1][2] = left[1][0] * right[0][2] + left[1][1] * right[1][2] + left[1][2] * right[2][2];
1298 output[2][0] = left[2][0] * right[0][0] + left[2][1] * right[1][0] + left[2][2] * right[2][0];
1299 output[2][1] = left[2][0] * right[0][1] + left[2][1] * right[1][1] + left[2][2] * right[2][1];
1300 output[2][2] = left[2][0] * right[0][2] + left[2][1] * right[1][2] + left[2][2] * right[2][2];
1301 }
1302
Mat3MultiplyVec3(const Mat3 input,const Vec3 vec,Vec3 output)1303 static void Mat3MultiplyVec3(const Mat3 input, const Vec3 vec, Vec3 output)
1304 {
1305 output[0] = input[0][0] * vec[0] + input[0][1] * vec[1] + input[0][2] * vec[2];
1306 output[1] = input[1][0] * vec[0] + input[1][1] * vec[1] + input[1][2] * vec[2];
1307 output[2] = input[2][0] * vec[0] + input[2][1] * vec[1] + input[2][2] * vec[2];
1308 }
1309
Mat3Inverse(const Mat3 input,Mat3 output)1310 static void Mat3Inverse(const Mat3 input, Mat3 output)
1311 {
1312 const float a0 = input[0][0];
1313 const float a1 = input[0][1];
1314 const float a2 = input[0][2];
1315
1316 const float b0 = input[1][0];
1317 const float b1 = input[1][1];
1318 const float b2 = input[1][2];
1319
1320 const float c0 = input[2][0];
1321 const float c1 = input[2][1];
1322 const float c2 = input[2][2];
1323
1324 float det = a0 * (b1 * c2 - b2 * c1) + a1 * (b2 * c0 - b0 * c2) + a2 * ( b0 * c1 - b1 * c0);
1325
1326 if (det != 0.0f)
1327 {
1328 float det_recip = 1.0f / det;
1329
1330 output[0][0] = (b1 * c2 - b2 * c1) * det_recip;
1331 output[0][1] = (a2 * c1 - a1 * c2) * det_recip;
1332 output[0][2] = (a1 * b2 - a2 * b1) * det_recip;
1333
1334 output[1][0] = (b2 * c0 - b0 * c2) * det_recip;
1335 output[1][1] = (a0 * c2 - a2 * c0) * det_recip;
1336 output[1][2] = (a2 * b0 - a0 * b2) * det_recip;
1337
1338 output[2][0] = (b0 * c1 - b1 * c0) * det_recip;
1339 output[2][1] = (a1 * c0 - a0 * c1) * det_recip;
1340 output[2][2] = (a0 * b1 - a1 * b0) * det_recip;
1341 }
1342 else
1343 {
1344 // irreversible
1345 output[0][0] = 1.0f;
1346 output[0][1] = 0.0f;
1347 output[0][2] = 0.0f;
1348 output[1][0] = 0.0f;
1349 output[1][1] = 1.0f;
1350 output[1][2] = 0.0f;
1351 output[2][0] = 0.0f;
1352 output[2][1] = 0.0f;
1353 output[2][2] = 1.0f;
1354 }
1355 }
1356
RGB2CIEXYZMatrix(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)1357 static void RGB2CIEXYZMatrix(
1358 const float xr, const float yr,
1359 const float xg, const float yg,
1360 const float xb, const float yb,
1361 const float xn, const float yn,
1362 Mat3 output)
1363 {
1364 const float zr = 1.0f - xr - yr;
1365 const float zg = 1.0f - xg - yg;
1366 const float zb = 1.0f - xb - yb;
1367 const float zn = 1.0f - xn - yn;
1368
1369 // m * [ar, ag, ab]T = [xn / yn, 1.0f, zn / yn]T;
1370 const Mat3 m =
1371 {
1372 xr, xg, xb,
1373 yr, yg, yb,
1374 zr, zg, zb
1375 };
1376
1377 Mat3 inversed_m;
1378
1379 Mat3Inverse(m, inversed_m);
1380
1381 const Vec3 XYZWithUnityY = {xn / yn, 1.0f, zn / yn};
1382 float aragab[3];
1383
1384 Mat3MultiplyVec3(inversed_m, XYZWithUnityY, aragab);
1385
1386 output[0][0] = m[0][0] * aragab[0];
1387 output[1][0] = m[1][0] * aragab[0];
1388 output[2][0] = m[2][0] * aragab[0];
1389 output[0][1] = m[0][1] * aragab[1];
1390 output[1][1] = m[1][1] * aragab[1];
1391 output[2][1] = m[2][1] * aragab[1];
1392 output[0][2] = m[0][2] * aragab[2];
1393 output[1][2] = m[1][2] * aragab[2];
1394 output[2][2] = m[2][2] * aragab[2];
1395 }
1396
VpHal_CalculateCCMWithMonitorGamut(VPHAL_HDR_CCM_TYPE CCMType,PVPHAL_HDR_PARAMS pTarget,float TempMatrix[12])1397 void VpHal_CalculateCCMWithMonitorGamut(
1398 VPHAL_HDR_CCM_TYPE CCMType,
1399 PVPHAL_HDR_PARAMS pTarget,
1400 float TempMatrix[12])
1401 {
1402 float src_xr = 1.0f, src_yr = 1.0f;
1403 float src_xg = 1.0f, src_yg = 1.0f;
1404 float src_xb = 1.0f, src_yb = 1.0f;
1405 float src_xn = 1.0f, src_yn = 1.0f;
1406
1407 float dst_xr = 1.0f, dst_yr = 1.0f;
1408 float dst_xg = 1.0f, dst_yg = 1.0f;
1409 float dst_xb = 1.0f, dst_yb = 1.0f;
1410 float dst_xn = 1.0f, dst_yn = 1.0f;
1411
1412 Mat3 SrcMatrix = {1.0f};
1413 Mat3 DstMatrix = {1.0f};
1414 Mat3 DstMatrixInverse = {1.0f};
1415 Mat3 SrcToDstMatrix = {1.0f};
1416
1417 Mat3 BT709ToBT2020Matrix = {1.0f};
1418 Mat3 BT2020ToBT709Matrix = {1.0f};
1419
1420 VPHAL_PUBLIC_CHK_NULL_NO_STATUS(pTarget);
1421
1422 if (CCMType == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX)
1423 {
1424 src_xr = 0.708f;
1425 src_yr = 0.292f;
1426 src_xg = 0.170f;
1427 src_yg = 0.797f;
1428 src_xb = 0.131f;
1429 src_yb = 0.046f;
1430 src_xn = 0.3127f;
1431 src_yn = 0.3290f;
1432
1433 dst_xr = pTarget->display_primaries_x[2] / 50000.0f;
1434 dst_yr = pTarget->display_primaries_y[2] / 50000.0f;
1435 dst_xg = pTarget->display_primaries_x[0] / 50000.0f;
1436 dst_yg = pTarget->display_primaries_y[0] / 50000.0f;
1437 dst_xb = pTarget->display_primaries_x[1] / 50000.0f;
1438 dst_yb = pTarget->display_primaries_y[1] / 50000.0f;
1439 dst_xn = pTarget->white_point_x / 50000.0f;
1440 dst_yn = pTarget->white_point_y / 50000.0f;
1441 }
1442 else if (CCMType == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX)
1443 {
1444 src_xr = pTarget->display_primaries_x[2] / 50000.0f;
1445 src_yr = pTarget->display_primaries_y[2] / 50000.0f;
1446 src_xg = pTarget->display_primaries_x[0] / 50000.0f;
1447 src_yg = pTarget->display_primaries_y[0] / 50000.0f;
1448 src_xb = pTarget->display_primaries_x[1] / 50000.0f;
1449 src_yb = pTarget->display_primaries_y[1] / 50000.0f;
1450 src_xn = pTarget->white_point_x / 50000.0f;
1451 src_yn = pTarget->white_point_y / 50000.0f;
1452
1453 dst_xr = 0.708f;
1454 dst_yr = 0.292f;
1455 dst_xg = 0.170f;
1456 dst_yg = 0.797f;
1457 dst_xb = 0.131f;
1458 dst_yb = 0.046f;
1459 dst_xn = 0.3127f;
1460 dst_yn = 0.3290f;
1461 }
1462 else
1463 {
1464 // VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX
1465 src_xr = pTarget->display_primaries_x[2] / 50000.0f;
1466 src_yr = pTarget->display_primaries_y[2] / 50000.0f;
1467 src_xg = pTarget->display_primaries_x[0] / 50000.0f;
1468 src_yg = pTarget->display_primaries_y[0] / 50000.0f;
1469 src_xb = pTarget->display_primaries_x[1] / 50000.0f;
1470 src_yb = pTarget->display_primaries_y[1] / 50000.0f;
1471 src_xn = pTarget->white_point_x / 50000.0f;
1472 src_yn = pTarget->white_point_y / 50000.0f;
1473
1474 dst_xr = 0.64f;
1475 dst_yr = 0.33f;
1476 dst_xg = 0.30f;
1477 dst_yg = 0.60f;
1478 dst_xb = 0.15f;
1479 dst_yb = 0.06f;
1480 dst_xn = 0.3127f;
1481 dst_yn = 0.3290f;
1482 }
1483
1484 RGB2CIEXYZMatrix(
1485 src_xr, src_yr,
1486 src_xg, src_yg,
1487 src_xb, src_yb,
1488 src_xn, src_yn,
1489 SrcMatrix);
1490
1491 RGB2CIEXYZMatrix(
1492 dst_xr, dst_yr,
1493 dst_xg, dst_yg,
1494 dst_xb, dst_yb,
1495 dst_xn, dst_yn,
1496 DstMatrix);
1497
1498 Mat3Inverse(DstMatrix, DstMatrixInverse);
1499 Mat3MultiplyMat3(DstMatrixInverse, SrcMatrix, SrcToDstMatrix);
1500
1501 TempMatrix[0] = SrcToDstMatrix[0][0];
1502 TempMatrix[1] = SrcToDstMatrix[0][1];
1503 TempMatrix[2] = SrcToDstMatrix[0][2];
1504 TempMatrix[3] = 0.0f;
1505 TempMatrix[4] = SrcToDstMatrix[1][0];
1506 TempMatrix[5] = SrcToDstMatrix[1][1];
1507 TempMatrix[6] = SrcToDstMatrix[1][2];
1508 TempMatrix[7] = 0.0f;
1509 TempMatrix[8] = SrcToDstMatrix[2][0];
1510 TempMatrix[9] = SrcToDstMatrix[2][1];
1511 TempMatrix[10] = SrcToDstMatrix[2][2];
1512 TempMatrix[11] = 0.0f;
1513
1514 finish:
1515 return;
1516 }
1517
1518 //!
1519 //! \brief Initiate EOTF Surface for HDR
1520 //! \details Initiate EOTF Surface for HDR
1521 //! \param PVPHAL_HDR_STATE pHdrStatee
1522 //! [in] Pointer to HDR state
1523 //! \param PVPHAL_SURFACE pCoeffSurface
1524 //! [in] Pointer to CSC/CCM Surface
1525 //! \return MOS_STATUS
1526 //!
VpHal_HdrInitCoeff_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_SURFACE pCoeffSurface)1527 MOS_STATUS VpHal_HdrInitCoeff_g9 (
1528 PVPHAL_HDR_STATE pHdrState,
1529 PVPHAL_SURFACE pCoeffSurface)
1530 {
1531 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1532 PMOS_INTERFACE pOsInterface = nullptr;
1533 uint32_t i = 0;
1534 float *pFloat = nullptr;
1535 float *pCoeff = nullptr;
1536 uint32_t *pEOTFType = nullptr;
1537 float *pEOTFCoeff = nullptr;
1538 float *pPivotPoint = nullptr;
1539 uint32_t *pTMType = nullptr;
1540 uint32_t *pOETFNeqType = nullptr;
1541 uint32_t *pCCMEnable = nullptr;
1542 float *pPWLFStretch = nullptr;
1543 float *pCoeffR = nullptr;
1544 float *pCoeffG = nullptr;
1545 float *pCoeffB = nullptr;
1546 uint16_t *pSlopeIntercept = nullptr;
1547 MOS_LOCK_PARAMS LockFlags = {};
1548 float PriorCscMatrix[12] = {};
1549 float PostCscMatrix[12] = {};
1550 float CcmMatrix[12] = {};
1551 float TempMatrix[12] = {};
1552 PVPHAL_SURFACE pSrc = nullptr;
1553
1554 VPHAL_PUBLIC_CHK_NULL(pHdrState);
1555 VPHAL_PUBLIC_CHK_NULL(pCoeffSurface);
1556 VPHAL_PUBLIC_CHK_NULL(pHdrState->pTargetSurf[0]);
1557
1558 eStatus = MOS_STATUS_SUCCESS;
1559 pOsInterface = pHdrState->pOsInterface;
1560
1561 VPHAL_PUBLIC_CHK_NULL(pOsInterface);
1562
1563 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
1564
1565 LockFlags.WriteOnly = 1;
1566
1567 // Lock the surface for writing
1568 pFloat = (float *)pOsInterface->pfnLockResource(
1569 pOsInterface,
1570 &(pCoeffSurface->OsResource),
1571 &LockFlags);
1572
1573 VPHAL_RENDER_CHK_NULL(pFloat);
1574
1575 #define SET_MATRIX(_c0, _c1, _c2, _c3, _c4, _c5, _c6, _c7, _c8, _c9, _c10, _c11) \
1576 { \
1577 TempMatrix[0] = _c0; \
1578 TempMatrix[1] = _c1; \
1579 TempMatrix[2] = _c2; \
1580 TempMatrix[3] = _c3; \
1581 TempMatrix[4] = _c4; \
1582 TempMatrix[5] = _c5; \
1583 TempMatrix[6] = _c6; \
1584 TempMatrix[7] = _c7; \
1585 TempMatrix[8] = _c8; \
1586 TempMatrix[9] = _c9; \
1587 TempMatrix[10] = _c10; \
1588 TempMatrix[11] = _c11; \
1589 }
1590
1591 #define SET_EOTF_COEFF(_c1, _c2, _c3, _c4, _c5) \
1592 { \
1593 *pEOTFCoeff = _c1; \
1594 pEOTFCoeff += pCoeffSurface->dwPitch / sizeof(float); \
1595 *pEOTFCoeff = _c2; \
1596 pEOTFCoeff += pCoeffSurface->dwPitch / sizeof(float); \
1597 *pEOTFCoeff = _c3; \
1598 pEOTFCoeff += pCoeffSurface->dwPitch / sizeof(float); \
1599 *pEOTFCoeff = _c4; \
1600 pEOTFCoeff += pCoeffSurface->dwPitch / sizeof(float); \
1601 *pEOTFCoeff = _c5; \
1602 }
1603
1604 #define WRITE_MATRIX(Matrix) \
1605 { \
1606 *pCoeff++ = Matrix[0]; \
1607 *pCoeff++ = Matrix[1]; \
1608 *pCoeff++ = Matrix[2]; \
1609 *pCoeff++ = Matrix[3]; \
1610 *pCoeff++ = Matrix[4]; \
1611 *pCoeff++ = Matrix[5]; \
1612 pCoeff+= pCoeffSurface->dwPitch / sizeof(float) - 6; \
1613 *pCoeff++ = Matrix[6]; \
1614 *pCoeff++ = Matrix[7]; \
1615 *pCoeff++ = Matrix[8]; \
1616 *pCoeff++ = Matrix[9]; \
1617 *pCoeff++ = Matrix[10]; \
1618 *pCoeff++ = Matrix[11]; \
1619 pCoeff+= pCoeffSurface->dwPitch / sizeof(float) - 6; \
1620 }
1621
1622 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++, pFloat += VPHAL_HDR_COEF_LINES_PER_LAYER_BASIC_G9 * pCoeffSurface->dwPitch / (sizeof(float)))
1623 {
1624 if (pHdrState->pSrcSurf[i] == nullptr)
1625 {
1626 continue;
1627 }
1628
1629 pSrc = pHdrState->pSrcSurf[i];
1630 pCoeff = pFloat;
1631
1632 if (pHdrState->pSrcSurf[i]->SurfType == SURF_IN_PRIMARY)
1633 {
1634 pHdrState->Reporting.GetFeatures().hdrMode = pHdrState->HdrMode[i];
1635 }
1636
1637 // EOTF/CCM/Tone Mapping/OETF require RGB input
1638 // So if prior CSC is needed, it will always be YUV to RGB conversion
1639 if (pHdrState->StageEnableFlags[i].PriorCSCEnable)
1640 {
1641 if (pHdrState->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT601)
1642 {
1643 SET_MATRIX( 1.000000f, 0.000000f, 1.402000f, 0.000000f,
1644 1.000000f, -0.344136f, -0.714136f, 0.000000f,
1645 1.000000f, 1.772000f, 0.000000f, 0.000000f);
1646
1647 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT601, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1648 }
1649 else if (pHdrState->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT709)
1650 {
1651 SET_MATRIX( 1.000000f, 0.000000f, 1.574800f, 0.000000f,
1652 1.000000f, -0.187324f, -0.468124f, 0.000000f,
1653 1.000000f, 1.855600f, 0.000000f, 0.000000f);
1654 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT709, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1655 }
1656 else if (pHdrState->PriorCSC[i] == VPHAL_HDR_CSC_YUV_TO_RGB_BT2020)
1657 {
1658 SET_MATRIX( 1.000000f, 0.000000f, 1.474600f, 0.000000f,
1659 1.000000f, -0.164550f, -0.571350f, 0.000000f,
1660 1.000000f, 1.881400f, 0.000000f, 0.000000f);
1661 VpHal_HdrCalcYuvToRgbMatrix(CSpace_BT2020, CSpace_sRGB, TempMatrix, PriorCscMatrix);
1662 }
1663 else
1664 {
1665 VPHAL_RENDER_ASSERTMESSAGE("Color Space Not found.");
1666 eStatus = MOS_STATUS_INVALID_PARAMETER;
1667 goto finish;
1668 }
1669 LimitFP32ArrayPrecisionToF3_9(PriorCscMatrix, ARRAY_SIZE(PriorCscMatrix));
1670 WRITE_MATRIX(PriorCscMatrix);
1671 }
1672 else
1673 {
1674 pCoeff += pCoeffSurface->dwPitch / sizeof(float) * 2;
1675 }
1676
1677 if (pHdrState->StageEnableFlags[i].CCMEnable)
1678 {
1679 // BT709 to BT2020 CCM
1680 if (pHdrState->CCM[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1681 {
1682 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f,
1683 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f,
1684 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1685 }
1686 // BT2020 to BT709 CCM
1687 else if (pHdrState->CCM[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1688 {
1689 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f,
1690 -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f,
1691 -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1692 }
1693 else
1694 {
1695 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f,
1696 0.0f, 1.0f, 0.0f, 0.0f,
1697 0.0f, 0.0f, 1.0f, 0.0f);
1698 }
1699
1700 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
1701 LimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
1702 WRITE_MATRIX(CcmMatrix);
1703 }
1704 else
1705 {
1706 pCoeff += pCoeffSurface->dwPitch / sizeof(float) * 2;
1707 }
1708
1709 // OETF will output RGB surface
1710 // So if post CSC is needed, it will always be RGB to YUV conversion
1711 if (pHdrState->StageEnableFlags[i].PostCSCEnable)
1712 {
1713 if (pHdrState->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT601)
1714 {
1715 SET_MATRIX( -0.331264f, -0.168736f, 0.500000f, 0.000000f,
1716 0.587000f, 0.299000f, 0.114000f, 0.000000f,
1717 -0.418688f, 0.500000f, -0.081312f, 0.000000f);
1718 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT601, TempMatrix, PostCscMatrix);
1719 }
1720 else if (pHdrState->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT709)
1721 {
1722 SET_MATRIX( -0.385428f, -0.114572f, 0.500000f, 0.000000f,
1723 0.715200f, 0.212600f, 0.072200f, 0.000000f,
1724 -0.454153f, 0.500000f, -0.045847f, 0.000000f);
1725 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT709, TempMatrix, PostCscMatrix);
1726 }
1727 else if (pHdrState->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT709_FULLRANGE)
1728 {
1729 SET_MATRIX( -0.385428f, -0.114572f, 0.500000f, 0.000000f,
1730 0.715200f, 0.212600f, 0.072200f, 0.000000f,
1731 -0.454153f, 0.500000f, -0.045847f, 0.000000f);
1732 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT709_FullRange, TempMatrix, PostCscMatrix);
1733 }
1734 else if (pHdrState->PostCSC[i] == VPHAL_HDR_CSC_RGB_TO_YUV_BT2020)
1735 {
1736 SET_MATRIX( -0.360370f, -0.139630f, 0.500000f, 0.000000f,
1737 0.678000f, 0.262700f, 0.059300f, 0.000000f,
1738 -0.459786f, 0.500000f, -0.040214f, 0.000000f);
1739 VpHal_HdrCalcRgbToYuvMatrix(CSpace_sRGB, CSpace_BT2020, TempMatrix, PostCscMatrix);
1740 }
1741 else
1742 {
1743 VPHAL_RENDER_ASSERTMESSAGE("Color Space Not found.");
1744 eStatus = MOS_STATUS_INVALID_PARAMETER;
1745 goto finish;
1746 }
1747 LimitFP32ArrayPrecisionToF3_9(PostCscMatrix, ARRAY_SIZE(PostCscMatrix));
1748 WRITE_MATRIX(PostCscMatrix);
1749 }
1750 else
1751 {
1752 pCoeff += pCoeffSurface->dwPitch / sizeof(float) * 2;
1753 }
1754
1755 pEOTFType = (uint32_t *)(pFloat + VPHAL_HDR_COEF_EOTF_OFFSET);
1756 pEOTFCoeff = pFloat + pCoeffSurface->dwPitch / sizeof(float) + VPHAL_HDR_COEF_EOTF_OFFSET;
1757
1758 if (pHdrState->StageEnableFlags[i].EOTFEnable)
1759 {
1760 if (pHdrState->EOTFGamma[i] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
1761 {
1762 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA_G9;
1763 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA_G9,
1764 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA_G9,
1765 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA_G9,
1766 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA_G9,
1767 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA_G9);
1768 }
1769 else if (pHdrState->EOTFGamma[i] == VPHAL_GAMMA_SMPTE_ST2084)
1770 {
1771 *pEOTFType = VPHAL_HDR_KERNEL_SMPTE_ST2084_G9;
1772 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_SMPTE_ST2084_G9,
1773 VPHAL_HDR_EOTF_COEFF2_SMPTE_ST2084_G9,
1774 VPHAL_HDR_EOTF_COEFF3_SMPTE_ST2084_G9,
1775 VPHAL_HDR_EOTF_COEFF4_SMPTE_ST2084_G9,
1776 VPHAL_HDR_EOTF_COEFF5_SMPTE_ST2084_G9);
1777 }
1778 else if (pHdrState->EOTFGamma[i] == VPHAL_GAMMA_BT1886)
1779 {
1780 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA_G9;
1781 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA_BT1886_G9,
1782 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA_BT1886_G9,
1783 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA_BT1886_G9,
1784 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA_BT1886_G9,
1785 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA_BT1886_G9);
1786 }
1787 else if (pHdrState->EOTFGamma[i] == VPHAL_GAMMA_SRGB)
1788 {
1789 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA_G9;
1790 SET_EOTF_COEFF(VPHAL_HDR_EOTF_COEFF1_TRADITIONNAL_GAMMA_SRGB_G9,
1791 VPHAL_HDR_EOTF_COEFF2_TRADITIONNAL_GAMMA_SRGB_G9,
1792 VPHAL_HDR_EOTF_COEFF3_TRADITIONNAL_GAMMA_SRGB_G9,
1793 VPHAL_HDR_EOTF_COEFF4_TRADITIONNAL_GAMMA_SRGB_G9,
1794 VPHAL_HDR_EOTF_COEFF5_TRADITIONNAL_GAMMA_SRGB_G9);
1795 }
1796 else
1797 {
1798 VPHAL_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
1799 eStatus = MOS_STATUS_INVALID_PARAMETER;
1800 goto finish;
1801 }
1802 }
1803
1804 pEOTFType ++;
1805 pEOTFCoeff = pFloat + pCoeffSurface->dwPitch / sizeof(float) + VPHAL_HDR_COEF_EOTF_OFFSET + 1;
1806
1807 if (pHdrState->StageEnableFlags[i].OETFEnable)
1808 {
1809 if (pHdrState->OETFGamma[i] == VPHAL_GAMMA_TRADITIONAL_GAMMA)
1810 {
1811 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA_G9;
1812 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_TRADITIONNAL_GAMMA_G9,
1813 VPHAL_HDR_OETF_COEFF2_TRADITIONNAL_GAMMA_G9,
1814 VPHAL_HDR_OETF_COEFF3_TRADITIONNAL_GAMMA_G9,
1815 VPHAL_HDR_OETF_COEFF4_TRADITIONNAL_GAMMA_G9,
1816 VPHAL_HDR_OETF_COEFF5_TRADITIONNAL_GAMMA_G9);
1817 }
1818 else if (pHdrState->OETFGamma[i] == VPHAL_GAMMA_SRGB)
1819 {
1820 *pEOTFType = VPHAL_HDR_KERNEL_EOTF_TRADITIONAL_GAMMA_G9;
1821 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_TRADITIONNAL_GAMMA_SRGB_G9,
1822 VPHAL_HDR_OETF_COEFF2_TRADITIONNAL_GAMMA_SRGB_G9,
1823 VPHAL_HDR_OETF_COEFF3_TRADITIONNAL_GAMMA_SRGB_G9,
1824 VPHAL_HDR_OETF_COEFF4_TRADITIONNAL_GAMMA_SRGB_G9,
1825 VPHAL_HDR_OETF_COEFF5_TRADITIONNAL_GAMMA_SRGB_G9);
1826 }
1827 else if (pHdrState->OETFGamma[i] == VPHAL_GAMMA_SMPTE_ST2084)
1828 {
1829 *pEOTFType = VPHAL_HDR_KERNEL_SMPTE_ST2084_G9;
1830 SET_EOTF_COEFF(VPHAL_HDR_OETF_COEFF1_SMPTE_ST2084_G9,
1831 VPHAL_HDR_OETF_COEFF2_SMPTE_ST2084_G9,
1832 VPHAL_HDR_OETF_COEFF3_SMPTE_ST2084_G9,
1833 VPHAL_HDR_OETF_COEFF4_SMPTE_ST2084_G9,
1834 VPHAL_HDR_OETF_COEFF5_SMPTE_ST2084_G9);
1835 }
1836 else
1837 {
1838 VPHAL_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
1839 eStatus = MOS_STATUS_INVALID_PARAMETER;
1840 goto finish;
1841 }
1842 }
1843
1844 // NOTE:
1845 // Pitch is not equal to width usually. So please be careful when using pointer addition.
1846 // Only do this when operands are in the same row.
1847 pPivotPoint = pFloat + pCoeffSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_PIVOT_POINT_LINE_OFFSET;
1848 pSlopeIntercept = (uint16_t *)(pFloat + pCoeffSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET);
1849 pPWLFStretch = pFloat + pCoeffSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_PIVOT_POINT_LINE_OFFSET + 5;
1850 pTMType = (uint32_t *)(pPWLFStretch);
1851 pCoeffR = pPWLFStretch + 1;
1852 pCoeffG = pCoeffR + 1;
1853 pCoeffB = pFloat + pCoeffSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET + 6;
1854 pOETFNeqType = (uint32_t *)(pFloat + pCoeffSurface->dwPitch / sizeof(float) * VPHAL_HDR_COEF_SLOPE_INTERCEPT_LINE_OFFSET + 7);
1855
1856 if (pHdrState->HdrMode[i] == VPHAL_HDR_MODE_TONE_MAPPING)
1857 {
1858 *pTMType = 1; // TMtype
1859 *pOETFNeqType = 0 | (10000 << 16); // OETFNEQ
1860 *pCoeffR = 0.25f;
1861 *pCoeffG = 0.625f;
1862 *pCoeffB = 0.125f;
1863 }
1864 else if (pHdrState->HdrMode[i] == VPHAL_HDR_MODE_INVERSE_TONE_MAPPING)
1865 {
1866 *pPWLFStretch = 0.01f; // Stretch
1867 *pOETFNeqType = 1 | ((uint32_t)100 << 16); // OETFNEQ
1868 *pCoeffR = 0.0f;
1869 *pCoeffG = 0.0f;
1870 *pCoeffB = 0.0f;
1871 }
1872 else if (pHdrState->HdrMode[i] == VPHAL_HDR_MODE_H2H ||
1873 pHdrState->HdrMode[i] == VPHAL_HDR_MODE_H2H_AUTO_MODE)
1874 {
1875 PVPHAL_SURFACE pTargetSurf = (PVPHAL_SURFACE)pHdrState->pTargetSurf[0];
1876
1877 *pTMType = 1; // TMtype
1878 *pOETFNeqType = 2 | (((uint32_t)(pTargetSurf->pHDRParams->max_display_mastering_luminance)) << 16); // OETFNEQ
1879 *pCoeffR = 0.25f;
1880 *pCoeffG = 0.625f;
1881 *pCoeffB = 0.125f;
1882 }
1883 else
1884 {
1885 *pPivotPoint = 0.0f;
1886 *pTMType = 0; // TMtype
1887 *pOETFNeqType = 0; // OETFNEQ
1888 }
1889 }
1890
1891 // Skip the Dst CSC area
1892 pFloat += 2 * pCoeffSurface->dwPitch / sizeof(float);
1893
1894 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++, pFloat += VPHAL_HDR_COEF_LINES_PER_LAYER_EXT_G9 * pCoeffSurface->dwPitch / (sizeof(float)))
1895 {
1896 pCCMEnable = (uint32_t *)pFloat;
1897 *(pCCMEnable + VPHAL_HDR_COEF_CCMEXT_OFFSET) = pHdrState->StageEnableFlags[i].CCMExt1Enable;
1898 *(pCCMEnable + VPHAL_HDR_COEF_CLAMP_OFFSET ) = pHdrState->StageEnableFlags[i].GamutClamp1Enable;
1899
1900 pCCMEnable += pCoeffSurface->dwPitch / sizeof(float) * 2;
1901 *(pCCMEnable + VPHAL_HDR_COEF_CCMEXT_OFFSET) = pHdrState->StageEnableFlags[i].CCMExt2Enable;
1902 *(pCCMEnable + VPHAL_HDR_COEF_CLAMP_OFFSET ) = pHdrState->StageEnableFlags[i].GamutClamp2Enable;
1903
1904 if (pHdrState->pSrcSurf[i] == nullptr)
1905 {
1906 continue;
1907 }
1908
1909 pCoeff = pFloat;
1910 if (pHdrState->StageEnableFlags[i].CCMExt1Enable)
1911 {
1912 // BT709 to BT2020 CCM
1913 if (pHdrState->CCMExt1[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1914 {
1915 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f,
1916 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f,
1917 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1918 }
1919 // BT2020 to BT709 CCM
1920 else if (pHdrState->CCMExt1[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1921 {
1922 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f,
1923 -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f,
1924 -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1925 }
1926 else if (pHdrState->CCMExt1[i] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
1927 pHdrState->CCMExt1[i] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
1928 pHdrState->CCMExt1[i] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
1929 {
1930 PVPHAL_SURFACE pTargetSurf = (PVPHAL_SURFACE)pHdrState->pTargetSurf[0];
1931 VpHal_CalculateCCMWithMonitorGamut(pHdrState->CCMExt1[i], pTargetSurf->pHDRParams, TempMatrix);
1932 }
1933 else
1934 {
1935 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f,
1936 0.0f, 1.0f, 0.0f, 0.0f,
1937 0.0f, 0.0f, 1.0f, 0.0f);
1938 }
1939
1940 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
1941 LimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
1942 WRITE_MATRIX(CcmMatrix);
1943 }
1944 else
1945 {
1946 pCoeff += pCoeffSurface->dwPitch / sizeof(float) * 2;
1947 }
1948
1949 if (pHdrState->StageEnableFlags[i].CCMExt2Enable)
1950 {
1951 // BT709 to BT2020 CCM
1952 if (pHdrState->CCMExt2[i] == VPHAL_HDR_CCM_BT601_BT709_TO_BT2020_MATRIX)
1953 {
1954 SET_MATRIX(0.627404078626f, 0.329282097415f, 0.043313797587f, 0.000000f,
1955 0.069097233123f, 0.919541035593f, 0.011361189924f, 0.000000f,
1956 0.016391587664f, 0.088013255546f, 0.895595009604f, 0.000000f);
1957 }
1958 // BT2020 to BT709 CCM
1959 else if (pHdrState->CCMExt2[i] == VPHAL_HDR_CCM_BT2020_TO_BT601_BT709_MATRIX)
1960 {
1961 SET_MATRIX(1.660490254890140f, -0.587638564717282f, -0.072851975229213f, 0.000000f,
1962 -0.124550248621850f, 1.132898753013895f, -0.008347895599309f, 0.000000f,
1963 -0.018151059958635f, -0.100578696221493f, 1.118729865913540f, 0.000000f);
1964 }
1965 else if (pHdrState->CCMExt2[i] == VPHAL_HDR_CCM_BT2020_TO_MONITOR_MATRIX ||
1966 pHdrState->CCMExt2[i] == VPHAL_HDR_CCM_MONITOR_TO_BT2020_MATRIX ||
1967 pHdrState->CCMExt2[i] == VPHAL_HDR_CCM_MONITOR_TO_BT709_MATRIX)
1968 {
1969 PVPHAL_SURFACE pTargetSurf = (PVPHAL_SURFACE)pHdrState->pTargetSurf[0];
1970 VpHal_CalculateCCMWithMonitorGamut(pHdrState->CCMExt2[i], pTargetSurf->pHDRParams, TempMatrix);
1971 }
1972 else
1973 {
1974 SET_MATRIX(1.0f, 0.0f, 0.0f, 0.0f,
1975 0.0f, 1.0f, 0.0f, 0.0f,
1976 0.0f, 0.0f, 1.0f, 0.0f);
1977 }
1978
1979 VpHal_HdrCalcCCMMatrix(TempMatrix, CcmMatrix);
1980 LimitFP32ArrayPrecisionToF3_9(CcmMatrix, ARRAY_SIZE(CcmMatrix));
1981 WRITE_MATRIX(CcmMatrix);
1982 }
1983 else
1984 {
1985 pCoeff += pCoeffSurface->dwPitch / sizeof(float) * 2;
1986 }
1987 }
1988
1989 pOsInterface->pfnUnlockResource(
1990 pOsInterface,
1991 &(pCoeffSurface->OsResource));
1992
1993 eStatus = MOS_STATUS_SUCCESS;
1994
1995 #undef SET_MATRIX
1996 #undef SET_EOTF_COEFF
1997 #undef WRITE_MATRIX
1998
1999 finish:
2000 return eStatus;
2001 }
2002
2003
2004 //! \brief Allocate Resources for HDR
2005 //! \details Allocate Resources for HDR
2006 //! \param PVPHAL_HDR_STATE pHdrStatee
2007 //! [in] Pointer to HDR state
2008 //! \return MOS_STATUS
2009 //!
VpHal_HdrAllocateResources_g9(PVPHAL_HDR_STATE pHdrState)2010 MOS_STATUS VpHal_HdrAllocateResources_g9(
2011 PVPHAL_HDR_STATE pHdrState)
2012 {
2013 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2014 PMOS_INTERFACE pOsInterface = nullptr;
2015 uint32_t dwWidth = 16;
2016 uint32_t dwHeight = 16;
2017 uint32_t dwDepth = 8;
2018 bool bAllocated = false;
2019 uint32_t dwUpdateMask = 0;
2020 int32_t i = 0;
2021 VPHAL_GET_SURFACE_INFO Info = {};
2022 MOS_ALLOC_GFXRES_PARAMS AllocParams = {};
2023 VPHAL_HDR_RENDER_DATA RenderData = {};
2024
2025 VPHAL_RENDER_CHK_NULL(pHdrState);
2026 VPHAL_RENDER_CHK_NULL(pHdrState->pOsInterface);
2027
2028 eStatus = MOS_STATUS_UNKNOWN;
2029 pOsInterface = pHdrState->pOsInterface;
2030
2031 // Allocate CSC CCM Coeff Surface
2032 dwWidth = VPHAL_HDR_COEF_SURFACE_WIDTH_G9;
2033 dwHeight = VPHAL_HDR_COEF_SURFACE_HEIGHT_G9;
2034
2035 pHdrState->pHDRStageConfigTable = HDRStageConfigTable_g9;
2036
2037 VPHAL_RENDER_CHK_STATUS(VpHal_HdrUpdatePerLayerPipelineStates(pHdrState, &dwUpdateMask));
2038
2039 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
2040 pOsInterface,
2041 &pHdrState->CoeffSurface,
2042 "CoeffSurface",
2043 Format_A8R8G8B8,
2044 MOS_GFXRES_2D,
2045 MOS_TILE_LINEAR,
2046 dwWidth,
2047 dwHeight,
2048 false,
2049 MOS_MMC_DISABLED,
2050 &bAllocated));
2051
2052 // Initialize COEF Coeff Surface
2053 if (dwUpdateMask || bAllocated)
2054 {
2055 VPHAL_RENDER_CHK_STATUS(pHdrState->pfnInitCoeff(
2056 pHdrState,
2057 &pHdrState->CoeffSurface));
2058 }
2059
2060 // Allocate OETF 1D LUT Surface
2061 dwWidth = pHdrState->dwOetfSurfaceWidth;
2062 dwHeight = pHdrState->dwOetfSurfaceWidth;
2063
2064 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
2065 {
2066 VPHAL_RENDER_CHK_STATUS(VpHal_ReAllocateSurface(
2067 pOsInterface,
2068 &pHdrState->OETF1DLUTSurface[i],
2069 "OETF1DLUTSurface",
2070 Format_R16F,
2071 MOS_GFXRES_2D,
2072 MOS_TILE_LINEAR,
2073 dwWidth,
2074 dwHeight,
2075 false,
2076 MOS_MMC_DISABLED,
2077 &bAllocated));
2078
2079 if (bAllocated || (dwUpdateMask & (1 << i)) || (dwUpdateMask & (1 << VPHAL_MAX_HDR_INPUT_LAYER)))
2080 {
2081 // Initialize OETF 1D LUT Surface
2082 VPHAL_RENDER_CHK_STATUS(pHdrState->pfnInitOETF1DLUT(
2083 pHdrState,
2084 i,
2085 &pHdrState->OETF1DLUTSurface[i]));
2086 }
2087 }
2088
2089 finish:
2090 return eStatus;
2091 }
2092
2093 //!
2094 //! \brief Free Resources for HDR
2095 //! \details Free Resources for HDR
2096 //! \param PVPHAL_HDR_STATE pHdrStatee
2097 //! [in] Pointer to HDR state
2098 //! \return MOS_STATUS
2099 //!
VpHal_HdrFreeResources_g9(PVPHAL_HDR_STATE pHdrState)2100 MOS_STATUS VpHal_HdrFreeResources_g9(
2101 PVPHAL_HDR_STATE pHdrState)
2102 {
2103 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2104 PMOS_INTERFACE pOsInterface = nullptr;
2105 int32_t i = 0;
2106
2107 VPHAL_RENDER_CHK_NULL(pHdrState);
2108 VPHAL_RENDER_CHK_NULL(pHdrState->pOsInterface);
2109
2110 eStatus = MOS_STATUS_SUCCESS;
2111 pOsInterface = pHdrState->pOsInterface;
2112
2113 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
2114 {
2115 pOsInterface->pfnFreeResource(pOsInterface,
2116 &(pHdrState->OETF1DLUTSurface[i].OsResource));
2117 }
2118
2119 pOsInterface->pfnFreeResource(pOsInterface,
2120 &(pHdrState->CoeffSurface.OsResource));
2121 finish:
2122 return eStatus;
2123 }
2124
2125 //!
2126 //! \brief HDR Surface State Setup
2127 //! \details Set up surface state used in HDR process, and bind the surface to pointed binding table entry.
2128 //! \param PVPHAL_HDR_STATE pHdrState
2129 // [in/out] Pointer to HDR state
2130 //! \param PVPHAL_HDR_RENDER_DATA pRenderData
2131 //! [in] Pointer to hdr render data.
2132 //! \return MOS_STATUS
2133 //! MOS_STATUS_SUCCESS if successful, otherwise failed
2134 //!
VpHal_HdrSetupSurfaceStates_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData)2135 MOS_STATUS VpHal_HdrSetupSurfaceStates_g9(
2136 PVPHAL_HDR_STATE pHdrState,
2137 PVPHAL_HDR_RENDER_DATA pRenderData)
2138 {
2139 PRENDERHAL_INTERFACE pRenderHal = nullptr;
2140 PVPHAL_SURFACE pSource = nullptr;
2141 PVPHAL_SURFACE pTarget = nullptr;
2142 PRENDERHAL_SURFACE pRenderHalSource = nullptr;
2143 PRENDERHAL_SURFACE pRenderHalTarget = nullptr;
2144 RENDERHAL_SURFACE_STATE_PARAMS SurfaceParams = {};
2145 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
2146 uint32_t i = 0;
2147 int32_t iBTentry = 0;
2148 PVPHAL_SURFACE pSurfaceTemp = nullptr;
2149 PRENDERHAL_SURFACE pRenderHalSurfaceTemp = nullptr;
2150
2151 VPHAL_RENDER_CHK_NULL(pHdrState);
2152 VPHAL_RENDER_CHK_NULL(pRenderData);
2153
2154 pRenderHal = pHdrState->pRenderHal;
2155 VPHAL_RENDER_CHK_NULL(pRenderHal);
2156
2157 for (i = 0; i < pHdrState->uSourceCount; i++)
2158 {
2159 if (i >= VPHAL_MAX_HDR_INPUT_LAYER)
2160 {
2161 eStatus = MOS_STATUS_INVALID_PARAMETER;
2162 goto finish;
2163 }
2164
2165 pSource = pHdrState->pSrcSurf[i];
2166 pRenderHalSource = & pHdrState->RenderHalSrcSurf[i];
2167 VPHAL_RENDER_CHK_NULL(pSource);
2168
2169 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2170
2171 // Render target or private surface
2172 if (pSource->SurfType == SURF_OUT_RENDERTARGET)
2173 {
2174 // Disable AVS, IEF
2175 pSource->ScalingMode = VPHAL_SCALING_BILINEAR;
2176 pSource->bIEF = false;
2177
2178 // Set flags for RT
2179 SurfaceParams.bRenderTarget = true;
2180 SurfaceParams.bWidthInDword_Y = true;
2181 SurfaceParams.bWidthInDword_UV = true;
2182 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_DSTRECT;
2183 }
2184 // other surfaces
2185 else
2186 {
2187 SurfaceParams.bRenderTarget = false;
2188 SurfaceParams.bWidthInDword_Y = false;
2189 SurfaceParams.bWidthInDword_UV = false;
2190 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_SRCRECT;
2191 }
2192
2193 // Set surface type based on scaling mode
2194 if (pSource->ScalingMode == VPHAL_SCALING_AVS || pSource->bIEF)
2195 {
2196 SurfaceParams.Type = pRenderHal->SurfaceTypeAdvanced;
2197 SurfaceParams.bAVS = true;
2198 }
2199 else
2200 {
2201 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2202 SurfaceParams.bAVS = false;
2203 }
2204
2205 SurfaceParams.MemObjCtl = pHdrState->SurfMemObjCtl.SourceSurfMemObjCtl;
2206 iBTentry = pHdrState->uSourceBindingTableIndex[i];
2207
2208 if (!Mos_ResourceIsNull(&pSource->OsResource))
2209 {
2210 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2211 pRenderHal,
2212 pSource,
2213 pRenderHalSource,
2214 &SurfaceParams,
2215 pRenderData->iBindingTable,
2216 iBTentry,
2217 false));
2218 }
2219 else
2220 {
2221 VPHAL_RENDER_ASSERTMESSAGE("Null resource found");
2222 eStatus = MOS_STATUS_NULL_POINTER;
2223 goto finish;
2224 }
2225
2226 if (pHdrState->LUTMode[i] == VPHAL_HDR_LUT_MODE_2D)
2227 {
2228 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2229 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2230 SurfaceParams.bRenderTarget = false;
2231 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
2232 SurfaceParams.bWidth16Align = false;
2233 SurfaceParams.MemObjCtl = pHdrState->SurfMemObjCtl.Lut2DSurfMemObjCtl;
2234
2235 if (!Mos_ResourceIsNull(&pHdrState->OETF1DLUTSurface[i].OsResource))
2236 {
2237 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2238 pRenderHal,
2239 &pHdrState->OETF1DLUTSurface[i],
2240 &pHdrState->RenderHalOETF1DLUTSurface[i],
2241 &SurfaceParams,
2242 pRenderData->iBindingTable,
2243 iBTentry + VPHAL_HDR_BTINDEX_OETF1DLUT_OFFSET_G9,
2244 false));
2245 }
2246 else
2247 {
2248 VPHAL_RENDER_ASSERTMESSAGE("Null resource found");
2249 eStatus = MOS_STATUS_NULL_POINTER;
2250 goto finish;
2251 }
2252 }
2253 }
2254
2255 for (i = 0; i < pHdrState->uTargetCount; i++)
2256 {
2257 if (i >= VPHAL_MAX_HDR_OUTPUT_LAYER)
2258 {
2259 eStatus = MOS_STATUS_INVALID_PARAMETER;
2260 goto finish;
2261 }
2262
2263 pTarget = pHdrState->pTargetSurf[i];
2264 pRenderHalTarget = &pHdrState->RenderHalTargetSurf[i];
2265 VPHAL_RENDER_CHK_NULL(pTarget);
2266
2267 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2268
2269 // Render target or private surface
2270 if (pTarget->SurfType == SURF_OUT_RENDERTARGET)
2271 {
2272 // Disable AVS, IEF
2273 pTarget->ScalingMode = VPHAL_SCALING_BILINEAR;
2274 pTarget->bIEF = false;
2275
2276 // Set flags for RT
2277 SurfaceParams.bRenderTarget = true;
2278 SurfaceParams.bWidthInDword_Y = true;
2279 SurfaceParams.bWidthInDword_UV = true;
2280 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_DSTRECT;
2281 }
2282 // other surfaces
2283 else
2284 {
2285 SurfaceParams.bRenderTarget = false;
2286 SurfaceParams.bWidthInDword_Y = false;
2287 SurfaceParams.bWidthInDword_UV = false;
2288 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_SRCRECT;
2289 }
2290
2291 // Set surface type based on scaling mode
2292 if (pTarget->ScalingMode == VPHAL_SCALING_AVS || pTarget->bIEF)
2293 {
2294 SurfaceParams.Type = pRenderHal->SurfaceTypeAdvanced;
2295 SurfaceParams.bAVS = true;
2296 }
2297 else
2298 {
2299 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2300 SurfaceParams.bAVS = false;
2301 }
2302
2303 SurfaceParams.MemObjCtl = pHdrState->SurfMemObjCtl.TargetSurfMemObjCtl;
2304 iBTentry = pHdrState->uTargetBindingTableIndex[i];
2305
2306 if (!Mos_ResourceIsNull(&pTarget->OsResource))
2307 {
2308 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2309 pRenderHal,
2310 pTarget,
2311 pRenderHalTarget,
2312 &SurfaceParams,
2313 pRenderData->iBindingTable,
2314 iBTentry,
2315 true));
2316 }
2317 else
2318 {
2319 VPHAL_RENDER_ASSERTMESSAGE("Null resource found");
2320 eStatus = MOS_STATUS_NULL_POINTER;
2321 goto finish;
2322 }
2323 }
2324
2325 pSurfaceTemp = &pHdrState->CoeffSurface;
2326 pRenderHalSurfaceTemp = &pHdrState->RenderHalCoeffSurface;
2327 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
2328 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
2329 SurfaceParams.bRenderTarget = false;
2330 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
2331 SurfaceParams.bWidth16Align = false;
2332 SurfaceParams.MemObjCtl = pHdrState->SurfMemObjCtl.CoeffSurfMemObjCtl;
2333 iBTentry = VPHAL_HDR_BTINDEX_COEFF_G9;
2334
2335 if (!Mos_ResourceIsNull(&pSurfaceTemp->OsResource))
2336 {
2337 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
2338 pRenderHal,
2339 pSurfaceTemp,
2340 pRenderHalSurfaceTemp,
2341 &SurfaceParams,
2342 pRenderData->iBindingTable,
2343 iBTentry,
2344 false));
2345 }
2346 else
2347 {
2348 VPHAL_RENDER_ASSERTMESSAGE("Null resource found");
2349 eStatus = MOS_STATUS_NULL_POINTER;
2350 goto finish;
2351 }
2352
2353 eStatus = MOS_STATUS_SUCCESS;
2354
2355 finish:
2356 return eStatus;
2357 }
2358
2359 //!
2360 //! \brief Set the Sampler States
2361 //! \details Set the Sampler States
2362 //! \param VPHAL_HDR_PHASE pHdrState
2363 //! [in] pointer to HDR State
2364 //! \param PVPHAL_HDR_RENDER_DATA
2365 //! [in] HDR render data
2366 //! \return MOS_STATUS
2367 //! MOS_STATUS_SUCCESS if successful, otherwise failed
2368 //!
VpHal_HdrSetSamplerStates_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData)2369 MOS_STATUS VpHal_HdrSetSamplerStates_g9 (
2370 PVPHAL_HDR_STATE pHdrState,
2371 PVPHAL_HDR_RENDER_DATA pRenderData)
2372 {
2373 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2374 PRENDERHAL_INTERFACE pRenderHal = nullptr;
2375 PMHW_SAMPLER_STATE_PARAM pSamplerStateParams = nullptr;
2376 uint32_t i = 0;
2377
2378 VPHAL_PUBLIC_CHK_NULL(pHdrState);
2379 VPHAL_PUBLIC_CHK_NULL(pRenderData);
2380
2381 pRenderHal = pHdrState->pRenderHal;
2382 VPHAL_PUBLIC_CHK_NULL(pRenderHal);
2383
2384 for (i = 0; i < VPHAL_HDR_SAMPLER_STATE_NUM; i++)
2385 {
2386 pSamplerStateParams = &pRenderData->SamplerStateParams[i];
2387
2388 switch (i)
2389 {
2390 case VPHAL_HDR_SAMPLER_STATE_3D_NEAREST_INDEX_G9:
2391 pSamplerStateParams->bInUse = true;
2392 pSamplerStateParams->SamplerType = MHW_SAMPLER_TYPE_3D;
2393 pSamplerStateParams->Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_NEAREST;
2394 pSamplerStateParams->Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2395 pSamplerStateParams->Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2396 pSamplerStateParams->Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2397 break;
2398 case VPHAL_HDR_SAMPLER_STATE_3D_BILINEAR_INDEX_G9:
2399 pSamplerStateParams->bInUse = true;
2400 pSamplerStateParams->SamplerType = MHW_SAMPLER_TYPE_3D;
2401 pSamplerStateParams->Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_BILINEAR;
2402 pSamplerStateParams->Unorm.AddressU = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2403 pSamplerStateParams->Unorm.AddressV = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2404 pSamplerStateParams->Unorm.AddressW = MHW_GFX3DSTATE_TEXCOORDMODE_CLAMP;
2405 break;
2406 case VPHAL_HDR_SAMPLER_STATE_AVS_NEAREST_INDEX_G9:
2407 case VPHAL_HDR_SAMPLER_STATE_AVS_POLYPHASE_INDEX_G9:
2408 pSamplerStateParams->bInUse = pHdrState->bNeed3DSampler? false: true;
2409 pSamplerStateParams->SamplerType = MHW_SAMPLER_TYPE_AVS;
2410 pSamplerStateParams->Avs.bHdcDwEnable = true;
2411 pSamplerStateParams->Avs.b8TapAdaptiveEnable = false;
2412 pSamplerStateParams->Avs.bEnableAVS = true;
2413 pSamplerStateParams->Avs.WeakEdgeThr = DETAIL_WEAK_EDGE_THRESHOLD;
2414 pSamplerStateParams->Avs.StrongEdgeThr = DETAIL_STRONG_EDGE_THRESHOLD;
2415 pSamplerStateParams->Avs.StrongEdgeWght = DETAIL_STRONG_EDGE_WEIGHT;
2416 pSamplerStateParams->Avs.RegularWght = DETAIL_REGULAR_EDGE_WEIGHT;
2417 pSamplerStateParams->Avs.NonEdgeWght = DETAIL_NON_EDGE_WEIGHT;
2418
2419 if (pHdrState->pSrcSurf[0] &&
2420 pHdrState->pSrcSurf[0]->pIEFParams &&
2421 pRenderData->pIEFParams &&
2422 pRenderData->pIEFParams->bEnabled)
2423 {
2424 pHdrState->pfnSetIefStates(pHdrState, pRenderData, pSamplerStateParams);
2425 }
2426
2427 if (i == VPHAL_HDR_SAMPLER_STATE_AVS_NEAREST_INDEX_G9)
2428 {
2429 pSamplerStateParams->Unorm.SamplerFilterMode = MHW_SAMPLER_FILTER_NEAREST;
2430 pSamplerStateParams->Avs.pMhwSamplerAvsTableParam = &pHdrState->mhwSamplerAvsTableParam[0];
2431
2432 pHdrState->pfnSetSamplerAvsTable(
2433 pRenderHal,
2434 pSamplerStateParams,
2435 pRenderData->pAVSParameters[0],
2436 pRenderData->PrimaryLayerFormat,
2437 1.0f,
2438 1.0f,
2439 CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP);
2440 }
2441
2442 if (i == VPHAL_HDR_SAMPLER_STATE_AVS_POLYPHASE_INDEX_G9)
2443 {
2444 pSamplerStateParams->Avs.pMhwSamplerAvsTableParam = &pHdrState->mhwSamplerAvsTableParam[0];
2445
2446 pHdrState->pfnSetSamplerAvsTable(
2447 pRenderHal,
2448 pSamplerStateParams,
2449 pRenderData->pAVSParameters[1],
2450 pRenderData->PrimaryLayerFormat,
2451 pRenderData->fPrimaryLayerScaleX,
2452 pRenderData->fPrimaryLayerScaleY,
2453 CHROMA_SITING_HORZ_LEFT | CHROMA_SITING_VERT_TOP);
2454 }
2455 default:
2456 break;
2457 }
2458 }
2459
2460 eStatus = pRenderHal->pfnSetSamplerStates(
2461 pRenderHal,
2462 pRenderData->iMediaID,
2463 &pRenderData->SamplerStateParams[0],
2464 VPHAL_HDR_SAMPLER_STATE_NUM);
2465
2466 finish:
2467 return eStatus;
2468 }
2469
2470 //!
2471 //! \brief Setup HDR CURBE data
2472 //! \details Setup HDR CURBE data
2473 //! \param PVPHAL_HDR_STATE pHdrState
2474 //! [in] Poniter to HDR state
2475 //! \param PVPHAL_HDR_RENDER_DATA pRenderData
2476 //! [in] Poniter to HDR render data
2477 //! \param int32_t* piCurbeOffsetOut
2478 //! [Out] Curbe offset
2479 //! \return MOS_STATUS
2480 //! MOS_STATUS_SUCCESS if successful, otherwise
2481 //!
VpHal_HdrLoadStaticData_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData,int32_t * piCurbeOffsetOut)2482 MOS_STATUS VpHal_HdrLoadStaticData_g9(
2483 PVPHAL_HDR_STATE pHdrState,
2484 PVPHAL_HDR_RENDER_DATA pRenderData,
2485 int32_t* piCurbeOffsetOut)
2486 {
2487 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2488 MEDIA_WALKER_HDR_STATIC_DATA_G9 HDRStatic = g_cInit_MEDIA_STATIC_HDR_g9;
2489 PRENDERHAL_INTERFACE pRenderHal = nullptr;
2490 PVPHAL_SURFACE pSource = nullptr;
2491 VPHAL_HDR_FORMAT_DESCRIPTOR_G9 FormatDescriptor = VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW_G9;
2492 VPHAL_HDR_ROTATION_G9 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0_G9;
2493 VPHAL_HDR_TWO_LAYER_OPTION_G9 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
2494 uint32_t ChromaSiting = 0;
2495 bool bChannelSwap = false;
2496 bool bBypassIEF = true;
2497 bool b3dLut = false;
2498 uint32_t uiSamplerStateIndex = 0;
2499 uint32_t uiSamplerStateIndex2= 0;
2500 uint16_t wAlpha = 0;
2501 uint32_t i = 0;
2502 uint32_t dwDestRectWidth = 0;
2503 uint32_t dwDestRectHeight = 0; // Target rectangle Width Height
2504
2505 float fScaleX = 0.0f, fScaleY = 0.0f; // x,y scaling factor
2506 float fStepX = 0.0f, fStepY = 0.0f; // x,y scaling steps
2507 float fOriginX = 0.0f, fOriginY = 0.0f; // x,y layer origin
2508 float fShiftX = 0.0f, fShiftY = 0.0f; // x,y shift
2509
2510 VPHAL_RENDER_CHK_NULL(pHdrState);
2511 VPHAL_RENDER_CHK_NULL(pHdrState->pRenderHal);
2512 VPHAL_RENDER_CHK_NULL(pRenderData);
2513 VPHAL_RENDER_CHK_NULL(piCurbeOffsetOut);
2514
2515 pRenderHal = pHdrState->pRenderHal;
2516 HdrTwoLayerOp = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
2517 HdrRotation = VPHAL_HDR_LAYER_ROTATION_0_G9;
2518 wAlpha = 0x0ff;
2519 uiSamplerStateIndex = uiSamplerStateIndex2 = 0;
2520
2521 for (i = 0; i < pHdrState->uSourceCount; i++)
2522 {
2523 if (i >= VPHAL_MAX_HDR_INPUT_LAYER)
2524 {
2525 eStatus = MOS_STATUS_INVALID_PARAMETER;
2526 goto finish;
2527 }
2528
2529 pSource = pHdrState->pSrcSurf[i];
2530 VPHAL_RENDER_CHK_NULL(pSource);
2531
2532 bChannelSwap = false;
2533 bBypassIEF = true;
2534
2535 fShiftX = 0;
2536 fShiftY = 0;
2537
2538 // Source rectangle is pre-rotated, destination rectangle is post-rotated.
2539 if (pSource->Rotation == VPHAL_ROTATION_IDENTITY ||
2540 pSource->Rotation == VPHAL_ROTATION_180 ||
2541 pSource->Rotation == VPHAL_MIRROR_HORIZONTAL ||
2542 pSource->Rotation == VPHAL_MIRROR_VERTICAL)
2543 {
2544 fScaleX = (float)(pSource->rcDst.right - pSource->rcDst.left) /
2545 (float)(pSource->rcSrc.right - pSource->rcSrc.left);
2546 fScaleY = (float)(pSource->rcDst.bottom - pSource->rcDst.top) /
2547 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top);
2548 }
2549 else
2550 {
2551 // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 ||
2552 // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
2553 fScaleX = (float)(pSource->rcDst.right - pSource->rcDst.left) /
2554 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top);
2555 fScaleY = (float)(pSource->rcDst.bottom - pSource->rcDst.top) /
2556 (float)(pSource->rcSrc.right - pSource->rcSrc.left);
2557 }
2558
2559 if (fScaleX == 1.0f && fScaleY == 1.0f && pSource->ScalingMode == VPHAL_SCALING_BILINEAR)
2560 {
2561 pSource->ScalingMode = VPHAL_SCALING_NEAREST;
2562 }
2563
2564 if (pSource->ScalingMode == VPHAL_SCALING_AVS)
2565 {
2566 uiSamplerStateIndex = VPHAL_HDR_AVS_SAMPLER_STATE_ADAPTIVE;
2567
2568 if (pSource->Format == Format_P010 ||
2569 pSource->Format == Format_P016)
2570 {
2571 uiSamplerStateIndex2 = VPHAL_HDR_AVS_SAMPLER_STATE_ADAPTIVE;
2572 }
2573 }
2574 else if (pSource->ScalingMode == VPHAL_SCALING_BILINEAR)
2575 {
2576 uiSamplerStateIndex = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
2577
2578 if (pSource->Format == Format_P010 ||
2579 pSource->Format == Format_P016)
2580 {
2581 uiSamplerStateIndex2 = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
2582 }
2583
2584 fShiftX = VPHAL_HW_LINEAR_SHIFT;
2585 fShiftY = VPHAL_HW_LINEAR_SHIFT;
2586 }
2587 else
2588 {
2589 uiSamplerStateIndex = VPHAL_HDR_3D_SAMPLER_STATE_NEAREST;
2590
2591 if (pSource->Format == Format_P010 ||
2592 pSource->Format == Format_P016)
2593 {
2594 uiSamplerStateIndex2 = VPHAL_HDR_3D_SAMPLER_STATE_BILINEAR;
2595 }
2596
2597 fShiftX = VPHAL_HW_LINEAR_SHIFT;
2598 fShiftY = VPHAL_HW_LINEAR_SHIFT;
2599 }
2600
2601 // Normalize source co-ordinates using the width and height programmed
2602 // in surface state. step X, Y pre-rotated
2603 // Source rectangle is pre-rotated, destination rectangle is post-rotated.
2604 if (pSource->Rotation == VPHAL_ROTATION_IDENTITY ||
2605 pSource->Rotation == VPHAL_ROTATION_180 ||
2606 pSource->Rotation == VPHAL_MIRROR_HORIZONTAL ||
2607 pSource->Rotation == VPHAL_MIRROR_VERTICAL)
2608 {
2609 fStepX = ((pSource->rcSrc.right - pSource->rcSrc.left) * 1.0f) /
2610 ((pSource->rcDst.right - pSource->rcDst.left) > 0 ?
2611 (pSource->rcDst.right - pSource->rcDst.left) : 1);
2612 fStepY = ((float)(pSource->rcSrc.bottom - pSource->rcSrc.top)) /
2613 ((pSource->rcDst.bottom - pSource->rcDst.top) > 0 ?
2614 (float)(pSource->rcDst.bottom - pSource->rcDst.top) : 1.0f);
2615 }
2616 else
2617 {
2618 // VPHAL_ROTATION_90 || VPHAL_ROTATION_270 ||
2619 // VPHAL_ROTATE_90_MIRROR_HORIZONTAL || VPHAL_ROTATE_90_MIRROR_VERTICAL
2620 fStepX = ((pSource->rcSrc.right - pSource->rcSrc.left) * 1.0f) /
2621 ((pSource->rcDst.bottom - pSource->rcDst.top) > 0 ?
2622 (pSource->rcDst.bottom - pSource->rcDst.top) : 1);
2623 fStepY = ((float)(pSource->rcSrc.bottom - pSource->rcSrc.top)) /
2624 ((pSource->rcDst.right - pSource->rcDst.left) > 0 ?
2625 (float)(pSource->rcDst.right - pSource->rcDst.left) : 1.0f);
2626 }
2627
2628 dwDestRectWidth = pHdrState->pTargetSurf[0]->dwWidth;
2629 dwDestRectHeight = pHdrState->pTargetSurf[0]->dwHeight;
2630
2631 switch (pSource->Rotation)
2632 {
2633 case VPHAL_ROTATION_IDENTITY:
2634 // Coordinate adjustment for render target coordinates (0,0)
2635 fShiftX -= pSource->rcDst.left;
2636 fShiftY -= pSource->rcDst.top;
2637 break;
2638 case VPHAL_ROTATION_90:
2639 // Coordinate adjustment for 90 degree rotation
2640 fShiftX -= (float)pSource->rcDst.top;
2641 fShiftY -= (float)dwDestRectWidth -
2642 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleX -
2643 (float)pSource->rcDst.left;
2644 break;
2645 case VPHAL_ROTATION_180:
2646 // Coordinate adjustment for 180 degree rotation
2647 fShiftX -= (float)dwDestRectWidth -
2648 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleX -
2649 (float)pSource->rcDst.left;
2650 fShiftY -= (float)dwDestRectHeight -
2651 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleY -
2652 (float)pSource->rcDst.top;
2653 break;
2654 case VPHAL_ROTATION_270:
2655 // Coordinate adjustment for 270 degree rotation
2656 fShiftX -= (float)dwDestRectHeight -
2657 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleY -
2658 (float)pSource->rcDst.top;
2659 fShiftY -= (float)pSource->rcDst.left;
2660 break;
2661 case VPHAL_MIRROR_HORIZONTAL:
2662 // Coordinate adjustment for horizontal mirroring
2663 fShiftX -= (float)dwDestRectWidth -
2664 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleX -
2665 (float)pSource->rcDst.left;
2666 fShiftY -= pSource->rcDst.top;
2667 break;
2668 case VPHAL_MIRROR_VERTICAL:
2669 // Coordinate adjustment for vertical mirroring
2670 fShiftX -= pSource->rcDst.left;
2671 fShiftY -= (float)dwDestRectHeight -
2672 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleY -
2673 (float)pSource->rcDst.top;
2674 break;
2675 case VPHAL_ROTATE_90_MIRROR_HORIZONTAL:
2676 // Coordinate adjustment for rotating 90 and horizontal mirroring
2677 fShiftX -= (float)pSource->rcDst.top;
2678 fShiftY -= (float)pSource->rcDst.left;
2679 break;
2680 case VPHAL_ROTATE_90_MIRROR_VERTICAL:
2681 default:
2682 // Coordinate adjustment for rotating 90 and vertical mirroring
2683 fShiftX -= (float)dwDestRectHeight -
2684 (float)(pSource->rcSrc.right - pSource->rcSrc.left) * fScaleY -
2685 (float)pSource->rcDst.top;
2686 fShiftY -= (float)dwDestRectWidth -
2687 (float)(pSource->rcSrc.bottom - pSource->rcSrc.top) * fScaleX -
2688 (float)pSource->rcDst.left;
2689 break;
2690 } // switch
2691
2692 fOriginX = ((float) pSource->rcSrc.left + fShiftX * fStepX) / (float)MOS_MIN(pSource->dwWidth, (uint32_t)pSource->rcSrc.right);
2693 fOriginY = ((float) pSource->rcSrc.top + fShiftY * fStepY) / (float)MOS_MIN(pSource->dwHeight, (uint32_t)pSource->rcSrc.bottom);
2694
2695 fStepX /= MOS_MIN(pSource->dwWidth, (uint32_t)pSource->rcSrc.right);
2696 fStepY /= MOS_MIN(pSource->dwHeight, (uint32_t)pSource->rcSrc.bottom);
2697
2698 FormatDescriptor = VpHal_HdrGetFormatDescriptor_g9(pSource->Format);
2699
2700 if (FormatDescriptor == VPHAL_HDR_FORMAT_DESCRIPTOR_UNKNOW_G9)
2701 {
2702 VPHAL_RENDER_ASSERTMESSAGE("Unsupported hdr input format");
2703 eStatus = MOS_STATUS_INVALID_PARAMETER;
2704 goto finish;
2705 }
2706
2707 // Chroma siting setting in curbe data will only take effect in 1x scaling case when 3D sampler is being used
2708 // For other cases, Chroma siting will be performed by AVS coefficients, and the here will be ignored by kernel
2709 ChromaSiting = VpHal_HdrGetHdrChromaSiting_g9(pSource->ChromaSiting);
2710
2711 if (pSource->Format == Format_B10G10R10A2 ||
2712 pSource->Format == Format_A8R8G8B8 ||
2713 pSource->Format == Format_X8R8G8B8 ||
2714 pSource->Format == Format_A16R16G16B16F)
2715 {
2716 bChannelSwap = true;
2717 }
2718
2719 if (pSource->pIEFParams)
2720 {
2721 if (pSource->pIEFParams->bEnabled)
2722 {
2723 bBypassIEF = false;
2724 }
2725 }
2726
2727 HdrRotation = VpHal_HdrGetHdrRotation_g9(pSource->Rotation);
2728
2729 b3dLut = (pHdrState->LUTMode[i] == VPHAL_HDR_LUT_MODE_3D ? true : false);
2730
2731 if (pSource->SurfType == SURF_IN_PRIMARY)
2732 {
2733 if (b3dLut)
2734 {
2735 pHdrState->Reporting.GetFeatures().hdrMode = (VPHAL_HDR_MODE)(((uint32_t)pHdrState->Reporting.GetFeatures().hdrMode) | VPHAL_HDR_MODE_3DLUT_MASK);
2736 }
2737 }
2738
2739 switch (i)
2740 {
2741 case 0:
2742 HDRStatic.DW0.HorizontalFrameOriginLayer0 = fOriginX;
2743 HDRStatic.DW8.VerticalFrameOriginLayer0 = fOriginY;
2744 HDRStatic.DW16.HorizontalScalingStepRatioLayer0 = fStepX;
2745 HDRStatic.DW24.VerticalScalingStepRatioLayer0 = fStepY;
2746 HDRStatic.DW32.LeftCoordinateRectangleLayer0 = pSource->rcDst.left;
2747 HDRStatic.DW32.TopCoordinateRectangleLayer0 = pSource->rcDst.top;
2748 HDRStatic.DW40.RightCoordinateRectangleLayer0 = pSource->rcDst.right - 1;
2749 HDRStatic.DW40.BottomCoordinateRectangleLayer0 = pSource->rcDst.bottom - 1;
2750 HDRStatic.DW48.FormatDescriptorLayer0 = FormatDescriptor;
2751 HDRStatic.DW48.ChromaSittingLocationLayer0 = ChromaSiting;
2752 HDRStatic.DW48.ChannelSwapEnablingFlagLayer0 = bChannelSwap;
2753 HDRStatic.DW48.IEFBypassEnablingFlagLayer0 = bBypassIEF;
2754 HDRStatic.DW48.RotationAngleMirrorDirectionLayer0 = HdrRotation;
2755 HDRStatic.DW48.SamplerIndexFirstPlaneLayer0 = uiSamplerStateIndex;
2756 if (pSource->Format == Format_P010 ||
2757 pSource->Format == Format_P016)
2758 {
2759 HDRStatic.DW48.SamplerIndexSecondThirdPlaneLayer0 = uiSamplerStateIndex2;
2760 }
2761 HDRStatic.DW48.CCMExtensionEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2762 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2763 HDRStatic.DW48.ToneMappingEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].PWLFEnable;
2764 HDRStatic.DW48.PriorCSCEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2765 HDRStatic.DW48.EOTF1DLUTEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].EOTFEnable;
2766 HDRStatic.DW48.CCMEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].CCMEnable;
2767 HDRStatic.DW48.OETF1DLUTEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].OETFEnable;
2768 HDRStatic.DW48.PostCSCEnablingFlagLayer0 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2769 HDRStatic.DW48.Enabling3DLUTFlagLayer0 = b3dLut;
2770 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2771 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2772 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2773 {
2774 HDRStatic.DW56.ConstantBlendingAlphaFillColorLayer0 = wAlpha;
2775 }
2776 HDRStatic.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_COMP_G9;
2777 if (pSource->SurfType == SURF_IN_PRIMARY &&
2778 pSource->pBlendingParams &&
2779 pSource->pBlendingParams->BlendType == BLEND_SOURCE &&
2780 (IS_RGB_CSPACE(pSource->ColorSpace) || IS_COLOR_SPACE_BT2020_RGB(pSource->ColorSpace)))
2781 {
2782 // For PDVD alpha blending issue:
2783 // If first frame is sRGB/stRGB/BT2020RGB format delivered as primary layer
2784 // (which means main video content is in the first layer)
2785 // and blend-type set as source blending,
2786 // do source blending w/ bg, instead of setting as composite.
2787 HDRStatic.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_SBLEND_G9;
2788 }
2789 break;
2790 case 1:
2791 HDRStatic.DW1.HorizontalFrameOriginLayer1 = fOriginX;
2792 HDRStatic.DW9.VerticalFrameOriginLayer1 = fOriginY;
2793 HDRStatic.DW17.HorizontalScalingStepRatioLayer1 = fStepX;
2794 HDRStatic.DW25.VerticalScalingStepRatioLayer1 = fStepY;
2795 HDRStatic.DW33.LeftCoordinateRectangleLayer1 = pSource->rcDst.left;
2796 HDRStatic.DW33.TopCoordinateRectangleLayer1 = pSource->rcDst.top;
2797 HDRStatic.DW41.RightCoordinateRectangleLayer1 = pSource->rcDst.right - 1;
2798 HDRStatic.DW41.BottomCoordinateRectangleLayer1 = pSource->rcDst.bottom - 1;
2799 HDRStatic.DW49.FormatDescriptorLayer1 = FormatDescriptor;
2800 HDRStatic.DW49.ChromaSittingLocationLayer1 = ChromaSiting;
2801 HDRStatic.DW49.ChannelSwapEnablingFlagLayer1 = bChannelSwap;
2802 HDRStatic.DW49.IEFBypassEnablingFlagLayer1 = bBypassIEF;
2803 HDRStatic.DW49.RotationAngleMirrorDirectionLayer1 = HdrRotation;
2804 HDRStatic.DW49.SamplerIndexFirstPlaneLayer1 = uiSamplerStateIndex;
2805 if (pSource->Format == Format_P010 ||
2806 pSource->Format == Format_P016)
2807 {
2808 HDRStatic.DW49.SamplerIndexSecondThirdPlaneLayer1 = uiSamplerStateIndex2;
2809 }
2810 HDRStatic.DW49.CCMExtensionEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2811 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2812 HDRStatic.DW49.ToneMappingEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].PWLFEnable;
2813 HDRStatic.DW49.PriorCSCEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2814 HDRStatic.DW49.EOTF1DLUTEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].EOTFEnable;
2815 HDRStatic.DW49.CCMEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].CCMEnable;
2816 HDRStatic.DW49.OETF1DLUTEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].OETFEnable;
2817 HDRStatic.DW49.PostCSCEnablingFlagLayer1 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2818 HDRStatic.DW49.Enabling3DLUTFlagLayer1 = b3dLut;
2819 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2820 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2821 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2822 {
2823 HDRStatic.DW56.ConstantBlendingAlphaFillColorLayer1 = wAlpha;
2824 }
2825 HDRStatic.DW58.TwoLayerOperationLayer1 = HdrTwoLayerOp;
2826 break;
2827 case 2:
2828 HDRStatic.DW2.HorizontalFrameOriginLayer2 = fOriginX;
2829 HDRStatic.DW10.VerticalFrameOriginLayer2 = fOriginY;
2830 HDRStatic.DW18.HorizontalScalingStepRatioLayer2 = fStepX;
2831 HDRStatic.DW26.VerticalScalingStepRatioLayer2 = fStepY;
2832 HDRStatic.DW34.LeftCoordinateRectangleLayer2 = pSource->rcDst.left;
2833 HDRStatic.DW34.TopCoordinateRectangleLayer2 = pSource->rcDst.top;
2834 HDRStatic.DW42.RightCoordinateRectangleLayer2 = pSource->rcDst.right - 1;
2835 HDRStatic.DW42.BottomCoordinateRectangleLayer2 = pSource->rcDst.bottom - 1;
2836 HDRStatic.DW50.FormatDescriptorLayer2 = FormatDescriptor;
2837 HDRStatic.DW50.ChromaSittingLocationLayer2 = ChromaSiting;
2838 HDRStatic.DW50.ChannelSwapEnablingFlagLayer2 = bChannelSwap;
2839 HDRStatic.DW50.IEFBypassEnablingFlagLayer2 = bBypassIEF;
2840 HDRStatic.DW50.RotationAngleMirrorDirectionLayer2 = HdrRotation;
2841 HDRStatic.DW50.SamplerIndexFirstPlaneLayer2 = uiSamplerStateIndex;
2842 if (pSource->Format == Format_P010 ||
2843 pSource->Format == Format_P016)
2844 {
2845 HDRStatic.DW50.SamplerIndexSecondThirdPlaneLayer2 = uiSamplerStateIndex2;
2846 }
2847 HDRStatic.DW50.CCMExtensionEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2848 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2849 HDRStatic.DW50.ToneMappingEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].PWLFEnable;
2850 HDRStatic.DW50.PriorCSCEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2851 HDRStatic.DW50.EOTF1DLUTEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].EOTFEnable;
2852 HDRStatic.DW50.CCMEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].CCMEnable;
2853 HDRStatic.DW50.OETF1DLUTEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].OETFEnable;
2854 HDRStatic.DW50.PostCSCEnablingFlagLayer2 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2855 HDRStatic.DW50.Enabling3DLUTFlagLayer2 = b3dLut;
2856 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2857 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2858 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2859 {
2860 HDRStatic.DW56.ConstantBlendingAlphaFillColorLayer2 = wAlpha;
2861 }
2862 HDRStatic.DW58.TwoLayerOperationLayer2 = HdrTwoLayerOp;
2863 break;
2864 case 3:
2865 HDRStatic.DW3.HorizontalFrameOriginLayer3 = fOriginX;
2866 HDRStatic.DW11.VerticalFrameOriginLayer3 = fOriginY;
2867 HDRStatic.DW19.HorizontalScalingStepRatioLayer3 = fStepX;
2868 HDRStatic.DW27.VerticalScalingStepRatioLayer3 = fStepY;
2869 HDRStatic.DW35.LeftCoordinateRectangleLayer3 = pSource->rcDst.left;
2870 HDRStatic.DW35.TopCoordinateRectangleLayer3 = pSource->rcDst.top;
2871 HDRStatic.DW43.RightCoordinateRectangleLayer3 = pSource->rcDst.right - 1;
2872 HDRStatic.DW43.BottomCoordinateRectangleLayer3 = pSource->rcDst.bottom - 1;
2873 HDRStatic.DW51.FormatDescriptorLayer3 = FormatDescriptor;
2874 HDRStatic.DW51.ChromaSittingLocationLayer3 = ChromaSiting;
2875 HDRStatic.DW51.ChannelSwapEnablingFlagLayer3 = bChannelSwap;
2876 HDRStatic.DW51.IEFBypassEnablingFlagLayer3 = bBypassIEF;
2877 HDRStatic.DW51.RotationAngleMirrorDirectionLayer3 = HdrRotation;
2878 HDRStatic.DW51.SamplerIndexFirstPlaneLayer3 = uiSamplerStateIndex;
2879 if (pSource->Format == Format_P010 ||
2880 pSource->Format == Format_P016)
2881 {
2882 HDRStatic.DW51.SamplerIndexSecondThirdPlaneLayer3 = uiSamplerStateIndex2;
2883 }
2884 HDRStatic.DW51.CCMExtensionEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2885 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2886 HDRStatic.DW51.ToneMappingEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].PWLFEnable;
2887 HDRStatic.DW51.PriorCSCEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2888 HDRStatic.DW51.EOTF1DLUTEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].EOTFEnable;
2889 HDRStatic.DW51.CCMEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].CCMEnable;
2890 HDRStatic.DW51.OETF1DLUTEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].OETFEnable;
2891 HDRStatic.DW51.PostCSCEnablingFlagLayer3 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2892 HDRStatic.DW51.Enabling3DLUTFlagLayer3 = b3dLut;
2893 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2894 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2895 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2896 {
2897 HDRStatic.DW56.ConstantBlendingAlphaFillColorLayer3 = wAlpha;
2898 }
2899 HDRStatic.DW58.TwoLayerOperationLayer3 = HdrTwoLayerOp;
2900 break;
2901 case 4:
2902 HDRStatic.DW4.HorizontalFrameOriginLayer4 = fOriginX;
2903 HDRStatic.DW12.VerticalFrameOriginLayer4 = fOriginY;
2904 HDRStatic.DW20.HorizontalScalingStepRatioLayer4 = fStepX;
2905 HDRStatic.DW28.VerticalScalingStepRatioLayer4 = fStepY;
2906 HDRStatic.DW36.LeftCoordinateRectangleLayer4 = pSource->rcDst.left;
2907 HDRStatic.DW36.TopCoordinateRectangleLayer4 = pSource->rcDst.top;
2908 HDRStatic.DW44.RightCoordinateRectangleLayer4 = pSource->rcDst.right - 1;
2909 HDRStatic.DW44.BottomCoordinateRectangleLayer4 = pSource->rcDst.bottom - 1;
2910 HDRStatic.DW52.FormatDescriptorLayer4 = FormatDescriptor;
2911 HDRStatic.DW52.ChromaSittingLocationLayer4 = ChromaSiting;
2912 HDRStatic.DW52.ChannelSwapEnablingFlagLayer4 = bChannelSwap;
2913 HDRStatic.DW52.IEFBypassEnablingFlagLayer4 = bBypassIEF;
2914 HDRStatic.DW52.RotationAngleMirrorDirectionLayer4 = HdrRotation;
2915 HDRStatic.DW52.SamplerIndexFirstPlaneLayer4 = uiSamplerStateIndex;
2916 if (pSource->Format == Format_P010 ||
2917 pSource->Format == Format_P016)
2918 {
2919 HDRStatic.DW52.SamplerIndexSecondThirdPlaneLayer4 = uiSamplerStateIndex2;
2920 }
2921 HDRStatic.DW52.CCMExtensionEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2922 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2923 HDRStatic.DW52.ToneMappingEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].PWLFEnable;
2924 HDRStatic.DW52.PriorCSCEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2925 HDRStatic.DW52.EOTF1DLUTEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].EOTFEnable;
2926 HDRStatic.DW52.CCMEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].CCMEnable;
2927 HDRStatic.DW52.OETF1DLUTEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].OETFEnable;
2928 HDRStatic.DW52.PostCSCEnablingFlagLayer4 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2929 HDRStatic.DW52.Enabling3DLUTFlagLayer4 = b3dLut;
2930 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2931 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2932 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2933 {
2934 HDRStatic.DW57.ConstantBlendingAlphaFillColorLayer4 = wAlpha;
2935 }
2936 HDRStatic.DW59.TwoLayerOperationLayer4 = HdrTwoLayerOp;
2937 break;
2938 case 5:
2939 HDRStatic.DW5.HorizontalFrameOriginLayer5 = fOriginX;
2940 HDRStatic.DW13.VerticalFrameOriginLayer5 = fOriginY;
2941 HDRStatic.DW21.HorizontalScalingStepRatioLayer5 = fStepX;
2942 HDRStatic.DW29.VerticalScalingStepRatioLayer5 = fStepY;
2943 HDRStatic.DW37.LeftCoordinateRectangleLayer5 = pSource->rcDst.left;
2944 HDRStatic.DW37.TopCoordinateRectangleLayer5 = pSource->rcDst.top;
2945 HDRStatic.DW45.RightCoordinateRectangleLayer5 = pSource->rcDst.right - 1;
2946 HDRStatic.DW45.BottomCoordinateRectangleLayer5 = pSource->rcDst.bottom - 1;
2947 HDRStatic.DW53.FormatDescriptorLayer5 = FormatDescriptor;
2948 HDRStatic.DW53.ChromaSittingLocationLayer5 = ChromaSiting;
2949 HDRStatic.DW53.ChannelSwapEnablingFlagLayer5 = bChannelSwap;
2950 HDRStatic.DW53.IEFBypassEnablingFlagLayer5 = bBypassIEF;
2951 HDRStatic.DW53.RotationAngleMirrorDirectionLayer5 = HdrRotation;
2952 HDRStatic.DW53.SamplerIndexFirstPlaneLayer5 = uiSamplerStateIndex;
2953 if (pSource->Format == Format_P010 ||
2954 pSource->Format == Format_P016)
2955 {
2956 HDRStatic.DW53.SamplerIndexSecondThirdPlaneLayer5 = uiSamplerStateIndex2;
2957 }
2958 HDRStatic.DW53.CCMExtensionEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2959 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2960 HDRStatic.DW53.ToneMappingEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].PWLFEnable;
2961 HDRStatic.DW53.PriorCSCEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2962 HDRStatic.DW53.EOTF1DLUTEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].EOTFEnable;
2963 HDRStatic.DW53.CCMEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].CCMEnable;
2964 HDRStatic.DW53.OETF1DLUTEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].OETFEnable;
2965 HDRStatic.DW53.PostCSCEnablingFlagLayer5 = pHdrState->StageEnableFlags[i].PostCSCEnable;
2966 HDRStatic.DW53.Enabling3DLUTFlagLayer5 = b3dLut;
2967 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
2968 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
2969 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
2970 {
2971 HDRStatic.DW57.ConstantBlendingAlphaFillColorLayer5 = wAlpha;
2972 }
2973 HDRStatic.DW59.TwoLayerOperationLayer5 = HdrTwoLayerOp;
2974 break;
2975 case 6:
2976 HDRStatic.DW6.HorizontalFrameOriginLayer6 = fOriginX;
2977 HDRStatic.DW14.VerticalFrameOriginLayer6 = fOriginY;
2978 HDRStatic.DW22.HorizontalScalingStepRatioLayer6 = fStepX;
2979 HDRStatic.DW30.VerticalScalingStepRatioLayer6 = fStepY;
2980 HDRStatic.DW38.LeftCoordinateRectangleLayer6 = pSource->rcDst.left;
2981 HDRStatic.DW38.TopCoordinateRectangleLayer6 = pSource->rcDst.top;
2982 HDRStatic.DW46.RightCoordinateRectangleLayer6 = pSource->rcDst.right - 1;
2983 HDRStatic.DW46.BottomCoordinateRectangleLayer6 = pSource->rcDst.bottom - 1;
2984 HDRStatic.DW54.FormatDescriptorLayer6 = FormatDescriptor;
2985 HDRStatic.DW54.ChromaSittingLocationLayer6 = ChromaSiting;
2986 HDRStatic.DW54.ChannelSwapEnablingFlagLayer6 = bChannelSwap;
2987 HDRStatic.DW54.IEFBypassEnablingFlagLayer6 = bBypassIEF;
2988 HDRStatic.DW54.RotationAngleMirrorDirectionLayer6 = HdrRotation;
2989 HDRStatic.DW54.SamplerIndexFirstPlaneLayer6 = uiSamplerStateIndex;
2990 if (pSource->Format == Format_P010 ||
2991 pSource->Format == Format_P016)
2992 {
2993 HDRStatic.DW54.SamplerIndexSecondThirdPlaneLayer6 = uiSamplerStateIndex2;
2994 }
2995 HDRStatic.DW54.CCMExtensionEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
2996 pHdrState->StageEnableFlags[i].CCMExt2Enable;
2997 HDRStatic.DW54.ToneMappingEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].PWLFEnable;
2998 HDRStatic.DW54.PriorCSCEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
2999 HDRStatic.DW54.EOTF1DLUTEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].EOTFEnable;
3000 HDRStatic.DW54.CCMEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].CCMEnable;
3001 HDRStatic.DW54.OETF1DLUTEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].OETFEnable;
3002 HDRStatic.DW54.PostCSCEnablingFlagLayer6 = pHdrState->StageEnableFlags[i].PostCSCEnable;
3003 HDRStatic.DW54.Enabling3DLUTFlagLayer6 = b3dLut;
3004 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
3005 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
3006 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
3007 {
3008 HDRStatic.DW57.ConstantBlendingAlphaFillColorLayer6 = wAlpha;
3009 }
3010 HDRStatic.DW59.TwoLayerOperationLayer6 = HdrTwoLayerOp;
3011 break;
3012 case 7:
3013 HDRStatic.DW7.HorizontalFrameOriginLayer7 = fOriginX;
3014 HDRStatic.DW15.VerticalFrameOriginLayer7 = fOriginY;
3015 HDRStatic.DW23.HorizontalScalingStepRatioLayer7 = fStepX;
3016 HDRStatic.DW31.VerticalScalingStepRatioLayer7 = fStepY;
3017 HDRStatic.DW39.LeftCoordinateRectangleLayer7 = pSource->rcDst.left;
3018 HDRStatic.DW39.TopCoordinateRectangleLayer7 = pSource->rcDst.top;
3019 HDRStatic.DW47.RightCoordinateRectangleLayer7 = pSource->rcDst.right - 1;
3020 HDRStatic.DW47.BottomCoordinateRectangleLayer7 = pSource->rcDst.bottom - 1;
3021 HDRStatic.DW55.FormatDescriptorLayer7 = FormatDescriptor;
3022 HDRStatic.DW55.ChromaSittingLocationLayer7 = ChromaSiting;
3023 HDRStatic.DW55.ChannelSwapEnablingFlagLayer7 = bChannelSwap;
3024 HDRStatic.DW55.IEFBypassEnablingFlagLayer7 = bBypassIEF;
3025 HDRStatic.DW55.RotationAngleMirrorDirectionLayer7 = HdrRotation;
3026 HDRStatic.DW55.SamplerIndexFirstPlaneLayer7 = uiSamplerStateIndex;
3027 if (pSource->Format == Format_P010 ||
3028 pSource->Format == Format_P016)
3029 {
3030 HDRStatic.DW55.SamplerIndexSecondThirdPlaneLayer7 = uiSamplerStateIndex2;
3031 }
3032 HDRStatic.DW55.CCMExtensionEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].CCMExt1Enable ||
3033 pHdrState->StageEnableFlags[i].CCMExt2Enable;
3034 HDRStatic.DW55.ToneMappingEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].PWLFEnable;
3035 HDRStatic.DW55.PriorCSCEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].PriorCSCEnable;
3036 HDRStatic.DW55.EOTF1DLUTEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].EOTFEnable;
3037 HDRStatic.DW55.CCMEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].CCMEnable;
3038 HDRStatic.DW55.OETF1DLUTEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].OETFEnable;
3039 HDRStatic.DW55.PostCSCEnablingFlagLayer7 = pHdrState->StageEnableFlags[i].PostCSCEnable;
3040 HDRStatic.DW55.Enabling3DLUTFlagLayer7 = b3dLut;
3041 if (HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CBLEND_G9 ||
3042 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CSBLEND_G9 ||
3043 HdrTwoLayerOp == VPHAL_HDR_TWO_LAYER_OPTION_CPBLEND_G9)
3044 {
3045 HDRStatic.DW57.ConstantBlendingAlphaFillColorLayer7 = wAlpha;
3046 }
3047 HDRStatic.DW59.TwoLayerOperationLayer7 = HdrTwoLayerOp;
3048 break;
3049 default:
3050 VPHAL_RENDER_ASSERTMESSAGE("Invalid input layer number.");
3051 break;
3052 }
3053 }
3054
3055 FormatDescriptor = VpHal_HdrGetFormatDescriptor_g9(pHdrState->pTargetSurf[0]->Format);
3056 ChromaSiting = VpHal_HdrGetHdrChromaSiting_g9(pHdrState->pTargetSurf[0]->ChromaSiting);
3057
3058 if (pHdrState->pTargetSurf[0]->Format == Format_B10G10R10A2 ||
3059 pHdrState->pTargetSurf[0]->Format == Format_A8R8G8B8 ||
3060 pHdrState->pTargetSurf[0]->Format == Format_X8R8G8B8 ||
3061 pHdrState->pTargetSurf[0]->Format == Format_A16R16G16B16F)
3062 {
3063 bChannelSwap = true;
3064 }
3065 else
3066 {
3067 bChannelSwap = false;
3068 }
3069
3070 HDRStatic.DW62.DestinationWidth = pHdrState->pTargetSurf[0]->dwWidth;
3071 HDRStatic.DW62.DestinationHeight = pHdrState->pTargetSurf[0]->dwHeight;
3072 HDRStatic.DW63.TotalNumberInputLayers = pHdrState->uSourceCount;
3073
3074 if (0 == pHdrState->uSourceCount)
3075 {
3076 HDRStatic.DW32.LeftCoordinateRectangleLayer0 = pHdrState->pTargetSurf[0]->dwWidth + 16;
3077 HDRStatic.DW32.TopCoordinateRectangleLayer0 = pHdrState->pTargetSurf[0]->dwHeight + 16;
3078 HDRStatic.DW40.RightCoordinateRectangleLayer0 = pHdrState->pTargetSurf[0]->dwWidth + 16;
3079 HDRStatic.DW40.BottomCoordinateRectangleLayer0 = pHdrState->pTargetSurf[0]->dwHeight + 16;
3080 HDRStatic.DW58.TwoLayerOperationLayer0 = VPHAL_HDR_TWO_LAYER_OPTION_COMP_G9;
3081 }
3082
3083 HDRStatic.DW63.FormatDescriptorDestination = FormatDescriptor;
3084 HDRStatic.DW63.ChromaSittingLocationDestination = ChromaSiting;
3085 HDRStatic.DW63.ChannelSwapEnablingFlagDestination = bChannelSwap;
3086
3087 // Set Background color (use cspace of first layer)
3088 if (pHdrState->pColorFillParams)
3089 {
3090 VPHAL_COLOR_SAMPLE_8 Src, Dst;
3091 VPHAL_CSPACE src_cspace, dst_cspace;
3092
3093 Src.dwValue = pHdrState->pColorFillParams->Color;
3094
3095 // get src and dst colorspaces
3096 src_cspace = pHdrState->pColorFillParams->CSpace;
3097 dst_cspace = pHdrState->pTargetSurf[0]->ColorSpace;
3098
3099 // Convert BG color only if not done so before. CSC is expensive!
3100 if (VpHal_CSC_8(&Dst, &Src, src_cspace, dst_cspace))
3101 {
3102 HDRStatic.DW60.FixedPointFillColorRVChannel = Dst.R << 8;
3103 HDRStatic.DW60.FixedPointFillColorGYChannel = Dst.G << 8;
3104 HDRStatic.DW61.FixedPointFillColorBUChannel = Dst.B << 8;
3105 HDRStatic.DW61.FixedPointFillColorAlphaChannel = Dst.A << 8;
3106 }
3107 else
3108 {
3109 HDRStatic.DW60.FixedPointFillColorRVChannel = Src.R << 8;
3110 HDRStatic.DW60.FixedPointFillColorGYChannel = Src.G << 8;
3111 HDRStatic.DW61.FixedPointFillColorBUChannel = Src.B << 8;
3112 HDRStatic.DW61.FixedPointFillColorAlphaChannel = Src.A << 8;
3113 }
3114 }
3115
3116 *piCurbeOffsetOut = pRenderHal->pfnLoadCurbeData(
3117 pRenderHal,
3118 pRenderData->pMediaState,
3119 &HDRStatic,
3120 sizeof(MEDIA_WALKER_HDR_STATIC_DATA_G9));
3121
3122 if (*piCurbeOffsetOut < 0)
3123 {
3124 eStatus = MOS_STATUS_UNKNOWN;
3125 goto finish;
3126 }
3127 pRenderData->iCurbeOffset = *piCurbeOffsetOut;
3128
3129 finish:
3130 return eStatus;
3131 }
3132
3133 //!
3134 //! \brief Get Hdr iTouch Split Frame Portion number
3135 //! \details Get Hdr iTouch Split Frame Portion number is Gen9 platform specific
3136 //! \param PVPHAL_HDR_STATE pHdrState
3137 //! [in/out] Pointer to HDR state
3138 //! \return MOS_STATUS
3139 //!
VpHal_HdrGetSplitFramePortion_g9(PVPHAL_HDR_STATE pHdrState)3140 MOS_STATUS VpHal_HdrGetSplitFramePortion_g9(
3141 PVPHAL_HDR_STATE pHdrState)
3142 {
3143 MOS_STATUS eStatus;
3144 uint32_t dwPixels;
3145
3146 VPHAL_RENDER_CHK_NULL(pHdrState);
3147 VPHAL_RENDER_CHK_NULL(pHdrState->pTargetSurf[0]);
3148
3149 dwPixels = pHdrState->pTargetSurf[0]->dwWidth * pHdrState->pTargetSurf[0]->dwHeight;
3150 //pHdrState->uiPortions = MOS_ROUNDUP_DIVIDE(dwPixels, g_Hdr_iTouc_Pixel_Throughput_g9[pHdrState->uSourceCount - 1]);
3151
3152 if (dwPixels <= 1920 * 1080)
3153 {
3154 pHdrState->uiSplitFramePortions = 2;
3155 }
3156 else if (dwPixels <= 3840 * 2160)
3157 {
3158 pHdrState->uiSplitFramePortions = 4;
3159 }
3160 else
3161 {
3162 pHdrState->uiSplitFramePortions = 8;
3163 }
3164
3165 eStatus = MOS_STATUS_SUCCESS;
3166
3167 finish:
3168 return eStatus;
3169 }
3170
3171 //!
3172 //! \brief Initializes interface for HDR
3173 //! \details Initializes interface for HDR which is Gen9 platform specific
3174 //! \param PVPHAL_HDR_STATE pHdrState
3175 //! [in] Pointer to HDR state
3176 //! \return MOS_STATUS
3177 //!
VpHal_HdrInitInterface_g9(PVPHAL_HDR_STATE pHdrState)3178 MOS_STATUS VpHal_HdrInitInterface_g9(
3179 PVPHAL_HDR_STATE pHdrState)
3180 {
3181 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3182 int32_t i = 0;
3183
3184 VPHAL_RENDER_CHK_NULL(pHdrState);
3185
3186 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
3187 {
3188 pHdrState->uSourceBindingTableIndex[i] = VPHAL_HDR_BTINDEX_LAYER0_G9 + i * VPHAL_HDR_BTINDEX_PER_LAYER0_G9;
3189 }
3190
3191 for (i = 0; i < VPHAL_MAX_HDR_OUTPUT_LAYER; i++)
3192 {
3193 pHdrState->uTargetBindingTableIndex[i] = VPHAL_HDR_BTINDEX_RENDERTARGET_G9 + i * VPHAL_HDR_BTINDEX_PER_TARGET_G9;
3194 }
3195
3196 for (i = 0; i < VPHAL_MAX_HDR_INPUT_LAYER; i++)
3197 {
3198 pHdrState->LUTMode[i] = VPHAL_HDR_LUT_MODE_NONE;
3199 pHdrState->EOTFGamma[i] = VPHAL_GAMMA_NONE;
3200 pHdrState->OETFGamma[i] = VPHAL_GAMMA_NONE;
3201 pHdrState->CCM[i] = VPHAL_HDR_CCM_NONE;
3202 pHdrState->CCMExt1[i] = VPHAL_HDR_CCM_NONE;
3203 pHdrState->CCMExt2[i] = VPHAL_HDR_CCM_NONE;
3204 pHdrState->HdrMode[i] = VPHAL_HDR_MODE_NONE;
3205 pHdrState->PriorCSC[i] = VPHAL_HDR_CSC_NONE;
3206 pHdrState->PostCSC[i] = VPHAL_HDR_CSC_NONE;
3207 }
3208
3209 // Allocate AVS parameters
3210 VpHal_RenderInitAVSParams(&pHdrState->AVSParameters[0],
3211 POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9,
3212 POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9);
3213
3214 VpHal_RenderInitAVSParams(&pHdrState->AVSParameters[1],
3215 POLYPHASE_Y_COEFFICIENT_TABLE_SIZE_G9,
3216 POLYPHASE_UV_COEFFICIENT_TABLE_SIZE_G9);
3217
3218 pHdrState->dwOetfSurfaceWidth = VPHAL_HDR_OETF_1DLUT_WIDTH;
3219 pHdrState->dwOetfSurfaceWidth = VPHAL_HDR_OETF_1DLUT_HEIGHT;
3220 pHdrState->pKernelParamTable = (PRENDERHAL_KERNEL_PARAM)g_Hdr_KernelParam_g9;
3221 pHdrState->pfnAllocateResources = VpHal_HdrAllocateResources_g9;
3222 pHdrState->pfnSetupSurfaceStates = VpHal_HdrSetupSurfaceStates_g9;
3223 pHdrState->pfnIsInputFormatSupported = VpHal_HdrIsInputFormatSupported_g9;
3224 pHdrState->pfnIsOutputFormatSupported = VpHal_HdrIsOutputFormatSupported_g9;
3225 pHdrState->pfnLoadStaticData = VpHal_HdrLoadStaticData_g9;
3226 pHdrState->pfnGetKernelParam = VpHal_HdrGetKernelParam_g9;
3227 pHdrState->pfnInitOETF1DLUT = VpHal_HdrInitOETF1DLUT_g9;
3228 pHdrState->pfnInitCoeff = VpHal_HdrInitCoeff_g9;
3229 pHdrState->pfnSetSamplerStates = VpHal_HdrSetSamplerStates_g9;
3230 pHdrState->pfnSetIefStates = VpHal_HdrSetIefStates_g9;
3231 pHdrState->pfnSetSamplerAvsTable = VpHal_HdrSetSamplerAvsTableParam_g9;
3232 pHdrState->pfnFreeResources = VpHal_HdrFreeResources_g9;
3233 pHdrState->pfnGetSplitFramePortion = VpHal_HdrGetSplitFramePortion_g9;
3234
3235 pHdrState->pfnSetupPreSurfaceStates = VpHal_HdrSetupPreProcessSurfaceStates_g9;
3236 pHdrState->pfnLoadPreStaticData = VpHal_HdrPreprocessLoadStaticData_g9;
3237
3238 eStatus = MOS_STATUS_SUCCESS;
3239
3240 finish:
3241 return eStatus;
3242 }
3243
3244 //!
3245 //! \brief Destroy interface for HDR
3246 //! \details Destroy interface for HDR which is Gen9 platform specific
3247 //! \param PVPHAL_HDR_STATE pHdrState
3248 //! [in] Pointer to HDR state
3249 //! \return MOS_STATUS
3250 //!
3251
VpHal_HdrDestroyInterface_g9(PVPHAL_HDR_STATE pHdrState)3252 MOS_STATUS VpHal_HdrDestroyInterface_g9(
3253 PVPHAL_HDR_STATE pHdrState)
3254 {
3255 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3256 VPHAL_RENDER_CHK_NULL(pHdrState);
3257
3258 VpHal_RenderDestroyAVSParams(&pHdrState->AVSParameters[0]);
3259 VpHal_RenderDestroyAVSParams(&pHdrState->AVSParameters[1]);
3260
3261 finish:
3262 return eStatus;
3263 }
3264
3265 //!
3266 //! \brief Set HDR Ief State
3267 //! \details Set HDR Ief State
3268 //! \param PVPHAL_HDR_STATE pHdrState
3269 //! [in] Pointer to HDR state
3270 //! \param PVPHAL_HDR_RENDER_DATA pRenderData
3271 //! [in] Pointer to render data
3272 //! \param PMHW_SAMPLER_STATE_PARAM pSamplerStateParams
3273 //! [in] Pointer to Sampler State Parameters
3274 //! \return MOS_STATUS
3275 //!
VpHal_HdrSetIefStates_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData,PMHW_SAMPLER_STATE_PARAM pSamplerStateParams)3276 MOS_STATUS VpHal_HdrSetIefStates_g9(
3277 PVPHAL_HDR_STATE pHdrState,
3278 PVPHAL_HDR_RENDER_DATA pRenderData,
3279 PMHW_SAMPLER_STATE_PARAM pSamplerStateParams)
3280 {
3281 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
3282
3283 VPHAL_RENDER_CHK_NULL(pHdrState);
3284 VPHAL_RENDER_CHK_NULL(pSamplerStateParams);
3285 VPHAL_RENDER_CHK_NULL(pRenderData);
3286
3287 MOS_UNUSED(pRenderData);
3288 {
3289 Ief ief(pHdrState->pSrcSurf[0]);
3290 VPHAL_RENDER_CHK_STATUS(ief.SetHwState(pSamplerStateParams));
3291 }
3292
3293 finish:
3294 return eStatus;
3295 }
3296
3297 //!
3298 //! \brief Initiate EOTF Surface for HDR
3299 //! \details Initiate EOTF Surface for HDR
3300 //! \param PVPHAL_HDR_STATE pHdrStatee
3301 //! [in] Pointer to HDR state
3302 //! \param int32_t iIndex
3303 //! [in] input surface index
3304 //! \param PVPHAL_SURFACE pOETF1DLUTSurface
3305 //! [in] Pointer to OETF 1D LUT Surface
3306 //! \return MOS_STATUS
3307 //!
VpHal_HdrInitOETF1DLUT_g9(PVPHAL_HDR_STATE pHdrState,int32_t iIndex,PVPHAL_SURFACE pOETF1DLUTSurface)3308 MOS_STATUS VpHal_HdrInitOETF1DLUT_g9(
3309 PVPHAL_HDR_STATE pHdrState,
3310 int32_t iIndex,
3311 PVPHAL_SURFACE pOETF1DLUTSurface)
3312 {
3313 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3314 PMOS_INTERFACE pOsInterface = nullptr;
3315 uint32_t i = 0;
3316 uint16_t *pSrcOetfLut = nullptr;
3317 uint8_t *pDstOetfLut = nullptr;
3318 MOS_LOCK_PARAMS LockFlags = {};
3319 PVPHAL_SURFACE pTargetSurf = (PVPHAL_SURFACE)pHdrState->pTargetSurf[0];
3320
3321 VPHAL_PUBLIC_CHK_NULL(pHdrState);
3322 VPHAL_PUBLIC_CHK_NULL(pOETF1DLUTSurface);
3323 pOsInterface = pHdrState->pOsInterface;
3324
3325 VPHAL_PUBLIC_CHK_NULL(pOsInterface);
3326
3327 MOS_ZeroMemory(&LockFlags, sizeof(MOS_LOCK_PARAMS));
3328
3329 LockFlags.WriteOnly = 1;
3330
3331 // Lock the surface for writing
3332 pDstOetfLut = (uint8_t *)pOsInterface->pfnLockResource(
3333 pOsInterface,
3334 &(pOETF1DLUTSurface->OsResource),
3335 &LockFlags);
3336
3337 VPHAL_RENDER_CHK_NULL(pDstOetfLut);
3338 VPHAL_RENDER_CHK_NULL(pHdrState->pTargetSurf[0]);
3339 VPHAL_RENDER_CHK_NULL(pHdrState->pTargetSurf[0]);
3340
3341 // Hdr kernel require 0 to 1 floating point color value
3342 // To transfer the value of 16bit integer OETF table to 0 to 1 floating point
3343 // We need to divide the table with 2^16 - 1
3344 if ((pTargetSurf->pHDRParams &&
3345 (pTargetSurf->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR ||
3346 pTargetSurf->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_HDR)) ||
3347 !pTargetSurf->pHDRParams)
3348 {
3349 if (pHdrState->OETFGamma[iIndex] == VPHAL_GAMMA_SRGB)
3350 {
3351 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_sRGB_FP16_g9;
3352 }
3353 else
3354 {
3355 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_BT709_FP16_g9;
3356 }
3357
3358 for (i = 0;
3359 i < pOETF1DLUTSurface->dwHeight;
3360 i++, pDstOetfLut += pOETF1DLUTSurface->dwPitch, pSrcOetfLut += pOETF1DLUTSurface->dwWidth)
3361 {
3362 MOS_SecureMemcpy(pDstOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->dwWidth,
3363 pSrcOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->dwWidth);
3364 }
3365 }
3366 else if (pTargetSurf->pHDRParams &&
3367 pTargetSurf->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
3368 {
3369 if (pHdrState->HdrMode[iIndex] == VPHAL_HDR_MODE_INVERSE_TONE_MAPPING)
3370 {
3371 const float fStretchFactor = 0.01f;
3372 VpHal_Generate2SegmentsOETFLUT(fStretchFactor, OETF2084, pHdrState->OetfSmpteSt2084);
3373 pSrcOetfLut = pHdrState->OetfSmpteSt2084;
3374 }
3375 else // pHdrState->HdrMode[iIndex] == VPHAL_HDR_MODE_H2H
3376 {
3377 pSrcOetfLut = (uint16_t *)g_Hdr_ColorCorrect_OETF_SMPTE_ST2084_3Segs_FP16_g9;
3378 }
3379
3380 for (i = 0;
3381 i < pOETF1DLUTSurface->dwHeight;
3382 i++, pDstOetfLut += pOETF1DLUTSurface->dwPitch, pSrcOetfLut += pOETF1DLUTSurface->dwWidth)
3383 {
3384 MOS_SecureMemcpy(pDstOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->dwWidth,
3385 pSrcOetfLut, sizeof(uint16_t) * pOETF1DLUTSurface->dwWidth);
3386 }
3387 }
3388 else
3389 {
3390 VPHAL_RENDER_ASSERTMESSAGE("Invalid EOTF setting for tone mapping");
3391 eStatus = MOS_STATUS_INVALID_PARAMETER;
3392 goto finish;
3393 }
3394
3395 pOsInterface->pfnUnlockResource(
3396 pOsInterface,
3397 &(pOETF1DLUTSurface->OsResource));
3398
3399 eStatus = MOS_STATUS_SUCCESS;
3400
3401 finish:
3402 return eStatus;
3403 }
3404
3405 //!
3406 //! \brief Get the Kernel Params
3407 //! \details Get the Kernel Params, including kernel unique ID, KDT Index
3408 //! \param VPHAL_HDR_KERNELID HdrKernelID
3409 //! [in] HDR Kernel ID
3410 //! \param int32_t* pKUIDOut
3411 //! [out] Kernel unique ID
3412 //! \param int32_t* pKDTIndexOut
3413 //! [out] KDT index
3414 //! \param PVPHAL_PERFTAG pPerfTag
3415 //! [out] Performance tag
3416 //! \return MOS_STATUS
3417 //! MOS_STATUS_SUCCESS if successful, otherwise failed
3418 //!
VpHal_HdrGetKernelParam_g9(uint32_t HdrKernelID,int32_t * pKUIDOut,int32_t * pKDTIndexOut)3419 MOS_STATUS VpHal_HdrGetKernelParam_g9(
3420 uint32_t HdrKernelID,
3421 int32_t* pKUIDOut,
3422 int32_t* pKDTIndexOut)
3423 {
3424 MOS_STATUS eStatus;
3425
3426 VPHAL_PUBLIC_CHK_NULL(pKUIDOut);
3427 VPHAL_PUBLIC_CHK_NULL(pKDTIndexOut);
3428
3429 eStatus = MOS_STATUS_SUCCESS;
3430
3431 if (HdrKernelID == KERNEL_HDR_MANDATORY)
3432 {
3433 *pKUIDOut = IDR_VP_HDR_mandatory;
3434 *pKDTIndexOut = KERNEL_HDR_MANDATORY_G9;
3435 }
3436 else if (HdrKernelID == KERNEL_HDR_PREPROCESS)
3437 {
3438 *pKUIDOut = IDR_VP_HDR_preprocess;
3439 *pKDTIndexOut = KERNEL_HDR_PREPROCESS_G9;
3440 }
3441 else
3442 {
3443 VPHAL_RENDER_ASSERTMESSAGE("Kernel Not found.");
3444 eStatus = MOS_STATUS_INVALID_PARAMETER;
3445 }
3446
3447 finish:
3448 return eStatus;
3449 }
3450
3451 //!
3452 //! \brief HDR PreProcess Surface State Setup
3453 //! \details Set up surface state used in HDR PreProcess, and bind the surface to pointed binding table entry.
3454 //! \param PVPHAL_HDR_STATE pHdrState
3455 // [in/out] Pointer to HDR state
3456 //! \param PVPHAL_HDR_RENDER_DATA pRenderData
3457 //! [in] Pointer to hdr render data.
3458 //! \return MOS_STATUS
3459 //! MOS_STATUS_SUCCESS if successful, otherwise failed
3460 //!
VpHal_HdrSetupPreProcessSurfaceStates_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData)3461 MOS_STATUS VpHal_HdrSetupPreProcessSurfaceStates_g9(
3462 PVPHAL_HDR_STATE pHdrState,
3463 PVPHAL_HDR_RENDER_DATA pRenderData)
3464 {
3465 PVPHAL_SURFACE pSurfaceTemp = nullptr;
3466 PRENDERHAL_SURFACE pRenderHalSurfaceTemp = nullptr;
3467 PRENDERHAL_INTERFACE pRenderHal = nullptr;
3468 MOS_STATUS eStatus = MOS_STATUS_UNKNOWN;
3469 RENDERHAL_SURFACE_STATE_PARAMS SurfaceParams = {};
3470 int32_t iBTentry = 0;
3471
3472 VPHAL_RENDER_CHK_NULL(pHdrState);
3473 VPHAL_RENDER_CHK_NULL(pRenderData);
3474
3475 eStatus = MOS_STATUS_UNKNOWN;
3476 pRenderHal = pHdrState->pRenderHal;
3477 VPHAL_RENDER_CHK_NULL(pRenderHal);
3478
3479 pSurfaceTemp = &pHdrState->CoeffSurface;
3480 pRenderHalSurfaceTemp = &pHdrState->RenderHalCoeffSurface;
3481
3482 MOS_ZeroMemory(&SurfaceParams, sizeof(SurfaceParams));
3483 SurfaceParams.Type = pRenderHal->SurfaceTypeDefault;
3484 SurfaceParams.bRenderTarget = false;
3485 SurfaceParams.Boundary = RENDERHAL_SS_BOUNDARY_ORIGINAL;
3486 SurfaceParams.bWidth16Align = false;
3487 SurfaceParams.MemObjCtl = pHdrState->SurfMemObjCtl.CoeffSurfMemObjCtl;
3488 iBTentry = 16;
3489
3490 if (!Mos_ResourceIsNull(&pSurfaceTemp->OsResource))
3491 {
3492 VPHAL_RENDER_CHK_STATUS(VpHal_CommonSetSurfaceForHwAccess(
3493 pRenderHal,
3494 pSurfaceTemp,
3495 pRenderHalSurfaceTemp,
3496 &SurfaceParams,
3497 pRenderData->iBindingTable,
3498 iBTentry,
3499 false));
3500 }
3501 else
3502 {
3503 VPHAL_RENDER_ASSERTMESSAGE("Null resource found");
3504 eStatus = MOS_STATUS_NULL_POINTER;
3505 goto finish;
3506 }
3507
3508 finish:
3509 return eStatus;
3510 }
3511
3512 //!
3513 //! \brief Setup HDR PreProcess CURBE data
3514 //! \details Setup HDR PreProcess CURBE data
3515 //! \param PVPHAL_HDR_STATE pHdrState
3516 //! [in] Poniter to HDR state
3517 //! \param PVPHAL_HDR_RENDER_DATA pRenderData
3518 //! [in] Poniter to HDR render data
3519 //! \param int32_t* piCurbeOffsetOut
3520 //! [Out] Curbe offset
3521 //! \return MOS_STATUS
3522 //! MOS_STATUS_SUCCESS if successful, otherwise
3523 //!
VpHal_HdrPreprocessLoadStaticData_g9(PVPHAL_HDR_STATE pHdrState,PVPHAL_HDR_RENDER_DATA pRenderData,int32_t * piCurbeOffsetOut)3524 MOS_STATUS VpHal_HdrPreprocessLoadStaticData_g9(
3525 PVPHAL_HDR_STATE pHdrState,
3526 PVPHAL_HDR_RENDER_DATA pRenderData,
3527 int32_t* piCurbeOffsetOut)
3528 {
3529 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3530 PRENDERHAL_INTERFACE pRenderHal = nullptr;
3531 PVPHAL_SURFACE pSource = nullptr;
3532 PVPHAL_SURFACE pTarget = nullptr;
3533
3534 MEDIA_WALKER_HDR_PREPROCESS_STATIC_DATA_G9 HDRStatic;
3535 MOS_ZeroMemory(&HDRStatic, sizeof(MEDIA_WALKER_HDR_PREPROCESS_STATIC_DATA_G9));
3536
3537 uint32_t uiMaxCLL[VPHAL_MAX_HDR_INPUT_LAYER] = { 0 };
3538 uint32_t uiMaxDLL[VPHAL_MAX_HDR_INPUT_LAYER] = { 0 };
3539 HDR_TMMODE tmMode[VPHAL_MAX_HDR_INPUT_LAYER] = { PREPROCESS_TM_MAX };
3540
3541 VPHAL_RENDER_CHK_NULL(pHdrState);
3542 VPHAL_RENDER_CHK_NULL(pHdrState->pRenderHal);
3543 VPHAL_RENDER_CHK_NULL(pRenderData);
3544 VPHAL_RENDER_CHK_NULL(piCurbeOffsetOut);
3545
3546 pRenderHal = pHdrState->pRenderHal;
3547
3548 for (uint32_t i = 0; i < pHdrState->uSourceCount; i++)
3549 {
3550 if (i >= VPHAL_MAX_HDR_INPUT_LAYER)
3551 {
3552 eStatus = MOS_STATUS_INVALID_PARAMETER;
3553 goto finish;
3554 }
3555
3556 pSource = pHdrState->pSrcSurf[i];
3557 if (pSource)
3558 {
3559 uiMaxCLL[i] = (pSource->pHDRParams) ? pSource->pHDRParams->MaxCLL : 0;
3560 }
3561
3562 switch (pHdrState->HdrMode[i])
3563 {
3564 case VPHAL_HDR_MODE_TONE_MAPPING: // H2S
3565 tmMode[i] = PREPROCESS_TM_H2S;
3566 break;
3567 case VPHAL_HDR_MODE_H2H: // H2S
3568 tmMode[i] = PREPROCESS_TM_H2H;
3569 break;
3570 case VPHAL_HDR_MODE_INVERSE_TONE_MAPPING: // S2H
3571 tmMode[i] = PREPROCESS_TM_S2H;
3572 break;
3573 default:
3574 break;
3575 }
3576
3577 pTarget = pHdrState->pTargetSurf[0];
3578 if (pTarget)
3579 {
3580 uiMaxDLL[0] = (pTarget->pHDRParams) ? pTarget->pHDRParams->max_display_mastering_luminance : 0;
3581 }
3582
3583 HDRStatic.uiMaxCLL[i] = uiMaxCLL[i];
3584 HDRStatic.uiMaxDLL[i] = uiMaxDLL[0];
3585 HDRStatic.uiTMMode[i] = tmMode[i];
3586 VPHAL_RENDER_NORMALMESSAGE("StreamIndex: %d, maxCLL: %d, maxDLL: %d, TMMode: %d", i, HDRStatic.uiMaxCLL[i], HDRStatic.uiMaxDLL[i], HDRStatic.uiTMMode[i]);
3587 }
3588 HDRStatic.OutputCoeffIndex = 16;
3589
3590 *piCurbeOffsetOut = pRenderHal->pfnLoadCurbeData(
3591 pRenderHal,
3592 pRenderData->pMediaState,
3593 &HDRStatic,
3594 sizeof(MEDIA_WALKER_HDR_PREPROCESS_STATIC_DATA_G9));
3595
3596 if (*piCurbeOffsetOut < 0)
3597 {
3598 eStatus = MOS_STATUS_UNKNOWN;
3599 goto finish;
3600 }
3601 pRenderData->iCurbeOffset = *piCurbeOffsetOut;
3602
3603 finish:
3604 return eStatus;
3605 }
3606