Debian Codegraph @

media_driver/agnostic/gen9_skl/codec/hal/codechal_fei_hevc_g9_skl.cpp

raw
1 /*
2 * Copyright (c) 2018, 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 codechal_fei_hevc_g9_skl.cpp
24 //! \brief HEVC FEI dual-pipe encoder for GEN9 SKL.
25 //!
26
27 #include "codechal_fei_hevc_g9_skl.h"
28 #include "igcodeckrn_g9.h"
29 #include "codeckrnheader.h"
30
31 #define GPUMMU_WA_PADDING (64 * 1024)
32
33 //! HEVC encoder kernel header structure for G9 SKL
34 struct CODECHAL_ENC_HEVC_KERNEL_HEADER_FEI_G9_SKL
35 {
36 int nKernelCount; //!< Total number of kernels
37
38 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_2xDownSampling_Kernel; //!< 2x down sampling kernel
39 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_32x32_PU_ModeDecision_Kernel; //!< Intra 32x32 PU mode decision kernel
40 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_16x16_PU_SADComputation_Kernel; //!< Intra 16x16 PU SAD computation kernel
41 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_16x16_PU_ModeDecision_Kernel; //!< Intra 16x16 PU mode decision kernel
42 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_8x8_PU_Kernel; //!< Intra 8x8 PU mode decision kernel
43 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_8x8_PU_FMode_Kernel; //!< Intra 8x8 PU final mode decision kernel
44 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_PB_32x32_PU_IntraCheck; //!< P/B 32x32 PU intra mode check kernel
45 CODECHAL_KERNEL_HEADER HEVC_FEI_LCUEnc_PB_MB; //!< P/B MbEnc Kernel
46 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_DS4HME; //!< 4x Scaling kernel
47 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_P_HME; //!< P frame HME kernel
48 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_B_HME; //!< B frame HME kernel
49 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_I_COARSE; //!< Intra coarse kernel
50 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_PB_Pak; //!< P/B frame PAK kernel
51 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_BRC_Blockcopy; //!< BRC blockcopy kerenel
52 CODECHAL_KERNEL_HEADER Hevc_FEI_LCUEnc_DS_Combined; //!< Down scale and format conversion kernel for 10 bit for KBL
53 CODECHAL_KERNEL_HEADER HEVC_FEI_LCUEnc_P_MB; //!< P frame MbEnc kernel
54 };
55
56 using PCODECHAL_ENC_HEVC_KERNEL_HEADER_FEI_G9_SKL = struct CODECHAL_ENC_HEVC_KERNEL_HEADER_FEI_G9_SKL*;
57
58 //! HEVC encoder FEI intra 8x8 PU final mode decision kernel curbe for GEN9
59 struct CODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9
60 {
61 union {
62 struct {
63 uint32_t FrameWidth : MOS_BITFIELD_RANGE(0, 15);
64 uint32_t FrameHeight : MOS_BITFIELD_RANGE(16, 31);
65 };
66 uint32_t Value;
67 } DW0;
68
69 union {
70 struct {
71 uint32_t SliceType : MOS_BITFIELD_RANGE(0, 1);
72 uint32_t PuType : MOS_BITFIELD_RANGE(2, 3);
73 uint32_t PakReordingFlag : MOS_BITFIELD_BIT(4);
74 uint32_t ReservedMBZ : MOS_BITFIELD_BIT(5);
75 uint32_t LCUType : MOS_BITFIELD_BIT(6);
76 uint32_t ScreenContentFlag : MOS_BITFIELD_BIT(7);
77 uint32_t IntraRefreshEn : MOS_BITFIELD_RANGE(8, 9);
78 uint32_t EnableRollingIntra : MOS_BITFIELD_BIT(10);
79 uint32_t HalfUpdateMixedLCU : MOS_BITFIELD_BIT(11);
80 uint32_t Reserved_12_23 : MOS_BITFIELD_RANGE(12, 23);
81 uint32_t EnableIntraEarlyExit : MOS_BITFIELD_BIT(24);
82 uint32_t BRCEnable : MOS_BITFIELD_BIT(25);
83 uint32_t LCUBRCEnable : MOS_BITFIELD_BIT(26);
84 uint32_t ROIEnable : MOS_BITFIELD_BIT(27);
85 uint32_t FASTSurveillanceFlag : MOS_BITFIELD_BIT(28);
86 uint32_t EnableFlexibleParam : MOS_BITFIELD_BIT(29);
87 uint32_t EnableQualityImprovement : MOS_BITFIELD_BIT(30);
88 uint32_t EnableDebugDump : MOS_BITFIELD_BIT(31);
89 };
90 uint32_t Value;
91 } DW1;
92
93 union {
94 struct {
95 uint32_t LambdaForLuma;
96 };
97 uint32_t Value;
98 } DW2;
99
100 union {
101 // For inter frame or enable statictics data dump
102 struct {
103 uint32_t LambdaForDistCalculation;
104 };
105 uint32_t Value;
106 } DW3;
107
108 union {
109 struct {
110 uint32_t ModeCostFor8x8PU_TU8;
111 };
112 uint32_t Value;
113 } DW4;
114
115 union {
116 struct {
117 uint32_t ModeCostFor8x8PU_TU4;
118 };
119 uint32_t Value;
120 } DW5;
121
122 union {
123 struct {
124 uint32_t SATD16x16PuThreshold : MOS_BITFIELD_RANGE(0, 15);
125 uint32_t BiasFactorToward8x8 : MOS_BITFIELD_RANGE(16, 31);
126 };
127 uint32_t Value;
128 } DW6;
129
130 union {
131 struct {
132 uint32_t Qp : MOS_BITFIELD_RANGE(0, 15);
133 uint32_t QpForInter : MOS_BITFIELD_RANGE(16, 31);
134 };
135 uint32_t Value;
136 } DW7;
137
138 union {
139 struct {
140 uint32_t SimplifiedFlagForInter : MOS_BITFIELD_BIT(0);
141 uint32_t EnableStatsDataDump : MOS_BITFIELD_BIT(1);
142 uint32_t Reserved_2_7 : MOS_BITFIELD_RANGE(2, 7);
143 uint32_t KBLControlFlag : MOS_BITFIELD_BIT(8);
144 uint32_t Reserved_9_31 : MOS_BITFIELD_RANGE(9, 31);
145 };
146 uint32_t Value;
147 } DW8;
148
149 union {
150 struct {
151 uint32_t IntraRefreshMBNum : MOS_BITFIELD_RANGE(0, 15);
152 uint32_t IntraRefreshUnitInMB : MOS_BITFIELD_RANGE(16, 23);
153 uint32_t IntraRefreshQPDelta : MOS_BITFIELD_RANGE(24, 31);
154 };
155 uint32_t Value;
156 } DW9;
157
158 union {
159 struct {
160 uint32_t Reserved;
161 };
162 uint32_t Value;
163 } DW10;
164
165 union {
166 struct {
167 uint32_t Reserved;
168 };
169 uint32_t Value;
170 } DW11;
171
172 union {
173 struct {
174 uint32_t Reserved;
175 };
176 uint32_t Value;
177 } DW12;
178
179 union {
180 struct {
181 uint32_t Reserved;
182 };
183 uint32_t Value;
184 } DW13;
185
186 union {
187 struct {
188 uint32_t Reserved;
189 };
190 uint32_t Value;
191 } DW14;
192
193 union {
194 struct {
195 uint32_t Reserved;
196 };
197 uint32_t Value;
198 } DW15;
199
200 union {
201 struct {
202 uint32_t BTI_PAK_Object;
203 };
204 uint32_t Value;
205 } DW16;
206
207 union {
208 struct {
209 uint32_t BTI_VME_8x8_Mode;
210 };
211 uint32_t Value;
212 } DW17;
213
214 union {
215 struct {
216 uint32_t BTI_Intra_Mode;
217 };
218 uint32_t Value;
219 } DW18;
220
221 union {
222 struct {
223 uint32_t BTI_PAK_Command;
224 };
225 uint32_t Value;
226 } DW19;
227
228 union {
229 struct {
230 uint32_t BTI_Slice_Map;
231 };
232 uint32_t Value;
233 } DW20;
234
235 union {
236 struct {
237 uint32_t BTI_IntraDist;
238 };
239 uint32_t Value;
240 } DW21;
241
242 union {
243 struct {
244 uint32_t BTI_BRC_Input;
245 };
246 uint32_t Value;
247 } DW22;
248
249 union {
250 struct {
251 uint32_t BTI_Simplest_Intra;
252 };
253 uint32_t Value;
254 } DW23;
255
256 union {
257 struct {
258 uint32_t BTI_LCU_Qp_Surface;
259 };
260 uint32_t Value;
261 } DW24;
262
263 union {
264 struct {
265 uint32_t BTI_BRC_Data;
266 };
267 uint32_t Value;
268 } DW25;
269
270 union {
271 //Output (for inter and statictics data dump only)
272 struct {
273 uint32_t BTI_Haar_Dist16x16;
274 };
275 uint32_t Value;
276 } DW26;
277
278 union {
279 // This surface should take the statistics surface from Hevc_LCUEnc_I_32x32_PU_ModeDecision as input
280 struct {
281 uint32_t BTI_Stats_Data;
282 };
283 uint32_t Value;
284 } DW27;
285
286 union {
287 // Frame level Statistics data surface
288 struct {
289 uint32_t BTI_Frame_Stats_Data;
290 };
291 uint32_t Value;
292 } DW28;
293
294 union {
295 // Frame level CTB Distortion data surface
296 struct {
297 uint32_t BTI_CTB_Distortion_Surface;
298 };
299 uint32_t Value;
300 } DW29;
301
302 union {
303 struct {
304 uint32_t BTI_Debug;
305 };
306 uint32_t Value;
307 } DW30;
308 };
309
310 using PCODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9 = struct CODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9*;
311 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9)) == 31);
312
313 //! HEVC encoder FEI B 32x32 PU intra check kernel curbe for GEN9
314 struct CODECHAL_FEI_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9
315 {
316 union {
317 struct {
318 uint32_t FrameWidth : MOS_BITFIELD_RANGE(0, 15);
319 uint32_t FrameHeight : MOS_BITFIELD_RANGE(16, 31);
320 };
321 uint32_t Value;
322 } DW0;
323
324 union {
325 struct {
326 uint32_t SliceType : MOS_BITFIELD_RANGE(0, 1);
327 uint32_t Reserved : MOS_BITFIELD_RANGE(2, 7);
328 uint32_t Log2MinTUSize : MOS_BITFIELD_RANGE(8, 15);
329 uint32_t Flags : MOS_BITFIELD_RANGE(16, 23);
330 uint32_t EnableIntraEarlyExit : MOS_BITFIELD_BIT(24);
331 uint32_t HMEEnable : MOS_BITFIELD_BIT(25);
332 uint32_t FASTSurveillanceFlag : MOS_BITFIELD_BIT(26);
333 uint32_t Res_27_30 : MOS_BITFIELD_RANGE(27, 30);
334 uint32_t EnableDebugDump : MOS_BITFIELD_BIT(31);
335 };
336 uint32_t Value;
337 } DW1;
338
339 union {
340 struct {
341 uint32_t QpValue : MOS_BITFIELD_RANGE(0, 15);
342 uint32_t QpMultiplier : MOS_BITFIELD_RANGE(16, 31);
343 };
344 uint32_t Value;
345 } DW2;
346
347 union {
348 struct {
349 uint32_t Reserved;
350 };
351 uint32_t Value;
352 } DW3;
353
354 union {
355 struct {
356 uint32_t Reserved;
357 };
358 uint32_t Value;
359 } DW4;
360
361 union {
362 struct {
363 uint32_t Reserved;
364 };
365 uint32_t Value;
366 } DW5;
367
368 union {
369 struct {
370 uint32_t Reserved;
371 };
372 uint32_t Value;
373 } DW6;
374
375 union {
376 struct {
377 uint32_t Reserved;
378 };
379 uint32_t Value;
380 } DW7;
381
382 union {
383 struct {
384 uint32_t BTI_Per32x32PuIntraCheck;
385 };
386 uint32_t Value;
387 } DW8;
388
389 union {
390 struct {
391 uint32_t BTI_Src_Y;
392 };
393 uint32_t Value;
394 } DW9;
395
396 union {
397 struct {
398 uint32_t BTI_Src_Y2X;
399 };
400 uint32_t Value;
401 } DW10;
402
403 union {
404 struct {
405 uint32_t BTI_Slice_Map;
406 };
407 uint32_t Value;
408 } DW11;
409
410 union {
411 struct {
412 uint32_t BTI_VME_Y2X;
413 };
414 uint32_t Value;
415 } DW12;
416
417 union {
418 struct {
419 uint32_t BTI_Simplest_Intra; // output only
420 };
421 uint32_t Value;
422 } DW13;
423
424 union {
425 struct {
426 uint32_t BTI_HME_MVPred;
427 };
428 uint32_t Value;
429 } DW14;
430
431 union {
432 struct {
433 uint32_t BTI_HME_Dist;
434 };
435 uint32_t Value;
436 } DW15;
437
438 union {
439 struct {
440 uint32_t BTI_LCU_Skip;
441 };
442 uint32_t Value;
443 } DW16;
444
445 union {
446 struct {
447 uint32_t BTI_Debug;
448 };
449 uint32_t Value;
450 } DW17;
451 };
452
453 using PCODECHAL_FEI_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9 = struct CODECHAL_FEI_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9;
454 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_FEI_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9)) == 18);
455
456 //! HEVC encoder FEI B Pak kernel curbe for GEN9
457 struct CODECHAL_FEI_HEVC_B_PAK_CURBE_G9
458 {
459 union
460 {
461 struct
462 {
463 uint32_t FrameWidth : MOS_BITFIELD_RANGE(0, 15);
464 uint32_t FrameHeight : MOS_BITFIELD_RANGE(16, 31);
465 };
466 struct
467 {
468 uint32_t Value;
469 };
470 } DW0;
471
472 union
473 {
474 struct
475 {
476 uint32_t Qp : MOS_BITFIELD_RANGE(0, 7);
477 uint32_t Res_8_15 : MOS_BITFIELD_RANGE(8, 15);
478 uint32_t MaxVmvR : MOS_BITFIELD_RANGE(16, 31);
479 };
480 struct
481 {
482 uint32_t Value;
483 };
484 } DW1;
485
486 union
487 {
488 struct
489 {
490 uint32_t SliceType : MOS_BITFIELD_RANGE(0, 1);
491 uint32_t EnableWA : MOS_BITFIELD_BIT( 2);
492 uint32_t Res_3_7 : MOS_BITFIELD_RANGE(3, 7);
493 uint32_t SimplestIntraEnable : MOS_BITFIELD_BIT(8);
494 uint32_t BrcEnable : MOS_BITFIELD_BIT(9);
495 uint32_t LcuBrcEnable : MOS_BITFIELD_BIT(10);
496 uint32_t ROIEnable : MOS_BITFIELD_BIT(11);
497 uint32_t FASTSurveillanceFlag : MOS_BITFIELD_BIT(12);
498 uint32_t EnableRollingIntra : MOS_BITFIELD_BIT(13);
499 uint32_t Res_14 : MOS_BITFIELD_BIT(14);
500 uint32_t EnableQualityImprovement : MOS_BITFIELD_BIT(15);
501 uint32_t KBLControlFlag : MOS_BITFIELD_BIT(16);
502 uint32_t Res_17_30 : MOS_BITFIELD_RANGE(17, 30);
503 uint32_t ScreenContent : MOS_BITFIELD_BIT(31);
504 };
505 struct
506 {
507 uint32_t Value;
508 };
509 } DW2;
510
511 union
512 {
513 struct
514 {
515 uint32_t IntraRefreshMBNum : MOS_BITFIELD_RANGE(0, 15);
516 uint32_t IntraRefreshUnitInMB : MOS_BITFIELD_RANGE(16, 23);
517 uint32_t IntraRefreshQPDelta : MOS_BITFIELD_RANGE(24, 31);
518 };
519 struct
520 {
521 uint32_t Value;
522 };
523 } DW3;
524
525 union
526 {
527 struct
528 {
529 uint32_t Reserved;
530 };
531 struct
532 {
533 uint32_t Value;
534 };
535 } DW4_15[12];
536
537 union
538 {
539 struct
540 {
541 uint32_t BTI_CU_Record;
542 };
543 struct
544 {
545 uint32_t Value;
546 };
547 } DW16;
548
549 union
550 {
551 struct
552 {
553 uint32_t BTI_PAK_Obj;
554 };
555 struct
556 {
557 uint32_t Value;
558 };
559 } DW17;
560
561 union
562 {
563 struct
564 {
565 uint32_t BTI_Slice_Map;
566 };
567 struct
568 {
569 uint32_t Value;
570 };
571 } DW18;
572
573 union
574 {
575 struct
576 {
577 uint32_t BTI_Brc_Input;
578 };
579 struct
580 {
581 uint32_t Value;
582 };
583 } DW19;
584
585 union
586 {
587 struct
588 {
589 uint32_t BTI_LCU_Qp;
590 };
591 struct
592 {
593 uint32_t Value;
594 };
595 } DW20;
596
597 union
598 {
599 struct
600 {
601 uint32_t BTI_Brc_Data;
602 };
603 struct
604 {
605 uint32_t Value;
606 };
607 } DW21;
608
609 union
610 {
611 struct
612 {
613 uint32_t BTI_MB_Data;
614 };
615 struct
616 {
617 uint32_t Value;
618 };
619 } DW22;
620
621 union
622 {
623 struct
624 {
625 uint32_t BTI_MVP_Surface;
626 };
627 struct
628 {
629 uint32_t Value;
630 };
631 } DW23;
632
633 union
634 {
635 struct
636 {
637 uint32_t BTI_WA_PAK_Data;
638 };
639 struct
640 {
641 uint32_t Value;
642 };
643 } DW24;
644
645 union
646 {
647 struct
648 {
649 uint32_t BTI_WA_PAK_Obj;
650 };
651 struct
652 {
653 uint32_t Value;
654 };
655 } DW25;
656
657 union
658 {
659 struct
660 {
661 uint32_t BTI_Debug;
662 };
663 struct
664 {
665 uint32_t Value;
666 };
667 } DW26;
668
669 };
670
671 using PCODECHAL_FEI_HEVC_B_PAK_CURBE_G9 = struct CODECHAL_FEI_HEVC_B_PAK_CURBE_G9*;
672 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_FEI_HEVC_B_PAK_CURBE_G9)) == 27);
673
674 //! HEVC encoder B MBEnc kernel curbe for GEN9
675 struct CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9
676 {
677 // DW0
678 union
679 {
680 struct
681 {
682 uint32_t SkipModeEn : MOS_BITFIELD_BIT(0);
683 uint32_t AdaptiveEn : MOS_BITFIELD_BIT(1);
684 uint32_t BiMixDis : MOS_BITFIELD_BIT(2);
685 uint32_t : MOS_BITFIELD_RANGE(3, 4);
686 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT(5);
687 uint32_t : MOS_BITFIELD_BIT(6);
688 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT(7);
689 uint32_t : MOS_BITFIELD_RANGE(8, 23);
690 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE(24, 31);
691 };
692 struct
693 {
694 uint32_t Value;
695 };
696 } DW0;
697
698 // DW1
699 union
700 {
701 struct
702 {
703 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE(0, 5);
704 uint32_t : MOS_BITFIELD_RANGE(6, 15);
705 uint32_t BiWeight : MOS_BITFIELD_RANGE(16, 21);
706 uint32_t : MOS_BITFIELD_RANGE(22, 27);
707 uint32_t UniMixDisable : MOS_BITFIELD_BIT(28);
708 uint32_t : MOS_BITFIELD_RANGE(29, 31);
709 };
710 struct
711 {
712 uint32_t Value;
713 };
714 } DW1;
715
716 // DW2
717 union
718 {
719 struct
720 {
721 uint32_t LenSP : MOS_BITFIELD_RANGE(0, 7);
722 uint32_t MaxNumSU : MOS_BITFIELD_RANGE(8, 15);
723 uint32_t PicWidth : MOS_BITFIELD_RANGE(16, 31);
724 };
725 struct
726 {
727 uint32_t Value;
728 };
729 } DW2;
730
731 // DW3
732 union
733 {
734 struct
735 {
736 uint32_t SrcSize : MOS_BITFIELD_RANGE(0, 1);
737 uint32_t : MOS_BITFIELD_RANGE(2, 3);
738 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE(4, 5);
739 uint32_t SrcAccess : MOS_BITFIELD_BIT(6);
740 uint32_t RefAccess : MOS_BITFIELD_BIT(7);
741 uint32_t SearchCtrl : MOS_BITFIELD_RANGE(8, 10);
742 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT(11);
743 uint32_t SubPelMode : MOS_BITFIELD_RANGE(12, 13);
744 uint32_t SkipType : MOS_BITFIELD_BIT(14);
745 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT(15);
746 uint32_t InterChromaMode : MOS_BITFIELD_BIT(16);
747 uint32_t FTEnable : MOS_BITFIELD_BIT(17);
748 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT(18);
749 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT(19);
750 uint32_t InterSAD : MOS_BITFIELD_RANGE(20, 21);
751 uint32_t IntraSAD : MOS_BITFIELD_RANGE(22, 23);
752 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE(24, 30);
753 uint32_t : MOS_BITFIELD_BIT(31);
754 };
755 struct
756 {
757 uint32_t Value;
758 };
759 } DW3;
760
761 union
762 {
763 struct
764 {
765 uint32_t PicHeightMinus1 : MOS_BITFIELD_RANGE(0, 15);
766 uint32_t Res_16_22 : MOS_BITFIELD_RANGE(16,22);
767 uint32_t EnableQualityImprovement : MOS_BITFIELD_BIT(23);
768 uint32_t EnableDebug : MOS_BITFIELD_BIT(24);
769 uint32_t EnableFlexibleParam : MOS_BITFIELD_BIT(25);
770 uint32_t EnableStatsDataDump : MOS_BITFIELD_BIT(26);
771 uint32_t Res_27 : MOS_BITFIELD_BIT(27);
772 uint32_t HMEEnable : MOS_BITFIELD_BIT(28);
773 uint32_t SliceType : MOS_BITFIELD_RANGE(29, 30);
774 uint32_t UseActualRefQPValue : MOS_BITFIELD_BIT(31);
775 };
776 struct
777 {
778 uint32_t Value;
779 };
780 } DW4;
781
782 // DW5
783 union
784 {
785 struct
786 {
787 uint32_t Res_0_15 : MOS_BITFIELD_RANGE(0, 15);
788 uint32_t RefWidth : MOS_BITFIELD_RANGE(16, 23);
789 uint32_t RefHeight : MOS_BITFIELD_RANGE(24, 31);
790 };
791 struct
792 {
793 uint32_t Value;
794 };
795 } DW5;
796
797 union
798 {
799 struct
800 {
801 uint32_t FrameWidth : MOS_BITFIELD_RANGE(0, 15);
802 uint32_t FrameHeight : MOS_BITFIELD_RANGE(16, 31);
803 };
804 struct
805 {
806 uint32_t Value;
807 };
808 } DW6;
809
810 // DW7
811 union
812 {
813 struct
814 {
815 uint32_t IntraPartMask : MOS_BITFIELD_RANGE(0, 4);
816 uint32_t NonSkipZMvAdded : MOS_BITFIELD_BIT(5);
817 uint32_t NonSkipModeAdded : MOS_BITFIELD_BIT(6);
818 uint32_t LumaIntraSrcCornerSwap : MOS_BITFIELD_BIT(7);
819 uint32_t : MOS_BITFIELD_RANGE(8, 15);
820 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE(16, 17);
821 uint32_t BilinearEnable : MOS_BITFIELD_BIT(18);
822 uint32_t Res_19 : MOS_BITFIELD_BIT(19);
823 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT(20);
824 uint32_t AConlyHAAR : MOS_BITFIELD_BIT(21);
825 uint32_t RefIDCostMode : MOS_BITFIELD_BIT(22);
826 uint32_t : MOS_BITFIELD_BIT(23);
827 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE(24, 31);
828 };
829 struct
830 {
831 uint32_t Value;
832 };
833 } DW7;
834
835 // DW8
836 union
837 {
838 struct
839 {
840 uint32_t Mode0Cost : MOS_BITFIELD_RANGE(0, 7);
841 uint32_t Mode1Cost : MOS_BITFIELD_RANGE(8, 15);
842 uint32_t Mode2Cost : MOS_BITFIELD_RANGE(16, 23);
843 uint32_t Mode3Cost : MOS_BITFIELD_RANGE(24, 31);
844 };
845 struct
846 {
847 uint32_t Value;
848 };
849 } DW8;
850
851 // DW9
852 union
853 {
854 struct
855 {
856 uint32_t Mode4Cost : MOS_BITFIELD_RANGE(0, 7);
857 uint32_t Mode5Cost : MOS_BITFIELD_RANGE(8, 15);
858 uint32_t Mode6Cost : MOS_BITFIELD_RANGE(16, 23);
859 uint32_t Mode7Cost : MOS_BITFIELD_RANGE(24, 31);
860 };
861 struct
862 {
863 uint32_t Value;
864 };
865 } DW9;
866
867 // DW10
868 union
869 {
870 struct
871 {
872 uint32_t Mode8Cost : MOS_BITFIELD_RANGE(0, 7);
873 uint32_t Mode9Cost : MOS_BITFIELD_RANGE(8, 15);
874 uint32_t RefIDCost : MOS_BITFIELD_RANGE(16, 23);
875 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE(24, 31);
876 };
877 struct
878 {
879 uint32_t Value;
880 };
881 } DW10;
882
883 // DW11
884 union
885 {
886 struct
887 {
888 uint32_t MV0Cost : MOS_BITFIELD_RANGE(0, 7);
889 uint32_t MV1Cost : MOS_BITFIELD_RANGE(8, 15);
890 uint32_t MV2Cost : MOS_BITFIELD_RANGE(16, 23);
891 uint32_t MV3Cost : MOS_BITFIELD_RANGE(24, 31);
892 };
893 struct
894 {
895 uint32_t Value;
896 };
897 } DW11;
898
899 // DW12
900 union
901 {
902 struct
903 {
904 uint32_t MV4Cost : MOS_BITFIELD_RANGE(0, 7);
905 uint32_t MV5Cost : MOS_BITFIELD_RANGE(8, 15);
906 uint32_t MV6Cost : MOS_BITFIELD_RANGE(16, 23);
907 uint32_t MV7Cost : MOS_BITFIELD_RANGE(24, 31);
908 };
909 struct
910 {
911 uint32_t Value;
912 };
913 } DW12;
914
915 // DW13
916 union
917 {
918 struct
919 {
920 uint32_t QpPrimeY : MOS_BITFIELD_RANGE(0, 7);
921 uint32_t QpPrimeCb : MOS_BITFIELD_RANGE(8, 15);
922 uint32_t QpPrimeCr : MOS_BITFIELD_RANGE(16, 23);
923 uint32_t TargetSizeInWord : MOS_BITFIELD_RANGE(24, 31);
924 };
925 struct
926 {
927 uint32_t Value;
928 };
929 } DW13;
930
931 // DW14
932 union
933 {
934 struct
935 {
936 uint32_t SICFwdTransCoeffThreshold_0 : MOS_BITFIELD_RANGE(0, 15);
937 uint32_t SICFwdTransCoeffThreshold_1 : MOS_BITFIELD_RANGE(16, 23);
938 uint32_t SICFwdTransCoeffThreshold_2 : MOS_BITFIELD_RANGE(24, 31);
939 };
940 struct
941 {
942 uint32_t Value;
943 };
944 } DW14;
945
946 // DW15
947 union
948 {
949 struct
950 {
951 uint32_t SICFwdTransCoeffThreshold_3 : MOS_BITFIELD_RANGE(0, 7);
952 uint32_t SICFwdTransCoeffThreshold_4 : MOS_BITFIELD_RANGE(8, 15);
953 uint32_t SICFwdTransCoeffThreshold_5 : MOS_BITFIELD_RANGE(16, 23);
954 uint32_t SICFwdTransCoeffThreshold_6 : MOS_BITFIELD_RANGE(24, 31); // Highest Freq
955 };
956 struct
957 {
958 uint32_t Value;
959 };
960 } DW15;
961
962 // DW16
963 union
964 {
965 struct
966 {
967 SearchPathDelta SPDelta_0;
968 SearchPathDelta SPDelta_1;
969 SearchPathDelta SPDelta_2;
970 SearchPathDelta SPDelta_3;
971 };
972 struct
973 {
974 uint32_t Value;
975 };
976 } DW16;
977
978 // DW17
979 union
980 {
981 struct
982 {
983 SearchPathDelta SPDelta_4;
984 SearchPathDelta SPDelta_5;
985 SearchPathDelta SPDelta_6;
986 SearchPathDelta SPDelta_7;
987 };
988 struct
989 {
990 uint32_t Value;
991 };
992 } DW17;
993
994 // DW18
995 union
996 {
997 struct
998 {
999 SearchPathDelta SPDelta_8;
1000 SearchPathDelta SPDelta_9;
1001 SearchPathDelta SPDelta_10;
1002 SearchPathDelta SPDelta_11;
1003 };
1004 struct
1005 {
1006 uint32_t Value;
1007 };
1008 } DW18;
1009
1010 // DW19
1011 union
1012 {
1013 struct
1014 {
1015 SearchPathDelta SPDelta_12;
1016 SearchPathDelta SPDelta_13;
1017 SearchPathDelta SPDelta_14;
1018 SearchPathDelta SPDelta_15;
1019 };
1020 struct
1021 {
1022 uint32_t Value;
1023 };
1024 } DW19;
1025
1026 // DW20
1027 union
1028 {
1029 struct
1030 {
1031 SearchPathDelta SPDelta_16;
1032 SearchPathDelta SPDelta_17;
1033 SearchPathDelta SPDelta_18;
1034 SearchPathDelta SPDelta_19;
1035 };
1036 struct
1037 {
1038 uint32_t Value;
1039 };
1040 } DW20;
1041
1042 // DW21
1043 union
1044 {
1045 struct
1046 {
1047 SearchPathDelta SPDelta_20;
1048 SearchPathDelta SPDelta_21;
1049 SearchPathDelta SPDelta_22;
1050 SearchPathDelta SPDelta_23;
1051 };
1052 struct
1053 {
1054 uint32_t Value;
1055 };
1056 } DW21;
1057
1058 // DW22
1059 union
1060 {
1061 struct
1062 {
1063 SearchPathDelta SPDelta_24;
1064 SearchPathDelta SPDelta_25;
1065 SearchPathDelta SPDelta_26;
1066 SearchPathDelta SPDelta_27;
1067 };
1068 struct
1069 {
1070 uint32_t Value;
1071 };
1072 } DW22;
1073
1074 // DW23
1075 union
1076 {
1077 struct
1078 {
1079 SearchPathDelta SPDelta_28;
1080 SearchPathDelta SPDelta_29;
1081 SearchPathDelta SPDelta_30;
1082 SearchPathDelta SPDelta_31;
1083 };
1084 struct
1085 {
1086 uint32_t Value;
1087 };
1088 } DW23;
1089
1090 // DW24
1091 union
1092 {
1093 struct
1094 {
1095 SearchPathDelta SPDelta_32;
1096 SearchPathDelta SPDelta_33;
1097 SearchPathDelta SPDelta_34;
1098 SearchPathDelta SPDelta_35;
1099 };
1100 struct
1101 {
1102 uint32_t Value;
1103 };
1104 } DW24;
1105
1106 // DW25
1107 union
1108 {
1109 struct
1110 {
1111 SearchPathDelta SPDelta_36;
1112 SearchPathDelta SPDelta_37;
1113 SearchPathDelta SPDelta_38;
1114 SearchPathDelta SPDelta_39;
1115 };
1116 struct
1117 {
1118 uint32_t Value;
1119 };
1120 } DW25;
1121
1122 // DW26
1123 union
1124 {
1125 struct
1126 {
1127 SearchPathDelta SPDelta_40;
1128 SearchPathDelta SPDelta_41;
1129 SearchPathDelta SPDelta_42;
1130 SearchPathDelta SPDelta_43;
1131 };
1132 struct
1133 {
1134 uint32_t Value;
1135 };
1136 } DW26;
1137
1138 // DW27
1139 union
1140 {
1141 struct
1142 {
1143 SearchPathDelta SPDelta_44;
1144 SearchPathDelta SPDelta_45;
1145 SearchPathDelta SPDelta_46;
1146 SearchPathDelta SPDelta_47;
1147 };
1148 struct
1149 {
1150 uint32_t Value;
1151 };
1152 } DW27;
1153
1154 // DW28
1155 union
1156 {
1157 struct
1158 {
1159 SearchPathDelta SPDelta_48;
1160 SearchPathDelta SPDelta_49;
1161 SearchPathDelta SPDelta_50;
1162 SearchPathDelta SPDelta_51;
1163 };
1164 struct
1165 {
1166 uint32_t Value;
1167 };
1168 } DW28;
1169
1170 // DW29
1171 union
1172 {
1173 struct
1174 {
1175 SearchPathDelta SPDelta_52;
1176 SearchPathDelta SPDelta_53;
1177 SearchPathDelta SPDelta_54;
1178 SearchPathDelta SPDelta_55;
1179 };
1180 struct
1181 {
1182 uint32_t Value;
1183 };
1184 } DW29;
1185
1186 // DW30
1187 union
1188 {
1189 struct
1190 {
1191 uint32_t Intra4x4ModeMask : MOS_BITFIELD_RANGE(0, 8);
1192 uint32_t : MOS_BITFIELD_RANGE(9, 15);
1193 uint32_t Intra8x8ModeMask : MOS_BITFIELD_RANGE(16, 24);
1194 uint32_t : MOS_BITFIELD_RANGE(25, 31);
1195 };
1196 struct
1197 {
1198 uint32_t Value;
1199 };
1200 } DW30;
1201
1202 // DW31
1203 union
1204 {
1205 struct
1206 {
1207 uint32_t Intra16x16ModeMask : MOS_BITFIELD_RANGE(0, 3);
1208 uint32_t IntraChromaModeMask : MOS_BITFIELD_RANGE(4, 7);
1209 uint32_t IntraComputeType : MOS_BITFIELD_RANGE(8, 9);
1210 uint32_t : MOS_BITFIELD_RANGE(10, 31);
1211 };
1212 struct
1213 {
1214 uint32_t Value;
1215 };
1216 } DW31;
1217
1218 // DW32
1219 union
1220 {
1221 struct
1222 {
1223 uint32_t SkipVal : MOS_BITFIELD_RANGE(0, 15);
1224 uint32_t MultiPredL0Disable : MOS_BITFIELD_RANGE(16, 23);
1225 uint32_t MultiPredL1Disable : MOS_BITFIELD_RANGE(24, 31);
1226 };
1227 struct
1228 {
1229 uint32_t Value;
1230 };
1231 } DW32;
1232
1233 // DW33
1234 union
1235 {
1236 struct
1237 {
1238 uint32_t Intra16x16NonDCPredPenalty : MOS_BITFIELD_RANGE(0, 7);
1239 uint32_t Intra8x8NonDCPredPenalty : MOS_BITFIELD_RANGE(8, 15);
1240 uint32_t Intra4x4NonDCPredPenalty : MOS_BITFIELD_RANGE(16, 23);
1241 uint32_t : MOS_BITFIELD_RANGE(24, 31);
1242 };
1243 struct
1244 {
1245 uint32_t Value;
1246 };
1247 } DW33;
1248
1249 union {
1250 struct {
1251 uint32_t LambdaME;
1252 };
1253 uint32_t Value;
1254 } DW34;
1255
1256 union {
1257 struct {
1258 uint32_t SimpIntraInterThreshold : MOS_BITFIELD_RANGE(0, 15);
1259 uint32_t ModeCostSp : MOS_BITFIELD_RANGE(16, 23);
1260 uint32_t IntraRefreshEn : MOS_BITFIELD_RANGE(24, 25);
1261 uint32_t FirstIntraRefresh : MOS_BITFIELD_BIT(26);
1262 uint32_t EnableRollingIntra : MOS_BITFIELD_BIT(27);
1263 uint32_t HalfUpdateMixedLCU : MOS_BITFIELD_BIT(28);
1264 uint32_t Res_29_31 : MOS_BITFIELD_RANGE(29, 31);
1265 };
1266 uint32_t Value;
1267 } DW35;
1268
1269 union {
1270 struct {
1271 uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE(0, 7);
1272 uint32_t HMECombinedExtraSUs : MOS_BITFIELD_RANGE(8, 15);
1273 uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE(16, 23);
1274 uint32_t PowerSaving : MOS_BITFIELD_BIT(24);
1275 uint32_t BRCEnable : MOS_BITFIELD_BIT(25);
1276 uint32_t LCUBRCEnable : MOS_BITFIELD_BIT(26);
1277 uint32_t ROIEnable : MOS_BITFIELD_BIT(27);
1278 uint32_t FASTSurveillanceFlag : MOS_BITFIELD_BIT(28);
1279 uint32_t CheckAllFractionalEnable : MOS_BITFIELD_BIT(29);
1280 uint32_t HMECombinedOverlap : MOS_BITFIELD_RANGE(30, 31);
1281 };
1282 uint32_t Value;
1283 } DW36;
1284
1285 union {
1286 struct {
1287 uint32_t ActualQpRefID0List0 : MOS_BITFIELD_RANGE(0, 7);
1288 uint32_t ActualQpRefID1List0 : MOS_BITFIELD_RANGE(8, 15);
1289 uint32_t ActualQpRefID2List0 : MOS_BITFIELD_RANGE(16, 23);
1290 uint32_t ActualQpRefID3List0 : MOS_BITFIELD_RANGE(24, 31);
1291 };
1292 uint32_t Value;
1293 } DW37;
1294
1295 union {
1296 struct {
1297 uint32_t NumIntraRefreshOffFrames : MOS_BITFIELD_RANGE(0, 15);
1298 uint32_t NumFrameInGOB : MOS_BITFIELD_RANGE(16, 31);
1299 };
1300 uint32_t Value;
1301 } DW38;
1302
1303 union {
1304 struct {
1305 uint32_t ActualQpRefID0List1 : MOS_BITFIELD_RANGE(0, 7);
1306 uint32_t ActualQpRefID1List1 : MOS_BITFIELD_RANGE(8, 15);
1307 uint32_t RefCost : MOS_BITFIELD_RANGE(16, 31);
1308 };
1309 uint32_t Value;
1310 } DW39;
1311
1312 union {
1313 struct {
1314 uint32_t TransformThreshold0 : MOS_BITFIELD_RANGE(0, 15);
1315 uint32_t TransformThreshold1 : MOS_BITFIELD_RANGE(16, 31);
1316 };
1317 uint32_t Value;
1318 } DW40;
1319
1320 union {
1321 struct {
1322 uint32_t TransformThreshold2 : MOS_BITFIELD_RANGE(0, 15);
1323 uint32_t TextureIntraCostThreshold : MOS_BITFIELD_RANGE(16, 31);
1324 };
1325 uint32_t Value;
1326 } DW41;
1327
1328 union {
1329 struct
1330 {
1331 uint32_t NumMVPredictorsL0 : MOS_BITFIELD_RANGE(0, 3);
1332 uint32_t NumMVPredictorsL1 : MOS_BITFIELD_RANGE(4, 7);
1333 uint32_t Res_8 : MOS_BITFIELD_BIT(8);
1334 uint32_t PerLCUQP : MOS_BITFIELD_BIT(9);
1335 uint32_t PerCTBInput : MOS_BITFIELD_BIT(10);
1336 uint32_t CTBDistortionOutput : MOS_BITFIELD_BIT(11);
1337 uint32_t MVPredictorBlockSize : MOS_BITFIELD_RANGE(12, 14);
1338 uint32_t Res_15 : MOS_BITFIELD_BIT(15);
1339 uint32_t MultiPredL0 : MOS_BITFIELD_RANGE(16, 19);
1340 uint32_t MultiPredL1 : MOS_BITFIELD_RANGE(20, 23);
1341 uint32_t Res_24_31 : MOS_BITFIELD_RANGE(24, 31);
1342 };
1343 uint32_t Value;
1344 } DW42;
1345
1346 union {
1347 struct {
1348 uint32_t Reserved;
1349 };
1350 uint32_t Value;
1351 } DW43;
1352
1353 union {
1354 struct {
1355 uint32_t MaxNumMergeCandidates : MOS_BITFIELD_RANGE(0, 3);
1356 uint32_t MaxNumRefList0 : MOS_BITFIELD_RANGE(4, 7);
1357 uint32_t MaxNumRefList1 : MOS_BITFIELD_RANGE(8, 11);
1358 uint32_t Res_12_15 : MOS_BITFIELD_RANGE(12, 15);
1359 uint32_t MaxVmvR : MOS_BITFIELD_RANGE(16, 31);
1360 };
1361 uint32_t Value;
1362 } DW44;
1363
1364 union {
1365 struct {
1366 uint32_t TemporalMvpEnableFlag : MOS_BITFIELD_BIT(0);
1367 uint32_t Res_1_7 : MOS_BITFIELD_RANGE(1, 7);
1368 uint32_t Log2ParallelMergeLevel : MOS_BITFIELD_RANGE(8, 15);
1369 uint32_t HMECombineLenPslice : MOS_BITFIELD_RANGE(16, 23);
1370 uint32_t HMECombineLenBslice : MOS_BITFIELD_RANGE(24, 31);
1371 };
1372 uint32_t Value;
1373 } DW45;
1374
1375 union {
1376 struct {
1377 uint32_t Log2MinTUSize : MOS_BITFIELD_RANGE(0, 7);
1378 uint32_t Log2MaxTUSize : MOS_BITFIELD_RANGE(8, 15);
1379 uint32_t Log2MinCUSize : MOS_BITFIELD_RANGE(16, 23);
1380 uint32_t Log2MaxCUSize : MOS_BITFIELD_RANGE(24, 31);
1381 };
1382 uint32_t Value;
1383 } DW46;
1384
1385 union {
1386 struct {
1387 uint32_t NumRegionsInSlice : MOS_BITFIELD_RANGE(0, 7);
1388 uint32_t TypeOfWalkingPattern : MOS_BITFIELD_RANGE(8, 11);
1389 uint32_t ChromaFlatnessCheckFlag : MOS_BITFIELD_BIT(12);
1390 uint32_t EnableIntraEarlyExit : MOS_BITFIELD_BIT(13);
1391 uint32_t SkipIntraKrnFlag : MOS_BITFIELD_BIT(14);
1392 uint32_t ScreenContentFlag : MOS_BITFIELD_BIT(15);
1393 uint32_t IsLowDelay : MOS_BITFIELD_BIT(16);
1394 uint32_t CollocatedFromL0Flag : MOS_BITFIELD_BIT(17);
1395 uint32_t ArbitarySliceFlag : MOS_BITFIELD_BIT(18);
1396 uint32_t MultiSliceFlag : MOS_BITFIELD_BIT(19);
1397 uint32_t Res_20_23 : MOS_BITFIELD_RANGE(20, 23);
1398 uint32_t isCurrRefL0LongTerm : MOS_BITFIELD_BIT(24);
1399 uint32_t isCurrRefL1LongTerm : MOS_BITFIELD_BIT(25);
1400 uint32_t NumRegionMinus1 : MOS_BITFIELD_RANGE(26, 31);
1401 };
1402 uint32_t Value;
1403 } DW47;
1404
1405 union {
1406 struct {
1407 uint32_t CurrentTdL0_0 : MOS_BITFIELD_RANGE(0, 15);
1408 uint32_t CurrentTdL0_1 : MOS_BITFIELD_RANGE(16, 31);
1409 };
1410 uint32_t Value;
1411 } DW48;
1412
1413 union {
1414 struct {
1415 uint32_t CurrentTdL0_2 : MOS_BITFIELD_RANGE(0, 15);
1416 uint32_t CurrentTdL0_3 : MOS_BITFIELD_RANGE(16, 31);
1417 };
1418 uint32_t Value;
1419 } DW49;
1420
1421 union {
1422 struct {
1423 uint32_t CurrentTdL1_0 : MOS_BITFIELD_RANGE(0, 15);
1424 uint32_t CurrentTdL1_1 : MOS_BITFIELD_RANGE(16, 31);
1425 };
1426 uint32_t Value;
1427 } DW50;
1428
1429 union {
1430 struct {
1431 uint32_t IntraRefreshMBNum : MOS_BITFIELD_RANGE(0, 15);
1432 uint32_t IntraRefreshUnitInMB : MOS_BITFIELD_RANGE(16, 23);
1433 uint32_t IntraRefreshQPDelta : MOS_BITFIELD_RANGE(24, 31);
1434 };
1435 uint32_t Value;
1436 } DW51;
1437
1438 union {
1439 struct {
1440 uint32_t NumofUnitInRegion : MOS_BITFIELD_RANGE(0, 15);
1441 uint32_t MaxHeightInRegion : MOS_BITFIELD_RANGE(16, 31);
1442 };
1443 uint32_t Value;
1444 } DW52;
1445
1446 union {
1447 struct {
1448 uint32_t IntraRefreshRefWidth : MOS_BITFIELD_RANGE(0, 7);
1449 uint32_t IntraRefreshRefHeight : MOS_BITFIELD_RANGE(8, 15);
1450 uint32_t Res_16_31 : MOS_BITFIELD_RANGE(16, 31);
1451 };
1452 uint32_t Value;
1453 } DW53;
1454
1455 union {
1456 struct {
1457 uint32_t Reserved;
1458 };
1459 uint32_t Value;
1460 } DW54;
1461
1462 union {
1463 struct {
1464 uint32_t Reserved;
1465 };
1466 uint32_t Value;
1467 } DW55;
1468
1469 union {
1470 struct {
1471 uint32_t BTI_CU_Record;
1472 };
1473 uint32_t Value;
1474 } DW56;
1475
1476 union {
1477 struct {
1478 uint32_t BTI_PAK_Cmd;
1479 };
1480 uint32_t Value;
1481 } DW57;
1482
1483 union {
1484 struct {
1485 uint32_t BTI_Src_Y;
1486 };
1487 uint32_t Value;
1488 } DW58;
1489
1490 union {
1491 struct {
1492 uint32_t BTI_Intra_Dist;
1493 };
1494 uint32_t Value;
1495 } DW59;
1496
1497 union {
1498 struct {
1499 uint32_t BTI_Min_Dist;
1500 };
1501 uint32_t Value;
1502 } DW60;
1503
1504 union {
1505 struct {
1506 uint32_t BTI_HMEMVPredFwdBwdSurfIndex;
1507 };
1508 uint32_t Value;
1509 } DW61;
1510
1511 union {
1512 struct {
1513 uint32_t BTI_HMEDistSurfIndex;
1514 };
1515 uint32_t Value;
1516 } DW62;
1517
1518 union {
1519 struct {
1520 uint32_t BTI_Slice_Map;
1521 };
1522 uint32_t Value;
1523 } DW63;
1524
1525 union {
1526 struct {
1527 uint32_t BTI_VME_Saved_UNI_SIC;
1528 };
1529 uint32_t Value;
1530 } DW64;
1531
1532 union {
1533 struct {
1534 uint32_t BTI_Simplest_Intra;
1535 };
1536 uint32_t Value;
1537 } DW65;
1538
1539 union {
1540 struct {
1541 uint32_t BTI_Collocated_RefFrame;
1542 };
1543 uint32_t Value;
1544 } DW66;
1545
1546 union {
1547 struct {
1548 uint32_t BTI_Reserved;
1549 };
1550 uint32_t Value;
1551 } DW67;
1552
1553 union {
1554 struct {
1555 uint32_t BTI_BRC_Input;
1556 };
1557 uint32_t Value;
1558 } DW68;
1559
1560 union {
1561 struct {
1562 uint32_t BTI_LCU_QP;
1563 };
1564 uint32_t Value;
1565 } DW69;
1566
1567 union {
1568 struct {
1569 uint32_t BTI_BRC_Data;
1570 };
1571 uint32_t Value;
1572 } DW70;
1573
1574 union {
1575 struct {
1576 uint32_t BTI_VMEInterPredictionSurfIndex;
1577 };
1578 uint32_t Value;
1579 } DW71;
1580
1581 union {
1582 //For B frame
1583 struct {
1584 uint32_t BTI_VMEInterPredictionBSurfIndex;
1585 };
1586 //For P frame
1587 struct {
1588 uint32_t BTI_ConcurrentThreadMap;
1589 };
1590 uint32_t Value;
1591 } DW72;
1592
1593 union {
1594 //For B frame
1595 struct {
1596 uint32_t BTI_ConcurrentThreadMap;
1597 };
1598 //For P frame
1599 struct {
1600 uint32_t BTI_MB_Data_CurFrame;
1601 };
1602 uint32_t Value;
1603 } DW73;
1604
1605 union {
1606 //For B frame
1607 struct {
1608 uint32_t BTI_MB_Data_CurFrame;
1609 };
1610 //For P frame
1611 struct {
1612 uint32_t BTI_MVP_CurFrame;
1613 };
1614 uint32_t Value;
1615 } DW74;
1616
1617 union {
1618 //For B frame
1619 struct {
1620 uint32_t BTI_MVP_CurFrame;
1621 };
1622 //For P frame
1623 struct {
1624 uint32_t BTI_Haar_Dist16x16;
1625 };
1626 uint32_t Value;
1627 } DW75;
1628
1629 union {
1630 // this surface need to take same surface name from Hevc_LCUEnc_I_8x8_PU_FMode_inLCU as input
1631 //For B frame
1632 struct {
1633 uint32_t BTI_Haar_Dist16x16;
1634 };
1635 //For P frame
1636 struct {
1637 uint32_t BTI_Stats_Data;
1638 };
1639 uint32_t Value;
1640 } DW76;
1641
1642 union {
1643 //For B frame
1644 struct {
1645 uint32_t BTI_Stats_Data;
1646 };
1647 //For P frame
1648 struct {
1649 uint32_t BTI_Frame_Stats_Data;
1650 };
1651 uint32_t Value;
1652 } DW77;
1653
1654 union {
1655 //For B frame
1656 struct {
1657 uint32_t BTI_Frame_Stats_Data;
1658 };
1659 //For P frame
1660 struct {
1661 uint32_t BTI_MVPredictor_Surface;
1662 };
1663 uint32_t Value;
1664 } DW78;
1665
1666 union {
1667 //For B frame
1668 struct {
1669 uint32_t BTI_MVPredictor_Surface;
1670 };
1671 //For P frame
1672 struct {
1673 uint32_t BTI_CTB_Input_Surface;
1674 };
1675 uint32_t Value;
1676 } DW79;
1677
1678 union {
1679 //For B frame
1680 struct {
1681 uint32_t BTI_CTB_Input_Surface;
1682 };
1683 //For P frame
1684 struct {
1685 uint32_t BTI_CTB_Distortion_Output_Surface;
1686 };
1687 uint32_t Value;
1688 } DW80;
1689
1690 union {
1691 //For B frame
1692 struct {
1693 uint32_t BTI_CTB_Distortion_Output_Surface;
1694 };
1695 //For P frame
1696 struct {
1697 uint32_t BTI_Debug;
1698 };
1699 uint32_t Value;
1700 } DW81;
1701
1702 union {
1703 //For B frame
1704 struct {
1705 uint32_t BTI_Debug;
1706 };
1707 uint32_t Value;
1708 } DW82;
1709 };
1710
1711 using PCODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9 = struct CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9*;
1712 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9)) == 83 );
1713
1714 MOS_STATUS CodechalFeiHevcStateG9Skl::SetMbEncKernelParams(MHW_KERNEL_PARAM* kernelParams, uint32_t idx)
1715 {
1716 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1717
1718 CODECHAL_ENCODE_CHK_NULL_RETURN(kernelParams);
1719
1720 auto curbeAlignment = m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment();
1721
1722 kernelParams->iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
1723 kernelParams->iIdCount = 1;
1724
1725 switch (idx)
1726 {
1727 case CODECHAL_HEVC_MBENC_2xSCALING:
1728 kernelParams->iBTCount = CODECHAL_HEVC_FEI_SCALING_FRAME_END - CODECHAL_HEVC_FEI_SCALING_FRAME_BEGIN;
1729 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(MEDIA_OBJECT_DOWNSCALING_2X_STATIC_DATA_G9), curbeAlignment);
1730 kernelParams->iBlockWidth = 32;
1731 kernelParams->iBlockHeight = 32;
1732 break;
1733
1734 case CODECHAL_HEVC_MBENC_32x32MD:
1735 kernelParams->iBTCount = CODECHAL_HEVC_FEI_32x32_PU_END - CODECHAL_HEVC_FEI_32x32_PU_BEGIN;
1736 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_I_32x32_PU_MODE_DECISION_CURBE_G9), curbeAlignment);
1737 kernelParams->iBlockWidth = 32;
1738 kernelParams->iBlockHeight = 32;
1739 break;
1740
1741 case CODECHAL_HEVC_MBENC_16x16SAD:
1742 kernelParams->iBTCount = CODECHAL_HEVC_FEI_16x16_PU_SAD_END - CODECHAL_HEVC_FEI_16x16_PU_SAD_BEGIN;
1743 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_ENC_HEVC_I_16x16_SAD_CURBE_G9), curbeAlignment);
1744 kernelParams->iBlockWidth = 16;
1745 kernelParams->iBlockHeight = 16;
1746 break;
1747
1748 case CODECHAL_HEVC_MBENC_16x16MD:
1749 kernelParams->iBTCount = CODECHAL_HEVC_FEI_16x16_PU_MD_END - CODECHAL_HEVC_FEI_16x16_PU_MD_BEGIN;
1750 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_I_16x16_PU_MODEDECISION_CURBE_G9), curbeAlignment);
1751 kernelParams->iBlockWidth = 32;
1752 kernelParams->iBlockHeight = 32;
1753 break;
1754
1755 case CODECHAL_HEVC_MBENC_8x8PU:
1756 kernelParams->iBTCount = CODECHAL_HEVC_FEI_8x8_PU_END - CODECHAL_HEVC_FEI_8x8_PU_BEGIN;
1757 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_I_8x8_PU_CURBE_G9), curbeAlignment);
1758 kernelParams->iBlockWidth = 8;
1759 kernelParams->iBlockHeight = 8;
1760 break;
1761
1762 case CODECHAL_HEVC_MBENC_8x8FMODE:
1763 kernelParams->iBTCount = CODECHAL_HEVC_FEI_8x8_PU_FMODE_END - CODECHAL_HEVC_FEI_8x8_PU_FMODE_BEGIN;
1764 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9), curbeAlignment);
1765 kernelParams->iBlockWidth = 32;
1766 kernelParams->iBlockHeight = 32;
1767 break;
1768
1769 case CODECHAL_HEVC_MBENC_32x32INTRACHECK:
1770 kernelParams->iBTCount = CODECHAL_HEVC_FEI_B_32x32_PU_END - CODECHAL_HEVC_FEI_B_32x32_PU_BEGIN;
1771 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_ENC_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9), curbeAlignment);
1772 kernelParams->iBlockWidth = 32;
1773 kernelParams->iBlockHeight = 32;
1774 break;
1775
1776 case CODECHAL_HEVC_FEI_MBENC_BENC:
1777 kernelParams->iBTCount = CODECHAL_HEVC_FEI_B_MBENC_END - CODECHAL_HEVC_FEI_B_MBENC_BEGIN;
1778 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9), curbeAlignment);
1779 kernelParams->iBlockWidth = 16;
1780 kernelParams->iBlockHeight = 16;
1781 break;
1782
1783 case CODECHAL_HEVC_FEI_MBENC_BPAK:
1784 kernelParams->iBTCount = CODECHAL_HEVC_FEI_B_PAK_END - CODECHAL_HEVC_FEI_B_PAK_BEGIN;
1785 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_ENC_HEVC_B_PAK_CURBE_G9), curbeAlignment);
1786 kernelParams->iBlockWidth = 32;
1787 kernelParams->iBlockHeight = 32;
1788 break;
1789
1790 case CODECHAL_HEVC_FEI_MBENC_DS_COMBINED:
1791 if (MEDIA_IS_SKU(m_skuTable, FtrEncodeHEVC10bit))
1792 {
1793 kernelParams->iBTCount = CODECHAL_HEVC_FEI_DS_COMBINED_END - CODECHAL_HEVC_FEI_DS_COMBINED_BEGIN;
1794 uint32_t uiDSCombinedKernelCurbeSize = sizeof(CODECHAL_ENC_HEVC_DS_COMBINED_CURBE_G9);
1795 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(uiDSCombinedKernelCurbeSize, curbeAlignment);
1796 kernelParams->iBlockWidth = 8;
1797 kernelParams->iBlockHeight = 8;
1798 }
1799 else
1800 {
1801 CODECHAL_ENCODE_ASSERT(false);
1802 eStatus = MOS_STATUS_INVALID_PARAMETER;
1803 }
1804 break;
1805
1806 case CODECHAL_HEVC_FEI_MBENC_PENC:
1807 kernelParams->iBTCount = CODECHAL_HEVC_FEI_P_MBENC_END - CODECHAL_HEVC_FEI_P_MBENC_BEGIN;
1808 //P MBEnc curbe has one less DWord than B MBEnc curbe
1809 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9) - sizeof(uint32_t), (size_t)curbeAlignment);
1810 kernelParams->iBlockWidth = 16;
1811 kernelParams->iBlockHeight = 16;
1812 break;
1813
1814 default:
1815 CODECHAL_ENCODE_ASSERT(false);
1816 eStatus = MOS_STATUS_INVALID_PARAMETER;
1817 }
1818
1819 return eStatus;
1820 }
1821
1822 MOS_STATUS CodechalFeiHevcStateG9Skl::SetMbEncBindingTable(PCODECHAL_ENCODE_BINDING_TABLE_GENERIC bindingTable, uint32_t idx)
1823 {
1824 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1825
1826 CODECHAL_ENCODE_CHK_NULL_RETURN(bindingTable);
1827
1828 MOS_ZeroMemory(bindingTable, sizeof(*bindingTable));
1829 bindingTable->dwMediaState = ConvertKrnOpsToMediaState(ENC_MBENC, idx);
1830
1831 switch (idx)
1832 {
1833 case CODECHAL_HEVC_MBENC_2xSCALING:
1834 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_SCALING_FRAME_END - CODECHAL_HEVC_FEI_SCALING_FRAME_BEGIN;
1835 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_SCALING_FRAME_BEGIN;
1836 break;
1837
1838 case CODECHAL_HEVC_MBENC_32x32MD:
1839 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_32x32_PU_END - CODECHAL_HEVC_FEI_32x32_PU_BEGIN;
1840 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_32x32_PU_BEGIN;
1841 break;
1842
1843 case CODECHAL_HEVC_MBENC_16x16SAD:
1844 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_16x16_PU_SAD_END - CODECHAL_HEVC_FEI_16x16_PU_SAD_BEGIN;
1845 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_16x16_PU_SAD_BEGIN;
1846 break;
1847
1848 case CODECHAL_HEVC_MBENC_16x16MD:
1849 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_16x16_PU_MD_END - CODECHAL_HEVC_FEI_16x16_PU_MD_BEGIN;
1850 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_16x16_PU_MD_BEGIN;
1851 break;
1852
1853 case CODECHAL_HEVC_MBENC_8x8PU:
1854 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_8x8_PU_END - CODECHAL_HEVC_FEI_8x8_PU_BEGIN;
1855 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_8x8_PU_BEGIN;
1856 break;
1857
1858 case CODECHAL_HEVC_MBENC_8x8FMODE:
1859 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_8x8_PU_FMODE_END - CODECHAL_HEVC_FEI_8x8_PU_FMODE_BEGIN;
1860 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_8x8_PU_FMODE_BEGIN;
1861 break;
1862
1863 case CODECHAL_HEVC_MBENC_32x32INTRACHECK:
1864 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_B_32x32_PU_END - CODECHAL_HEVC_FEI_B_32x32_PU_BEGIN;
1865 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_B_32x32_PU_BEGIN;
1866 break;
1867
1868 case CODECHAL_HEVC_FEI_MBENC_BENC:
1869 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_B_MBENC_END - CODECHAL_HEVC_FEI_B_MBENC_BEGIN;
1870 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_B_MBENC_BEGIN;
1871 break;
1872
1873 case CODECHAL_HEVC_FEI_MBENC_BPAK:
1874 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_B_PAK_END - CODECHAL_HEVC_FEI_B_PAK_BEGIN;
1875 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_B_PAK_BEGIN;
1876 break;
1877
1878 case CODECHAL_HEVC_FEI_MBENC_DS_COMBINED:
1879 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_DS_COMBINED_END - CODECHAL_HEVC_FEI_DS_COMBINED_BEGIN;
1880 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_DS_COMBINED_BEGIN;
1881 break;
1882
1883 case CODECHAL_HEVC_FEI_MBENC_PENC:
1884 bindingTable->dwNumBindingTableEntries = CODECHAL_HEVC_FEI_P_MBENC_END - CODECHAL_HEVC_FEI_P_MBENC_BEGIN;
1885 bindingTable->dwBindingTableStartOffset = CODECHAL_HEVC_FEI_P_MBENC_BEGIN;
1886 break;
1887
1888 default:
1889 CODECHAL_ENCODE_ASSERT(false);
1890 eStatus = MOS_STATUS_INVALID_PARAMETER;
1891 return eStatus;
1892 }
1893
1894 for (uint32_t i = 0; i < bindingTable->dwNumBindingTableEntries; i++)
1895 {
1896 bindingTable->dwBindingTableEntries[i] = i;
1897 }
1898
1899 return eStatus;
1900 }
1901
1902 MOS_STATUS CodechalFeiHevcStateG9Skl::EndKernelCall(
1903 CODECHAL_MEDIA_STATE_TYPE mediaStateType,
1904 PMHW_KERNEL_STATE kernelState,
1905 PMOS_COMMAND_BUFFER cmdBuffer)
1906 {
1907 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1908
1909 CODECHAL_ENCODE_FUNCTION_ENTER;
1910
1911 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncHevcStateG9::EndKernelCall(mediaStateType, kernelState, cmdBuffer));
1912
1913 // skip haar distortion surface, statstics data dump surface
1914 // and frame level statstics data surface because they are not used
1915 #if 0
1916 CODECHAL_DEBUG_TOOL(
1917 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpSurface(
1918 &m_encStatsBuffers.m_puStatsSurface,
1919 CodechalDbgAttr::attrOutput,
1920 "HEVC_B_MBENC_PU_StatsSurface",
1921 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
1922
1923 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpSurface(
1924 &m_encStatsBuffers.m_8x8PuHaarDist,
1925 CodechalDbgAttr::attrOutput,
1926 "HEVC_B_MBENC_8X8_PU_HaarDistSurface",
1927 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
1928
1929 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1930 &m_encStatsBuffers.m_8x8PuFrameStats.sResource,
1931 "HEVC_B_MBENC_ConstantData_In",
1932 CodechalDbgAttr::attrOutput,
1933 m_encStatsBuffers.m_8x8PuFrameStats.dwSize,
1934 0,
1935 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
1936
1937 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpSurface(
1938 &m_encStatsBuffers.m_mbEncStatsSurface,
1939 CodechalDbgAttr::attrOutput,
1940 "HEVC_B_MBENC_MB_ENC_StatsSurface",
1941 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
1942
1943 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
1944 &m_encStatsBuffers.m_mbEncFrameStats.sResource,
1945 "HEVC_B_MBENC_ConstantData_In",
1946 CodechalDbgAttr::attrOutput,
1947 m_encStatsBuffers.m_mbEncFrameStats.dwSize,
1948 0,
1949 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
1950 )
1951 #endif
1952 return eStatus;
1953 }
1954
1955 MOS_STATUS CodechalFeiHevcStateG9Skl::InitKernelState()
1956 {
1957 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1958
1959 CODECHAL_ENCODE_FUNCTION_ENTER;
1960
1961 // InitKernelStateMbEnc
1962 m_numMbEncEncKrnStates = CODECHAL_HEVC_FEI_MBENC_NUM_BXT_SKL;
1963
1964 m_mbEncKernelStates = MOS_NewArray(MHW_KERNEL_STATE, m_numMbEncEncKrnStates);
1965 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mbEncKernelStates);
1966
1967 m_mbEncKernelBindingTable = (PCODECHAL_ENCODE_BINDING_TABLE_GENERIC)MOS_AllocAndZeroMemory(
1968 sizeof(GenericBindingTable) * m_numMbEncEncKrnStates);
1969 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mbEncKernelBindingTable);
1970
1971 auto krnStateIdx = m_mbEncKernelStates;
1972
1973 for (uint32_t KrnStateIdx = 0; KrnStateIdx < m_numMbEncEncKrnStates; KrnStateIdx++)
1974 {
1975 auto kernelSize = m_combinedKernelSize;
1976 CODECHAL_KERNEL_HEADER currKrnHeader;
1977
1978 if (KrnStateIdx == CODECHAL_HEVC_FEI_MBENC_DS_COMBINED &&
1979 m_numMbEncEncKrnStates == CODECHAL_HEVC_FEI_MBENC_NUM_BXT_SKL) //Ignore. It isn't used on BXT.
1980 {
1981 krnStateIdx++;
1982 continue;
1983 }
1984
1985 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
1986 m_kernelBinary,
1987 ENC_MBENC,
1988 KrnStateIdx,
1989 &currKrnHeader,
1990 &kernelSize));
1991
1992 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetMbEncKernelParams(
1993 &krnStateIdx->KernelParams,
1994 KrnStateIdx));
1995
1996 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetMbEncBindingTable(
1997 &m_mbEncKernelBindingTable[KrnStateIdx], KrnStateIdx));
1998
1999 krnStateIdx->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
2000 krnStateIdx->KernelParams.pBinary = m_kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
2001 krnStateIdx->KernelParams.iSize = kernelSize;
2002
2003 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
2004 m_stateHeapInterface,
2005 krnStateIdx->KernelParams.iBTCount,
2006 &krnStateIdx->dwSshSize,
2007 &krnStateIdx->dwBindingTableSize));
2008
2009 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, krnStateIdx));
2010
2011 krnStateIdx++;
2012 }
2013
2014 return eStatus;
2015 }
2016
2017 MOS_STATUS CodechalFeiHevcStateG9Skl::GetKernelHeaderAndSize(
2018 void *binary,
2019 EncOperation operation,
2020 uint32_t krnStateIdx,
2021 void *krnHeader,
2022 uint32_t *krnSize)
2023 {
2024 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2025
2026 CODECHAL_ENCODE_FUNCTION_ENTER;
2027
2028 CODECHAL_ENCODE_CHK_NULL_RETURN(binary);
2029 CODECHAL_ENCODE_CHK_NULL_RETURN(krnHeader);
2030 CODECHAL_ENCODE_CHK_NULL_RETURN(krnSize);
2031
2032 PCODECHAL_ENC_HEVC_KERNEL_HEADER_FEI_G9_SKL kernelHeaderTable = (PCODECHAL_ENC_HEVC_KERNEL_HEADER_FEI_G9_SKL)binary;
2033 PCODECHAL_KERNEL_HEADER currKrnHeader = nullptr;
2034
2035 if (operation == ENC_SCALING4X)
2036 {
2037 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_I_DS4HME;
2038 }
2039 else if (operation == ENC_ME)
2040 {
2041 // SKL supports P frame. P HME index CODECHAL_ENCODE_ME_IDX_P is 0 and B HME index CODECHAL_ENCODE_ME_IDX_B is 1
2042 if (krnStateIdx == 0)
2043 {
2044 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_P_HME;
2045 }
2046 else
2047 {
2048 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_B_HME;
2049 }
2050 }
2051 else if (operation == ENC_BRC)
2052 {
2053 switch (krnStateIdx)
2054 {
2055 case CODECHAL_HEVC_BRC_COARSE_INTRA:
2056 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_I_COARSE;
2057 break;
2058
2059 default:
2060 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported BRC mode requested");
2061 eStatus = MOS_STATUS_INVALID_PARAMETER;
2062 return eStatus;
2063 }
2064 }
2065 else if (operation == ENC_MBENC)
2066 {
2067 switch (krnStateIdx)
2068 {
2069 case CODECHAL_HEVC_MBENC_2xSCALING:
2070 case CODECHAL_HEVC_MBENC_32x32MD:
2071 case CODECHAL_HEVC_MBENC_16x16SAD:
2072 case CODECHAL_HEVC_MBENC_16x16MD:
2073 case CODECHAL_HEVC_MBENC_8x8PU:
2074 case CODECHAL_HEVC_MBENC_8x8FMODE:
2075 case CODECHAL_HEVC_MBENC_32x32INTRACHECK:
2076 case CODECHAL_HEVC_FEI_MBENC_BENC:
2077 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_I_2xDownSampling_Kernel;
2078 currKrnHeader += krnStateIdx;
2079 break;
2080
2081 case CODECHAL_HEVC_FEI_MBENC_BPAK:
2082 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_PB_Pak;
2083 break;
2084
2085 case CODECHAL_HEVC_FEI_MBENC_DS_COMBINED:
2086 currKrnHeader = &kernelHeaderTable->Hevc_FEI_LCUEnc_DS_Combined;
2087 break;
2088
2089 case CODECHAL_HEVC_FEI_MBENC_PENC:
2090 currKrnHeader = &kernelHeaderTable->HEVC_FEI_LCUEnc_P_MB;
2091 break;
2092
2093 default:
2094 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
2095 eStatus = MOS_STATUS_INVALID_PARAMETER;
2096 return eStatus;
2097 }
2098 }
2099 else
2100 {
2101 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
2102 eStatus = MOS_STATUS_INVALID_PARAMETER;
2103 return eStatus;
2104 }
2105
2106 *((PCODECHAL_KERNEL_HEADER)krnHeader) = *currKrnHeader;
2107
2108 PCODECHAL_KERNEL_HEADER nextKrnHeader = (currKrnHeader + 1);
2109 PCODECHAL_KERNEL_HEADER invalidEntry = (PCODECHAL_KERNEL_HEADER)(((uint8_t*)binary) + sizeof(*kernelHeaderTable));
2110 uint32_t nextKrnOffset = *krnSize;
2111
2112 if (nextKrnHeader < invalidEntry)
2113 {
2114 nextKrnOffset = nextKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT;
2115 }
2116 *krnSize = nextKrnOffset - (currKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
2117
2118 return eStatus;
2119 }
2120
2121
2122 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode2xScalingKernel()
2123 {
2124 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2125
2126 PerfTagSetting perfTag;
2127 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_SCALING_KERNEL);
2128
2129 uint32_t krnIdx = CODECHAL_HEVC_MBENC_2xSCALING;
2130 auto kernelState = &m_mbEncKernelStates[krnIdx];
2131 auto pScalingBindingTable = &m_mbEncKernelBindingTable[krnIdx];
2132 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2133 {
2134 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
2135 }
2136
2137 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
2138 m_osInterface,
2139 &m_scaled2xSurface));
2140
2141 // Setup DSH
2142 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2143 m_stateHeapInterface,
2144 kernelState,
2145 false,
2146 0,
2147 false,
2148 m_storeData));
2149
2150 //Setup CURBE
2151 MEDIA_OBJECT_DOWNSCALING_2X_STATIC_DATA_G9 cmd, *curbe = &cmd;
2152 MOS_ZeroMemory(curbe, sizeof(*curbe));
2153 curbe->DW0.PicWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
2154 curbe->DW0.PicHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
2155
2156 uint32_t startBTI = 0;
2157 curbe->DW8.BTI_Src_Y = pScalingBindingTable->dwBindingTableEntries[startBTI++];
2158 curbe->DW9.BTI_Dst_Y = pScalingBindingTable->dwBindingTableEntries[startBTI++];
2159
2160 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_2X_SCALING;
2161 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2162 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
2163
2164 MOS_COMMAND_BUFFER cmdBuffer;
2165 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
2166 &cmdBuffer,
2167 kernelState,
2168 encFunctionType,
2169 nullptr));
2170
2171 // Add surface states, 2X scaling uses U16Norm surface format
2172 startBTI = 0;
2173
2174 // Source surface/s
2175 auto surfaceCodecParams = &m_surfaceParams[SURFACE_RAW_Y];
2176 surfaceCodecParams->bUse16UnormSurfaceFormat = true;
2177
2178 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2179 kernelState,
2180 &cmdBuffer,
2181 SURFACE_RAW_Y,
2182 &pScalingBindingTable->dwBindingTableEntries[startBTI++]
2183 ));
2184
2185 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
2186 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(surfaceCodecParams));
2187
2188 // Destination surface/s
2189 m_scaled2xSurface.dwWidth = MOS_ALIGN_CEIL((m_frameWidth / SCALE_FACTOR_2x), CODECHAL_MACROBLOCK_WIDTH);
2190 m_scaled2xSurface.dwHeight = MOS_ALIGN_CEIL((m_frameHeight / SCALE_FACTOR_2x), CODECHAL_MACROBLOCK_HEIGHT);
2191
2192 m_surfaceParams[SURFACE_Y_2X].bUse16UnormSurfaceFormat =
2193 m_surfaceParams[SURFACE_Y_2X].bIsWritable =
2194 m_surfaceParams[SURFACE_Y_2X].bRenderTarget = true;
2195 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2196 kernelState,
2197 &cmdBuffer,
2198 SURFACE_Y_2X,
2199 &pScalingBindingTable->dwBindingTableEntries[startBTI++]
2200 ));
2201
2202 if (!m_hwWalker)
2203 {
2204 eStatus = MOS_STATUS_UNKNOWN;
2205 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
2206 return eStatus;
2207 }
2208
2209 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
2210 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
2211 walkerCodecParams.WalkerMode = m_walkerMode;
2212 // check kernel of Downscaling 2x kernels for Ultra HME.
2213 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 32) >> 5;
2214 // The frame kernel process 32x32 input pixels and output 16x16 down sampled pixels
2215 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 32) >> 5;
2216 /* Enforce no dependency dispatch order for Scaling kernel, */
2217 walkerCodecParams.bNoDependency = true;
2218
2219 MHW_WALKER_PARAMS walkerParams;
2220 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
2221 m_hwInterface,
2222 &walkerParams,
2223 &walkerCodecParams));
2224
2225 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
2226 &cmdBuffer,
2227 &walkerParams));
2228
2229 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
2230 encFunctionType,
2231 kernelState,
2232 &cmdBuffer));
2233
2234 return eStatus;
2235 }
2236
2237 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode32x32PuModeDecisionKernel()
2238 {
2239 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2240
2241 PerfTagSetting perfTag;
2242 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_32X32_PU_MD);
2243
2244 uint32_t krnIdx = CODECHAL_HEVC_MBENC_32x32MD;
2245 auto kernelState = &m_mbEncKernelStates[krnIdx];
2246 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
2247 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2248 {
2249 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
2250 }
2251
2252 // Setup DSH
2253 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2254 m_stateHeapInterface,
2255 kernelState,
2256 false,
2257 0,
2258 false,
2259 m_storeData));
2260
2261 //Setup CURBE
2262 uint32_t log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
2263
2264 CalcLambda(CODECHAL_ENCODE_HEVC_I_SLICE, INTRA_TRANSFORM_HAAR);
2265 int32_t sliceQp = CalSliceQp();
2266
2267 double lambdaScalingFactor = 1.0;
2268 double qpLambda = m_qpLambdaMd[CODECHAL_ENCODE_HEVC_I_SLICE][sliceQp];
2269 double squaredQpLambda = qpLambda * qpLambda;
2270 m_fixedPointLambda = (uint32_t)(lambdaScalingFactor * squaredQpLambda * (1<<10));
2271
2272 CODECHAL_FEI_HEVC_I_32x32_PU_MODE_DECISION_CURBE_G9 cmd, *curbe = &cmd;
2273 MOS_ZeroMemory(curbe, sizeof(*curbe));
2274 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
2275 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
2276
2277 curbe->DW1.EnableDebugDump = false;
2278 curbe->DW1.LCUType = (log2MaxCUSize==6)? 0 /*64x64*/ : 1 /*32x32*/;
2279 curbe->DW1.PuType = 0; // 32x32 PU
2280 curbe->DW1.BRCEnable = m_encodeParams.bMbQpDataEnabled || m_brcEnabled;
2281 curbe->DW1.LCUBRCEnable = m_encodeParams.bMbQpDataEnabled || m_lcuBrcEnabled;
2282 curbe->DW1.SliceType = PicCodingTypeToSliceType(m_hevcPicParams->CodingType);
2283 curbe->DW1.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
2284 curbe->DW1.ROIEnable = (m_hevcPicParams->NumROI > 0);
2285 curbe->DW1.SliceQp = sliceQp;
2286 curbe->DW1.EnableStatsDataDump = m_encodeParams.bReportStatisticsEnabled;
2287 curbe->DW1.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
2288
2289 curbe->DW2.Lambda = m_fixedPointLambda;
2290
2291 curbe->DW3.ModeCost32x32 = 0;
2292
2293 curbe->DW4.EarlyExit = (uint32_t)-1;
2294 if (curbe->DW1.EnableStatsDataDump)
2295 {
2296 double lambdaMd;
2297 float hadBias = 2.0f;
2298
2299 lambdaMd = m_qpLambdaMd[curbe->DW1.SliceType][sliceQp];
2300 lambdaMd = lambdaMd * hadBias;
2301 curbe->DW5.NewLambdaForHaarTransform = (uint32_t)(lambdaMd*(1<<10));
2302 }
2303
2304 uint32_t startIndex = 0;
2305 curbe->DW8.BTI_32x32PU_Output = bindingTable->dwBindingTableEntries[startIndex++];
2306 curbe->DW9.BTI_Src_Y = bindingTable->dwBindingTableEntries[startIndex++];
2307 startIndex++; // skip one BTI for Y and UV have the same BTI
2308 curbe->DW10.BTI_Src_Y2x = bindingTable->dwBindingTableEntries[startIndex++];
2309 curbe->DW11.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startIndex++];
2310 curbe->DW12.BTI_Src_Y2x_VME = bindingTable->dwBindingTableEntries[startIndex++];
2311 curbe->DW13.BTI_Brc_Input = bindingTable->dwBindingTableEntries[startIndex++];
2312 curbe->DW14.BTI_LCU_Qp_Surface = bindingTable->dwBindingTableEntries[startIndex++];
2313 curbe->DW15.BTI_Brc_Data = bindingTable->dwBindingTableEntries[startIndex++];
2314 curbe->DW16.BTI_Stats_Data = bindingTable->dwBindingTableEntries[startIndex++];
2315 curbe->DW17.BTI_Kernel_Debug = bindingTable->dwBindingTableEntries[startIndex++];
2316
2317 CODECHAL_ENCODE_ASSERT(startIndex == bindingTable->dwNumBindingTableEntries);
2318
2319 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_32x32_PU_MODE_DECISION;
2320 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2321 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
2322
2323 MOS_COMMAND_BUFFER cmdBuffer;
2324 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
2325 &cmdBuffer,
2326 kernelState,
2327 encFunctionType,
2328 nullptr));
2329
2330 //Add surface states
2331 startIndex = 0;
2332
2333 // 32x32 PU output
2334 m_surfaceParams[SURFACE_32x32_PU_OUTPUT].bIsWritable =
2335 m_surfaceParams[SURFACE_32x32_PU_OUTPUT].bRenderTarget = true;
2336 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2337 kernelState,
2338 &cmdBuffer,
2339 SURFACE_32x32_PU_OUTPUT,
2340 &bindingTable->dwBindingTableEntries[startIndex++]));
2341
2342 // Source Y and UV
2343 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2344 kernelState,
2345 &cmdBuffer,
2346 SURFACE_RAW_Y_UV,
2347 &bindingTable->dwBindingTableEntries[startIndex++]));
2348 startIndex ++; // UV index
2349
2350 // Source Y2x
2351 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2352 kernelState,
2353 &cmdBuffer,
2354 SURFACE_Y_2X,
2355 &bindingTable->dwBindingTableEntries[startIndex++]));
2356
2357 // Slice map
2358 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2359 kernelState,
2360 &cmdBuffer,
2361 SURFACE_SLICE_MAP,
2362 &bindingTable->dwBindingTableEntries[startIndex++]));
2363
2364 // Source Y2x for VME
2365 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2366 kernelState,
2367 &cmdBuffer,
2368 SURFACE_Y_2X_VME,
2369 &bindingTable->dwBindingTableEntries[startIndex++]));
2370
2371 // BRC Input
2372 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2373 kernelState,
2374 &cmdBuffer,
2375 SURFACE_BRC_INPUT,
2376 &bindingTable->dwBindingTableEntries[startIndex++]));
2377
2378 // LCU Qp surface
2379 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2380 kernelState,
2381 &cmdBuffer,
2382 SURFACE_LCU_QP,
2383 &bindingTable->dwBindingTableEntries[startIndex++]));
2384
2385 // BRC data surface
2386 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2387 kernelState,
2388 &cmdBuffer,
2389 SURFACE_BRC_DATA,
2390 &bindingTable->dwBindingTableEntries[startIndex++]));
2391
2392 // skip statstics data dump surface because it is not used
2393
2394 if (!m_hwWalker)
2395 {
2396 eStatus = MOS_STATUS_UNKNOWN;
2397 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
2398 return eStatus;
2399 }
2400
2401 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
2402 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
2403 walkerCodecParams.WalkerMode = m_walkerMode;
2404 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 32) >> 5; /* looping for Walker is needed at 8x8 block level */
2405 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 32) >> 5;
2406 walkerCodecParams.bNoDependency = true; /* Enforce no dependency dispatch order for 32x32 MD kernel */
2407
2408 MHW_WALKER_PARAMS walkerParams;
2409 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
2410 m_hwInterface,
2411 &walkerParams,
2412 &walkerCodecParams));
2413
2414 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
2415 &cmdBuffer,
2416 &walkerParams));
2417
2418 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
2419 encFunctionType,
2420 kernelState,
2421 &cmdBuffer));
2422
2423 return eStatus;
2424 }
2425
2426 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode16x16SadPuComputationKernel()
2427 {
2428 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2429
2430 CODECHAL_ENCODE_FUNCTION_ENTER;
2431
2432 PerfTagSetting perfTag;
2433 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_16X16_SAD);
2434
2435 uint32_t krnIdx = CODECHAL_HEVC_MBENC_16x16SAD;
2436 auto kernelState = &m_mbEncKernelStates[krnIdx];
2437 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
2438 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2439 {
2440 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
2441 }
2442
2443 //Setup DSH
2444 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2445 m_stateHeapInterface,
2446 kernelState,
2447 false,
2448 0,
2449 false,
2450 m_storeData));
2451
2452 // Setup CURBE
2453 CODECHAL_ENC_HEVC_I_16x16_SAD_CURBE_G9 cmd, *curbe = &cmd;
2454
2455 MOS_ZeroMemory(curbe, sizeof(*curbe));
2456 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
2457 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
2458
2459 curbe->DW1.Log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
2460 curbe->DW1.Log2MinCUSize = m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3;
2461 curbe->DW1.Log2MinTUSize = m_hevcSeqParams->log2_min_transform_block_size_minus2 + 2;
2462 curbe->DW1.EnableIntraEarlyExit = (m_hevcSeqParams->TargetUsage == 0x04) ? ((m_hevcPicParams->CodingType == I_TYPE) ? 0 : 1) : 0;
2463
2464 curbe->DW2.SliceType = PicCodingTypeToSliceType(m_hevcPicParams->CodingType);
2465 curbe->DW2.SimFlagForInter = false;
2466 if(m_hevcPicParams->CodingType != I_TYPE)
2467 {
2468 curbe->DW2.FASTSurveillanceFlag = m_hevcSeqParams->bVideoSurveillance;
2469 }
2470
2471 uint32_t startIndex = 0;
2472 curbe->DW8.BTI_Src_Y = bindingTable->dwBindingTableEntries[startIndex++];
2473 startIndex++; // skip UV BTI
2474 curbe->DW9.BTI_Sad_16x16_PU_Output = bindingTable->dwBindingTableEntries[startIndex++];
2475 curbe->DW10.BTI_32x32_Pu_ModeDecision = bindingTable->dwBindingTableEntries[startIndex++];
2476 curbe->DW11.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startIndex++];
2477 curbe->DW12.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startIndex++];
2478 curbe->DW13.BTI_Debug = bindingTable->dwBindingTableEntries[startIndex++];
2479
2480 CODECHAL_ENCODE_ASSERT(startIndex == bindingTable->dwNumBindingTableEntries);
2481
2482 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_16x16_PU_SAD;
2483 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2484 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
2485
2486 MOS_COMMAND_BUFFER cmdBuffer;
2487 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
2488 &cmdBuffer,
2489 kernelState,
2490 encFunctionType,
2491 nullptr));
2492
2493 //Add surface states
2494 startIndex = 0;
2495
2496 // Source Y and UV
2497 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2498 kernelState,
2499 &cmdBuffer,
2500 SURFACE_RAW_Y_UV,
2501 &bindingTable->dwBindingTableEntries[startIndex++]));
2502 startIndex++;
2503
2504 // 16x16 PU SAD output
2505 m_surfaceParams[SURFACE_16x16PU_SAD].bIsWritable =
2506 m_surfaceParams[SURFACE_16x16PU_SAD].bRenderTarget = true;
2507 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2508 kernelState,
2509 &cmdBuffer,
2510 SURFACE_16x16PU_SAD,
2511 &bindingTable->dwBindingTableEntries[startIndex++]));
2512
2513 // 32x32 PU MD data
2514 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2515 kernelState,
2516 &cmdBuffer,
2517 SURFACE_32x32_PU_OUTPUT,
2518 &bindingTable->dwBindingTableEntries[startIndex++]));
2519
2520 // Slice map
2521 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2522 kernelState,
2523 &cmdBuffer,
2524 SURFACE_SLICE_MAP,
2525 &bindingTable->dwBindingTableEntries[startIndex++]));
2526
2527 // Simplest Intra
2528 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2529 kernelState,
2530 &cmdBuffer,
2531 SURFACE_SIMPLIFIED_INTRA,
2532 &bindingTable->dwBindingTableEntries[startIndex++]));
2533
2534 if (!m_hwWalker)
2535 {
2536 eStatus = MOS_STATUS_UNKNOWN;
2537 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
2538 return eStatus;
2539 }
2540
2541 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
2542 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
2543 walkerCodecParams.WalkerMode = m_walkerMode;
2544 /* looping for Walker is needed at 16x16 block level */
2545 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 16) >> 4;
2546 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 16) >> 4;
2547 /* Enforce no dependency dispatch order for the 16x16 SAD kernel */
2548 walkerCodecParams.bNoDependency = true;
2549
2550 MHW_WALKER_PARAMS walkerParams;
2551 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
2552 m_hwInterface,
2553 &walkerParams,
2554 &walkerCodecParams));
2555
2556 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
2557 &cmdBuffer,
2558 &walkerParams));
2559
2560 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
2561 encFunctionType,
2562 kernelState,
2563 &cmdBuffer));
2564
2565 return eStatus;
2566 }
2567
2568 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode16x16PuModeDecisionKernel()
2569 {
2570 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2571
2572 CODECHAL_ENCODE_FUNCTION_ENTER;
2573
2574 PerfTagSetting perfTag;
2575 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_16X16_PU_MD);
2576
2577 uint32_t krnIdx = CODECHAL_HEVC_MBENC_16x16MD;
2578 auto kernelState = &m_mbEncKernelStates[krnIdx];
2579 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
2580 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2581 {
2582 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
2583 }
2584
2585 // Setup DSH
2586 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2587 m_stateHeapInterface,
2588 kernelState,
2589 false,
2590 0,
2591 false,
2592 m_storeData));
2593
2594 // Setup CURBE
2595 int32_t sliceQp = CalSliceQp();
2596 uint8_t sliceType = PicCodingTypeToSliceType(m_hevcPicParams->CodingType);
2597
2598 double lambdaScaleFactor = 0.46 + sliceQp - 22;
2599 if (lambdaScaleFactor < 0)
2600 {
2601 lambdaScaleFactor = 0.46;
2602 }
2603
2604 if (lambdaScaleFactor > 15)
2605 {
2606 lambdaScaleFactor = 15;
2607 }
2608
2609 double squredLambda = lambdaScaleFactor * pow(2.0, ((double)sliceQp-12.0)/6);
2610 m_fixedPointLambdaForLuma = (uint32_t)(squredLambda * (1<<10));
2611
2612 double lambdaScalingFactor = 1.0;
2613 double qpLambda = m_qpLambdaMd[sliceType][sliceQp];
2614 double squaredQpLambda = qpLambda * qpLambda;
2615 m_fixedPointLambdaForChroma = (uint32_t)(lambdaScalingFactor * squaredQpLambda * (1<<10));
2616
2617 LoadCosts(sliceType, (uint8_t)sliceQp, INTRA_TRANSFORM_HAAR);
2618
2619 CODECHAL_FEI_HEVC_I_16x16_PU_MODEDECISION_CURBE_G9 cmd, *curbe = &cmd;
2620 MOS_ZeroMemory(curbe, sizeof(*curbe));
2621
2622 uint32_t log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
2623 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
2624 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
2625
2626 curbe->DW1.Log2MaxCUSize = log2MaxCUSize;
2627 curbe->DW1.Log2MinCUSize = m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3;
2628 curbe->DW1.Log2MinTUSize = m_hevcSeqParams->log2_min_transform_block_size_minus2 + 2;
2629 curbe->DW1.SliceQp = sliceQp;
2630
2631 curbe->DW2.FixedPoint_Lambda_PredMode = m_fixedPointLambdaForChroma;
2632
2633 curbe->DW3.LambdaScalingFactor = 1;
2634 curbe->DW3.SliceType = sliceType;
2635 curbe->DW3.EnableIntraEarlyExit = (m_hevcSeqParams->TargetUsage == 0x04) ? ((m_hevcPicParams->CodingType == I_TYPE) ? 0 : 1) : 0;
2636 curbe->DW3.BRCEnable = m_encodeParams.bMbQpDataEnabled || m_brcEnabled;
2637 curbe->DW3.LCUBRCEnable = m_encodeParams.bMbQpDataEnabled || m_lcuBrcEnabled;
2638 curbe->DW3.ROIEnable = (m_hevcPicParams->NumROI > 0);
2639 curbe->DW3.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
2640 curbe->DW3.EnableRollingIntra = m_hevcPicParams->bEnableRollingIntraRefresh;
2641 //Given only Column Rolling I is supported, if in future, Row Rolling I support to be added, then, need to make change here as per Kernel
2642 curbe->DW3.IntraRefreshEn = m_hevcPicParams->bEnableRollingIntraRefresh;
2643 curbe->DW3.HalfUpdateMixedLCU = 0;
2644 curbe->DW3.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
2645
2646 curbe->DW4.PenaltyForIntra8x8NonDCPredMode = 0;
2647 curbe->DW4.IntraComputeType = 1;
2648 curbe->DW4.AVCIntra8x8Mask = 0;
2649 curbe->DW4.IntraSadAdjust = 2;
2650
2651 double lambdaMd = sqrt(0.57*pow(2.0, ((double)sliceQp-12.0)/3));
2652 squredLambda = lambdaMd * lambdaMd;
2653 uint32_t newLambda = (uint32_t)(squredLambda*(1<<10));
2654 curbe->DW5.FixedPoint_Lambda_CU_Mode_for_Cost_Calculation = newLambda;
2655
2656 curbe->DW6.ScreenContentFlag = m_hevcPicParams->bScreenContent;
2657
2658 curbe->DW7.ModeCostIntraNonPred = m_modeCost[0];
2659 curbe->DW7.ModeCostIntra16x16 = m_modeCost[1];
2660 curbe->DW7.ModeCostIntra8x8 = m_modeCost[2];
2661 curbe->DW7.ModeCostIntra4x4 = m_modeCost[3];
2662
2663 curbe->DW8.FixedPoint_Lambda_CU_Mode_for_Luma = m_fixedPointLambdaForLuma;
2664
2665 if (m_hevcPicParams->bEnableRollingIntraRefresh)
2666 {
2667 curbe->DW9.IntraRefreshMBNum = m_hevcPicParams->IntraInsertionLocation;
2668 curbe->DW9.IntraRefreshQPDelta = m_hevcPicParams->QpDeltaForInsertedIntra;
2669 curbe->DW9.IntraRefreshUnitInMB = m_hevcPicParams->IntraInsertionSize;
2670 }
2671
2672 curbe->DW10.SimplifiedFlagForInter = 0;
2673 if (m_encodeParams.bReportStatisticsEnabled)
2674 {
2675 curbe->DW10.HaarTransformMode = true;
2676 }
2677 else
2678 {
2679 curbe->DW10.HaarTransformMode = (m_hevcPicParams->CodingType == I_TYPE)? false: true;
2680 }
2681
2682 uint32_t startBTI = 0;
2683 curbe->DW16.BTI_Src_Y = bindingTable->dwBindingTableEntries[startBTI++];
2684 startBTI++; // skip UV BTI
2685 curbe->DW17.BTI_Sad_16x16_PU = bindingTable->dwBindingTableEntries[startBTI++];
2686 curbe->DW18.BTI_PAK_Object = bindingTable->dwBindingTableEntries[startBTI++];
2687 curbe->DW19.BTI_SAD_32x32_PU_mode = bindingTable->dwBindingTableEntries[startBTI++];
2688 curbe->DW20.BTI_VME_Mode_8x8 = bindingTable->dwBindingTableEntries[startBTI++];
2689 curbe->DW21.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startBTI++];
2690 curbe->DW22.BTI_VME_Src = bindingTable->dwBindingTableEntries[startBTI++];
2691 curbe->DW23.BTI_BRC_Input = bindingTable->dwBindingTableEntries[startBTI++];
2692 curbe->DW24.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startBTI++];
2693 curbe->DW25.BTI_LCU_Qp_Surface = bindingTable->dwBindingTableEntries[startBTI++];
2694 curbe->DW26.BTI_BRC_Data = bindingTable->dwBindingTableEntries[startBTI++];
2695 curbe->DW27.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
2696
2697 CODECHAL_ENCODE_ASSERT(startBTI == bindingTable->dwNumBindingTableEntries);
2698
2699 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_16x16_PU_MODE_DECISION;
2700 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2701 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
2702
2703 MOS_COMMAND_BUFFER cmdBuffer;
2704 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
2705 &cmdBuffer,
2706 kernelState,
2707 encFunctionType,
2708 nullptr));
2709
2710 //Add surface states
2711 startBTI = 0;
2712
2713 // Source Y and UV:
2714 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2715 kernelState,
2716 &cmdBuffer,
2717 SURFACE_RAW_Y_UV,
2718 &bindingTable->dwBindingTableEntries[startBTI++]));
2719 startBTI++;
2720
2721 // 16x16 PU SAD output
2722 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2723 kernelState,
2724 &cmdBuffer,
2725 SURFACE_16x16PU_SAD,
2726 &bindingTable->dwBindingTableEntries[startBTI++]));
2727
2728 // PAK object output
2729 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2730 kernelState,
2731 &cmdBuffer,
2732 SURFACE_CU_RECORD,
2733 &bindingTable->dwBindingTableEntries[startBTI++]));
2734
2735 // 32x32 PU MD data
2736 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2737 kernelState,
2738 &cmdBuffer,
2739 SURFACE_32x32_PU_OUTPUT,
2740 &bindingTable->dwBindingTableEntries[startBTI++]));
2741
2742 // VME 8x8 mode
2743 m_surfaceParams[SURFACE_VME_8x8].bIsWritable =
2744 m_surfaceParams[SURFACE_VME_8x8].bRenderTarget = true;
2745 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2746 kernelState,
2747 &cmdBuffer,
2748 SURFACE_VME_8x8,
2749 &bindingTable->dwBindingTableEntries[startBTI++]));
2750
2751 // Slice map
2752 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2753 kernelState,
2754 &cmdBuffer,
2755 SURFACE_SLICE_MAP,
2756 &bindingTable->dwBindingTableEntries[startBTI++]));
2757
2758 // Source Y for VME
2759 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2760 kernelState,
2761 &cmdBuffer,
2762 SURFACE_RAW_VME,
2763 &bindingTable->dwBindingTableEntries[startBTI++]));
2764
2765 // BRC Input
2766 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2767 kernelState,
2768 &cmdBuffer,
2769 SURFACE_BRC_INPUT,
2770 &bindingTable->dwBindingTableEntries[startBTI++]));
2771
2772 // Simplest Intra
2773 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2774 kernelState,
2775 &cmdBuffer,
2776 SURFACE_SIMPLIFIED_INTRA,
2777 &bindingTable->dwBindingTableEntries[startBTI++]));
2778
2779 // LCU Qp surface
2780 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2781 kernelState,
2782 &cmdBuffer,
2783 SURFACE_LCU_QP,
2784 &bindingTable->dwBindingTableEntries[startBTI++]));
2785
2786 // BRC data surface
2787 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2788 kernelState,
2789 &cmdBuffer,
2790 SURFACE_BRC_DATA,
2791 &bindingTable->dwBindingTableEntries[startBTI++]));
2792
2793 if (!m_hwWalker)
2794 {
2795 eStatus = MOS_STATUS_UNKNOWN;
2796 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
2797 return eStatus;
2798 }
2799
2800 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
2801 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
2802 walkerCodecParams.WalkerMode = m_walkerMode;
2803 /* looping for Walker is needed at 32x32 block level in OPT case*/
2804 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 32) >> 5;
2805 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 32) >> 5;
2806 walkerCodecParams.bNoDependency = true;
2807
2808 MHW_WALKER_PARAMS walkerParams;
2809 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
2810 m_hwInterface,
2811 &walkerParams,
2812 &walkerCodecParams));
2813
2814 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
2815 &cmdBuffer,
2816 &walkerParams));
2817
2818 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
2819 encFunctionType,
2820 kernelState,
2821 &cmdBuffer));
2822
2823 return eStatus;
2824 }
2825
2826 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode8x8PUKernel()
2827 {
2828 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2829
2830 CODECHAL_ENCODE_FUNCTION_ENTER;
2831
2832 PerfTagSetting perfTag;
2833 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_8X8_PU);
2834
2835 uint32_t krnIdx = CODECHAL_HEVC_MBENC_8x8PU;
2836 auto kernelState = &m_mbEncKernelStates[krnIdx];
2837 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
2838 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2839 {
2840 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
2841 }
2842
2843 // Setup DSH
2844 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2845 m_stateHeapInterface,
2846 kernelState,
2847 false,
2848 0,
2849 false,
2850 m_storeData));
2851
2852 // Setup CURBE
2853 uint32_t log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
2854 CODECHAL_FEI_HEVC_I_8x8_PU_CURBE_G9 cmd, *curbe = &cmd;
2855 MOS_ZeroMemory(curbe, sizeof(*curbe));
2856
2857 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
2858 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
2859 curbe->DW1.SliceType = PicCodingTypeToSliceType(m_hevcPicParams->CodingType);
2860 curbe->DW1.PuType = 2; // 8x8
2861 curbe->DW1.DcFilterFlag = true;
2862 curbe->DW1.AngleRefineFlag = true;
2863 curbe->DW1.LCUType = (log2MaxCUSize==6)? 0 /*64x64*/ : 1 /*32x32*/;
2864 curbe->DW1.ScreenContentFlag = m_hevcPicParams->bScreenContent;
2865 curbe->DW1.EnableIntraEarlyExit = (m_hevcSeqParams->TargetUsage == 0x04) ? ((m_hevcPicParams->CodingType == I_TYPE) ? 0 : 1) : 0;
2866 curbe->DW1.EnableDebugDump = false;
2867 curbe->DW1.BRCEnable = m_encodeParams.bMbQpDataEnabled || m_brcEnabled;
2868 curbe->DW1.LCUBRCEnable = m_encodeParams.bMbQpDataEnabled || m_lcuBrcEnabled;
2869 curbe->DW1.ROIEnable = (m_hevcPicParams->NumROI > 0);
2870 curbe->DW1.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
2871 curbe->DW1.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
2872 curbe->DW1.QPValue = CalSliceQp();
2873 if (m_hevcPicParams->bEnableRollingIntraRefresh)
2874 {
2875 curbe->DW1.EnableRollingIntra = true;
2876 curbe->DW1.IntraRefreshEn = true;
2877 curbe->DW1.HalfUpdateMixedLCU = 0;
2878
2879 curbe->DW5.IntraRefreshMBNum = m_hevcPicParams->IntraInsertionLocation;
2880 curbe->DW5.IntraRefreshQPDelta = m_hevcPicParams->QpDeltaForInsertedIntra;
2881 curbe->DW5.IntraRefreshUnitInMB = m_hevcPicParams->IntraInsertionSize;
2882
2883 int32_t qp = CalSliceQp();
2884 curbe->DW1.QPValue = (uint32_t)qp;
2885 }
2886
2887 curbe->DW2.LumaLambda = m_fixedPointLambdaForLuma;
2888
2889 curbe->DW3.ChromaLambda = m_fixedPointLambdaForChroma;
2890
2891 if (m_encodeParams.bReportStatisticsEnabled)
2892 {
2893 curbe->DW4.HaarTransformFlag = true;
2894 }
2895 else
2896 {
2897 curbe->DW4.HaarTransformFlag = (m_hevcPicParams->CodingType == I_TYPE) ? false : true;
2898 }
2899 curbe->DW4.SimplifiedFlagForInter = false;
2900
2901 uint32_t startBTI = 0;
2902 curbe->DW8.BTI_Src_Y = bindingTable->dwBindingTableEntries[startBTI++];
2903 startBTI++; // skip one BTI for Y and UV have the same BTI
2904 curbe->DW9.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startBTI++];
2905 curbe->DW10.BTI_VME_8x8_Mode = bindingTable->dwBindingTableEntries[startBTI++];
2906 curbe->DW11.BTI_Intra_Mode = bindingTable->dwBindingTableEntries[startBTI++];
2907 curbe->DW12.BTI_BRC_Input = bindingTable->dwBindingTableEntries[startBTI++];
2908 curbe->DW13.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startBTI++];
2909 curbe->DW14.BTI_LCU_Qp_Surface = bindingTable->dwBindingTableEntries[startBTI++];
2910 curbe->DW15.BTI_BRC_Data = bindingTable->dwBindingTableEntries[startBTI++];
2911 curbe->DW16.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
2912
2913 CODECHAL_ENCODE_ASSERT(startBTI == bindingTable->dwNumBindingTableEntries);
2914
2915 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_8x8_PU;
2916 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2917 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
2918
2919 MOS_COMMAND_BUFFER cmdBuffer;
2920 if(m_numMb8x8IntraKernelSplit == 0)
2921 {
2922 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(&cmdBuffer,
2923 kernelState,
2924 encFunctionType,
2925 nullptr));
2926 }
2927 else
2928 {
2929 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2930
2931 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
2932 MOS_ZeroMemory(&idParams, sizeof(idParams));
2933 idParams.pKernelState = kernelState;
2934 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
2935 m_stateHeapInterface,
2936 1,
2937 &idParams));
2938
2939 // Add binding table
2940 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
2941 m_stateHeapInterface,
2942 kernelState));
2943 }
2944
2945 //Add surface states
2946 startBTI = 0;
2947
2948 // Source Y and UV
2949 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2950 kernelState,
2951 &cmdBuffer,
2952 SURFACE_RAW_Y_UV,
2953 &bindingTable->dwBindingTableEntries[startBTI++]));
2954 startBTI++;
2955
2956 // Slice Map
2957 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2958 kernelState,
2959 &cmdBuffer,
2960 SURFACE_SLICE_MAP,
2961 &bindingTable->dwBindingTableEntries[startBTI++]));
2962
2963 // VME 8x8 mode
2964 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2965 kernelState,
2966 &cmdBuffer,
2967 SURFACE_VME_8x8,
2968 &bindingTable->dwBindingTableEntries[startBTI++]));
2969
2970 // Intra mode
2971 m_surfaceParams[SURFACE_INTRA_MODE].bIsWritable =
2972 m_surfaceParams[SURFACE_INTRA_MODE].bRenderTarget = true;
2973 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2974 kernelState,
2975 &cmdBuffer,
2976 SURFACE_INTRA_MODE,
2977 &bindingTable->dwBindingTableEntries[startBTI++]));
2978
2979 // BRC Input
2980 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2981 kernelState,
2982 &cmdBuffer,
2983 SURFACE_BRC_INPUT,
2984 &bindingTable->dwBindingTableEntries[startBTI++]));
2985
2986 // Simplest Intra
2987 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2988 kernelState,
2989 &cmdBuffer,
2990 SURFACE_SIMPLIFIED_INTRA,
2991 &bindingTable->dwBindingTableEntries[startBTI++]));
2992
2993 // LCU Qp surface
2994 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
2995 kernelState,
2996 &cmdBuffer,
2997 SURFACE_LCU_QP,
2998 &bindingTable->dwBindingTableEntries[startBTI++]));
2999
3000 // BRC data surface
3001 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3002 kernelState,
3003 &cmdBuffer,
3004 SURFACE_BRC_DATA,
3005 &bindingTable->dwBindingTableEntries[startBTI++]));
3006
3007 if (!m_hwWalker)
3008 {
3009 eStatus = MOS_STATUS_UNKNOWN;
3010 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
3011 return eStatus;
3012 }
3013
3014 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
3015 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
3016 walkerCodecParams.WalkerMode = m_walkerMode;
3017 // each EU is based on one 8x8 block
3018 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH) >> 3;
3019 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT) >> 3;
3020 /* Enforce no dependency dispatch order for 8x8 PU kernel */
3021 walkerCodecParams.bNoDependency = true;
3022
3023 if(m_numMb8x8IntraKernelSplit == 0)
3024 {
3025 MHW_WALKER_PARAMS walkerParams;
3026 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3027 m_hwInterface,
3028 &walkerParams,
3029 &walkerCodecParams));
3030
3031 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
3032 &cmdBuffer,
3033 &walkerParams));
3034 }
3035 else
3036 {
3037 uint32_t numRowPerSplit = (walkerCodecParams.dwResolutionY + m_numMb8x8IntraKernelSplit - 1) / m_numMb8x8IntraKernelSplit;
3038 uint32_t currentNumRow = 0;
3039
3040 for(uint32_t i = 0; i < m_numMb8x8IntraKernelSplit; i++)
3041 {
3042 // Program render engine pipe commands
3043 SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams();
3044 sendKernelCmdsParams.EncFunctionType = encFunctionType;
3045 sendKernelCmdsParams.pKernelState = kernelState;
3046 sendKernelCmdsParams.bEnableCustomScoreBoard= true;
3047 sendKernelCmdsParams.pCustomScoreBoard = &m_walkingPatternParam.ScoreBoard;
3048 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
3049
3050 MHW_WALKER_PARAMS walkerParams;
3051 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3052 m_hwInterface,
3053 &walkerParams,
3054 &walkerCodecParams));
3055
3056 if(currentNumRow + numRowPerSplit >= walkerCodecParams.dwResolutionY)
3057 {
3058 // the last split may not have the same number of rows as previous splits
3059 numRowPerSplit = walkerCodecParams.dwResolutionY - currentNumRow;
3060 }
3061
3062 walkerParams.LocalStart.y = currentNumRow;
3063 walkerParams.dwLocalLoopExecCount = numRowPerSplit * walkerCodecParams.dwResolutionX;
3064
3065 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
3066 &cmdBuffer,
3067 &walkerParams));
3068
3069 currentNumRow += numRowPerSplit;
3070 if(currentNumRow >= walkerCodecParams.dwResolutionY)
3071 {
3072 break;
3073 }
3074 }
3075 }
3076
3077 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
3078 encFunctionType,
3079 kernelState,
3080 &cmdBuffer));
3081
3082 return eStatus;
3083 }
3084
3085 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode8x8PUFMODEKernel()
3086 {
3087 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3088
3089 CODECHAL_ENCODE_FUNCTION_ENTER;
3090
3091 PerfTagSetting perfTag;
3092 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_8X8_FMODE);
3093
3094 uint32_t krnIdx = CODECHAL_HEVC_MBENC_8x8FMODE;
3095 auto kernelState = &m_mbEncKernelStates[krnIdx];
3096 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
3097 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3098 {
3099 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
3100 }
3101
3102 // Setup DSH
3103 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3104 m_stateHeapInterface,
3105 kernelState,
3106 false,
3107 0,
3108 false,
3109 m_storeData));
3110
3111 // Setup CURBE
3112 int32_t qp = CalSliceQp();
3113 uint32_t sliceQp = (uint32_t)qp;
3114 uint32_t log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
3115
3116 CODECHAL_FEI_HEVC_I_8x8_PU_FMODE_CURBE_G9 cmd, *curbe = &cmd;
3117 MOS_ZeroMemory(curbe, sizeof(*curbe));
3118 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
3119 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
3120
3121 curbe->DW1.SliceType = PicCodingTypeToSliceType(m_hevcPicParams->CodingType);
3122 curbe->DW1.PuType = 2;
3123 curbe->DW1.PakReordingFlag = (m_hevcPicParams->CodingType == I_TYPE)? true : false;
3124 curbe->DW1.LCUType = (log2MaxCUSize == 6)? 0 /*64x64*/: 1 /*32x32*/;
3125 curbe->DW1.ScreenContentFlag = m_hevcPicParams->bScreenContent;
3126 curbe->DW1.EnableIntraEarlyExit = (m_hevcSeqParams->TargetUsage == 0x04) ? ((m_hevcPicParams->CodingType == I_TYPE) ? 0 : 1) : 0;
3127 curbe->DW1.EnableDebugDump = false;
3128 curbe->DW1.BRCEnable = m_encodeParams.bMbQpDataEnabled || m_brcEnabled;
3129 curbe->DW1.LCUBRCEnable = m_encodeParams.bMbQpDataEnabled || m_lcuBrcEnabled;
3130 curbe->DW1.ROIEnable = (m_hevcPicParams->NumROI > 0);
3131 curbe->DW1.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
3132 curbe->DW1.EnableRollingIntra = m_hevcPicParams->bEnableRollingIntraRefresh;
3133 curbe->DW1.IntraRefreshEn = m_hevcPicParams->bEnableRollingIntraRefresh;
3134 curbe->DW1.HalfUpdateMixedLCU = 0;
3135 curbe->DW1.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
3136 curbe->DW2.LambdaForLuma = m_fixedPointLambdaForLuma;
3137
3138 if (m_hevcPicParams->CodingType != I_TYPE ||
3139 m_encodeParams.bReportStatisticsEnabled)
3140 {
3141 float hadBias = 2.0f;
3142
3143 double lambdaMd = m_qpLambdaMd[curbe->DW1.SliceType][sliceQp];
3144 lambdaMd = lambdaMd * hadBias;
3145 curbe->DW3.LambdaForDistCalculation = (uint32_t)(lambdaMd*(1<<10));
3146 }
3147 curbe->DW4.ModeCostFor8x8PU_TU8 = 0;
3148 curbe->DW5.ModeCostFor8x8PU_TU4 = 0;
3149 curbe->DW6.SATD16x16PuThreshold = MOS_MAX(200 * ((int32_t)sliceQp - 12), 0);
3150 curbe->DW6.BiasFactorToward8x8 = (m_hevcPicParams->bScreenContent) ? 1024 : 1126+102;
3151 curbe->DW7.Qp = sliceQp;
3152 curbe->DW7.QpForInter = 0;
3153 curbe->DW8.SimplifiedFlagForInter = false;
3154 curbe->DW8.EnableStatsDataDump = m_encodeParams.bReportStatisticsEnabled;
3155 // KBLControlFlag determines the PAK OBJ format as it varies from Gen9 to Gen9.5+
3156 curbe->DW8.KBLControlFlag = UsePlatformControlFlag();
3157 curbe->DW9.IntraRefreshMBNum = m_hevcPicParams->IntraInsertionLocation;
3158 curbe->DW9.IntraRefreshQPDelta = m_hevcPicParams->QpDeltaForInsertedIntra;
3159 curbe->DW9.IntraRefreshUnitInMB = m_hevcPicParams->IntraInsertionSize;
3160
3161 uint32_t startBTI = 0;
3162 curbe->DW16.BTI_PAK_Object = bindingTable->dwBindingTableEntries[startBTI++];
3163 curbe->DW17.BTI_VME_8x8_Mode = bindingTable->dwBindingTableEntries[startBTI++];
3164 curbe->DW18.BTI_Intra_Mode = bindingTable->dwBindingTableEntries[startBTI++];
3165 curbe->DW19.BTI_PAK_Command = bindingTable->dwBindingTableEntries[startBTI++];
3166 curbe->DW20.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startBTI++];
3167 curbe->DW21.BTI_IntraDist = bindingTable->dwBindingTableEntries[startBTI++];
3168 curbe->DW22.BTI_BRC_Input = bindingTable->dwBindingTableEntries[startBTI++];
3169 curbe->DW23.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startBTI++];
3170 curbe->DW24.BTI_LCU_Qp_Surface = bindingTable->dwBindingTableEntries[startBTI++];
3171 curbe->DW25.BTI_BRC_Data = bindingTable->dwBindingTableEntries[startBTI++];
3172 curbe->DW26.BTI_Haar_Dist16x16 = bindingTable->dwBindingTableEntries[startBTI++];
3173 curbe->DW27.BTI_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
3174 curbe->DW28.BTI_Frame_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
3175 curbe->DW29.BTI_CTB_Distortion_Surface = 0;
3176 startBTI++;
3177 curbe->DW30.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
3178
3179 CODECHAL_ENCODE_ASSERT(startBTI == bindingTable->dwNumBindingTableEntries);
3180
3181 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_8x8_PU_FMODE;
3182 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3183 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
3184
3185 MOS_COMMAND_BUFFER cmdBuffer;
3186 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
3187 &cmdBuffer,
3188 kernelState,
3189 encFunctionType,
3190 nullptr));
3191
3192 //Add surface states
3193 startBTI = 0;
3194
3195 // PAK object
3196 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3197 kernelState,
3198 &cmdBuffer,
3199 SURFACE_CU_RECORD,
3200 &bindingTable->dwBindingTableEntries[startBTI++]));
3201
3202 // VME 8x8 mode
3203 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3204 kernelState,
3205 &cmdBuffer,
3206 SURFACE_VME_8x8,
3207 &bindingTable->dwBindingTableEntries[startBTI++]));
3208
3209 // Intra mode
3210 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3211 kernelState,
3212 &cmdBuffer,
3213 SURFACE_INTRA_MODE,
3214 &bindingTable->dwBindingTableEntries[startBTI++]));
3215
3216 // PAK command
3217 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3218 kernelState,
3219 &cmdBuffer,
3220 SURFACE_HCP_PAK,
3221 &bindingTable->dwBindingTableEntries[startBTI++]));
3222
3223 // Slice Map
3224 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3225 kernelState,
3226 &cmdBuffer,
3227 SURFACE_SLICE_MAP,
3228 &bindingTable->dwBindingTableEntries[startBTI++]));
3229
3230 // Intra dist
3231 m_surfaceParams[SURFACE_INTRA_DIST].bIsWritable =
3232 m_surfaceParams[SURFACE_INTRA_DIST].bRenderTarget = true;
3233 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3234 kernelState,
3235 &cmdBuffer,
3236 SURFACE_INTRA_DIST,
3237 &bindingTable->dwBindingTableEntries[startBTI++]));
3238
3239 // BRC Input
3240 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3241 kernelState,
3242 &cmdBuffer,
3243 SURFACE_BRC_INPUT,
3244 &bindingTable->dwBindingTableEntries[startBTI++]));
3245
3246 // Simplest Intra
3247 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3248 kernelState,
3249 &cmdBuffer,
3250 SURFACE_SIMPLIFIED_INTRA,
3251 &bindingTable->dwBindingTableEntries[startBTI++]));
3252
3253 // LCU Qp surface
3254 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3255 kernelState,
3256 &cmdBuffer,
3257 SURFACE_LCU_QP,
3258 &bindingTable->dwBindingTableEntries[startBTI++]));
3259
3260 // BRC data surface
3261 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3262 kernelState,
3263 &cmdBuffer,
3264 SURFACE_BRC_DATA,
3265 &bindingTable->dwBindingTableEntries[startBTI++]));
3266
3267 // skip haar distortion surface, statstics data dump surface
3268 // and frame level statstics data surface because they are not used
3269
3270 if (!m_hwWalker)
3271 {
3272 eStatus = MOS_STATUS_UNKNOWN;
3273 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
3274 return eStatus;
3275 }
3276
3277 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
3278 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
3279 walkerCodecParams.WalkerMode = m_walkerMode;
3280 // each EU is based on one LCU
3281 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, (1<<log2MaxCUSize)) >> log2MaxCUSize;
3282 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, (1<<log2MaxCUSize)) >> log2MaxCUSize;
3283 /* Enforce no dependency dispatch order for 8x8 PU FMODE kernel */
3284 walkerCodecParams.bNoDependency = true;
3285
3286 MHW_WALKER_PARAMS walkerParams;
3287 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3288 m_hwInterface,
3289 &walkerParams,
3290 &walkerCodecParams));
3291
3292 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
3293 &cmdBuffer,
3294 &walkerParams));
3295
3296 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
3297 encFunctionType,
3298 kernelState,
3299 &cmdBuffer));
3300
3301 return eStatus;
3302 }
3303
3304 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode32X32BIntraCheckKernel()
3305 {
3306 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3307
3308 CODECHAL_ENCODE_FUNCTION_ENTER;
3309
3310 PerfTagSetting perfTag;
3311 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_32X32_B_IC);
3312
3313 uint32_t krnIdx = CODECHAL_HEVC_MBENC_32x32INTRACHECK;
3314 auto kernelState = &m_mbEncKernelStates[krnIdx];
3315 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
3316
3317 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3318 {
3319 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
3320 }
3321
3322 // Setup DSH
3323 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3324 m_stateHeapInterface,
3325 kernelState,
3326 false,
3327 0,
3328 false,
3329 m_storeData));
3330
3331 // Setup CURBE
3332 if (m_pictureCodingType == P_TYPE)
3333 {
3334 CalcLambda(CODECHAL_ENCODE_HEVC_P_SLICE, INTRA_TRANSFORM_HAAR);
3335 }
3336 else
3337 {
3338 CalcLambda(CODECHAL_ENCODE_HEVC_B_SLICE, INTRA_TRANSFORM_HAAR);
3339 }
3340 int32_t sliceQp = CalSliceQp();
3341
3342 double lambdaScalingFactor = 1.0;
3343 double qpLambda = m_qpLambdaMd[CODECHAL_ENCODE_HEVC_I_SLICE][sliceQp];
3344 double squaredQpLambda = qpLambda * qpLambda;
3345 m_fixedPointLambda = (uint32_t)(lambdaScalingFactor * squaredQpLambda * (1<<10));
3346
3347 CODECHAL_FEI_HEVC_B_32x32_PU_INTRA_CHECK_CURBE_G9 cmd, *curbe = &cmd;
3348 MOS_ZeroMemory(curbe, sizeof(*curbe));
3349 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
3350 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
3351
3352 curbe->DW1.EnableDebugDump = false;
3353 curbe->DW1.EnableIntraEarlyExit = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : 1;
3354 curbe->DW1.Flags = 0;
3355 curbe->DW1.Log2MinTUSize = m_hevcSeqParams->log2_min_transform_block_size_minus2 + 2;
3356 curbe->DW1.SliceType = m_hevcSliceParams->slice_type;
3357 curbe->DW1.HMEEnable = 0;
3358 curbe->DW1.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
3359
3360 curbe->DW2.QpMultiplier = 100;
3361 curbe->DW2.QpValue = 0; // MBZ
3362
3363 uint32_t startIndex = 0;
3364 curbe->DW8.BTI_Per32x32PuIntraCheck = bindingTable->dwBindingTableEntries[startIndex++];
3365 curbe->DW9.BTI_Src_Y = bindingTable->dwBindingTableEntries[startIndex++];
3366 startIndex++; // skip one BTI for Y and UV have the same BTI
3367 curbe->DW10.BTI_Src_Y2X = bindingTable->dwBindingTableEntries[startIndex++];
3368 curbe->DW11.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startIndex++];
3369 curbe->DW12.BTI_VME_Y2X = bindingTable->dwBindingTableEntries[startIndex++];
3370 curbe->DW13.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startIndex++];
3371 curbe->DW14.BTI_HME_MVPred = bindingTable->dwBindingTableEntries[startIndex++];
3372 curbe->DW15.BTI_HME_Dist = bindingTable->dwBindingTableEntries[startIndex++];
3373 curbe->DW16.BTI_LCU_Skip = bindingTable->dwBindingTableEntries[startIndex++];
3374 curbe->DW17.BTI_Debug = bindingTable->dwBindingTableEntries[startIndex++];
3375
3376 CODECHAL_ENCODE_ASSERT(startIndex == bindingTable->dwNumBindingTableEntries);
3377
3378 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_32x32_B_INTRA_CHECK;
3379 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3380 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
3381
3382 MOS_COMMAND_BUFFER cmdBuffer;
3383 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
3384 &cmdBuffer,
3385 kernelState,
3386 encFunctionType,
3387 nullptr));
3388
3389 //Add surface states
3390 startIndex = 0;
3391
3392 // 32x32 PU B Intra Check Output
3393 m_surfaceParams[SURFACE_32x32_PU_OUTPUT].bIsWritable =
3394 m_surfaceParams[SURFACE_32x32_PU_OUTPUT].bRenderTarget = true;
3395 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3396 kernelState,
3397 &cmdBuffer,
3398 SURFACE_32x32_PU_OUTPUT,
3399 &bindingTable->dwBindingTableEntries[startIndex++]));
3400
3401 // Source Y and UV
3402 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3403 kernelState,
3404 &cmdBuffer,
3405 SURFACE_RAW_Y_UV,
3406 &bindingTable->dwBindingTableEntries[startIndex++]));
3407 startIndex++;
3408
3409 // Source Y2x
3410 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3411 kernelState,
3412 &cmdBuffer,
3413 SURFACE_Y_2X,
3414 &bindingTable->dwBindingTableEntries[startIndex++]));
3415
3416 // Slice map
3417 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3418 kernelState,
3419 &cmdBuffer,
3420 SURFACE_SLICE_MAP,
3421 &bindingTable->dwBindingTableEntries[startIndex++]));
3422
3423 // Source Y2x for VME
3424 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3425 kernelState,
3426 &cmdBuffer,
3427 SURFACE_Y_2X_VME,
3428 &bindingTable->dwBindingTableEntries[startIndex++]));
3429
3430 // Simplest Intra
3431 m_surfaceParams[SURFACE_SIMPLIFIED_INTRA].bIsWritable =
3432 m_surfaceParams[SURFACE_SIMPLIFIED_INTRA].bRenderTarget = true;
3433 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3434 kernelState,
3435 &cmdBuffer,
3436 SURFACE_SIMPLIFIED_INTRA,
3437 &bindingTable->dwBindingTableEntries[startIndex++]));
3438
3439 // skip SURFACE_HME_MVP and SURFACE_HME_DIST from HME since FEI alsways disables HME
3440 startIndex += 2;
3441
3442 // LCU Qp/Skip surface
3443 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3444 kernelState,
3445 &cmdBuffer,
3446 SURFACE_LCU_QP,
3447 &bindingTable->dwBindingTableEntries[startIndex++]));
3448
3449 if (!m_hwWalker)
3450 {
3451 eStatus = MOS_STATUS_UNKNOWN;
3452 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
3453 return eStatus;
3454 }
3455
3456 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
3457 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
3458 walkerCodecParams.WalkerMode = m_walkerMode;
3459 /* looping for Walker is needed at 8x8 block level */
3460 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 32) >> 5;
3461 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 32) >> 5;
3462 /* Enforce no dependency dispatch order for 32x32 B Intra Check kernel */
3463 walkerCodecParams.bNoDependency = true;
3464
3465 MHW_WALKER_PARAMS walkerParams;
3466 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3467 m_hwInterface,
3468 &walkerParams,
3469 &walkerCodecParams));
3470
3471 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
3472 &cmdBuffer,
3473 &walkerParams));
3474
3475 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
3476 encFunctionType,
3477 kernelState,
3478 &cmdBuffer));
3479
3480 return eStatus;
3481 }
3482
3483 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode8x8BPakKernel(
3484 PCODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9 pEncBCurbe)
3485 {
3486 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3487
3488 CODECHAL_ENCODE_FUNCTION_ENTER;
3489
3490 CODECHAL_ENCODE_CHK_NULL_RETURN(pEncBCurbe);
3491
3492 PerfTagSetting perfTag;
3493 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_PAK_KERNEL);
3494
3495 uint32_t krnIdx = CODECHAL_HEVC_FEI_MBENC_BPAK;
3496 auto kernelState = &m_mbEncKernelStates[krnIdx];
3497 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
3498 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3499 {
3500 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
3501 }
3502
3503 //Setup DSH
3504 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3505 m_stateHeapInterface,
3506 kernelState,
3507 false,
3508 0,
3509 false,
3510 m_storeData));
3511
3512 //Setup CURBE
3513 CODECHAL_FEI_HEVC_B_PAK_CURBE_G9 cmd, *curbe = &cmd;
3514 MOS_ZeroMemory(curbe, sizeof(*curbe));
3515 curbe->DW0.FrameWidth = MOS_ALIGN_CEIL(m_frameWidth, CODECHAL_MACROBLOCK_WIDTH);
3516 curbe->DW0.FrameHeight = MOS_ALIGN_CEIL(m_frameHeight, CODECHAL_MACROBLOCK_HEIGHT);
3517
3518 curbe->DW1.MaxVmvR = pEncBCurbe->DW44.MaxVmvR;
3519 curbe->DW1.Qp = pEncBCurbe->DW13.QpPrimeY;
3520 curbe->DW2.BrcEnable = pEncBCurbe->DW36.BRCEnable;
3521 curbe->DW2.LcuBrcEnable = pEncBCurbe->DW36.LCUBRCEnable;
3522 curbe->DW2.ScreenContent = pEncBCurbe->DW47.ScreenContentFlag;
3523 curbe->DW2.SimplestIntraEnable = pEncBCurbe->DW47.SkipIntraKrnFlag;
3524 curbe->DW2.SliceType = pEncBCurbe->DW4.SliceType;
3525 curbe->DW2.EnableWA = 0;
3526 curbe->DW2.ROIEnable = (m_hevcPicParams->NumROI > 0);
3527 curbe->DW2.FASTSurveillanceFlag = (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
3528 // KBLControlFlag determines the PAK OBJ format as it varies from Gen9 to Gen9.5+
3529 curbe->DW2.KBLControlFlag = UsePlatformControlFlag();
3530 curbe->DW2.EnableRollingIntra = m_hevcPicParams->bEnableRollingIntraRefresh;
3531 curbe->DW2.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
3532 curbe->DW3.IntraRefreshQPDelta = m_hevcPicParams->QpDeltaForInsertedIntra;
3533 curbe->DW3.IntraRefreshMBNum = m_hevcPicParams->IntraInsertionLocation;
3534 curbe->DW3.IntraRefreshUnitInMB = m_hevcPicParams->IntraInsertionSize;
3535
3536 uint32_t startBTI = 0;
3537 curbe->DW16.BTI_CU_Record = bindingTable->dwBindingTableEntries[startBTI++];
3538 curbe->DW17.BTI_PAK_Obj = bindingTable->dwBindingTableEntries[startBTI++];
3539 curbe->DW18.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startBTI++];
3540 curbe->DW19.BTI_Brc_Input = bindingTable->dwBindingTableEntries[startBTI++];
3541 curbe->DW20.BTI_LCU_Qp = bindingTable->dwBindingTableEntries[startBTI++];
3542 curbe->DW21.BTI_Brc_Data = bindingTable->dwBindingTableEntries[startBTI++];
3543 curbe->DW22.BTI_MB_Data = bindingTable->dwBindingTableEntries[startBTI++];
3544 curbe->DW23.BTI_MVP_Surface = bindingTable->dwBindingTableEntries[startBTI++];
3545 curbe->DW24.BTI_WA_PAK_Data = bindingTable->dwBindingTableEntries[startBTI++];
3546 curbe->DW25.BTI_WA_PAK_Obj = bindingTable->dwBindingTableEntries[startBTI++];
3547 curbe->DW26.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
3548
3549 CODECHAL_ENCODE_ASSERT(startBTI == bindingTable->dwNumBindingTableEntries);
3550
3551 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_HEVC_B_PAK;
3552 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3553 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
3554
3555 MOS_COMMAND_BUFFER cmdBuffer;
3556 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(
3557 &cmdBuffer,
3558 kernelState,
3559 encFunctionType,
3560 nullptr));
3561
3562 //Add surface states
3563 startBTI = 0;
3564 //0: CU record
3565 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3566 kernelState,
3567 &cmdBuffer,
3568 SURFACE_CU_RECORD,
3569 &bindingTable->dwBindingTableEntries[startBTI++]));
3570
3571 //1: PAK command
3572 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3573 kernelState,
3574 &cmdBuffer,
3575 SURFACE_HCP_PAK,
3576 &bindingTable->dwBindingTableEntries[startBTI++]));
3577
3578 //2: slice map
3579 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3580 kernelState,
3581 &cmdBuffer,
3582 SURFACE_SLICE_MAP,
3583 &bindingTable->dwBindingTableEntries[startBTI++]));
3584
3585 // 3: BRC Input
3586 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3587 kernelState,
3588 &cmdBuffer,
3589 SURFACE_BRC_INPUT,
3590 &bindingTable->dwBindingTableEntries[startBTI++]));
3591
3592 // 4: LCU Qp
3593 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3594 kernelState,
3595 &cmdBuffer,
3596 SURFACE_LCU_QP,
3597 &bindingTable->dwBindingTableEntries[startBTI++]));
3598
3599 // 5: LCU BRC constant
3600 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3601 kernelState,
3602 &cmdBuffer,
3603 SURFACE_BRC_DATA,
3604 &bindingTable->dwBindingTableEntries[startBTI++]));
3605
3606 // 6: MV index buffer or MB data
3607 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3608 kernelState,
3609 &cmdBuffer,
3610 SURFACE_MB_MV_INDEX,
3611 &bindingTable->dwBindingTableEntries[startBTI++]));
3612
3613 // 7: MVP index buffer
3614 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
3615 kernelState,
3616 &cmdBuffer,
3617 SURFACE_MVP_INDEX,
3618 &bindingTable->dwBindingTableEntries[startBTI++]));
3619
3620 // skip 8 and 9 for SURFACE_WA_CU_RECORD and SURFACE_WA_HCP_PAK
3621
3622 if (!m_hwWalker)
3623 {
3624 eStatus = MOS_STATUS_UNKNOWN;
3625 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
3626 return eStatus;
3627 }
3628
3629 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
3630 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
3631 walkerCodecParams.WalkerMode = m_walkerMode;
3632 /* looping for Walker is needed at 8x8 block level */
3633 walkerCodecParams.dwResolutionX = MOS_ALIGN_CEIL(m_frameWidth, 32) >> 5;
3634 walkerCodecParams.dwResolutionY = MOS_ALIGN_CEIL(m_frameHeight, 32) >> 5;
3635 /* Enforce no dependency dispatch order for 32x32 B Intra Check kernel */
3636 walkerCodecParams.bNoDependency = true;
3637 walkerCodecParams.wPictureCodingType = m_pictureCodingType;
3638 walkerCodecParams.bUseScoreboard = m_useHwScoreboard;
3639
3640 MHW_WALKER_PARAMS walkerParams;
3641 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3642 m_hwInterface,
3643 &walkerParams,
3644 &walkerCodecParams));
3645
3646 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
3647 &cmdBuffer,
3648 &walkerParams));
3649
3650 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
3651 encFunctionType,
3652 kernelState,
3653 &cmdBuffer));
3654
3655 return eStatus;
3656 }
3657
3658 MOS_STATUS CodechalFeiHevcStateG9Skl::Encode8x8PBMbEncKernel()
3659 {
3660 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3661
3662 CODECHAL_ENCODE_FUNCTION_ENTER;
3663
3664 PerfTagSetting perfTag;
3665 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_MBENC_KERNEL);
3666
3667 uint32_t krnIdx = CODECHAL_HEVC_FEI_MBENC_BENC;
3668 if (m_pictureCodingType == P_TYPE)
3669 {
3670 //krnIdx = m_hevcPicParams->bEnableRollingIntraRefresh ? CODECHAL_HEVC_FEI_MBENC_ADV_P : CODECHAL_HEVC_FEI_MBENC_PENC;
3671 krnIdx = CODECHAL_HEVC_FEI_MBENC_PENC;
3672 }
3673 else if (m_pictureCodingType == B_TYPE)
3674 {
3675 // In TU7, we still need the original ENC B kernel to process the I frame
3676 //krnIdx = m_hevcPicParams->bEnableRollingIntraRefresh ? CODECHAL_HEVC_FEI_MBENC_ADV : CODECHAL_HEVC_FEI_MBENC_BENC;
3677 krnIdx = CODECHAL_HEVC_FEI_MBENC_BENC;
3678 }
3679
3680 auto kernelState = &m_mbEncKernelStates[krnIdx];
3681 auto bindingTable = &m_mbEncKernelBindingTable[krnIdx];
3682 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3683 {
3684 CODECHAL_ENCODE_CHK_STATUS_RETURN(RequestSshAndVerifyCommandBufferSize(kernelState));
3685 }
3686
3687 int32_t sliceQp = CalSliceQp();
3688 uint8_t sliceType = PicCodingTypeToSliceType(m_pictureCodingType);
3689
3690 if (m_feiPicParams->FastIntraMode)
3691 {
3692 // When TU=7, lambda is not computed in the 32x32 MD stage for it is skipped.
3693 CalcLambda(sliceType, INTRA_TRANSFORM_HAAR);
3694 }
3695 LoadCosts(sliceType, (uint8_t)sliceQp, INTRA_TRANSFORM_REGULAR);
3696
3697 uint8_t mbCodeIdxForTempMVP = 0xFF;
3698 if(m_pictureCodingType != I_TYPE)
3699 {
3700 if(m_hevcPicParams->CollocatedRefPicIndex != 0xFF && m_hevcPicParams->CollocatedRefPicIndex < CODEC_MAX_NUM_REF_FRAME_HEVC)
3701 {
3702 uint8_t FrameIdx = m_hevcPicParams->RefFrameList[m_hevcPicParams->CollocatedRefPicIndex].FrameIdx;
3703
3704 mbCodeIdxForTempMVP = m_refList[FrameIdx]->ucScalingIdx;
3705 }
3706
3707 if(mbCodeIdxForTempMVP == 0xFF && m_hevcSliceParams->slice_temporal_mvp_enable_flag)
3708 {
3709 // Temporal reference MV index is invalid and so disable the temporal MVP
3710 CODECHAL_ENCODE_ASSERT(false);
3711 m_hevcSliceParams->slice_temporal_mvp_enable_flag = false;
3712 }
3713 }
3714
3715 CODECHAL_ENCODE_CHK_STATUS_RETURN(GenerateWalkingControlRegion());
3716
3717 //Setup DSH
3718 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3719 m_stateHeapInterface,
3720 kernelState,
3721 false,
3722 0,
3723 false,
3724 m_storeData));
3725
3726 //Setup CURBE
3727 uint8_t forwardTransformThd[7] = { 0 };
3728 CalcForwardCoeffThd(forwardTransformThd, sliceQp);
3729
3730 uint32_t curbeSize = 0;
3731 void *defaultCurbe = (void *)GetDefaultCurbeEncBKernel(curbeSize);
3732 CODECHAL_ENCODE_ASSERT(defaultCurbe);
3733
3734 CODECHAL_FEI_HEVC_B_MB_ENC_CURBE_G9 cmd, *curbe = &cmd;
3735 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(curbe, sizeof(cmd), defaultCurbe, curbeSize));
3736
3737 bool transform_8x8_mode_flag = true;
3738 uint32_t SearchPath = (m_feiPicParams->SearchWindow == 5) ? 2 : 1; // 2 means full search, 1 means diamand search
3739 uint32_t LenSP = m_feiPicParams->LenSP;
3740 uint32_t RefWidth = m_feiPicParams->RefWidth;
3741 uint32_t RefHeight = m_feiPicParams->RefHeight;
3742
3743 switch (m_feiPicParams->SearchWindow)
3744 {
3745 case 0:
3746 // not use predefined search window
3747 if((m_feiPicParams->SearchPath != 0) && (m_feiPicParams->SearchPath != 1) && (m_feiPicParams->SearchPath != 2))
3748 {
3749 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC input SearchPath for SearchWindow=0 case!!!.");
3750 eStatus = MOS_STATUS_INVALID_PARAMETER;
3751 return eStatus;
3752 }
3753 SearchPath = m_feiPicParams->SearchPath;
3754 if(((RefWidth * RefHeight) > 2048) || (RefWidth > 64) || (RefHeight > 64))
3755 {
3756 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC input RefWidth/RefHeight size for SearchWindow=0 case!!!.");
3757 eStatus = MOS_STATUS_INVALID_PARAMETER;
3758 return eStatus;
3759 }
3760 break;
3761 case 1:
3762 // Tiny SUs 24x24 window
3763 RefWidth = 24;
3764 RefHeight = 24;
3765 LenSP = 4;
3766 break;
3767 case 2:
3768 // Small SUs 28x28 window
3769 RefWidth = 28;
3770 RefHeight = 28;
3771 LenSP = 9;
3772 break;
3773 case 3:
3774 // Diamond SUs 48x40 window
3775 RefWidth = 48;
3776 RefHeight = 40;
3777 LenSP = 16;
3778 break;
3779 case 4:
3780 // Large Diamond SUs 48x40 window
3781 RefWidth = 48;
3782 RefHeight = 40;
3783 LenSP = 32;
3784 break;
3785 case 5:
3786 // Exhaustive SUs 48x40 window
3787 RefWidth = 48;
3788 RefHeight = 40;
3789 LenSP = 48;
3790 if (m_hevcSeqParams->TargetUsage != 7)
3791 {
3792 if (m_pictureCodingType == B_TYPE)
3793 {
3794 LenSP = 48;
3795 } else {
3796 LenSP = 57;
3797 }
3798 } else {
3799 LenSP = 25;
3800 }
3801 break;
3802 default:
3803 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC SearchWindow value for HEVC FEI on SKL!!!.");
3804 eStatus = MOS_STATUS_INVALID_PARAMETER;
3805 return eStatus;
3806 }
3807
3808 if((m_pictureCodingType == B_TYPE) && (curbe->DW3.BMEDisableFBR == 0))
3809 {
3810 if(RefWidth > 32)
3811 {
3812 RefWidth = 32;
3813 }
3814 if(RefHeight > 32)
3815 {
3816 RefHeight = 32;
3817 }
3818 }
3819
3820 curbe->DW0.AdaptiveEn = m_feiPicParams->AdaptiveSearch;
3821 curbe->DW0.T8x8FlagForInterEn = transform_8x8_mode_flag;
3822 curbe->DW2.PicWidth = m_picWidthInMb;
3823 curbe->DW2.LenSP = LenSP;
3824 curbe->DW3.SrcAccess = curbe->DW3.RefAccess = 0;
3825 if (m_feiPicParams->FastIntraMode)
3826 {
3827 curbe->DW3.FTEnable = (m_ftqBasedSkip[0x07] >> 1) & 0x01;
3828 }
3829 else
3830 {
3831 curbe->DW3.FTEnable = (m_ftqBasedSkip[0x04] >> 1) & 0x01;
3832 }
3833 curbe->DW3.SubPelMode = m_feiPicParams->SubPelMode;
3834
3835 curbe->DW4.PicHeightMinus1 = m_picHeightInMb - 1;
3836 curbe->DW4.EnableStatsDataDump = m_encodeParams.bReportStatisticsEnabled;
3837 curbe->DW4.HMEEnable = 0;
3838 curbe->DW4.SliceType = sliceType;
3839 curbe->DW4.EnableQualityImprovement = m_encodeParams.bQualityImprovementEnable;
3840 curbe->DW4.UseActualRefQPValue = false;
3841
3842 curbe->DW5.RefWidth = RefWidth;
3843 curbe->DW5.RefHeight = RefHeight;
3844
3845 curbe->DW7.IntraPartMask = 0x3;
3846
3847 curbe->DW6.FrameWidth = m_picWidthInMb * CODECHAL_MACROBLOCK_WIDTH;
3848 curbe->DW6.FrameHeight = m_picHeightInMb * CODECHAL_MACROBLOCK_HEIGHT;
3849
3850 curbe->DW8.Mode0Cost = m_modeCost[0];
3851 curbe->DW8.Mode1Cost = m_modeCost[1];
3852 curbe->DW8.Mode2Cost = m_modeCost[2];
3853 curbe->DW8.Mode3Cost = m_modeCost[3];
3854
3855 curbe->DW9.Mode4Cost = m_modeCost[4];
3856 curbe->DW9.Mode5Cost = m_modeCost[5];
3857 curbe->DW9.Mode6Cost = m_modeCost[6];
3858 curbe->DW9.Mode7Cost = m_modeCost[7];
3859
3860 curbe->DW10.Mode8Cost= m_modeCost[8];
3861 curbe->DW10.Mode9Cost= m_modeCost[9];
3862 curbe->DW10.RefIDCost = m_modeCost[10];
3863 curbe->DW10.ChromaIntraModeCost = m_modeCost[11];
3864
3865 curbe->DW11.MV0Cost = m_mvCost[0];
3866 curbe->DW11.MV1Cost = m_mvCost[1];
3867 curbe->DW11.MV2Cost = m_mvCost[2];
3868 curbe->DW11.MV3Cost = m_mvCost[3];
3869
3870 curbe->DW12.MV4Cost = m_mvCost[4];
3871 curbe->DW12.MV5Cost = m_mvCost[5];
3872 curbe->DW12.MV6Cost = m_mvCost[6];
3873 curbe->DW12.MV7Cost = m_mvCost[7];
3874
3875 curbe->DW13.QpPrimeY = sliceQp;
3876 uint8_t bitDepthChromaMinus8 = 0; // support 4:2:0 only
3877 int32_t qpBdOffsetC = 6 * bitDepthChromaMinus8;
3878 int32_t qPi = (int32_t)CodecHal_Clip3((-qpBdOffsetC), 51, (sliceQp + m_hevcPicParams->pps_cb_qp_offset));
3879 int32_t QPc = (qPi < 30) ? qPi : QPcTable[qPi - 30];
3880 curbe->DW13.QpPrimeCb= QPc + qpBdOffsetC;
3881 qPi = (int32_t)CodecHal_Clip3((-qpBdOffsetC), 51, (sliceQp + m_hevcPicParams->pps_cr_qp_offset));
3882 QPc = (qPi < 30) ? qPi : QPcTable[qPi - 30];
3883 curbe->DW13.QpPrimeCr= QPc;
3884
3885 curbe->DW14.SICFwdTransCoeffThreshold_0 = forwardTransformThd[0];
3886 curbe->DW14.SICFwdTransCoeffThreshold_1 = forwardTransformThd[1];
3887 curbe->DW14.SICFwdTransCoeffThreshold_2 = forwardTransformThd[2];
3888
3889 curbe->DW15.SICFwdTransCoeffThreshold_3 = forwardTransformThd[3];
3890 curbe->DW15.SICFwdTransCoeffThreshold_4 = forwardTransformThd[4];
3891 curbe->DW15.SICFwdTransCoeffThreshold_5 = forwardTransformThd[5];
3892 curbe->DW15.SICFwdTransCoeffThreshold_6 = forwardTransformThd[6];
3893
3894 if (SearchPath == 1)
3895 {
3896 // diamond search
3897 if (m_pictureCodingType == P_TYPE)
3898 {
3899 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(curbe->DW16), 14 * sizeof(uint32_t), &(m_encBTu7PCurbeInit[16]), 14 * sizeof(uint32_t)));
3900 }
3901 else if (m_pictureCodingType == B_TYPE)
3902 {
3903 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(curbe->DW16), 14 * sizeof(uint32_t), &(m_encBTu7BCurbeInit[16]), 14 * sizeof(uint32_t)));
3904 }
3905 }
3906 else if((SearchPath != 0) && (SearchPath != 2))
3907 {
3908 // default 0 and 2 are full sparil search
3909 CODECHAL_ENCODE_ASSERT(false);
3910 }
3911
3912 curbe->DW32.SkipVal = m_skipValB[curbe->DW3.BlockBasedSkipEnable][transform_8x8_mode_flag][sliceQp];
3913
3914 if(m_pictureCodingType == I_TYPE)
3915 {
3916 *(float*)&(curbe->DW34.LambdaME) = 0.0;
3917 }
3918 else if (m_pictureCodingType == P_TYPE)
3919 {
3920 *(float*)&(curbe->DW34.LambdaME) = (float)m_qpLambdaMe[CODECHAL_ENCODE_HEVC_P_SLICE][sliceQp];
3921 }
3922 else
3923 {
3924 *(float*)&(curbe->DW34.LambdaME) = (float)m_qpLambdaMe[CODECHAL_ENCODE_HEVC_B_SLICE][sliceQp];
3925 }
3926
3927 curbe->DW35.ModeCostSp = m_modeCostSp;
3928 curbe->DW35.SimpIntraInterThreshold = m_simplestIntraInterThreshold;
3929
3930 curbe->DW36.NumRefIdxL0MinusOne = m_hevcSliceParams->num_ref_idx_l0_active_minus1;
3931 curbe->DW36.NumRefIdxL1MinusOne = m_hevcSliceParams->num_ref_idx_l1_active_minus1;
3932 curbe->DW36.BRCEnable = m_encodeParams.bMbQpDataEnabled || m_brcEnabled;
3933 curbe->DW36.LCUBRCEnable = m_encodeParams.bMbQpDataEnabled || m_lcuBrcEnabled;
3934 curbe->DW36.PowerSaving = m_powerSavingEnabled;
3935 curbe->DW36.ROIEnable = (m_hevcPicParams->NumROI > 0);
3936 curbe->DW36.FASTSurveillanceFlag= (m_hevcPicParams->CodingType == I_TYPE) ? 0 : m_hevcSeqParams->bVideoSurveillance;
3937
3938 if(m_pictureCodingType != I_TYPE)
3939 {
3940 curbe->DW37.ActualQpRefID0List0 = GetQPValueFromRefList(LIST_0, CODECHAL_ENCODE_REF_ID_0);
3941 curbe->DW37.ActualQpRefID1List0 = GetQPValueFromRefList(LIST_0, CODECHAL_ENCODE_REF_ID_1);
3942 curbe->DW37.ActualQpRefID2List0 = GetQPValueFromRefList(LIST_0, CODECHAL_ENCODE_REF_ID_2);
3943 curbe->DW37.ActualQpRefID3List0 = GetQPValueFromRefList(LIST_0, CODECHAL_ENCODE_REF_ID_3);
3944 curbe->DW41.TextureIntraCostThreshold = 500;
3945
3946 if(m_pictureCodingType == B_TYPE) {
3947 curbe->DW39.ActualQpRefID0List1 = GetQPValueFromRefList(LIST_1, CODECHAL_ENCODE_REF_ID_0);
3948 curbe->DW39.ActualQpRefID1List1 = GetQPValueFromRefList(LIST_1, CODECHAL_ENCODE_REF_ID_1);
3949 float lambda_me = (float)m_qpLambdaMe[CODECHAL_ENCODE_HEVC_B_SLICE][sliceQp];
3950 if (m_encodeParams.bQualityImprovementEnable)
3951 {
3952 curbe->DW40.TransformThreshold0 = (uint16_t) (lambda_me * 56.25 + 0.5);
3953 curbe->DW40.TransformThreshold1 = (uint16_t) (lambda_me * 21 + 0.5);
3954 curbe->DW41.TransformThreshold2 = (uint16_t) (lambda_me * 9 + 0.5);
3955 }
3956 }
3957 }
3958
3959 curbe->DW42.NumMVPredictorsL0 = m_feiPicParams->NumMVPredictorsL0;
3960 curbe->DW42.NumMVPredictorsL1 = m_feiPicParams->NumMVPredictorsL1;
3961 curbe->DW42.PerLCUQP = m_encodeParams.bMbQpDataEnabled;
3962 curbe->DW42.PerCTBInput = m_feiPicParams->bPerCTBInput;
3963 curbe->DW42.CTBDistortionOutput = m_feiPicParams->bDistortionEnable;
3964 curbe->DW42.MultiPredL0 = m_feiPicParams->MultiPredL0;
3965 curbe->DW42.MultiPredL1 = m_feiPicParams->MultiPredL1;
3966 curbe->DW42.MVPredictorBlockSize = m_feiPicParams->MVPredictorInput;
3967
3968 curbe->DW44.MaxVmvR = 511 * 4;
3969 curbe->DW44.MaxNumMergeCandidates = m_hevcSliceParams->MaxNumMergeCand;
3970
3971 if(m_pictureCodingType != I_TYPE)
3972 {
3973 curbe->DW44.MaxNumRefList0 = curbe->DW36.NumRefIdxL0MinusOne + 1;
3974
3975 curbe->DW45.TemporalMvpEnableFlag = m_hevcSliceParams->slice_temporal_mvp_enable_flag;
3976 curbe->DW45.HMECombineLenPslice = 8;
3977 if(m_pictureCodingType == B_TYPE)
3978 {
3979 curbe->DW44.MaxNumRefList1 = curbe->DW36.NumRefIdxL1MinusOne + 1;
3980 curbe->DW45.HMECombineLenBslice = 8;
3981 }
3982 }
3983
3984 curbe->DW45.Log2ParallelMergeLevel = m_hevcPicParams->log2_parallel_merge_level_minus2 + 2;
3985
3986 curbe->DW46.Log2MaxTUSize = m_hevcSeqParams->log2_max_transform_block_size_minus2 + 2;
3987 curbe->DW46.Log2MinTUSize = m_hevcSeqParams->log2_min_transform_block_size_minus2 + 2;
3988 curbe->DW46.Log2MaxCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
3989 curbe->DW46.Log2MinCUSize = m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3;
3990
3991 curbe->DW47.NumRegionsInSlice = m_numRegionsInSlice;
3992 curbe->DW47.TypeOfWalkingPattern = m_enable26WalkingPattern;
3993 curbe->DW47.ChromaFlatnessCheckFlag= (m_feiPicParams->FastIntraMode) ? 0 : 1;
3994 curbe->DW47.EnableIntraEarlyExit = (m_feiPicParams->FastIntraMode) ? 0 : 1;
3995 curbe->DW47.SkipIntraKrnFlag = (m_feiPicParams->FastIntraMode) ? 1 : 0;
3996 curbe->DW47.CollocatedFromL0Flag = m_hevcSliceParams->collocated_from_l0_flag;
3997 curbe->DW47.IsLowDelay = m_lowDelay;
3998 curbe->DW47.ScreenContentFlag = m_hevcPicParams->bScreenContent;
3999 curbe->DW47.MultiSliceFlag = (m_numSlices > 1);
4000 curbe->DW47.ArbitarySliceFlag = m_arbitraryNumMbsInSlice;
4001 curbe->DW47.NumRegionMinus1 = m_walkingPatternParam.dwNumRegion - 1;
4002
4003 if(m_pictureCodingType != I_TYPE)
4004 {
4005 curbe->DW48.CurrentTdL0_0 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[0][0]);
4006 curbe->DW48.CurrentTdL0_1 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[0][1]);
4007 curbe->DW49.CurrentTdL0_2 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[0][2]);
4008 curbe->DW49.CurrentTdL0_3 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[0][3]);
4009 if(m_pictureCodingType == B_TYPE) {
4010 curbe->DW50.CurrentTdL1_0 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[1][0]);
4011 curbe->DW50.CurrentTdL1_1 = ComputeTemporalDifference(m_hevcSliceParams->RefPicList[1][1]);
4012 }
4013 }
4014
4015 curbe->DW52.NumofUnitInRegion = m_walkingPatternParam.dwNumUnitsInRegion;
4016 curbe->DW52.MaxHeightInRegion = m_walkingPatternParam.dwMaxHeightInRegion;
4017
4018 uint32_t startBTI = 0;
4019 curbe->DW56.BTI_CU_Record = bindingTable->dwBindingTableEntries[startBTI++];
4020 curbe->DW57.BTI_PAK_Cmd = bindingTable->dwBindingTableEntries[startBTI++];
4021 curbe->DW58.BTI_Src_Y = bindingTable->dwBindingTableEntries[startBTI++];
4022 startBTI++; //skip UV index
4023 curbe->DW59.BTI_Intra_Dist = bindingTable->dwBindingTableEntries[startBTI++];
4024 curbe->DW60.BTI_Min_Dist = bindingTable->dwBindingTableEntries[startBTI++];
4025 curbe->DW61.BTI_HMEMVPredFwdBwdSurfIndex = bindingTable->dwBindingTableEntries[startBTI++];
4026 curbe->DW62.BTI_HMEDistSurfIndex = bindingTable->dwBindingTableEntries[startBTI++];
4027 curbe->DW63.BTI_Slice_Map = bindingTable->dwBindingTableEntries[startBTI++];
4028 curbe->DW64.BTI_VME_Saved_UNI_SIC = bindingTable->dwBindingTableEntries[startBTI++];
4029 curbe->DW65.BTI_Simplest_Intra = bindingTable->dwBindingTableEntries[startBTI++];
4030 curbe->DW66.BTI_Collocated_RefFrame = bindingTable->dwBindingTableEntries[startBTI++];
4031 curbe->DW67.BTI_Reserved = bindingTable->dwBindingTableEntries[startBTI++];
4032 curbe->DW68.BTI_BRC_Input = bindingTable->dwBindingTableEntries[startBTI++];
4033 curbe->DW69.BTI_LCU_QP = bindingTable->dwBindingTableEntries[startBTI++];
4034 curbe->DW70.BTI_BRC_Data = bindingTable->dwBindingTableEntries[startBTI++];
4035 curbe->DW71.BTI_VMEInterPredictionSurfIndex= bindingTable->dwBindingTableEntries[startBTI++];
4036 if(m_pictureCodingType == P_TYPE)
4037 {
4038 //P MBEnc curbe 72~75 are different from B frame.
4039 startBTI += (CODECHAL_HEVC_P_MBENC_CONCURRENT_THD_MAP - CODECHAL_HEVC_P_MBENC_VME_FORWARD_0);
4040 curbe->DW72.BTI_ConcurrentThreadMap= bindingTable->dwBindingTableEntries[startBTI++];
4041 curbe->DW73.BTI_MB_Data_CurFrame = bindingTable->dwBindingTableEntries[startBTI++];
4042 curbe->DW74.BTI_MVP_CurFrame = bindingTable->dwBindingTableEntries[startBTI++];
4043 curbe->DW75.BTI_Haar_Dist16x16 = bindingTable->dwBindingTableEntries[startBTI++];
4044 curbe->DW76.BTI_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
4045 curbe->DW77.BTI_Frame_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
4046 curbe->DW78.BTI_MVPredictor_Surface= bindingTable->dwBindingTableEntries[startBTI++];
4047 curbe->DW79.BTI_CTB_Input_Surface = bindingTable->dwBindingTableEntries[startBTI++];
4048 curbe->DW80.BTI_CTB_Distortion_Output_Surface = bindingTable->dwBindingTableEntries[startBTI++];
4049 curbe->DW81.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
4050 }
4051 else
4052 {
4053 startBTI += (CODECHAL_HEVC_B_MBENC_VME_BACKWARD_7 - CODECHAL_HEVC_B_MBENC_VME_FORWARD_0 + 1);
4054
4055 curbe->DW72.BTI_VMEInterPredictionBSurfIndex = bindingTable->dwBindingTableEntries[startBTI++];
4056 startBTI += (CODECHAL_HEVC_B_MBENC_VME_MUL_NOUSE_3 - CODECHAL_HEVC_B_MBENC_VME_MUL_BACKWARD_0 + 1);
4057
4058 curbe->DW73.BTI_ConcurrentThreadMap= bindingTable->dwBindingTableEntries[startBTI++];
4059 curbe->DW74.BTI_MB_Data_CurFrame = bindingTable->dwBindingTableEntries[startBTI++];
4060 curbe->DW75.BTI_MVP_CurFrame = bindingTable->dwBindingTableEntries[startBTI++];
4061 curbe->DW76.BTI_Haar_Dist16x16 = bindingTable->dwBindingTableEntries[startBTI++];
4062 curbe->DW77.BTI_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
4063 curbe->DW78.BTI_Frame_Stats_Data = bindingTable->dwBindingTableEntries[startBTI++];
4064 curbe->DW79.BTI_MVPredictor_Surface= bindingTable->dwBindingTableEntries[startBTI++];
4065 curbe->DW80.BTI_CTB_Input_Surface = bindingTable->dwBindingTableEntries[startBTI++];
4066 curbe->DW81.BTI_CTB_Distortion_Output_Surface = bindingTable->dwBindingTableEntries[startBTI++];
4067 curbe->DW82.BTI_Debug = bindingTable->dwBindingTableEntries[startBTI++];
4068 }
4069
4070 // Intra refresh is enabled. Program related CURBE fields
4071 if (m_hevcPicParams->bEnableRollingIntraRefresh)
4072 {
4073 curbe->DW35.IntraRefreshEn = true;
4074 curbe->DW35.FirstIntraRefresh = m_firstIntraRefresh;
4075 curbe->DW35.HalfUpdateMixedLCU = 0;
4076 curbe->DW35.EnableRollingIntra = true;
4077
4078 curbe->DW38.NumFrameInGOB = m_frameNumInGob;
4079 curbe->DW38.NumIntraRefreshOffFrames = m_frameNumWithoutIntraRefresh;
4080
4081 curbe->DW51.IntraRefreshQPDelta = m_hevcPicParams->QpDeltaForInsertedIntra;
4082 curbe->DW51.IntraRefreshMBNum = m_hevcPicParams->IntraInsertionLocation;
4083 curbe->DW51.IntraRefreshUnitInMB = m_hevcPicParams->IntraInsertionSize;
4084
4085 curbe->DW53.IntraRefreshRefHeight = 40;
4086 curbe->DW53.IntraRefreshRefWidth = 48;
4087
4088 m_firstIntraRefresh = false;
4089 m_frameNumWithoutIntraRefresh = 0;
4090 }
4091 else if (m_pictureCodingType != I_TYPE) // don't increment num frames w/o refresh in case of TU7 I frames
4092 {
4093 m_frameNumWithoutIntraRefresh++;
4094 }
4095
4096 CODECHAL_ENCODE_ASSERT(startBTI == bindingTable->dwNumBindingTableEntries);
4097
4098 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_HEVC_B_MBENC;
4099 if (m_pictureCodingType == P_TYPE)
4100 {
4101 //P frame curbe only use the DW0~DW75
4102 CODECHAL_ENCODE_CHK_STATUS_RETURN(
4103 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd) - sizeof(uint32_t)));
4104 }
4105 else
4106 {
4107 CODECHAL_ENCODE_CHK_STATUS_RETURN(
4108 AddCurbeToStateHeap(kernelState, encFunctionType, &cmd, sizeof(cmd)));
4109 }
4110
4111 MOS_COMMAND_BUFFER cmdBuffer;
4112 if(m_numMbBKernelSplit == 0)
4113 {
4114 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendKernelCmdsAndBindingTable(&cmdBuffer,
4115 kernelState,
4116 encFunctionType,
4117 &m_walkingPatternParam.ScoreBoard));
4118 }
4119 else
4120 {
4121 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
4122
4123 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
4124 MOS_ZeroMemory(&idParams, sizeof(idParams));
4125 idParams.pKernelState = kernelState;
4126 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
4127 m_stateHeapInterface,
4128 1,
4129 &idParams));
4130
4131 // Add binding table
4132 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
4133 m_stateHeapInterface,
4134 kernelState));
4135 }
4136
4137 //Add surface states
4138 startBTI = 0;
4139
4140 //0: CU record
4141 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4142 kernelState,
4143 &cmdBuffer,
4144 SURFACE_CU_RECORD,
4145 &bindingTable->dwBindingTableEntries[startBTI++]));
4146
4147 //1: PAK command
4148 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4149 kernelState,
4150 &cmdBuffer,
4151 SURFACE_HCP_PAK,
4152 &bindingTable->dwBindingTableEntries[startBTI++]));
4153
4154 //2 and 3 Source Y and UV
4155 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4156 kernelState,
4157 &cmdBuffer,
4158 SURFACE_RAW_Y_UV,
4159 &bindingTable->dwBindingTableEntries[startBTI++]));
4160 startBTI++;
4161
4162 //4: Intra dist
4163 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4164 kernelState,
4165 &cmdBuffer,
4166 SURFACE_INTRA_DIST,
4167 &bindingTable->dwBindingTableEntries[startBTI++]));
4168
4169 //5: min distortion
4170 m_surfaceParams[SURFACE_MIN_DIST].bIsWritable =
4171 m_surfaceParams[SURFACE_MIN_DIST].bRenderTarget = true;
4172 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4173 kernelState,
4174 &cmdBuffer,
4175 SURFACE_MIN_DIST,
4176 &bindingTable->dwBindingTableEntries[startBTI++]));
4177
4178 // 6 and 7, skip SURFACE_HME_MVP and SURFACE_HME_DIST from HME since FEI alsways disables HME
4179 startBTI += 2;
4180
4181 //8: slice map
4182 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4183 kernelState,
4184 &cmdBuffer,
4185 SURFACE_SLICE_MAP,
4186 &bindingTable->dwBindingTableEntries[startBTI++]));
4187
4188 //9: VME UNI and SIC data
4189 m_surfaceParams[SURFACE_VME_UNI_SIC_DATA].bIsWritable =
4190 m_surfaceParams[SURFACE_VME_UNI_SIC_DATA].bRenderTarget = true;
4191 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4192 kernelState,
4193 &cmdBuffer,
4194 SURFACE_VME_UNI_SIC_DATA,
4195 &bindingTable->dwBindingTableEntries[startBTI++]));
4196
4197 //10: Simplest Intra
4198 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4199 kernelState,
4200 &cmdBuffer,
4201 SURFACE_SIMPLIFIED_INTRA,
4202 &bindingTable->dwBindingTableEntries[startBTI++]));
4203
4204 // 11: Reference frame col-located data surface
4205 if(mbCodeIdxForTempMVP == 0xFF)
4206 {
4207 startBTI++;
4208 }
4209 else
4210 {
4211 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4212 kernelState,
4213 &cmdBuffer,
4214 SURFACE_COL_MB_MV,
4215 &bindingTable->dwBindingTableEntries[startBTI++],
4216 m_trackedBuf->GetMvTemporalBuffer(mbCodeIdxForTempMVP)));
4217 }
4218
4219 // 12: Current frame col-located data surface -- reserved now
4220 startBTI++;
4221
4222 // 13: BRC Input
4223 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4224 kernelState,
4225 &cmdBuffer,
4226 SURFACE_BRC_INPUT,
4227 &bindingTable->dwBindingTableEntries[startBTI++]));
4228
4229 // 14: LCU Qp
4230 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4231 kernelState,
4232 &cmdBuffer,
4233 SURFACE_LCU_QP,
4234 &bindingTable->dwBindingTableEntries[startBTI++]));
4235
4236 // 15: LCU BRC constant
4237 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4238 kernelState,
4239 &cmdBuffer,
4240 SURFACE_BRC_DATA,
4241 &bindingTable->dwBindingTableEntries[startBTI++]));
4242
4243 // 16 - 32 Current plus forward and backward surface 0-7
4244 //16: Source Y for VME
4245 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4246 kernelState,
4247 &cmdBuffer,
4248 SURFACE_RAW_VME,
4249 &bindingTable->dwBindingTableEntries[startBTI++]));
4250
4251 for(uint32_t surfaceIdx = 0; surfaceIdx < 8; surfaceIdx++)
4252 {
4253 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[LIST_0][surfaceIdx];
4254 if(!CodecHal_PictureIsInvalid(refPic) &&
4255 !CodecHal_PictureIsInvalid(m_hevcPicParams->RefFrameList[refPic.FrameIdx]))
4256 {
4257 uint8_t idx = m_hevcPicParams->RefFrameList[refPic.FrameIdx].FrameIdx;
4258
4259 // Picture Y VME
4260 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4261 kernelState,
4262 &cmdBuffer,
4263 SURFACE_REF_FRAME_VME,
4264 &bindingTable->dwBindingTableEntries[startBTI++],
4265 &m_refList[idx]->sRefBuffer,
4266 curbe->DW6.FrameWidth,
4267 curbe->DW6.FrameHeight));
4268
4269 }
4270 else
4271 {
4272 // Skip the binding table index because it is not used
4273 startBTI++;
4274 }
4275
4276 refPic = m_hevcSliceParams->RefPicList[LIST_1][surfaceIdx];
4277 if(!CodecHal_PictureIsInvalid(refPic) &&
4278 !CodecHal_PictureIsInvalid(m_hevcPicParams->RefFrameList[refPic.FrameIdx]))
4279 {
4280 uint8_t idx = m_hevcPicParams->RefFrameList[refPic.FrameIdx].FrameIdx;
4281
4282 // Picture Y VME
4283 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4284 kernelState,
4285 &cmdBuffer,
4286 SURFACE_REF_FRAME_VME,
4287 &bindingTable->dwBindingTableEntries[startBTI++],
4288 &m_refList[idx]->sRefBuffer,
4289 curbe->DW6.FrameWidth,
4290 curbe->DW6.FrameHeight));
4291
4292 }
4293 else
4294 {
4295 // Skip the binding table index because it is not used
4296 startBTI++;
4297 }
4298 }
4299 CODECHAL_ENCODE_ASSERT(startBTI == CODECHAL_HEVC_B_MBENC_VME_BACKWARD_7 - CODECHAL_HEVC_B_MBENC_BEGIN + 1);
4300
4301 if (m_pictureCodingType != P_TYPE)
4302 {
4303 //33-41 VME multi-ref BTI -- Current plus [backward, nil][0..3]
4304 //33: Current Y VME surface
4305 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4306 kernelState,
4307 &cmdBuffer,
4308 SURFACE_RAW_VME,
4309 &bindingTable->dwBindingTableEntries[startBTI++]));
4310
4311 for(uint32_t surfaceIdx = 0; surfaceIdx < 4; surfaceIdx++)
4312 {
4313 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[1][surfaceIdx];
4314 if(!CodecHal_PictureIsInvalid(refPic) &&
4315 !CodecHal_PictureIsInvalid(m_hevcPicParams->RefFrameList[refPic.FrameIdx]))
4316 {
4317 uint8_t idx = m_hevcPicParams->RefFrameList[refPic.FrameIdx].FrameIdx;
4318
4319 // Picture Y VME
4320 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4321 kernelState,
4322 &cmdBuffer,
4323 SURFACE_REF_FRAME_VME,
4324 &bindingTable->dwBindingTableEntries[startBTI++],
4325 &m_refList[idx]->sRefBuffer,
4326 curbe->DW6.FrameWidth,
4327 curbe->DW6.FrameHeight));
4328 }
4329 else
4330 {
4331 // Skip the binding table index because it is not used
4332 startBTI++;
4333 }
4334
4335 // Skip the binding table index because it is not used
4336 startBTI++;
4337 }
4338 CODECHAL_ENCODE_ASSERT(startBTI == CODECHAL_HEVC_B_MBENC_VME_MUL_NOUSE_3 - CODECHAL_HEVC_B_MBENC_BEGIN + 1);
4339 }
4340
4341 // B 42 or P 33: Concurrent thread
4342 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4343 kernelState,
4344 &cmdBuffer,
4345 (SURFACE_ID)(SURFACE_CONCURRENT_THREAD + m_concurrentThreadIndex),
4346 &bindingTable->dwBindingTableEntries[startBTI++]));
4347
4348 if (++m_concurrentThreadIndex >= NUM_CONCURRENT_THREAD)
4349 {
4350 m_concurrentThreadIndex = 0;
4351 }
4352
4353 // B 43 or P 34: MV index buffer
4354 m_surfaceParams[SURFACE_MB_MV_INDEX].bIsWritable =
4355 m_surfaceParams[SURFACE_MB_MV_INDEX].bRenderTarget = true;
4356 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4357 kernelState,
4358 &cmdBuffer,
4359 SURFACE_MB_MV_INDEX,
4360 &bindingTable->dwBindingTableEntries[startBTI++]));
4361
4362 // B 44: or P 35: MVP index buffer
4363 m_surfaceParams[SURFACE_MVP_INDEX].bIsWritable =
4364 m_surfaceParams[SURFACE_MVP_INDEX].bRenderTarget = true;
4365 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4366 kernelState,
4367 &cmdBuffer,
4368 SURFACE_MVP_INDEX,
4369 &bindingTable->dwBindingTableEntries[startBTI++]));
4370
4371 // skip three BTI for haar distortion surface, statstics data dump surface
4372 // and frame level statstics data surface because they are not used
4373 startBTI += 3;
4374
4375 // 48: FEI external MVPredictor surface
4376 if (m_feiPicParams->MVPredictorInput)
4377 {
4378 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4379 kernelState,
4380 &cmdBuffer,
4381 SURFACE_FEI_EXTERNAL_MVP,
4382 &bindingTable->dwBindingTableEntries[startBTI++]));
4383 }
4384 else
4385 {
4386 startBTI++;
4387 }
4388
4389 if (m_feiPicParams->bPerCTBInput)
4390 {
4391 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSurfacesState(
4392 kernelState,
4393 &cmdBuffer,
4394 SURFACE_FEI_PER_CTB_CTRL,
4395 &bindingTable->dwBindingTableEntries[startBTI++]));
4396 }
4397 else
4398 {
4399 startBTI ++;
4400 }
4401 startBTI += 1;
4402
4403 if (!m_hwWalker)
4404 {
4405 eStatus = MOS_STATUS_UNKNOWN;
4406 CODECHAL_ENCODE_ASSERTMESSAGE("Currently HW walker shall not be disabled for CM based down scaling kernel.");
4407 return eStatus;
4408 }
4409
4410 if(m_numMbBKernelSplit == 0)
4411 {
4412 // always use customized media walker
4413 MHW_WALKER_PARAMS walkerParams;
4414 MOS_SecureMemcpy(&walkerParams, sizeof(walkerParams), &m_walkingPatternParam.MediaWalker, sizeof(m_walkingPatternParam.MediaWalker));
4415 walkerParams.ColorCountMinusOne = m_walkingPatternParam.dwNumRegion - 1;
4416
4417 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
4418 &cmdBuffer,
4419 &walkerParams));
4420 }
4421 else
4422 {
4423 int32_t localOuterLoopExecCount = m_walkingPatternParam.MediaWalker.dwLocalLoopExecCount;
4424 int32_t localInitialStartPointY = m_walkingPatternParam.MediaWalker.LocalStart.y;
4425 int32_t phase = MOS_MIN(m_numMbBKernelSplit, MAX_NUM_KERNEL_SPLIT);
4426 int32_t totalExecCount = localOuterLoopExecCount + 1;
4427 int32_t deltaExecCount = (((totalExecCount+phase - 1) / phase) + 1) & 0xfffe;
4428 int32_t remainExecCount = totalExecCount;
4429
4430 int32_t deltaY = 0;
4431 if (m_enable26WalkingPattern)
4432 {
4433 deltaY = deltaExecCount / 2;
4434 }
4435 else
4436 {
4437 deltaY = deltaExecCount * 2;
4438 }
4439
4440 int32_t startPointY[MAX_NUM_KERNEL_SPLIT] = { 0 };
4441 int32_t currentExecCount[MAX_NUM_KERNEL_SPLIT] = { -1 };
4442 currentExecCount[0] = (remainExecCount > deltaExecCount)?(deltaExecCount-1) : (remainExecCount-1);
4443 startPointY[0] = localInitialStartPointY;
4444
4445 for (auto i = 1; i < phase; i++)
4446 {
4447 remainExecCount -= deltaExecCount;
4448 if (remainExecCount < 1)
4449 {
4450 remainExecCount = 1;
4451 }
4452
4453 currentExecCount[i] = (remainExecCount > deltaExecCount)?(deltaExecCount-1) : (remainExecCount-1);
4454 startPointY[i] = startPointY[i-1] + deltaY;
4455 }
4456
4457 for(auto i = 0; i < phase; i++)
4458 {
4459 if(currentExecCount[i] < 0)
4460 {
4461 break;
4462 }
4463
4464 // Program render engine pipe commands
4465 SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams();
4466 sendKernelCmdsParams.EncFunctionType = encFunctionType;
4467 sendKernelCmdsParams.pKernelState = kernelState;
4468 sendKernelCmdsParams.bEnableCustomScoreBoard= true;
4469 sendKernelCmdsParams.pCustomScoreBoard = &m_walkingPatternParam.ScoreBoard;
4470 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
4471
4472 // Change walker execution count and local start Y for different phases
4473 m_walkingPatternParam.MediaWalker.dwLocalLoopExecCount = currentExecCount[i];
4474 m_walkingPatternParam.MediaWalker.LocalStart.y = startPointY[i];
4475
4476 // always use customized media walker
4477 MHW_WALKER_PARAMS walkerParams;
4478 MOS_SecureMemcpy(&walkerParams, sizeof(walkerParams), &m_walkingPatternParam.MediaWalker, sizeof(m_walkingPatternParam.MediaWalker));
4479 walkerParams.ColorCountMinusOne = m_walkingPatternParam.dwNumRegion - 1;
4480
4481 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
4482 &cmdBuffer,
4483 &walkerParams));
4484 }
4485 }
4486
4487 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndKernelCall(
4488 encFunctionType,
4489 kernelState,
4490 &cmdBuffer));
4491
4492 CODECHAL_DEBUG_TOOL(
4493 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4494 &m_mvIndex.sResource,
4495 CodechalDbgAttr::attrOutput,
4496 "MbData",
4497 m_mvpIndex.dwSize,
4498 0,
4499 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
4500
4501 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4502 &m_mvpIndex.sResource,
4503 CodechalDbgAttr::attrOutput,
4504 "MvData",
4505 m_mvpIndex.dwSize,
4506 0,
4507 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
4508 )
4509
4510 m_lastTaskInPhase = true;
4511 eStatus = Encode8x8BPakKernel(curbe);
4512
4513 return eStatus;
4514 }
4515
4516
4517 MOS_STATUS CodechalFeiHevcStateG9Skl::EncodeKernelFunctions()
4518 {
4519 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4520
4521 CODECHAL_ENCODE_FUNCTION_ENTER;
4522
4523 m_feiPicParams = (CodecEncodeHevcFeiPicParams *)m_encodeParams.pFeiPicParams;
4524
4525 CODECHAL_DEBUG_TOOL(
4526 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
4527 m_rawSurfaceToEnc,
4528 CodechalDbgAttr::attrEncodeRawInputSurface,
4529 "SrcSurf"));
4530 )
4531
4532 if (m_pakOnlyTest)
4533 {
4534 // Skip all ENC kernel operations for now it is in the PAK only test mode.
4535 // PAK and CU records will be passed via the app
4536 return eStatus;
4537 }
4538
4539 if (m_brcEnabled || m_hmeEnabled)
4540 {
4541 eStatus = MOS_STATUS_UNKNOWN;
4542 CODECHAL_ENCODE_ASSERTMESSAGE("HEVC FEI does not support BRC and HMEenabled.");
4543 return eStatus;
4544 }
4545
4546 if(m_osInterface->bSimIsActive)
4547 {
4548 MOS_LOCK_PARAMS lockFlags;
4549 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4550 lockFlags.WriteOnly = 1;
4551
4552 uint8_t* data = (uint8_t* )m_osInterface->pfnLockResource(m_osInterface, &m_resMbCodeSurface, &lockFlags);
4553 if (data)
4554 {
4555 MOS_ZeroMemory(data, m_mbCodeSize);
4556 m_osInterface->pfnUnlockResource(m_osInterface, &m_resMbCodeSurface);
4557 }
4558 }
4559
4560 // Generate slice map for kernel
4561 CODECHAL_ENCODE_CHK_STATUS_RETURN(GenerateSliceMap());
4562
4563 //Reset to use a different performance tag ID for I kernels. Each kernel has a different buffer ID
4564 m_osInterface->pfnResetPerfBufferID(m_osInterface);
4565
4566 m_firstTaskInPhase = true;
4567 m_lastTaskInPhase = false;
4568
4569 // ROI uses the BRC LCU update kernel, even in CQP. So we will call it
4570 // first if in CQP. It has no other kernel execution dependencies, even
4571 // that brc is not initialized is not a dependency
4572 if (m_hevcPicParams->NumROI && !m_brcEnabled)
4573 {
4574 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeBrcUpdateLCUBasedKernel(nullptr));
4575 }
4576
4577 // config LCU QP input
4578 if (m_encodeParams.bMbQpDataEnabled)
4579 {
4580 // Setup Lamda/Cost table for LCU QP mode
4581 auto psBrcConstantData = &m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx];
4582 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupBrcConstantTable(psBrcConstantData));
4583
4584 if (m_encodeParams.psMbQpDataSurface)
4585 {
4586 CODECHAL_ENCODE_CHK_STATUS_RETURN(Convert1byteTo2bytesQPperLCU(m_encodeParams.psMbQpDataSurface, &m_lcuQP));
4587 m_surfaceParams[SURFACE_LCU_QP].psSurface = &m_lcuQP;
4588 }
4589 }
4590
4591 CODECHAL_DEBUG_TOOL(
4592 if (m_feiPicParams->bPerBlockQP) {
4593 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpSurface(
4594 &m_lcuQP,
4595 CodechalDbgAttr::attrInput,
4596 "HEVC_B_MBENC_MB_QP",
4597 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
4598 }
4599
4600 if (m_feiPicParams->MVPredictorInput) {
4601 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4602 &m_feiPicParams->resMVPredictor,
4603 "HEVC_B_MBENC_ConstantData_In",
4604 CodechalDbgAttr::attrInput,
4605 m_feiPicParams->resMVPredictor.iSize,
4606 0,
4607 CODECHAL_MEDIA_STATE_HEVC_B_MBENC));
4608 })
4609
4610 if(m_feiPicParams->FastIntraMode)
4611 {
4612 if (m_hevcPicParams->CodingType == I_TYPE)
4613 {
4614 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode8x8PBMbEncKernel());
4615 }
4616 }
4617 else
4618 {
4619 //Step 1: perform 2:1 down-scaling
4620 if (m_hevcSeqParams->bit_depth_luma_minus8 == 0) // use this for 8 bit only case.
4621 {
4622 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode2xScalingKernel());
4623 }
4624
4625 //Step 2: 32x32 PU Mode Decision or 32x32 PU Intra check kernel
4626 if (m_hevcPicParams->CodingType == I_TYPE)
4627 {
4628 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode32x32PuModeDecisionKernel());
4629 }
4630 else
4631 {
4632 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode32X32BIntraCheckKernel());
4633 }
4634
4635 //Step 3: 16x16 SAD Computation
4636 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode16x16SadPuComputationKernel());
4637
4638 CODECHAL_DEBUG_TOOL(
4639 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4640 &m_sad16x16Pu.sResource,
4641 CodechalDbgAttr::attrOutput,
4642 "HEVC_16x16_PU_SAD_Out",
4643 m_sad16x16Pu.dwSize,
4644 0,
4645 CODECHAL_MEDIA_STATE_16x16_PU_SAD));
4646 )
4647
4648 //Step 4: 16x16 PU Mode Decision
4649 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode16x16PuModeDecisionKernel());
4650
4651 CODECHAL_DEBUG_TOOL(
4652 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4653 &m_vme8x8Mode.sResource,
4654 CodechalDbgAttr::attrOutput,
4655 "HEVC_16x16_PU_MD_Out",
4656 m_vme8x8Mode.dwSize,
4657 0,
4658 CODECHAL_MEDIA_STATE_16x16_PU_MODE_DECISION));
4659 )
4660
4661 //Step 5: 8x8 PU
4662 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode8x8PUKernel());
4663
4664 //Step 6: 8x8 PU FMODE
4665 m_lastTaskInPhase = true;
4666 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode8x8PUFMODEKernel());
4667
4668 CODECHAL_DEBUG_TOOL(
4669 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
4670 &m_scaled2xSurface,
4671 CodechalDbgAttr::attrReferenceSurfaces,
4672 "2xScaledSurf"))
4673
4674 if (m_pictureCodingType == I_TYPE)
4675 {
4676 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4677 &m_32x32PuOutputData.sResource,
4678 CodechalDbgAttr::attrOutput,
4679 "HEVC_32x32_PU_MD_Out",
4680 m_32x32PuOutputData.dwSize,
4681 0,
4682 CODECHAL_MEDIA_STATE_32x32_PU_MODE_DECISION));
4683 }
4684 else
4685 {
4686 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4687 &m_32x32PuOutputData.sResource,
4688 CodechalDbgAttr::attrOutput,
4689 "HEVC_32x32_B_INTRA_CHECK_Out",
4690 m_32x32PuOutputData.dwSize,
4691 0,
4692 CODECHAL_MEDIA_STATE_32x32_PU_MODE_DECISION));
4693
4694 }
4695
4696 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4697 &m_intraMode.sResource,
4698 CodechalDbgAttr::attrOutput,
4699 "HEVC_8x8_PU_MD_Out",
4700 m_intraMode.dwSize,
4701 0,
4702 CODECHAL_MEDIA_STATE_8x8_PU));
4703
4704 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4705 &m_intraDist.sResource,
4706 CodechalDbgAttr::attrOutput,
4707 "HEVC_8x8_PU_FMOD_Out",
4708 m_intraDist.dwSize,
4709 0,
4710 CODECHAL_MEDIA_STATE_8x8_PU_FMODE));
4711 )
4712 }
4713
4714 // Sync-wait can be executed after I-kernel is submitted before there is no dependency for I to wait for PAK to be ready
4715 CODECHAL_ENCODE_CHK_STATUS_RETURN(WaitForPak());
4716
4717 //Step 7: B MB ENC kernel for B picture only
4718 if (m_hevcPicParams->CodingType != I_TYPE)
4719 {
4720 m_firstTaskInPhase = true;
4721 m_lastTaskInPhase = false;
4722
4723 if (m_feiPicParams->MVPredictorInput)
4724 {
4725 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
4726 &m_surfaceParams[SURFACE_FEI_EXTERNAL_MVP],
4727 &m_feiPicParams->resMVPredictor,
4728 m_feiPicParams->resMVPredictor.iSize,
4729 0,
4730 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
4731 0,
4732 false));
4733 }
4734
4735 if ((m_hevcSeqParams->bit_depth_luma_minus8))
4736 {
4737 bool formatConversionDone[NUM_FORMAT_CONV_FRAMES] = { false };
4738 formatConversionDone[0] = true; // always true since its for the input surface.
4739
4740 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
4741 {
4742 if (!m_picIdx[i].bValid || !m_currUsedRefPic[i])
4743 {
4744 continue;
4745 }
4746
4747 uint8_t picIdx = m_picIdx[i].ucPicIdx;
4748 CODECHAL_ENCODE_ASSERT(picIdx < 127);
4749
4750 uint8_t frameStoreId = (uint8_t)m_refIdxMapping[i];
4751
4752 if (frameStoreId >= CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC)
4753 {
4754 CODECHAL_ENCODE_ASSERT(0);
4755 eStatus = MOS_STATUS_INVALID_PARAMETER;
4756 return eStatus;
4757 }
4758
4759 if (formatConversionDone[frameStoreId + 1] != true)
4760 {
4761 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeDSCombinedKernel(dsDisabled, (frameStoreId + 1), picIdx));
4762 formatConversionDone[frameStoreId + 1] = true;
4763 m_refList[picIdx]->sRefBuffer = m_formatConvertedSurface[frameStoreId + 1];
4764 }
4765 }
4766 }
4767
4768 CODECHAL_ENCODE_CHK_STATUS_RETURN(Encode8x8PBMbEncKernel());
4769 }
4770
4771 // Notify PAK engine once ENC is done
4772 if (!m_pakOnlyTest && !Mos_ResourceIsNull(&m_resSyncObjectRenderContextInUse))
4773 {
4774 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
4775 syncParams.GpuContext = m_renderContext;
4776 syncParams.presSyncResource = &m_resSyncObjectRenderContextInUse;
4777
4778 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4779 }
4780
4781 return eStatus;
4782 }
4783
4784 MOS_STATUS CodechalFeiHevcStateG9Skl::Initialize(CodechalSetting * settings)
4785 {
4786 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4787
4788 CODECHAL_ENCODE_FUNCTION_ENTER;
4789
4790 // common initilization
4791 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncHevcState::Initialize(settings));
4792
4793 m_cscDsState->EnableMmc();
4794
4795 m_brcBuffers.dwBrcConstantSurfaceWidth = BRC_CONSTANT_SURFACE_WIDTH;
4796 m_brcBuffers.dwBrcConstantSurfaceHeight = BRC_CONSTANT_SURFACE_HEIGHT;
4797
4798 // LCU size is 32x32 in Gen9
4799 m_widthAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameWidth, 32);
4800 m_heightAlignedMaxLcu = MOS_ALIGN_CEIL(m_frameHeight, 32);
4801
4802 m_brcEnabled = false;
4803 m_hmeEnabled = false;
4804 m_hmeSupported = false;
4805 m_16xMeUserfeatureControl = false;
4806 m_16xMeSupported = false;
4807 m_32xMeUserfeatureControl = false;
4808 m_32xMeSupported = false;
4809
4810 // regkey setup
4811 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
4812 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4813 MOS_UserFeature_ReadValue_ID(
4814 nullptr,
4815 __MEDIA_USER_FEATURE_VALUE_SINGLE_TASK_PHASE_ENABLE_ID,
4816 &userFeatureData,
4817 m_osInterface->pOsContext);
4818 m_singleTaskPhaseSupported = (userFeatureData.i32Data) ? true : false;
4819
4820 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4821 MOS_UserFeature_ReadValue_ID(
4822 nullptr,
4823 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_26Z_ENABLE_ID,
4824 &userFeatureData,
4825 m_osInterface->pOsContext);
4826 m_enable26WalkingPattern = (userFeatureData.i32Data) ? false : true;
4827
4828 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4829 eStatus = MOS_UserFeature_ReadValue_ID(
4830 nullptr,
4831 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_REGION_NUMBER_ID,
4832 &userFeatureData,
4833 m_osInterface->pOsContext);
4834
4835 if (eStatus == MOS_STATUS_SUCCESS)
4836 {
4837 // Region number must be greater than 1
4838 m_numRegionsInSlice = (userFeatureData.i32Data < 1) ? 1 : userFeatureData.i32Data;
4839 }
4840 else
4841 {
4842 // Reset the status to success if regkey is not set
4843 eStatus = MOS_STATUS_SUCCESS;
4844 }
4845
4846 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4847 MOS_UserFeature_ReadValue_ID(
4848 nullptr,
4849 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_NUM_8x8_INTRA_KERNEL_SPLIT,
4850 &userFeatureData,
4851 m_osInterface->pOsContext);
4852 m_numMb8x8IntraKernelSplit = (userFeatureData.i32Data < 0) ? 0 : userFeatureData.i32Data;
4853
4854 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4855 MOS_UserFeature_ReadValue_ID(
4856 nullptr,
4857 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_NUM_B_KERNEL_SPLIT,
4858 &userFeatureData,
4859 m_osInterface->pOsContext);
4860 m_numMbBKernelSplit = (userFeatureData.i32Data < 0) ? 0 : userFeatureData.i32Data;
4861
4862 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
4863 MOS_UserFeature_ReadValue_ID(
4864 nullptr,
4865 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_POWER_SAVING,
4866 &userFeatureData,
4867 m_osInterface->pOsContext);
4868 m_powerSavingEnabled = (userFeatureData.i32Data) ? true : false;
4869
4870 if (MEDIA_IS_SKU(m_skuTable, FtrEncodeHEVC10bit))
4871 {
4872 /* Make the width aligned to a multiple of 32 and then get the no of macroblocks.*/
4873 /* This is done to facilitate the use of format conversion kernel for downscaling to 4x and 2x along with formatconversion of 10 bit data to 8 bit data.
4874 Refer format conversion kernel for further details .
4875 We will use only 4x downscale for HME, Super and ultra HME use the traditional scaling kernels.
4876 */
4877 uint32_t downscaledSurfaceWidth4x = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x* CODECHAL_MACROBLOCK_WIDTH), (CODECHAL_MACROBLOCK_WIDTH * 2));
4878 m_downscaledWidthInMb4x = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(downscaledSurfaceWidth4x);
4879
4880 }
4881
4882 return eStatus;
4883 }
4884
4885 uint32_t CodechalFeiHevcStateG9Skl::GetMaxBtCount()
4886 {
4887 auto wBtIdxAlignment = m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment();
4888
4889 // 6 I kernels
4890 uint32_t uiBtCountPhase1 = MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_2xSCALING].KernelParams.iBTCount, wBtIdxAlignment) +
4891 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_16x16SAD].KernelParams.iBTCount, wBtIdxAlignment) +
4892 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_16x16MD].KernelParams.iBTCount, wBtIdxAlignment) +
4893 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_8x8PU].KernelParams.iBTCount, wBtIdxAlignment) +
4894 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_8x8FMODE].KernelParams.iBTCount, wBtIdxAlignment);
4895
4896 uiBtCountPhase1 += MOS_MAX(
4897 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_32x32MD].KernelParams.iBTCount, wBtIdxAlignment),
4898 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_MBENC_32x32INTRACHECK].KernelParams.iBTCount, wBtIdxAlignment));
4899
4900 if (MEDIA_IS_SKU(m_skuTable, FtrEncodeHEVC10bit))
4901 {
4902 uiBtCountPhase1 += MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_FEI_MBENC_DS_COMBINED].KernelParams.iBTCount, wBtIdxAlignment);
4903 }
4904
4905 // two B kernels
4906 uint32_t uiBtCountPhase2 = MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_FEI_MBENC_BENC].KernelParams.iBTCount, wBtIdxAlignment) +
4907 MOS_ALIGN_CEIL(m_mbEncKernelStates[CODECHAL_HEVC_FEI_MBENC_BPAK].KernelParams.iBTCount, wBtIdxAlignment);
4908
4909 uint32_t uiMaxBtCount = MOS_MAX(uiBtCountPhase1, uiBtCountPhase2);
4910
4911 return uiMaxBtCount;
4912 }
4913
4914 MOS_STATUS CodechalFeiHevcStateG9Skl::AllocateEncResources()
4915 {
4916 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4917
4918 CODECHAL_ENCODE_FUNCTION_ENTER;
4919
4920 m_sliceMap = (PCODECHAL_ENCODE_HEVC_SLICE_MAP)MOS_AllocAndZeroMemory(
4921 m_widthAlignedMaxLcu * m_heightAlignedMaxLcu * sizeof(m_sliceMap[0]));
4922 CODECHAL_ENCODE_CHK_NULL_RETURN(m_sliceMap);
4923
4924 uint32_t Downscaling2xWidth = m_widthAlignedMaxLcu >> 1;
4925 uint32_t Downscaling2xHeight = m_heightAlignedMaxLcu >> 1;
4926 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateSurface(
4927 &m_scaled2xSurface,
4928 Downscaling2xWidth,
4929 Downscaling2xHeight,
4930 "2x Downscaling"));
4931
4932 uint32_t uiWidth = m_widthAlignedMaxLcu >> 3;
4933 uint32_t uiHeight = m_heightAlignedMaxLcu >> 5;
4934 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
4935 &m_sliceMapSurface,
4936 uiWidth,
4937 uiHeight,
4938 "Slice Map"));
4939
4940 uint32_t uiSize = 32 * (m_widthAlignedMaxLcu >> 5) * (m_heightAlignedMaxLcu >> 5);
4941 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
4942 &m_32x32PuOutputData,
4943 uiSize,
4944 "32x32 PU Output Data"));
4945
4946 uiSize = 8 * 4 * (m_widthAlignedMaxLcu >> 4) * (m_heightAlignedMaxLcu >> 4);
4947 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
4948 &m_sad16x16Pu,
4949 uiSize,
4950 "SAD 16x16 PU"));
4951
4952 // need 64 bytes for statistics report .
4953 uiSize = 64 * (m_widthAlignedMaxLcu >> 4) * (m_heightAlignedMaxLcu >> 4);
4954 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
4955 &m_vme8x8Mode,
4956 uiSize,
4957 "VME 8x8 mode"));
4958
4959 uiSize = 32 * (m_widthAlignedMaxLcu >> 3) * (m_heightAlignedMaxLcu >> 3);
4960 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
4961 &m_intraMode,
4962 uiSize,
4963 "Intra mode"));
4964
4965 uiSize = 16 * (m_widthAlignedMaxLcu >> 4) * (m_heightAlignedMaxLcu >> 4);
4966 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
4967 &m_intraDist,
4968 uiSize,
4969 "Intra dist"));
4970
4971 // Change the surface size
4972 uiWidth = m_widthAlignedMaxLcu >> 1;
4973 uiHeight = m_heightAlignedMaxLcu >> 4;
4974 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
4975 &m_minDistortion,
4976 uiWidth,
4977 uiHeight,
4978 "Min distortion surface"));
4979
4980 // Allocate FEI 2D 2bytes LCU QP surface
4981 uiWidth = MOS_ALIGN_CEIL((m_widthAlignedMaxLcu >> 4), 64);
4982 uiHeight = MOS_ALIGN_CEIL((m_heightAlignedMaxLcu >> 5), 4);
4983 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
4984 &m_lcuQP,
4985 uiWidth,
4986 uiHeight,
4987 "LCU_QP surface"));
4988
4989 uiWidth = sizeof(CODECHAL_ENCODE_HEVC_WALKING_CONTROL_REGION);
4990 uiHeight = HEVC_CONCURRENT_SURFACE_HEIGHT;
4991 for (uint32_t i = 0; i < NUM_CONCURRENT_THREAD; i++)
4992 {
4993 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
4994 &m_concurrentThreadSurface[i],
4995 uiWidth,
4996 uiHeight,
4997 "Concurrent Thread"));
4998 }
4999
5000 //uiSize = (dwWidthAlignedMaxLCU * dwHeightAlignedMaxLCU / 4);
5001 uiSize = (m_widthAlignedMaxLcu * m_heightAlignedMaxLcu / 4) + GPUMMU_WA_PADDING;
5002 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
5003 &m_mvIndex,
5004 uiSize,
5005 "MV index surface"));
5006
5007 //uiSize = (dwWidthAlignedMaxLCU * dwHeightAlignedMaxLCU / 2);
5008 uiSize = (m_widthAlignedMaxLcu * m_heightAlignedMaxLcu / 2) + GPUMMU_WA_PADDING;
5009 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
5010 &m_mvpIndex,
5011 uiSize,
5012 "MVP index surface"));
5013
5014 uiSize = m_widthAlignedMaxLcu * m_heightAlignedMaxLcu;
5015 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
5016 &m_vmeSavedUniSic,
5017 uiSize,
5018 "VME Saved UniSic surface"));
5019
5020 uiWidth = m_widthAlignedMaxLcu >> 3;
5021 uiHeight = m_heightAlignedMaxLcu >> 5;
5022 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
5023 &m_simplestIntraSurface,
5024 uiWidth,
5025 uiHeight,
5026 "Simplest Intra surface"));
5027
5028 m_allocator->AllocateResource(m_standard, 1024, 1, brcInputForEncKernel, "brcInputForEncKernel", true);
5029
5030 if (MEDIA_IS_SKU(m_skuTable, FtrEncodeHEVC10bit))
5031 {
5032 // adding 10 bit support for KBL : output surface for format conversion from 10bit to 8 bit
5033 for (uint32_t i = 0; i < NUM_FORMAT_CONV_FRAMES; i++)
5034 {
5035 if (Mos_ResourceIsNull(&m_formatConvertedSurface[i].OsResource))
5036 {
5037 uiWidth = m_widthAlignedMaxLcu;
5038 uiHeight = m_heightAlignedMaxLcu;
5039
5040 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateSurface(
5041 &m_formatConvertedSurface[i],
5042 uiWidth,
5043 uiHeight,
5044 "Format Converted Surface"));
5045 }
5046 }
5047
5048 if (Mos_ResourceIsNull(&m_resMbStatisticsSurface.sResource))
5049 {
5050 uiSize = 52 * m_picWidthInMb * m_picHeightInMb; // 13 DWs or 52 bytes for statistics per MB
5051
5052 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
5053 &m_resMbStatisticsSurface,
5054 uiSize,
5055 "MB stats surface"));
5056 }
5057 }
5058
5059 // ROI
5060 // ROI buffer size uses MB units for HEVC, not LCU
5061 uiWidth = MOS_ALIGN_CEIL(m_picWidthInMb * 4, 64);
5062 uiHeight = MOS_ALIGN_CEIL(m_picHeightInMb, 8);
5063
5064 MOS_ZeroMemory(&m_roiSurface, sizeof(m_roiSurface));
5065 m_roiSurface.TileType = MOS_TILE_LINEAR;
5066 m_roiSurface.bArraySpacing = true;
5067 m_roiSurface.Format = Format_Buffer_2D;
5068 m_roiSurface.dwWidth = uiWidth;
5069 m_roiSurface.dwPitch = uiWidth;
5070 m_roiSurface.dwHeight = uiHeight;
5071
5072 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
5073 &m_roiSurface,
5074 uiWidth,
5075 uiHeight,
5076 "ROI Buffer"));
5077
5078 return eStatus;
5079 }
5080
5081 MOS_STATUS CodechalFeiHevcStateG9Skl::FreeEncResources()
5082 {
5083 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5084
5085 CODECHAL_ENCODE_FUNCTION_ENTER;
5086
5087 MOS_Delete(m_meKernelState);
5088 m_meKernelState = nullptr;
5089 MOS_FreeMemory(m_meKernelBindingTable);
5090 m_meKernelBindingTable = nullptr;
5091
5092 MOS_DeleteArray(m_mbEncKernelStates);
5093 m_mbEncKernelStates = nullptr;
5094 MOS_FreeMemory(m_mbEncKernelBindingTable);
5095 m_mbEncKernelBindingTable = nullptr;
5096
5097 MOS_DeleteArray(m_brcKernelStates);
5098 m_brcKernelStates = nullptr;
5099 MOS_FreeMemory(m_brcKernelBindingTable);
5100 m_brcKernelBindingTable = nullptr;
5101
5102 MOS_FreeMemory(m_surfaceParams); m_surfaceParams = nullptr;
5103
5104 for (auto i = 0; i < NUM_FORMAT_CONV_FRAMES; i++)
5105 {
5106 m_osInterface->pfnFreeResource(
5107 m_osInterface,
5108 &m_formatConvertedSurface[i].OsResource);
5109 }
5110
5111 m_osInterface->pfnFreeResource(
5112 m_osInterface,
5113 &m_scaled2xSurface.OsResource);
5114
5115 m_osInterface->pfnFreeResource(
5116 m_osInterface,
5117 &m_resMbStatisticsSurface.sResource);
5118
5119 m_osInterface->pfnFreeResource(
5120 m_osInterface,
5121 &m_sliceMapSurface.OsResource);
5122
5123 m_osInterface->pfnFreeResource(
5124 m_osInterface,
5125 &m_32x32PuOutputData.sResource);
5126
5127 m_osInterface->pfnFreeResource(
5128 m_osInterface,
5129 &m_sad16x16Pu.sResource);
5130
5131 m_osInterface->pfnFreeResource(
5132 m_osInterface,
5133 &m_vme8x8Mode.sResource);
5134
5135 m_osInterface->pfnFreeResource(
5136 m_osInterface,
5137 &m_intraMode.sResource);
5138
5139 m_osInterface->pfnFreeResource(
5140 m_osInterface,
5141 &m_intraDist.sResource);
5142
5143 m_osInterface->pfnFreeResource(
5144 m_osInterface,
5145 &m_mvIndex.sResource);
5146
5147 m_osInterface->pfnFreeResource(
5148 m_osInterface,
5149 &m_mvpIndex.sResource);
5150
5151 m_osInterface->pfnFreeResource(
5152 m_osInterface,
5153 &m_vmeSavedUniSic.sResource);
5154
5155 m_osInterface->pfnFreeResource(
5156 m_osInterface,
5157 &m_minDistortion.OsResource);
5158
5159 m_osInterface->pfnFreeResource(
5160 m_osInterface,
5161 &m_lcuQP.OsResource);
5162
5163 for (uint32_t i = 0; i < NUM_CONCURRENT_THREAD; i++)
5164 {
5165 m_osInterface->pfnFreeResource(
5166 m_osInterface,
5167 &m_concurrentThreadSurface[i].OsResource);
5168 }
5169
5170 m_osInterface->pfnFreeResource(
5171 m_osInterface,
5172 &m_simplestIntraSurface.OsResource);
5173
5174 MOS_FreeMemory(m_sliceMap);
5175 m_sliceMap = nullptr;
5176
5177 m_osInterface->pfnFreeResource(
5178 m_osInterface,
5179 &m_roiSurface.OsResource);
5180
5181
5182 return eStatus;
5183 }
5184
5185 MOS_STATUS CodechalFeiHevcStateG9Skl::InitSurfaceInfoTable()
5186 {
5187 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5188
5189 m_surfaceParams = (PCODECHAL_SURFACE_CODEC_PARAMS)MOS_AllocAndZeroMemory(
5190 sizeof(*m_surfaceParams) * SURFACE_NUM_TOTAL);
5191 CODECHAL_ENCODE_CHK_NULL_RETURN(m_surfaceParams);
5192
5193 PCODECHAL_SURFACE_CODEC_PARAMS param = &m_surfaceParams[SURFACE_RAW_Y];
5194 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5195 param,
5196 m_rawSurfaceToEnc,
5197 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5198 0,
5199 m_verticalLineStride,
5200 false));
5201
5202 param = &m_surfaceParams[SURFACE_RAW_10bit_Y];
5203 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5204 param,
5205 m_rawSurfaceToEnc,
5206 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5207 0,
5208 m_verticalLineStride,
5209 false));
5210
5211 // MB stats surface -- currently not used
5212 param = &m_surfaceParams[SURFACE_RAW_MBSTAT];
5213 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5214 param,
5215 &m_resMbStatisticsSurface.sResource,
5216 m_resMbStatisticsSurface.dwSize,
5217 0,
5218 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5219 0,
5220 true));
5221 param->bRawSurface = true;
5222
5223 param = &m_surfaceParams[SURFACE_RAW_FC_8bit_Y_UV];
5224 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5225 param,
5226 &m_formatConvertedSurface[0],
5227 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5228 0,
5229 m_verticalLineStride,
5230 true)); //this should be writable as it is output of formatconversion
5231 param->bUseUVPlane = true;
5232
5233 param = &m_surfaceParams[SURFACE_RAW_Y_UV];
5234 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5235 param,
5236 m_rawSurfaceToEnc,
5237 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5238 0,
5239 m_verticalLineStride,
5240 false));
5241 param->bUseUVPlane = true;
5242
5243 param = &m_surfaceParams[SURFACE_RAW_10bit_Y_UV];
5244 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5245 param,
5246 m_rawSurfaceToEnc,
5247 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5248 0,
5249 m_verticalLineStride,
5250 false));//this should be writable as it is output of formatconversion
5251 param->bUseUVPlane = true;
5252
5253 param = &m_surfaceParams[SURFACE_Y_2X];
5254 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5255 param,
5256 &m_scaled2xSurface,
5257 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5258 0,
5259 m_verticalLineStride,
5260 false));
5261
5262 param = &m_surfaceParams[SURFACE_32x32_PU_OUTPUT];
5263 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5264 param,
5265 &m_32x32PuOutputData.sResource,
5266 m_32x32PuOutputData.dwSize,
5267 0,
5268 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5269 0,
5270 false));
5271
5272 param = &m_surfaceParams[SURFACE_SLICE_MAP];
5273 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5274 param,
5275 &m_sliceMapSurface,
5276 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5277 0,
5278 m_verticalLineStride,
5279 false));
5280
5281 param = &m_surfaceParams[SURFACE_Y_2X_VME];
5282 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParamsVME(
5283 param,
5284 &m_scaled2xSurface,
5285 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value,
5286 0));
5287
5288 param = &m_surfaceParams[SURFACE_BRC_INPUT];
5289 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5290 param,
5291 (MOS_RESOURCE*)m_allocator->GetResource(m_standard, brcInputForEncKernel),
5292 m_allocator->GetResourceSize(m_standard, brcInputForEncKernel),
5293 0,
5294 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5295 0,
5296 false));
5297
5298 param = &m_surfaceParams[SURFACE_LCU_QP];
5299 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5300 param,
5301 &m_lcuQP,
5302 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5303 0,
5304 m_verticalLineStride,
5305 false));
5306
5307 param = &m_surfaceParams[SURFACE_ROI];
5308 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5309 param,
5310 &m_roiSurface,
5311 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5312 0,
5313 m_verticalLineStride,
5314 false));
5315
5316 param = &m_surfaceParams[SURFACE_BRC_DATA];
5317 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5318 param,
5319 &m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx],
5320 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5321 0,
5322 m_verticalLineStride,
5323 false));
5324
5325 param = &m_surfaceParams[SURFACE_SIMPLIFIED_INTRA];
5326 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5327 param,
5328 &m_simplestIntraSurface,
5329 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5330 0,
5331 m_verticalLineStride,
5332 false));
5333
5334 // skip SURFACE_HME_MVP and SURFACE_HME_DIST from HME since FEI alsways disables HME
5335
5336 param = &m_surfaceParams[SURFACE_16x16PU_SAD];
5337 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5338 param,
5339 &m_sad16x16Pu.sResource,
5340 m_sad16x16Pu.dwSize,
5341 0,
5342 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5343 0,
5344 false));
5345
5346 param = &m_surfaceParams[SURFACE_RAW_VME];
5347 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParamsVME(
5348 param,
5349 m_rawSurfaceToEnc,
5350 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5351 0));
5352
5353 param = &m_surfaceParams[SURFACE_VME_8x8];
5354 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5355 param,
5356 &m_vme8x8Mode.sResource,
5357 m_vme8x8Mode.dwSize,
5358 0,
5359 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5360 0,
5361 false));
5362
5363 param = &m_surfaceParams[SURFACE_CU_RECORD];
5364 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5365 param,
5366 &m_resMbCodeSurface,
5367 m_mbCodeSize - m_mvOffset,
5368 m_mvOffset,
5369 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5370 0,
5371 true));
5372
5373 param = &m_surfaceParams[SURFACE_INTRA_MODE];
5374 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5375 param,
5376 &m_intraMode.sResource,
5377 m_intraMode.dwSize,
5378 0,
5379 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5380 0,
5381 false));
5382
5383 param = &m_surfaceParams[SURFACE_HCP_PAK];
5384 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5385 param,
5386 &m_resMbCodeSurface,
5387 m_mvOffset,
5388 0,
5389 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5390 0,
5391 true));
5392
5393 param = &m_surfaceParams[SURFACE_INTRA_DIST];
5394 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5395 param,
5396 &m_intraDist.sResource,
5397 m_intraDist.dwSize,
5398 0,
5399 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5400 0,
5401 false));
5402
5403 param = &m_surfaceParams[SURFACE_MIN_DIST];
5404 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5405 param,
5406 &m_minDistortion,
5407 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value,
5408 0,
5409 m_verticalLineStride,
5410 false));
5411
5412 param = &m_surfaceParams[SURFACE_VME_UNI_SIC_DATA];
5413 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5414 param,
5415 &m_vmeSavedUniSic.sResource,
5416 m_vmeSavedUniSic.dwSize,
5417 0,
5418 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5419 0,
5420 false));
5421
5422 param = &m_surfaceParams[SURFACE_COL_MB_MV];
5423 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5424 param,
5425 nullptr,
5426 m_sizeOfMvTemporalBuffer,
5427 0,
5428 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5429 0,
5430 false));
5431
5432 m_concurrentThreadIndex = 0;
5433 for (uint32_t i = 0; i < NUM_CONCURRENT_THREAD; i++)
5434 {
5435 param = &m_surfaceParams[SURFACE_CONCURRENT_THREAD + i];
5436 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5437 param,
5438 &m_concurrentThreadSurface[i],
5439 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value,
5440 0,
5441 m_verticalLineStride,
5442 false));
5443 }
5444
5445 param = &m_surfaceParams[SURFACE_MB_MV_INDEX];
5446 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5447 param,
5448 &m_mvIndex.sResource,
5449 m_mvIndex.dwSize,
5450 0,
5451 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5452 0,
5453 false));
5454
5455 param = &m_surfaceParams[SURFACE_MVP_INDEX];
5456 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5457 param,
5458 &m_mvpIndex.sResource,
5459 m_mvpIndex.dwSize,
5460 0,
5461 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5462 0,
5463 false));
5464
5465 param = &m_surfaceParams[SURFACE_REF_FRAME_VME];
5466 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParamsVME(
5467 param,
5468 0,
5469 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value,
5470 0));
5471
5472 param = &m_surfaceParams[SURFACE_Y_4X];
5473 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5474 param,
5475 nullptr,
5476 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5477 0,
5478 m_verticalLineStride,
5479 false));
5480
5481 param = &m_surfaceParams[SURFACE_Y_4X_VME];
5482 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParamsVME(
5483 param,
5484 nullptr,
5485 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value,
5486 0));
5487
5488 param = &m_surfaceParams[SURFACE_BRC_HISTORY];
5489 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5490 param,
5491 &m_brcBuffers.resBrcHistoryBuffer,
5492 m_brcHistoryBufferSize,
5493 0,
5494 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5495 0,
5496 true));
5497
5498 param = &m_surfaceParams[SURFACE_BRC_ME_DIST];
5499 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5500 param,
5501 &m_brcBuffers.sMeBrcDistortionBuffer,
5502 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5503 0,
5504 m_verticalLineStride,
5505 true));
5506
5507 param = &m_surfaceParams[SURFACE_BRC_PAST_PAK_INFO];
5508 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5509 param,
5510 &m_brcBuffers.resBrcPakStatisticBuffer[0],
5511 m_hevcBrcPakStatisticsSize,
5512 0,
5513 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5514 0,
5515 false));
5516
5517 param = &m_surfaceParams[SURFACE_BRC_HCP_PIC_STATE];
5518 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5519 param,
5520 &m_brcBuffers.resBrcImageStatesWriteBuffer[0],
5521 m_brcBuffers.dwBrcHcpPicStateSize,
5522 0,
5523 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5524 0,
5525 false));
5526
5527 #if 0
5528 param = &m_surfaceParams[SURFACE_PU_STATS];
5529 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5530 param,
5531 &m_encStatsBuffers.m_puStatsSurface,
5532 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5533 0,
5534 m_verticalLineStride,
5535 true));
5536
5537 param = &m_surfaceParams[SURFACE_8X8_PU_HAAR_DIST];
5538 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5539 param,
5540 &m_encStatsBuffers.m_8x8PuHaarDist,
5541 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5542 0,
5543 m_verticalLineStride,
5544 true));
5545
5546 param = &m_surfaceParams[SURFACE_8X8_PU_FRAME_STATS];
5547 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5548 param,
5549 &m_encStatsBuffers.m_8x8PuFrameStats.sResource,
5550 m_encStatsBuffers.m_8x8PuFrameStats.dwSize,
5551 0,
5552 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5553 0,
5554 true));
5555
5556 param = &m_surfaceParams[SURFACE_MB_ENC_STATS];
5557 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams2D(
5558 param,
5559 &m_encStatsBuffers.m_mbEncStatsSurface,
5560 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value,
5561 0,
5562 m_verticalLineStride,
5563 true));
5564
5565 param = &m_surfaceParams[SURFACE_MB_ENC_FRAME_STATS];
5566 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5567 param,
5568 &m_encStatsBuffers.m_mbEncFrameStats.sResource,
5569 m_encStatsBuffers.m_mbEncFrameStats.dwSize,
5570 0,
5571 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5572 0,
5573 true));
5574
5575 param = &m_surfaceParams[SURFACE_FEI_EXTERNAL_MVP];
5576 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5577 param,
5578 &m_feiPicParams->resMVPredictor,
5579 m_feiPicParams->resMVPredictor.iSize,
5580 0,
5581 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5582 0,
5583 false));
5584
5585 param = &m_surfaceParams[SURFACE_FEI_PER_LCU_QP];
5586 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5587 param,
5588 &m_feiPicParams->resCTBQp,
5589 m_feiPicParams->resCTBQp.iSize,
5590 0,
5591 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5592 0,
5593 false));
5594
5595 param = &m_surfaceParams[SURFACE_FEI_PER_CTB_CTRL];
5596 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5597 param,
5598 &m_feiPicParams->resCTBCtrl,
5599 m_feiPicParams->resCTBCtrl.iSize,
5600 0,
5601 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5602 0,
5603 false));
5604
5605 param = &m_surfaceParams[SURFACE_FEI_CTB_DISTORTION];
5606 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitSurfaceCodecParams1D(
5607 param,
5608 &m_feiPicParams->resDistortion,
5609 m_feiPicParams->resDistortion.iSize,
5610 0,
5611 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value,
5612 0,
5613 false));
5614 #endif
5615
5616 return eStatus;
5617 }
5618
5619 MOS_STATUS CodechalFeiHevcStateG9Skl::SetSequenceStructs()
5620 {
5621 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5622
5623 CODECHAL_ENCODE_FUNCTION_ENTER;
5624
5625 m_feiPicParams = (CodecEncodeHevcFeiPicParams *)m_encodeParams.pFeiPicParams;
5626
5627 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncHevcState::SetSequenceStructs());
5628
5629 m_enable26WalkingPattern = m_feiPicParams->bForceLCUSplit;
5630 m_numRegionsInSlice = m_feiPicParams->NumConcurrentEncFramePartition;
5631 m_encodeParams.bReportStatisticsEnabled = 0;
5632 m_encodeParams.bQualityImprovementEnable = 0;
5633
5634 if (m_feiPicParams->FastIntraMode)
5635 {
5636 m_hevcSeqParams->TargetUsage = 0x07;
5637 }
5638
5639 return eStatus;
5640 }
5641
5642 CodechalFeiHevcStateG9Skl::CodechalFeiHevcStateG9Skl(CodechalHwInterface* hwInterface,
5643 CodechalDebugInterface* debugInterface,
5644 PCODECHAL_STANDARD_INFO standardInfo)
5645 :CodechalEncHevcStateG9(hwInterface, debugInterface, standardInfo)
5646 {
5647 m_kernelBase = (uint8_t *)IGCODECKRN_G9;
5648 m_kuid = IDR_CODEC_HEVC_FEI_COMBINED_KENREL_INTEL;
5649 pfnGetKernelHeaderAndSize = GetKernelHeaderAndSize;
5650 m_noMeKernelForPFrame = false;
5651 m_feiEnable = true;
5652
5653 MOS_STATUS eStatus = InitMhw();
5654 if (eStatus != MOS_STATUS_SUCCESS)
5655 {
5656 CODECHAL_ENCODE_ASSERTMESSAGE("HEVC FEI encoder MHW initialization failed.");
5657 }
5658 }
5659