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