Debian Codegraph @

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