1 /*
2 * Copyright (c) 2017, 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_encode_mpeg2_g9.cpp
24 //! \brief MPEG2 dual-pipe encoder for GEN9.
25 //!
26
27 #include "codechal_encode_mpeg2_g9.h"
28 #include "igcodeckrn_g9.h"
29
30 struct KernelHeaderMpegG9
31 {
32 uint32_t m_kernelCount;
33
34 // MBEnc Norm/Perf/Quality moes for frame
35 CODECHAL_KERNEL_HEADER m_mpeg2MbEncI;
36 CODECHAL_KERNEL_HEADER m_mpeg2MbEncP;
37 CODECHAL_KERNEL_HEADER m_mpeg2MbEncB;
38
39 // ME Downscale
40 CODECHAL_KERNEL_HEADER m_plyDscalePly;
41
42 // AVC_ME kernels for distortion
43 CODECHAL_KERNEL_HEADER m_mpeg2AvcMeP;
44 CODECHAL_KERNEL_HEADER m_mpeg2AvcMeB;
45
46 CODECHAL_KERNEL_HEADER m_mpeg2InitFrameBrc;
47 CODECHAL_KERNEL_HEADER m_mpeg2FrameEncUpdate;
48 CODECHAL_KERNEL_HEADER m_mpeg2BrcResetFrame;
49
50 // BRCBlockCopy
51 CODECHAL_KERNEL_HEADER m_mpeg2BrcBlockCopy;
52 };
53
54 enum BindingTableOffsetMeG9
55 {
56 meMvDataSurface = 0,
57 meDistortionSurface = 2,
58 meBrcDistortion = 3,
59 meCurrForFwdRef = 5,
60 meFwdRefIdx0 = 6,
61 meCurrForBwdRef = 22,
62 meBwdRefIdx0 = 23,
63 meNumSurface = 27,
64 };
65
66 enum BindingTableOffsetMbEncG9
67 {
68 mbEncPakObj = 0,
69 mbEncPakObjPrev = 1,
70 mbEncCurrentY = 3,
71 mbEncBrcDistortionSurface = 8,
72 mbEncCurrentPic = 9,
73 mbEncForwardPic = 10,
74 mbEncBackwardPic = 11,
75 mbEncInterlaceFrameCurrentPic = 14,
76 mbEncInterlaceFrameBackwardPic = 15,
77 mbEncMbControl = 18,
78 mbEncNumBindingTableEntries = 19
79 };
80
81 class MeCurbeG9
82 {
83 public:
84 struct CurbeData
85 {
86 // DW0
87 union
88 {
89 struct
90 {
91 uint32_t m_skipModeEn : MOS_BITFIELD_BIT(0);
92 uint32_t m_adaptiveEn : MOS_BITFIELD_BIT(1);
93 uint32_t m_biMixDis : MOS_BITFIELD_BIT(2);
94 uint32_t m_reserved3 : MOS_BITFIELD_RANGE(3, 4);
95 uint32_t m_earlyImeSuccessEn : MOS_BITFIELD_BIT(5);
96 uint32_t m_reserved6 : MOS_BITFIELD_BIT(6);
97 uint32_t m_t8x8FlagForInterEn : MOS_BITFIELD_BIT(7);
98 uint32_t m_reserved8 : MOS_BITFIELD_RANGE(8, 23);
99 uint32_t m_earlyImeStop : MOS_BITFIELD_RANGE(24, 31);
100 };
101 struct
102 {
103 uint32_t m_value;
104 };
105 } DW0;
106
107 // DW1
108 union
109 {
110 struct
111 {
112 uint32_t m_maxNumMVs : MOS_BITFIELD_RANGE(0, 5);
113 uint32_t m_reserved6 : MOS_BITFIELD_RANGE(6, 15);
114 uint32_t m_biWeight : MOS_BITFIELD_RANGE(16, 21);
115 uint32_t m_reserved22 : MOS_BITFIELD_RANGE(22, 27);
116 uint32_t m_uniMixDisable : MOS_BITFIELD_BIT(28);
117 uint32_t m_reserved29 : MOS_BITFIELD_RANGE(29, 31);
118 };
119 struct
120 {
121 uint32_t m_value;
122 };
123 } DW1;
124
125 // DW2
126 union
127 {
128 struct
129 {
130 uint32_t m_maxLenSP : MOS_BITFIELD_RANGE(0, 7);
131 uint32_t m_maxNumSU : MOS_BITFIELD_RANGE(8, 15);
132 uint32_t m_reserved16 : MOS_BITFIELD_RANGE(16, 31);
133 };
134 struct
135 {
136 uint32_t m_value;
137 };
138 } DW2;
139
140 // DW3
141 union
142 {
143 struct
144 {
145 uint32_t m_srcSize : MOS_BITFIELD_RANGE(0, 1);
146 uint32_t m_reserved2 : MOS_BITFIELD_RANGE(2, 3);
147 uint32_t m_mbTypeRemap : MOS_BITFIELD_RANGE(4, 5);
148 uint32_t m_srcAccess : MOS_BITFIELD_BIT(6);
149 uint32_t m_refAccess : MOS_BITFIELD_BIT(7);
150 uint32_t m_searchCtrl : MOS_BITFIELD_RANGE(8, 10);
151 uint32_t m_dualSearchPathOption : MOS_BITFIELD_BIT(11);
152 uint32_t m_subPelMode : MOS_BITFIELD_RANGE(12, 13);
153 uint32_t m_skipType : MOS_BITFIELD_BIT(14);
154 uint32_t m_disableFieldCacheAlloc : MOS_BITFIELD_BIT(15);
155 uint32_t m_interChromaMode : MOS_BITFIELD_BIT(16);
156 uint32_t m_ftEnable : MOS_BITFIELD_BIT(17);
157 uint32_t m_bmeDisableFBR : MOS_BITFIELD_BIT(18);
158 uint32_t m_blockBasedSkipEnable : MOS_BITFIELD_BIT(19);
159 uint32_t m_interSAD : MOS_BITFIELD_RANGE(20, 21);
160 uint32_t m_intraSAD : MOS_BITFIELD_RANGE(22, 23);
161 uint32_t m_subMbPartMask : MOS_BITFIELD_RANGE(24, 30);
162 uint32_t m_reserved31 : MOS_BITFIELD_BIT(31);
163 };
164 struct
165 {
166 uint32_t m_value;
167 };
168 } DW3;
169
170 // DW4
171 union
172 {
173 struct
174 {
175 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(0, 7);
176 uint32_t m_pictureHeightMinus1 : MOS_BITFIELD_RANGE(8, 15);
177 uint32_t m_pictureWidth : MOS_BITFIELD_RANGE(16, 23);
178 uint32_t m_reserved24 : MOS_BITFIELD_RANGE(24, 31);
179 };
180 struct
181 {
182 uint32_t m_value;
183 };
184 } DW4;
185
186 // DW5
187 union
188 {
189 struct
190 {
191 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(0, 7);
192 uint32_t m_qpPrimeY : MOS_BITFIELD_RANGE(8, 15);
193 uint32_t m_refWidth : MOS_BITFIELD_RANGE(16, 23);
194 uint32_t m_refHeight : MOS_BITFIELD_RANGE(24, 31);
195
196 };
197 struct
198 {
199 uint32_t m_value;
200 };
201 } DW5;
202
203 // DW6
204 union
205 {
206 struct
207 {
208 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(0, 2);
209 uint32_t m_meModes : MOS_BITFIELD_RANGE(3, 4);
210 uint32_t m_reserved5 : MOS_BITFIELD_RANGE(5, 7);
211 uint32_t m_superCombineDist : MOS_BITFIELD_RANGE(8, 15);
212 uint32_t m_maxVmvR : MOS_BITFIELD_RANGE(16, 31);
213 };
214 struct
215 {
216 uint32_t m_value;
217 };
218 } DW6;
219
220 // DW7
221 union
222 {
223 struct
224 {
225 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(0, 15);
226 uint32_t m_mvCostScaleFactor : MOS_BITFIELD_RANGE(16, 17);
227 uint32_t m_bilinearEnable : MOS_BITFIELD_BIT(18);
228 uint32_t m_srcFieldPolarity : MOS_BITFIELD_BIT(19);
229 uint32_t m_weightedSADHAAR : MOS_BITFIELD_BIT(20);
230 uint32_t m_acOnlyHAAR : MOS_BITFIELD_BIT(21);
231 uint32_t m_refIDCostMode : MOS_BITFIELD_BIT(22);
232 uint32_t m_reserved23 : MOS_BITFIELD_BIT(23);
233 uint32_t m_skipCenterMask : MOS_BITFIELD_RANGE(24, 31);
234 };
235 struct
236 {
237 uint32_t m_value;
238 };
239 } DW7;
240
241 // DW8
242 union
243 {
244 struct
245 {
246 uint32_t m_mode0Cost : MOS_BITFIELD_RANGE(0, 7);
247 uint32_t m_mode1Cost : MOS_BITFIELD_RANGE(8, 15);
248 uint32_t m_mode2Cost : MOS_BITFIELD_RANGE(16, 23);
249 uint32_t m_mode3Cost : MOS_BITFIELD_RANGE(24, 31);
250 };
251 struct
252 {
253 uint32_t m_value;
254 };
255 } DW8;
256
257 // DW9
258 union
259 {
260 struct
261 {
262 uint32_t m_mode4Cost : MOS_BITFIELD_RANGE(0, 7);
263 uint32_t m_mode5Cost : MOS_BITFIELD_RANGE(8, 15);
264 uint32_t m_mode6Cost : MOS_BITFIELD_RANGE(16, 23);
265 uint32_t m_mode7Cost : MOS_BITFIELD_RANGE(24, 31);
266 };
267 struct
268 {
269 uint32_t m_value;
270 };
271 } DW9;
272
273 // DW10
274 union
275 {
276 struct
277 {
278 uint32_t m_mode8Cost : MOS_BITFIELD_RANGE(0, 7);
279 uint32_t m_mode9Cost : MOS_BITFIELD_RANGE(8, 15);
280 uint32_t m_refIDCost : MOS_BITFIELD_RANGE(16, 23);
281 uint32_t m_chromaIntraModeCost : MOS_BITFIELD_RANGE(24, 31);
282 };
283 struct
284 {
285 uint32_t m_value;
286 };
287 } DW10;
288
289 // DW11
290 union
291 {
292 struct
293 {
294 uint32_t m_mv0Cost : MOS_BITFIELD_RANGE(0, 7);
295 uint32_t m_mv1Cost : MOS_BITFIELD_RANGE(8, 15);
296 uint32_t m_mv2Cost : MOS_BITFIELD_RANGE(16, 23);
297 uint32_t m_mv3Cost : MOS_BITFIELD_RANGE(24, 31);
298 };
299 struct
300 {
301 uint32_t m_value;
302 };
303 } DW11;
304
305 // DW12
306 union
307 {
308 struct
309 {
310 uint32_t m_mv4Cost : MOS_BITFIELD_RANGE(0, 7);
311 uint32_t m_mv5Cost : MOS_BITFIELD_RANGE(8, 15);
312 uint32_t m_mv6Cost : MOS_BITFIELD_RANGE(16, 23);
313 uint32_t m_mv7Cost : MOS_BITFIELD_RANGE(24, 31);
314 };
315 struct
316 {
317 uint32_t m_value;
318 };
319 } DW12;
320
321 // DW13
322 union
323 {
324 struct
325 {
326 uint32_t m_numRefIdxL0MinusOne : MOS_BITFIELD_RANGE(0, 7);
327 uint32_t m_numRefIdxL1MinusOne : MOS_BITFIELD_RANGE(8, 15);
328 uint32_t m_actualMBWidth : MOS_BITFIELD_RANGE(16, 23);
329 uint32_t m_actualMBHeight : MOS_BITFIELD_RANGE(24, 31);
330 };
331 struct
332 {
333 uint32_t m_value;
334 };
335 } DW13;
336
337 // DW14
338 union
339 {
340 struct
341 {
342 uint32_t m_list0RefID0FieldParity : MOS_BITFIELD_BIT(0);
343 uint32_t m_list0RefID1FieldParity : MOS_BITFIELD_BIT(1);
344 uint32_t m_list0RefID2FieldParity : MOS_BITFIELD_BIT(2);
345 uint32_t m_list0RefID3FieldParity : MOS_BITFIELD_BIT(3);
346 uint32_t m_list0RefID4FieldParity : MOS_BITFIELD_BIT(4);
347 uint32_t m_list0RefID5FieldParity : MOS_BITFIELD_BIT(5);
348 uint32_t m_list0RefID6FieldParity : MOS_BITFIELD_BIT(6);
349 uint32_t m_list0RefID7FieldParity : MOS_BITFIELD_BIT(7);
350 uint32_t m_list1RefID0FieldParity : MOS_BITFIELD_BIT(8);
351 uint32_t m_list1RefID1FieldParity : MOS_BITFIELD_BIT(9);
352 uint32_t m_reserved10 : MOS_BITFIELD_RANGE(10, 31);
353 };
354 struct
355 {
356 uint32_t m_value;
357 };
358 } DW14;
359
360 // DW15
361 union
362 {
363 struct
364 {
365 uint32_t m_prevMvReadPosFactor : MOS_BITFIELD_RANGE(0, 7);
366 uint32_t m_mvShiftFactor : MOS_BITFIELD_RANGE(8, 15);
367 uint32_t m_reserved16 : MOS_BITFIELD_RANGE(16, 31);
368 };
369 struct
370 {
371 uint32_t m_value;
372 };
373 } DW15;
374
375 struct
376 {
377 // DW16
378 union
379 {
380 struct
381 {
382 SearchPathDelta m_spDelta_0;
383 SearchPathDelta m_spDelta_1;
384 SearchPathDelta m_spDelta_2;
385 SearchPathDelta m_spDelta_3;
386 };
387 struct
388 {
389 uint32_t m_value;
390 };
391 } DW16;
392
393 // DW17
394 union
395 {
396 struct
397 {
398 SearchPathDelta m_spDelta_4;
399 SearchPathDelta m_spDelta_5;
400 SearchPathDelta m_spDelta_6;
401 SearchPathDelta m_spDelta_7;
402 };
403 struct
404 {
405 uint32_t m_value;
406 };
407 } DW17;
408
409 // DW18
410 union
411 {
412 struct
413 {
414 SearchPathDelta m_spDelta_8;
415 SearchPathDelta m_spDelta_9;
416 SearchPathDelta m_spDelta_10;
417 SearchPathDelta m_spDelta_11;
418 };
419 struct
420 {
421 uint32_t m_value;
422 };
423 } DW18;
424
425 // DW19
426 union
427 {
428 struct
429 {
430 SearchPathDelta m_spDelta_12;
431 SearchPathDelta m_spDelta_13;
432 SearchPathDelta m_spDelta_14;
433 SearchPathDelta m_spDelta_15;
434 };
435 struct
436 {
437 uint32_t m_value;
438 };
439 } DW19;
440
441 // DW20
442 union
443 {
444 struct
445 {
446 SearchPathDelta m_spDelta_16;
447 SearchPathDelta m_spDelta_17;
448 SearchPathDelta m_spDelta_18;
449 SearchPathDelta m_spDelta_19;
450 };
451 struct
452 {
453 uint32_t m_value;
454 };
455 } DW20;
456
457 // DW21
458 union
459 {
460 struct
461 {
462 SearchPathDelta m_spDelta_20;
463 SearchPathDelta m_spDelta_21;
464 SearchPathDelta m_spDelta_22;
465 SearchPathDelta m_spDelta_23;
466 };
467 struct
468 {
469 uint32_t m_value;
470 };
471 } DW21;
472
473 // DW22
474 union
475 {
476 struct
477 {
478 SearchPathDelta m_spDelta_24;
479 SearchPathDelta m_spDelta_25;
480 SearchPathDelta m_spDelta_26;
481 SearchPathDelta m_spDelta_27;
482 };
483 struct
484 {
485 uint32_t m_value;
486 };
487 } DW22;
488
489 // DW23
490 union
491 {
492 struct
493 {
494 SearchPathDelta m_spDelta_28;
495 SearchPathDelta m_spDelta_29;
496 SearchPathDelta m_spDelta_30;
497 SearchPathDelta m_spDelta_31;
498 };
499 struct
500 {
501 uint32_t m_value;
502 };
503 } DW23;
504
505 // DW24
506 union
507 {
508 struct
509 {
510 SearchPathDelta m_spDelta_32;
511 SearchPathDelta m_spDelta_33;
512 SearchPathDelta m_spDelta_34;
513 SearchPathDelta m_spDelta_35;
514 };
515 struct
516 {
517 uint32_t m_value;
518 };
519 } DW24;
520
521 // DW25
522 union
523 {
524 struct
525 {
526 SearchPathDelta m_spDelta_36;
527 SearchPathDelta m_spDelta_37;
528 SearchPathDelta m_spDelta_38;
529 SearchPathDelta m_spDelta_39;
530 };
531 struct
532 {
533 uint32_t m_value;
534 };
535 } DW25;
536
537 // DW26
538 union
539 {
540 struct
541 {
542 SearchPathDelta m_spDelta_40;
543 SearchPathDelta m_spDelta_41;
544 SearchPathDelta m_spDelta_42;
545 SearchPathDelta m_spDelta_43;
546 };
547 struct
548 {
549 uint32_t m_value;
550 };
551 } DW26;
552
553 // DW27
554 union
555 {
556 struct
557 {
558 SearchPathDelta m_spDelta_44;
559 SearchPathDelta m_spDelta_45;
560 SearchPathDelta m_spDelta_46;
561 SearchPathDelta m_spDelta_47;
562 };
563 struct
564 {
565 uint32_t m_value;
566 };
567 } DW27;
568
569 // DW28
570 union
571 {
572 struct
573 {
574 SearchPathDelta m_spDelta_48;
575 SearchPathDelta m_spDelta_49;
576 SearchPathDelta m_spDelta_50;
577 SearchPathDelta m_spDelta_51;
578 };
579 struct
580 {
581 uint32_t m_value;
582 };
583 } DW28;
584
585 // DW29
586 union
587 {
588 struct
589 {
590 SearchPathDelta m_spDelta_52;
591 SearchPathDelta m_spDelta_53;
592 SearchPathDelta m_spDelta_54;
593 SearchPathDelta m_spDelta_55;
594 };
595 struct
596 {
597 uint32_t m_value;
598 };
599 } DW29;
600 } SpDelta;
601
602 // DW30
603 union
604 {
605 struct
606 {
607 uint32_t m_reserved;
608 };
609 struct
610 {
611 uint32_t m_value;
612 };
613 } DW30;
614
615 // DW31
616 union
617 {
618 struct
619 {
620 uint32_t m_reserved;
621 };
622 struct
623 {
624 uint32_t m_value;
625 };
626 } DW31;
627
628 // DW32
629 union
630 {
631 struct
632 {
633 uint32_t m_4xMeMvOutputDataSurfIndex;
634 };
635 struct
636 {
637 uint32_t m_value;
638 };
639 } DW32;
640
641 // DW33
642 union
643 {
644 struct
645 {
646 uint32_t m_16xMeMvInputDataSurfIndex;
647 };
648 struct
649 {
650 uint32_t m_value;
651 };
652 } DW33;
653
654 // DW34
655 union
656 {
657 struct
658 {
659 uint32_t m_4xMeOutputDistSurfIndex;
660 };
661 struct
662 {
663 uint32_t m_value;
664 };
665 } DW34;
666
667 // DW35
668 union
669 {
670 struct
671 {
672 uint32_t m_4xMeOutputBrcDistSurfIndex;
673 };
674 struct
675 {
676 uint32_t m_value;
677 };
678 } DW35;
679
680 // DW36
681 union
682 {
683 struct
684 {
685 uint32_t m_vmeFwdInterPredictionSurfIndex;
686 };
687 struct
688 {
689 uint32_t m_value;
690 };
691 } DW36;
692
693 // DW37
694 union
695 {
696 struct
697 {
698 uint32_t m_vmeBwdInterPredictionSurfIndex;
699 };
700 struct
701 {
702 uint32_t m_value;
703 };
704 } DW37;
705
706 // DW38
707 union
708 {
709 struct
710 {
711 uint32_t m_reserved;
712 };
713 struct
714 {
715 uint32_t m_value;
716 };
717 } DW38;
718 }m_curbeData;
719
720 //!
721 //! \brief Constructor
722 //!
723 MeCurbeG9();
724
725 //!
726 //! \brief Destructor
727 //!
~MeCurbeG9()728 ~MeCurbeG9(){};
729
730 static const size_t m_byteSize = sizeof(CurbeData);
731
732 } ;
733
734 class MbEncCurbeG9
735 {
736 public:
737 struct CurbeData
738 {
739 union
740 {
741 struct
742 {
743 uint32_t m_skipModeEn : MOS_BITFIELD_BIT(0);
744 uint32_t m_adaptiveEn : MOS_BITFIELD_BIT(1);
745 uint32_t m_biMixDis : MOS_BITFIELD_BIT(2);
746 uint32_t m_isInterlacedFrameFlag : MOS_BITFIELD_BIT(3);
747 uint32_t m_isTopFieldFirst : MOS_BITFIELD_BIT(4);
748 uint32_t m_earlyImeSuccessEn : MOS_BITFIELD_BIT(5);
749 uint32_t m_forceToSkip : MOS_BITFIELD_BIT(6);
750 uint32_t m_t8x8FlagForInterEn : MOS_BITFIELD_BIT(7);
751 uint32_t m_refPixOff : MOS_BITFIELD_RANGE(8,15);
752 uint32_t m_reserved1 : MOS_BITFIELD_RANGE(16,23);
753 uint32_t m_earlyImeStop : MOS_BITFIELD_RANGE(24,31);
754 };
755 struct
756 {
757 uint32_t m_value;
758 };
759 } DW0;
760
761 union
762 {
763 struct
764 {
765 uint32_t m_maxNumMVs : MOS_BITFIELD_RANGE(0,5);
766 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(6,7);
767 uint32_t m_refIDPolBits : MOS_BITFIELD_RANGE(8,15);
768 uint32_t m_biWeight : MOS_BITFIELD_RANGE(16,21);
769 uint32_t m_gxMask : MOS_BITFIELD_BIT(22);
770 uint32_t m_gyMask : MOS_BITFIELD_BIT(23);
771 uint32_t m_refPixShift : MOS_BITFIELD_RANGE(24,27);
772 uint32_t m_uniMixDisable : MOS_BITFIELD_BIT(28);
773 uint32_t m_refPixBiasEn : MOS_BITFIELD_BIT(29); // m_refPixBiasEn (MBZ)
774 uint32_t m_idmShapeModeExt7x7 : MOS_BITFIELD_BIT(30);
775 uint32_t m_idmShapeModeExt5x5 : MOS_BITFIELD_BIT(31);
776 };
777 struct
778 {
779 uint32_t m_value;
780 };
781 } DW1;
782
783 union
784 {
785 struct
786 {
787 uint32_t m_maxLenSP : MOS_BITFIELD_RANGE(0,7);
788 uint32_t m_maxNumSU : MOS_BITFIELD_RANGE(8,15);
789 uint32_t m_start0X : MOS_BITFIELD_RANGE(16,19);
790 uint32_t m_start0Y : MOS_BITFIELD_RANGE(20,23);
791 uint32_t m_start1X : MOS_BITFIELD_RANGE(24,27);
792 uint32_t m_start1Y : MOS_BITFIELD_RANGE(28,31);
793 };
794 struct
795 {
796 uint32_t m_value;
797 };
798 } DW2;
799
800 union
801 {
802 struct
803 {
804 uint32_t m_fieldBias : MOS_BITFIELD_RANGE(0,7);
805 uint32_t m_oppFieldBias : MOS_BITFIELD_RANGE(8,15);
806 uint32_t m_fieldSkipThr : MOS_BITFIELD_RANGE(16,31);
807 };
808 struct
809 {
810 uint32_t m_value;
811 };
812 } DW3;
813
814 union
815 {
816 struct
817 {
818 uint32_t m_reserved0 : MOS_BITFIELD_RANGE(0,7);
819 uint32_t m_picHeightMinus1 : MOS_BITFIELD_RANGE(8,15);
820 uint32_t m_picWidth : MOS_BITFIELD_RANGE(16,23);
821 uint32_t m_reserved24 : MOS_BITFIELD_BIT(24); // WalkerType
822 uint32_t m_motionSeeding : MOS_BITFIELD_BIT(25);
823 uint32_t m_kernelMBModeDecision : MOS_BITFIELD_BIT(26);
824 uint32_t m_iFrameMBDistortionDumpEnable : MOS_BITFIELD_BIT(27);
825 uint32_t m_fieldFlag : MOS_BITFIELD_BIT(28);
826 uint32_t m_pictureType : MOS_BITFIELD_RANGE(29,30);
827 uint32_t m_reserved1 : MOS_BITFIELD_BIT(31);
828 };
829 struct
830 {
831 uint32_t m_value;
832 };
833 } DW4;
834
835 struct
836 {
837 union
838 {
839 struct
840 {
841 uint32_t m_mv0Cost : MOS_BITFIELD_RANGE(0, 7);
842 uint32_t m_mv1Cost : MOS_BITFIELD_RANGE(8, 15);
843 uint32_t m_mv2Cost : MOS_BITFIELD_RANGE(16, 23);
844 uint32_t m_mv3Cost : MOS_BITFIELD_RANGE(24, 31);
845 };
846 struct
847 {
848 uint32_t m_value;
849 };
850 } DW5;
851
852 union
853 {
854 struct
855 {
856 uint32_t m_mv4Cost : MOS_BITFIELD_RANGE(0, 7);
857 uint32_t m_mv5Cost : MOS_BITFIELD_RANGE(8, 15);
858 uint32_t m_mv6Cost : MOS_BITFIELD_RANGE(16, 23);
859 uint32_t m_mv7Cost : MOS_BITFIELD_RANGE(24, 31);
860 };
861 struct
862 {
863 uint32_t m_value;
864 };
865 } DW6;
866 } MvCost;
867
868 union
869 {
870 struct
871 {
872 uint32_t m_intraPartMask : MOS_BITFIELD_RANGE(0,4);
873 uint32_t m_nonSkipZMvAdded : MOS_BITFIELD_BIT(5);
874 uint32_t m_nonSkipModeAdded : MOS_BITFIELD_BIT(6);
875 uint32_t m_reserved7 : MOS_BITFIELD_BIT(7);
876 uint32_t m_reserved8 : MOS_BITFIELD_RANGE(8,15);
877 uint32_t m_mvCostScaleFactor : MOS_BITFIELD_RANGE(16,17);
878 uint32_t m_bilinearEnable : MOS_BITFIELD_BIT(18);
879 uint32_t m_srcFieldPolarity : MOS_BITFIELD_BIT(19);
880 uint32_t m_weightedSADHAAR : MOS_BITFIELD_BIT(20);
881 uint32_t m_acOnlyHAAR : MOS_BITFIELD_BIT(21);
882 uint32_t m_refIDCostMode : MOS_BITFIELD_BIT(22);
883 uint32_t m_idmShapeMode : MOS_BITFIELD_BIT(23);
884 uint32_t m_skipCenterMask : MOS_BITFIELD_RANGE(24,31);
885 };
886 struct
887 {
888 uint32_t m_value;
889 };
890 } DW7;
891
892 union
893 {
894 struct
895 {
896 uint32_t m_mode8Cost : MOS_BITFIELD_RANGE(0,7);
897 uint32_t m_mode9Cost : MOS_BITFIELD_RANGE(8,15);
898 uint32_t m_refIDCost : MOS_BITFIELD_RANGE(16,23);
899 uint32_t m_chromaIntraModeCost : MOS_BITFIELD_RANGE(24,31);
900 };
901 struct
902 {
903 uint32_t m_value;
904 };
905 } DW8;
906
907 union
908 {
909 struct
910 {
911 uint32_t m_srcSize : MOS_BITFIELD_RANGE(0,1);
912 uint32_t m_mbQPEnable : MOS_BITFIELD_BIT(2);
913 uint32_t m_mbSkipEnable : MOS_BITFIELD_BIT(3);
914 uint32_t m_mbNonSkipEnable : MOS_BITFIELD_BIT(4);
915 uint32_t m_reserved5 : MOS_BITFIELD_BIT(5);
916 uint32_t m_srcAccess : MOS_BITFIELD_BIT(6);
917 uint32_t m_refAccess : MOS_BITFIELD_BIT(7);
918 uint32_t m_searchCtrl : MOS_BITFIELD_RANGE(8,10);
919 uint32_t m_dualSearchOpt : MOS_BITFIELD_BIT(11);
920 uint32_t m_subPelMode : MOS_BITFIELD_RANGE(12,13);
921 uint32_t m_skipType : MOS_BITFIELD_BIT(14);
922 uint32_t m_fieldCacheAllocationDis : MOS_BITFIELD_BIT(15);
923 uint32_t m_interChromaMode : MOS_BITFIELD_BIT(16);
924 uint32_t m_ftEnable : MOS_BITFIELD_BIT(17);
925 uint32_t m_bmeDisableFBR : MOS_BITFIELD_BIT(18);
926 uint32_t m_reserved19 : MOS_BITFIELD_BIT(19);
927 uint32_t m_interSAD : MOS_BITFIELD_RANGE(20,21);
928 uint32_t m_intraSAD : MOS_BITFIELD_RANGE(22,23);
929 uint32_t m_subMbPartMask : MOS_BITFIELD_RANGE(24,30);
930 uint32_t m_reserved31 : MOS_BITFIELD_BIT(31);
931 };
932 struct
933 {
934 uint32_t m_value;
935 };
936 } DW9;
937
938 union
939 {
940 struct
941 {
942 uint32_t m_dispatchID : MOS_BITFIELD_RANGE(0,7);
943 uint32_t m_largeMbSizeInWord : MOS_BITFIELD_RANGE(8,15);
944 uint32_t m_refWidth : MOS_BITFIELD_RANGE(16,23);
945 uint32_t m_refHeight : MOS_BITFIELD_RANGE(24,31);
946 };
947 struct
948 {
949 uint32_t m_value;
950 };
951 } DW10;
952
953 union
954 {
955 struct
956 {
957 uint32_t m_qpScaleCode : MOS_BITFIELD_RANGE(0,7);
958 uint32_t m_intraFactor : MOS_BITFIELD_RANGE(8,11);
959 uint32_t m_intraMulFact : MOS_BITFIELD_RANGE(12,15);
960 uint32_t m_intraBiasFF : MOS_BITFIELD_RANGE(16,23);
961 uint32_t m_intraBiasFrame : MOS_BITFIELD_RANGE(24,31);
962 };
963 struct
964 {
965 uint32_t m_value;
966 };
967 } DW11;
968
969 union
970 {
971 struct
972 {
973 uint32_t m_isFastMode : MOS_BITFIELD_RANGE(0,7);
974 uint32_t m_smallMbSizeInWord : MOS_BITFIELD_RANGE(8,15);
975 uint32_t m_distScaleFactor : MOS_BITFIELD_RANGE(16,31);
976 };
977 struct
978 {
979 uint32_t m_value;
980 };
981 } DW12;
982
983 union
984 {
985 struct
986 {
987 uint32_t m_panicModeMBThreshold : MOS_BITFIELD_RANGE(0,15);
988 uint32_t m_targetSizeInWord : MOS_BITFIELD_RANGE(16,23);
989 uint32_t m_reserved14 : MOS_BITFIELD_RANGE(24,31);
990 };
991 struct
992 {
993 uint32_t m_value;
994 };
995 } DW13;
996
997 union
998 {
999 struct
1000 {
1001 uint32_t m_forwardHorizontalSearchRange : MOS_BITFIELD_RANGE(0,15);
1002 uint32_t m_forwardVerticalSearchRange : MOS_BITFIELD_RANGE(16,31);
1003 };
1004 struct
1005 {
1006 uint32_t m_value;
1007 };
1008 } DW14;
1009
1010 union
1011 {
1012 struct
1013 {
1014 uint32_t m_backwardHorizontalSearchRange : MOS_BITFIELD_RANGE(0,15);
1015 uint32_t m_backwardVerticalSearchRange : MOS_BITFIELD_RANGE(16,31);
1016 };
1017 struct
1018 {
1019 uint32_t m_value;
1020 };
1021 } DW15;
1022
1023 struct
1024 {
1025 union
1026 {
1027 struct
1028 {
1029 uint32_t m_meDelta0to3;
1030 };
1031 struct
1032 {
1033 uint32_t m_value;
1034 };
1035 } DW16;
1036
1037 union
1038 {
1039 struct
1040 {
1041 uint32_t m_meDelta4to7;
1042 };
1043 struct
1044 {
1045 uint32_t m_value;
1046 };
1047 } DW17;
1048
1049 union
1050 {
1051 struct
1052 {
1053 uint32_t m_meDelta8to11;
1054 };
1055 struct
1056 {
1057 uint32_t m_value;
1058 };
1059 } DW18;
1060
1061 union
1062 {
1063 struct
1064 {
1065 uint32_t m_meDelta12to15;
1066 };
1067 struct
1068 {
1069 uint32_t m_value;
1070 };
1071 } DW19;
1072
1073 union
1074 {
1075 struct
1076 {
1077 uint32_t m_meDelta16to19;
1078 };
1079 struct
1080 {
1081 uint32_t m_value;
1082 };
1083 } DW20;
1084
1085 union
1086 {
1087 struct
1088 {
1089 uint32_t m_meDelta20to23;
1090 };
1091 struct
1092 {
1093 uint32_t m_value;
1094 };
1095 } DW21;
1096
1097 union
1098 {
1099 struct
1100 {
1101 uint32_t m_meDelta24to27;
1102 };
1103 struct
1104 {
1105 uint32_t m_value;
1106 };
1107 } DW22;
1108
1109 union
1110 {
1111 struct
1112 {
1113 uint32_t m_meDelta28to31;
1114 };
1115 struct
1116 {
1117 uint32_t m_value;
1118 };
1119 } DW23;
1120
1121 union
1122 {
1123 struct
1124 {
1125 uint32_t m_meDelta32to35;
1126 };
1127 struct
1128 {
1129 uint32_t m_value;
1130 };
1131 } DW24;
1132
1133 union
1134 {
1135 struct
1136 {
1137 uint32_t m_meDelta36to39;
1138 };
1139 struct
1140 {
1141 uint32_t m_value;
1142 };
1143 } DW25;
1144
1145 union
1146 {
1147 struct
1148 {
1149 uint32_t m_meDelta40to43;
1150 };
1151 struct
1152 {
1153 uint32_t m_value;
1154 };
1155 } DW26;
1156
1157 union
1158 {
1159 struct
1160 {
1161 uint32_t m_meDelta44to47;
1162 };
1163 struct
1164 {
1165 uint32_t m_value;
1166 };
1167 } DW27;
1168
1169 union
1170 {
1171 struct
1172 {
1173 uint32_t m_meDelta48to51;
1174 };
1175 struct
1176 {
1177 uint32_t m_value;
1178 };
1179 } DW28;
1180
1181 union
1182 {
1183 struct
1184 {
1185 uint32_t m_meDelta52to55;
1186 };
1187 struct
1188 {
1189 uint32_t m_value;
1190 };
1191 } DW29;
1192
1193 union
1194 {
1195 struct
1196 {
1197 uint32_t m_mode0Cost : MOS_BITFIELD_RANGE(0, 7);
1198 uint32_t m_mode1Cost : MOS_BITFIELD_RANGE(8, 15);
1199 uint32_t m_mode2Cost : MOS_BITFIELD_RANGE(16, 23);
1200 uint32_t m_mode3Cost : MOS_BITFIELD_RANGE(24, 31);
1201 };
1202 struct
1203 {
1204 uint32_t m_value;
1205 };
1206 } DW30;
1207
1208 union
1209 {
1210 struct
1211 {
1212 uint32_t m_mode4Cost : MOS_BITFIELD_RANGE(0, 7);
1213 uint32_t m_mode5Cost : MOS_BITFIELD_RANGE(8, 15);
1214 uint32_t m_mode6Cost : MOS_BITFIELD_RANGE(16, 23);
1215 uint32_t m_mode7Cost : MOS_BITFIELD_RANGE(24, 31);
1216 };
1217 struct
1218 {
1219 uint32_t m_value;
1220 };
1221 } DW31;
1222 } VmeSPath0;
1223
1224 struct
1225 {
1226 union
1227 {
1228 struct
1229 {
1230 uint32_t m_meDelta0to3;
1231 };
1232 struct
1233 {
1234 uint32_t m_value;
1235 };
1236 } DW32;
1237
1238 union
1239 {
1240 struct
1241 {
1242 uint32_t m_meDelta4to7;
1243 };
1244 struct
1245 {
1246 uint32_t m_value;
1247 };
1248 } DW33;
1249
1250 union
1251 {
1252 struct
1253 {
1254 uint32_t m_meDelta8to11;
1255 };
1256 struct
1257 {
1258 uint32_t m_value;
1259 };
1260 } DW34;
1261
1262 union
1263 {
1264 struct
1265 {
1266 uint32_t m_meDelta12to15;
1267 };
1268 struct
1269 {
1270 uint32_t m_value;
1271 };
1272 } DW35;
1273
1274 union
1275 {
1276 struct
1277 {
1278 uint32_t m_meDelta16to19;
1279 };
1280 struct
1281 {
1282 uint32_t m_value;
1283 };
1284 } DW36;
1285
1286 union
1287 {
1288 struct
1289 {
1290 uint32_t m_meDelta20to23;
1291 };
1292 struct
1293 {
1294 uint32_t m_value;
1295 };
1296 } DW37;
1297
1298 union
1299 {
1300 struct
1301 {
1302 uint32_t m_meDelta24to27;
1303 };
1304 struct
1305 {
1306 uint32_t m_value;
1307 };
1308 } DW38;
1309
1310 union
1311 {
1312 struct
1313 {
1314 uint32_t m_meDelta28to31;
1315 };
1316 struct
1317 {
1318 uint32_t m_value;
1319 };
1320 } DW39;
1321
1322 union
1323 {
1324 struct
1325 {
1326 uint32_t m_meDelta32to35;
1327 };
1328 struct
1329 {
1330 uint32_t m_value;
1331 };
1332 } DW40;
1333
1334 union
1335 {
1336 struct
1337 {
1338 uint32_t m_meDelta36to39;
1339 };
1340 struct
1341 {
1342 uint32_t m_value;
1343 };
1344 } DW41;
1345
1346 union
1347 {
1348 struct
1349 {
1350 uint32_t m_meDelta40to43;
1351 };
1352 struct
1353 {
1354 uint32_t m_value;
1355 };
1356 } DW42;
1357
1358 union
1359 {
1360 struct
1361 {
1362 uint32_t m_meDelta44to47;
1363 };
1364 struct
1365 {
1366 uint32_t m_value;
1367 };
1368 } DW43;
1369
1370 union
1371 {
1372 struct
1373 {
1374 uint32_t m_meDelta48to51;
1375 };
1376 struct
1377 {
1378 uint32_t m_value;
1379 };
1380 } DW44;
1381
1382 union
1383 {
1384 struct
1385 {
1386 uint32_t m_meDelta52to55;
1387 };
1388 struct
1389 {
1390 uint32_t m_value;
1391 };
1392 } DW45;
1393
1394 struct
1395 {
1396 union
1397 {
1398 struct
1399 {
1400 uint32_t m_mv0Cost_Interlaced : MOS_BITFIELD_RANGE(0, 7);
1401 uint32_t m_mv1Cost_Interlaced : MOS_BITFIELD_RANGE(8, 15);
1402 uint32_t m_mv2Cost_Interlaced : MOS_BITFIELD_RANGE(16, 23);
1403 uint32_t m_mv3Cost_Interlaced : MOS_BITFIELD_RANGE(24, 31);
1404 };
1405 struct
1406 {
1407 uint32_t m_value;
1408 };
1409 } DW46;
1410
1411 union
1412 {
1413 struct
1414 {
1415 uint32_t m_mv4Cost_Interlaced : MOS_BITFIELD_RANGE(0, 7);
1416 uint32_t m_mv5Cost_Interlaced : MOS_BITFIELD_RANGE(8, 15);
1417 uint32_t m_mv6Cost_Interlaced : MOS_BITFIELD_RANGE(16, 23);
1418 uint32_t m_mv7Cost_Interlaced : MOS_BITFIELD_RANGE(24, 31);
1419 };
1420 struct
1421 {
1422 uint32_t m_value;
1423 };
1424 } DW47;
1425 } MvCostInterlace;
1426 } VmeSPath1;
1427
1428 union
1429 {
1430 struct
1431 {
1432 uint32_t m_batchBufferEnd;
1433 };
1434 struct
1435 {
1436 uint32_t m_value;
1437 };
1438 } DW48;
1439
1440 union
1441 {
1442 struct
1443 {
1444 uint32_t m_pakObjCmds;
1445 };
1446 struct
1447 {
1448 uint32_t m_value;
1449 };
1450 } DW49;
1451
1452 union
1453 {
1454 struct
1455 {
1456 uint32_t m_prevmPakObjCmds;
1457 };
1458 struct
1459 {
1460 uint32_t m_value;
1461 };
1462 } DW50;
1463
1464 union
1465 {
1466 struct
1467 {
1468 uint32_t m_currPicY;
1469 };
1470 struct
1471 {
1472 uint32_t m_value;
1473 };
1474 } DW51;
1475
1476 union
1477 {
1478 struct
1479 {
1480 uint32_t m_currFwdBwdRef;
1481 };
1482 struct
1483 {
1484 uint32_t m_value;
1485 };
1486 } DW52;
1487
1488 union
1489 {
1490 struct
1491 {
1492 uint32_t m_currBwdRef;
1493 };
1494 struct
1495 {
1496 uint32_t m_value;
1497 };
1498 } DW53;
1499
1500 union
1501 {
1502 struct
1503 {
1504 uint32_t m_distSurf4x;
1505 };
1506 struct
1507 {
1508 uint32_t m_value;
1509 };
1510 } DW54;
1511
1512 union
1513 {
1514 struct
1515 {
1516 uint32_t m_mbControl;
1517 };
1518 struct
1519 {
1520 uint32_t m_value;
1521 };
1522 } DW55;
1523 }m_curbeData;
1524
1525 //!
1526 //! \brief Constructor
1527 //!
1528 MbEncCurbeG9(uint8_t codingType);
1529
1530 //!
1531 //! \brief Destructor
1532 //!
~MbEncCurbeG9()1533 ~MbEncCurbeG9(){};
1534
1535 static const size_t m_byteSize = sizeof(CurbeData);
1536 };
1537
MeCurbeG9()1538 MeCurbeG9::MeCurbeG9()
1539 {
1540 CODECHAL_ENCODE_FUNCTION_ENTER;
1541
1542 MOS_ZeroMemory(&m_curbeData, m_byteSize);
1543
1544 m_curbeData.DW0.m_value = 0x00000000;
1545 m_curbeData.DW1.m_value = 0x00200010;
1546 m_curbeData.DW2.m_value = 0x00003939;
1547 m_curbeData.DW3.m_value = 0x77a43000;
1548 m_curbeData.DW4.m_value = 0x00000000;
1549 m_curbeData.DW5.m_value = 0x28300000;
1550
1551 m_curbeData.DW32.m_value = 0xffffffff;
1552 m_curbeData.DW33.m_value = 0xffffffff;
1553 m_curbeData.DW34.m_value = 0xffffffff;
1554 m_curbeData.DW35.m_value = 0xffffffff;
1555 m_curbeData.DW36.m_value = 0xffffffff;
1556 m_curbeData.DW37.m_value = 0xffffffff;
1557 m_curbeData.DW38.m_value = 0xffffffff;
1558
1559 }
1560
MbEncCurbeG9(uint8_t codingType)1561 MbEncCurbeG9::MbEncCurbeG9(uint8_t codingType)
1562 {
1563 CODECHAL_ENCODE_FUNCTION_ENTER;
1564
1565 MOS_ZeroMemory(&m_curbeData, m_byteSize);
1566
1567 m_curbeData.DW0.m_value = 0x00000023;
1568 switch (codingType)
1569 {
1570 case I_TYPE:
1571 m_curbeData.DW1.m_value = 0x00200020;
1572 m_curbeData.DW2.m_value = 0x00000000;
1573 m_curbeData.DW4.m_value = 0x00000000;
1574 m_curbeData.DW7.m_value = 0x00050066;
1575 m_curbeData.DW8.m_value = 0x00000000;
1576 m_curbeData.DW9.m_value = 0x7EA41000;
1577 m_curbeData.DW10.m_value = 0x0000FF00;
1578 break;
1579 case P_TYPE:
1580 m_curbeData.DW1.m_value = 0x00200020;
1581 m_curbeData.DW2.m_value = 0x00001009;
1582 m_curbeData.DW4.m_value = 0x20000000;
1583 m_curbeData.DW7.m_value = 0x00050066;
1584 m_curbeData.DW8.m_value = 0x00000041;
1585 m_curbeData.DW9.m_value = 0x7EA41000;
1586 m_curbeData.DW10.m_value = 0x2830FF00;
1587 break;
1588 case B_TYPE:
1589 default:
1590 m_curbeData.DW1.m_value = 0x10200010;
1591 m_curbeData.DW2.m_value = 0x00001005;
1592 m_curbeData.DW4.m_value = 0x40000000;
1593 m_curbeData.DW7.m_value = 0xFF050066;
1594 m_curbeData.DW8.m_value = 0x00000041;
1595 m_curbeData.DW9.m_value = 0x7EA01000;
1596 m_curbeData.DW10.m_value = 0x2020FF00;
1597 break;
1598
1599 }
1600
1601 m_curbeData.DW3.m_value = 0xFE0C0000;
1602 m_curbeData.MvCost.DW5.m_value = 0x00000000;
1603 m_curbeData.MvCost.DW6.m_value = 0x00000000;
1604 m_curbeData.DW11.m_value = 0x5A325300;
1605 m_curbeData.DW12.m_value = 0x0000FF00;
1606 m_curbeData.DW13.m_value = 0x00FF0000;
1607
1608 }
1609
CodechalEncodeMpeg2G9(CodechalHwInterface * hwInterface,CodechalDebugInterface * debugInterface,PCODECHAL_STANDARD_INFO standardInfo)1610 CodechalEncodeMpeg2G9::CodechalEncodeMpeg2G9(
1611 CodechalHwInterface* hwInterface,
1612 CodechalDebugInterface* debugInterface,
1613 PCODECHAL_STANDARD_INFO standardInfo)
1614 :CodechalEncodeMpeg2(hwInterface, debugInterface, standardInfo)
1615 {
1616 CODECHAL_ENCODE_FUNCTION_ENTER;
1617
1618 pfnGetKernelHeaderAndSize = GetKernelHeaderAndSize;
1619
1620 MOS_STATUS eStatus = CodecHalGetKernelBinaryAndSize(
1621 (uint8_t *)IGCODECKRN_G9,
1622 m_kuid,
1623 &m_kernelBinary,
1624 &m_combinedKernelSize);
1625
1626 CODECHAL_ENCODE_ASSERT(eStatus == MOS_STATUS_SUCCESS);
1627
1628 m_hwInterface->GetStateHeapSettings()->dwIshSize +=
1629 MOS_ALIGN_CEIL(m_combinedKernelSize, (1 << MHW_KERNEL_OFFSET_SHIFT));
1630
1631 m_needCheckCpEnabled = true;
1632 }
1633
Initialize(CodechalSetting * codecHalSettings)1634 MOS_STATUS CodechalEncodeMpeg2G9::Initialize(CodechalSetting * codecHalSettings)
1635 {
1636 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1637
1638 CODECHAL_ENCODE_FUNCTION_ENTER;
1639
1640 // common initilization
1641 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeMpeg2::Initialize(codecHalSettings));
1642
1643 return eStatus;
1644 }
1645
GetKernelHeaderAndSize(void * binary,EncOperation operation,uint32_t krnStateIdx,void * krnHeader,uint32_t * krnSize)1646 MOS_STATUS CodechalEncodeMpeg2G9::GetKernelHeaderAndSize(
1647 void *binary,
1648 EncOperation operation,
1649 uint32_t krnStateIdx,
1650 void *krnHeader,
1651 uint32_t *krnSize)
1652 {
1653 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1654
1655 CODECHAL_ENCODE_FUNCTION_ENTER;
1656
1657 CODECHAL_ENCODE_CHK_NULL_RETURN(binary);
1658 CODECHAL_ENCODE_CHK_NULL_RETURN(krnHeader);
1659 CODECHAL_ENCODE_CHK_NULL_RETURN(krnSize);
1660
1661 auto kernelHeaderTable = (KernelHeaderMpegG9 *)binary;
1662 PCODECHAL_KERNEL_HEADER currKrnHeader;
1663
1664 if (operation == ENC_SCALING4X)
1665 {
1666 currKrnHeader = &kernelHeaderTable->m_plyDscalePly;
1667 }
1668 else if (operation == ENC_ME)
1669 {
1670 currKrnHeader = &kernelHeaderTable->m_mpeg2AvcMeP;
1671 }
1672 else if (operation == ENC_BRC)
1673 {
1674 currKrnHeader = &kernelHeaderTable->m_mpeg2InitFrameBrc;
1675 }
1676 else if (operation == ENC_MBENC)
1677 {
1678 currKrnHeader = &kernelHeaderTable->m_mpeg2MbEncI;
1679 }
1680 else
1681 {
1682 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
1683 eStatus = MOS_STATUS_INVALID_PARAMETER;
1684 return eStatus;
1685 }
1686
1687 currKrnHeader += krnStateIdx;
1688 *((PCODECHAL_KERNEL_HEADER)krnHeader) = *currKrnHeader;
1689
1690 PCODECHAL_KERNEL_HEADER invalidEntry = &(kernelHeaderTable->m_mpeg2BrcResetFrame) + 1;
1691 PCODECHAL_KERNEL_HEADER nextKrnHeader = (currKrnHeader + 1);
1692 uint32_t nextKrnOffset = *krnSize;
1693
1694 if (nextKrnHeader < invalidEntry)
1695 {
1696 nextKrnOffset = nextKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT;
1697 }
1698 *krnSize = nextKrnOffset - (currKrnHeader->KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
1699
1700 return eStatus;
1701 }
1702
InitKernelState()1703 MOS_STATUS CodechalEncodeMpeg2G9::InitKernelState()
1704 {
1705 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1706
1707 CODECHAL_ENCODE_FUNCTION_ENTER;
1708
1709 // Init kernel state
1710 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMe());
1711 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMbEnc());
1712 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateBrc());
1713
1714 return eStatus;
1715 }
1716
InitKernelStateMe()1717 MOS_STATUS CodechalEncodeMpeg2G9::InitKernelStateMe()
1718 {
1719 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1720
1721 CODECHAL_ENCODE_FUNCTION_ENTER;
1722
1723 for (uint8_t krnStateIdx = 0; krnStateIdx < 2; krnStateIdx++)
1724 {
1725 auto kernelStatePtr = &m_meKernelStates[krnStateIdx];
1726 auto kernelSize = m_combinedKernelSize;
1727
1728 CODECHAL_KERNEL_HEADER currKrnHeader;
1729 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
1730 m_kernelBinary,
1731 ENC_ME,
1732 krnStateIdx,
1733 &currKrnHeader,
1734 &kernelSize));
1735
1736 kernelStatePtr->KernelParams.iBTCount = meNumSurface;
1737 kernelStatePtr->KernelParams.iThreadCount = m_hwInterface->GetRenderInterface()->GetHwCaps()->dwMaxThreads;
1738 kernelStatePtr->KernelParams.iCurbeLength = MeCurbeG9::m_byteSize;
1739 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
1740 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
1741 kernelStatePtr->KernelParams.iIdCount = 1;
1742
1743 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
1744 kernelStatePtr->KernelParams.pBinary = m_kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
1745 kernelStatePtr->KernelParams.iSize = kernelSize;
1746 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
1747 m_stateHeapInterface,
1748 kernelStatePtr->KernelParams.iBTCount,
1749 &kernelStatePtr->dwSshSize,
1750 &kernelStatePtr->dwBindingTableSize));
1751
1752 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
1753 }
1754
1755 // Until a better way can be found, maintain old binding table structures
1756 auto meBindingTable = &m_meBindingTable;
1757
1758 // Mpeg2 uses AVC ME Kernel for P/B distortion calculation
1759 meBindingTable->dwMEMVDataSurface = meMvDataSurface;
1760 meBindingTable->dwMECurrForFwdRef = meCurrForFwdRef;
1761 meBindingTable->dwMECurrForBwdRef = meCurrForBwdRef;
1762 meBindingTable->dwMEDist = meDistortionSurface;
1763 meBindingTable->dwMEBRCDist = meBrcDistortion;
1764 meBindingTable->dwMEFwdRefPicIdx[0] = meFwdRefIdx0;
1765 meBindingTable->dwMEFwdRefPicIdx[1] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1766 meBindingTable->dwMEFwdRefPicIdx[2] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1767 meBindingTable->dwMEFwdRefPicIdx[3] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1768 meBindingTable->dwMEFwdRefPicIdx[4] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1769 meBindingTable->dwMEFwdRefPicIdx[5] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1770 meBindingTable->dwMEFwdRefPicIdx[6] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1771 meBindingTable->dwMEFwdRefPicIdx[7] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1772 meBindingTable->dwMEBwdRefPicIdx[0] = meBwdRefIdx0;
1773 meBindingTable->dwMEBwdRefPicIdx[1] = CODECHAL_INVALID_BINDING_TABLE_IDX;
1774
1775 return eStatus;
1776 }
1777
InitKernelStateMbEnc()1778 MOS_STATUS CodechalEncodeMpeg2G9::InitKernelStateMbEnc()
1779 {
1780 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1781
1782 CODECHAL_ENCODE_FUNCTION_ENTER;
1783
1784 for (uint8_t krnStateIdx = 0; krnStateIdx < mbEncKernelIdxNum; krnStateIdx++)
1785 {
1786 auto kernelStatePtr = &m_mbEncKernelStates[krnStateIdx];
1787 auto kernelSize = m_combinedKernelSize;
1788
1789 CODECHAL_KERNEL_HEADER currKrnHeader;
1790 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
1791 m_kernelBinary,
1792 ENC_MBENC,
1793 krnStateIdx,
1794 &currKrnHeader,
1795 &kernelSize));
1796
1797 kernelStatePtr->KernelParams.iBTCount = mbEncNumBindingTableEntries;
1798 kernelStatePtr->KernelParams.iThreadCount = m_hwInterface->GetRenderInterface()->GetHwCaps()->dwMaxThreads;
1799 kernelStatePtr->KernelParams.iCurbeLength = MbEncCurbeG9::m_byteSize;
1800 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
1801 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
1802 kernelStatePtr->KernelParams.iIdCount = 1;
1803
1804 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
1805 kernelStatePtr->KernelParams.pBinary = m_kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
1806 kernelStatePtr->KernelParams.iSize = kernelSize;
1807
1808 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
1809 m_stateHeapInterface,
1810 kernelStatePtr->KernelParams.iBTCount,
1811 &kernelStatePtr->dwSshSize,
1812 &kernelStatePtr->dwBindingTableSize));
1813
1814 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
1815 }
1816
1817 m_mbEncBindingTable.m_mbEncPakObj = mbEncPakObj;
1818 m_mbEncBindingTable.m_mbEncPakObjPrev = mbEncPakObjPrev;
1819 m_mbEncBindingTable.m_mbEncCurrentY = mbEncCurrentY;
1820 m_mbEncBindingTable.m_mbEncBrcDistortionSurface = mbEncBrcDistortionSurface;
1821 m_mbEncBindingTable.m_mbEncCurrentPic = mbEncCurrentPic;
1822 m_mbEncBindingTable.m_mbEncForwardPic = mbEncForwardPic;
1823 m_mbEncBindingTable.m_mbEncBackwardPic = mbEncBackwardPic;
1824 m_mbEncBindingTable.m_mbEncInterlaceFrameCurrentPic = mbEncInterlaceFrameCurrentPic;
1825 m_mbEncBindingTable.m_mbEncInterlaceFrameBackwardPic = mbEncInterlaceFrameBackwardPic;
1826 m_mbEncBindingTable.m_mbEncMbControl = mbEncMbControl;
1827
1828 return eStatus;
1829 }
1830
SetCurbeMe()1831 MOS_STATUS CodechalEncodeMpeg2G9::SetCurbeMe()
1832 {
1833 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1834
1835 CODECHAL_ENCODE_FUNCTION_ENTER;
1836
1837 MeCurbeG9 cmd;
1838
1839 // r1
1840 cmd.m_curbeData.DW3.m_subPelMode = 3;
1841 if (m_fieldScalingOutputInterleaved)
1842 {
1843 cmd.m_curbeData.DW3.m_srcAccess = cmd.m_curbeData.DW3.m_refAccess =
1844 CodecHal_PictureIsField(m_picParams->m_currOriginalPic) ? 1 : 0;
1845 cmd.m_curbeData.DW7.m_srcFieldPolarity =
1846 CodecHal_PictureIsBottomField(m_picParams->m_currOriginalPic) ? 1 : 0;
1847 }
1848
1849 uint32_t scaleFactor = 4; // Scale factor always 4x, SHME/UHME not supported
1850 cmd.m_curbeData.DW4.m_pictureHeightMinus1 =
1851 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight / scaleFactor) - 1;
1852 cmd.m_curbeData.DW4.m_pictureWidth =
1853 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth / scaleFactor);
1854 cmd.m_curbeData.DW5.m_qpPrimeY = m_mvCostTableOffset;
1855 cmd.m_curbeData.DW6.m_meModes = CODECHAL_ENCODE_ME4X_ONLY;
1856 cmd.m_curbeData.DW6.m_superCombineDist = m_superCombineDistGeneric[m_seqParams->m_targetUsage];
1857 cmd.m_curbeData.DW6.m_maxVmvR = m_maxVmvr;
1858
1859 if (!CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic))
1860 {
1861 cmd.m_curbeData.DW6.m_maxVmvR = cmd.m_curbeData.DW6.m_maxVmvR >> 1;
1862 }
1863
1864 if (m_pictureCodingType == B_TYPE)
1865 {
1866 // This field is irrelevant since we are not using the bi-direct search.
1867 // set it to 32
1868 cmd.m_curbeData.DW1.m_biWeight = 32;
1869 cmd.m_curbeData.DW13.m_numRefIdxL1MinusOne = 0; // always 0 for MPEG2
1870 }
1871
1872 if (m_pictureCodingType == P_TYPE ||
1873 m_pictureCodingType == B_TYPE)
1874 {
1875 cmd.m_curbeData.DW13.m_numRefIdxL0MinusOne = 0; // always 0 for MPEG2
1876 }
1877
1878 // r3 & r4
1879 uint8_t meMethod = (m_pictureCodingType == B_TYPE) ? m_bMeMethodGeneric[m_seqParams->m_targetUsage] : m_meMethodGeneric[m_seqParams->m_targetUsage];
1880 uint8_t tableIdx = (m_pictureCodingType == B_TYPE) ? 1 : 0;
1881 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
1882 &(cmd.m_curbeData.SpDelta), 14 * sizeof(uint32_t),
1883 CodechalEncoderState::m_encodeSearchPath[tableIdx][meMethod],
1884 14 * sizeof(uint32_t)));
1885
1886 // r5
1887 cmd.m_curbeData.DW32.m_4xMeMvOutputDataSurfIndex = m_meBindingTable.dwMEMVDataSurface ;
1888 cmd.m_curbeData.DW34.m_4xMeOutputDistSurfIndex = m_meBindingTable.dwMEDist;
1889 cmd.m_curbeData.DW35.m_4xMeOutputBrcDistSurfIndex = m_meBindingTable.dwMEBRCDist;
1890 cmd.m_curbeData.DW36.m_vmeFwdInterPredictionSurfIndex = m_meBindingTable.dwMECurrForFwdRef;
1891 cmd.m_curbeData.DW37.m_vmeBwdInterPredictionSurfIndex = m_meBindingTable.dwMECurrForBwdRef;
1892
1893 uint32_t krnStateIdx =
1894 (m_pictureCodingType == P_TYPE) ? CODECHAL_ENCODE_ME_IDX_P : CODECHAL_ENCODE_ME_IDX_B;
1895
1896 if (m_pictureCodingType == B_TYPE && CodecHal_PictureIsInvalid(m_picParams->m_refFrameList[1]))
1897 {
1898 krnStateIdx = CODECHAL_ENCODE_ME_IDX_P;
1899 }
1900 auto kernelState = &m_meKernelStates[krnStateIdx];
1901
1902 CODECHAL_ENCODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
1903 &cmd,
1904 kernelState->dwCurbeOffset,
1905 cmd.m_byteSize));
1906 return eStatus;
1907
1908 }
1909
SendMeSurfaces(PMOS_COMMAND_BUFFER cmdBuffer)1910 MOS_STATUS CodechalEncodeMpeg2G9::SendMeSurfaces(
1911 PMOS_COMMAND_BUFFER cmdBuffer)
1912 {
1913 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1914
1915 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
1916
1917 auto meBindingTable = &m_meBindingTable;
1918 CODECHAL_ENCODE_CHK_NULL_RETURN(meBindingTable);
1919 PMOS_SURFACE currScaledSurface = m_trackedBuf->Get4xDsSurface(CODEC_CURR_TRACKED_BUFFER);
1920 PMOS_SURFACE meMvDataBuffer = &m_4xMEMVDataBuffer;
1921
1922 // Reference height and width information should be taken from the current scaled surface rather
1923 // than from the reference scaled surface in the case of PAFF.
1924 auto bufWidth = MOS_ALIGN_CEIL(m_downscaledWidthInMb4x * 32, 64);
1925 auto bufHeight =
1926 m_downscaledHeightInMb4x * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER;
1927
1928 // Force the values
1929 meMvDataBuffer->dwWidth = bufWidth;
1930 meMvDataBuffer->dwHeight = bufHeight;
1931 meMvDataBuffer->dwPitch = bufWidth;
1932
1933 uint32_t krnStateIdx =
1934 (m_pictureCodingType == P_TYPE) ? CODECHAL_ENCODE_ME_IDX_P : CODECHAL_ENCODE_ME_IDX_B;
1935
1936 if (m_pictureCodingType == B_TYPE && CodecHal_PictureIsInvalid(m_picParams->m_refFrameList[1]))
1937 {
1938 krnStateIdx = CODECHAL_ENCODE_ME_IDX_P;
1939 }
1940 auto kernelState = &m_meKernelStates[krnStateIdx];
1941
1942 CODECHAL_SURFACE_CODEC_PARAMS surfaceParams;
1943 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
1944 surfaceParams.bIs2DSurface = true;
1945 surfaceParams.bMediaBlockRW = true;
1946 surfaceParams.psSurface = meMvDataBuffer;
1947 surfaceParams.dwOffset = m_memvBottomFieldOffset;
1948 surfaceParams.dwCacheabilityControl =
1949 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
1950 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEMVDataSurface;
1951 surfaceParams.bIsWritable = true;
1952 surfaceParams.bRenderTarget = true;
1953 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
1954 m_hwInterface,
1955 cmdBuffer,
1956 &surfaceParams,
1957 kernelState));
1958
1959 // Insert Distortion buffers only for 4xMe case
1960 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
1961 surfaceParams.bIs2DSurface = true;
1962 surfaceParams.bMediaBlockRW = true;
1963 surfaceParams.psSurface = &m_brcBuffers.sMeBrcDistortionBuffer;
1964 surfaceParams.dwOffset = m_brcBuffers.dwMeBrcDistortionBottomFieldOffset;
1965 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBRCDist;
1966 surfaceParams.dwCacheabilityControl =
1967 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE].Value;
1968 surfaceParams.bIsWritable = true;
1969 surfaceParams.bRenderTarget = true;
1970 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
1971 m_hwInterface,
1972 cmdBuffer,
1973 &surfaceParams,
1974 kernelState));
1975
1976 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
1977 surfaceParams.bIs2DSurface = true;
1978 surfaceParams.bMediaBlockRW = true;
1979 surfaceParams.psSurface = &m_4xMEDistortionBuffer;
1980 surfaceParams.dwOffset = m_meDistortionBottomFieldOffset;
1981 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEDist;
1982 surfaceParams.dwCacheabilityControl =
1983 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
1984 surfaceParams.bIsWritable = true;
1985 surfaceParams.bRenderTarget = true;
1986 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
1987 m_hwInterface,
1988 cmdBuffer,
1989 &surfaceParams,
1990 kernelState));
1991
1992 bool currFieldPicture = CodecHal_PictureIsField(m_currOriginalPic) ? 1 : 0;
1993 bool currBottomField = CodecHal_PictureIsBottomField(m_currOriginalPic) ? 1 : 0;
1994 uint8_t currVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME :
1995 ((currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
1996 uint32_t refScaledBottomFieldOffset = 0;
1997 auto refScaledSurface = *currScaledSurface;
1998
1999 // Setup references 1...n
2000 // LIST 0 references
2001 CODEC_PICTURE refPic = m_picParams->m_refFrameList[0];
2002 // no need to modify index if picture is invalid
2003 if (refPic.PicFlags != PICTURE_INVALID)
2004 {
2005 refPic.FrameIdx = 0;
2006 }
2007
2008 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
2009 {
2010 // Current Picture Y - VME
2011 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
2012 surfaceParams.bUseAdvState = true;
2013 surfaceParams.psSurface = currScaledSurface;
2014 surfaceParams.dwOffset = currBottomField ? (uint32_t)m_scaledBottomFieldOffset : 0;
2015 surfaceParams.dwCacheabilityControl =
2016 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
2017 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForFwdRef;
2018 surfaceParams.ucVDirection = currVDirection;
2019 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
2020 m_hwInterface,
2021 cmdBuffer,
2022 &surfaceParams,
2023 kernelState));
2024
2025 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
2026 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
2027 uint8_t scaledIdx = m_refList[refPicIdx]->ucScalingIdx;
2028 // for 4xMe
2029 MOS_SURFACE* p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
2030 if (p4xSurface != nullptr)
2031 {
2032 refScaledSurface.OsResource = p4xSurface->OsResource;
2033 }
2034 else
2035 {
2036 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
2037 }
2038 refScaledBottomFieldOffset = refBottomField ? (uint32_t)m_scaledBottomFieldOffset : 0;
2039
2040 // L0 Reference Picture Y - VME
2041 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
2042 surfaceParams.bUseAdvState = true;
2043 surfaceParams.psSurface = &refScaledSurface;
2044 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
2045 surfaceParams.dwCacheabilityControl =
2046 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
2047 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEFwdRefPicIdx[0];
2048 surfaceParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME :
2049 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
2050 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
2051 m_hwInterface,
2052 cmdBuffer,
2053 &surfaceParams,
2054 kernelState));
2055 }
2056
2057 // Setup references 1...n
2058 // LIST 1 references
2059 refPic = m_picParams->m_refFrameList[1];
2060 // no need to modify index if picture is invalid
2061 if (refPic.PicFlags != PICTURE_INVALID)
2062 {
2063 refPic.FrameIdx = 1;
2064 }
2065 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
2066 {
2067 // Current Picture Y - VME
2068 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
2069 surfaceParams.bUseAdvState = true;
2070 surfaceParams.psSurface = currScaledSurface;
2071 surfaceParams.dwOffset = currBottomField ? (uint32_t)m_scaledBottomFieldOffset : 0;
2072 surfaceParams.dwCacheabilityControl =
2073 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
2074 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForBwdRef;
2075 surfaceParams.ucVDirection = currVDirection;
2076 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
2077 m_hwInterface,
2078 cmdBuffer,
2079 &surfaceParams,
2080 kernelState));
2081
2082 bool refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
2083 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
2084 uint8_t scaledIdx = m_refList[refPicIdx]->ucScalingIdx;
2085
2086 // for 4xMe
2087 MOS_SURFACE* p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
2088 if (p4xSurface != nullptr)
2089 {
2090 refScaledSurface.OsResource = p4xSurface->OsResource;
2091 }
2092 else
2093 {
2094 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
2095 }
2096 refScaledBottomFieldOffset = refBottomField ? (uint32_t)m_scaledBottomFieldOffset : 0;
2097
2098 // L1 Reference Picture Y - VME
2099 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
2100 surfaceParams.bUseAdvState = true;
2101 surfaceParams.psSurface = &refScaledSurface;
2102 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
2103 surfaceParams.dwCacheabilityControl =
2104 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
2105 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBwdRefPicIdx[0];
2106 surfaceParams.ucVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME :
2107 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
2108 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
2109 m_hwInterface,
2110 cmdBuffer,
2111 &surfaceParams,
2112 kernelState));
2113 }
2114
2115 return eStatus;
2116 }
2117
SetCurbeMbEnc(bool mbEncIFrameDistEnabled,bool mbQpDataEnabled)2118 MOS_STATUS CodechalEncodeMpeg2G9::SetCurbeMbEnc(
2119 bool mbEncIFrameDistEnabled,
2120 bool mbQpDataEnabled)
2121 {
2122 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2123
2124 CODECHAL_ENCODE_FUNCTION_ENTER;
2125
2126 uint16_t picWidthInMb = mbEncIFrameDistEnabled ?
2127 (uint16_t)m_downscaledWidthInMb4x : m_picWidthInMb;
2128 uint16_t fieldFrameHeightInMb = mbEncIFrameDistEnabled ?
2129 (uint16_t)m_downscaledFrameFieldHeightInMb4x : m_frameFieldHeightInMb;
2130 uint8_t codingType = m_mbEncForcePictureCodingType ?
2131 m_mbEncForcePictureCodingType : (uint8_t)m_pictureCodingType;
2132
2133 MbEncCurbeG9 cmd(codingType);
2134
2135 // Set CURBE data as per
2136 cmd.m_curbeData.DW0.m_isInterlacedFrameFlag =
2137 (CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic)) ? (m_picParams->m_fieldCodingFlag || m_picParams->m_fieldFrameCodingFlag) : 0;
2138 cmd.m_curbeData.DW0.m_isTopFieldFirst = cmd.m_curbeData.DW0.m_isInterlacedFrameFlag ? !m_picParams->m_interleavedFieldBFF : 0;
2139 cmd.m_curbeData.DW0.m_forceToSkip = 0;
2140 cmd.m_curbeData.DW4.m_pictureType = codingType;
2141 cmd.m_curbeData.DW4.m_fieldFlag = (CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic)) ? 0 : 1;
2142 cmd.m_curbeData.DW4.m_picWidth = picWidthInMb;
2143 cmd.m_curbeData.DW4.m_picHeightMinus1 = fieldFrameHeightInMb - 1;
2144
2145 cmd.m_curbeData.DW7.m_bilinearEnable = 1;
2146 cmd.m_curbeData.DW7.m_mvCostScaleFactor = 1; // half-pel
2147 cmd.m_curbeData.DW7.m_idmShapeMode = 0;
2148
2149 cmd.m_curbeData.DW9.m_srcAccess = cmd.m_curbeData.DW9.m_refAccess = 0;
2150 cmd.m_curbeData.DW9.m_fieldCacheAllocationDis = 0;
2151
2152 // This is approximation using first slice
2153 // MPEG2 quantiser_scale_code legal range is [1, 31] inclusive
2154 if (m_sliceParams->m_quantiserScaleCode < 1)
2155 {
2156 m_sliceParams->m_quantiserScaleCode = 1;
2157 }
2158 else if (m_sliceParams->m_quantiserScaleCode > 31)
2159 {
2160 m_sliceParams->m_quantiserScaleCode = 31;
2161 }
2162
2163 cmd.m_curbeData.DW9.m_mbQPEnable = mbQpDataEnabled;
2164 cmd.m_curbeData.DW11.m_qpScaleCode = m_sliceParams->m_quantiserScaleCode;
2165 cmd.m_curbeData.DW2.m_maxNumSU = 0x10;
2166 cmd.m_curbeData.DW12.m_isFastMode = 0;
2167
2168 if (m_seqParams ->m_rateControlMethod == RATECONTROL_CQP)
2169 {
2170 cmd.m_curbeData.DW13.m_panicModeMBThreshold = 0xFFFF;
2171 }
2172
2173 cmd.m_curbeData.DW14.m_forwardHorizontalSearchRange = 4 << m_picParams->m_fcode00;
2174 cmd.m_curbeData.DW14.m_forwardVerticalSearchRange = 4 << m_picParams->m_fcode01;
2175 cmd.m_curbeData.DW15.m_backwardHorizontalSearchRange = 4 << m_picParams->m_fcode10;
2176 cmd.m_curbeData.DW15.m_backwardVerticalSearchRange = 4 << m_picParams->m_fcode11;
2177
2178 if (codingType == I_TYPE)
2179 {
2180 cmd.m_curbeData.DW2.m_value = 0;
2181 cmd.m_curbeData.DW4.m_pictureType = 0;
2182 cmd.m_curbeData.DW9.m_intraSAD = 0x2;
2183
2184 // Modify CURBE for distortion calculation.
2185 if (mbEncIFrameDistEnabled)
2186 {
2187 cmd.m_curbeData.DW4.m_iFrameMBDistortionDumpEnable = true;
2188 }
2189 else
2190 {
2191 // Make sure the distortion dump flag is disabled for the normal MBEnc case.
2192 // No need to reset the height and width since they are set
2193 // correctly above this if-else and not modified after.
2194 cmd.m_curbeData.DW4.m_iFrameMBDistortionDumpEnable = false;
2195 }
2196 }
2197 else if (codingType == P_TYPE)
2198 {
2199 cmd.m_curbeData.DW1.m_uniMixDisable = 0;
2200 cmd.m_curbeData.DW1.m_biWeight = 32;
2201 cmd.m_curbeData.DW2.m_maxLenSP = 0x09;
2202 cmd.m_curbeData.DW4.m_pictureType = 1;
2203 cmd.m_curbeData.DW9.m_interSAD = 2;
2204 cmd.m_curbeData.DW9.m_intraSAD = 2;
2205 cmd.m_curbeData.DW9.m_searchCtrl = 0;
2206 cmd.m_curbeData.DW9.m_subPelMode = 1;
2207 cmd.m_curbeData.DW9.m_skipType = 0;
2208 cmd.m_curbeData.DW9.m_subMbPartMask = 0x7E;
2209 cmd.m_curbeData.DW10.m_refWidth = 48;
2210 cmd.m_curbeData.DW10.m_refHeight = 40;
2211 cmd.m_curbeData.DW12.m_distScaleFactor = 0;
2212 cmd.m_curbeData.DW7.m_skipCenterMask = 0x55;
2213
2214 //Motion vector cost is taken from VME_LUTXY
2215 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2216 &(cmd.m_curbeData.MvCost),
2217 sizeof(uint32_t)* 2,
2218 m_vmeLutXyP,
2219 sizeof(uint32_t)* 2));
2220
2221 //VME_SEARCH_PATH
2222 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2223 &(cmd.m_curbeData.VmeSPath0),
2224 sizeof(uint32_t)* 16,
2225 m_vmeSPathP0,
2226 sizeof(uint32_t)* 16));
2227
2228 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2229 &(cmd.m_curbeData.VmeSPath1),
2230 sizeof(uint32_t)* 16,
2231 m_vmeSPathP1,
2232 sizeof(uint32_t)* 16));
2233
2234 //Interlaced motion vector cost is the same as progressive P frame
2235 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2236 &(cmd.m_curbeData.VmeSPath1.MvCostInterlace),
2237 sizeof(uint32_t)* 2,
2238 m_vmeLutXyP,
2239 sizeof(uint32_t)* 2));
2240
2241 }
2242 else// B_TYPE
2243 {
2244 cmd.m_curbeData.DW1.m_biWeight = 32;
2245 cmd.m_curbeData.DW1.m_refPixShift = 0;
2246 cmd.m_curbeData.DW2.m_maxLenSP = 0x05;
2247 cmd.m_curbeData.DW4.m_pictureType = 2;
2248 cmd.m_curbeData.DW9.m_subMbPartMask = 0x7E;
2249 cmd.m_curbeData.DW9.m_subPelMode = 1;
2250 cmd.m_curbeData.DW9.m_skipType = 0;
2251 cmd.m_curbeData.DW9.m_searchCtrl = 7;
2252 cmd.m_curbeData.DW9.m_interSAD = 2;
2253 cmd.m_curbeData.DW9.m_intraSAD = 2;
2254 cmd.m_curbeData.DW10.m_refWidth = 32;
2255 cmd.m_curbeData.DW10.m_refHeight = 32;
2256 cmd.m_curbeData.DW7.m_skipCenterMask = 0xFF;
2257
2258 switch (m_picParams->m_gopRefDist)
2259 {
2260 case 3:
2261 cmd.m_curbeData.DW12.m_distScaleFactor = (m_frameNumB > 1) ? 43 : 21;
2262 break;
2263 case 4:
2264 cmd.m_curbeData.DW12.m_distScaleFactor = (m_frameNumB << 4);
2265 break;
2266 default:
2267 cmd.m_curbeData.DW12.m_distScaleFactor = 32;
2268 break;
2269 }
2270
2271 //Motion vector cost is taken from VME_LUTXY
2272 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2273 &(cmd.m_curbeData.MvCost), sizeof(uint32_t)* 2,
2274 m_vmeLutXyB,
2275 sizeof(uint32_t)* 2));
2276
2277 //VME_SEARCH_PATH
2278 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2279 &(cmd.m_curbeData.VmeSPath0),
2280 sizeof(uint32_t)* 16,
2281 m_vmeSPathB0,
2282 sizeof(uint32_t)* 16));
2283
2284 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2285 &(cmd.m_curbeData.VmeSPath1),
2286 sizeof(uint32_t)* 16,
2287 m_vmeSPathB1,
2288 sizeof(uint32_t)* 16));
2289
2290 //Interlaced motion vector cost is the same as progressive P frame
2291 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
2292 &(cmd.m_curbeData.VmeSPath1.MvCostInterlace),
2293 sizeof(uint32_t)* 2,
2294 m_vmeLutXyP,
2295 sizeof(uint32_t)* 2));
2296
2297 }
2298
2299 //ModeCost for P/B pictures
2300 if (codingType != I_TYPE)
2301 {
2302 cmd.m_curbeData.VmeSPath0.DW30.m_value = 0x83; // Setting mode 0 cost to 0x83 (131)
2303 cmd.m_curbeData.VmeSPath0.DW31.m_value = 0x41414141; // Set mode 4, 5, 6, 7 costs to 0x41 (67)
2304 cmd.m_curbeData.DW8.m_mode8Cost = 0x41;
2305 }
2306
2307 cmd.m_curbeData.DW48.m_value = 0x05000000; // BB-End Command
2308 cmd.m_curbeData.DW49.m_value = m_mbEncBindingTable.m_mbEncPakObj;
2309 cmd.m_curbeData.DW50.m_value = m_mbEncBindingTable.m_mbEncPakObjPrev;
2310 cmd.m_curbeData.DW51.m_value = m_mbEncBindingTable.m_mbEncCurrentY;
2311 cmd.m_curbeData.DW52.m_value = m_mbEncBindingTable.m_mbEncCurrentPic; // Also FWD REF & BWD REF too, +1, +2 respectively
2312 cmd.m_curbeData.DW53.m_value = m_mbEncBindingTable.m_mbEncInterlaceFrameCurrentPic; // Also Int BWD Ref (+1)
2313 cmd.m_curbeData.DW54.m_value = m_mbEncBindingTable.m_mbEncBrcDistortionSurface;
2314 cmd.m_curbeData.DW55.m_value = m_mbEncBindingTable.m_mbEncMbControl;
2315
2316 PMHW_KERNEL_STATE kernelState;
2317 // Initialize DSH kernel region
2318 if (mbEncIFrameDistEnabled)
2319 {
2320 kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_IFRAMEDIST];
2321 }
2322 else
2323 {
2324 // wPictureCodingType: I_TYPE = 1, P_TYPE = 2, B_TYPE = 3
2325 // KernelStates are I: 0, P: 1, B: 2
2326 // m_mbEncKernelStates: I: m_mbEncKernelStates[0], P: m_mbEncKernelStates[1], B: m_mbEncKernelStates[2]
2327 uint32_t krnStateIdx = codingType - 1;
2328 kernelState = &m_mbEncKernelStates[krnStateIdx];
2329 }
2330 CODECHAL_ENCODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
2331 &cmd,
2332 kernelState->dwCurbeOffset,
2333 cmd.m_byteSize));
2334
2335 return eStatus;
2336
2337 }
2338
ExecuteKernelFunctions()2339 MOS_STATUS CodechalEncodeMpeg2G9::ExecuteKernelFunctions()
2340 {
2341 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2342
2343 CODECHAL_ENCODE_FUNCTION_ENTER;
2344
2345 CODECHAL_ENCODE_CHK_NULL_RETURN(m_picParams);
2346
2347 m_mbEncForcePictureCodingType = 0;
2348
2349 // use P_TYPE in G9 MbEnc kernel for B with invalid backward reference
2350 if (m_pictureCodingType == B_TYPE && CodecHal_PictureIsInvalid(m_picParams->m_refFrameList[1]))
2351 {
2352 m_mbEncForcePictureCodingType = P_TYPE;
2353 }
2354
2355 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeMpeg2::ExecuteKernelFunctions());
2356
2357 return eStatus;
2358 }