Debian Codegraph @

media_driver/agnostic/gen8/codec/hal/codechal_fei_avc_g8.cpp

raw
1 /*
2 * Copyright (c) 2011-2021, 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_avc_g8.cpp
24 //! \brief This file implements the C++ class/interface for Gen8 platform's AVC
25 //! FEI encoding to be used across CODECHAL components.
26 //!
27
28 #include "codechal_fei_avc_g8.h"
29 #include "codeckrnheader.h"
30 #include "igcodeckrn_g8.h"
31 #include "hal_oca_interface.h"
32
33
34 #define CODECHAL_ENCODE_AVC_MAX_NUM_REF_L0 4
35 #define CODECHAL_ENCODE_AVC_MAX_NUM_REF_L1 2
36
37 //this enum should be moved into base
38 typedef enum _BINDING_TABLE_OFFSET_2xSCALING_CM
39 {
40 SCALING_2x_FRAME_SRC_Y_CM = 0,
41 SCALING_2x_FRAME_DST_Y_CM = 1,
42 SCALING_2x_FIELD_TOP_SRC_Y_CM = 0,
43 SCALING_2x_FIELD_TOP_DST_Y_CM = 1,
44 SCALING_2x_FIELD_BOT_SRC_Y_CM = 2,
45 SCALINGL_2x_FIELD_BOT_DST_Y_CM = 3,
46 SCALING_2x_NUM_SURFACES_CM = 4
47 }BINDING_TABLE_OFFSET_2xSCALING_CM;
48
49 typedef struct _KERNEL_HEADER_FEI_CM {
50 int nKernelCount;
51
52 // MbEnc FEI for Frame/Field
53 CODECHAL_KERNEL_HEADER AVCMBEnc_Fei_I;
54 CODECHAL_KERNEL_HEADER AVCMBEnc_Fei_P;
55 CODECHAL_KERNEL_HEADER AVCMBEnc_Fei_B;
56 // PreProc
57 CODECHAL_KERNEL_HEADER AVC_Fei_ProProc;
58 // HME
59 CODECHAL_KERNEL_HEADER AVC_ME_P;
60 CODECHAL_KERNEL_HEADER AVC_ME_B;
61 // DownScaling
62 CODECHAL_KERNEL_HEADER PLY_DScale_PLY;
63 CODECHAL_KERNEL_HEADER PLY_DScale_2f_PLY_2f;
64 // 2x DownScaling
65 CODECHAL_KERNEL_HEADER PLY_2xDScale_PLY;
66 CODECHAL_KERNEL_HEADER PLY_2xDScale_2f_PLY_2f;
67 //Weighted Prediction Kernel
68 CODECHAL_KERNEL_HEADER AVC_WeightedPrediction;
69 } KERNEL_HEADER_FEI_CM, *PKERNEL_HEADER_FEI_CM;
70
71 static const CODECHAL_ENCODE_AVC_IPCM_THRESHOLD g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[5] =
72 {
73 { 2, 3000 },
74 { 4, 3600 },
75 { 6, 5000 },
76 { 10, 8000 },
77 { 18, 9000 },
78 };
79
80 typedef enum _MBENC_BINDING_TABLE_OFFSET_CM_FEI
81 {
82 MBENC_MFC_AVC_PAK_OBJ_CM_FEI = 0,
83 MBENC_IND_MV_DATA_CM_FEI = 1,
84 MBENC_BRC_DISTORTION_CM_FEI = 2, // For BRC distortion for I
85 MBENC_CURR_Y_CM_FEI = 3,
86 MBENC_CURR_UV_CM_FEI = 4,
87 MBENC_MB_SPECIFIC_DATA_CM_FEI = 5,
88 MBENC_AUX_VME_OUT_CM_FEI = 6,
89 MBENC_REFPICSELECT_L0_CM_FEI = 7,
90 MBENC_MV_DATA_FROM_ME_CM_FEI = 8,
91 MBENC_4xME_DISTORTION_CM_FEI = 9,
92 MBENC_REFPICSELECT_L1_CM_FEI = 10,
93 MBENC_FWD_MB_DATA_CM_FEI = 11,
94 MBENC_FWD_MV_DATA_CM_FEI = 12,
95 MBENC_MBQP_CM_FEI = 13,
96 MBENC_MBBRC_CONST_DATA_CM_FEI = 14,
97 MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_CM_FEI = 15,
98 MBENC_RESERVED0_CM_FEI = 21,
99 MBENC_RESERVED1_CM_FEI = 23,
100 MBENC_RESERVED2_CM_FEI = 25,
101 MBENC_RESERVED3_CM_FEI = 27,
102 MBENC_RESERVED4_CM_FEI = 29,
103 MBENC_RESERVED5_CM_FEI = 31,
104 MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_CM_FEI = 32,
105 MBENC_VME_INTER_PRED_BWD_PIC_IDX0_1_CM_FEI = 33,
106 MBENC_RESERVED6_CM_FEI = 34,
107 MBENC_VME_INTER_PRED_BWD_PIC_IDX1_1_CM_FEI = 35,
108 MBENC_RESERVED7_CM_FEI = 36,
109 MBENC_FLATNESS_CHECK_CM_FEI = 37,
110 MBENC_MAD_DATA_CM_FEI = 38,
111 MBENC_INTER_DISTORTION_CM_FEI = 39,
112 MBENC_BEST_INTER_INTRA_CM_FEI = 40,
113 MBENC_BRC_CURBE_DATA_CM_FEI = 41,
114 MBENC_MV_PREDICTOR_CM_FEI = 42,
115 MBENC_NUM_SURFACES_CM_FEI = 43
116 } MBENC_BINDING_TABLE_OFFSET_CM_FEI;
117
118 //should be moved into fei base use base!
119 typedef struct _MEDIA_OBJECT_2xSCALING_STATIC_DATA_CM_FEI_G8
120 {
121 // uint32_t 0 - GRF R1.0
122 union
123 {
124 struct
125 {
126 uint32_t InputPictureWidth : MOS_BITFIELD_RANGE( 0,15 );
127 uint32_t InputPictureHeight : MOS_BITFIELD_RANGE( 16,31 );
128 };
129
130 uint32_t Value;
131 } DW0;
132
133 // DW1
134 union
135 {
136 struct
137 {
138 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
139 };
140 struct
141 {
142 uint32_t Value;
143 };
144 } DW1;
145
146 // DW2
147 union
148 {
149 struct
150 {
151 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
152 };
153 struct
154 {
155 uint32_t Value;
156 };
157 } DW2;
158
159 // DW3
160 union
161 {
162 struct
163 {
164 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
165 };
166 struct
167 {
168 uint32_t Value;
169 };
170 } DW3;
171
172 // DW4
173 union
174 {
175 struct
176 {
177 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
178 };
179 struct
180 {
181 uint32_t Value;
182 };
183 } DW4;
184
185 // DW5
186 union
187 {
188 struct
189 {
190 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
191 };
192 struct
193 {
194 uint32_t Value;
195 };
196 } DW5;
197
198 // DW6
199 union
200 {
201 struct
202 {
203 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
204 };
205 struct
206 {
207 uint32_t Value;
208 };
209 } DW6;
210
211 // DW7
212 union
213 {
214 struct
215 {
216 uint32_t Reserved : MOS_BITFIELD_RANGE( 1,31 );
217 };
218 struct
219 {
220 uint32_t Value;
221 };
222 } DW7;
223
224 // DW8
225 union
226 {
227 struct
228 {
229 uint32_t InputYBTIFrame : MOS_BITFIELD_RANGE( 0,31 );
230 };
231 struct
232 {
233 uint32_t InputYBTITopField : MOS_BITFIELD_RANGE( 0,31 );
234 };
235 struct
236 {
237 uint32_t Value;
238 };
239 } DW8;
240
241 // DW9
242 union
243 {
244 struct
245 {
246 uint32_t OutputYBTIFrame : MOS_BITFIELD_RANGE( 0,31 );
247 };
248 struct
249 {
250 uint32_t OutputYBTITopField : MOS_BITFIELD_RANGE( 0,31 );
251 };
252 struct
253 {
254 uint32_t Value;
255 };
256 } DW9;
257
258 // DW10
259 union
260 {
261 struct
262 {
263 uint32_t InputYBTIBottomField : MOS_BITFIELD_RANGE( 0,31 );
264 };
265 struct
266 {
267 uint32_t Value;
268 };
269 } DW10;
270
271 // DW11
272 union
273 {
274 struct
275 {
276 uint32_t OutputYBTIBottomField : MOS_BITFIELD_RANGE( 0,31 );
277 };
278 struct
279 {
280 uint32_t Value;
281 };
282 } DW11;
283 } MEDIA_OBJECT_2xSCALING_STATIC_DATA_CM_FEI_G8, *PMEDIA_OBJECT_2xSCALING_STATIC_DATA_CM_FEI_G8;
284
285 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(MEDIA_OBJECT_2xSCALING_STATIC_DATA_CM_FEI_G8)) == 12);
286 //different with g9, but seem as legacy
287 typedef struct _ME_CURBE_CM_FEI
288 {
289 // DW0
290 union
291 {
292 struct
293 {
294 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 );
295 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 );
296 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 );
297 uint32_t : MOS_BITFIELD_RANGE( 3, 4 );
298 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 );
299 uint32_t : MOS_BITFIELD_BIT( 6 );
300 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 );
301 uint32_t : MOS_BITFIELD_RANGE( 8,23 );
302 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 );
303 };
304 struct
305 {
306 uint32_t Value;
307 };
308 } DW0;
309
310 // DW1
311 union
312 {
313 struct
314 {
315 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE( 0, 5 );
316 uint32_t : MOS_BITFIELD_RANGE( 6,15 );
317 uint32_t BiWeight : MOS_BITFIELD_RANGE( 16,21 );
318 uint32_t : MOS_BITFIELD_RANGE( 22,27 );
319 uint32_t UniMixDisable : MOS_BITFIELD_BIT( 28 );
320 uint32_t : MOS_BITFIELD_RANGE( 29,31 );
321 };
322 struct
323 {
324 uint32_t Value;
325 };
326 } DW1;
327
328 // DW2
329 union
330 {
331 struct
332 {
333 uint32_t LenSP : MOS_BITFIELD_RANGE( 0, 7 );
334 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 );
335 uint32_t : MOS_BITFIELD_RANGE( 16,31 );
336 };
337 struct
338 {
339 uint32_t Value;
340 };
341 } DW2;
342
343 // DW3
344 union
345 {
346 struct
347 {
348 uint32_t SrcSize : MOS_BITFIELD_RANGE( 0, 1 );
349 uint32_t : MOS_BITFIELD_RANGE( 2, 3 );
350 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE( 4, 5 );
351 uint32_t SrcAccess : MOS_BITFIELD_BIT( 6 );
352 uint32_t RefAccess : MOS_BITFIELD_BIT( 7 );
353 uint32_t SearchCtrl : MOS_BITFIELD_RANGE( 8,10 );
354 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT( 11 );
355 uint32_t SubPelMode : MOS_BITFIELD_RANGE( 12,13 );
356 uint32_t SkipType : MOS_BITFIELD_BIT( 14 );
357 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT( 15 );
358 uint32_t InterChromaMode : MOS_BITFIELD_BIT( 16 );
359 uint32_t FTEnable : MOS_BITFIELD_BIT( 17 );
360 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT( 18 );
361 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT( 19 );
362 uint32_t InterSAD : MOS_BITFIELD_RANGE( 20,21 );
363 uint32_t IntraSAD : MOS_BITFIELD_RANGE( 22,23 );
364 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE( 24,30 );
365 uint32_t : MOS_BITFIELD_BIT( 31 );
366 };
367 struct
368 {
369 uint32_t Value;
370 };
371 } DW3;
372
373 // DW4
374 union
375 {
376 struct
377 {
378 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
379 uint32_t PictureHeightMinus1 : MOS_BITFIELD_RANGE( 8,15 );
380 uint32_t PictureWidth : MOS_BITFIELD_RANGE( 16,23 );
381 uint32_t : MOS_BITFIELD_RANGE( 24,31 );
382 };
383 struct
384 {
385 uint32_t Value;
386 };
387 } DW4;
388
389 // DW5
390 union
391 {
392 struct
393 {
394 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
395 uint32_t QpPrimeY : MOS_BITFIELD_RANGE( 8,15 );
396 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 );
397 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 );
398
399 };
400 struct
401 {
402 uint32_t Value;
403 };
404 } DW5;
405
406 // DW6
407 union
408 {
409 struct
410 {
411 uint32_t : MOS_BITFIELD_RANGE( 0, 2 );
412 uint32_t WriteDistortions : MOS_BITFIELD_BIT( 3 );
413 uint32_t UseMvFromPrevStep : MOS_BITFIELD_BIT( 4 );
414 uint32_t : MOS_BITFIELD_RANGE( 5, 7 );
415 uint32_t SuperCombineDist : MOS_BITFIELD_RANGE( 8,15 );
416 uint32_t MaxVmvR : MOS_BITFIELD_RANGE( 16,31 );
417 };
418 struct
419 {
420 uint32_t Value;
421 };
422 } DW6;
423
424 // DW7
425 union
426 {
427 struct
428 {
429 uint32_t : MOS_BITFIELD_RANGE( 0,15 );
430 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE( 16,17 );
431 uint32_t BilinearEnable : MOS_BITFIELD_BIT( 18 );
432 uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT( 19 );
433 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT( 20 );
434 uint32_t AConlyHAAR : MOS_BITFIELD_BIT( 21 );
435 uint32_t RefIDCostMode : MOS_BITFIELD_BIT( 22 );
436 uint32_t : MOS_BITFIELD_BIT( 23 );
437 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE( 24,31 );
438 };
439 struct
440 {
441 uint32_t Value;
442 };
443 } DW7;
444
445 // DW8
446 union
447 {
448 struct
449 {
450 uint32_t Mode0Cost : MOS_BITFIELD_RANGE( 0, 7 );
451 uint32_t Mode1Cost : MOS_BITFIELD_RANGE( 8,15 );
452 uint32_t Mode2Cost : MOS_BITFIELD_RANGE( 16,23 );
453 uint32_t Mode3Cost : MOS_BITFIELD_RANGE( 24,31 );
454 };
455 struct
456 {
457 uint32_t Value;
458 };
459 } DW8;
460
461 // DW9
462 union
463 {
464 struct
465 {
466 uint32_t Mode4Cost : MOS_BITFIELD_RANGE( 0, 7 );
467 uint32_t Mode5Cost : MOS_BITFIELD_RANGE( 8,15 );
468 uint32_t Mode6Cost : MOS_BITFIELD_RANGE( 16,23 );
469 uint32_t Mode7Cost : MOS_BITFIELD_RANGE( 24,31 );
470 };
471 struct
472 {
473 uint32_t Value;
474 };
475 } DW9;
476
477 // DW10
478 union
479 {
480 struct
481 {
482 uint32_t Mode8Cost : MOS_BITFIELD_RANGE( 0, 7 );
483 uint32_t Mode9Cost : MOS_BITFIELD_RANGE( 8,15 );
484 uint32_t RefIDCost : MOS_BITFIELD_RANGE( 16,23 );
485 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE( 24,31 );
486 };
487 struct
488 {
489 uint32_t Value;
490 };
491 } DW10;
492
493 // DW11
494 union
495 {
496 struct
497 {
498 uint32_t MV0Cost : MOS_BITFIELD_RANGE( 0, 7 );
499 uint32_t MV1Cost : MOS_BITFIELD_RANGE( 8,15 );
500 uint32_t MV2Cost : MOS_BITFIELD_RANGE( 16,23 );
501 uint32_t MV3Cost : MOS_BITFIELD_RANGE( 24,31 );
502 };
503 struct
504 {
505 uint32_t Value;
506 };
507 } DW11;
508
509 // DW12
510 union
511 {
512 struct
513 {
514 uint32_t MV4Cost : MOS_BITFIELD_RANGE( 0, 7 );
515 uint32_t MV5Cost : MOS_BITFIELD_RANGE( 8,15 );
516 uint32_t MV6Cost : MOS_BITFIELD_RANGE( 16,23 );
517 uint32_t MV7Cost : MOS_BITFIELD_RANGE( 24,31 );
518 };
519 struct
520 {
521 uint32_t Value;
522 };
523 } DW12;
524
525 // DW13
526 union
527 {
528 struct
529 {
530 uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE( 0, 7 );
531 uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE( 8,15 );
532 uint32_t ActualMBWidth : MOS_BITFIELD_RANGE( 16,23 );
533 uint32_t ActualMBHeight : MOS_BITFIELD_RANGE( 24,31 );
534 };
535 struct
536 {
537 uint32_t Value;
538 };
539 } DW13;
540
541 // DW14
542 union
543 {
544 struct
545 {
546 uint32_t List0RefID0FieldParity : MOS_BITFIELD_BIT( 0 );
547 uint32_t List0RefID1FieldParity : MOS_BITFIELD_BIT( 1 );
548 uint32_t List0RefID2FieldParity : MOS_BITFIELD_BIT( 2 );
549 uint32_t List0RefID3FieldParity : MOS_BITFIELD_BIT( 3 );
550 uint32_t List0RefID4FieldParity : MOS_BITFIELD_BIT( 4 );
551 uint32_t List0RefID5FieldParity : MOS_BITFIELD_BIT( 5 );
552 uint32_t List0RefID6FieldParity : MOS_BITFIELD_BIT( 6 );
553 uint32_t List0RefID7FieldParity : MOS_BITFIELD_BIT( 7 );
554 uint32_t List1RefID0FieldParity : MOS_BITFIELD_BIT( 8 );
555 uint32_t List1RefID1FieldParity : MOS_BITFIELD_BIT( 9 );
556 uint32_t : MOS_BITFIELD_RANGE( 10,31 );
557 };
558 struct
559 {
560 uint32_t Value;
561 };
562 } DW14;
563
564 // DW15
565 union
566 {
567 struct
568 {
569 uint32_t PrevMvReadPosFactor : MOS_BITFIELD_RANGE( 0, 7 );
570 uint32_t MvShiftFactor : MOS_BITFIELD_RANGE( 8, 15 );
571 uint32_t Reserved : MOS_BITFIELD_RANGE( 16,31 );
572 };
573 struct
574 {
575 uint32_t Value;
576 };
577 } DW15;
578
579 struct
580 {
581 // DW16
582 union
583 {
584 struct
585 {
586 SearchPathDelta SPDelta_0;
587 SearchPathDelta SPDelta_1;
588 SearchPathDelta SPDelta_2;
589 SearchPathDelta SPDelta_3;
590 };
591 struct
592 {
593 uint32_t Value;
594 };
595 } DW16;
596
597 // DW17
598 union
599 {
600 struct
601 {
602 SearchPathDelta SPDelta_4;
603 SearchPathDelta SPDelta_5;
604 SearchPathDelta SPDelta_6;
605 SearchPathDelta SPDelta_7;
606 };
607 struct
608 {
609 uint32_t Value;
610 };
611 } DW17;
612
613 // DW18
614 union
615 {
616 struct
617 {
618 SearchPathDelta SPDelta_8;
619 SearchPathDelta SPDelta_9;
620 SearchPathDelta SPDelta_10;
621 SearchPathDelta SPDelta_11;
622 };
623 struct
624 {
625 uint32_t Value;
626 };
627 } DW18;
628
629 // DW19
630 union
631 {
632 struct
633 {
634 SearchPathDelta SPDelta_12;
635 SearchPathDelta SPDelta_13;
636 SearchPathDelta SPDelta_14;
637 SearchPathDelta SPDelta_15;
638 };
639 struct
640 {
641 uint32_t Value;
642 };
643 } DW19;
644
645 // DW20
646 union
647 {
648 struct
649 {
650 SearchPathDelta SPDelta_16;
651 SearchPathDelta SPDelta_17;
652 SearchPathDelta SPDelta_18;
653 SearchPathDelta SPDelta_19;
654 };
655 struct
656 {
657 uint32_t Value;
658 };
659 } DW20;
660
661 // DW21
662 union
663 {
664 struct
665 {
666 SearchPathDelta SPDelta_20;
667 SearchPathDelta SPDelta_21;
668 SearchPathDelta SPDelta_22;
669 SearchPathDelta SPDelta_23;
670 };
671 struct
672 {
673 uint32_t Value;
674 };
675 } DW21;
676
677 // DW22
678 union
679 {
680 struct
681 {
682 SearchPathDelta SPDelta_24;
683 SearchPathDelta SPDelta_25;
684 SearchPathDelta SPDelta_26;
685 SearchPathDelta SPDelta_27;
686 };
687 struct
688 {
689 uint32_t Value;
690 };
691 } DW22;
692
693 // DW23
694 union
695 {
696 struct
697 {
698 SearchPathDelta SPDelta_28;
699 SearchPathDelta SPDelta_29;
700 SearchPathDelta SPDelta_30;
701 SearchPathDelta SPDelta_31;
702 };
703 struct
704 {
705 uint32_t Value;
706 };
707 } DW23;
708
709 // DW24
710 union
711 {
712 struct
713 {
714 SearchPathDelta SPDelta_32;
715 SearchPathDelta SPDelta_33;
716 SearchPathDelta SPDelta_34;
717 SearchPathDelta SPDelta_35;
718 };
719 struct
720 {
721 uint32_t Value;
722 };
723 } DW24;
724
725 // DW25
726 union
727 {
728 struct
729 {
730 SearchPathDelta SPDelta_36;
731 SearchPathDelta SPDelta_37;
732 SearchPathDelta SPDelta_38;
733 SearchPathDelta SPDelta_39;
734 };
735 struct
736 {
737 uint32_t Value;
738 };
739 } DW25;
740
741 // DW26
742 union
743 {
744 struct
745 {
746 SearchPathDelta SPDelta_40;
747 SearchPathDelta SPDelta_41;
748 SearchPathDelta SPDelta_42;
749 SearchPathDelta SPDelta_43;
750 };
751 struct
752 {
753 uint32_t Value;
754 };
755 } DW26;
756
757 // DW27
758 union
759 {
760 struct
761 {
762 SearchPathDelta SPDelta_44;
763 SearchPathDelta SPDelta_45;
764 SearchPathDelta SPDelta_46;
765 SearchPathDelta SPDelta_47;
766 };
767 struct
768 {
769 uint32_t Value;
770 };
771 } DW27;
772
773 // DW28
774 union
775 {
776 struct
777 {
778 SearchPathDelta SPDelta_48;
779 SearchPathDelta SPDelta_49;
780 SearchPathDelta SPDelta_50;
781 SearchPathDelta SPDelta_51;
782 };
783 struct
784 {
785 uint32_t Value;
786 };
787 } DW28;
788
789 // DW29
790 union
791 {
792 struct
793 {
794 SearchPathDelta SPDelta_52;
795 SearchPathDelta SPDelta_53;
796 SearchPathDelta SPDelta_54;
797 SearchPathDelta SPDelta_55;
798 };
799 struct
800 {
801 uint32_t Value;
802 };
803 } DW29;
804 } SPDelta;
805
806 // DW30
807 union
808 {
809 struct
810 {
811 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
812 };
813 struct
814 {
815 uint32_t Value;
816 };
817 } DW30;
818
819 // DW31
820 union
821 {
822 struct
823 {
824 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
825 };
826 struct
827 {
828 uint32_t Value;
829 };
830 } DW31;
831
832 // DW32
833 union
834 {
835 struct
836 {
837 uint32_t _4xMeMvOutputDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
838 };
839 struct
840 {
841 uint32_t Value;
842 };
843 } DW32;
844
845 // DW33
846 union
847 {
848 struct
849 {
850 uint32_t _16xOr32xMeMvInputDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
851 };
852 struct
853 {
854 uint32_t Value;
855 };
856 } DW33;
857
858 // DW34
859 union
860 {
861 struct
862 {
863 uint32_t _4xMeOutputDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
864 };
865 struct
866 {
867 uint32_t Value;
868 };
869 } DW34;
870
871 // DW35
872 union
873 {
874 struct
875 {
876 uint32_t _4xMeOutputBrcDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
877 };
878 struct
879 {
880 uint32_t Value;
881 };
882 } DW35;
883
884 // DW36
885 union
886 {
887 struct
888 {
889 uint32_t VMEFwdInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
890 };
891 struct
892 {
893 uint32_t Value;
894 };
895 } DW36;
896
897 // DW37
898 union
899 {
900 struct
901 {
902 uint32_t VMEBwdInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
903 };
904 struct
905 {
906 uint32_t Value;
907 };
908 } DW37;
909
910 // DW38
911 union
912 {
913 struct
914 {
915 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
916 };
917 struct
918 {
919 uint32_t Value;
920 };
921 } DW38;
922
923 } ME_CURBE_CM_FEI, *PME_CURBE_CM_FEI;
924 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(ME_CURBE_CM_FEI)) == 39);
925 //seem as legacy
926 const uint32_t CodechalEncodeAvcEncFeiG8::m_modeMvCost_Cm_PreProc[3][CODEC_AVC_NUM_QP][8] =
927 {
928 // I-Frame
929 {
930 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff000000, 0x00000000, 0x00000000 },
931 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff010101, 0x00000000, 0x00000000 },
932 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff020202, 0x00000000, 0x00000000 },
933 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff030303, 0x00000000, 0x00000000 },
934 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff040404, 0x00000000, 0x00000000 },
935 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff050505, 0x00000000, 0x00000000 },
936 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff060606, 0x00000000, 0x00000000 },
937 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff070707, 0x01010001, 0x01010101 },
938 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff080808, 0x01010001, 0x01010101 },
939 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff090909, 0x03030003, 0x03030303 },
940 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0a0a0a, 0x03030003, 0x03030303 },
941 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0b0b0b, 0x06060006, 0x06060606 },
942 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0c0c0c, 0x06060006, 0x06060606 },
943 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0d0d0d, 0x08080008, 0x08080808 },
944 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0e0e0e, 0x08080008, 0x08080808 },
945 { 0x1e03000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff0f0f0f, 0x0b0b000b, 0x0b0b0b0b },
946 { 0x2e06001a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff101010, 0x0b0b000b, 0x0b0b0b0b },
947 { 0x2e06001a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff111111, 0x0d0d000d, 0x0d0d0d0d },
948 { 0x2e06001a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff121212, 0x0d0d000d, 0x0d0d0d0d },
949 { 0x2e06001a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff131313, 0x10100010, 0x10101010 },
950 { 0x3b09001f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff141414, 0x10100010, 0x10101010 },
951 { 0x3b09001f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff151515, 0x13130013, 0x13131313 },
952 { 0x3b09001f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff161616, 0x13130013, 0x13131313 },
953 { 0x3e0c002a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff171717, 0x16160016, 0x16161616 },
954 { 0x3e0c002a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff181818, 0x16160016, 0x16161616 },
955 { 0x3e0c002a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff191919, 0x1a1a001a, 0x1a1a1a1a },
956 { 0x490f002d, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1a1a1a, 0x1a1a001a, 0x1a1a1a1a },
957 { 0x4b19002f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1b1b1b, 0x1e1e001e, 0x1e1e1e1e },
958 { 0x4b19002f, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1c1c1c, 0x1e1e001e, 0x1e1e1e1e },
959 { 0x4c1b0039, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1d1d1d, 0x22220022, 0x22222222 },
960 { 0x4e1c003a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1e1e1e, 0x22220022, 0x22222222 },
961 { 0x581e003b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff1f1f1f, 0x27270027, 0x27272727 },
962 { 0x591f003d, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff202020, 0x27270027, 0x27272727 },
963 { 0x5a28003e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff212121, 0x2c2c002c, 0x2c2c2c2c },
964 { 0x5b2a0048, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff222222, 0x2c2c002c, 0x2c2c2c2c },
965 { 0x5c2b0049, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff232323, 0x32320032, 0x32323232 },
966 { 0x5e2c004a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff242424, 0x32320032, 0x32323232 },
967 { 0x682e004b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff252525, 0x38380038, 0x38383838 },
968 { 0x692f004d, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff262626, 0x38380038, 0x38383838 },
969 { 0x6a39004e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff272727, 0x3e3e003e, 0x3e3e3e3e },
970 { 0x6b390058, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff282828, 0x3e3e003e, 0x3e3e3e3e },
971 { 0x6d3b0059, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff292929, 0x45450045, 0x45454545 },
972 { 0x6e3c005a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2a2a2a, 0x45450045, 0x45454545 },
973 { 0x783e005b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2b2b2b, 0x4d4d004d, 0x4d4d4d4d },
974 { 0x793f005d, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2c2c2c, 0x4d4d004d, 0x4d4d4d4d },
975 { 0x7a48005e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2d2d2d, 0x55550055, 0x55555555 },
976 { 0x7b4a0068, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2e2e2e, 0x55550055, 0x55555555 },
977 { 0x7c4b0069, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff2f2f2f, 0x5e5e005e, 0x5e5e5e5e },
978 { 0x7e4c006a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff303030, 0x5e5e005e, 0x5e5e5e5e },
979 { 0x884e006b, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff313131, 0x68680068, 0x68686868 },
980 { 0x894f006d, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff323232, 0x68680068, 0x68686868 },
981 { 0x8a59006e, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff333333, 0x73730073, 0x73737373 }
982 },
983 // P-Frame
984 {
985 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff000000, 0x00000000, 0x00000000 },
986 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff010101, 0x00000000, 0x00000000 },
987 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff020202, 0x00000000, 0x00000000 },
988 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff030303, 0x00000000, 0x00000000 },
989 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff040404, 0x00000000, 0x00000000 },
990 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff050505, 0x00000000, 0x00000000 },
991 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff060606, 0x00000000, 0x00000000 },
992 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff070707, 0x01010001, 0x01010101 },
993 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff080808, 0x01010001, 0x01010101 },
994 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff090909, 0x03030003, 0x03030303 },
995 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0a0a0a, 0x03030003, 0x03030303 },
996 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0b0b0b, 0x06060006, 0x06060606 },
997 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0c0c0c, 0x06060006, 0x06060606 },
998 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0d0d0d, 0x08080008, 0x08080808 },
999 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0e0e0e, 0x08080008, 0x08080808 },
1000 { 0x391e1a07, 0x06040208, 0x00040005, 0x09050401, 0x0f0e0c0a, 0xff0f0f0f, 0x0b0b000b, 0x0b0b0b0b },
1001 { 0x492e2a0e, 0x0d090519, 0x0008000b, 0x190a0802, 0x1f1e1c1a, 0xff101010, 0x0b0b000b, 0x0b0b0b0b },
1002 { 0x492e2a0e, 0x0d090519, 0x0008000b, 0x190a0802, 0x1f1e1c1a, 0xff111111, 0x0d0d000d, 0x0d0d0d0d },
1003 { 0x492e2a0e, 0x0d090519, 0x0008000b, 0x190a0802, 0x1f1e1c1a, 0xff121212, 0x0d0d000d, 0x0d0d0d0d },
1004 { 0x492e2a0e, 0x0d090519, 0x0008000b, 0x190a0802, 0x1f1e1c1a, 0xff131313, 0x10100010, 0x10101010 },
1005 { 0x4d3b2f1b, 0x1a0d071d, 0x000c0018, 0x1e0f0c03, 0x2b2b291f, 0xff141414, 0x10100010, 0x10101010 },
1006 { 0x4d3b2f1b, 0x1a0d071d, 0x000c0018, 0x1e0f0c03, 0x2b2b291f, 0xff151515, 0x13130013, 0x13131313 },
1007 { 0x4d3b2f1b, 0x1a0d071d, 0x000c0018, 0x1e0f0c03, 0x2b2b291f, 0xff161616, 0x13130013, 0x13131313 },
1008 { 0x593e3a1e, 0x1d190a29, 0x0018001b, 0x291a1804, 0x2f2e2c2a, 0xff171717, 0x16160016, 0x16161616 },
1009 { 0x593e3a1e, 0x1d190a29, 0x0018001b, 0x291a1804, 0x2f2e2c2a, 0xff181818, 0x16160016, 0x16161616 },
1010 { 0x593e3a1e, 0x1d190a29, 0x0018001b, 0x291a1804, 0x2f2e2c2a, 0xff191919, 0x1a1a001a, 0x1a1a1a1a },
1011 { 0x5b493d29, 0x281c0d2b, 0x001a001e, 0x2b1d1a05, 0x39392f2d, 0xff1a1a1a, 0x1a1a001a, 0x1a1a1a1a },
1012 { 0x5d4b3f2b, 0x2a1e0f2d, 0x001c0028, 0x2e1f1c06, 0x3b3b392f, 0xff1b1b1b, 0x1e1e001e, 0x1e1e1e1e },
1013 { 0x5d4b3f2b, 0x2a1e0f2d, 0x001c0028, 0x2e1f1c06, 0x3b3b392f, 0xff1c1c1c, 0x1e1e001e, 0x1e1e1e1e },
1014 { 0x5f4c492c, 0x2c28192f, 0x001e002a, 0x38291e07, 0x3d3c3b39, 0xff1d1d1d, 0x22220022, 0x22222222 },
1015 { 0x694e4a2e, 0x2d291b39, 0x0028002b, 0x392a2808, 0x3f3e3c3a, 0xff1e1e1e, 0x22220022, 0x22222222 },
1016 { 0x6a584b38, 0x2f2a1c3a, 0x0029002c, 0x3a2b2909, 0x48483e3b, 0xff1f1f1f, 0x27270027, 0x27272727 },
1017 { 0x6b594d39, 0x382c1d3b, 0x002a002e, 0x3b2d2a0a, 0x49493f3d, 0xff202020, 0x27270027, 0x27272727 },
1018 { 0x6c5a4e3a, 0x392d1f3c, 0x002b002f, 0x3c2e2b0b, 0x4a4a483e, 0xff212121, 0x2c2c002c, 0x2c2c2c2c },
1019 { 0x6e5b583b, 0x3b2f293e, 0x002d0039, 0x3f382d0d, 0x4c4b4a48, 0xff222222, 0x2c2c002c, 0x2c2c2c2c },
1020 { 0x6f5c593c, 0x3c38293f, 0x002e003a, 0x48392e0e, 0x4d4c4b49, 0xff232323, 0x32320032, 0x32323232 },
1021 { 0x795e5a3e, 0x3d392b49, 0x0038003b, 0x493a3818, 0x4f4e4c4a, 0xff242424, 0x32320032, 0x32323232 },
1022 { 0x7a685b48, 0x3f3a2c4a, 0x0039003c, 0x4a3b3919, 0x58584e4b, 0xff252525, 0x38380038, 0x38383838 },
1023 { 0x7b695d49, 0x483c2d4b, 0x003a003e, 0x4b3d3a1a, 0x59594f4d, 0xff262626, 0x38380038, 0x38383838 },
1024 { 0x7d6a5e4a, 0x4a3d2f4c, 0x003c0048, 0x4d3e3c1c, 0x5b5a594e, 0xff272727, 0x3e3e003e, 0x3e3e3e3e },
1025 { 0x7e6b684b, 0x4a3e384d, 0x003d0049, 0x4e483d1d, 0x5c5b5958, 0xff282828, 0x3e3e003e, 0x3e3e3e3e },
1026 { 0x886d694d, 0x4c483a4f, 0x003f004a, 0x58493f1f, 0x5e5d5b59, 0xff292929, 0x45450045, 0x45454545 },
1027 { 0x896e6a4e, 0x4d493b59, 0x0048004b, 0x594a4828, 0x5f5e5c5a, 0xff2a2a2a, 0x45450045, 0x45454545 },
1028 { 0x8a786b58, 0x4f4a3c5a, 0x0049004c, 0x5a4b4929, 0x68685e5b, 0xff2b2b2b, 0x4d4d004d, 0x4d4d4d4d },
1029 { 0x8b796d59, 0x584c3d5b, 0x004a004e, 0x5b4d4a2a, 0x69695f5d, 0xff2c2c2c, 0x4d4d004d, 0x4d4d4d4d },
1030 { 0x8c7a6e5a, 0x594d3f5c, 0x004b004f, 0x5d4e4b2b, 0x6b6a685e, 0xff2d2d2d, 0x55550055, 0x55555555 },
1031 { 0x8e7b785b, 0x5b4f485e, 0x004d0059, 0x5e584d2d, 0x6c6b6a68, 0xff2e2e2e, 0x55550055, 0x55555555 },
1032 { 0x8f7c795c, 0x5c58495f, 0x004e005a, 0x68594e2e, 0x6d6c6b69, 0xff2f2f2f, 0x5e5e005e, 0x5e5e5e5e },
1033 { 0x8f7e7a5e, 0x5d594b69, 0x0058005b, 0x695a5838, 0x6f6e6c6a, 0xff303030, 0x5e5e005e, 0x5e5e5e5e },
1034 { 0x8f887b68, 0x5f5a4c6a, 0x0059005c, 0x6a5b5939, 0x6f6f6e6b, 0xff313131, 0x68680068, 0x68686868 },
1035 { 0x8f897d69, 0x685c4d6b, 0x005a005e, 0x6b5d5a3a, 0x6f6f6f6d, 0xff323232, 0x68680068, 0x68686868 },
1036 { 0x8f8a7e6a, 0x695d4f6c, 0x005b0068, 0x6d5e5b3b, 0x6f6f6f6e, 0xff333333, 0x73730073, 0x73737373 }
1037 },
1038 // B-Frame
1039 {
1040 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff000000, 0x00000000, 0x00000000 },
1041 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff010101, 0x00000000, 0x00000000 },
1042 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff020202, 0x00000000, 0x00000000 },
1043 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff030303, 0x00000000, 0x00000000 },
1044 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff040404, 0x00000000, 0x00000000 },
1045 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff050505, 0x00000000, 0x00000000 },
1046 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff060606, 0x00000000, 0x00000000 },
1047 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff070707, 0x01010001, 0x01010101 },
1048 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff080808, 0x01010001, 0x01010101 },
1049 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff090909, 0x03030003, 0x03030303 },
1050 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0a0a0a, 0x03030003, 0x03030303 },
1051 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0b0b0b, 0x06060006, 0x06060606 },
1052 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0c0c0c, 0x06060006, 0x06060606 },
1053 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0d0d0d, 0x08080008, 0x08080808 },
1054 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0e0e0e, 0x08080008, 0x08080808 },
1055 { 0x3a2a2907, 0x0a08060c, 0x00040206, 0x06020200, 0x180e0c0a, 0xff0f0f0f, 0x0b0b000b, 0x0b0b0b0b },
1056 { 0x4a3a390e, 0x1b190d1c, 0x0008040c, 0x0c040400, 0x281e1c1a, 0xff101010, 0x0b0b000b, 0x0b0b0b0b },
1057 { 0x4a3a390e, 0x1b190d1c, 0x0008040c, 0x0c040400, 0x281e1c1a, 0xff111111, 0x0d0d000d, 0x0d0d0d0d },
1058 { 0x4a3a390e, 0x1b190d1c, 0x0008040c, 0x0c040400, 0x281e1c1a, 0xff121212, 0x0d0d000d, 0x0d0d0d0d },
1059 { 0x4a3a390e, 0x1b190d1c, 0x0008040c, 0x0c040400, 0x281e1c1a, 0xff131313, 0x10100010, 0x10101010 },
1060 { 0x4f3f3d1b, 0x281d1a29, 0x000c0619, 0x19060600, 0x2c2b291f, 0xff141414, 0x10100010, 0x10101010 },
1061 { 0x4f3f3d1b, 0x281d1a29, 0x000c0619, 0x19060600, 0x2c2b291f, 0xff151515, 0x13130013, 0x13131313 },
1062 { 0x4f3f3d1b, 0x281d1a29, 0x000c0619, 0x19060600, 0x2c2b291f, 0xff161616, 0x13130013, 0x13131313 },
1063 { 0x5a4a491e, 0x2b291d2c, 0x0018081c, 0x1c080800, 0x382e2c2a, 0xff171717, 0x16160016, 0x16161616 },
1064 { 0x5a4a491e, 0x2b291d2c, 0x0018081c, 0x1c080800, 0x382e2c2a, 0xff181818, 0x16160016, 0x16161616 },
1065 { 0x5a4a491e, 0x2b291d2c, 0x0018081c, 0x1c080800, 0x382e2c2a, 0xff191919, 0x1a1a001a, 0x1a1a1a1a },
1066 { 0x5d4d4b29, 0x2d2b282f, 0x001a0a1f, 0x1f0a0a00, 0x3a392f2d, 0xff1a1a1a, 0x1a1a001a, 0x1a1a1a1a },
1067 { 0x5f4f4d2b, 0x382d2a39, 0x001c0c29, 0x290c0c00, 0x3c3b392f, 0xff1b1b1b, 0x1e1e001e, 0x1e1e1e1e },
1068 { 0x5f4f4d2b, 0x382d2a39, 0x001c0c29, 0x290c0c00, 0x3c3b392f, 0xff1c1c1c, 0x1e1e001e, 0x1e1e1e1e },
1069 { 0x69594f2c, 0x392f2b3b, 0x001e0e2b, 0x2b0e0e00, 0x3e3c3b39, 0xff1d1d1d, 0x22220022, 0x22222222 },
1070 { 0x6a5a592e, 0x3b392d3c, 0x0028182c, 0x2c181800, 0x483e3c3a, 0xff1e1e1e, 0x22220022, 0x22222222 },
1071 { 0x6b5b5a38, 0x3c3a2f3e, 0x0029192e, 0x2e191900, 0x49483e3b, 0xff1f1f1f, 0x27270027, 0x27272727 },
1072 { 0x6d5d5b39, 0x3d3b383f, 0x002a1a2f, 0x2f1a1a00, 0x4a493f3d, 0xff202020, 0x27270027, 0x27272727 },
1073 { 0x6e5e5c3a, 0x3e3c3948, 0x002b1b38, 0x381b1b00, 0x4b4a483e, 0xff212121, 0x2c2c002c, 0x2c2c2c2c },
1074 { 0x78685e3b, 0x493e3b4a, 0x002d1d3a, 0x3a1d1d00, 0x4d4b4a48, 0xff222222, 0x2c2c002c, 0x2c2c2c2c },
1075 { 0x79695f3c, 0x493f3b4b, 0x002e1e3b, 0x3b1e1e00, 0x4e4c4b49, 0xff232323, 0x32320032, 0x32323232 },
1076 { 0x7a6a693e, 0x4b493d4c, 0x0038283c, 0x3c282800, 0x584e4c4a, 0xff242424, 0x32320032, 0x32323232 },
1077 { 0x7b6b6a48, 0x4c4a3f4e, 0x0039293e, 0x3e292900, 0x59584e4b, 0xff252525, 0x38380038, 0x38383838 },
1078 { 0x7d6d6b49, 0x4d4b484f, 0x003a2a3f, 0x3f2a2a00, 0x5a594f4d, 0xff262626, 0x38380038, 0x38383838 },
1079 { 0x7e6e6c4a, 0x4f4c4959, 0x003c2c49, 0x492c2c00, 0x5c5a594e, 0xff272727, 0x3e3e003e, 0x3e3e3e3e },
1080 { 0x88786d4b, 0x584d4a59, 0x003d2d49, 0x492d2d00, 0x5d5b5958, 0xff282828, 0x3e3e003e, 0x3e3e3e3e },
1081 { 0x89796f4d, 0x5a4f4c5b, 0x003f2f4b, 0x4b2f2f00, 0x5f5d5b59, 0xff292929, 0x45450045, 0x45454545 },
1082 { 0x8a7a794e, 0x5b594d5c, 0x0048384c, 0x4c383800, 0x685e5c5a, 0xff2a2a2a, 0x45450045, 0x45454545 },
1083 { 0x8b7b7a58, 0x5c5a4f5e, 0x0049394e, 0x4e393900, 0x69685e5b, 0xff2b2b2b, 0x4d4d004d, 0x4d4d4d4d },
1084 { 0x8d7d7b59, 0x5d5b585f, 0x004a3a4f, 0x4f3a3a00, 0x6a695f5d, 0xff2c2c2c, 0x4d4d004d, 0x4d4d4d4d },
1085 { 0x8e7e7c5a, 0x5f5c5968, 0x004b3b58, 0x583b3b00, 0x6b6a685e, 0xff2d2d2d, 0x55550055, 0x55555555 },
1086 { 0x8f887e5b, 0x685e5a6a, 0x004d3d5a, 0x5a3d3d00, 0x6d6b6a68, 0xff2e2e2e, 0x55550055, 0x55555555 },
1087 { 0x8f897f5c, 0x695f5c6b, 0x004e3e5b, 0x5b3e3e00, 0x6e6c6b69, 0xff2f2f2f, 0x5e5e005e, 0x5e5e5e5e },
1088 { 0x8f8a895e, 0x6b695d6c, 0x0058485c, 0x5c484800, 0x6f6e6c6a, 0xff303030, 0x5e5e005e, 0x5e5e5e5e },
1089 { 0x8f8b8a68, 0x6c6a5f6e, 0x0059495e, 0x5e494900, 0x6f6f6e6b, 0xff313131, 0x68680068, 0x68686868 },
1090 { 0x8f8d8b69, 0x6d6b686f, 0x005a4a5f, 0x5f4a4a00, 0x6f6f6f6d, 0xff323232, 0x68680068, 0x68686868 },
1091 { 0x8f8e8c6a, 0x6f6c6979, 0x005b4b69, 0x694b4b00, 0x6f6f6f6e, 0xff333333, 0x73730073, 0x73737373 }
1092 }
1093 };
1094
1095 const uint32_t CodechalEncodeAvcEncFeiG8::m_meCurbeCmFei[39] =
1096 {
1097 0x00000000, 0x00200010, 0x00003939, 0x77a43000, 0x00000000, 0x28300000, 0x00000000, 0x00000000,
1098 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1099 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1100 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1101 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
1102 };
1103
1104 // AVC PreProc CURBE init data for G9 CM Kernel
1105 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalIFrame[49] =
1106 {
1107 0x00000082, 0x00000000, 0x00003910, 0x00a83000, 0x00000000, 0x28300000, 0x00000000, 0x00000000,
1108 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1109 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1110 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1111 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x40000000, 0x00000080, 0x00003900, 0x28301000,
1112 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1113 0xffffffff
1114 };
1115
1116 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalIfield[49] =
1117 {
1118 0x00000082, 0x00000000, 0x00003910, 0x00a830c0, 0x00000000, 0x28300000, 0x00000000, 0x00000000,
1119 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1120 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1121 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1122 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x40000000, 0x00000080, 0x00003900, 0x28301000,
1123 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1124 0xffffffff
1125 };
1126
1127 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalPFrame[49] =
1128 {
1129 0x000000a3, 0x00000008, 0x00003910, 0x00ae3000, 0x00000000, 0x28300000, 0x00000000, 0x01400060,
1130 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1131 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1132 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1133 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x60000000, 0x000000a1, 0x00003900, 0x28301000,
1134 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1135 0xffffffff
1136 };
1137
1138 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalPField[49] =
1139 {
1140 0x000000a3, 0x00000008, 0x00003910, 0x00ae30c0, 0x00000000, 0x28300000, 0x00000000, 0x01400060,
1141 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1142 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1143 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1144 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x40000000, 0x000000a1, 0x00003900, 0x28301000,
1145 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1146 0xffffffff
1147 };
1148
1149 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalBFrame[49] =
1150 {
1151 0x000000a3, 0x00200008, 0x00003910, 0x00aa7700, 0x00000000, 0x20200000, 0x00000000, 0xff400000,
1152 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1153 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1154 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1155 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x60000000, 0x000000a1, 0x00003900, 0x28301000,
1156 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1157 0xffffffff
1158 };
1159
1160 const uint32_t CodechalEncodeAvcEncFeiG8::m_preProcCurbeCmNormalBField[49] =
1161 {
1162 0x000000a3, 0x00200008, 0x00003919, 0x00aa77c0, 0x00000000, 0x20200000, 0x00000000, 0xff400000,
1163 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1164 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1165 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1166 0x00000000, 0x00040c24, 0x00000000, 0x00000000, 0x40000000, 0x000000a1, 0x00003900, 0x28301000,
1167 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
1168 0xffffffff
1169 };
1170
1171 typedef struct _MBENC_CURBE_CM_FEI
1172 {
1173 // DW0
1174 union
1175 {
1176 struct
1177 {
1178 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 );
1179 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 );
1180 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 );
1181 uint32_t : MOS_BITFIELD_RANGE( 3, 4 );
1182 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 );
1183 uint32_t : MOS_BITFIELD_BIT( 6 );
1184 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 );
1185 uint32_t : MOS_BITFIELD_RANGE( 8,23 );
1186 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 );
1187 };
1188 struct
1189 {
1190 uint32_t Value;
1191 };
1192 } DW0;
1193
1194 // DW1
1195 union
1196 {
1197 struct
1198 {
1199 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE( 0, 5 );
1200 uint32_t : MOS_BITFIELD_RANGE( 6,15 );
1201 uint32_t BiWeight : MOS_BITFIELD_RANGE( 16,21 );
1202 uint32_t : MOS_BITFIELD_RANGE( 22,27 );
1203 uint32_t UniMixDisable : MOS_BITFIELD_BIT( 28 );
1204 uint32_t : MOS_BITFIELD_RANGE( 29,31 );
1205 };
1206 struct
1207 {
1208 uint32_t Value;
1209 };
1210 } DW1;
1211
1212 // DW2
1213 union
1214 {
1215 struct
1216 {
1217 uint32_t LenSP : MOS_BITFIELD_RANGE( 0, 7 );
1218 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 );
1219 uint32_t PicWidth : MOS_BITFIELD_RANGE( 16,31 );
1220 };
1221 struct
1222 {
1223 uint32_t Value;
1224 };
1225 } DW2;
1226
1227 // DW3
1228 union
1229 {
1230 struct
1231 {
1232 uint32_t SrcSize : MOS_BITFIELD_RANGE( 0, 1 );
1233 uint32_t : MOS_BITFIELD_RANGE( 2, 3 );
1234 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE( 4, 5 );
1235 uint32_t SrcAccess : MOS_BITFIELD_BIT( 6 );
1236 uint32_t RefAccess : MOS_BITFIELD_BIT( 7 );
1237 uint32_t SearchCtrl : MOS_BITFIELD_RANGE( 8,10 );
1238 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT( 11 );
1239 uint32_t SubPelMode : MOS_BITFIELD_RANGE( 12,13 );
1240 uint32_t SkipType : MOS_BITFIELD_BIT( 14 );
1241 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT( 15 );
1242 uint32_t InterChromaMode : MOS_BITFIELD_BIT( 16 );
1243 uint32_t FTEnable : MOS_BITFIELD_BIT( 17 );
1244 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT( 18 );
1245 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT( 19 );
1246 uint32_t InterSAD : MOS_BITFIELD_RANGE( 20,21 );
1247 uint32_t IntraSAD : MOS_BITFIELD_RANGE( 22,23 );
1248 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE( 24,30 );
1249 uint32_t : MOS_BITFIELD_BIT( 31 );
1250 };
1251 struct
1252 {
1253 uint32_t Value;
1254 };
1255 } DW3;
1256
1257 // DW4
1258 union
1259 {
1260 struct
1261 {
1262 uint32_t PicHeightMinus1 : MOS_BITFIELD_RANGE( 0,15 );
1263 uint32_t MvRestrictionInSliceEnable : MOS_BITFIELD_BIT( 16 );
1264 uint32_t DeltaMvEnable : MOS_BITFIELD_BIT( 17 );
1265 uint32_t TrueDistortionEnable : MOS_BITFIELD_BIT( 18 );
1266 uint32_t FEIEnable : MOS_BITFIELD_BIT( 19);
1267 uint32_t MultipleMVPredictorPerMBEnable : MOS_BITFIELD_BIT( 20);
1268 uint32_t VMEDistortionOutputEnable : MOS_BITFIELD_BIT( 21);
1269 uint32_t PerMBQpEnable : MOS_BITFIELD_BIT( 22);
1270 uint32_t MBInputEnable : MOS_BITFIELD_BIT( 23);
1271 uint32_t : MOS_BITFIELD_BIT( 24);
1272 uint32_t bCurFldIDR : MOS_BITFIELD_BIT( 25 );
1273 uint32_t ConstrainedIntraPredFlag : MOS_BITFIELD_BIT( 26 );
1274 uint32_t FieldParityFlag : MOS_BITFIELD_BIT( 27 );
1275 uint32_t HMEEnable : MOS_BITFIELD_BIT( 28 );
1276 uint32_t PictureType : MOS_BITFIELD_RANGE( 29,30 );
1277 uint32_t UseActualRefQPValue : MOS_BITFIELD_BIT( 31 );
1278 };
1279 struct
1280 {
1281 uint32_t Value;
1282 };
1283 } DW4;
1284
1285 // DW5
1286 union
1287 {
1288 struct
1289 {
1290 uint32_t SliceMbHeight : MOS_BITFIELD_RANGE( 0,15 );
1291 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 );
1292 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 );
1293 };
1294 struct
1295 {
1296 uint32_t Value;
1297 };
1298 } DW5;
1299
1300 // DW6
1301 union
1302 {
1303 struct
1304 {
1305 uint32_t BatchBufferEnd : MOS_BITFIELD_RANGE( 0,31 );
1306 };
1307 struct
1308 {
1309 uint32_t Value;
1310 };
1311 } DW6;
1312
1313 // DW7
1314 union
1315 {
1316 struct
1317 {
1318 uint32_t IntraPartMask : MOS_BITFIELD_RANGE( 0, 4 );
1319 uint32_t NonSkipZMvAdded : MOS_BITFIELD_BIT( 5 );
1320 uint32_t NonSkipModeAdded : MOS_BITFIELD_BIT( 6 );
1321 uint32_t LumaIntraSrcCornerSwap : MOS_BITFIELD_BIT( 7 );
1322 uint32_t : MOS_BITFIELD_RANGE( 8,15 );
1323 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE( 16,17 );
1324 uint32_t BilinearEnable : MOS_BITFIELD_BIT( 18 );
1325 uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT( 19 );
1326 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT( 20 );
1327 uint32_t AConlyHAAR : MOS_BITFIELD_BIT( 21 );
1328 uint32_t RefIDCostMode : MOS_BITFIELD_BIT( 22 );
1329 uint32_t : MOS_BITFIELD_BIT( 23 );
1330 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE( 24,31 );
1331 };
1332 struct
1333 {
1334 uint32_t Value;
1335 };
1336 } DW7;
1337
1338 struct
1339 {
1340 // DW8
1341 union
1342 {
1343 struct
1344 {
1345 uint32_t Mode0Cost : MOS_BITFIELD_RANGE( 0, 7 );
1346 uint32_t Mode1Cost : MOS_BITFIELD_RANGE( 8,15 );
1347 uint32_t Mode2Cost : MOS_BITFIELD_RANGE( 16,23 );
1348 uint32_t Mode3Cost : MOS_BITFIELD_RANGE( 24,31 );
1349 };
1350 struct
1351 {
1352 uint32_t Value;
1353 };
1354 } DW8;
1355
1356 // DW9
1357 union
1358 {
1359 struct
1360 {
1361 uint32_t Mode4Cost : MOS_BITFIELD_RANGE( 0, 7 );
1362 uint32_t Mode5Cost : MOS_BITFIELD_RANGE( 8,15 );
1363 uint32_t Mode6Cost : MOS_BITFIELD_RANGE( 16,23 );
1364 uint32_t Mode7Cost : MOS_BITFIELD_RANGE( 24,31 );
1365 };
1366 struct
1367 {
1368 uint32_t Value;
1369 };
1370 } DW9;
1371
1372 // DW10
1373 union
1374 {
1375 struct
1376 {
1377 uint32_t Mode8Cost : MOS_BITFIELD_RANGE( 0, 7 );
1378 uint32_t Mode9Cost : MOS_BITFIELD_RANGE( 8,15 );
1379 uint32_t RefIDCost : MOS_BITFIELD_RANGE( 16,23 );
1380 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE( 24,31 );
1381 };
1382 struct
1383 {
1384 uint32_t Value;
1385 };
1386 } DW10;
1387
1388 // DW11
1389 union
1390 {
1391 struct
1392 {
1393 uint32_t MV0Cost : MOS_BITFIELD_RANGE( 0, 7 );
1394 uint32_t MV1Cost : MOS_BITFIELD_RANGE( 8,15 );
1395 uint32_t MV2Cost : MOS_BITFIELD_RANGE( 16,23 );
1396 uint32_t MV3Cost : MOS_BITFIELD_RANGE( 24,31 );
1397 };
1398 struct
1399 {
1400 uint32_t Value;
1401 };
1402 } DW11;
1403
1404 // DW12
1405 union
1406 {
1407 struct
1408 {
1409 uint32_t MV4Cost : MOS_BITFIELD_RANGE( 0, 7 );
1410 uint32_t MV5Cost : MOS_BITFIELD_RANGE( 8,15 );
1411 uint32_t MV6Cost : MOS_BITFIELD_RANGE( 16,23 );
1412 uint32_t MV7Cost : MOS_BITFIELD_RANGE( 24,31 );
1413 };
1414 struct
1415 {
1416 uint32_t Value;
1417 };
1418 } DW12;
1419
1420 // DW13
1421 union
1422 {
1423 struct
1424 {
1425 uint32_t QpPrimeY : MOS_BITFIELD_RANGE( 0, 7 );
1426 uint32_t QpPrimeCb : MOS_BITFIELD_RANGE( 8,15 );
1427 uint32_t QpPrimeCr : MOS_BITFIELD_RANGE( 16,23 );
1428 uint32_t TargetSizeInWord : MOS_BITFIELD_RANGE( 24,31 );
1429 };
1430 struct
1431 {
1432 uint32_t Value;
1433 };
1434 } DW13;
1435
1436 // DW14
1437 union
1438 {
1439 struct
1440 {
1441 uint32_t SICFwdTransCoeffThreshold_0 : MOS_BITFIELD_RANGE( 0,15 );
1442 uint32_t SICFwdTransCoeffThreshold_1 : MOS_BITFIELD_RANGE( 16,23 );
1443 uint32_t SICFwdTransCoeffThreshold_2 : MOS_BITFIELD_RANGE( 24,31 );
1444 };
1445 struct
1446 {
1447 uint32_t Value;
1448 };
1449 } DW14;
1450
1451 // DW15
1452 union
1453 {
1454 struct
1455 {
1456 uint32_t SICFwdTransCoeffThreshold_3 : MOS_BITFIELD_RANGE( 0, 7 );
1457 uint32_t SICFwdTransCoeffThreshold_4 : MOS_BITFIELD_RANGE( 8,15 );
1458 uint32_t SICFwdTransCoeffThreshold_5 : MOS_BITFIELD_RANGE( 16,23 );
1459 uint32_t SICFwdTransCoeffThreshold_6 : MOS_BITFIELD_RANGE( 24,31 ); // Highest Freq
1460 };
1461 struct
1462 {
1463 uint32_t Value;
1464 };
1465 } DW15;
1466 } ModeMvCost;
1467
1468 struct
1469 {
1470 // DW16
1471 union
1472 {
1473 struct
1474 {
1475 SearchPathDelta SPDelta_0;
1476 SearchPathDelta SPDelta_1;
1477 SearchPathDelta SPDelta_2;
1478 SearchPathDelta SPDelta_3;
1479 };
1480 struct
1481 {
1482 uint32_t Value;
1483 };
1484 } DW16;
1485
1486 // DW17
1487 union
1488 {
1489 struct
1490 {
1491 SearchPathDelta SPDelta_4;
1492 SearchPathDelta SPDelta_5;
1493 SearchPathDelta SPDelta_6;
1494 SearchPathDelta SPDelta_7;
1495 };
1496 struct
1497 {
1498 uint32_t Value;
1499 };
1500 } DW17;
1501
1502 // DW18
1503 union
1504 {
1505 struct
1506 {
1507 SearchPathDelta SPDelta_8;
1508 SearchPathDelta SPDelta_9;
1509 SearchPathDelta SPDelta_10;
1510 SearchPathDelta SPDelta_11;
1511 };
1512 struct
1513 {
1514 uint32_t Value;
1515 };
1516 } DW18;
1517
1518 // DW19
1519 union
1520 {
1521 struct
1522 {
1523 SearchPathDelta SPDelta_12;
1524 SearchPathDelta SPDelta_13;
1525 SearchPathDelta SPDelta_14;
1526 SearchPathDelta SPDelta_15;
1527 };
1528 struct
1529 {
1530 uint32_t Value;
1531 };
1532 } DW19;
1533
1534 // DW20
1535 union
1536 {
1537 struct
1538 {
1539 SearchPathDelta SPDelta_16;
1540 SearchPathDelta SPDelta_17;
1541 SearchPathDelta SPDelta_18;
1542 SearchPathDelta SPDelta_19;
1543 };
1544 struct
1545 {
1546 uint32_t Value;
1547 };
1548 } DW20;
1549
1550 // DW21
1551 union
1552 {
1553 struct
1554 {
1555 SearchPathDelta SPDelta_20;
1556 SearchPathDelta SPDelta_21;
1557 SearchPathDelta SPDelta_22;
1558 SearchPathDelta SPDelta_23;
1559 };
1560 struct
1561 {
1562 uint32_t Value;
1563 };
1564 } DW21;
1565
1566 // DW22
1567 union
1568 {
1569 struct
1570 {
1571 SearchPathDelta SPDelta_24;
1572 SearchPathDelta SPDelta_25;
1573 SearchPathDelta SPDelta_26;
1574 SearchPathDelta SPDelta_27;
1575 };
1576 struct
1577 {
1578 uint32_t Value;
1579 };
1580 } DW22;
1581
1582 // DW23
1583 union
1584 {
1585 struct
1586 {
1587 SearchPathDelta SPDelta_28;
1588 SearchPathDelta SPDelta_29;
1589 SearchPathDelta SPDelta_30;
1590 SearchPathDelta SPDelta_31;
1591 };
1592 struct
1593 {
1594 uint32_t Value;
1595 };
1596 } DW23;
1597
1598 // DW24
1599 union
1600 {
1601 struct
1602 {
1603 SearchPathDelta SPDelta_32;
1604 SearchPathDelta SPDelta_33;
1605 SearchPathDelta SPDelta_34;
1606 SearchPathDelta SPDelta_35;
1607 };
1608 struct
1609 {
1610 uint32_t Value;
1611 };
1612 } DW24;
1613
1614 // DW25
1615 union
1616 {
1617 struct
1618 {
1619 SearchPathDelta SPDelta_36;
1620 SearchPathDelta SPDelta_37;
1621 SearchPathDelta SPDelta_38;
1622 SearchPathDelta SPDelta_39;
1623 };
1624 struct
1625 {
1626 uint32_t Value;
1627 };
1628 } DW25;
1629
1630 // DW26
1631 union
1632 {
1633 struct
1634 {
1635 SearchPathDelta SPDelta_40;
1636 SearchPathDelta SPDelta_41;
1637 SearchPathDelta SPDelta_42;
1638 SearchPathDelta SPDelta_43;
1639 };
1640 struct
1641 {
1642 uint32_t Value;
1643 };
1644 } DW26;
1645
1646 // DW27
1647 union
1648 {
1649 struct
1650 {
1651 SearchPathDelta SPDelta_44;
1652 SearchPathDelta SPDelta_45;
1653 SearchPathDelta SPDelta_46;
1654 SearchPathDelta SPDelta_47;
1655 };
1656 struct
1657 {
1658 uint32_t Value;
1659 };
1660 } DW27;
1661
1662 // DW28
1663 union
1664 {
1665 struct
1666 {
1667 SearchPathDelta SPDelta_48;
1668 SearchPathDelta SPDelta_49;
1669 SearchPathDelta SPDelta_50;
1670 SearchPathDelta SPDelta_51;
1671 };
1672 struct
1673 {
1674 uint32_t Value;
1675 };
1676 } DW28;
1677
1678 // DW29
1679 union
1680 {
1681 struct
1682 {
1683 SearchPathDelta SPDelta_52;
1684 SearchPathDelta SPDelta_53;
1685 SearchPathDelta SPDelta_54;
1686 SearchPathDelta SPDelta_55;
1687 };
1688 struct
1689 {
1690 uint32_t Value;
1691 };
1692 } DW29;
1693
1694 // DW30
1695 union
1696 {
1697 struct
1698 {
1699 uint32_t Intra4x4ModeMask : MOS_BITFIELD_RANGE( 0, 8 );
1700 uint32_t : MOS_BITFIELD_RANGE( 9,15 );
1701 uint32_t Intra8x8ModeMask : MOS_BITFIELD_RANGE( 16,24 );
1702 uint32_t : MOS_BITFIELD_RANGE( 25,31 );
1703 };
1704 struct
1705 {
1706 uint32_t Value;
1707 };
1708 } DW30;
1709
1710 // DW31
1711 union
1712 {
1713 struct
1714 {
1715 uint32_t Intra16x16ModeMask : MOS_BITFIELD_RANGE( 0, 3 );
1716 uint32_t IntraChromaModeMask : MOS_BITFIELD_RANGE( 4, 7 );
1717 uint32_t IntraComputeType : MOS_BITFIELD_RANGE( 8, 9 );
1718 uint32_t : MOS_BITFIELD_RANGE( 10,31 );
1719 };
1720 struct
1721 {
1722 uint32_t Value;
1723 };
1724 } DW31;
1725 } SPDelta;
1726
1727 // DW32
1728 union
1729 {
1730 struct
1731 {
1732 uint32_t SkipVal : MOS_BITFIELD_RANGE( 0,15 );
1733 uint32_t MultiPredL0Disable : MOS_BITFIELD_RANGE( 16,23 );
1734 uint32_t MultiPredL1Disable : MOS_BITFIELD_RANGE( 24,31 );
1735 };
1736 struct
1737 {
1738 uint32_t Value;
1739 };
1740 } DW32;
1741
1742 // DW33
1743 union
1744 {
1745 struct
1746 {
1747 uint32_t Intra16x16NonDCPredPenalty : MOS_BITFIELD_RANGE( 0,7 );
1748 uint32_t Intra8x8NonDCPredPenalty : MOS_BITFIELD_RANGE( 8,15 );
1749 uint32_t Intra4x4NonDCPredPenalty : MOS_BITFIELD_RANGE( 16,23 );
1750 uint32_t : MOS_BITFIELD_RANGE( 24,31 );
1751 };
1752 struct
1753 {
1754 uint32_t Value;
1755 };
1756 } DW33;
1757
1758 // DW34
1759 union
1760 {
1761 struct
1762 {
1763 uint32_t List0RefID0FieldParity : MOS_BITFIELD_BIT( 0 );
1764 uint32_t List0RefID1FieldParity : MOS_BITFIELD_BIT( 1 );
1765 uint32_t List0RefID2FieldParity : MOS_BITFIELD_BIT( 2 );
1766 uint32_t List0RefID3FieldParity : MOS_BITFIELD_BIT( 3 );
1767 uint32_t List0RefID4FieldParity : MOS_BITFIELD_BIT( 4 );
1768 uint32_t List0RefID5FieldParity : MOS_BITFIELD_BIT( 5 );
1769 uint32_t List0RefID6FieldParity : MOS_BITFIELD_BIT( 6 );
1770 uint32_t List0RefID7FieldParity : MOS_BITFIELD_BIT( 7 );
1771 uint32_t List1RefID0FrameFieldFlag : MOS_BITFIELD_BIT( 8 );
1772 uint32_t List1RefID1FrameFieldFlag : MOS_BITFIELD_BIT( 9 );
1773 uint32_t : MOS_BITFIELD_RANGE( 10,19 );
1774 uint32_t NumMVPredictorsL1 : MOS_BITFIELD_RANGE( 20,23 );
1775 uint32_t List1RefID0FieldParity : MOS_BITFIELD_BIT( 24 );
1776 uint32_t List1RefID1FieldParity : MOS_BITFIELD_BIT( 25 );
1777 uint32_t MADEnableFlag : MOS_BITFIELD_BIT( 26 );
1778 uint32_t ROIEnableFlag : MOS_BITFIELD_BIT( 27 );
1779 uint32_t EnableMBFlatnessChkOptimization : MOS_BITFIELD_BIT( 28 );
1780 uint32_t bDirectMode : MOS_BITFIELD_BIT( 29 );
1781 uint32_t MBBrcEnable : MOS_BITFIELD_BIT( 30 );
1782 uint32_t bOriginalBff : MOS_BITFIELD_BIT( 31 );
1783 };
1784 struct
1785 {
1786 uint32_t Value;
1787 };
1788 } DW34;
1789
1790 // DW35
1791 union
1792 {
1793 struct
1794 {
1795 uint32_t PanicModeMBThreshold : MOS_BITFIELD_RANGE( 0,15 );
1796 uint32_t SmallMbSizeInWord : MOS_BITFIELD_RANGE( 16,23 );
1797 uint32_t LargeMbSizeInWord : MOS_BITFIELD_RANGE( 24,31 );
1798 };
1799 struct
1800 {
1801 uint32_t Value;
1802 };
1803 } DW35;
1804
1805 // DW36
1806 union
1807 {
1808 struct
1809 {
1810 uint32_t NumRefIdxL0MinusOne : MOS_BITFIELD_RANGE( 0, 7 );
1811 uint32_t HMECombinedExtraSUs : MOS_BITFIELD_RANGE( 8,15 );
1812 uint32_t NumRefIdxL1MinusOne : MOS_BITFIELD_RANGE( 16,23 );
1813 uint32_t NumMVPredictors : MOS_BITFIELD_RANGE( 24,27 ); // FEI only
1814 uint32_t IsFwdFrameShortTermRef : MOS_BITFIELD_BIT( 28 );
1815 uint32_t CheckAllFractionalEnable : MOS_BITFIELD_BIT( 29 );
1816 uint32_t HMECombineOverlap : MOS_BITFIELD_RANGE( 30,31 );
1817 };
1818 struct
1819 {
1820 uint32_t Value;
1821 };
1822 } DW36;
1823
1824 // DW37
1825 union
1826 {
1827 struct
1828 {
1829 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 );
1830 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 );
1831 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 );
1832 uint32_t : MOS_BITFIELD_RANGE( 3, 4 );
1833 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 );
1834 uint32_t : MOS_BITFIELD_BIT( 6 );
1835 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 );
1836 uint32_t : MOS_BITFIELD_RANGE( 8,23 );
1837 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 );
1838 };
1839 struct
1840 {
1841 uint32_t Value;
1842 };
1843 } DW37;
1844
1845 // DW38
1846 union
1847 {
1848 struct
1849 {
1850 uint32_t LenSP : MOS_BITFIELD_RANGE( 0, 7 );
1851 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 );
1852 uint32_t RefThreshold : MOS_BITFIELD_RANGE( 16,31 );
1853 };
1854 struct
1855 {
1856 uint32_t Value;
1857 };
1858 } DW38;
1859
1860 // DW39
1861 union
1862 {
1863 struct
1864 {
1865 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
1866 uint32_t HMERefWindowsCombThreshold : MOS_BITFIELD_RANGE( 8,15 );
1867 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 );
1868 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 );
1869 };
1870 struct
1871 {
1872 uint32_t Value;
1873 };
1874 } DW39;
1875
1876 // DW40
1877 union
1878 {
1879 struct
1880 {
1881 uint32_t DistScaleFactorRefID0List0 : MOS_BITFIELD_RANGE( 0,15 );
1882 uint32_t DistScaleFactorRefID1List0 : MOS_BITFIELD_RANGE( 16,31 );
1883 };
1884 struct
1885 {
1886 uint32_t Value;
1887 };
1888 } DW40;
1889
1890 // DW41
1891 union
1892 {
1893 struct
1894 {
1895 uint32_t DistScaleFactorRefID2List0 : MOS_BITFIELD_RANGE( 0,15 );
1896 uint32_t DistScaleFactorRefID3List0 : MOS_BITFIELD_RANGE( 16,31 );
1897 };
1898 struct
1899 {
1900 uint32_t Value;
1901 };
1902 } DW41;
1903
1904 // DW42
1905 union
1906 {
1907 struct
1908 {
1909 uint32_t DistScaleFactorRefID4List0 : MOS_BITFIELD_RANGE( 0,15 );
1910 uint32_t DistScaleFactorRefID5List0 : MOS_BITFIELD_RANGE( 16,31 );
1911 };
1912 struct
1913 {
1914 uint32_t Value;
1915 };
1916 } DW42;
1917
1918 // DW43
1919 union
1920 {
1921 struct
1922 {
1923 uint32_t DistScaleFactorRefID6List0 : MOS_BITFIELD_RANGE( 0,15 );
1924 uint32_t DistScaleFactorRefID7List0 : MOS_BITFIELD_RANGE( 16,31 );
1925 };
1926 struct
1927 {
1928 uint32_t Value;
1929 };
1930 } DW43;
1931
1932 // DW44
1933 union
1934 {
1935 struct
1936 {
1937 uint32_t ActualQPValueForRefID0List0 : MOS_BITFIELD_RANGE( 0, 7 );
1938 uint32_t ActualQPValueForRefID1List0 : MOS_BITFIELD_RANGE( 8,15 );
1939 uint32_t ActualQPValueForRefID2List0 : MOS_BITFIELD_RANGE( 16,23 );
1940 uint32_t ActualQPValueForRefID3List0 : MOS_BITFIELD_RANGE( 24,31 );
1941 };
1942 struct
1943 {
1944 uint32_t Value;
1945 };
1946 } DW44;
1947
1948 // DW45
1949 union
1950 {
1951 struct
1952 {
1953 uint32_t ActualQPValueForRefID4List0 : MOS_BITFIELD_RANGE( 0, 7 );
1954 uint32_t ActualQPValueForRefID5List0 : MOS_BITFIELD_RANGE( 8,15 );
1955 uint32_t ActualQPValueForRefID6List0 : MOS_BITFIELD_RANGE( 16,23 );
1956 uint32_t ActualQPValueForRefID7List0 : MOS_BITFIELD_RANGE( 24,31 );
1957 };
1958 struct
1959 {
1960 uint32_t Value;
1961 };
1962 } DW45;
1963
1964 // DW46
1965 union
1966 {
1967 struct
1968 {
1969 uint32_t ActualQPValueForRefID0List1 : MOS_BITFIELD_RANGE( 0, 7 );
1970 uint32_t ActualQPValueForRefID1List1 : MOS_BITFIELD_RANGE( 8,15 );
1971 uint32_t RefCost : MOS_BITFIELD_RANGE( 16,31 );
1972 };
1973 struct
1974 {
1975 uint32_t Value;
1976 };
1977 } DW46;
1978
1979 // DW47
1980 union
1981 {
1982 struct
1983 {
1984 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
1985 uint32_t IntraCostSF : MOS_BITFIELD_RANGE( 8,15 );
1986 uint32_t MaxVmvR : MOS_BITFIELD_RANGE( 16,31 );
1987 };
1988 struct
1989 {
1990 uint32_t Value;
1991 };
1992 } DW47;
1993
1994 //DW48
1995 union
1996 {
1997 struct
1998 {
1999 uint32_t IntraRefreshMBNum : MOS_BITFIELD_RANGE( 0,15 );
2000 uint32_t IntraRefreshUnitInMBMinus1 : MOS_BITFIELD_RANGE( 16,23 );
2001 uint32_t IntraRefreshQPDelta : MOS_BITFIELD_RANGE( 24,31 );
2002 };
2003 struct
2004 {
2005 uint32_t Value;
2006 };
2007 } DW48;
2008
2009 // DW49
2010 union
2011 {
2012 struct
2013 {
2014 uint32_t ROI1_X_left : MOS_BITFIELD_RANGE( 0,15 );
2015 uint32_t ROI1_Y_top : MOS_BITFIELD_RANGE( 16,31 );
2016 };
2017 struct
2018 {
2019 uint32_t Value;
2020 };
2021 } DW49;
2022
2023 // DW50
2024 union
2025 {
2026 struct
2027 {
2028 uint32_t ROI1_X_right : MOS_BITFIELD_RANGE( 0,15 );
2029 uint32_t ROI1_Y_bottom : MOS_BITFIELD_RANGE( 16,31 );
2030 };
2031 struct
2032 {
2033 uint32_t Value;
2034 };
2035 } DW50;
2036
2037 // DW51
2038 union
2039 {
2040 struct
2041 {
2042 uint32_t ROI2_X_left : MOS_BITFIELD_RANGE( 0,15 );
2043 uint32_t ROI2_Y_top : MOS_BITFIELD_RANGE( 16,31 );
2044 };
2045 struct
2046 {
2047 uint32_t Value;
2048 };
2049 } DW51;
2050
2051 // DW52
2052 union
2053 {
2054 struct
2055 {
2056 uint32_t ROI2_X_right : MOS_BITFIELD_RANGE( 0,15 );
2057 uint32_t ROI2_Y_bottom : MOS_BITFIELD_RANGE( 16,31 );
2058 };
2059 struct
2060 {
2061 uint32_t Value;
2062 };
2063 } DW52;
2064
2065 // DW53
2066 union
2067 {
2068 struct
2069 {
2070 uint32_t ROI3_X_left : MOS_BITFIELD_RANGE( 0,15 );
2071 uint32_t ROI3_Y_top : MOS_BITFIELD_RANGE( 16,31 );
2072 };
2073 struct
2074 {
2075 uint32_t Value;
2076 };
2077 } DW53;
2078
2079 // DW54
2080 union
2081 {
2082 struct
2083 {
2084 uint32_t ROI3_X_right : MOS_BITFIELD_RANGE( 0,15 );
2085 uint32_t ROI3_Y_bottom : MOS_BITFIELD_RANGE( 16,31 );
2086 };
2087 struct
2088 {
2089 uint32_t Value;
2090 };
2091 } DW54;
2092
2093 // DW55
2094 union
2095 {
2096 struct
2097 {
2098 uint32_t ROI4_X_left : MOS_BITFIELD_RANGE( 0,15 );
2099 uint32_t ROI4_Y_top : MOS_BITFIELD_RANGE( 16,31 );
2100 };
2101 struct
2102 {
2103 uint32_t Value;
2104 };
2105 } DW55;
2106
2107 // DW56
2108 union
2109 {
2110 struct
2111 {
2112 uint32_t ROI4_X_right : MOS_BITFIELD_RANGE( 0,15 );
2113 uint32_t ROI4_Y_bottom : MOS_BITFIELD_RANGE( 16,31 );
2114 };
2115 struct
2116 {
2117 uint32_t Value;
2118 };
2119 } DW56;
2120
2121 // DW57
2122 union
2123 {
2124 struct
2125 {
2126 uint32_t ROI1_dQpPrimeY : MOS_BITFIELD_RANGE( 0, 7 );
2127 uint32_t ROI2_dQpPrimeY : MOS_BITFIELD_RANGE( 8,15 );
2128 uint32_t ROI3_dQpPrimeY : MOS_BITFIELD_RANGE( 16,23 );
2129 uint32_t ROI4_dQpPrimeY : MOS_BITFIELD_RANGE( 24,31 );
2130 };
2131 struct
2132 {
2133 uint32_t Value;
2134 };
2135 } DW57;
2136
2137 // DW58
2138 union
2139 {
2140 struct
2141 {
2142 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2143 };
2144 struct
2145 {
2146 uint32_t Value;
2147 };
2148 } DW58;
2149
2150 // DW59
2151 union
2152 {
2153 struct
2154 {
2155 uint32_t IPCM_QP0 : MOS_BITFIELD_RANGE( 0, 7 );
2156 uint32_t IPCM_QP1 : MOS_BITFIELD_RANGE( 8,15 );
2157 uint32_t IPCM_QP2 : MOS_BITFIELD_RANGE( 16,23 );
2158 uint32_t IPCM_QP3 : MOS_BITFIELD_RANGE( 24,31 );
2159 };
2160 struct
2161 {
2162 uint32_t Value;
2163 };
2164 } DW59;
2165
2166 // DW60
2167 union
2168 {
2169 struct
2170 {
2171 uint32_t IPCM_QP4 : MOS_BITFIELD_RANGE( 0, 7 );
2172 uint32_t Reserved : MOS_BITFIELD_RANGE( 8,15 );
2173 uint32_t IPCM_Thresh0 : MOS_BITFIELD_RANGE( 16,31 );
2174 };
2175 struct
2176 {
2177 uint32_t Value;
2178 };
2179 } DW60;
2180
2181 // DW61
2182 union
2183 {
2184 struct
2185 {
2186 uint32_t IPCM_Thresh1 : MOS_BITFIELD_RANGE( 0,15 );
2187 uint32_t IPCM_Thresh2 : MOS_BITFIELD_RANGE( 16,31 );
2188 };
2189 struct
2190 {
2191 uint32_t Value;
2192 };
2193 } DW61;
2194
2195 // DW62
2196 union
2197 {
2198 struct
2199 {
2200 uint32_t IPCM_Thresh3 : MOS_BITFIELD_RANGE( 0,15 );
2201 uint32_t IPCM_Thresh4 : MOS_BITFIELD_RANGE( 16,31 );
2202 };
2203 struct
2204 {
2205 uint32_t Value;
2206 };
2207 } DW62;
2208
2209 // DW63
2210 union
2211 {
2212 struct
2213 {
2214 uint32_t L1ListRef0PictureCodingType : MOS_BITFIELD_RANGE( 0, 1 ); // 0-invalid, 1-TFF, 2-invalid, 3-BFF
2215 uint32_t Reserved : MOS_BITFIELD_RANGE( 2,31 );
2216 };
2217 struct
2218 {
2219 uint32_t Value;
2220 };
2221 } DW63;
2222
2223 // DW64
2224 union
2225 {
2226 struct
2227 {
2228 uint32_t BottomFieldOffsetL1ListRef0MV : MOS_BITFIELD_RANGE( 0,31 );
2229 };
2230 struct
2231 {
2232 uint32_t Value;
2233 };
2234 } DW64;
2235
2236 // DW65
2237 union
2238 {
2239 struct
2240 {
2241 uint32_t BottomFieldOffsetL1ListRef0MBCode : MOS_BITFIELD_RANGE( 0,31 );
2242 };
2243 struct
2244 {
2245 uint32_t Value;
2246 };
2247 } DW65;
2248
2249 // DW66
2250 union
2251 {
2252 struct
2253 {
2254 uint32_t MBDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2255 };
2256 struct
2257 {
2258 uint32_t Value;
2259 };
2260 } DW66;
2261
2262 // DW67
2263 union
2264 {
2265 struct
2266 {
2267 uint32_t MVDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2268 };
2269 struct
2270 {
2271 uint32_t Value;
2272 };
2273 } DW67;
2274
2275 // DW68
2276 union
2277 {
2278 struct
2279 {
2280 uint32_t IDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2281 };
2282 struct
2283 {
2284 uint32_t Value;
2285 };
2286 } DW68;
2287
2288 // DW69
2289 union
2290 {
2291 struct
2292 {
2293 uint32_t SrcYSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2294 };
2295 struct
2296 {
2297 uint32_t Value;
2298 };
2299 } DW69;
2300
2301 // DW70
2302 union
2303 {
2304 struct
2305 {
2306 uint32_t MBSpecificDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2307 };
2308 struct
2309 {
2310 uint32_t Value;
2311 };
2312 } DW70;
2313
2314 // DW71
2315 union
2316 {
2317 struct
2318 {
2319 uint32_t AuxVmeOutSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2320 };
2321 struct
2322 {
2323 uint32_t Value;
2324 };
2325 } DW71;
2326
2327 // DW72
2328 union
2329 {
2330 struct
2331 {
2332 uint32_t CurrRefPicSelSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2333 };
2334 struct
2335 {
2336 uint32_t Value;
2337 };
2338 } DW72;
2339
2340 // DW73
2341 union
2342 {
2343 struct
2344 {
2345 uint32_t HMEMVPredFwdBwdSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2346 };
2347 struct
2348 {
2349 uint32_t Value;
2350 };
2351 } DW73;
2352
2353 // DW74
2354 union
2355 {
2356 struct
2357 {
2358 uint32_t HMEDistSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2359 };
2360 struct
2361 {
2362 uint32_t Value;
2363 };
2364 } DW74;
2365
2366 // DW75
2367 union
2368 {
2369 struct
2370 {
2371 uint32_t RefPicSelectL1SurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2372 };
2373 struct
2374 {
2375 uint32_t Value;
2376 };
2377 } DW75;
2378
2379 // DW76
2380 union
2381 {
2382 struct
2383 {
2384 uint32_t FwdFrmMBDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2385 };
2386 struct
2387 {
2388 uint32_t Value;
2389 };
2390 } DW76;
2391
2392 // DW77
2393 union
2394 {
2395 struct
2396 {
2397 uint32_t FwdFrmMVSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2398 };
2399 struct
2400 {
2401 uint32_t Value;
2402 };
2403 } DW77;
2404
2405 // DW78
2406 union
2407 {
2408 struct
2409 {
2410 uint32_t MBQPBuffer : MOS_BITFIELD_RANGE( 0,31 );
2411 };
2412 struct
2413 {
2414 uint32_t Value;
2415 };
2416 } DW78;
2417
2418 // DW79
2419 union
2420 {
2421 struct
2422 {
2423 uint32_t MBBRCLut : MOS_BITFIELD_RANGE( 0,31 );
2424 };
2425 struct
2426 {
2427 uint32_t Value;
2428 };
2429 } DW79;
2430
2431 // DW80
2432 union
2433 {
2434 struct
2435 {
2436 uint32_t VMEInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2437 };
2438 struct
2439 {
2440 uint32_t Value;
2441 };
2442 } DW80;
2443
2444 // DW81
2445 union
2446 {
2447 struct
2448 {
2449 uint32_t VMEInterPredictionMRSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2450 };
2451 struct
2452 {
2453 uint32_t Value;
2454 };
2455 } DW81;
2456
2457 // DW82
2458 union
2459 {
2460 struct
2461 {
2462 uint32_t FlatnessChkSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2463 };
2464 struct
2465 {
2466 uint32_t Value;
2467 };
2468 } DW82;
2469
2470 // DW83
2471 union
2472 {
2473 struct
2474 {
2475 uint32_t MADSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2476 };
2477 struct
2478 {
2479 uint32_t Value;
2480 };
2481 } DW83;
2482
2483 // DW84
2484 union
2485 {
2486 struct
2487 {
2488 uint32_t InterDistortionSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2489 };
2490 struct
2491 {
2492 uint32_t Value;
2493 };
2494 } DW84;
2495
2496 // DW85
2497 union
2498 {
2499 struct
2500 {
2501 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2502 };
2503 struct
2504 {
2505 uint32_t Value;
2506 };
2507 } DW85;
2508
2509 // DW86
2510 union
2511 {
2512 struct
2513 {
2514 uint32_t BRCCurbeSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
2515 };
2516 struct
2517 {
2518 uint32_t Value;
2519 };
2520 } DW86;
2521
2522 // DW87
2523 union
2524 {
2525 struct
2526 {
2527 uint32_t MvPredictorSurfIndex : MOS_BITFIELD_RANGE(0, 31);
2528 };
2529 struct
2530 {
2531 uint32_t Value;
2532 };
2533 } DW87;
2534
2535 // DW88
2536 union
2537 {
2538 struct
2539 {
2540 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2541 };
2542 struct
2543 {
2544 uint32_t Value;
2545 };
2546 } DW88;
2547
2548 // DW89
2549 union
2550 {
2551 struct
2552 {
2553 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2554 };
2555 struct
2556 {
2557 uint32_t Value;
2558 };
2559 } DW89;
2560
2561 // DW90
2562 union
2563 {
2564 struct
2565 {
2566 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2567 };
2568 struct
2569 {
2570 uint32_t Value;
2571 };
2572 } DW90;
2573
2574 // DW91
2575 union
2576 {
2577 struct
2578 {
2579 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2580 };
2581 struct
2582 {
2583 uint32_t Value;
2584 };
2585 } DW91;
2586
2587 // DW92
2588 union
2589 {
2590 struct
2591 {
2592 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2593 };
2594 struct
2595 {
2596 uint32_t Value;
2597 };
2598 } DW92;
2599
2600 // DW93
2601 union
2602 {
2603 struct
2604 {
2605 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2606 };
2607 struct
2608 {
2609 uint32_t Value;
2610 };
2611 } DW93;
2612
2613 // DW94
2614 union
2615 {
2616 struct
2617 {
2618 uint32_t Reserved : MOS_BITFIELD_RANGE( 0,31 );
2619 };
2620 struct
2621 {
2622 uint32_t Value;
2623 };
2624 } DW94;
2625
2626 }MBENC_CURBE_CM_FEI, *PMBENC_CURBE_CM_FEI;
2627 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(MBENC_CURBE_CM_FEI)) == CodechalEncodeAvcEncFeiG8::m_feiMBEncCurbeSizeInDword);
2628
2629 typedef struct _PREPROC_CURBE_CM
2630 {
2631 // DW0
2632 union
2633 {
2634 struct
2635 {
2636 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 );
2637 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 );
2638 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 );
2639 uint32_t : MOS_BITFIELD_RANGE( 3, 4 );
2640 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 );
2641 uint32_t : MOS_BITFIELD_BIT( 6 );
2642 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 );
2643 uint32_t : MOS_BITFIELD_RANGE( 8,23 );
2644 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 );
2645 };
2646 struct
2647 {
2648 uint32_t Value;
2649 };
2650 } DW0;
2651
2652 // DW1
2653 union
2654 {
2655 struct
2656 {
2657 uint32_t MaxNumMVs : MOS_BITFIELD_RANGE( 0, 5 );
2658 uint32_t : MOS_BITFIELD_RANGE( 6,15 );
2659 uint32_t BiWeight : MOS_BITFIELD_RANGE( 16,21 );
2660 uint32_t : MOS_BITFIELD_RANGE( 22,27 );
2661 uint32_t UniMixDisable : MOS_BITFIELD_BIT( 28 );
2662 uint32_t : MOS_BITFIELD_RANGE( 29,31 );
2663 };
2664 struct
2665 {
2666 uint32_t Value;
2667 };
2668 } DW1;
2669
2670 // DW2
2671 union
2672 {
2673 struct
2674 {
2675 uint32_t LenSP : MOS_BITFIELD_RANGE( 0, 7 );
2676 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 );
2677 uint32_t PicWidth : MOS_BITFIELD_RANGE( 16,31 );
2678 };
2679 struct
2680 {
2681 uint32_t Value;
2682 };
2683 } DW2;
2684
2685 // DW3
2686 union
2687 {
2688 struct
2689 {
2690 uint32_t SrcSize : MOS_BITFIELD_RANGE( 0, 1 );
2691 uint32_t : MOS_BITFIELD_RANGE( 2, 3 );
2692 uint32_t MbTypeRemap : MOS_BITFIELD_RANGE( 4, 5 );
2693 uint32_t SrcAccess : MOS_BITFIELD_BIT( 6 );
2694 uint32_t RefAccess : MOS_BITFIELD_BIT( 7 );
2695 uint32_t SearchCtrl : MOS_BITFIELD_RANGE( 8,10 );
2696 uint32_t DualSearchPathOption : MOS_BITFIELD_BIT( 11 );
2697 uint32_t SubPelMode : MOS_BITFIELD_RANGE( 12,13 );
2698 uint32_t SkipType : MOS_BITFIELD_BIT( 14 );
2699 uint32_t DisableFieldCacheAlloc : MOS_BITFIELD_BIT( 15 );
2700 uint32_t InterChromaMode : MOS_BITFIELD_BIT( 16 );
2701 uint32_t FTEnable : MOS_BITFIELD_BIT( 17 );
2702 uint32_t BMEDisableFBR : MOS_BITFIELD_BIT( 18 );
2703 uint32_t BlockBasedSkipEnable : MOS_BITFIELD_BIT( 19 );
2704 uint32_t InterSAD : MOS_BITFIELD_RANGE( 20,21 );
2705 uint32_t IntraSAD : MOS_BITFIELD_RANGE( 22,23 );
2706 uint32_t SubMbPartMask : MOS_BITFIELD_RANGE( 24,30 );
2707 uint32_t : MOS_BITFIELD_BIT( 31 );
2708 };
2709 struct
2710 {
2711 uint32_t Value;
2712 };
2713 } DW3;
2714
2715 // DW4
2716 union
2717 {
2718 struct
2719 {
2720 uint32_t FrameQp : MOS_BITFIELD_RANGE( 0, 7 );
2721 uint32_t PerMBQpEnable : MOS_BITFIELD_BIT( 8 );
2722 uint32_t FieldParityFlag : MOS_BITFIELD_BIT( 9 );
2723 uint32_t HMEEnable : MOS_BITFIELD_BIT( 10 );
2724 uint32_t MultipleMVPredictorPerMBEnable : MOS_BITFIELD_RANGE( 11,12 );
2725 uint32_t DisableMvOutput : MOS_BITFIELD_BIT( 13 );
2726 uint32_t DisableMbStats : MOS_BITFIELD_BIT( 14 );
2727 uint32_t BwdRefPicFrameFieldFlag : MOS_BITFIELD_BIT( 15 );
2728 uint32_t FwdRefPicFrameFieldFlag : MOS_BITFIELD_BIT( 16 );
2729 uint32_t BwdRefPicFieldParityFlag : MOS_BITFIELD_BIT( 17 );
2730 uint32_t FwdRefPicFieldParityFlag : MOS_BITFIELD_BIT( 18 );
2731 uint32_t CurrPicFieldParityFlag : MOS_BITFIELD_BIT( 19 );
2732 uint32_t BwdRefPicEnable : MOS_BITFIELD_BIT( 20 );
2733 uint32_t FwdRefPicEnable : MOS_BITFIELD_BIT( 21 );
2734 uint32_t : MOS_BITFIELD_RANGE( 22,31 );
2735 };
2736 struct
2737 {
2738 uint32_t Value;
2739 };
2740 } DW4;
2741
2742 // DW5
2743 union
2744 {
2745 struct
2746 {
2747 uint32_t SliceMbHeight : MOS_BITFIELD_RANGE( 0,15 );
2748 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 );
2749 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 );
2750 };
2751 struct
2752 {
2753 uint32_t Value;
2754 };
2755 } DW5;
2756
2757 // DW6
2758 union
2759 {
2760 struct
2761 {
2762 uint32_t PicHeight : MOS_BITFIELD_RANGE( 0,15 );
2763 uint32_t : MOS_BITFIELD_RANGE( 16,31 );
2764 };
2765 struct
2766 {
2767 uint32_t Value;
2768 };
2769 } DW6;
2770
2771 // DW7
2772 union
2773 {
2774 struct
2775 {
2776 uint32_t IntraPartMask : MOS_BITFIELD_RANGE( 0, 4 );
2777 uint32_t NonSkipZMvAdded : MOS_BITFIELD_BIT( 5 );
2778 uint32_t NonSkipModeAdded : MOS_BITFIELD_BIT( 6 );
2779 uint32_t LumaIntraSrcCornerSwap : MOS_BITFIELD_BIT( 7 );
2780 uint32_t : MOS_BITFIELD_RANGE( 8,15 );
2781 uint32_t MVCostScaleFactor : MOS_BITFIELD_RANGE( 16,17 );
2782 uint32_t BilinearEnable : MOS_BITFIELD_BIT( 18 );
2783 uint32_t SrcFieldPolarity : MOS_BITFIELD_BIT( 19 );
2784 uint32_t WeightedSADHAAR : MOS_BITFIELD_BIT( 20 );
2785 uint32_t AConlyHAAR : MOS_BITFIELD_BIT( 21 );
2786 uint32_t RefIDCostMode : MOS_BITFIELD_BIT( 22 );
2787 uint32_t : MOS_BITFIELD_BIT( 23 );
2788 uint32_t SkipCenterMask : MOS_BITFIELD_RANGE( 24,31 );
2789 };
2790 struct
2791 {
2792 uint32_t Value;
2793 };
2794 } DW7;
2795
2796 struct
2797 {
2798 // DW8
2799 union
2800 {
2801 struct
2802 {
2803 uint32_t Mode0Cost : MOS_BITFIELD_RANGE( 0, 7 );
2804 uint32_t Mode1Cost : MOS_BITFIELD_RANGE( 8,15 );
2805 uint32_t Mode2Cost : MOS_BITFIELD_RANGE( 16,23 );
2806 uint32_t Mode3Cost : MOS_BITFIELD_RANGE( 24,31 );
2807 };
2808 struct
2809 {
2810 uint32_t Value;
2811 };
2812 } DW8;
2813
2814 // DW9
2815 union
2816 {
2817 struct
2818 {
2819 uint32_t Mode4Cost : MOS_BITFIELD_RANGE( 0, 7 );
2820 uint32_t Mode5Cost : MOS_BITFIELD_RANGE( 8,15 );
2821 uint32_t Mode6Cost : MOS_BITFIELD_RANGE( 16,23 );
2822 uint32_t Mode7Cost : MOS_BITFIELD_RANGE( 24,31 );
2823 };
2824 struct
2825 {
2826 uint32_t Value;
2827 };
2828 } DW9;
2829
2830 // DW10
2831 union
2832 {
2833 struct
2834 {
2835 uint32_t Mode8Cost : MOS_BITFIELD_RANGE( 0, 7 );
2836 uint32_t Mode9Cost : MOS_BITFIELD_RANGE( 8,15 );
2837 uint32_t RefIDCost : MOS_BITFIELD_RANGE( 16,23 );
2838 uint32_t ChromaIntraModeCost : MOS_BITFIELD_RANGE( 24,31 );
2839 };
2840 struct
2841 {
2842 uint32_t Value;
2843 };
2844 } DW10;
2845
2846 // DW11
2847 union
2848 {
2849 struct
2850 {
2851 uint32_t MV0Cost : MOS_BITFIELD_RANGE( 0, 7 );
2852 uint32_t MV1Cost : MOS_BITFIELD_RANGE( 8,15 );
2853 uint32_t MV2Cost : MOS_BITFIELD_RANGE( 16,23 );
2854 uint32_t MV3Cost : MOS_BITFIELD_RANGE( 24,31 );
2855 };
2856 struct
2857 {
2858 uint32_t Value;
2859 };
2860 } DW11;
2861
2862 // DW12
2863 union
2864 {
2865 struct
2866 {
2867 uint32_t MV4Cost : MOS_BITFIELD_RANGE( 0, 7 );
2868 uint32_t MV5Cost : MOS_BITFIELD_RANGE( 8,15 );
2869 uint32_t MV6Cost : MOS_BITFIELD_RANGE( 16,23 );
2870 uint32_t MV7Cost : MOS_BITFIELD_RANGE( 24,31 );
2871 };
2872 struct
2873 {
2874 uint32_t Value;
2875 };
2876 } DW12;
2877
2878 // DW13
2879 union
2880 {
2881 struct
2882 {
2883 uint32_t : MOS_BITFIELD_RANGE( 0, 31 );
2884 };
2885 struct
2886 {
2887 uint32_t Value;
2888 };
2889 } DW13;
2890
2891 // DW14
2892 union
2893 {
2894 struct
2895 {
2896 uint32_t SICFwdTransCoeffThreshold_0 : MOS_BITFIELD_RANGE( 0,15 );
2897 uint32_t SICFwdTransCoeffThreshold_1 : MOS_BITFIELD_RANGE( 16,23 );
2898 uint32_t SICFwdTransCoeffThreshold_2 : MOS_BITFIELD_RANGE( 24,31 );
2899 };
2900 struct
2901 {
2902 uint32_t Value;
2903 };
2904 } DW14;
2905
2906 // DW15
2907 union
2908 {
2909 struct
2910 {
2911 uint32_t SICFwdTransCoeffThreshold_3 : MOS_BITFIELD_RANGE( 0, 7 );
2912 uint32_t SICFwdTransCoeffThreshold_4 : MOS_BITFIELD_RANGE( 8,15 );
2913 uint32_t SICFwdTransCoeffThreshold_5 : MOS_BITFIELD_RANGE( 16,23 );
2914 uint32_t SICFwdTransCoeffThreshold_6 : MOS_BITFIELD_RANGE( 24,31 ); // Highest Freq
2915 };
2916 struct
2917 {
2918 uint32_t Value;
2919 };
2920 } DW15;
2921 } ModeMvCost;
2922
2923 struct
2924 {
2925 // DW16
2926 union
2927 {
2928 struct
2929 {
2930 SearchPathDelta SPDelta_0;
2931 SearchPathDelta SPDelta_1;
2932 SearchPathDelta SPDelta_2;
2933 SearchPathDelta SPDelta_3;
2934 };
2935 struct
2936 {
2937 uint32_t Value;
2938 };
2939 } DW16;
2940
2941 // DW17
2942 union
2943 {
2944 struct
2945 {
2946 SearchPathDelta SPDelta_4;
2947 SearchPathDelta SPDelta_5;
2948 SearchPathDelta SPDelta_6;
2949 SearchPathDelta SPDelta_7;
2950 };
2951 struct
2952 {
2953 uint32_t Value;
2954 };
2955 } DW17;
2956
2957 // DW18
2958 union
2959 {
2960 struct
2961 {
2962 SearchPathDelta SPDelta_8;
2963 SearchPathDelta SPDelta_9;
2964 SearchPathDelta SPDelta_10;
2965 SearchPathDelta SPDelta_11;
2966 };
2967 struct
2968 {
2969 uint32_t Value;
2970 };
2971 } DW18;
2972
2973 // DW19
2974 union
2975 {
2976 struct
2977 {
2978 SearchPathDelta SPDelta_12;
2979 SearchPathDelta SPDelta_13;
2980 SearchPathDelta SPDelta_14;
2981 SearchPathDelta SPDelta_15;
2982 };
2983 struct
2984 {
2985 uint32_t Value;
2986 };
2987 } DW19;
2988
2989 // DW20
2990 union
2991 {
2992 struct
2993 {
2994 SearchPathDelta SPDelta_16;
2995 SearchPathDelta SPDelta_17;
2996 SearchPathDelta SPDelta_18;
2997 SearchPathDelta SPDelta_19;
2998 };
2999 struct
3000 {
3001 uint32_t Value;
3002 };
3003 } DW20;
3004
3005 // DW21
3006 union
3007 {
3008 struct
3009 {
3010 SearchPathDelta SPDelta_20;
3011 SearchPathDelta SPDelta_21;
3012 SearchPathDelta SPDelta_22;
3013 SearchPathDelta SPDelta_23;
3014 };
3015 struct
3016 {
3017 uint32_t Value;
3018 };
3019 } DW21;
3020
3021 // DW22
3022 union
3023 {
3024 struct
3025 {
3026 SearchPathDelta SPDelta_24;
3027 SearchPathDelta SPDelta_25;
3028 SearchPathDelta SPDelta_26;
3029 SearchPathDelta SPDelta_27;
3030 };
3031 struct
3032 {
3033 uint32_t Value;
3034 };
3035 } DW22;
3036
3037 // DW23
3038 union
3039 {
3040 struct
3041 {
3042 SearchPathDelta SPDelta_28;
3043 SearchPathDelta SPDelta_29;
3044 SearchPathDelta SPDelta_30;
3045 SearchPathDelta SPDelta_31;
3046 };
3047 struct
3048 {
3049 uint32_t Value;
3050 };
3051 } DW23;
3052
3053 // DW24
3054 union
3055 {
3056 struct
3057 {
3058 SearchPathDelta SPDelta_32;
3059 SearchPathDelta SPDelta_33;
3060 SearchPathDelta SPDelta_34;
3061 SearchPathDelta SPDelta_35;
3062 };
3063 struct
3064 {
3065 uint32_t Value;
3066 };
3067 } DW24;
3068
3069 // DW25
3070 union
3071 {
3072 struct
3073 {
3074 SearchPathDelta SPDelta_36;
3075 SearchPathDelta SPDelta_37;
3076 SearchPathDelta SPDelta_38;
3077 SearchPathDelta SPDelta_39;
3078 };
3079 struct
3080 {
3081 uint32_t Value;
3082 };
3083 } DW25;
3084
3085 // DW26
3086 union
3087 {
3088 struct
3089 {
3090 SearchPathDelta SPDelta_40;
3091 SearchPathDelta SPDelta_41;
3092 SearchPathDelta SPDelta_42;
3093 SearchPathDelta SPDelta_43;
3094 };
3095 struct
3096 {
3097 uint32_t Value;
3098 };
3099 } DW26;
3100
3101 // DW27
3102 union
3103 {
3104 struct
3105 {
3106 SearchPathDelta SPDelta_44;
3107 SearchPathDelta SPDelta_45;
3108 SearchPathDelta SPDelta_46;
3109 SearchPathDelta SPDelta_47;
3110 };
3111 struct
3112 {
3113 uint32_t Value;
3114 };
3115 } DW27;
3116
3117 // DW28
3118 union
3119 {
3120 struct
3121 {
3122 SearchPathDelta SPDelta_48;
3123 SearchPathDelta SPDelta_49;
3124 SearchPathDelta SPDelta_50;
3125 SearchPathDelta SPDelta_51;
3126 };
3127 struct
3128 {
3129 uint32_t Value;
3130 };
3131 } DW28;
3132
3133 // DW29
3134 union
3135 {
3136 struct
3137 {
3138 SearchPathDelta SPDelta_52;
3139 SearchPathDelta SPDelta_53;
3140 SearchPathDelta SPDelta_54;
3141 SearchPathDelta SPDelta_55;
3142 };
3143 struct
3144 {
3145 uint32_t Value;
3146 };
3147 } DW29;
3148
3149 // DW30
3150 union
3151 {
3152 struct
3153 {
3154 uint32_t Intra4x4ModeMask : MOS_BITFIELD_RANGE( 0, 8 );
3155 uint32_t : MOS_BITFIELD_RANGE( 9,15 );
3156 uint32_t Intra8x8ModeMask : MOS_BITFIELD_RANGE( 16,24 );
3157 uint32_t : MOS_BITFIELD_RANGE( 25,31 );
3158 };
3159 struct
3160 {
3161 uint32_t Value;
3162 };
3163 } DW30;
3164
3165 // DW31
3166 union
3167 {
3168 struct
3169 {
3170 uint32_t Intra16x16ModeMask : MOS_BITFIELD_RANGE( 0, 3 );
3171 uint32_t IntraChromaModeMask : MOS_BITFIELD_RANGE( 4, 7 );
3172 uint32_t IntraComputeType : MOS_BITFIELD_RANGE( 8, 9 );
3173 uint32_t : MOS_BITFIELD_RANGE( 10,31 );
3174 };
3175 struct
3176 {
3177 uint32_t Value;
3178 };
3179 } DW31;
3180 } SPDelta;
3181
3182 // DW32
3183 union
3184 {
3185 struct
3186 {
3187 uint32_t MaxVmvR : MOS_BITFIELD_RANGE( 0,15 );
3188 uint32_t : MOS_BITFIELD_RANGE( 16,31 );
3189 };
3190 struct
3191 {
3192 uint32_t Value;
3193 };
3194 } DW32;
3195
3196 // DW33
3197 union
3198 {
3199 struct
3200 {
3201 uint32_t Intra16x16NonDCPredPenalty : MOS_BITFIELD_RANGE( 0,7 );
3202 uint32_t Intra8x8NonDCPredPenalty : MOS_BITFIELD_RANGE( 8,15 );
3203 uint32_t Intra4x4NonDCPredPenalty : MOS_BITFIELD_RANGE( 16,23 );
3204 uint32_t : MOS_BITFIELD_RANGE( 24,31 );
3205 };
3206 struct
3207 {
3208 uint32_t Value;
3209 };
3210 } DW33;
3211
3212 // DW34
3213 union
3214 {
3215 struct
3216 {
3217 uint32_t : MOS_BITFIELD_RANGE( 0,31 );
3218 };
3219 struct
3220 {
3221 uint32_t Value;
3222 };
3223 } DW34;
3224
3225 // DW35
3226 union
3227 {
3228 struct
3229 {
3230 uint32_t : MOS_BITFIELD_RANGE( 0,31 );
3231 };
3232 struct
3233 {
3234 uint32_t Value;
3235 };
3236 } DW35;
3237
3238 // DW36
3239 union
3240 {
3241 struct
3242 {
3243 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
3244 uint32_t HMECombinedExtraSUs : MOS_BITFIELD_RANGE( 8,15 );
3245 uint32_t : MOS_BITFIELD_RANGE( 16,29 );
3246 uint32_t HMECombineOverlap : MOS_BITFIELD_RANGE( 30,31 );
3247 };
3248 struct
3249 {
3250 uint32_t Value;
3251 };
3252 } DW36;
3253
3254 // DW37
3255 union
3256 {
3257 struct
3258 {
3259 uint32_t SkipModeEn : MOS_BITFIELD_BIT( 0 );
3260 uint32_t AdaptiveEn : MOS_BITFIELD_BIT( 1 );
3261 uint32_t BiMixDis : MOS_BITFIELD_BIT( 2 );
3262 uint32_t : MOS_BITFIELD_RANGE( 3, 4 );
3263 uint32_t EarlyImeSuccessEn : MOS_BITFIELD_BIT( 5 );
3264 uint32_t : MOS_BITFIELD_BIT( 6 );
3265 uint32_t T8x8FlagForInterEn : MOS_BITFIELD_BIT( 7 );
3266 uint32_t : MOS_BITFIELD_RANGE( 8,23 );
3267 uint32_t EarlyImeStop : MOS_BITFIELD_RANGE( 24,31 );
3268 };
3269 struct
3270 {
3271 uint32_t Value;
3272 };
3273 } DW37;
3274
3275 // DW38
3276 union
3277 {
3278 struct
3279 {
3280 uint32_t LenSP : MOS_BITFIELD_RANGE( 0, 7 );
3281 uint32_t MaxNumSU : MOS_BITFIELD_RANGE( 8,15 );
3282 uint32_t RefThreshold : MOS_BITFIELD_RANGE( 16,31 );
3283 };
3284 struct
3285 {
3286 uint32_t Value;
3287 };
3288 } DW38;
3289
3290 // DW39
3291 union
3292 {
3293 struct
3294 {
3295 uint32_t : MOS_BITFIELD_RANGE( 0, 7 );
3296 uint32_t HMERefWindowsCombThreshold : MOS_BITFIELD_RANGE( 8,15 );
3297 uint32_t RefWidth : MOS_BITFIELD_RANGE( 16,23 );
3298 uint32_t RefHeight : MOS_BITFIELD_RANGE( 24,31 );
3299 };
3300 struct
3301 {
3302 uint32_t Value;
3303 };
3304 } DW39;
3305
3306 // DW40
3307 union
3308 {
3309 struct
3310 {
3311 uint32_t CurrPicSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3312 };
3313 struct
3314 {
3315 uint32_t Value;
3316 };
3317 } DW40;
3318
3319 // DW41
3320 union
3321 {
3322 struct
3323 {
3324 uint32_t HMEMvDataSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3325 };
3326 struct
3327 {
3328 uint32_t Value;
3329 };
3330 } DW41;
3331
3332 // DW42
3333 union
3334 {
3335 struct
3336 {
3337 uint32_t MvPredictorSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3338 };
3339 struct
3340 {
3341 uint32_t Value;
3342 };
3343 } DW42;
3344
3345 // DW43
3346 union
3347 {
3348 struct
3349 {
3350 uint32_t MbQpSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3351 };
3352 struct
3353 {
3354 uint32_t Value;
3355 };
3356 } DW43;
3357
3358 // DW44
3359 union
3360 {
3361 struct
3362 {
3363 uint32_t MvDataOutSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3364 };
3365 struct
3366 {
3367 uint32_t Value;
3368 };
3369 } DW44;
3370
3371 // DW45
3372 union
3373 {
3374 struct
3375 {
3376 uint32_t MbStatsOutSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3377 };
3378 struct
3379 {
3380 uint32_t Value;
3381 };
3382 } DW45;
3383
3384 // DW46
3385 union
3386 {
3387 struct
3388 {
3389 uint32_t VMEInterPredictionSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3390 };
3391 struct
3392 {
3393 uint32_t Value;
3394 };
3395 } DW46;
3396
3397 // DW47
3398 union
3399 {
3400 struct
3401 {
3402 uint32_t VMEInterPredictionMRSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3403 };
3404 struct
3405 {
3406 uint32_t Value;
3407 };
3408 } DW47;
3409
3410 // DW48
3411 union
3412 {
3413 struct
3414 {
3415 uint32_t FtqLutSurfIndex : MOS_BITFIELD_RANGE( 0,31 );
3416 };
3417 struct
3418 {
3419 uint32_t Value;
3420 };
3421 } DW48;
3422
3423 } PREPROC_CURBE_CM, *PPREPROC_CURBE_CM;
3424
3425 C_ASSERT(MOS_BYTES_TO_DWORDS(sizeof(PREPROC_CURBE_CM)) == 49);
3426
3427 // AVC FEI MBEnc CURBE init data for G9 Kernel
3428 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalIFrame[m_feiMBEncCurbeSizeInDword] =
3429 {
3430 0x00000082, 0x00000000, 0x00003910, 0x00a83000, 0x00000000, 0x28300000, 0x05000000, 0x00000000,
3431 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3432 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3433 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3434 0x80800000, 0x00040c24, 0x00000000, 0xffff00ff, 0x40000000, 0x00000080, 0x00003900, 0x28301000,
3435 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000002,
3436 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3437 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3438 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3439 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3440 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3441 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3442 };
3443
3444 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalIField[m_feiMBEncCurbeSizeInDword] =
3445 {
3446 0x00000082, 0x00000000, 0x00003910, 0x00a830c0, 0x02000000, 0x28300000, 0x05000000, 0x00000000,
3447 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3448 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3449 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3450 0x80800000, 0x00040c24, 0x00000000, 0xffff00ff, 0x40000000, 0x00000080, 0x00003900, 0x28301000,
3451 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000002,
3452 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3453 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3454 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3455 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3456 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3457 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3458 };
3459
3460 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalPFrame[m_feiMBEncCurbeSizeInDword] =
3461 {
3462 0x000000a3, 0x00000008, 0x00003910, 0x00ae3000, 0x30000000, 0x28300000, 0x05000000, 0x01400060,
3463 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3464 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3465 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3466 0x80010000, 0x00040c24, 0x00000000, 0xffff00ff, 0x60000000, 0x000000a1, 0x00003900, 0x28301000,
3467 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x08000002,
3468 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3469 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3470 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3471 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3472 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3473 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3474 };
3475
3476 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalPfield[m_feiMBEncCurbeSizeInDword] =
3477 {
3478 0x000000a3, 0x00000008, 0x00003910, 0x00ae30c0, 0x30000000, 0x28300000, 0x05000000, 0x01400060,
3479 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3480 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3481 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3482 0x80010000, 0x00040c24, 0x00000000, 0xffff00ff, 0x40000000, 0x000000a1, 0x00003900, 0x28301000,
3483 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04000002,
3484 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3485 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3486 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3487 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3488 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3489 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3490
3491 };
3492
3493 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalBFrame[m_feiMBEncCurbeSizeInDword] =
3494 {
3495 0x000000a3, 0x00200008, 0x00003910, 0x00aa7700, 0x50020000, 0x20200000, 0x05000000, 0xff400000,
3496 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3497 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3498 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3499 0x01010000, 0x00040c24, 0x00000000, 0xffff00ff, 0x60000000, 0x000000a1, 0x00003900, 0x28301000,
3500 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x08000002,
3501 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3502 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3503 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3504 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3505 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3506 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3507 };
3508
3509 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeNormalBField[m_feiMBEncCurbeSizeInDword] =
3510 {
3511 0x000000a3, 0x00200008, 0x00003919, 0x00aa77c0, 0x50020000, 0x20200000, 0x05000000, 0xff400000,
3512 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3513 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3514 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3515 0x01010000, 0x00040c24, 0x00000000, 0xffff00ff, 0x40000000, 0x000000a1, 0x00003900, 0x28301000,
3516 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x04000002,
3517 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3518 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3519 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3520 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3521 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3522 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3523
3524 };
3525
3526 // FEI AVC I_DIST CURBE init data for G9 Kernel
3527 const uint32_t CodechalEncodeAvcEncFeiG8::m_feiMbEncCurbeIFrameDist[m_feiMBEncCurbeSizeInDword] =
3528 {
3529 0x00000082, 0x00200008, 0x001e3910, 0x00a83000, 0x90000000, 0x28300000, 0x00000000, 0x00000000,
3530 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xff000000, 0x00000000, 0x00000000,
3531 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3532 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000100,
3533 0x80800000, 0x00000000, 0x00000800, 0xffff00ff, 0x40000000, 0x00000080, 0x00003900, 0x28300000,
3534 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3535 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3536 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
3537 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3538 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3539 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
3540 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
3541 };
3542
3543 typedef enum _CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_PREPROC_CM_G8
3544 {
3545 CODECHAL_ENCODE_AVC_PREPROC_CURR_Y_CM_G8 = 0,
3546 CODECHAL_ENCODE_AVC_PREPROC_CURR_UV_CM_G8 = 1,
3547 CODECHAL_ENCODE_AVC_PREPROC_HME_MV_DATA_CM_G8 = 2,
3548 CODECHAL_ENCODE_AVC_PREPROC_MV_PREDICTOR_CM_G8 = 3,
3549 CODECHAL_ENCODE_AVC_PREPROC_MBQP_CM_G8 = 4,
3550 CODECHAL_ENCODE_AVC_PREPROC_MV_DATA_CM_G8 = 5,
3551 CODECHAL_ENCODE_AVC_PREPROC_MB_STATS_CM_G8 = 6,
3552 CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_0_CM_G8 = 7,
3553 CODECHAL_ENCODE_AVC_PREPROC_VME_FWD_PIC_IDX0_CM_G8 = 8,
3554 CODECHAL_ENCODE_AVC_PREPROC_VME_BWD_PIC_IDX0_0_CM_G8 = 9,
3555 CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_1_CM_G8 = 10,
3556 CODECHAL_ENCODE_AVC_PREPROC_VME_BWD_PIC_IDX0_1_CM_G8 = 11,
3557 CODECHAL_ENCODE_AVC_PREPROC_RESERVED1_CM_G8 = 12,
3558 CODECHAL_ENCODE_AVC_PREPROC_FTQ_LUT_CM_G8 = 13,
3559 CODECHAL_ENCODE_AVC_PREPROC_NUM_SURFACES_CM_G8 = 14
3560 } CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_PREPROC_CM_G8;
3561
3562 typedef enum _CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_PREPROC_FIELD_CM_G8
3563 {
3564 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_0_CM_G8 = 7,
3565 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_FWD_PIC_IDX0_0_CM_G8 = 8,
3566 CODECHAL_ENCODE_AVC_PREPROC_FIELD_RESERVED0_CM_G8 = 9,
3567 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_FWD_PIC_IDX0_1_CM_G8 = 10,
3568 CODECHAL_ENCODE_AVC_PREPROC_FIELD_RESERVED1_CM_G8 = 11,
3569 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_1_CM_G8 = 12,
3570 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_BWD_PIC_IDX0_0_CM_G8 = 13,
3571 CODECHAL_ENCODE_AVC_PREPROC_FIELD_RESERVED2_CM_G8 = 14,
3572 CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_BWD_PIC_IDX0_1_CM_G8 = 15,
3573 CODECHAL_ENCODE_AVC_PREPROC_FIELD_RESERVED3_CM_G8 = 16,
3574 CODECHAL_ENCODE_AVC_PREPROC_FIELD_FTQ_LUT_CM_G8 = 17,
3575 CODECHAL_ENCODE_AVC_PREPROC_FIELD_NUM_SURFACES_CM_G8 = 18
3576 } CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_PREPROC_FIELD_CM_G8;
3577
3578 CodechalEncodeAvcEncFeiG8::CodechalEncodeAvcEncFeiG8(
3579 CodechalHwInterface * hwInterface,
3580 CodechalDebugInterface *debugInterface,
3581 PCODECHAL_STANDARD_INFO standardInfo) : CodechalEncodeAvcEncG8(hwInterface, debugInterface, standardInfo)
3582 {
3583 CODECHAL_ENCODE_FUNCTION_ENTER;
3584
3585 m_cmKernelEnable = true;
3586 bHighTextureModeCostEnable = false;
3587
3588 this->pfnGetKernelHeaderAndSize = this->EncodeGetKernelHeaderAndSize;
3589 m_feiEnable = true;
3590
3591 if (m_codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC)
3592 {
3593 m_hmeSupported = true;
3594 m_flatnessCheckSupported = true;
3595 }
3596
3597 m_16xMeSupported = false;
3598 m_32xMeSupported = false;
3599
3600 //FEI output Stats which is a superset of MbStats buffer, so no need for MbStats
3601 m_mbStatsSupported = false;
3602 m_kuid = IDR_CODEC_AllAVCEnc_FEI;
3603 AddIshSize(m_kuid, m_kernelBase);
3604 }
3605
3606 CodechalEncodeAvcEncFeiG8::~CodechalEncodeAvcEncFeiG8()
3607 {
3608 }
3609
3610 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitializePicture(const EncoderParams& params)
3611 {
3612 CODECHAL_ENCODE_FUNCTION_ENTER;
3613 if (m_codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC)
3614 {
3615 return EncodePreEncInitialize(params);
3616 }
3617 else
3618 {
3619 return CodechalEncodeAvcEnc::InitializePicture( params);
3620 }
3621 }
3622
3623 MOS_STATUS CodechalEncodeAvcEncFeiG8::EncodePreEncInitialize(const EncoderParams& params)
3624 {
3625 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3626
3627 CODECHAL_ENCODE_FUNCTION_ENTER;
3628
3629 auto preEncParams = (FeiPreEncParams*)params.pPreEncParams;
3630
3631 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface);
3632 CODECHAL_ENCODE_CHK_NULL_RETURN(preEncParams->psCurrOriginalSurface);
3633
3634 auto avcRefList = &m_refList[0];
3635 auto avcPicIdx = &m_picIdx[0];
3636
3637 CodecHalGetResourceInfo(m_osInterface, preEncParams->psCurrOriginalSurface);
3638 m_rawSurface = *(preEncParams->psCurrOriginalSurface);
3639 m_rawSurfaceToEnc =
3640 m_rawSurfaceToPak = &m_rawSurface;
3641 m_targetUsage = TARGETUSAGE_RT_SPEED;
3642 m_kernelMode = CodecHal_TargetUsageToMode_AVC[m_targetUsage];
3643 m_flatnessCheckEnabled = m_flatnessCheckSupported;
3644
3645 auto prevPic = m_currOriginalPic;
3646 uint8_t prevIdx = prevPic.FrameIdx;
3647 uint8_t currIdx = preEncParams->CurrOriginalPicture.FrameIdx;
3648 bool firstFieldInput = (prevPic.PicFlags == PICTURE_INVALID) && ((preEncParams->CurrOriginalPicture.PicFlags == PICTURE_TOP_FIELD) || (preEncParams->CurrOriginalPicture.PicFlags == PICTURE_BOTTOM_FIELD));
3649
3650 avcRefList[currIdx]->sRefBuffer = avcRefList[currIdx]->sRefRawBuffer = m_rawSurface;
3651 avcRefList[currIdx]->RefPic = m_currOriginalPic;
3652 avcRefList[currIdx]->bUsedAsRef = true;
3653
3654 // FEI PreEnc doesn't have CurrReconstructedPicture, here we set m_currReconstructedPic = pPreEncParams->CurrOriginalPicture
3655 // so it can resue the AVC functions.
3656 m_currOriginalPic = preEncParams->CurrOriginalPicture;
3657 m_currReconstructedPic = preEncParams->CurrOriginalPicture;
3658 m_currRefList = m_refList[m_currOriginalPic.FrameIdx];
3659
3660 uint8_t numRef = 0;
3661 for (uint8_t i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
3662 {
3663 avcPicIdx[i].bValid = false;
3664 }
3665
3666 // FEI only support one past and one future reference picture now
3667 uint8_t index;
3668 if (preEncParams->dwNumPastReferences > 0)
3669 {
3670 CODECHAL_ENCODE_ASSERT(preEncParams->dwNumPastReferences == 1);
3671 CODECHAL_ENCODE_ASSERT(!CodecHal_PictureIsInvalid(preEncParams->PastRefPicture));
3672 index = preEncParams->PastRefPicture.FrameIdx;
3673 avcPicIdx[numRef].bValid = true;
3674 avcPicIdx[numRef].ucPicIdx = index;
3675 avcRefList[index]->RefPic.PicFlags =
3676 CodecHal_CombinePictureFlags(avcRefList[index]->RefPic, preEncParams->PastRefPicture);
3677 avcRefList[currIdx]->RefList[numRef] = preEncParams->PastRefPicture;
3678 numRef++;
3679 }
3680
3681 if (preEncParams->dwNumFutureReferences > 0)
3682 {
3683 CODECHAL_ENCODE_ASSERT(preEncParams->dwNumFutureReferences == 1);
3684 CODECHAL_ENCODE_ASSERT(!CodecHal_PictureIsInvalid(preEncParams->FutureRefPicture))
3685 index = preEncParams->FutureRefPicture.FrameIdx;
3686 avcPicIdx[numRef].bValid = true;
3687 avcPicIdx[numRef].ucPicIdx = index;
3688 avcRefList[index]->RefPic.PicFlags =
3689 CodecHal_CombinePictureFlags(avcRefList[index]->RefPic, preEncParams->FutureRefPicture);
3690 avcRefList[currIdx]->RefList[numRef] = preEncParams->FutureRefPicture;
3691 numRef++;
3692 }
3693 avcRefList[currIdx]->ucNumRef = numRef;
3694
3695 m_verticalLineStride = CODECHAL_VLINESTRIDE_FRAME;
3696 m_verticalLineStrideOffset = CODECHAL_VLINESTRIDEOFFSET_TOP_FIELD;
3697 m_meDistortionBottomFieldOffset = 0;
3698 m_meMvBottomFieldOffset = 0;
3699
3700 if (CodecHal_PictureIsField(m_currOriginalPic))
3701 {
3702 m_frameFieldHeight = ((m_frameHeight + 1) >> 1);
3703 m_frameFieldHeightInMb = ((m_picHeightInMb + 1) >> 1);
3704 m_downscaledFrameFieldHeightInMb4x = ((m_downscaledHeightInMb4x + 1) >> 1);
3705 m_downscaledFrameFieldHeightInMb16x = ((m_downscaledHeightInMb16x + 1) >> 1);
3706 m_downscaledFrameFieldHeightInMb32x = ((m_downscaledHeightInMb32x + 1) >> 1);
3707 if (CodecHal_PictureIsFrame(prevPic) || prevIdx != currIdx || firstFieldInput)
3708 {
3709 m_firstField = 1;
3710 }
3711 else
3712 {
3713 m_firstField = 0;
3714 }
3715
3716 m_verticalLineStride = CODECHAL_VLINESTRIDE_FIELD;
3717 m_frameHeight = m_frameFieldHeightInMb * 2 * 16;
3718 m_picHeightInMb = (uint16_t)(m_frameHeight / 16);
3719 m_mbvProcStatsBottomFieldOffset = 0;
3720
3721 if (CodecHal_PictureIsBottomField(m_currOriginalPic))
3722 {
3723 m_verticalLineStrideOffset = CODECHAL_VLINESTRIDEOFFSET_BOT_FIELD;
3724
3725 m_meDistortionBottomFieldOffset =
3726 MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64) *
3727 MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4 * 10), 8);
3728 m_meMvBottomFieldOffset =
3729 MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 32), 64) *
3730 (m_downscaledFrameFieldHeightInMb4x * 4);
3731 }
3732 }
3733 else
3734 {
3735 m_frameFieldHeight = m_frameHeight;
3736 m_frameFieldHeightInMb = m_picHeightInMb;
3737 m_downscaledFrameFieldHeightInMb4x = m_downscaledHeightInMb4x;
3738 m_downscaledFrameFieldHeightInMb16x = m_downscaledHeightInMb16x;
3739 m_downscaledFrameFieldHeightInMb32x = m_downscaledHeightInMb32x;
3740 m_firstField = 1;
3741 }
3742
3743 if ((preEncParams->bDisableMVOutput == 1) && (preEncParams->bDisableStatisticsOutput == 1))
3744 {
3745 m_hmeEnabled = false;
3746 }
3747 else
3748 {
3749 m_hmeEnabled = (preEncParams->dwNumPastReferences + preEncParams->dwNumFutureReferences) > 0 ? true : false;
3750 }
3751 m_scalingEnabled = m_firstField && preEncParams->bInputUpdated;
3752 m_useRawForRef = m_userFlags.bUseRawPicForRef;
3753
3754 m_scalingEnabled = (m_hmeSupported || bBrcEnabled) && m_firstField;
3755
3756 // PREENC doesn't differentiate picture by its "PictureCodingType". However in order to reuse the CODECHAL function,
3757 // we manually assign the PictureCodingType given its past/future references.
3758 if (preEncParams->dwNumFutureReferences > 0)
3759 {
3760 m_pictureCodingType = B_TYPE;
3761 }
3762 else if (preEncParams->dwNumPastReferences > 0)
3763 {
3764 m_pictureCodingType = P_TYPE;
3765 }
3766 else
3767 {
3768 m_pictureCodingType = I_TYPE;
3769 }
3770
3771 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetStatusReportParams(
3772 m_refList[m_currOriginalPic.FrameIdx]));
3773
3774 CODECHAL_DEBUG_TOOL(
3775 m_debugInterface->m_currPic = m_currOriginalPic;
3776 m_debugInterface->m_bufferDumpFrameNum = m_storeData;
3777 m_debugInterface->m_frameType = m_pictureCodingType;)
3778
3779 return eStatus;
3780 }
3781
3782 MOS_STATUS CodechalEncodeAvcEncFeiG8::ExecuteKernelFunctions()
3783 {
3784 if (m_codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC)
3785 {
3786 return EncodePreEncKernelFunctions();
3787 }
3788 else
3789 {
3790 return CodechalEncodeAvcEncG8::ExecuteKernelFunctions();
3791 }
3792 }
3793
3794 MOS_STATUS CodechalEncodeAvcEncFeiG8::EncodePreEncKernelFunctions()
3795 {
3796 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3797
3798 CODECHAL_ENCODE_FUNCTION_ENTER;
3799
3800 auto preEncParams = (FeiPreEncParams*)m_encodeParams.pPreEncParams;
3801 auto avcRefList = &m_refList[0];
3802
3803 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
3804 m_rawSurfaceToEnc,
3805 CodechalDbgAttr::attrEncodeRawInputSurface,
3806 "SrcSurf"))
3807 );
3808
3809 // save these 2 flags
3810 auto firstField = m_firstField;
3811 auto currRefList = m_currRefList;
3812
3813 // Scaling, HME and PreProc are included in the same task phase
3814 m_lastEncPhase = true;
3815 m_firstTaskInPhase = true;
3816
3817 UpdateSSDSliceCount();
3818
3819 m_trackedBuf->ResetUsedForCurrFrame();
3820
3821 bool dsSurfaceInCache;
3822 uint8_t scaledIdx = m_trackedBuf->PreencLookUpBufIndex(m_currOriginalPic.FrameIdx, &dsSurfaceInCache);
3823 m_trackedBuf->AllocateForCurrFramePreenc(scaledIdx);
3824 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_trackedBuf->AllocateSurfaceDS());
3825
3826 bool dsPastRefInCache = false;
3827 bool callDsPastRef = false;
3828 uint8_t pastRefScaledIdx = 0;
3829 if (preEncParams->dwNumPastReferences > 0)
3830 {
3831 pastRefScaledIdx = m_trackedBuf->PreencLookUpBufIndex(preEncParams->PastRefPicture.FrameIdx, &dsPastRefInCache);
3832 if ((!preEncParams->bPastRefUpdated) && dsPastRefInCache)
3833 {
3834 CODECHAL_ENCODE_VERBOSEMESSAGE("find PastRef Downscaled Surface in cache, so skip DS");
3835 }
3836 else
3837 {
3838 callDsPastRef = true;
3839 }
3840 }
3841
3842 bool dsFutureRefInCache = false;
3843 bool callDsFutureRef = false;
3844 uint8_t futureRefScaledIdx = 0;
3845 if (preEncParams->dwNumFutureReferences > 0)
3846 {
3847 futureRefScaledIdx = m_trackedBuf->PreencLookUpBufIndex(preEncParams->FutureRefPicture.FrameIdx, &dsFutureRefInCache);
3848 if ((!preEncParams->bFutureRefUpdated) && dsFutureRefInCache)
3849 {
3850 CODECHAL_ENCODE_VERBOSEMESSAGE("find FutureRef Downscaled Surface in cache, so skip DS");
3851 }
3852 else
3853 {
3854 callDsFutureRef = true;
3855 }
3856 }
3857
3858 bool callPreEncKernel = (preEncParams->bDisableMVOutput == 0) || (preEncParams->bDisableStatisticsOutput == 0);
3859
3860 CodechalEncodeCscDs::KernelParams cscScalingKernelParams;
3861 if ((!preEncParams->bCurPicUpdated) && dsSurfaceInCache)
3862 {
3863 CODECHAL_ENCODE_VERBOSEMESSAGE("find Downscaled Surface in cache, so skip DS");
3864 }
3865 else
3866 {
3867 if (!preEncParams->bCurPicUpdated)
3868 {
3869 CODECHAL_ENCODE_VERBOSEMESSAGE("Cannot find matched Downscaled Surface, DS again");
3870 }
3871 if (scaledIdx == CODEC_NUM_TRACKED_BUFFERS)
3872 {
3873 CODECHAL_ENCODE_ASSERTMESSAGE("Cannot find empty DS slot for preenc.");
3874 eStatus = MOS_STATUS_INVALID_PARAMETER;
3875 return eStatus;
3876 }
3877
3878 m_firstField = preEncParams->bCurPicUpdated ? 1 : m_firstField;
3879 m_currRefList->ucScalingIdx = scaledIdx;
3880 m_currRefList->b4xScalingUsed = false;
3881 m_currRefList->b16xScalingUsed = false;
3882 m_currRefList->b32xScalingUsed = false;
3883
3884 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
3885 cscScalingKernelParams.bLastTaskInPhase4xDS = !(callDsPastRef || callDsFutureRef || m_hmeEnabled || callPreEncKernel);
3886 cscScalingKernelParams.b32xScalingInUse = false;
3887 cscScalingKernelParams.b16xScalingInUse = false;
3888 cscScalingKernelParams.bLastTaskInPhase4xDS = !m_hmeEnabled;
3889 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->DsKernel(&cscScalingKernelParams));
3890
3891 }
3892
3893 // Scaling for Past ref
3894 if (callDsPastRef)
3895 {
3896 if (!preEncParams->bPastRefUpdated)
3897 {
3898 CODECHAL_ENCODE_VERBOSEMESSAGE("Cannot find matched Downscaled Surface, DS again");
3899 }
3900 if (pastRefScaledIdx == CODEC_NUM_TRACKED_BUFFERS)
3901 {
3902 CODECHAL_ENCODE_ASSERTMESSAGE("Cannot find empty DS slot for preenc.");
3903 eStatus = MOS_STATUS_INVALID_PARAMETER;
3904 return eStatus;
3905 }
3906
3907 uint8_t pastRefIdx = preEncParams->PastRefPicture.FrameIdx;
3908 avcRefList[pastRefIdx]->sRefBuffer = avcRefList[pastRefIdx]->sRefRawBuffer = preEncParams->sPastRefSurface;
3909 avcRefList[pastRefIdx]->RefPic = preEncParams->PastRefPicture;
3910 avcRefList[pastRefIdx]->bUsedAsRef = true;
3911 m_firstField = true;
3912 m_currRefList = avcRefList[pastRefIdx];
3913 m_currRefList->ucScalingIdx = pastRefScaledIdx;
3914 m_currRefList->b4xScalingUsed = false;
3915 m_currRefList->b16xScalingUsed = false;
3916 m_currRefList->b32xScalingUsed = false;
3917
3918 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
3919 cscScalingKernelParams.bLastTaskInPhase4xDS = !(callDsFutureRef || m_hmeEnabled || callPreEncKernel);
3920 cscScalingKernelParams.b32xScalingInUse = false;
3921 cscScalingKernelParams.b16xScalingInUse = false;
3922 cscScalingKernelParams.bRawInputProvided = true;
3923 cscScalingKernelParams.bScalingforRef = true;
3924 cscScalingKernelParams.sInputRawSurface = preEncParams->sPastRefSurface;
3925 cscScalingKernelParams.inputPicture = preEncParams->PastRefPicture;
3926
3927 if (preEncParams->bPastRefStatsNeeded)
3928 {
3929 cscScalingKernelParams.sInputStatsBuffer = preEncParams->sPastRefStatsBuffer;
3930 if (CodecHal_PictureIsField(m_currOriginalPic))
3931 {
3932 cscScalingKernelParams.sInputStatsBotFieldBuffer = preEncParams->sPastRefStatsBotFieldBuffer;
3933 }
3934 cscScalingKernelParams.bStatsInputProvided = true;
3935 }
3936 m_trackedBuf->AllocateForCurrFramePreenc(pastRefScaledIdx);
3937 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->DsKernel(&cscScalingKernelParams));
3938 }
3939
3940 // Scaling for Future ref
3941 if (callDsFutureRef)
3942 {
3943 if (!preEncParams->bFutureRefUpdated)
3944 {
3945 CODECHAL_ENCODE_VERBOSEMESSAGE("Cannot find matched Downscaled Surface, DS again");
3946 }
3947 if (futureRefScaledIdx == CODEC_NUM_TRACKED_BUFFERS)
3948 {
3949 CODECHAL_ENCODE_ASSERTMESSAGE("Cannot find empty DS slot for preenc.");
3950 eStatus = MOS_STATUS_INVALID_PARAMETER;
3951 return eStatus;
3952 }
3953
3954 uint8_t futureRefIdx = preEncParams->FutureRefPicture.FrameIdx;
3955 avcRefList[futureRefIdx]->sRefBuffer = avcRefList[futureRefIdx]->sRefRawBuffer = preEncParams->sFutureRefSurface;
3956 avcRefList[futureRefIdx]->RefPic = preEncParams->FutureRefPicture;
3957 avcRefList[futureRefIdx]->bUsedAsRef = true;
3958 m_firstField = true;
3959 m_currRefList = avcRefList[futureRefIdx];
3960 m_currRefList->ucScalingIdx = futureRefScaledIdx;
3961 m_currRefList->b4xScalingUsed = false;
3962 m_currRefList->b16xScalingUsed = false;
3963 m_currRefList->b32xScalingUsed = false;
3964
3965 m_lastTaskInPhase = false;
3966 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
3967 cscScalingKernelParams.bLastTaskInPhase4xDS = !(m_hmeEnabled || callPreEncKernel);
3968 cscScalingKernelParams.b32xScalingInUse = false;
3969 cscScalingKernelParams.b16xScalingInUse = false;
3970 cscScalingKernelParams.bRawInputProvided = true;
3971 cscScalingKernelParams.bScalingforRef = true;
3972 cscScalingKernelParams.sInputRawSurface = preEncParams->sFutureRefSurface;
3973 cscScalingKernelParams.inputPicture = preEncParams->FutureRefPicture;
3974
3975 if (preEncParams->bFutureRefStatsNeeded)
3976 {
3977 cscScalingKernelParams.sInputStatsBuffer = preEncParams->sFutureRefStatsBuffer;
3978 if (CodecHal_PictureIsField(m_currOriginalPic))
3979 {
3980 cscScalingKernelParams.sInputStatsBotFieldBuffer = preEncParams->sFutureRefStatsBotFieldBuffer;
3981 }
3982 cscScalingKernelParams.bStatsInputProvided = true;
3983 }
3984 m_trackedBuf->AllocateForCurrFramePreenc(futureRefScaledIdx);
3985 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->DsKernel(&cscScalingKernelParams));
3986 }
3987
3988 m_firstField = firstField;
3989 m_currRefList = currRefList;
3990
3991 if (m_hmeEnabled)
3992 {
3993 CODEC_AVC_ENCODE_SLICE_PARAMS avcSliceParams;
3994
3995 memset(&avcSliceParams, 0, sizeof(CODEC_AVC_ENCODE_SLICE_PARAMS));
3996 if (preEncParams->dwNumPastReferences > 0)
3997 {
3998 avcSliceParams.num_ref_idx_l0_active_minus1 = 0;
3999 avcSliceParams.RefPicList[LIST_0][0] = preEncParams->PastRefPicture;
4000 avcSliceParams.RefPicList[LIST_0][0].FrameIdx = 0;
4001 }
4002 else
4003 {
4004 avcSliceParams.RefPicList[LIST_0][0].PicFlags = PICTURE_INVALID;
4005 }
4006
4007 if (preEncParams->dwNumFutureReferences > 0)
4008 {
4009 avcSliceParams.num_ref_idx_l1_active_minus1 = 0;
4010 avcSliceParams.RefPicList[LIST_1][0] = preEncParams->FutureRefPicture;
4011 avcSliceParams.RefPicList[LIST_1][0].FrameIdx = (preEncParams->dwNumPastReferences > 0) ? 1 : 0;
4012 }
4013 else
4014 {
4015 avcSliceParams.RefPicList[LIST_1][0].PicFlags = PICTURE_INVALID;
4016 }
4017
4018 m_avcSliceParams = &avcSliceParams;
4019 m_lastTaskInPhase = !callPreEncKernel;
4020 CODECHAL_ENCODE_CHK_STATUS_RETURN(GenericEncodeMeKernel(&BrcBuffers, HME_LEVEL_4x));
4021
4022 }
4023
4024 m_lastTaskInPhase = true;
4025 if (callPreEncKernel)
4026 {
4027 // Execute the PreEnc kernel only when MV and/or Statistics output required.
4028 // Especially for I frame case, if user disables the statistics output, the PreEnc can be skipped
4029 CODECHAL_ENCODE_CHK_STATUS_RETURN(PreProcKernel());
4030 if(preEncParams->bMBQp){
4031 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4032 &preEncParams->resMbQpBuffer,
4033 CodechalDbgAttr::attrInput,
4034 "MbQp",
4035 m_picWidthInMb * m_frameFieldHeightInMb,
4036 0,
4037 CODECHAL_MEDIA_STATE_PREPROC)));
4038 }
4039 if(preEncParams->dwMVPredictorCtrl){
4040 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4041 &preEncParams->resMvPredBuffer,
4042 CodechalDbgAttr::attrInput,
4043 "MvPredictor",
4044 m_picWidthInMb * m_frameFieldHeightInMb * 8,
4045 0,
4046 CODECHAL_MEDIA_STATE_PREPROC)));
4047 }
4048
4049 }
4050 // Reset buffer ID used for MbEnc kernel performance reports
4051 m_osInterface->pfnResetPerfBufferID(m_osInterface);
4052
4053 m_setRequestedEUSlices = false;
4054
4055 return eStatus;
4056 }
4057
4058 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitKernelStateMe()
4059 {
4060 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4061
4062 CODECHAL_ENCODE_FUNCTION_ENTER;
4063
4064 uint8_t* kernelBinary;
4065 uint32_t kernelSize;
4066
4067 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(m_kernelBase, m_kuid, &kernelBinary, &kernelSize));
4068
4069 for (uint32_t krnStateIdx = 0; krnStateIdx < 2; krnStateIdx++)
4070 {
4071 auto kernelStatePtr = &m_meKernelStates[krnStateIdx];
4072 CODECHAL_KERNEL_HEADER currKrnHeader;
4073
4074 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeGetKernelHeaderAndSize(
4075 kernelBinary,
4076 ENC_ME,
4077 krnStateIdx,
4078 &currKrnHeader,
4079 &kernelSize));
4080
4081 kernelStatePtr->KernelParams.iBTCount = ME_NUM_SURFACES_CM;
4082 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
4083 kernelStatePtr->KernelParams.iCurbeLength = sizeof(ME_CURBE_CM_FEI);
4084 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
4085 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
4086 kernelStatePtr->KernelParams.iIdCount = 1;
4087
4088 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
4089 kernelStatePtr->KernelParams.pBinary = kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
4090 kernelStatePtr->KernelParams.iSize = kernelSize;
4091 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
4092 m_stateHeapInterface,
4093 kernelStatePtr->KernelParams.iBTCount,
4094 &kernelStatePtr->dwSshSize,
4095 &kernelStatePtr->dwBindingTableSize));
4096
4097 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
4098 }
4099
4100 // Until a better way can be found, maintain old binding table structures
4101 auto bindingTable = &m_meBindingTable;
4102 bindingTable->dwMEMVDataSurface = ME_MV_DATA_SURFACE_CM;
4103 bindingTable->dw16xMEMVDataSurface = ME_16x_MV_DATA_SURFACE_CM;
4104 bindingTable->dw32xMEMVDataSurface = ME_32x_MV_DATA_SURFACE_CM;
4105 bindingTable->dwMEDist = ME_DISTORTION_SURFACE_CM;
4106 bindingTable->dwMEBRCDist = ME_BRC_DISTORTION_CM;
4107 bindingTable->dwMECurrForFwdRef = ME_CURR_FOR_FWD_REF_CM;
4108 bindingTable->dwMEFwdRefPicIdx[0] = ME_FWD_REF_IDX0_CM;
4109 bindingTable->dwMEFwdRefPicIdx[1] = ME_FWD_REF_IDX1_CM;
4110 bindingTable->dwMEFwdRefPicIdx[2] = ME_FWD_REF_IDX2_CM;
4111 bindingTable->dwMEFwdRefPicIdx[3] = ME_FWD_REF_IDX3_CM;
4112 bindingTable->dwMEFwdRefPicIdx[4] = ME_FWD_REF_IDX4_CM;
4113 bindingTable->dwMEFwdRefPicIdx[5] = ME_FWD_REF_IDX5_CM;
4114 bindingTable->dwMEFwdRefPicIdx[6] = ME_FWD_REF_IDX6_CM;
4115 bindingTable->dwMEFwdRefPicIdx[7] = ME_FWD_REF_IDX7_CM;
4116 bindingTable->dwMECurrForBwdRef = ME_CURR_FOR_BWD_REF_CM;
4117 bindingTable->dwMEBwdRefPicIdx[0] = ME_BWD_REF_IDX0_CM;
4118 bindingTable->dwMEBwdRefPicIdx[1] = ME_BWD_REF_IDX1_CM;
4119 return eStatus;
4120 }
4121
4122 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitKernelStateMbEnc()
4123 {
4124 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4125 CODECHAL_ENCODE_FUNCTION_ENTER;
4126 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetRenderInterface()->GetHwCaps());
4127
4128 uint32_t numMbEncKrnStates =
4129 MBENC_TARGET_USAGE_CM * m_mbencNumTargetUsagesCmFei;
4130 pMbEncKernelStates =
4131 MOS_NewArray(MHW_KERNEL_STATE, numMbEncKrnStates);
4132 CODECHAL_ENCODE_CHK_NULL_RETURN(pMbEncKernelStates);
4133
4134 auto kernelStatePtr = pMbEncKernelStates;
4135 uint8_t* kernelBinary;
4136 uint32_t kernelSize;
4137
4138 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(m_kernelBase, m_kuid, &kernelBinary, &kernelSize));
4139
4140 for (uint32_t krnStateIdx = 0; krnStateIdx < numMbEncKrnStates; krnStateIdx++)
4141 {
4142 bool kernelState = (krnStateIdx >= MBENC_TARGET_USAGE_CM);
4143
4144 CODECHAL_KERNEL_HEADER currKrnHeader;
4145 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
4146 kernelBinary,
4147 (kernelState ? ENC_MBENC_ADV : ENC_MBENC),
4148 (kernelState ? krnStateIdx - MBENC_TARGET_USAGE_CM : krnStateIdx),
4149 &currKrnHeader,
4150 &kernelSize));
4151
4152 kernelStatePtr->KernelParams.iBTCount = MBENC_NUM_SURFACES_CM;
4153 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
4154 kernelStatePtr->KernelParams.iCurbeLength = sizeof(MBENC_CURBE_CM_FEI);
4155 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
4156 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
4157 kernelStatePtr->KernelParams.iIdCount = 1;
4158
4159 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface);
4160 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
4161 kernelStatePtr->KernelParams.pBinary = kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
4162 kernelStatePtr->KernelParams.iSize = kernelSize;
4163
4164 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
4165 m_stateHeapInterface,
4166 kernelStatePtr->KernelParams.iBTCount,
4167 &kernelStatePtr->dwSshSize,
4168 &kernelStatePtr->dwBindingTableSize));
4169
4170 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
4171
4172 kernelStatePtr++;
4173 }
4174
4175 // Until a better way can be found, maintain old binding table structures
4176 auto bindingTable = &MbEncBindingTable;
4177
4178 bindingTable->dwAvcMBEncMfcAvcPakObj = MBENC_MFC_AVC_PAK_OBJ_CM_FEI;
4179 bindingTable->dwAvcMBEncIndMVData = MBENC_IND_MV_DATA_CM_FEI;
4180 bindingTable->dwAvcMBEncBRCDist = MBENC_BRC_DISTORTION_CM_FEI;
4181 bindingTable->dwAvcMBEncCurrY = MBENC_CURR_Y_CM_FEI;
4182 bindingTable->dwAvcMBEncCurrUV = MBENC_CURR_UV_CM_FEI;
4183 bindingTable->dwAvcMBEncMbSpecificData = MBENC_MB_SPECIFIC_DATA_CM_FEI;
4184 bindingTable->dwAvcMBEncRefPicSelectL0 = MBENC_REFPICSELECT_L0_CM_FEI;
4185 bindingTable->dwAvcMBEncMVDataFromME = MBENC_MV_DATA_FROM_ME_CM_FEI;
4186 bindingTable->dwAvcMBEncMEDist = MBENC_4xME_DISTORTION_CM_FEI;
4187 bindingTable->dwAvcMBEncRefPicSelectL1 = MBENC_REFPICSELECT_L1_CM_FEI;
4188 bindingTable->dwAvcMBEncBwdRefMBData = MBENC_FWD_MB_DATA_CM_FEI;
4189 bindingTable->dwAvcMBEncBwdRefMVData = MBENC_FWD_MV_DATA_CM_FEI;
4190 bindingTable->dwAvcMBEncMbBrcConstData = MBENC_MBBRC_CONST_DATA_CM_FEI;
4191 bindingTable->dwAvcMBEncFlatnessChk = MBENC_FLATNESS_CHECK_CM_FEI;
4192 bindingTable->dwAvcMBEncMADData = MBENC_MAD_DATA_CM_FEI;
4193 bindingTable->dwAvcMBEncVMEDistortion = MBENC_INTER_DISTORTION_CM_FEI;
4194 bindingTable->dwAvcMbEncBRCCurbeData = MBENC_BRC_CURBE_DATA_CM_FEI;
4195 bindingTable->dwAvcMBEncMvPrediction = MBENC_MV_PREDICTOR_CM_FEI;
4196
4197 // Frame
4198 bindingTable->dwAvcMBEncMbQpFrame = MBENC_MBQP_CM;
4199 bindingTable->dwAvcMBEncCurrPicFrame[0] = MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_CM;
4200 bindingTable->dwAvcMBEncFwdPicFrame[0] = MBENC_VME_INTER_PRED_FWD_PIC_IDX0_CM;
4201 bindingTable->dwAvcMBEncBwdPicFrame[0] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_0_CM;
4202 bindingTable->dwAvcMBEncFwdPicFrame[1] = MBENC_VME_INTER_PRED_FWD_PIC_IDX1_CM;
4203 bindingTable->dwAvcMBEncBwdPicFrame[1] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_0_CM;
4204 bindingTable->dwAvcMBEncFwdPicFrame[2] = MBENC_VME_INTER_PRED_FWD_PIC_IDX2_CM;
4205 bindingTable->dwAvcMBEncFwdPicFrame[3] = MBENC_VME_INTER_PRED_FWD_PIC_IDX3_CM;
4206 bindingTable->dwAvcMBEncFwdPicFrame[4] = MBENC_VME_INTER_PRED_FWD_PIC_IDX4_CM;
4207 bindingTable->dwAvcMBEncFwdPicFrame[5] = MBENC_VME_INTER_PRED_FWD_PIC_IDX5_CM;
4208 bindingTable->dwAvcMBEncFwdPicFrame[6] = MBENC_VME_INTER_PRED_FWD_PIC_IDX6_CM;
4209 bindingTable->dwAvcMBEncFwdPicFrame[7] = MBENC_VME_INTER_PRED_FWD_PIC_IDX7_CM;
4210 bindingTable->dwAvcMBEncCurrPicFrame[1] = MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_CM;
4211 bindingTable->dwAvcMBEncBwdPicFrame[2] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_1_CM;
4212 bindingTable->dwAvcMBEncBwdPicFrame[3] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_1_CM;
4213
4214 // Field
4215 bindingTable->dwAvcMBEncMbQpField = MBENC_MBQP_CM;
4216 bindingTable->dwAvcMBEncFieldCurrPic[0] = MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_CM;
4217 bindingTable->dwAvcMBEncFwdPicTopField[0] = MBENC_VME_INTER_PRED_FWD_PIC_IDX0_CM;
4218 bindingTable->dwAvcMBEncBwdPicTopField[0] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_0_CM;
4219 bindingTable->dwAvcMBEncFwdPicBotField[0] = MBENC_VME_INTER_PRED_FWD_PIC_IDX0_CM;
4220 bindingTable->dwAvcMBEncBwdPicBotField[0] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_0_CM;
4221 bindingTable->dwAvcMBEncFwdPicTopField[1] = MBENC_VME_INTER_PRED_FWD_PIC_IDX1_CM;
4222 bindingTable->dwAvcMBEncBwdPicTopField[1] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_0_CM;
4223 bindingTable->dwAvcMBEncFwdPicBotField[1] = MBENC_VME_INTER_PRED_FWD_PIC_IDX1_CM;
4224 bindingTable->dwAvcMBEncBwdPicBotField[1] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_0_CM;
4225 bindingTable->dwAvcMBEncFwdPicTopField[2] = MBENC_VME_INTER_PRED_FWD_PIC_IDX2_CM;
4226 bindingTable->dwAvcMBEncFwdPicBotField[2] = MBENC_VME_INTER_PRED_FWD_PIC_IDX2_CM;
4227 bindingTable->dwAvcMBEncFwdPicTopField[3] = MBENC_VME_INTER_PRED_FWD_PIC_IDX3_CM;
4228 bindingTable->dwAvcMBEncFwdPicBotField[3] = MBENC_VME_INTER_PRED_FWD_PIC_IDX3_CM;
4229 bindingTable->dwAvcMBEncFieldCurrPic[1] = MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_CM;
4230 bindingTable->dwAvcMBEncBwdPicTopField[2] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_1_CM;
4231 bindingTable->dwAvcMBEncBwdPicBotField[2] = MBENC_VME_INTER_PRED_BWD_PIC_IDX0_1_CM;
4232 bindingTable->dwAvcMBEncBwdPicTopField[3] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_1_CM;
4233 bindingTable->dwAvcMBEncBwdPicBotField[3] = MBENC_VME_INTER_PRED_BWD_PIC_IDX1_1_CM;
4234 return eStatus;
4235 }
4236
4237 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitKernelStatePreProc()
4238 {
4239 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4240
4241 CODECHAL_ENCODE_FUNCTION_ENTER;
4242
4243 auto kernelStatePtr = &PreProcKernelState;
4244
4245 uint8_t* kernelBinary;
4246 uint32_t kernelSize;
4247
4248 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(m_kernelBase, m_kuid, &kernelBinary, &kernelSize));
4249
4250 uint32_t krnStateIdx = 0;
4251 CODECHAL_KERNEL_HEADER currKrnHeader;
4252 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeGetKernelHeaderAndSize(
4253 kernelBinary,
4254 ENC_PREPROC,
4255 krnStateIdx,
4256 &currKrnHeader,
4257 &kernelSize));
4258
4259 kernelStatePtr->KernelParams.iBTCount = CODECHAL_ENCODE_AVC_PREPROC_FIELD_NUM_SURFACES_CM_G8;
4260 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
4261 kernelStatePtr->KernelParams.iCurbeLength = sizeof(PREPROC_CURBE_CM);
4262 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
4263 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
4264 kernelStatePtr->KernelParams.iIdCount = 1;
4265
4266 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
4267 kernelStatePtr->KernelParams.pBinary = kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
4268 kernelStatePtr->KernelParams.iSize = kernelSize;
4269
4270 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
4271 m_stateHeapInterface,
4272 kernelStatePtr->KernelParams.iBTCount,
4273 &kernelStatePtr->dwSshSize,
4274 &kernelStatePtr->dwBindingTableSize));
4275
4276 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
4277
4278 // Until a better way can be found, maintain old binding table structures
4279 auto bindingTable = &PreProcBindingTable;
4280
4281 bindingTable->dwAvcPreProcCurrY = CODECHAL_ENCODE_AVC_PREPROC_CURR_Y_CM_G8;
4282 bindingTable->dwAvcPreProcCurrUV = CODECHAL_ENCODE_AVC_PREPROC_CURR_UV_CM_G8;
4283 bindingTable->dwAvcPreProcMVDataFromHME = CODECHAL_ENCODE_AVC_PREPROC_HME_MV_DATA_CM_G8;
4284 bindingTable->dwAvcPreProcMvPredictor = CODECHAL_ENCODE_AVC_PREPROC_MV_PREDICTOR_CM_G8;
4285 bindingTable->dwAvcPreProcMbQp = CODECHAL_ENCODE_AVC_PREPROC_MBQP_CM_G8;
4286 bindingTable->dwAvcPreProcMvDataOut = CODECHAL_ENCODE_AVC_PREPROC_MV_DATA_CM_G8;
4287 bindingTable->dwAvcPreProcMbStatsOut = CODECHAL_ENCODE_AVC_PREPROC_MB_STATS_CM_G8;
4288 bindingTable->dwAvcPreProcVMECurrPicFrame[0] = CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_0_CM_G8;
4289 bindingTable->dwAvcPreProcVMEFwdPicFrame = CODECHAL_ENCODE_AVC_PREPROC_VME_FWD_PIC_IDX0_CM_G8;
4290 bindingTable->dwAvcPreProcVMEBwdPicFrame[0] = CODECHAL_ENCODE_AVC_PREPROC_VME_BWD_PIC_IDX0_0_CM_G8;
4291 bindingTable->dwAvcPreProcVMECurrPicFrame[1] = CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_1_CM_G8;
4292 bindingTable->dwAvcPreProcVMEBwdPicFrame[1] = CODECHAL_ENCODE_AVC_PREPROC_VME_BWD_PIC_IDX0_1_CM_G8;
4293 bindingTable->dwAvcPreProcFtqLut = CODECHAL_ENCODE_AVC_PREPROC_FTQ_LUT_CM_G8;
4294
4295 //field case
4296 bindingTable->dwAvcPreProcVMECurrPicField[0] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_0_CM_G8;
4297 bindingTable->dwAvcPreProcVMEFwdPicField[0] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_FWD_PIC_IDX0_0_CM_G8;
4298
4299 bindingTable->dwAvcPreProcVMEFwdPicField[1] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_FWD_PIC_IDX0_1_CM_G8;
4300
4301 bindingTable->dwAvcPreProcVMECurrPicField[1] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_1_CM_G8;
4302 bindingTable->dwAvcPreProcVMEBwdPicField[0] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_BWD_PIC_IDX0_0_CM_G8;
4303
4304 bindingTable->dwAvcPreProcVMEBwdPicField[1] = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_BWD_PIC_IDX0_1_CM_G8;
4305
4306 bindingTable->dwAvcPreProcFtqLutField = CODECHAL_ENCODE_AVC_PREPROC_FIELD_FTQ_LUT_CM_G8;
4307
4308 return eStatus;
4309 }
4310
4311 MOS_STATUS CodechalEncodeAvcEncFeiG8::SendAvcMbEncSurfaces(PMOS_COMMAND_BUFFER cmdBuffer, PCODECHAL_ENCODE_AVC_MBENC_SURFACE_PARAMS params)
4312 {
4313 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4314 CODECHAL_ENCODE_FUNCTION_ENTER;
4315
4316 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
4317 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pAvcSlcParams);
4318 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ppRefList);
4319 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pCurrOriginalPic);
4320 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pCurrReconstructedPic);
4321 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psCurrPicSurface);
4322
4323 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pMbEncBindingTable);
4324 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
4325 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pFeiPicParams);
4326
4327 auto kernelState = params->pKernelState;
4328
4329 auto feiPicParams = (CodecEncodeAvcFeiPicParams *)params->pFeiPicParams;
4330 auto avcMbEncBindingTable = params->pMbEncBindingTable;
4331
4332 bool currFieldPicture = CodecHal_PictureIsField(*(params->pCurrOriginalPic)) ? 1 : 0;
4333 bool currBottomField = CodecHal_PictureIsBottomField(*(params->pCurrOriginalPic)) ? 1 : 0;
4334 auto currPicRefListEntry = params->ppRefList[params->pCurrReconstructedPic->FrameIdx];
4335 auto mbCodeBuffer = &currPicRefListEntry->resRefMbCodeBuffer;
4336 auto mvDataBuffer = &currPicRefListEntry->resRefMvDataBuffer;
4337 uint32_t refMbCodeBottomFieldOffset;
4338 uint32_t refMvBottomFieldOffset;
4339 if (feiPicParams->MbCodeMvEnable)
4340 {
4341 refMbCodeBottomFieldOffset = 0;
4342 refMvBottomFieldOffset = 0;
4343 }
4344 else
4345 {
4346 refMbCodeBottomFieldOffset =
4347 params->dwFrameFieldHeightInMb * params->dwFrameWidthInMb * 64;
4348 refMvBottomFieldOffset =
4349 MOS_ALIGN_CEIL(params->dwFrameFieldHeightInMb * params->dwFrameWidthInMb * (32 * 4), 0x1000);
4350 }
4351 uint8_t vDirection;
4352 if (params->bMbEncIFrameDistInUse)
4353 {
4354 vDirection = CODECHAL_VDIRECTION_FRAME;
4355 }
4356 else
4357 {
4358 vDirection = (CodecHal_PictureIsFrame(*(params->pCurrOriginalPic))) ? CODECHAL_VDIRECTION_FRAME :
4359 (currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD;
4360 }
4361
4362 // PAK Obj command buffer
4363 uint32_t size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 16 * 4; // 11DW + 5DW padding
4364 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
4365 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4366 surfaceCodecParams.presBuffer = mbCodeBuffer;
4367 surfaceCodecParams.dwSize = size;
4368 surfaceCodecParams.dwOffset = params->dwMbCodeBottomFieldOffset;
4369 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMfcAvcPakObj;
4370 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PAK_OBJECT_ENCODE].Value;
4371 surfaceCodecParams.bRenderTarget = true;
4372 surfaceCodecParams.bIsWritable = true;
4373 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4374 m_hwInterface,
4375 cmdBuffer,
4376 &surfaceCodecParams,
4377 kernelState));
4378
4379 // MV data buffer
4380 size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 32 * 4;
4381 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4382 surfaceCodecParams.presBuffer = mvDataBuffer;
4383 surfaceCodecParams.dwSize = size;
4384 surfaceCodecParams.dwOffset = params->dwMvBottomFieldOffset;
4385 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
4386 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncIndMVData;
4387 surfaceCodecParams.bRenderTarget = true;
4388 surfaceCodecParams.bIsWritable = true;
4389 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4390 m_hwInterface,
4391 cmdBuffer,
4392 &surfaceCodecParams,
4393 kernelState));
4394
4395 // Current Picture Y
4396 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4397 surfaceCodecParams.bIs2DSurface = true;
4398 surfaceCodecParams.bUseUVPlane = true;
4399 surfaceCodecParams.psSurface = params->psCurrPicSurface;
4400 surfaceCodecParams.dwOffset = params->dwCurrPicSurfaceOffset;
4401 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
4402 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncCurrY;
4403 surfaceCodecParams.dwUVBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncCurrUV;
4404 surfaceCodecParams.dwVerticalLineStride = params->dwVerticalLineStride;
4405 surfaceCodecParams.dwVerticalLineStrideOffset = params->dwVerticalLineStrideOffset;
4406 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4407 m_hwInterface,
4408 cmdBuffer,
4409 &surfaceCodecParams,
4410 kernelState));
4411
4412 // AVC_ME MV data buffer
4413 if (params->bHmeEnabled)
4414 {
4415 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps4xMeMvDataBuffer);
4416
4417 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4418 surfaceCodecParams.bIs2DSurface = true;
4419 surfaceCodecParams.bMediaBlockRW = true;
4420 surfaceCodecParams.psSurface = params->ps4xMeMvDataBuffer;
4421 surfaceCodecParams.dwOffset = params->dwMeMvBottomFieldOffset;
4422 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
4423 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMVDataFromME;
4424 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4425 m_hwInterface,
4426 cmdBuffer,
4427 &surfaceCodecParams,
4428 kernelState));
4429
4430 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps4xMeDistortionBuffer);
4431
4432 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4433 surfaceCodecParams.bIs2DSurface = true;
4434 surfaceCodecParams.bMediaBlockRW = true;
4435 surfaceCodecParams.psSurface = params->ps4xMeDistortionBuffer;
4436 surfaceCodecParams.dwOffset = params->dwMeDistortionBottomFieldOffset;
4437 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
4438 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMEDist;
4439 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4440 m_hwInterface,
4441 cmdBuffer,
4442 &surfaceCodecParams,
4443 kernelState));
4444 }
4445
4446 // Current Picture Y - VME
4447 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4448 surfaceCodecParams.bUseAdvState = true;
4449 surfaceCodecParams.psSurface = params->psCurrPicSurface;
4450 surfaceCodecParams.dwOffset = params->dwCurrPicSurfaceOffset;
4451 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
4452 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ?
4453 avcMbEncBindingTable->dwAvcMBEncFieldCurrPic[0] : avcMbEncBindingTable->dwAvcMBEncCurrPicFrame[0];
4454 surfaceCodecParams.ucVDirection = vDirection;
4455 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4456 m_hwInterface,
4457 cmdBuffer,
4458 &surfaceCodecParams,
4459 kernelState));
4460
4461 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ?
4462 avcMbEncBindingTable->dwAvcMBEncFieldCurrPic[1] : avcMbEncBindingTable->dwAvcMBEncCurrPicFrame[1];
4463 surfaceCodecParams.ucVDirection = vDirection;
4464 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4465 m_hwInterface,
4466 cmdBuffer,
4467 &surfaceCodecParams,
4468 kernelState));
4469
4470 // Setup references 1...n
4471 // LIST 0 references
4472 for (uint8_t refIdx = 0; refIdx <= params->pAvcSlcParams->num_ref_idx_l0_active_minus1; refIdx++)
4473 {
4474 auto refPic = params->pAvcSlcParams->RefPicList[LIST_0][refIdx];
4475 if (!CodecHal_PictureIsInvalid(refPic) && params->pAvcPicIdx[refPic.FrameIdx].bValid)
4476 {
4477 uint8_t refPicIdx = params->pAvcPicIdx[refPic.FrameIdx].ucPicIdx;
4478 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
4479 uint32_t refBindingTableOffset;
4480 // Program the surface based on current picture's field/frame mode
4481 uint8_t refVDirection;
4482 if (currFieldPicture) // if current picture is field
4483 {
4484 if (refBottomField)
4485 {
4486 refVDirection = CODECHAL_VDIRECTION_BOT_FIELD;
4487 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncFwdPicBotField[refIdx];
4488 }
4489 else
4490 {
4491 refVDirection = CODECHAL_VDIRECTION_TOP_FIELD;
4492 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncFwdPicTopField[refIdx];
4493 }
4494 }
4495 else // if current picture is frame
4496 {
4497 refVDirection = CODECHAL_VDIRECTION_FRAME;
4498 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncFwdPicFrame[refIdx];
4499 }
4500
4501 // Picture Y VME
4502 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4503 surfaceCodecParams.bUseAdvState = true;
4504 if((params->bUseWeightedSurfaceForL0) &&
4505 (params->pAvcSlcParams->luma_weight_flag[LIST_0] & (1 << refIdx)) &&
4506 (refIdx < CODEC_AVC_MAX_FORWARD_WP_FRAME))
4507 {
4508 surfaceCodecParams.psSurface = &params->pWeightedPredOutputPicSelectList[CODEC_AVC_WP_OUTPUT_L0_START + refIdx].sBuffer;
4509 }
4510 else
4511 {
4512 surfaceCodecParams.psSurface = &params->ppRefList[refPicIdx]->sRefBuffer;
4513 }
4514 surfaceCodecParams.dwWidthInUse = params->dwFrameWidthInMb * 16;
4515 surfaceCodecParams.dwHeightInUse = params->dwFrameHeightInMb * 16;
4516
4517 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
4518 surfaceCodecParams.ucVDirection = refVDirection;
4519 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
4520 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4521 m_hwInterface,
4522 cmdBuffer,
4523 &surfaceCodecParams,
4524 kernelState));
4525 }
4526 }
4527
4528 // Setup references 1...n
4529 // LIST 1 references
4530 for (uint8_t refIdx = 0; refIdx <= params->pAvcSlcParams->num_ref_idx_l1_active_minus1; refIdx++)
4531 {
4532 if (!currFieldPicture && refIdx > 0)
4533 {
4534 // Only 1 LIST 1 reference required here since only single ref is supported in frame case
4535 break;
4536 }
4537
4538 auto refPic = params->pAvcSlcParams->RefPicList[LIST_1][refIdx];
4539 if (!CodecHal_PictureIsInvalid(refPic) && params->pAvcPicIdx[refPic.FrameIdx].bValid)
4540 {
4541 uint8_t refPicIdx = params->pAvcPicIdx[refPic.FrameIdx].ucPicIdx;
4542 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
4543 uint32_t refMbCodeBottomFieldOffsetUsed;
4544 uint32_t refMvBottomFieldOffsetUsed;
4545 uint8_t refVDirection;
4546 uint32_t refBindingTableOffset;
4547 // Program the surface based on current picture's field/frame mode
4548 if (currFieldPicture) // if current picture is field
4549 {
4550 if (refBottomField)
4551 {
4552 refVDirection = CODECHAL_VDIRECTION_BOT_FIELD;
4553 refMbCodeBottomFieldOffsetUsed = refMbCodeBottomFieldOffset;
4554 refMvBottomFieldOffsetUsed = refMvBottomFieldOffset;
4555 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicBotField[refIdx];
4556 }
4557 else
4558 {
4559 refVDirection = CODECHAL_VDIRECTION_TOP_FIELD;
4560 refMbCodeBottomFieldOffsetUsed = 0;
4561 refMvBottomFieldOffsetUsed = 0;
4562 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicTopField[refIdx];
4563 }
4564 }
4565 else // if current picture is frame
4566 {
4567 refVDirection = CODECHAL_VDIRECTION_FRAME;
4568 refMbCodeBottomFieldOffsetUsed = 0;
4569 refMvBottomFieldOffsetUsed = 0;
4570 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicFrame[refIdx];
4571 }
4572
4573 // Picture Y VME
4574 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4575 surfaceCodecParams.bUseAdvState = true;
4576 surfaceCodecParams.dwWidthInUse = params->dwFrameWidthInMb * 16;
4577 surfaceCodecParams.dwHeightInUse = params->dwFrameHeightInMb * 16;
4578 // max backforward weight prediction surface is 2
4579 if((params->bUseWeightedSurfaceForL1) &&
4580 (params->pAvcSlcParams->luma_weight_flag[LIST_1]&(1<<refIdx)) &&
4581 (refIdx < CODEC_AVC_MAX_BACKWARD_WP_FRAME))
4582 {
4583 surfaceCodecParams.psSurface = &params->pWeightedPredOutputPicSelectList[CODEC_AVC_WP_OUTPUT_L1_START + refIdx].sBuffer;
4584 }
4585 else
4586 {
4587 surfaceCodecParams.psSurface = &params->ppRefList[refPicIdx]->sRefBuffer;
4588 }
4589 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
4590 surfaceCodecParams.ucVDirection = refVDirection;
4591 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
4592 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4593 m_hwInterface,
4594 cmdBuffer,
4595 &surfaceCodecParams,
4596 kernelState));
4597
4598 if (refIdx == 0)
4599 {
4600 if(currFieldPicture && (params->ppRefList[refPicIdx]->ucAvcPictureCodingType == CODEC_AVC_PIC_CODING_TYPE_FRAME || params->ppRefList[refPicIdx]->ucAvcPictureCodingType == CODEC_AVC_PIC_CODING_TYPE_INVALID))
4601 {
4602 refMbCodeBottomFieldOffsetUsed = 0;
4603 refMvBottomFieldOffsetUsed = 0;
4604 }
4605 // MB data buffer
4606 size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 16 * 4;
4607
4608 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4609 surfaceCodecParams.dwSize = size;
4610 if (feiPicParams->MbCodeMvEnable && currFieldPicture)
4611 {
4612 surfaceCodecParams.presBuffer = refBottomField ? &params->ppRefList[refPicIdx]->resRefBotFieldMbCodeBuffer :
4613 &params->ppRefList[refPicIdx]->resRefTopFieldMbCodeBuffer;
4614 }
4615 else
4616 {
4617 surfaceCodecParams.presBuffer = &params->ppRefList[refPicIdx]->resRefMbCodeBuffer;
4618 }
4619 surfaceCodecParams.dwOffset = refMbCodeBottomFieldOffsetUsed;
4620 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PAK_OBJECT_ENCODE].Value;
4621 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdRefMBData;
4622 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4623 m_hwInterface,
4624 cmdBuffer,
4625 &surfaceCodecParams,
4626 kernelState));
4627
4628 // MV data buffer
4629 size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 32 * 4;
4630 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4631 surfaceCodecParams.dwSize = size;
4632 if (feiPicParams->MbCodeMvEnable && currFieldPicture)
4633 {
4634 surfaceCodecParams.presBuffer = refBottomField ? &params->ppRefList[refPicIdx]->resRefBotFieldMvDataBuffer :
4635 &params->ppRefList[refPicIdx]->resRefTopFieldMvDataBuffer;
4636 }
4637 else
4638 {
4639 surfaceCodecParams.presBuffer = &params->ppRefList[refPicIdx]->resRefMvDataBuffer;
4640 }
4641 surfaceCodecParams.dwOffset = refMvBottomFieldOffsetUsed;
4642 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
4643 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdRefMVData;
4644 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4645 m_hwInterface,
4646 cmdBuffer,
4647 &surfaceCodecParams,
4648 kernelState));
4649 }
4650
4651 if (refIdx < CODECHAL_ENCODE_NUM_MAX_VME_L1_REF)
4652 {
4653 if (currFieldPicture)
4654 {
4655 // The binding table contains multiple entries for IDX0 backwards references
4656 if (refBottomField)
4657 {
4658 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicBotField[refIdx + CODECHAL_ENCODE_NUM_MAX_VME_L1_REF];
4659 }
4660 else
4661 {
4662 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicTopField[refIdx + CODECHAL_ENCODE_NUM_MAX_VME_L1_REF];
4663 }
4664 }
4665 else
4666 {
4667 refBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBwdPicFrame[refIdx + CODECHAL_ENCODE_NUM_MAX_VME_L1_REF];
4668 }
4669
4670 // Picture Y VME
4671 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4672 surfaceCodecParams.bUseAdvState = true;
4673
4674 surfaceCodecParams.dwWidthInUse = params->dwFrameWidthInMb * 16;
4675 surfaceCodecParams.dwHeightInUse = params->dwFrameHeightInMb * 16;
4676
4677 surfaceCodecParams.psSurface = &params->ppRefList[refPicIdx]->sRefBuffer;
4678 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
4679 surfaceCodecParams.ucVDirection = refVDirection;
4680 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
4681 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4682 m_hwInterface,
4683 cmdBuffer,
4684 &surfaceCodecParams,
4685 kernelState));
4686 }
4687 }
4688 }
4689
4690 // BRC distortion data buffer for I frame
4691 if (params->bMbEncIFrameDistInUse)
4692 {
4693 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4694 surfaceCodecParams.bIs2DSurface = true;
4695 surfaceCodecParams.bMediaBlockRW = true;
4696 surfaceCodecParams.psSurface = params->psMeBrcDistortionBuffer;
4697 surfaceCodecParams.dwOffset = params->dwMeBrcDistortionBottomFieldOffset;
4698 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncBRCDist;
4699 surfaceCodecParams.bIsWritable = true;
4700 surfaceCodecParams.bRenderTarget = true;
4701 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4702 m_hwInterface,
4703 cmdBuffer,
4704 &surfaceCodecParams,
4705 kernelState));
4706 }
4707
4708 // RefPicSelect of Current Picture
4709 if (params->bUsedAsRef)
4710 {
4711 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4712 surfaceCodecParams.bIs2DSurface = true;
4713 surfaceCodecParams.bMediaBlockRW = true;
4714 surfaceCodecParams.psSurface = &currPicRefListEntry->pRefPicSelectListEntry->sBuffer;
4715 surfaceCodecParams.psSurface->dwHeight = MOS_ALIGN_CEIL(surfaceCodecParams.psSurface->dwHeight, 8);
4716 surfaceCodecParams.dwOffset = params->dwRefPicSelectBottomFieldOffset;
4717 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncRefPicSelectL0;
4718 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
4719 surfaceCodecParams.bRenderTarget = true;
4720 surfaceCodecParams.bIsWritable = true;
4721 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4722 m_hwInterface,
4723 cmdBuffer,
4724 &surfaceCodecParams,
4725 kernelState));
4726 }
4727
4728 if (params->bFlatnessCheckEnabled)
4729 {
4730 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4731 surfaceCodecParams.bIs2DSurface = true;
4732 surfaceCodecParams.bMediaBlockRW = true;
4733 surfaceCodecParams.psSurface = params->psFlatnessCheckSurface;
4734 surfaceCodecParams.dwOffset = currBottomField ? params->dwFlatnessCheckBottomFieldOffset : 0;
4735 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncFlatnessChk;
4736 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_FLATNESS_CHECK_ENCODE].Value;
4737 surfaceCodecParams.bRenderTarget = true;
4738 surfaceCodecParams.bIsWritable = true;
4739 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4740 m_hwInterface,
4741 cmdBuffer,
4742 &surfaceCodecParams,
4743 kernelState));
4744 }
4745
4746 if (params->wPictureCodingType == B_TYPE)
4747 {
4748 auto refPic = params->pAvcSlcParams->RefPicList[LIST_1][0];
4749 if (!CodecHal_PictureIsInvalid(refPic) && params->pAvcPicIdx[refPic.FrameIdx].bValid)
4750 {
4751 bool refBottomField = CodecHal_PictureIsBottomField(refPic);
4752 auto refPicIdx = params->pAvcPicIdx[refPic.FrameIdx].ucPicIdx;
4753
4754 if (params->ppRefList[refPicIdx]->pRefPicSelectListEntry == nullptr)
4755 {
4756 CODECHAL_ENCODE_ASSERTMESSAGE("The RefPicSelectList entry for L1, IDX0 is not valid.");
4757 return eStatus;
4758 }
4759
4760 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4761 surfaceCodecParams.bIs2DSurface = true;
4762 surfaceCodecParams.bMediaBlockRW = true;
4763 surfaceCodecParams.psSurface =
4764 &params->ppRefList[refPicIdx]->pRefPicSelectListEntry->sBuffer;
4765 surfaceCodecParams.dwOffset = refBottomField ? params->dwRefPicSelectBottomFieldOffset : 0;
4766 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncRefPicSelectL1;
4767 surfaceCodecParams.dwCacheabilityControl =
4768 m_hwInterface->ComposeSurfaceCacheabilityControl(
4769 MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE,
4770 codechalLLC);
4771 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4772 m_hwInterface,
4773 cmdBuffer,
4774 &surfaceCodecParams,
4775 kernelState));
4776 }
4777 }
4778
4779 if (params->bMADEnabled)
4780 {
4781 size = CODECHAL_MAD_BUFFER_SIZE;
4782
4783 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4784 surfaceCodecParams.bRawSurface = true;
4785 surfaceCodecParams.dwSize = size;
4786 surfaceCodecParams.presBuffer = params->presMADDataBuffer;
4787 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMADData;
4788 surfaceCodecParams.bRenderTarget = true;
4789 surfaceCodecParams.bIsWritable = true;
4790 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4791 m_hwInterface,
4792 cmdBuffer,
4793 &surfaceCodecParams,
4794 kernelState));
4795 }
4796
4797 // FEI Mb Specific Data surface
4798 if (feiPicParams->bPerMBInput)
4799 {
4800 size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 16;
4801 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4802 surfaceCodecParams.dwSize = size;
4803 surfaceCodecParams.presBuffer = &(feiPicParams->resMBCtrl);
4804 surfaceCodecParams.dwOffset = 0;
4805 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMbSpecificData;
4806 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4807 m_hwInterface,
4808 cmdBuffer,
4809 &surfaceCodecParams,
4810 kernelState));
4811 }
4812
4813 // FEI Multi Mv Predictor Surface
4814 if (feiPicParams->MVPredictorEnable)
4815 {
4816 size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 40;
4817 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4818 surfaceCodecParams.dwSize = size;
4819 surfaceCodecParams.presBuffer = &(feiPicParams->resMVPredictor);
4820 surfaceCodecParams.dwOffset = 0;
4821 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
4822 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMvPrediction;
4823 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4824 m_hwInterface,
4825 cmdBuffer,
4826 &surfaceCodecParams,
4827 kernelState));
4828 }
4829
4830 // FEI distortion surface
4831 if (feiPicParams->DistortionEnable)
4832 {
4833 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4834 surfaceCodecParams.presBuffer = &(feiPicParams->resDistortion);
4835 surfaceCodecParams.dwOffset = 0;
4836 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncVMEDistortion;
4837 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
4838 surfaceCodecParams.bRenderTarget = true;
4839 surfaceCodecParams.bIsWritable = true;
4840 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4841 m_hwInterface,
4842 cmdBuffer,
4843 &surfaceCodecParams,
4844 kernelState));
4845 }
4846
4847 if (feiPicParams->bMBQp)
4848 {
4849 // 16 DWs per QP value
4850 size = 16 * 52 * sizeof(uint32_t);
4851 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4852 surfaceCodecParams.presBuffer = params->presMbBrcConstDataBuffer;
4853 surfaceCodecParams.dwSize = size;
4854 surfaceCodecParams.dwBindingTableOffset = avcMbEncBindingTable->dwAvcMBEncMbBrcConstData;
4855 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4856 m_hwInterface,
4857 cmdBuffer,
4858 &surfaceCodecParams,
4859 kernelState));
4860
4861 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4862 surfaceCodecParams.presBuffer = &(feiPicParams->resMBQp);
4863 surfaceCodecParams.dwOffset = 0;
4864 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ? avcMbEncBindingTable->dwAvcMBEncMbQpField :
4865 avcMbEncBindingTable->dwAvcMBEncMbQpFrame;
4866 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4867 m_hwInterface,
4868 cmdBuffer,
4869 &surfaceCodecParams,
4870 kernelState));
4871 }
4872
4873 return eStatus;
4874 }
4875
4876 MOS_STATUS CodechalEncodeAvcEncFeiG8::PreProcKernel()
4877 {
4878 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4879
4880 CODECHAL_ENCODE_FUNCTION_ENTER;
4881
4882 auto preEncParams = (FeiPreEncParams*)m_encodeParams.pPreEncParams;
4883 auto refList = &m_refList[0];
4884
4885 auto encFunctionType = CODECHAL_MEDIA_STATE_PREPROC;
4886 auto kernelState = &PreProcKernelState;
4887
4888 PerfTagSetting perfTag;
4889 perfTag.Value = 0;
4890 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
4891 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_PREPROC_KERNEL;
4892 perfTag.PictureCodingType = m_pictureCodingType;
4893 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
4894
4895 // If Single Task Phase is not enabled, use BT count for the kernel state.
4896 if (m_firstTaskInPhase == true || !m_singleTaskPhaseSupported)
4897 {
4898 uint32_t dwMaxBtCount = m_singleTaskPhaseSupported ?
4899 m_maxBtCount : kernelState->KernelParams.iBTCount;
4900 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
4901 m_stateHeapInterface,
4902 dwMaxBtCount));
4903 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(dwMaxBtCount);
4904 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
4905 }
4906
4907 // Set up the DSH/SSH as normal
4908 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
4909 m_stateHeapInterface,
4910 kernelState,
4911 false,
4912 0,
4913 false,
4914 m_storeData));
4915
4916 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
4917 MOS_ZeroMemory(&idParams, sizeof(idParams));
4918 idParams.pKernelState = kernelState;
4919 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
4920 m_stateHeapInterface,
4921 1,
4922 &idParams));
4923
4924 // Setup Curbe
4925 CODECHAL_ENCODE_AVC_PREPROC_CURBE_PARAMS preProcCurbeParams;
4926 MOS_ZeroMemory(&preProcCurbeParams, sizeof(preProcCurbeParams));
4927 preProcCurbeParams.pPreEncParams = preEncParams;
4928 preProcCurbeParams.wPicWidthInMb = m_picWidthInMb;
4929 preProcCurbeParams.wFieldFrameHeightInMb = m_frameFieldHeightInMb;
4930 preProcCurbeParams.pKernelState = kernelState;
4931
4932 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeAvcPreProc(
4933 &preProcCurbeParams));
4934
4935 CODECHAL_DEBUG_TOOL(
4936 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4937 encFunctionType,
4938 MHW_DSH_TYPE,
4939 kernelState));
4940
4941 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
4942 encFunctionType,
4943 kernelState));
4944
4945 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4946 encFunctionType,
4947 MHW_ISH_TYPE,
4948 kernelState));
4949 )
4950
4951 for (uint8_t i = 0; i < CODEC_AVC_MAX_NUM_REF_FRAME; i++)
4952 {
4953 if (m_picIdx[i].bValid)
4954 {
4955 uint8_t index = m_picIdx[i].ucPicIdx;
4956 refList[index]->sRefBuffer = refList[index]->sRefRawBuffer;
4957
4958 CodecHalGetResourceInfo(m_osInterface, &refList[index]->sRefBuffer);
4959 }
4960 }
4961
4962 MOS_COMMAND_BUFFER cmdBuffer;
4963 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4964
4965 SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams();
4966 sendKernelCmdsParams.EncFunctionType = encFunctionType;
4967 sendKernelCmdsParams.ucDmvPredFlag = (m_pictureCodingType == I_TYPE) ? 0 : m_avcSliceParams->direct_spatial_mv_pred_flag;
4968
4969 sendKernelCmdsParams.pKernelState = kernelState;
4970 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
4971
4972 // Set up FtqLut Buffer if there is QP change within a frame
4973 if (preEncParams->bMBQp)
4974 {
4975 CODECHAL_ENCODE_AVC_INIT_MBBRC_CONSTANT_DATA_BUFFER_PARAMS initMbBrcConstantDataBufferParams;
4976
4977 MOS_ZeroMemory(&initMbBrcConstantDataBufferParams, sizeof(initMbBrcConstantDataBufferParams));
4978 initMbBrcConstantDataBufferParams.pOsInterface = m_osInterface;
4979 initMbBrcConstantDataBufferParams.presBrcConstantDataBuffer =
4980 &BrcBuffers.resMbBrcConstDataBuffer[m_currRecycledBufIdx];
4981 initMbBrcConstantDataBufferParams.bPreProcEnable = true;
4982 initMbBrcConstantDataBufferParams.bEnableKernelTrellis = bKernelTrellis && m_trellisQuantParams.dwTqEnabled;;
4983
4984 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitMbBrcConstantDataBuffer(&initMbBrcConstantDataBufferParams));
4985 }
4986
4987 // Add binding table
4988 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
4989 m_stateHeapInterface,
4990 kernelState));
4991
4992 //Add surface states
4993 CODECHAL_ENCODE_AVC_PREPROC_SURFACE_PARAMS preProcSurfaceParams;
4994 MOS_ZeroMemory(&preProcSurfaceParams, sizeof(preProcSurfaceParams));
4995 preProcSurfaceParams.pPreEncParams = preEncParams;
4996 preProcSurfaceParams.ppRefList = &m_refList[0];
4997 preProcSurfaceParams.pCurrOriginalPic = &m_currOriginalPic;
4998 preProcSurfaceParams.psCurrPicSurface = m_rawSurfaceToEnc;
4999 preProcSurfaceParams.ps4xMeMvDataBuffer = &m_4xMeMvDataBuffer;
5000 preProcSurfaceParams.presFtqLutBuffer = &BrcBuffers.resMbBrcConstDataBuffer[m_currRecycledBufIdx];
5001 preProcSurfaceParams.dwMeMvBottomFieldOffset = m_meMvBottomFieldOffset;
5002 preProcSurfaceParams.dwFrameWidthInMb = (uint32_t)m_picWidthInMb;
5003 preProcSurfaceParams.dwFrameFieldHeightInMb = (uint32_t)m_frameFieldHeightInMb;
5004 preProcSurfaceParams.dwMBVProcStatsBottomFieldOffset =
5005 CodecHal_PictureIsBottomField(m_currOriginalPic) ? m_mbvProcStatsBottomFieldOffset : 0;
5006 // Interleaved input surfaces
5007 preProcSurfaceParams.dwVerticalLineStride = m_verticalLineStride;
5008 preProcSurfaceParams.dwVerticalLineStrideOffset = m_verticalLineStrideOffset;
5009 preProcSurfaceParams.bHmeEnabled = m_hmeEnabled;
5010 preProcSurfaceParams.pPreProcBindingTable = &PreProcBindingTable;
5011 preProcSurfaceParams.pKernelState = kernelState;
5012
5013 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendAvcPreProcSurfaces(&cmdBuffer, &preProcSurfaceParams));
5014
5015 uint32_t resolutionX = (uint32_t)m_picWidthInMb;
5016 uint32_t resolutionY = (uint32_t)m_frameFieldHeightInMb;
5017
5018 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
5019 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
5020 walkerCodecParams.WalkerMode = m_walkerMode;
5021 walkerCodecParams.dwResolutionX = resolutionX;
5022 walkerCodecParams.dwResolutionY = resolutionY;
5023 walkerCodecParams.bNoDependency = true;
5024 walkerCodecParams.bMbaff = m_mbaffEnabled;
5025 walkerCodecParams.bGroupIdSelectSupported = m_groupIdSelectSupported;
5026 walkerCodecParams.ucGroupId = m_groupId;
5027
5028 MHW_WALKER_PARAMS walkerParams;
5029 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
5030 m_hwInterface,
5031 &walkerParams,
5032 &walkerCodecParams));
5033
5034 HalOcaInterface::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, __FUNCTION__, sizeof(__FUNCTION__));
5035 HalOcaInterface::OnDispatch(cmdBuffer, *m_osInterface, *m_miInterface, *m_renderEngineInterface->GetMmioRegisters());
5036
5037 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
5038 &cmdBuffer,
5039 &walkerParams));
5040
5041 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
5042
5043 // Add dump for MBEnc surface state heap here
5044 CODECHAL_DEBUG_TOOL(
5045 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
5046 encFunctionType,
5047 MHW_SSH_TYPE,
5048 kernelState));
5049 )
5050
5051 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
5052 &cmdBuffer,
5053 encFunctionType,
5054 nullptr)));
5055
5056 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
5057 m_stateHeapInterface,
5058 kernelState));
5059
5060 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
5061 {
5062 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
5063 m_stateHeapInterface));
5064 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
5065 }
5066
5067 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, m_singleTaskPhaseSupported, m_lastTaskInPhase));
5068
5069 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
5070
5071 if ((!m_singleTaskPhaseSupported || m_lastTaskInPhase))
5072 {
5073 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
5074 m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw);
5075 m_lastTaskInPhase = false;
5076 }
5077
5078 return eStatus;
5079 }
5080
5081 MOS_STATUS CodechalEncodeAvcEncFeiG8::SetCurbeMe(MeCurbeParams* params)
5082 {
5083 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5084
5085 CODECHAL_ENCODE_FUNCTION_ENTER;
5086
5087 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5088
5089 auto preEncParams = (FeiPreEncParams*)m_encodeParams.pPreEncParams;
5090 CODECHAL_ENCODE_CHK_NULL_RETURN(preEncParams);
5091
5092 auto slcParams = m_avcSliceParams;
5093 bool framePicture = CodecHal_PictureIsFrame(m_currOriginalPic);
5094 uint32_t scaleFactor;
5095 uint8_t mvShiftFactor = 0, prevMvReadPosFactor = 0;
5096 bool useMvFromPrevStep, writeDistortions;
5097 switch (params->hmeLvl)
5098 {
5099 case HME_LEVEL_4x:
5100 useMvFromPrevStep = false;
5101 writeDistortions = false;
5102 scaleFactor = SCALE_FACTOR_4x;
5103 mvShiftFactor = 2;
5104 prevMvReadPosFactor = 0;
5105 break;
5106 default:
5107 eStatus = MOS_STATUS_INVALID_PARAMETER;
5108 return eStatus;
5109 break;
5110 }
5111
5112 ME_CURBE_CM_FEI cmd;
5113 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5114 &cmd,
5115 sizeof(ME_CURBE_CM_FEI),
5116 m_meCurbeCmFei,
5117 sizeof(ME_CURBE_CM_FEI)));
5118
5119 cmd.DW3.SubPelMode = 3;
5120 if (m_fieldScalingOutputInterleaved)
5121 {
5122 cmd.DW3.SrcAccess =
5123 cmd.DW3.RefAccess = CodecHal_PictureIsField(m_currOriginalPic) ? 1 : 0;
5124 cmd.DW7.SrcFieldPolarity = CodecHal_PictureIsBottomField(m_currOriginalPic) ? 1 : 0;
5125 }
5126
5127 cmd.DW4.PictureHeightMinus1 =
5128 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight / scaleFactor) - 1;
5129 cmd.DW4.PictureWidth =
5130 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth / scaleFactor);
5131 cmd.DW5.QpPrimeY = preEncParams->dwFrameQp;
5132 cmd.DW6.WriteDistortions = writeDistortions;
5133 cmd.DW6.UseMvFromPrevStep = useMvFromPrevStep;
5134
5135 cmd.DW6.SuperCombineDist = m_superCombineDistGeneric[m_targetUsage];
5136 cmd.DW6.MaxVmvR = (framePicture) ?
5137 CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) * 4 :
5138 (CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) >> 1) * 4;
5139
5140 if (m_pictureCodingType == B_TYPE)
5141 {
5142 // This field is irrelevant since we are not using the bi-direct search.
5143 // set it to 32
5144 cmd.DW1.BiWeight = 32;
5145 cmd.DW13.NumRefIdxL1MinusOne = slcParams->num_ref_idx_l1_active_minus1;
5146 }
5147
5148 if (m_pictureCodingType == P_TYPE ||
5149 m_pictureCodingType == B_TYPE)
5150 {
5151 cmd.DW13.NumRefIdxL0MinusOne = slcParams->num_ref_idx_l0_active_minus1;
5152 }
5153
5154 if (!framePicture)
5155 {
5156 if (m_pictureCodingType != I_TYPE)
5157 {
5158 cmd.DW14.List0RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_0);
5159 cmd.DW14.List0RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_1);
5160 cmd.DW14.List0RefID2FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_2);
5161 cmd.DW14.List0RefID3FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_3);
5162 cmd.DW14.List0RefID4FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_4);
5163 cmd.DW14.List0RefID5FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_5);
5164 cmd.DW14.List0RefID6FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_6);
5165 cmd.DW14.List0RefID7FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_7);
5166 }
5167 if (m_pictureCodingType == B_TYPE)
5168 {
5169 cmd.DW14.List1RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_0);
5170 cmd.DW14.List1RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_1);
5171 }
5172 }
5173
5174 cmd.DW15.MvShiftFactor = mvShiftFactor;
5175 cmd.DW15.PrevMvReadPosFactor = prevMvReadPosFactor;
5176
5177 // r3 & r4
5178 uint8_t meMethod = (m_pictureCodingType == B_TYPE) ? m_bMeMethodGeneric[m_targetUsage] : m_meMethodGeneric[m_targetUsage];
5179 uint8_t tableIdx = (m_pictureCodingType == B_TYPE) ? 1 : 0;
5180 eStatus = MOS_SecureMemcpy(&(cmd.SPDelta), 14 * sizeof(uint32_t), CodechalEncoderState::m_encodeSearchPath[tableIdx][meMethod], 14 * sizeof(uint32_t));
5181 if (eStatus != MOS_STATUS_SUCCESS)
5182 {
5183 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
5184 return eStatus;
5185 }
5186 if(params->pCurbeBinary)
5187 {
5188 MOS_SecureMemcpy(params->pCurbeBinary,m_feiMeCurbeDataSize,&cmd,m_feiMeCurbeDataSize);
5189 return eStatus;
5190 }
5191 // r5
5192 cmd.DW32._4xMeMvOutputDataSurfIndex = ME_MV_DATA_SURFACE_CM;
5193 cmd.DW33._16xOr32xMeMvInputDataSurfIndex = (params->hmeLvl == HME_LEVEL_32x) ?
5194 ME_32x_MV_DATA_SURFACE_CM : ME_16x_MV_DATA_SURFACE_CM;
5195 cmd.DW34._4xMeOutputDistSurfIndex = ME_DISTORTION_SURFACE_CM;
5196 cmd.DW35._4xMeOutputBrcDistSurfIndex = ME_BRC_DISTORTION_CM;
5197 cmd.DW36.VMEFwdInterPredictionSurfIndex = ME_CURR_FOR_FWD_REF_CM;
5198 cmd.DW37.VMEBwdInterPredictionSurfIndex = ME_CURR_FOR_BWD_REF_CM;
5199 cmd.DW38.Value = 0; //MBZ for BDW
5200
5201 CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
5202 &cmd,
5203 params->pKernelState->dwCurbeOffset,
5204 sizeof(cmd)));
5205
5206 return eStatus;
5207 }
5208
5209 MOS_STATUS CodechalEncodeAvcEncFeiG8::SendMeSurfaces(PMOS_COMMAND_BUFFER cmdBuffer, MeSurfaceParams* params)
5210 {
5211 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5212
5213 CODECHAL_ENCODE_FUNCTION_ENTER;
5214
5215 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface);
5216 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
5217 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5218 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
5219 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pCurrOriginalPic);
5220 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps4xMeMvDataBuffer);
5221 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psMeBrcDistortionBuffer);
5222
5223 // only 4x HME is supported for FEI
5224 CODECHAL_ENCODE_ASSERT(!params->b32xMeInUse && !params->b16xMeInUse);
5225 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pMeBindingTable);
5226 auto meBindingTable = params->pMeBindingTable;
5227 bool currFieldPicture = CodecHal_PictureIsField(*(params->pCurrOriginalPic)) ? 1 : 0;
5228 bool currBottomField = CodecHal_PictureIsBottomField(*(params->pCurrOriginalPic)) ? 1 : 0;
5229 uint8_t currVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME :
5230 ((currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
5231 uint8_t scaledIdx = params->ppRefList[m_currReconstructedPic.FrameIdx]->ucScalingIdx;
5232 auto currScaledSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
5233 CODECHAL_ENCODE_CHK_NULL_RETURN(currScaledSurface);
5234 auto meMvDataBuffer = params->ps4xMeMvDataBuffer;
5235 uint32_t meMvBottomFieldOffset = params->dw4xMeMvBottomFieldOffset;
5236 uint32_t currScaledBottomFieldOffset = params->dw4xScaledBottomFieldOffset;
5237
5238 // Reference height and width information should be taken from the current scaled surface rather
5239 // than from the reference scaled surface in the case of PAFF.
5240 auto refScaledSurface = *currScaledSurface;
5241
5242 uint32_t width = MOS_ALIGN_CEIL(params->dwDownscaledWidthInMb * 32, 64);
5243 uint32_t height = params->dwDownscaledHeightInMb * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER;
5244
5245 // Force the values
5246 meMvDataBuffer->dwWidth = width;
5247 meMvDataBuffer->dwHeight = height;
5248 meMvDataBuffer->dwPitch = width;
5249
5250 CODECHAL_SURFACE_CODEC_PARAMS surfaceParams;
5251 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5252 surfaceParams.bIs2DSurface = true;
5253 surfaceParams.bMediaBlockRW = true;
5254 surfaceParams.psSurface = meMvDataBuffer;
5255 surfaceParams.dwOffset = meMvBottomFieldOffset;
5256 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
5257 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEMVDataSurface;
5258 surfaceParams.bIsWritable = true;
5259 surfaceParams.bRenderTarget = true;
5260 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5261 m_hwInterface,
5262 cmdBuffer,
5263 &surfaceParams,
5264 params->pKernelState));
5265
5266 // Insert Distortion buffers only for 4xMe case
5267 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5268 surfaceParams.bIs2DSurface = true;
5269 surfaceParams.bMediaBlockRW = true;
5270 surfaceParams.psSurface = params->psMeBrcDistortionBuffer;
5271 surfaceParams.dwOffset = params->dwMeBrcDistortionBottomFieldOffset;
5272 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBRCDist;
5273 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE].Value;
5274 surfaceParams.bIsWritable = true;
5275 surfaceParams.bRenderTarget = true;
5276 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5277 m_hwInterface,
5278 cmdBuffer,
5279 &surfaceParams,
5280 params->pKernelState));
5281
5282 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5283 surfaceParams.bIs2DSurface = true;
5284 surfaceParams.bMediaBlockRW = true;
5285 surfaceParams.psSurface = params->psMeDistortionBuffer;
5286 surfaceParams.dwOffset = params->dwMeDistortionBottomFieldOffset;
5287 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEDist;
5288 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
5289 surfaceParams.bIsWritable = true;
5290 surfaceParams.bRenderTarget = true;
5291 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5292 m_hwInterface,
5293 cmdBuffer,
5294 &surfaceParams,
5295 params->pKernelState));
5296
5297 // Setup references 1...n
5298 // LIST 0 references
5299 for (uint8_t refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++)
5300 {
5301 auto refPic = params->pL0RefFrameList[refIdx];
5302
5303 if (!CodecHal_PictureIsInvalid(refPic) && params->pPicIdx[refPic.FrameIdx].bValid)
5304 {
5305 if (refIdx == 0)
5306 {
5307 // Current Picture Y - VME
5308 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5309 surfaceParams.bUseAdvState = true;
5310 surfaceParams.psSurface = currScaledSurface;
5311 surfaceParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
5312 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
5313 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForFwdRef;
5314 surfaceParams.ucVDirection = currVDirection;
5315 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5316 m_hwInterface,
5317 cmdBuffer,
5318 &surfaceParams,
5319 params->pKernelState));
5320 }
5321
5322 bool refFieldPicture = CodecHal_PictureIsField(refPic) ? 1 : 0;
5323 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
5324 uint8_t refPicIdx = params->pPicIdx[refPic.FrameIdx].ucPicIdx;
5325 scaledIdx = params->ppRefList[refPicIdx]->ucScalingIdx;
5326
5327 MOS_SURFACE* p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
5328 if (p4xSurface != nullptr)
5329 {
5330 refScaledSurface.OsResource = p4xSurface->OsResource;
5331 }
5332 else
5333 {
5334 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
5335 }
5336 uint32_t refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
5337
5338 // L0 Reference Picture Y - VME
5339 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5340 surfaceParams.bUseAdvState = true;
5341 surfaceParams.psSurface = &refScaledSurface;
5342 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
5343 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
5344 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEFwdRefPicIdx[refIdx];
5345 surfaceParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME :
5346 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
5347 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5348 m_hwInterface,
5349 cmdBuffer,
5350 &surfaceParams,
5351 params->pKernelState));
5352
5353 if (currFieldPicture)
5354 {
5355 // VME needs to set ref index 1 too for field case
5356 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEFwdRefPicIdx[refIdx + 1];
5357 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5358 m_hwInterface,
5359 cmdBuffer,
5360 &surfaceParams,
5361 params->pKernelState));
5362 }
5363 }
5364 }
5365
5366 // Setup references 1...n
5367 // LIST 1 references
5368 for (uint8_t refIdx = 0; refIdx <= params->dwNumRefIdxL1ActiveMinus1; refIdx++)
5369 {
5370 auto refPic = params->pL1RefFrameList[refIdx];
5371
5372 if (!CodecHal_PictureIsInvalid(refPic) && params->pPicIdx[refPic.FrameIdx].bValid)
5373 {
5374 if (refIdx == 0)
5375 {
5376 // Current Picture Y - VME
5377 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5378 surfaceParams.bUseAdvState = true;
5379 surfaceParams.psSurface = currScaledSurface;
5380 surfaceParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
5381 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
5382 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForBwdRef;
5383 surfaceParams.ucVDirection = currVDirection;
5384 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5385 m_hwInterface,
5386 cmdBuffer,
5387 &surfaceParams,
5388 params->pKernelState));
5389 }
5390
5391 bool refFieldPicture = CodecHal_PictureIsField(refPic) ? 1 : 0;
5392 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
5393 uint8_t refPicIdx = params->pPicIdx[refPic.FrameIdx].ucPicIdx;
5394 scaledIdx = params->ppRefList[refPicIdx]->ucScalingIdx;
5395
5396 MOS_SURFACE* p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
5397 if (p4xSurface != nullptr)
5398 {
5399 refScaledSurface.OsResource = p4xSurface->OsResource;
5400 }
5401 else
5402 {
5403 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
5404 }
5405 uint32_t refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
5406
5407 // L1 Reference Picture Y - VME
5408 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
5409 surfaceParams.bUseAdvState = true;
5410 surfaceParams.psSurface = &refScaledSurface;
5411 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
5412 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
5413 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBwdRefPicIdx[refIdx];
5414 surfaceParams.ucVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME :
5415 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
5416 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5417 m_hwInterface,
5418 cmdBuffer,
5419 &surfaceParams,
5420 params->pKernelState));
5421
5422 if (currFieldPicture)
5423 {
5424 // VME needs to set ref index 1 too for field case
5425 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBwdRefPicIdx[refIdx + 1];
5426 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5427 m_hwInterface,
5428 cmdBuffer,
5429 &surfaceParams,
5430 params->pKernelState));
5431 }
5432 }
5433 }
5434
5435 return eStatus;
5436 }
5437
5438 MOS_STATUS CodechalEncodeAvcEncFeiG8::EncodeGetKernelHeaderAndSize(void *pvBinary, EncOperation operation, uint32_t krnStateIdx, void* pvKrnHeader, uint32_t *pdwKrnSize)
5439 {
5440 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5441
5442 CODECHAL_ENCODE_CHK_NULL_RETURN(pvBinary);
5443 CODECHAL_ENCODE_CHK_NULL_RETURN(pvKrnHeader);
5444 CODECHAL_ENCODE_CHK_NULL_RETURN(pdwKrnSize);
5445
5446 auto kernelHeaderTable = (PKERNEL_HEADER_FEI_CM)pvBinary;
5447 PCODECHAL_KERNEL_HEADER invalidEntry = &(kernelHeaderTable->AVC_WeightedPrediction) + 1;
5448 uint32_t nextKrnOffset = *pdwKrnSize;
5449
5450 PCODECHAL_KERNEL_HEADER currKrnHeader;
5451 if (operation == ENC_SCALING4X)
5452 {
5453 currKrnHeader = &kernelHeaderTable->PLY_DScale_PLY;
5454 }
5455 else if (operation == ENC_ME)
5456 {
5457 currKrnHeader = &kernelHeaderTable->AVC_ME_P;
5458 }
5459 else if (operation == ENC_MBENC)
5460 {
5461 currKrnHeader = &kernelHeaderTable->AVCMBEnc_Fei_I;
5462 }
5463 else if (operation == ENC_PREPROC)
5464 {
5465 currKrnHeader = &kernelHeaderTable->AVC_Fei_ProProc;
5466 }
5467 else if (operation == ENC_WP)
5468 {
5469 currKrnHeader = &kernelHeaderTable->AVC_WeightedPrediction;
5470 }
5471 else
5472 {
5473 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
5474 eStatus = MOS_STATUS_INVALID_PARAMETER;
5475 return eStatus;
5476 }
5477
5478 currKrnHeader += krnStateIdx;
5479 *((PCODECHAL_KERNEL_HEADER)pvKrnHeader) = *currKrnHeader;
5480
5481 PCODECHAL_KERNEL_HEADER nextKrnHeader = (currKrnHeader + 1);
5482 if (nextKrnHeader < invalidEntry)
5483 {
5484 nextKrnOffset = nextKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT;
5485 }
5486 *pdwKrnSize = nextKrnOffset - (currKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
5487
5488 return eStatus;
5489 }
5490
5491 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitializeState()
5492 {
5493 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5494
5495 CODECHAL_ENCODE_FUNCTION_ENTER;
5496
5497 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcEncG8::InitializeState());
5498
5499 if (m_codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC)
5500 {
5501 m_hmeSupported = true;
5502 m_flatnessCheckSupported = true;
5503 }
5504
5505 if (m_feiEnable)
5506 {
5507 if (m_codecFunction == CODECHAL_FUNCTION_FEI_PRE_ENC)
5508 {
5509 m_hmeSupported = true;
5510 m_flatnessCheckSupported = true;
5511 }
5512
5513 m_16xMeSupported = false;
5514 m_32xMeSupported = false;
5515 }
5516
5517 bWeightedPredictionSupported = true;
5518 dwBrcConstantSurfaceWidth = m_brcConstantSurfaceWidth;
5519 dwBrcConstantSurfaceHeight = m_brcConstantSurfaceHeight;
5520
5521 return eStatus;
5522 }
5523
5524 MOS_STATUS CodechalEncodeAvcEncFeiG8::ValidateNumReferences(PCODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS params)
5525 {
5526 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5527
5528 CODECHAL_ENCODE_FUNCTION_ENTER;
5529 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5530 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
5531 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pAvcSliceParams);
5532
5533 uint8_t numRefIdx0MinusOne = params->pAvcSliceParams->num_ref_idx_l0_active_minus1;
5534 uint8_t numRefIdx1MinusOne = params->pAvcSliceParams->num_ref_idx_l1_active_minus1;
5535
5536 // Nothing to do here if numRefIdx = 0 and frame encoded
5537 if (numRefIdx0MinusOne == 0 && !CodecHal_PictureIsField(params->pPicParams->CurrOriginalPic))
5538 {
5539 if (params->wPictureCodingType == P_TYPE ||
5540 (params->wPictureCodingType == B_TYPE && numRefIdx1MinusOne == 0))
5541 {
5542 return eStatus;
5543 }
5544 }
5545
5546 if (params->wPictureCodingType == P_TYPE || params->wPictureCodingType == B_TYPE)
5547 {
5548 uint8_t maxPNumRefIdx0MinusOne = CODECHAL_ENCODE_AVC_MAX_NUM_REF_L0 - 1;
5549 uint8_t maxPNumRefIdx1MinusOne = CODECHAL_ENCODE_AVC_MAX_NUM_REF_L1 - 1;
5550 if(params->bPAKonly)
5551 {
5552 maxPNumRefIdx0MinusOne = CODEC_AVC_MAX_NUM_REF_FRAME - 1;
5553 maxPNumRefIdx1MinusOne = CODEC_AVC_MAX_NUM_REF_FRAME - 1;
5554 }
5555 if (params->wPictureCodingType == P_TYPE)
5556 {
5557 if (numRefIdx0MinusOne > maxPNumRefIdx0MinusOne)
5558 {
5559 CODECHAL_ENCODE_NORMALMESSAGE("Invalid active reference list size.");
5560 numRefIdx0MinusOne = maxPNumRefIdx0MinusOne;
5561 }
5562 numRefIdx1MinusOne = 0;
5563 }
5564 else // B_TYPE
5565 {
5566 if (numRefIdx0MinusOne > maxPNumRefIdx0MinusOne)
5567 {
5568 CODECHAL_ENCODE_NORMALMESSAGE("Invalid active reference list size.");
5569 numRefIdx0MinusOne = maxPNumRefIdx0MinusOne;
5570 }
5571
5572 if (numRefIdx1MinusOne > maxPNumRefIdx1MinusOne)
5573 {
5574 CODECHAL_ENCODE_NORMALMESSAGE("Invalid active reference list size.");
5575 numRefIdx1MinusOne = maxPNumRefIdx1MinusOne;
5576 }
5577
5578 // supports at most 1 L1 ref for frame picture for non-PAK only case
5579 if (CodecHal_PictureIsFrame(params->pPicParams->CurrOriginalPic) && numRefIdx1MinusOne > 0 && (!params->bPAKonly))
5580 {
5581 numRefIdx1MinusOne = 0;
5582 }
5583 }
5584 }
5585
5586 // Override number of references used by VME. PAK uses value from DDI (num_ref_idx_l*_active_minus1_from_DDI)
5587 params->pAvcSliceParams->num_ref_idx_l0_active_minus1 = numRefIdx0MinusOne;
5588 params->pAvcSliceParams->num_ref_idx_l1_active_minus1 = numRefIdx1MinusOne;
5589
5590 return eStatus;
5591 }
5592
5593 MOS_STATUS CodechalEncodeAvcEncFeiG8::InitKernelStateWP()
5594 {
5595 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5596
5597 CODECHAL_ENCODE_FUNCTION_ENTER;
5598
5599 pWPKernelState = MOS_New(MHW_KERNEL_STATE);
5600 CODECHAL_ENCODE_CHK_NULL_RETURN(pWPKernelState);
5601
5602 auto kernelStatePtr = pWPKernelState;
5603
5604 uint8_t* kernelBinary;
5605 uint32_t kernelSize;
5606
5607 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetKernelBinaryAndSize(m_kernelBase, m_kuid, &kernelBinary, &kernelSize));
5608
5609 CODECHAL_KERNEL_HEADER currKrnHeader;
5610 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeGetKernelHeaderAndSize(
5611 kernelBinary,
5612 ENC_WP,
5613 0,
5614 &currKrnHeader,
5615 &kernelSize));
5616 kernelStatePtr->KernelParams.iBTCount = WP_NUM_SURFACES;
5617 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
5618 kernelStatePtr->KernelParams.iCurbeLength = sizeof(WP_CURBE);
5619 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
5620 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
5621 kernelStatePtr->KernelParams.iIdCount = 1;
5622 kernelStatePtr->KernelParams.iInlineDataLength = 0;
5623
5624 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
5625 kernelStatePtr->KernelParams.pBinary = kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
5626 kernelStatePtr->KernelParams.iSize = kernelSize;
5627 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
5628 m_stateHeapInterface,
5629 kernelStatePtr->KernelParams.iBTCount,
5630 &kernelStatePtr->dwSshSize,
5631 &kernelStatePtr->dwBindingTableSize));
5632
5633 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
5634
5635 return eStatus;
5636 }
5637
5638 MOS_STATUS CodechalEncodeAvcEncFeiG8::GetMbEncKernelStateIdx(CodechalEncodeIdOffsetParams* params, uint32_t* pdwKernelOffset)
5639 {
5640 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5641
5642 CODECHAL_ENCODE_FUNCTION_ENTER;
5643
5644 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5645 CODECHAL_ENCODE_CHK_NULL_RETURN(pdwKernelOffset);
5646
5647 *pdwKernelOffset = MBENC_I_OFFSET_CM;
5648
5649 if (params->EncFunctionType == CODECHAL_MEDIA_STATE_ENC_ADV)
5650 {
5651 *pdwKernelOffset += MBENC_TARGET_USAGE_CM;
5652 }
5653
5654 if (params->wPictureCodingType == P_TYPE)
5655 {
5656 *pdwKernelOffset += MBENC_P_OFFSET_CM;
5657 }
5658 else if (params->wPictureCodingType == B_TYPE)
5659 {
5660 *pdwKernelOffset += MBENC_B_OFFSET_CM;
5661 }
5662
5663 return eStatus;
5664 }
5665
5666 MOS_STATUS CodechalEncodeAvcEncFeiG8::SetCurbeAvcMbEnc(PCODECHAL_ENCODE_AVC_MBENC_CURBE_PARAMS params)
5667 {
5668 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5669 CODECHAL_ENCODE_FUNCTION_ENTER;
5670 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5671 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPicParams);
5672 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
5673 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSlcParams);
5674
5675 auto seqParams = params->pSeqParams;
5676 CODECHAL_ENCODE_ASSERT(seqParams->TargetUsage == TARGETUSAGE_RT_SPEED);
5677 // set sliceQP to MAX_SLICE_QP for MbEnc kernel, we can use it to verify whether QP is changed or not
5678 auto picParams = params->pPicParams;
5679 auto slcParams = params->pSlcParams;
5680 uint8_t sliceQP = (params->bUseMbEncAdvKernel && params->bBrcEnabled) ? CODECHAL_ENCODE_AVC_MAX_SLICE_QP : picParams->pic_init_qp_minus26 + 26 + slcParams->slice_qp_delta;
5681 bool framePicture = CodecHal_PictureIsFrame(picParams->CurrOriginalPic);
5682
5683 MBENC_CURBE_CM_FEI cmd;
5684
5685 if (params->bMbEncIFrameDistEnabled)
5686 {
5687 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5688 &cmd,
5689 sizeof(MBENC_CURBE_CM_FEI),
5690 m_feiMbEncCurbeIFrameDist,
5691 sizeof(MBENC_CURBE_CM_FEI)));
5692 }
5693 else
5694 {
5695 switch (m_pictureCodingType)
5696 {
5697 case I_TYPE:
5698 if (framePicture)
5699 {
5700 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5701 &cmd,
5702 sizeof(MBENC_CURBE_CM_FEI),
5703 m_feiMbEncCurbeNormalIFrame,
5704 sizeof(MBENC_CURBE_CM_FEI)));
5705 }
5706 else
5707 {
5708 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5709 &cmd,
5710 sizeof(MBENC_CURBE_CM_FEI),
5711 m_feiMbEncCurbeNormalIField,
5712 sizeof(MBENC_CURBE_CM_FEI)));
5713 }
5714 break;
5715
5716 case P_TYPE:
5717 if (framePicture)
5718 {
5719 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5720 &cmd,
5721 sizeof(MBENC_CURBE_CM_FEI),
5722 m_feiMbEncCurbeNormalPFrame,
5723 sizeof(MBENC_CURBE_CM_FEI)));
5724 }
5725 else
5726 {
5727 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5728 &cmd,
5729 sizeof(MBENC_CURBE_CM_FEI),
5730 m_feiMbEncCurbeNormalPfield,
5731 sizeof(MBENC_CURBE_CM_FEI)));
5732 }
5733 break;
5734
5735 case B_TYPE:
5736 if (framePicture)
5737 {
5738 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5739 &cmd,
5740 sizeof(MBENC_CURBE_CM_FEI),
5741 m_feiMbEncCurbeNormalBFrame,
5742 sizeof(MBENC_CURBE_CM_FEI)));
5743 }
5744 else
5745 {
5746 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5747 &cmd,
5748 sizeof(MBENC_CURBE_CM_FEI),
5749 m_feiMbEncCurbeNormalBField,
5750 sizeof(MBENC_CURBE_CM_FEI)));
5751 }
5752 break;
5753
5754 default:
5755 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture coding type.");
5756 eStatus = MOS_STATUS_UNKNOWN;
5757 return eStatus;
5758 }
5759 }
5760 auto feiPicParams = (CodecEncodeAvcFeiPicParams *)(m_avcFeiPicParams);
5761 uint8_t ucMeMethod = (feiPicParams->SearchWindow == 5) || (feiPicParams->SearchWindow == 8) ? 4 : 6; // 4 means full search, 6 means diamand search
5762 uint32_t refWidth = feiPicParams->RefWidth;
5763 uint32_t refHeight = feiPicParams->RefHeight;
5764 uint32_t lenSP = feiPicParams->LenSP;
5765 switch (feiPicParams->SearchWindow)
5766 {
5767 case 0:
5768 // not use predefined search window
5769 if((feiPicParams->SearchPath != 0) && (feiPicParams->SearchPath != 1) && (feiPicParams->SearchPath != 2))
5770 {
5771 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC input SearchPath for SearchWindow=0 case!!!.");
5772 eStatus = MOS_STATUS_INVALID_PARAMETER;
5773 return eStatus;
5774 }
5775 ucMeMethod = (feiPicParams->SearchPath == 1) ? 6 : 4; // 4 means full search, 6 means diamand search
5776 if(((refWidth * refHeight) > 2048) || (refWidth > 64) || (refHeight > 64))
5777 {
5778 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC input refWidth/refHeight size for SearchWindow=0 case!!!.");
5779 eStatus = MOS_STATUS_INVALID_PARAMETER;
5780 return eStatus;
5781 }
5782 break;
5783 case 1:
5784 // Tiny SUs 24x24 window
5785 refWidth = 24;
5786 refHeight = 24;
5787 lenSP = 4;
5788 break;
5789 case 2:
5790 // Small SUs 28x28 window
5791 refWidth = 28;
5792 refHeight = 28;
5793 lenSP = 9;
5794 break;
5795 case 3:
5796 // Diamond SUs 48x40 window
5797 refWidth = 48;
5798 refHeight = 40;
5799 lenSP = 16;
5800 break;
5801 case 4:
5802 // Large Diamond SUs 48x40 window
5803 refWidth = 48;
5804 refHeight = 40;
5805 lenSP = 32;
5806 break;
5807 case 5:
5808 // Exhaustive SUs 48x40 window
5809 refWidth = 48;
5810 refHeight = 40;
5811 lenSP = 48;
5812 break;
5813 case 6:
5814 // Diamond SUs 64x32 window
5815 refWidth = 64;
5816 refHeight = 32;
5817 lenSP = 16;
5818 break;
5819 case 7:
5820 // Large Diamond SUs 64x32 window
5821 refWidth = 64;
5822 refHeight = 32;
5823 lenSP = 32;
5824 break;
5825 case 8:
5826 // Exhaustive SUs 64x32 window
5827 refWidth = 64;
5828 refHeight = 32;
5829 lenSP = 48;
5830 break;
5831 default:
5832 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI MB ENC SearchWindow value!!!.");
5833 eStatus = MOS_STATUS_INVALID_PARAMETER;
5834 return eStatus;
5835 }
5836
5837 if((m_pictureCodingType == B_TYPE) && (cmd.DW3.BMEDisableFBR == 0))
5838 {
5839 if(refWidth > 32)
5840 {
5841 refWidth = 32;
5842 }
5843 if(refHeight > 32)
5844 {
5845 refHeight = 32;
5846 }
5847 }
5848
5849 // r1
5850 cmd.DW0.AdaptiveEn =
5851 cmd.DW37.AdaptiveEn = feiPicParams->AdaptiveSearch;
5852 cmd.DW0.T8x8FlagForInterEn =
5853 cmd.DW37.T8x8FlagForInterEn = picParams->transform_8x8_mode_flag;
5854 cmd.DW2.LenSP = lenSP;
5855 cmd.DW38.LenSP = 0; // MBZ
5856 cmd.DW2.MaxNumSU = cmd.DW38.MaxNumSU = 57;
5857 cmd.DW3.SrcAccess =
5858 cmd.DW3.RefAccess = framePicture ? 0 : 1;
5859 if (m_pictureCodingType != I_TYPE && bFTQEnable)
5860 {
5861 if (m_pictureCodingType == P_TYPE)
5862 {
5863 cmd.DW3.FTEnable = FTQBasedSkip[seqParams->TargetUsage] & 0x01;
5864 }
5865 else // B_TYPE
5866 {
5867 cmd.DW3.FTEnable = (FTQBasedSkip[seqParams->TargetUsage] >> 1) & 0x01;
5868 }
5869 }
5870 else
5871 {
5872 cmd.DW3.FTEnable = 0;
5873 }
5874
5875 cmd.DW2.PicWidth = params->wPicWidthInMb;
5876 cmd.DW3.SubMbPartMask = feiPicParams->SubMBPartMask;
5877 cmd.DW3.SubPelMode = feiPicParams->SubPelMode;
5878 cmd.DW3.InterSAD = feiPicParams->InterSAD;
5879 cmd.DW3.IntraSAD = feiPicParams->IntraSAD;
5880 cmd.DW3.SearchCtrl = (m_pictureCodingType == B_TYPE) ? 7 : 0;
5881 cmd.DW4.PicHeightMinus1 = params->wFieldFrameHeightInMb - 1;
5882 cmd.DW4.TrueDistortionEnable = feiPicParams->DistortionType == 0 ? 1 : 0;
5883
5884 bool bottomField = CodecHal_PictureIsBottomField(picParams->CurrOriginalPic);
5885 cmd.DW4.FieldParityFlag =
5886 cmd.DW7.SrcFieldPolarity = bottomField ? 1 : 0;
5887 cmd.DW4.bCurFldIDR = framePicture ? 0 : (picParams->bIdrPic || m_firstFieldIdrPic);
5888 cmd.DW4.ConstrainedIntraPredFlag = picParams->constrained_intra_pred_flag;
5889 cmd.DW4.HMEEnable = m_hmeEnabled;
5890 cmd.DW4.PictureType = m_pictureCodingType - 1;
5891 cmd.DW4.UseActualRefQPValue = m_hmeEnabled ? (MRDisableQPCheck[seqParams->TargetUsage] == 0) : false;
5892 cmd.DW4.FEIEnable = 1;
5893 cmd.DW4.MultipleMVPredictorPerMBEnable = feiPicParams->MVPredictorEnable;
5894 cmd.DW4.VMEDistortionOutputEnable = feiPicParams->DistortionEnable;
5895 cmd.DW4.PerMBQpEnable = feiPicParams->bMBQp;
5896 cmd.DW4.MBInputEnable = feiPicParams->bPerMBInput;
5897 cmd.DW4.HMEEnable = 0;
5898 cmd.DW5.SliceMbHeight = params->usSliceHeight;
5899 cmd.DW7.IntraPartMask = feiPicParams->IntraPartMask;
5900
5901 // r2
5902 if (params->bMbEncIFrameDistEnabled)
5903 {
5904 cmd.DW6.BatchBufferEnd = 0;
5905 }
5906 else
5907 {
5908 uint8_t tableIdx = m_pictureCodingType - 1;
5909 eStatus = MOS_SecureMemcpy(&(cmd.ModeMvCost), 8 * sizeof(uint32_t), ModeMvCost_Cm[tableIdx][sliceQP], 8 * sizeof(uint32_t));
5910 if (eStatus != MOS_STATUS_SUCCESS)
5911 {
5912 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
5913 return eStatus;
5914 }
5915
5916 if (m_pictureCodingType == I_TYPE && bOldModeCostEnable)
5917 {
5918 // Old intra mode cost needs to be used if bOldModeCostEnable is 1
5919 cmd.ModeMvCost.DW8.Value = OldIntraModeCost_Cm_Common[sliceQP];
5920 }
5921 else if (m_skipBiasAdjustmentEnable)
5922 {
5923 // Load different MvCost for P picture when SkipBiasAdjustment is enabled
5924 // No need to check for P picture as the flag is only enabled for P picture
5925 cmd.ModeMvCost.DW11.Value = MvCost_PSkipAdjustment_Cm_Common[sliceQP];
5926 }
5927 }
5928
5929 // r3 & r4
5930 if (params->bMbEncIFrameDistEnabled)
5931 {
5932 cmd.SPDelta.DW31.IntraComputeType = 1;
5933 }
5934 else
5935 {
5936 uint8_t tableIdx = (m_pictureCodingType == B_TYPE) ? 1 : 0;
5937 eStatus = MOS_SecureMemcpy(&(cmd.SPDelta), 16 * sizeof(uint32_t), CodechalEncoderState::m_encodeSearchPath[tableIdx][ucMeMethod], 16 * sizeof(uint32_t));
5938 if (eStatus != MOS_STATUS_SUCCESS)
5939 {
5940 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
5941 return eStatus;
5942 }
5943 }
5944
5945 // r5
5946 if (m_pictureCodingType == P_TYPE)
5947 {
5948 cmd.DW32.SkipVal = SkipVal_P_Common
5949 [cmd.DW3.BlockBasedSkipEnable]
5950 [picParams->transform_8x8_mode_flag]
5951 [sliceQP];
5952 }
5953 else if (m_pictureCodingType == B_TYPE)
5954 {
5955 cmd.DW32.SkipVal = SkipVal_B_Common
5956 [cmd.DW3.BlockBasedSkipEnable]
5957 [picParams->transform_8x8_mode_flag]
5958 [sliceQP];
5959 }
5960
5961 cmd.ModeMvCost.DW13.QpPrimeY = sliceQP;
5962 // QpPrimeCb and QpPrimeCr are not used by Kernel. Following settings are for CModel matching.
5963 cmd.ModeMvCost.DW13.QpPrimeCb = sliceQP;
5964 cmd.ModeMvCost.DW13.QpPrimeCr = sliceQP;
5965 cmd.ModeMvCost.DW13.TargetSizeInWord = 0xff; // hardcoded for BRC disabled
5966
5967 if (bMultiPredEnable && (m_pictureCodingType != I_TYPE))
5968 {
5969 cmd.DW32.MultiPredL0Disable = feiPicParams->MultiPredL0 ? CODECHAL_ENCODE_AVC_MULTIPRED_ENABLE : CODECHAL_ENCODE_AVC_MULTIPRED_DISABLE;
5970 cmd.DW32.MultiPredL1Disable = (m_pictureCodingType == B_TYPE && feiPicParams->MultiPredL1) ? CODECHAL_ENCODE_AVC_MULTIPRED_ENABLE : CODECHAL_ENCODE_AVC_MULTIPRED_DISABLE;
5971 }
5972 else
5973 {
5974 cmd.DW32.MultiPredL0Disable = CODECHAL_ENCODE_AVC_MULTIPRED_DISABLE;
5975 cmd.DW32.MultiPredL1Disable = CODECHAL_ENCODE_AVC_MULTIPRED_DISABLE;
5976 }
5977
5978 if (!framePicture)
5979 {
5980 if (m_pictureCodingType != I_TYPE)
5981 {
5982 cmd.DW34.List0RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_0);
5983 cmd.DW34.List0RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_1);
5984 cmd.DW34.List0RefID2FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_2);
5985 cmd.DW34.List0RefID3FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_3);
5986 cmd.DW34.List0RefID4FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_4);
5987 cmd.DW34.List0RefID5FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_5);
5988 cmd.DW34.List0RefID6FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_6);
5989 cmd.DW34.List0RefID7FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_7);
5990 }
5991 if (m_pictureCodingType == B_TYPE)
5992 {
5993 cmd.DW34.List1RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_0);
5994 cmd.DW34.List1RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_1);
5995 }
5996 }
5997
5998 if (m_pictureCodingType == B_TYPE)
5999 {
6000 cmd.DW34.List1RefID0FrameFieldFlag = GetRefPicFieldFlag(params, LIST_1, CODECHAL_ENCODE_REF_ID_0);
6001 cmd.DW34.List1RefID1FrameFieldFlag = GetRefPicFieldFlag(params, LIST_1, CODECHAL_ENCODE_REF_ID_1);
6002 cmd.DW34.bDirectMode = slcParams->direct_spatial_mv_pred_flag;
6003 }
6004 cmd.DW34.bOriginalBff = framePicture ? 0 :
6005 ((m_firstField && (bottomField)) || (!m_firstField && (!bottomField)));
6006 cmd.DW34.EnableMBFlatnessChkOptimization = m_flatnessCheckEnabled;
6007 cmd.DW34.ROIEnableFlag = params->bRoiEnabled;
6008 cmd.DW34.MADEnableFlag = m_madEnabled;
6009 cmd.DW34.MBBrcEnable = 0;
6010 cmd.DW36.CheckAllFractionalEnable = bCAFEnable;
6011 cmd.DW38.RefThreshold = m_refThreshold;
6012 cmd.DW39.HMERefWindowsCombThreshold = (m_pictureCodingType == B_TYPE) ?
6013 HMEBCombineLen[seqParams->TargetUsage] : HMECombineLen[seqParams->TargetUsage];
6014
6015 // Those fields are not really used for I_dist kernel,
6016 // but set them to 0 to get bit-exact match with kernel prototype
6017 if (params->bMbEncIFrameDistEnabled)
6018 {
6019 cmd.ModeMvCost.DW13.QpPrimeY = 0;
6020 cmd.ModeMvCost.DW13.QpPrimeCb = 0;
6021 cmd.ModeMvCost.DW13.QpPrimeCr = 0;
6022 cmd.DW33.Intra16x16NonDCPredPenalty = 0;
6023 cmd.DW33.Intra4x4NonDCPredPenalty = 0;
6024 cmd.DW33.Intra8x8NonDCPredPenalty = 0;
6025 }
6026
6027 //r6
6028 if (cmd.DW4.UseActualRefQPValue)
6029 {
6030 cmd.DW44.ActualQPValueForRefID0List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_0);
6031 cmd.DW44.ActualQPValueForRefID1List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_1);
6032 cmd.DW44.ActualQPValueForRefID2List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_2);
6033 cmd.DW44.ActualQPValueForRefID3List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_3);
6034 cmd.DW45.ActualQPValueForRefID4List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_4);
6035 cmd.DW45.ActualQPValueForRefID5List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_5);
6036 cmd.DW45.ActualQPValueForRefID6List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_6);
6037 cmd.DW45.ActualQPValueForRefID7List0 = AVCGetQPValueFromRefList(params, LIST_0, CODECHAL_ENCODE_REF_ID_7);
6038 cmd.DW46.ActualQPValueForRefID0List1 = AVCGetQPValueFromRefList(params, LIST_1, CODECHAL_ENCODE_REF_ID_0);
6039 cmd.DW46.ActualQPValueForRefID1List1 = AVCGetQPValueFromRefList(params, LIST_1, CODECHAL_ENCODE_REF_ID_1);
6040 }
6041
6042 uint8_t tableIdx = m_pictureCodingType - 1;
6043 cmd.DW46.RefCost = RefCost_MultiRefQp[tableIdx][sliceQP];
6044
6045 cmd.DW34.NumMVPredictorsL1 = 0;
6046 // Picture Coding Type dependent parameters
6047 if (m_pictureCodingType == I_TYPE)
6048 {
6049 cmd.DW0.SkipModeEn = 0;
6050 cmd.DW37.SkipModeEn = 0;
6051 cmd.DW36.HMECombineOverlap = 0;
6052 cmd.DW36.CheckAllFractionalEnable = 0;
6053 cmd.DW47.IntraCostSF = 16; // This is not used but recommended to set this to 16 by Kernel team
6054 }
6055 else if (m_pictureCodingType == P_TYPE)
6056 {
6057 cmd.DW1.MaxNumMVs = GetMaxMvsPer2Mb(seqParams->Level) / 2;
6058 cmd.DW3.BMEDisableFBR = 1;
6059 cmd.DW5.RefWidth = cmd.DW39.RefWidth = refWidth;
6060 cmd.DW5.RefHeight = cmd.DW39.RefHeight = refHeight;
6061 cmd.DW7.NonSkipZMvAdded = 1;
6062 cmd.DW7.NonSkipModeAdded = 1;
6063 cmd.DW7.SkipCenterMask = 1;
6064 cmd.DW47.IntraCostSF =
6065 bAdaptiveIntraScalingEnable ?
6066 AdaptiveIntraScalingFactor_Cm_Common[sliceQP] :
6067 IntraScalingFactor_Cm_Common[sliceQP];
6068 cmd.DW47.MaxVmvR = (framePicture) ? CodecHalAvcEncode_GetMaxMvLen(seqParams->Level) * 4 : (CodecHalAvcEncode_GetMaxMvLen(seqParams->Level) >> 1) * 4;
6069 cmd.DW36.HMECombineOverlap = 1;
6070 cmd.DW36.NumRefIdxL0MinusOne = bMultiPredEnable ? slcParams->num_ref_idx_l0_active_minus1 : 0;
6071 cmd.DW36.NumMVPredictors = feiPicParams->NumMVPredictorsL0;
6072 cmd.DW34.NumMVPredictorsL1 = 0;
6073 cmd.DW36.CheckAllFractionalEnable = feiPicParams->RepartitionCheckEnable;
6074 }
6075 else
6076 {
6077 // B_TYPE
6078 cmd.DW1.MaxNumMVs = GetMaxMvsPer2Mb(seqParams->Level) / 2;
6079 cmd.DW1.BiWeight = m_biWeight;
6080 cmd.DW3.SkipType = 1;
6081 cmd.DW5.RefWidth = cmd.DW39.RefWidth = refWidth;
6082 cmd.DW5.RefHeight = cmd.DW39.RefHeight = refHeight;
6083 cmd.DW7.SkipCenterMask = 0xFF;
6084 cmd.DW47.IntraCostSF =
6085 bAdaptiveIntraScalingEnable ?
6086 AdaptiveIntraScalingFactor_Cm_Common[sliceQP] :
6087 IntraScalingFactor_Cm_Common[sliceQP];
6088 cmd.DW47.MaxVmvR = (framePicture) ? CodecHalAvcEncode_GetMaxMvLen(seqParams->Level) * 4 : (CodecHalAvcEncode_GetMaxMvLen(seqParams->Level) >> 1) * 4;
6089 cmd.DW36.HMECombineOverlap = 1;
6090 // Checking if the forward frame (List 1 index 0) is a short term reference
6091 {
6092 auto codecHalPic = params->pSlcParams->RefPicList[LIST_1][0];
6093 if (codecHalPic.PicFlags != PICTURE_INVALID &&
6094 codecHalPic.FrameIdx != CODECHAL_ENCODE_AVC_INVALID_PIC_ID &&
6095 params->pPicIdx[codecHalPic.FrameIdx].bValid)
6096 {
6097 // Although its name is FWD, it actually means the future frame or the backward reference frame
6098 cmd.DW36.IsFwdFrameShortTermRef = CodecHal_PictureIsShortTermRef(params->pPicParams->RefFrameList[codecHalPic.FrameIdx]);
6099 }
6100 else
6101 {
6102 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid backward reference frame.");
6103 eStatus = MOS_STATUS_INVALID_PARAMETER;
6104 return eStatus;
6105 }
6106 }
6107 cmd.DW36.NumRefIdxL0MinusOne = bMultiPredEnable ? slcParams->num_ref_idx_l0_active_minus1 : 0;
6108 cmd.DW36.NumRefIdxL1MinusOne = bMultiPredEnable ? slcParams->num_ref_idx_l1_active_minus1 : 0;
6109 cmd.DW36.NumMVPredictors = feiPicParams->NumMVPredictorsL0;
6110 cmd.DW34.NumMVPredictorsL1 = feiPicParams->NumMVPredictorsL1;
6111 cmd.DW36.CheckAllFractionalEnable = feiPicParams->RepartitionCheckEnable;
6112 cmd.DW40.DistScaleFactorRefID0List0 = m_distScaleFactorList0[0];
6113 cmd.DW40.DistScaleFactorRefID1List0 = m_distScaleFactorList0[1];
6114 cmd.DW41.DistScaleFactorRefID2List0 = m_distScaleFactorList0[2];
6115 cmd.DW41.DistScaleFactorRefID3List0 = m_distScaleFactorList0[3];
6116 cmd.DW42.DistScaleFactorRefID4List0 = m_distScaleFactorList0[4];
6117 cmd.DW42.DistScaleFactorRefID5List0 = m_distScaleFactorList0[5];
6118 cmd.DW43.DistScaleFactorRefID6List0 = m_distScaleFactorList0[6];
6119 cmd.DW43.DistScaleFactorRefID7List0 = m_distScaleFactorList0[7];
6120 {
6121 CODEC_PICTURE refPic;
6122 refPic = slcParams->RefPicList[LIST_1][0];
6123 cmd.DW63.L1ListRef0PictureCodingType = m_refList[m_picIdx[refPic.FrameIdx].ucPicIdx]->ucAvcPictureCodingType;
6124 if(framePicture && ((cmd.DW63.L1ListRef0PictureCodingType == CODEC_AVC_PIC_CODING_TYPE_TFF_FIELD) || (cmd.DW63.L1ListRef0PictureCodingType == CODEC_AVC_PIC_CODING_TYPE_BFF_FIELD)))
6125 {
6126 uint16_t fieldHeightInMb = (params->wFieldFrameHeightInMb + 1) >> 1;
6127 cmd.DW64.BottomFieldOffsetL1ListRef0MV = MOS_ALIGN_CEIL(fieldHeightInMb * params->wPicWidthInMb * (32 * 4), 0x1000);
6128 cmd.DW65.BottomFieldOffsetL1ListRef0MBCode = fieldHeightInMb * params->wPicWidthInMb * 64;
6129 }
6130 }
6131 }
6132
6133 *params->pdwBlockBasedSkipEn = cmd.DW3.BlockBasedSkipEnable;
6134
6135 if (picParams->EnableRollingIntraRefresh)
6136 {
6137 /* Multiple predictor should be completely disabled for the RollingI feature. This does not lead to much quality drop for P frames especially for TU as 1 */
6138 cmd.DW32.MultiPredL0Disable = CODECHAL_ENCODE_AVC_MULTIPRED_DISABLE;
6139
6140 /* Pass the same IntraRefreshUnit to the kernel w/o the adjustment by -1, so as to have an overlap of one MB row or column of Intra macroblocks
6141 across one P frame to another P frame, as needed by the RollingI algo */
6142 cmd.DW48.IntraRefreshMBNum = picParams->IntraRefreshMBNum; /* MB row or column number */
6143 cmd.DW48.IntraRefreshUnitInMBMinus1 = picParams->IntraRefreshUnitinMB;
6144 cmd.DW48.IntraRefreshQPDelta = picParams->IntraRefreshQPDelta;
6145 }
6146
6147 if (true == params->bRoiEnabled)
6148 {
6149 cmd.DW49.ROI1_X_left = picParams->ROI[0].Left;
6150 cmd.DW49.ROI1_Y_top = picParams->ROI[0].Top;
6151 cmd.DW50.ROI1_X_right = picParams->ROI[0].Right;
6152 cmd.DW50.ROI1_Y_bottom = picParams->ROI[0].Bottom;
6153
6154 cmd.DW51.ROI2_X_left = picParams->ROI[1].Left;
6155 cmd.DW51.ROI2_Y_top = picParams->ROI[1].Top;
6156 cmd.DW52.ROI2_X_right = picParams->ROI[1].Right;
6157 cmd.DW52.ROI2_Y_bottom = picParams->ROI[1].Bottom;
6158
6159 cmd.DW53.ROI3_X_left = picParams->ROI[2].Left;
6160 cmd.DW53.ROI3_Y_top = picParams->ROI[2].Top;
6161 cmd.DW54.ROI3_X_right = picParams->ROI[2].Right;
6162 cmd.DW54.ROI3_Y_bottom = picParams->ROI[2].Bottom;
6163
6164 cmd.DW55.ROI4_X_left = picParams->ROI[3].Left;
6165 cmd.DW55.ROI4_Y_top = picParams->ROI[3].Top;
6166 cmd.DW56.ROI4_X_right = picParams->ROI[3].Right;
6167 cmd.DW56.ROI4_Y_bottom = picParams->ROI[3].Bottom;
6168
6169 if (bBrcEnabled == false)
6170 {
6171 uint16_t numROI = picParams->NumROI;
6172 char priorityLevelOrDQp[CODECHAL_ENCODE_AVC_MAX_ROI_NUMBER] = { 0 };
6173
6174 // cqp case
6175 for (unsigned int i = 0; i < numROI; i += 1)
6176 {
6177 char dQpRoi = picParams->ROI[i].PriorityLevelOrDQp;
6178
6179 // clip qp roi in order to have (qp + qpY) in range [0, 51]
6180 priorityLevelOrDQp[i] = (char)CodecHal_Clip3(-sliceQP, CODECHAL_ENCODE_AVC_MAX_SLICE_QP - sliceQP, dQpRoi);
6181 }
6182
6183 cmd.DW57.ROI1_dQpPrimeY = priorityLevelOrDQp[0];
6184 cmd.DW57.ROI2_dQpPrimeY = priorityLevelOrDQp[1];
6185 cmd.DW57.ROI3_dQpPrimeY = priorityLevelOrDQp[2];
6186 cmd.DW57.ROI4_dQpPrimeY = priorityLevelOrDQp[3];
6187 }
6188 else
6189 {
6190 // kernel does not support BRC case
6191 cmd.DW34.ROIEnableFlag = 0;
6192 }
6193 }
6194 //older isa curbe length is 236, new is 252
6195 if(params->pCurbeBinary)
6196 {
6197 MOS_SecureMemcpy(params->pCurbeBinary,m_feiMBEncCurbeDataSizeExcludeSurfaceIdx,&cmd,m_feiMBEncCurbeDataSizeExcludeSurfaceIdx);
6198 return eStatus;
6199 }
6200 //IPCM QP and threshold
6201 cmd.DW59.IPCM_QP0 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[0].QP;
6202 cmd.DW59.IPCM_QP1 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[1].QP;
6203 cmd.DW59.IPCM_QP2 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[2].QP;
6204 cmd.DW59.IPCM_QP3 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[3].QP;
6205 cmd.DW60.IPCM_QP4 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[4].QP;
6206 cmd.DW60.IPCM_Thresh0 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[0].Threshold;
6207 cmd.DW61.IPCM_Thresh1 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[1].Threshold;
6208 cmd.DW61.IPCM_Thresh2 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[2].Threshold;
6209 cmd.DW62.IPCM_Thresh3 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[3].Threshold;
6210 cmd.DW62.IPCM_Thresh4 = g_cInit_CODECHAL_ENCODE_AVC_IPCM_Threshold_Table_G8[4].Threshold;
6211
6212 cmd.DW66.MBDataSurfIndex = MBENC_MFC_AVC_PAK_OBJ_CM_FEI;
6213 cmd.DW67.MVDataSurfIndex = MBENC_IND_MV_DATA_CM_FEI;
6214 cmd.DW68.IDistSurfIndex = MBENC_BRC_DISTORTION_CM_FEI;
6215 cmd.DW69.SrcYSurfIndex = MBENC_CURR_Y_CM_FEI;
6216 cmd.DW70.MBSpecificDataSurfIndex = MBENC_MB_SPECIFIC_DATA_CM_FEI;
6217 cmd.DW71.AuxVmeOutSurfIndex = MBENC_AUX_VME_OUT_CM_FEI;
6218 cmd.DW72.CurrRefPicSelSurfIndex = MBENC_REFPICSELECT_L0_CM_FEI;
6219 cmd.DW73.HMEMVPredFwdBwdSurfIndex = MBENC_MV_DATA_FROM_ME_CM_FEI;
6220 cmd.DW74.HMEDistSurfIndex = MBENC_4xME_DISTORTION_CM_FEI;
6221 cmd.DW75.RefPicSelectL1SurfIndex = MBENC_REFPICSELECT_L1_CM_FEI;
6222 cmd.DW76.FwdFrmMBDataSurfIndex = MBENC_FWD_MB_DATA_CM_FEI;
6223 cmd.DW77.FwdFrmMVSurfIndex = MBENC_FWD_MV_DATA_CM_FEI;
6224 cmd.DW78.MBQPBuffer = MBENC_MBQP_CM_FEI;
6225 cmd.DW79.MBBRCLut = MBENC_MBBRC_CONST_DATA_CM_FEI;
6226 cmd.DW80.VMEInterPredictionSurfIndex = MBENC_VME_INTER_PRED_CURR_PIC_IDX_0_CM_FEI;
6227 cmd.DW81.VMEInterPredictionMRSurfIndex = MBENC_VME_INTER_PRED_CURR_PIC_IDX_1_CM_FEI;
6228 cmd.DW82.FlatnessChkSurfIndex = MBENC_FLATNESS_CHECK_CM_FEI;
6229 cmd.DW83.MADSurfIndex = MBENC_MAD_DATA_CM_FEI;
6230 cmd.DW84.InterDistortionSurfIndex = MBENC_INTER_DISTORTION_CM_FEI;
6231 cmd.DW86.BRCCurbeSurfIndex = MBENC_BRC_CURBE_DATA_CM_FEI;
6232 cmd.DW87.MvPredictorSurfIndex = MBENC_MV_PREDICTOR_CM_FEI;
6233
6234 CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
6235 &cmd,
6236 params->pKernelState->dwCurbeOffset,
6237 sizeof(cmd)));
6238
6239 return eStatus;
6240
6241 }
6242
6243 MOS_STATUS CodechalEncodeAvcEncFeiG8::SetCurbeAvcPreProc(PCODECHAL_ENCODE_AVC_PREPROC_CURBE_PARAMS params)
6244 {
6245 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6246
6247 CODECHAL_ENCODE_FUNCTION_ENTER;
6248
6249 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
6250 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPreEncParams);
6251
6252 auto preEncParams = params->pPreEncParams;
6253
6254 uint32_t sliceQp = preEncParams->dwFrameQp;
6255 bool framePicture = CodecHal_PictureIsFrame(m_currOriginalPic);
6256 bool bottomField = CodecHal_PictureIsBottomField(m_currOriginalPic);
6257 PREPROC_CURBE_CM cmd;
6258 switch (m_pictureCodingType)
6259 {
6260 case I_TYPE:
6261 if (framePicture)
6262 {
6263 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6264 &cmd,
6265 sizeof(PREPROC_CURBE_CM),
6266 m_preProcCurbeCmNormalIFrame,
6267 sizeof(PREPROC_CURBE_CM)));
6268 }
6269 else
6270 {
6271 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6272 &cmd,
6273 sizeof(PREPROC_CURBE_CM),
6274 m_preProcCurbeCmNormalIfield,
6275 sizeof(PREPROC_CURBE_CM)));
6276 }
6277 break;
6278
6279 case P_TYPE:
6280 if (framePicture)
6281 {
6282 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6283 &cmd,
6284 sizeof(PREPROC_CURBE_CM),
6285 m_preProcCurbeCmNormalPFrame,
6286 sizeof(PREPROC_CURBE_CM)));
6287 }
6288 else
6289 {
6290 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6291 &cmd,
6292 sizeof(PREPROC_CURBE_CM),
6293 m_preProcCurbeCmNormalPField,
6294 sizeof(PREPROC_CURBE_CM)));
6295 }
6296 break;
6297
6298 case B_TYPE:
6299 if (framePicture)
6300 {
6301 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6302 &cmd,
6303 sizeof(PREPROC_CURBE_CM),
6304 m_preProcCurbeCmNormalBFrame,
6305 sizeof(PREPROC_CURBE_CM)));
6306 }
6307 else
6308 {
6309 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
6310 &cmd,
6311 sizeof(PREPROC_CURBE_CM),
6312 m_preProcCurbeCmNormalBField,
6313 sizeof(PREPROC_CURBE_CM)));
6314 }
6315 break;
6316
6317 default:
6318 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture coding type.");
6319 eStatus = MOS_STATUS_UNKNOWN;
6320 return eStatus;
6321 }
6322
6323 uint8_t meMethod = (preEncParams->dwSearchWindow == 5) || (preEncParams->dwSearchWindow == 8) ? 4 : 6; // 4 means full search, 6 means diamand search
6324 uint32_t refWidth = preEncParams->dwRefWidth;
6325 uint32_t refHeight = preEncParams->dwRefHeight;
6326 uint32_t lenSP = preEncParams->dwLenSP;
6327 switch (preEncParams->dwSearchWindow)
6328 {
6329 case 0:
6330 // not use predefined search window and search patch
6331 if ((preEncParams->dwSearchPath != 0) && (preEncParams->dwSearchPath != 1) && (preEncParams->dwSearchPath != 2))
6332 {
6333 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI PREENC input SearchPath for SearchWindow=0 case!!!.");
6334 eStatus = MOS_STATUS_INVALID_PARAMETER;
6335 return eStatus;
6336 }
6337 meMethod = (preEncParams->dwSearchPath == 1) ? 6 : 4; // 4 means full search, 6 means diamand search
6338 if (((refWidth * refHeight) > 2048) || (refWidth > 64) || (refHeight > 64))
6339 {
6340 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI PREENC PreProc input refWidth/refHeight size for SearchWindow=0 case!!!.");
6341 eStatus = MOS_STATUS_INVALID_PARAMETER;
6342 return eStatus;
6343 }
6344 break;
6345 case 1:
6346 // Tiny 4 SUs 24x24 window
6347 refWidth = 24;
6348 refHeight = 24;
6349 lenSP = 4;
6350 break;
6351 case 2:
6352 // Small 9 SUs 28x28 window
6353 refWidth = 28;
6354 refHeight = 28;
6355 lenSP = 9;
6356 break;
6357 case 3:
6358 // Diamond 16 SUs 48x40 window
6359 refWidth = 48;
6360 refHeight = 40;
6361 lenSP = 16;
6362 break;
6363 case 4:
6364 // Large Diamond 32 SUs 48x40 window
6365 refWidth = 48;
6366 refHeight = 40;
6367 lenSP = 32;
6368 break;
6369 case 5:
6370 // Exhaustive 48 SUs 48x40 window
6371 refWidth = 48;
6372 refHeight = 40;
6373 lenSP = 48;
6374 break;
6375 case 6:
6376 // Diamond 16 SUs 64x32 window
6377 refWidth = 64;
6378 refHeight = 32;
6379 lenSP = 16;
6380 break;
6381 case 7:
6382 // Large Diamond 32 SUs 64x32 window
6383 refWidth = 64;
6384 refHeight = 32;
6385 lenSP = 32;
6386 break;
6387 case 8:
6388 // Exhaustive 48 SUs 64x32 window
6389 refWidth = 64;
6390 refHeight = 32;
6391 lenSP = 48;
6392 break;
6393 default:
6394 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture FEI PREENC PreProc SearchWindow value!!!.");
6395 eStatus = MOS_STATUS_INVALID_PARAMETER;
6396 return eStatus;
6397 }
6398
6399 // r1
6400 cmd.DW0.AdaptiveEn =
6401 cmd.DW37.AdaptiveEn = preEncParams->bAdaptiveSearch;
6402 cmd.DW2.LenSP = lenSP;
6403 cmd.DW38.LenSP = 0; // MBZ
6404 cmd.DW2.MaxNumSU = cmd.DW38.MaxNumSU = 57;
6405
6406 cmd.DW3.SrcAccess =
6407 cmd.DW3.RefAccess = framePicture ? 0 : 1;
6408
6409 if (m_pictureCodingType != I_TYPE && bFTQEnable)
6410 {
6411 cmd.DW3.FTEnable = preEncParams->bFTEnable;
6412 }
6413 else
6414 {
6415 cmd.DW3.FTEnable = 0;
6416 }
6417 cmd.DW3.SubMbPartMask = preEncParams->dwSubMBPartMask;
6418 cmd.DW3.SubPelMode = preEncParams->dwSubPelMode;
6419 cmd.DW3.IntraSAD = preEncParams->dwIntraSAD;
6420 cmd.DW3.InterSAD = preEncParams->dwInterSAD;
6421
6422 cmd.DW2.PicWidth = params->wPicWidthInMb;
6423 cmd.DW6.PicHeight = cmd.DW5.SliceMbHeight = params->wFieldFrameHeightInMb;
6424
6425 cmd.DW4.FieldParityFlag = cmd.DW4.CurrPicFieldParityFlag =
6426 cmd.DW7.SrcFieldPolarity = bottomField ? 1 : 0;
6427 cmd.DW4.HMEEnable = m_hmeEnabled;
6428 cmd.DW4.FrameQp = sliceQp;
6429 cmd.DW4.PerMBQpEnable = preEncParams->bMBQp;
6430 cmd.DW4.MultipleMVPredictorPerMBEnable = (m_pictureCodingType == I_TYPE) ? 0 : preEncParams->dwMVPredictorCtrl;
6431 cmd.DW4.DisableMvOutput = (m_pictureCodingType == I_TYPE) ? 1 : preEncParams->bDisableMVOutput;
6432 cmd.DW4.DisableMbStats = preEncParams->bDisableStatisticsOutput;
6433 cmd.DW4.FwdRefPicEnable = preEncParams->dwNumPastReferences > 0 ? 1 : 0;
6434 cmd.DW4.FwdRefPicFrameFieldFlag = CodecHal_PictureIsFrame(preEncParams->PastRefPicture) ? 0 : 1;
6435 cmd.DW4.FwdRefPicFieldParityFlag = CodecHal_PictureIsBottomField(preEncParams->PastRefPicture);
6436 cmd.DW4.BwdRefPicEnable = preEncParams->dwNumFutureReferences > 0 ? 1 : 0;
6437 cmd.DW4.BwdRefPicFrameFieldFlag = CodecHal_PictureIsFrame(preEncParams->FutureRefPicture) ? 0 : 1;
6438 cmd.DW4.BwdRefPicFieldParityFlag = CodecHal_PictureIsBottomField(preEncParams->FutureRefPicture);
6439 cmd.DW7.IntraPartMask = preEncParams->dwIntraPartMask;
6440
6441 uint8_t tableIdx = m_pictureCodingType - 1;
6442 eStatus = MOS_SecureMemcpy(&(cmd.ModeMvCost), 8 * sizeof(uint32_t), m_modeMvCost_Cm_PreProc[tableIdx][sliceQp], 8 * sizeof(uint32_t));
6443 if (eStatus != MOS_STATUS_SUCCESS)
6444 {
6445 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
6446 return eStatus;
6447 }
6448 cmd.ModeMvCost.DW8.Value = 0;
6449 cmd.ModeMvCost.DW9.Value = 0;
6450 cmd.ModeMvCost.DW10.Value = 0;
6451 cmd.ModeMvCost.DW11.Value = 0;
6452 cmd.ModeMvCost.DW12.Value = 0;
6453 cmd.ModeMvCost.DW13.Value = 0;
6454
6455 if (!framePicture && m_pictureCodingType != I_TYPE)
6456 {
6457 /* for field, R2.2 upper word should be set to zero for P and B frames */
6458 cmd.ModeMvCost.DW10.Value &= 0x0000FFFF;
6459 }
6460
6461 tableIdx = (m_pictureCodingType == B_TYPE) ? 1 : 0;
6462 eStatus = MOS_SecureMemcpy(&(cmd.SPDelta), 16 * sizeof(uint32_t), CodechalEncoderState::m_encodeSearchPath[tableIdx][meMethod], 16 * sizeof(uint32_t));
6463 if (eStatus != MOS_STATUS_SUCCESS)
6464 {
6465 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
6466 return eStatus;
6467 }
6468 // disable Intra Compute when disabling all mode in dwIntraPartMask
6469 if (preEncParams->dwIntraPartMask == 0x7)
6470 {
6471 cmd.SPDelta.DW31.IntraComputeType = 3;
6472 }
6473
6474 cmd.DW38.RefThreshold = m_refThreshold;
6475 cmd.DW39.HMERefWindowsCombThreshold = (m_pictureCodingType == B_TYPE) ?
6476 HMEBCombineLen[m_targetUsage] : HMECombineLen[m_targetUsage];
6477
6478 // Picture Coding Type dependent parameters
6479 if (m_pictureCodingType == I_TYPE)
6480 {
6481 cmd.DW0.SkipModeEn = 0;
6482 cmd.DW37.SkipModeEn = 0;
6483 cmd.DW36.HMECombineOverlap = 0;
6484 }
6485 else if (m_pictureCodingType == P_TYPE)
6486 {
6487 cmd.DW1.MaxNumMVs = GetMaxMvsPer2Mb(CODEC_AVC_LEVEL_52) / 2;
6488 cmd.DW3.BMEDisableFBR = 1;
6489 cmd.DW3.SearchCtrl = 0;
6490 cmd.DW5.RefWidth = cmd.DW39.RefWidth = refWidth;
6491 cmd.DW5.RefHeight = cmd.DW39.RefHeight = refHeight;
6492 cmd.DW7.NonSkipZMvAdded = 1;
6493 cmd.DW7.NonSkipModeAdded = 1;
6494 cmd.DW7.SkipCenterMask = 1;
6495 cmd.DW32.MaxVmvR = (framePicture) ? CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) * 4 : (CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) >> 1) * 4;
6496 cmd.DW36.HMECombineOverlap = 1;
6497 }
6498 else
6499 {
6500 // B_TYPE
6501 cmd.DW1.MaxNumMVs = GetMaxMvsPer2Mb(CODEC_AVC_LEVEL_52) / 2;
6502 cmd.DW3.SearchCtrl = 0;
6503 cmd.DW3.SkipType = 1;
6504 cmd.DW5.RefWidth = cmd.DW39.RefWidth = refWidth;
6505 cmd.DW5.RefHeight = cmd.DW39.RefHeight = refHeight;
6506 cmd.DW7.SkipCenterMask = 0xFF;
6507 cmd.DW32.MaxVmvR = (framePicture) ? CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) * 4 : (CodecHalAvcEncode_GetMaxMvLen(CODEC_AVC_LEVEL_52) >> 1) * 4;
6508 cmd.DW36.HMECombineOverlap = 1;
6509 }
6510 if(params->pCurbeBinary)
6511 {
6512 MOS_SecureMemcpy(params->pCurbeBinary,m_feiPreProcCurbeDataSize,&cmd,m_feiPreProcCurbeDataSize);
6513 return eStatus;
6514 }
6515
6516 cmd.DW40.CurrPicSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_CURR_Y_CM_G8;
6517 cmd.DW41.HMEMvDataSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_HME_MV_DATA_CM_G8;
6518 cmd.DW42.MvPredictorSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_MV_PREDICTOR_CM_G8;
6519 cmd.DW43.MbQpSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_MBQP_CM_G8;
6520 cmd.DW44.MvDataOutSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_MV_DATA_CM_G8;
6521 cmd.DW45.MbStatsOutSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_MB_STATS_CM_G8;
6522 if (framePicture)
6523 {
6524 cmd.DW46.VMEInterPredictionSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_0_CM_G8;
6525 cmd.DW47.VMEInterPredictionMRSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_VME_CURR_PIC_IDX_1_CM_G8;
6526 cmd.DW48.FtqLutSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_FTQ_LUT_CM_G8;
6527 }
6528 else
6529 {
6530 cmd.DW46.VMEInterPredictionSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_0_CM_G8;
6531 cmd.DW47.VMEInterPredictionMRSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_VME_FIELD_CURR_PIC_IDX_1_CM_G8;
6532 cmd.DW48.FtqLutSurfIndex = CODECHAL_ENCODE_AVC_PREPROC_FIELD_FTQ_LUT_CM_G8;
6533 }
6534
6535 CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
6536 &cmd,
6537 params->pKernelState->dwCurbeOffset,
6538 sizeof(cmd)));
6539
6540 return eStatus;
6541 }
6542
6543 MOS_STATUS CodechalEncodeAvcEncFeiG8::SendAvcPreProcSurfaces(PMOS_COMMAND_BUFFER cmdBuffer, PCODECHAL_ENCODE_AVC_PREPROC_SURFACE_PARAMS params)
6544 {
6545 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6546
6547 CODECHAL_ENCODE_FUNCTION_ENTER;
6548 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface);
6549 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface->GetOsInterface());
6550 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
6551 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
6552 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pCurrOriginalPic);
6553 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psCurrPicSurface);
6554
6555 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPreProcBindingTable);
6556 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
6557 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pPreEncParams);
6558
6559 auto kernelState = params->pKernelState;
6560
6561 auto preEncParams = (FeiPreEncParams*)params->pPreEncParams;
6562 auto avcPreProcBindingTable = params->pPreProcBindingTable;
6563
6564 bool currFieldPicture = CodecHal_PictureIsField(*(params->pCurrOriginalPic)) ? 1 : 0;
6565 bool currBottomField = CodecHal_PictureIsBottomField(*(params->pCurrOriginalPic)) ? 1 : 0;
6566
6567 uint8_t vDirection = (CodecHal_PictureIsFrame(*(params->pCurrOriginalPic))) ? CODECHAL_VDIRECTION_FRAME :
6568 (currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD;
6569
6570 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
6571 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6572 surfaceCodecParams.bIs2DSurface = true;
6573 surfaceCodecParams.bMediaBlockRW = true; // Use media block RW for DP 2D surface access
6574 surfaceCodecParams.bUseUVPlane = true;
6575 surfaceCodecParams.psSurface = params->psCurrPicSurface;
6576 surfaceCodecParams.dwOffset = 0;
6577 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
6578 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcCurrY;
6579 surfaceCodecParams.dwUVBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcCurrUV;
6580 surfaceCodecParams.dwVerticalLineStride = params->dwVerticalLineStride;
6581 surfaceCodecParams.dwVerticalLineStrideOffset = params->dwVerticalLineStrideOffset;
6582
6583 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6584 m_hwInterface,
6585 cmdBuffer,
6586 &surfaceCodecParams,
6587 kernelState));
6588
6589 // AVC_ME MV data buffer
6590 if (params->bHmeEnabled)
6591 {
6592 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps4xMeMvDataBuffer);
6593
6594 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6595 surfaceCodecParams.bIs2DSurface = true;
6596 surfaceCodecParams.bMediaBlockRW = true;
6597 surfaceCodecParams.psSurface = params->ps4xMeMvDataBuffer;
6598 surfaceCodecParams.dwOffset = params->dwMeMvBottomFieldOffset;
6599 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
6600 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcMVDataFromHME;
6601 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6602 m_hwInterface,
6603 cmdBuffer,
6604 &surfaceCodecParams,
6605 kernelState));
6606 }
6607
6608 if (preEncParams->dwMVPredictorCtrl)
6609 {
6610 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6611
6612 uint32_t size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 8;
6613 surfaceCodecParams.dwSize = size;
6614 surfaceCodecParams.presBuffer = &(preEncParams->resMvPredBuffer);
6615 surfaceCodecParams.dwOffset = 0;
6616 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
6617 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcMvPredictor;
6618 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6619 m_hwInterface,
6620 cmdBuffer,
6621 &surfaceCodecParams,
6622 kernelState));
6623 }
6624
6625 if (preEncParams->bMBQp)
6626 {
6627 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6628
6629 uint32_t size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb;
6630 surfaceCodecParams.dwSize = size;
6631 surfaceCodecParams.presBuffer = &(preEncParams->resMbQpBuffer);
6632 surfaceCodecParams.dwOffset = 0;
6633 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcMbQp;
6634 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6635 m_hwInterface,
6636 cmdBuffer,
6637 &surfaceCodecParams,
6638 kernelState));
6639
6640 // 16 DWs per QP value
6641 size = 16 * 52 * sizeof(uint32_t);
6642
6643 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6644 surfaceCodecParams.presBuffer = params->presFtqLutBuffer;
6645 surfaceCodecParams.dwSize = size;
6646 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ? avcPreProcBindingTable->dwAvcPreProcFtqLutField : avcPreProcBindingTable->dwAvcPreProcFtqLut;
6647 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6648 m_hwInterface,
6649 cmdBuffer,
6650 &surfaceCodecParams,
6651 kernelState));
6652
6653 }
6654
6655 if (!preEncParams->bDisableMVOutput)
6656 {
6657 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6658
6659 uint32_t size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 32 * 4;
6660 surfaceCodecParams.presBuffer = &(preEncParams->resMvBuffer);
6661 surfaceCodecParams.dwSize = size;
6662 surfaceCodecParams.dwOffset = 0;
6663 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
6664 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcMvDataOut;
6665 surfaceCodecParams.bRenderTarget = true;
6666 surfaceCodecParams.bIsWritable = true;
6667 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6668 m_hwInterface,
6669 cmdBuffer,
6670 &surfaceCodecParams,
6671 kernelState));
6672 }
6673
6674 if (!preEncParams->bDisableStatisticsOutput)
6675 {
6676 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6677
6678 uint32_t size = params->dwFrameWidthInMb * params->dwFrameFieldHeightInMb * 64;
6679 if (currBottomField)
6680 {
6681 surfaceCodecParams.presBuffer = &(preEncParams->resStatsBotFieldBuffer);
6682 }
6683 else
6684 {
6685 surfaceCodecParams.presBuffer = &(preEncParams->resStatsBuffer);
6686 }
6687 surfaceCodecParams.dwSize = size;
6688 surfaceCodecParams.dwOffset = params->dwMBVProcStatsBottomFieldOffset;
6689 surfaceCodecParams.bRenderTarget = true;
6690 surfaceCodecParams.bIsWritable = true;
6691 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcMbStatsOut;
6692 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6693 m_hwInterface,
6694 cmdBuffer,
6695 &surfaceCodecParams,
6696 kernelState));
6697 }
6698
6699 // Current Picture Y - VME
6700 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6701 surfaceCodecParams.bUseAdvState = true;
6702 surfaceCodecParams.psSurface = params->psCurrPicSurface;
6703 surfaceCodecParams.dwOffset = 0;
6704 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
6705 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ? avcPreProcBindingTable->dwAvcPreProcVMECurrPicField[0] : avcPreProcBindingTable->dwAvcPreProcVMECurrPicFrame[0];
6706 surfaceCodecParams.ucVDirection = vDirection;
6707
6708 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6709 m_hwInterface,
6710 cmdBuffer,
6711 &surfaceCodecParams,
6712 kernelState));
6713
6714 surfaceCodecParams.dwBindingTableOffset = currFieldPicture ? avcPreProcBindingTable->dwAvcPreProcVMECurrPicField[1] : avcPreProcBindingTable->dwAvcPreProcVMECurrPicFrame[1];
6715 surfaceCodecParams.ucVDirection = vDirection;
6716 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6717 m_hwInterface,
6718 cmdBuffer,
6719 &surfaceCodecParams,
6720 kernelState));
6721
6722 uint32_t refBindingTableOffset;
6723 if (preEncParams->dwNumPastReferences > 0)
6724 {
6725 auto refPic = preEncParams->PastRefPicture;
6726 uint8_t refPicIdx = refPic.FrameIdx;
6727 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
6728 uint8_t refVDirection;
6729 // Program the surface based on current picture's field/frame mode
6730 if (currFieldPicture) // if current picture is field
6731 {
6732 if (refBottomField)
6733 {
6734 refVDirection = CODECHAL_VDIRECTION_BOT_FIELD;
6735 }
6736 else
6737 {
6738 refVDirection = CODECHAL_VDIRECTION_TOP_FIELD;
6739 }
6740 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEFwdPicField[0];
6741 }
6742 else // if current picture is frame
6743 {
6744 refVDirection = CODECHAL_VDIRECTION_FRAME;
6745 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEFwdPicFrame;
6746 }
6747
6748 // Picture Y VME
6749 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6750 surfaceCodecParams.bUseAdvState = true;
6751 surfaceCodecParams.psSurface = &params->ppRefList[refPicIdx]->sRefBuffer;
6752 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
6753 surfaceCodecParams.ucVDirection = refVDirection;
6754 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
6755
6756 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6757 m_hwInterface,
6758 cmdBuffer,
6759 &surfaceCodecParams,
6760 kernelState));
6761
6762 if (currFieldPicture) // if current picture is field
6763 {
6764 surfaceCodecParams.dwBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEFwdPicField[1];
6765
6766 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6767 m_hwInterface,
6768 cmdBuffer,
6769 &surfaceCodecParams,
6770 kernelState));
6771 }
6772 }
6773
6774 if (preEncParams->dwNumFutureReferences > 0)
6775 {
6776 auto refPic = preEncParams->FutureRefPicture;
6777 uint8_t refPicIdx = refPic.FrameIdx;
6778 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
6779 uint8_t refVDirection;
6780
6781 // Program the surface based on current picture's field/frame mode
6782 if (currFieldPicture) // if current picture is field
6783 {
6784 if (refBottomField)
6785 {
6786 refVDirection = CODECHAL_VDIRECTION_BOT_FIELD;
6787 }
6788 else
6789 {
6790 refVDirection = CODECHAL_VDIRECTION_TOP_FIELD;
6791 }
6792 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEBwdPicField[0];
6793 }
6794 else // if current picture is frame
6795 {
6796 refVDirection = CODECHAL_VDIRECTION_FRAME;
6797 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEBwdPicFrame[0];
6798 }
6799
6800 // Picture Y VME
6801 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
6802 surfaceCodecParams.bUseAdvState = true;
6803 surfaceCodecParams.psSurface = &params->ppRefList[refPicIdx]->sRefBuffer;
6804 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
6805 surfaceCodecParams.ucVDirection = refVDirection;
6806 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
6807
6808 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6809 m_hwInterface,
6810 cmdBuffer,
6811 &surfaceCodecParams,
6812 kernelState));
6813
6814 if (currFieldPicture) // if current picture is field
6815 {
6816 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEBwdPicField[1];
6817 }
6818 else
6819 {
6820 refBindingTableOffset = avcPreProcBindingTable->dwAvcPreProcVMEBwdPicFrame[1];
6821 }
6822 surfaceCodecParams.dwBindingTableOffset = refBindingTableOffset;
6823
6824 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6825 m_hwInterface,
6826 cmdBuffer,
6827 &surfaceCodecParams,
6828 kernelState));
6829 }
6830
6831 return eStatus;
6832 }
6833
6834 void CodechalEncodeAvcEncFeiG8::UpdateSSDSliceCount()
6835 {
6836 CodechalEncodeAvcBase::UpdateSSDSliceCount();
6837
6838 uint32_t sliceCount;
6839 if (m_frameHeight * m_frameWidth >= 960*540)
6840 {
6841 sliceCount = 2;
6842 }
6843 else
6844 {
6845 sliceCount = 1;
6846 }
6847
6848 if (m_osInterface->pfnSetSliceCount)
6849 {
6850 m_osInterface->pfnSetSliceCount(m_osInterface, &sliceCount);
6851 }
6852 }
6853