Debian Codegraph @

media_driver/agnostic/common/codec/hal/codechal_encode_mpeg2.cpp

raw
1 /*
2 * Copyright (c) 2017-2018, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_encode_mpeg2.cpp
24 //! \brief Defines base class for MPEG2 dual-pipe encoder.
25 //!
26 #include "codechal_encode_mpeg2.h"
27 #include "codechal_mmc_encode_mpeg2.h"
28 #include "codechal_kernel_hme.h"
29 #include "codeckrnheader.h"
30 #include "mos_os_cp_interface_specific.h"
31
32 #define CODECHAL_ENCODE_MPEG2_FCODE_X(width) ((width < 200) ? 3 : (width < 500) ? 4 : (width < 1400) ? 5 : 6)
33 #define CODECHAL_ENCODE_MPEG2_FCODE_Y(fcodeX) ((fcodeX > 5) ? 5 : fcodeX)
34
35 //!
36 //! \enum ProfileIdc
37 //! \brief Profile idc
38 //!
39 enum ProfileIdc
40 {
41 highProfile = 0x10,
42 spatialProfile = 0x20,
43 snrProfile = 0x30,
44 mainProfile = 0x40,
45 simpleProfile = 0x50
46 } ;
47
48 //!
49 //! \enum LevelIdc
50 //! \brief Level idc
51 //!
52 enum LevelIdc
53 {
54 levelHighP = 2,
55 levelHigh = 4,
56 levelHigh1440 = 6,
57 levelMain = 8,
58 levelLow = 10
59 } ;
60
61 //!
62 //! \enum StartCode
63 //! \brief Start code
64 //!
65 enum StartCode
66 {
67 startCodePrefix = 0x000001, // bit string 0000 0000 0000 0000 0000 0001
68 startCodePicture = 0x00,
69 // slice_start_code = 0x01..0xAF, it is the slice_vertical_position for the slice
70 // 0xB0, 0xB1, 0xB6 - Reserved
71 startCodeUserData = 0xB2,
72 startCodeSequenceHeader = 0xB3,
73 startCodeSequenceError = 0xB4,
74 startCodeExtension = 0xB5,
75 startCodeSequenceEnd = 0xB7,
76 startCodeGroupStart = 0xB8
77 // system start codes = 0xB9..0xFF
78 } ;
79
80 //!
81 //! \enum BingdingTableOffsetBrcInitReset
82 //! \brief Bingding table offset brc init reset
83 //!
84 enum BingdingTableOffsetBrcInitReset
85 {
86 brcInitResetHistory = 0,
87 brcInitResetDistortion = 1,
88 brcInitResetNumBindingTableEntries = 2
89 } ;
90
91 //!
92 //! \enum BindingTableOffsetBrcUpdate
93 //! \brief Binding table offset brc update
94 //!
95 enum BindingTableOffsetBrcUpdate
96 {
97 brcUpdateHistory = 0,
98 brcUpdatePakStaticOutput = 1,
99 brcUpdatePictureStateRead = 2,
100 brcUpdatePictureStateWrite = 3,
101 brcUpdateMbencCurbeRead = 4,
102 brcUpdateMbencCurbeWrite = 5,
103 brcUpdateDistortion = 6,
104 brcUpdateConstantData = 7,
105 brcUpdatePicHeaderInputData = 8,
106 brcUpdateOutputData = 9,
107 brcUpdateNumBindingTableEntries = 10
108 } ;
109
110 //!
111 //! \class BrcInitResetCurbe
112 //! \brief Brc initialization reset curbe
113 //!
114 class BrcInitResetCurbe
115 {
116 public:
117 //!
118 //! \struct CurbeData
119 //! \brief Curbe data
120 //!
121 struct CurbeData
122 {
123 union
124 {
125 struct
126 {
127 uint32_t m_profileLevelMaxFrame : MOS_BITFIELD_RANGE(0,31);
128 };
129 struct
130 {
131 uint32_t m_value;
132 };
133 } DW0;
134
135 union
136 {
137 struct
138 {
139 uint32_t m_initBufFullInBits : MOS_BITFIELD_RANGE(0,31);
140 };
141 struct
142 {
143 uint32_t m_value;
144 };
145 } DW1;
146
147 union
148 {
149 struct
150 {
151 uint32_t m_bufSizeInBits : MOS_BITFIELD_RANGE(0,31);
152 };
153 struct
154 {
155 uint32_t m_value;
156 };
157 } DW2;
158
159 union
160 {
161 struct
162 {
163 uint32_t m_averageBitRate : MOS_BITFIELD_RANGE(0,31);
164 };
165 struct
166 {
167 uint32_t m_value;
168 };
169 } DW3;
170
171 union
172 {
173 struct
174 {
175 uint32_t m_maxBitRate : MOS_BITFIELD_RANGE(0,31);
176 };
177 struct
178 {
179 uint32_t m_value;
180 };
181 } DW4;
182
183 union
184 {
185 struct
186 {
187 uint32_t m_minBitRate : MOS_BITFIELD_RANGE(0,31);
188 };
189 struct
190 {
191 uint32_t m_value;
192 };
193 } DW5;
194
195 union
196 {
197 struct
198 {
199 uint32_t m_frameRateM : MOS_BITFIELD_RANGE(0,31);
200 };
201 struct
202 {
203 uint32_t m_value;
204 };
205 } DW6;
206
207 union
208 {
209 struct
210 {
211 uint32_t m_frameRateD : MOS_BITFIELD_RANGE(0,31);
212 };
213 struct
214 {
215 uint32_t m_value;
216 };
217 } DW7;
218
219 union
220 {
221 struct
222 {
223 uint32_t m_brcFlag : MOS_BITFIELD_RANGE(0,15);
224 uint32_t m_gopP : MOS_BITFIELD_RANGE(16,31);
225 };
226 struct
227 {
228 uint32_t m_value;
229 };
230 } DW8;
231
232 union
233 {
234 struct
235 {
236 uint32_t m_gopB : MOS_BITFIELD_RANGE(0,15);
237 uint32_t m_frameWidthInBytes : MOS_BITFIELD_RANGE(16,31);
238 };
239 struct
240 {
241 uint32_t m_value;
242 };
243 } DW9;
244
245 union
246 {
247 struct
248 {
249 uint32_t m_frameHeightInBytes : MOS_BITFIELD_RANGE(0,15);
250 uint32_t m_avbrAccuracy : MOS_BITFIELD_RANGE(16,31);
251 };
252 struct
253 {
254 uint32_t m_value;
255 };
256 } DW10;
257
258 union
259 {
260 struct
261 {
262 uint32_t m_avbrConvergence : MOS_BITFIELD_RANGE(0,15);
263 uint32_t m_minQP : MOS_BITFIELD_RANGE(16,31);
264 };
265 struct
266 {
267 uint32_t m_value;
268 };
269 } DW11;
270
271 union
272 {
273 struct
274 {
275 uint32_t m_maxQP : MOS_BITFIELD_RANGE(0,15);
276 uint32_t m_noSlices : MOS_BITFIELD_RANGE(16,31);
277 };
278 struct
279 {
280 uint32_t m_value;
281 };
282 } DW12;
283
284 union
285 {
286 struct
287 {
288 uint32_t m_instantRateThreshold0ForP : MOS_BITFIELD_RANGE(0,7);
289 uint32_t m_instantRateThreshold1ForP : MOS_BITFIELD_RANGE(8,15);
290 uint32_t m_instantRateThreshold2ForP : MOS_BITFIELD_RANGE(16,23);
291 uint32_t m_instantRateThreshold3ForP : MOS_BITFIELD_RANGE(24,31);
292 };
293 struct
294 {
295 uint32_t m_value;
296 };
297 } DW13;
298
299 union
300 {
301 struct
302 {
303 uint32_t m_instantRateThreshold0ForB : MOS_BITFIELD_RANGE(0,7);
304 uint32_t m_instantRateThreshold1ForB : MOS_BITFIELD_RANGE(8,15);
305 uint32_t m_instantRateThreshold2ForB : MOS_BITFIELD_RANGE(16,23);
306 uint32_t m_instantRateThreshold3ForB : MOS_BITFIELD_RANGE(24,31);
307 };
308 struct
309 {
310 uint32_t m_value;
311 };
312 } DW14;
313
314 union
315 {
316 struct
317 {
318 uint32_t m_instantRateThreshold0ForI : MOS_BITFIELD_RANGE(0,7);
319 uint32_t m_instantRateThreshold1ForI : MOS_BITFIELD_RANGE(8,15);
320 uint32_t m_instantRateThreshold2ForI : MOS_BITFIELD_RANGE(16,23);
321 uint32_t m_instantRateThreshold3ForI : MOS_BITFIELD_RANGE(24,31);
322 };
323 struct
324 {
325 uint32_t m_value;
326 };
327 } DW15;
328
329 union
330 {
331 struct
332 {
333 uint32_t m_deviationThreshold0ForPandB : MOS_BITFIELD_RANGE(0,7); // Signed byte
334 uint32_t m_deviationThreshold1ForPandB : MOS_BITFIELD_RANGE(8,15); // Signed byte
335 uint32_t m_deviationThreshold2ForPandB : MOS_BITFIELD_RANGE(16,23); // Signed byte
336 uint32_t m_deviationThreshold3ForPandB : MOS_BITFIELD_RANGE(24,31); // Signed byte
337 };
338 struct
339 {
340 uint32_t m_value;
341 };
342 } DW16;
343
344 union
345 {
346 struct
347 {
348 uint32_t m_deviationThreshold4ForPandB : MOS_BITFIELD_RANGE(0,7); // Signed byte
349 uint32_t m_deviationThreshold5ForPandB : MOS_BITFIELD_RANGE(8,15); // Signed byte
350 uint32_t m_deviationThreshold6ForPandB : MOS_BITFIELD_RANGE(16,23); // Signed byte
351 uint32_t m_deviationThreshold7ForPandB : MOS_BITFIELD_RANGE(24,31); // Signed byte
352 };
353 struct
354 {
355 uint32_t m_value;
356 };
357 } DW17;
358
359 union
360 {
361 struct
362 {
363 uint32_t m_deviationThreshold0ForVBR : MOS_BITFIELD_RANGE(0,7); // Signed byte
364 uint32_t m_deviationThreshold1ForVBR : MOS_BITFIELD_RANGE(8,15); // Signed byte
365 uint32_t m_deviationThreshold2ForVBR : MOS_BITFIELD_RANGE(16,23); // Signed byte
366 uint32_t m_deviationThreshold3ForVBR : MOS_BITFIELD_RANGE(24,31); // Signed byte
367 };
368 struct
369 {
370 uint32_t m_value;
371 };
372 } DW18;
373
374 union
375 {
376 struct
377 {
378 uint32_t m_deviationThreshold4ForVBR : MOS_BITFIELD_RANGE(0,7); // Signed byte
379 uint32_t m_deviationThreshold5ForVBR : MOS_BITFIELD_RANGE(8,15); // Signed byte
380 uint32_t m_deviationThreshold6ForVBR : MOS_BITFIELD_RANGE(16,23); // Signed byte
381 uint32_t m_deviationThreshold7ForVBR : MOS_BITFIELD_RANGE(24,31); // Signed byte
382 };
383 struct
384 {
385 uint32_t m_value;
386 };
387 } DW19;
388
389 union
390 {
391 struct
392 {
393 uint32_t m_deviationThreshold0ForI : MOS_BITFIELD_RANGE(0,7); // Signed byte
394 uint32_t m_deviationThreshold1ForI : MOS_BITFIELD_RANGE(8,15); // Signed byte
395 uint32_t m_deviationThreshold2ForI : MOS_BITFIELD_RANGE(16,23); // Signed byte
396 uint32_t m_deviationThreshold3ForI : MOS_BITFIELD_RANGE(24,31); // Signed byte
397 };
398 struct
399 {
400 uint32_t m_value;
401 };
402 } DW20;
403
404 union
405 {
406 struct
407 {
408 uint32_t m_deviationThreshold4ForI : MOS_BITFIELD_RANGE(0,7); // Signed byte
409 uint32_t m_deviationThreshold5ForI : MOS_BITFIELD_RANGE(8,15); // Signed byte
410 uint32_t m_deviationThreshold6ForI : MOS_BITFIELD_RANGE(16,23); // Signed byte
411 uint32_t m_deviationThreshold7ForI : MOS_BITFIELD_RANGE(24,31); // Signed byte
412 };
413 struct
414 {
415 uint32_t m_value;
416 };
417 } DW21;
418
419 union
420 {
421 struct
422 {
423 uint32_t m_value;
424 };
425 } DW22;
426
427 union
428 {
429 struct
430 {
431 uint32_t m_value;
432 };
433 } DW23;
434
435 union
436 {
437 struct
438 {
439 uint32_t m_value;
440 };
441 } DW24;
442
443 union
444 {
445 struct
446 {
447 uint32_t m_value;
448 };
449 } DW25;
450 }m_curbeData;
451
452 //!
453 //! \brief Constructor
454 //!
455 BrcInitResetCurbe();
456
457 //!
458 //! \brief Destructor
459 //!
460 ~BrcInitResetCurbe(){};
461
462 static const size_t m_byteSize = sizeof(CurbeData);
463
464 };
465
466 //!
467 //! \struct BrcUpdateCurbe
468 //! \brief BRC update curbe
469 //!
470 class BrcUpdateCurbe
471 {
472 public:
473 //!
474 //! \struct CurbeData
475 //! \brief Curbe data
476 //!
477 struct CurbeData
478 {
479 union
480 {
481 struct
482 {
483 uint32_t m_targetSize : MOS_BITFIELD_RANGE(0,31);
484 };
485 struct
486 {
487 uint32_t m_value;
488 };
489 } DW0;
490
491 union
492 {
493 struct
494 {
495 uint32_t m_frameNumber : MOS_BITFIELD_RANGE(0,31);
496 };
497 struct
498 {
499 uint32_t m_value;
500 };
501 } DW1;
502
503 union
504 {
505 struct
506 {
507 uint32_t m_sliceNumber : MOS_BITFIELD_RANGE(0,31);
508 };
509 struct
510 {
511 uint32_t m_value;
512 };
513 } DW2;
514
515 union
516 {
517 struct
518 {
519 uint32_t m_startGAdjFrame0 : MOS_BITFIELD_RANGE(0,15);
520 uint32_t m_startGAdjFrame1 : MOS_BITFIELD_RANGE(16,31);
521 };
522 struct
523 {
524 uint32_t m_value;
525 };
526 } DW3;
527
528 union
529 {
530 struct
531 {
532 uint32_t m_startGAdjFrame2 : MOS_BITFIELD_RANGE(0,15);
533 uint32_t m_startGAdjFrame3 : MOS_BITFIELD_RANGE(16,31);
534 };
535 struct
536 {
537 uint32_t m_value;
538 };
539 } DW4;
540
541 union
542 {
543 struct
544 {
545 uint32_t m_targetSizeFlag : MOS_BITFIELD_RANGE(0,7);
546 uint32_t m_brcFlag : MOS_BITFIELD_RANGE(8,15);
547 uint32_t m_maxNumPAKs : MOS_BITFIELD_RANGE(16,23);
548 uint32_t m_currFrameType : MOS_BITFIELD_RANGE(24,31);
549 };
550 struct
551 {
552 uint32_t m_value;
553 };
554 } DW5;
555
556 // This offset indicates the byte position of the q_scale_type bit
557 // in the 2nd level batch buffer containing the INSERT_OBJ command
558 // for inserting the picture header data into the bitstream.
559 // This offset includes the 8 bytes of the INSERT command at the
560 // beginning of the buffer.
561 union
562 {
563 struct
564 {
565 uint32_t m_qScaleTypeOffset : MOS_BITFIELD_RANGE(0,15);
566 uint32_t m_vbvDelay : MOS_BITFIELD_RANGE(16,31);
567 };
568 struct
569 {
570 uint32_t m_value;
571 };
572 } DW6;
573
574 // This size is the size of the entire 2nd level batch buffer
575 // containing the INSERT_OBJ command for inserting the
576 // picture header data into the bitstream. It includes the batch buffer end
577 // command at the end of the buffer.
578 union
579 {
580 struct
581 {
582 uint32_t m_picHeaderDataBufferSize :MOS_BITFIELD_RANGE(0,31);
583 };
584 struct
585 {
586 uint32_t m_value;
587 };
588
589 } DW7;
590
591 union
592 {
593 struct
594 {
595 uint32_t m_startGlobalAdjustMult0 : MOS_BITFIELD_RANGE(0,7);
596 uint32_t m_startGlobalAdjustMult1 : MOS_BITFIELD_RANGE(8,15);
597 uint32_t m_startGlobalAdjustMult2 : MOS_BITFIELD_RANGE(16,23);
598 uint32_t m_startGlobalAdjustMult3 : MOS_BITFIELD_RANGE(24,31);
599 };
600 struct
601 {
602 uint32_t m_value;
603 };
604 } DW8;
605
606 union
607 {
608 struct
609 {
610 uint32_t m_startGlobalAdjustMult4 : MOS_BITFIELD_RANGE(0,7);
611 uint32_t m_startGlobalAdjustDiv0 : MOS_BITFIELD_RANGE(8,15);
612 uint32_t m_startGlobalAdjustDiv1 : MOS_BITFIELD_RANGE(16,23);
613 uint32_t m_startGlobalAdjustDiv2 : MOS_BITFIELD_RANGE(24,31);
614 };
615 struct
616 {
617 uint32_t m_value;
618 };
619 } DW9;
620
621 union
622 {
623 struct
624 {
625 uint32_t m_startGlobalAdjustDiv3 : MOS_BITFIELD_RANGE(0,7);
626 uint32_t m_startGlobalAdjustDiv4 : MOS_BITFIELD_RANGE(8,15);
627 uint32_t m_qpThreshold0 : MOS_BITFIELD_RANGE(16,23);
628 uint32_t m_qpThreshold1 : MOS_BITFIELD_RANGE(24,31);
629 };
630 struct
631 {
632 uint32_t m_value;
633 };
634 } DW10;
635
636 union
637 {
638 struct
639 {
640 uint32_t m_qpThreshold2 : MOS_BITFIELD_RANGE(0,7);
641 uint32_t m_qpThreshold3 : MOS_BITFIELD_RANGE(8,15);
642 uint32_t m_gRateRatioThreshold0 : MOS_BITFIELD_RANGE(16,23);
643 uint32_t m_gRateRatioThreshold1 : MOS_BITFIELD_RANGE(24,31);
644 };
645 struct
646 {
647 uint32_t m_value;
648 };
649 } DW11;
650
651 union
652 {
653 struct
654 {
655 uint32_t m_gRateRatioThreshold2 : MOS_BITFIELD_RANGE(0,7);
656 uint32_t m_gRateRatioThreshold3 : MOS_BITFIELD_RANGE(8,15);
657 uint32_t m_gRateRatioThreshold4 : MOS_BITFIELD_RANGE(16,23);
658 uint32_t m_gRateRatioThreshold5 : MOS_BITFIELD_RANGE(24,31);
659 };
660 struct
661 {
662 uint32_t m_value;
663 };
664 } DW12;
665
666 union
667 {
668 struct
669 {
670 uint32_t m_gRateRatioThresholdQP0 : MOS_BITFIELD_RANGE(0,7);
671 uint32_t m_gRateRatioThresholdQP1 : MOS_BITFIELD_RANGE(8,15);
672 uint32_t m_gRateRatioThresholdQP2 : MOS_BITFIELD_RANGE(16,23);
673 uint32_t m_gRateRatioThresholdQP3 : MOS_BITFIELD_RANGE(24,31);
674 };
675 struct
676 {
677 uint32_t m_value;
678 };
679 } DW13;
680
681 union
682 {
683 struct
684 {
685 uint32_t m_gRateRatioThresholdQP4 : MOS_BITFIELD_RANGE(0,7);
686 uint32_t m_gRateRatioThresholdQP5 : MOS_BITFIELD_RANGE(8,15);
687 uint32_t m_gRateRatioThresholdQP6 : MOS_BITFIELD_RANGE(16,23);
688 uint32_t m_forceToSkip : MOS_BITFIELD_RANGE(24,24);
689 uint32_t m_reserved25 : MOS_BITFIELD_RANGE(25,31);
690 };
691 struct
692 {
693 uint32_t m_value;
694 };
695 } DW14;
696
697 union
698 {
699 struct
700 {
701 uint32_t m_extraHeaders : MOS_BITFIELD_RANGE(0,15);
702 uint32_t m_intraDcPrecisionOffset : MOS_BITFIELD_RANGE(16,31);
703 };
704 struct
705 {
706 uint32_t m_value;
707 };
708 } DW15;
709
710 union
711 {
712 struct
713 {
714 uint32_t m_value;
715 };
716 } DW16[16];
717
718 union
719 {
720 struct
721 {
722 uint32_t m_bindingTableIndex : MOS_BITFIELD_RANGE(0,31);
723 };
724 struct
725 {
726 uint32_t m_value;
727 };
728 } DW32[10];
729 }m_curbeData;
730
731 //!
732 //! \brief Constructor
733 //!
734 BrcUpdateCurbe();
735
736 //!
737 //! \brief Destructor
738 //!
739 ~BrcUpdateCurbe(){};
740
741 static const size_t m_byteSize = sizeof(CurbeData);
742
743 } ;
744
745 //!
746 //! \struct VLCode
747 //! \brief VL code
748 //!
749 struct VLCode{
750 uint32_t m_code;
751 uint32_t m_len;
752 };
753
754 //!
755 //! \struct MediaObjectInlineDataMpeg2
756 //! \brief Media object inline data
757 //!
758 struct MediaObjectInlineDataMpeg2
759 {
760 // DW0
761 union
762 {
763 struct
764 {
765 uint32_t m_mbX : 8; //<! in MB unit
766 uint32_t m_mbY : 8; //<! in MB unit
767 uint32_t m_reserved : 16;
768 };
769 struct
770 {
771 uint32_t m_value;
772 };
773 } DW0;
774
775 // uint32_t 1
776 union
777 {
778 struct
779 {
780 uint32_t m_lastMbInSliceGroup : 8;
781 uint32_t m_firstMbInSliceGroup : 8;
782 uint32_t m_lastMbInSlice : 8;
783 uint32_t m_firstMbInSlice : 8;
784 };
785 struct
786 {
787 uint32_t m_value;
788 };
789 } DW1;
790
791 // uint32_t 2
792 union
793 {
794 struct
795 {
796 uint32_t m_batchBufferEnd : 32;
797 };
798 struct
799 {
800 uint32_t m_value;
801 };
802 } DW2;
803 } ;
804
805 //!
806 //! \struct SliceRecord
807 //! \brief Slice record
808 //!
809 struct SliceRecord
810 {
811 // DW 1
812 union
813 {
814 struct
815 {
816 uint32_t m_lastMbInSliceGroup : 8;
817 uint32_t m_firstMbInSliceGroup : 8;
818 uint32_t m_lastMbInSlice : 8;
819 uint32_t m_firstMbInSlice : 8;
820 };
821 struct
822 {
823 uint32_t m_value;
824 };
825 } DW1;
826
827 // DW 2
828 union
829 {
830 struct
831 {
832 uint32_t m_batchBufferEnd : 32;
833 };
834 struct
835 {
836 uint32_t m_value;
837 };
838 } DW2;
839 } ;
840
841 /* VL codes for macroblock_address_increment ISO/IEC 13818-2, B.1, Table B-1. */
842 static const VLCode mpeg2AddrIncreamentTbl[35] =
843 {
844 { 0x00, 0 }, // forbidden m_value
845 { 0x01, 1 },
846 { 0x03, 3 }, { 0x02, 3 },
847 { 0x03, 4 }, { 0x02, 4 },
848 { 0x03, 5 }, { 0x02, 5 },
849 { 0x07, 7 }, { 0x06, 7 },
850 { 0x0b, 8 }, { 0x0a, 8 }, { 0x09, 8 }, { 0x08, 8 }, { 0x07, 8 }, { 0x06, 8 },
851 { 0x17, 10 }, { 0x16, 10 }, { 0x15, 10 }, { 0x14, 10 }, { 0x13, 10 }, { 0x12, 10 },
852 { 0x23, 11 }, { 0x22, 11 }, { 0x21, 11 }, { 0x20, 11 }, { 0x1f, 11 }, { 0x1e, 11 }, { 0x1d, 11 }, { 0x1c, 11 }, { 0x1b, 11 }, { 0x1a, 11 }, { 0x19, 11 }, { 0x18, 11 },
853 { 0x08, 11 } // macroblock_escape
854 };
855
856 /* VL codes for macroblock_type ISO/IEC 13818-2, B.2, Tables B-2, B-3, B-4. */
857 static const VLCode mpeg2MbTypeTbl[3][32] =
858 {
859 /* I */
860 {
861 { 0x00, 0 }, { 0x01, 1 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
862 { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
863 { 0x00, 0 }, { 0x01, 2 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
864 { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }
865 },
866 /* P */
867 {
868 { 0x00, 0 }, { 0x03, 5 }, { 0x01, 2 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
869 { 0x01, 3 }, { 0x00, 0 }, { 0x01, 1 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
870 { 0x00, 0 }, { 0x01, 6 }, { 0x01, 5 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 },
871 { 0x00, 0 }, { 0x00, 0 }, { 0x02, 5 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }
872 },
873 /* B */
874 {
875 { 0x00, 0 }, { 0x03, 5 }, { 0x00, 0 }, { 0x00, 0 }, { 0x02, 3 }, { 0x00, 0 }, { 0x03, 3 }, { 0x00, 0 },
876 { 0x02, 4 }, { 0x00, 0 }, { 0x03, 4 }, { 0x00, 0 }, { 0x02, 2 }, { 0x00, 0 }, { 0x03, 2 }, { 0x00, 0 },
877 { 0x00, 0 }, { 0x01, 6 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x02, 6 }, { 0x00, 0 },
878 { 0x00, 0 }, { 0x00, 0 }, { 0x03, 6 }, { 0x00, 0 }, { 0x00, 0 }, { 0x00, 0 }, { 0x02, 5 }, { 0x00, 0 }
879 }
880 };
881
882 /* VL codes for motion_code+16 ISO/IEC 13818-2, B.4, Table B-10. */
883 static const VLCode mpeg2MvVlcTbl[33] =
884 {
885 // negative motion_code
886 { 0x19, 11 }, { 0x1b, 11 }, { 0x1d, 11 }, { 0x1f, 11 }, { 0x21, 11 }, { 0x23, 11 },
887 { 0x13, 10 }, { 0x15, 10 }, { 0x17, 10 },
888 { 0x07, 8 }, { 0x09, 8 }, { 0x0b, 8 },
889 { 0x07, 7 },
890 { 0x03, 5 },
891 { 0x03, 4 },
892 { 0x03, 3 },
893 // zero motion_code
894 { 0x01, 1 },
895 // positive motion_code
896 { 0x02, 3 },
897 { 0x02, 4 },
898 { 0x02, 5 },
899 { 0x06, 7 },
900 { 0x0a, 8 }, { 0x08, 8 }, { 0x06, 8 },
901 { 0x16, 10 }, { 0x14, 10 }, { 0x12, 10 },
902 { 0x22, 11 }, { 0x20, 11 }, { 0x1e, 11 }, { 0x1c, 11 }, { 0x1a, 11 }, { 0x18, 11 }
903 };
904
905 BrcInitResetCurbe::BrcInitResetCurbe()
906 {
907 CODECHAL_ENCODE_FUNCTION_ENTER;
908
909 MOS_ZeroMemory(&m_curbeData, m_byteSize);
910
911 m_curbeData.DW10.m_avbrAccuracy = 30;
912 m_curbeData.DW11.m_avbrConvergence = 150;
913 m_curbeData.DW11.m_minQP = 1;
914 m_curbeData.DW12.m_maxQP = 112;
915 m_curbeData.DW12.m_noSlices = 1;
916 m_curbeData.DW13.m_instantRateThreshold0ForP = 30;
917 m_curbeData.DW13.m_instantRateThreshold1ForP = 50;
918 m_curbeData.DW13.m_instantRateThreshold2ForP = 70;
919 m_curbeData.DW13.m_instantRateThreshold3ForP = 120;
920 m_curbeData.DW14.m_instantRateThreshold0ForB = 25;
921 m_curbeData.DW14.m_instantRateThreshold1ForB = 50;
922 m_curbeData.DW14.m_instantRateThreshold2ForB = 70;
923 m_curbeData.DW14.m_instantRateThreshold3ForB = 120;
924 m_curbeData.DW15.m_instantRateThreshold0ForI = 30;
925 m_curbeData.DW15.m_instantRateThreshold1ForI = 50;
926 m_curbeData.DW15.m_instantRateThreshold2ForI = 90;
927 m_curbeData.DW15.m_instantRateThreshold3ForI = 115;
928 m_curbeData.DW16.m_deviationThreshold0ForPandB = MOS_BITFIELD_VALUE((uint32_t)-45, 8);
929 m_curbeData.DW16.m_deviationThreshold1ForPandB = MOS_BITFIELD_VALUE((uint32_t)-33, 8);
930 m_curbeData.DW16.m_deviationThreshold2ForPandB = MOS_BITFIELD_VALUE((uint32_t)-23, 8);
931 m_curbeData.DW16.m_deviationThreshold3ForPandB = MOS_BITFIELD_VALUE((uint32_t)-15, 8);
932 m_curbeData.DW17.m_deviationThreshold4ForPandB = 15;
933 m_curbeData.DW17.m_deviationThreshold5ForPandB = 23;
934 m_curbeData.DW17.m_deviationThreshold6ForPandB = 35;
935 m_curbeData.DW17.m_deviationThreshold7ForPandB = 45;
936 m_curbeData.DW18.m_deviationThreshold0ForVBR = MOS_BITFIELD_VALUE((uint32_t)-45, 8);
937 m_curbeData.DW18.m_deviationThreshold1ForVBR = MOS_BITFIELD_VALUE((uint32_t)-35, 8);
938 m_curbeData.DW18.m_deviationThreshold2ForVBR = MOS_BITFIELD_VALUE((uint32_t)-25, 8);
939 m_curbeData.DW18.m_deviationThreshold3ForVBR = MOS_BITFIELD_VALUE((uint32_t)-15, 8);
940 m_curbeData.DW19.m_deviationThreshold4ForVBR = 40;
941 m_curbeData.DW19.m_deviationThreshold5ForVBR = 50;
942 m_curbeData.DW19.m_deviationThreshold6ForVBR = 75;
943 m_curbeData.DW19.m_deviationThreshold7ForVBR = 90;
944 m_curbeData.DW20.m_deviationThreshold0ForI = MOS_BITFIELD_VALUE((uint32_t)-40, 8);
945 m_curbeData.DW20.m_deviationThreshold1ForI = MOS_BITFIELD_VALUE((uint32_t)-30, 8);
946 m_curbeData.DW20.m_deviationThreshold2ForI = MOS_BITFIELD_VALUE((uint32_t)-17, 8);
947 m_curbeData.DW20.m_deviationThreshold3ForI = MOS_BITFIELD_VALUE((uint32_t)-10, 8);
948 m_curbeData.DW21.m_deviationThreshold4ForI = 10;
949 m_curbeData.DW21.m_deviationThreshold5ForI = 20;
950 m_curbeData.DW21.m_deviationThreshold6ForI = 33;
951 m_curbeData.DW21.m_deviationThreshold7ForI = 45;
952 m_curbeData.DW25.m_value = 1;
953 }
954
955 BrcUpdateCurbe::BrcUpdateCurbe()
956 {
957 CODECHAL_ENCODE_FUNCTION_ENTER;
958
959 MOS_ZeroMemory(&m_curbeData, m_byteSize);
960
961 m_curbeData.DW3.m_startGAdjFrame0 = 10;
962 m_curbeData.DW3.m_startGAdjFrame1 = 50;
963 m_curbeData.DW4.m_startGAdjFrame2 = 100;
964 m_curbeData.DW4.m_startGAdjFrame3 = 150;
965 m_curbeData.DW7.m_picHeaderDataBufferSize = 0;
966 m_curbeData.DW8.m_startGlobalAdjustMult0 = 1;
967 m_curbeData.DW8.m_startGlobalAdjustMult1 = 1;
968 m_curbeData.DW8.m_startGlobalAdjustMult2 = 3;
969 m_curbeData.DW8.m_startGlobalAdjustMult3 = 2;
970 m_curbeData.DW9.m_startGlobalAdjustMult4 = 1;
971 m_curbeData.DW9.m_startGlobalAdjustDiv0 = 40;
972 m_curbeData.DW9.m_startGlobalAdjustDiv1 = 5;
973 m_curbeData.DW9.m_startGlobalAdjustDiv2 = 5;
974 m_curbeData.DW10.m_startGlobalAdjustDiv3 = 3;
975 m_curbeData.DW10.m_startGlobalAdjustDiv4 = 1;
976 m_curbeData.DW10.m_qpThreshold0 = 7;
977 m_curbeData.DW10.m_qpThreshold1 = 18;
978 m_curbeData.DW11.m_qpThreshold2 = 25;
979 m_curbeData.DW11.m_qpThreshold3 = 37;
980 m_curbeData.DW11.m_gRateRatioThreshold0 = 40;
981 m_curbeData.DW11.m_gRateRatioThreshold1 = 75;
982 m_curbeData.DW12.m_gRateRatioThreshold2 = 97;
983 m_curbeData.DW12.m_gRateRatioThreshold3 = 103;
984 m_curbeData.DW12.m_gRateRatioThreshold4 = 125;
985 m_curbeData.DW12.m_gRateRatioThreshold5 = 160;
986 m_curbeData.DW13.m_gRateRatioThresholdQP0 = MOS_BITFIELD_VALUE((uint32_t)-3, 8);
987 m_curbeData.DW13.m_gRateRatioThresholdQP1 = MOS_BITFIELD_VALUE((uint32_t)-2, 8);
988 m_curbeData.DW13.m_gRateRatioThresholdQP2 = MOS_BITFIELD_VALUE((uint32_t)-1, 8);
989 m_curbeData.DW13.m_gRateRatioThresholdQP3 = 0;
990 m_curbeData.DW14.m_gRateRatioThresholdQP4 = 1;
991 m_curbeData.DW14.m_gRateRatioThresholdQP5 = 2;
992 m_curbeData.DW14.m_gRateRatioThresholdQP6 = 3;
993 m_curbeData.DW14.m_forceToSkip = 1;
994 m_curbeData.DW15.m_value = 0;
995 m_curbeData.DW16[0].m_value = 0x06040200;
996 m_curbeData.DW16[1].m_value = 0x0e0c0a08;
997 m_curbeData.DW16[2].m_value = 0x16141210;
998 m_curbeData.DW16[3].m_value = 0x1e1c1a18;
999 m_curbeData.DW16[4].m_value = 0x26242220;
1000 m_curbeData.DW16[5].m_value = 0x2e2c2a28;
1001 m_curbeData.DW16[6].m_value = 0x36343230;
1002 m_curbeData.DW16[7].m_value = 0x3e3c3a38;
1003 m_curbeData.DW16[8].m_value = 0x03020100;
1004 m_curbeData.DW16[9].m_value = 0x07060504;
1005 m_curbeData.DW16[10].m_value = 0x0e0c0a08;
1006 m_curbeData.DW16[11].m_value = 0x16141210;
1007 m_curbeData.DW16[12].m_value = 0x24201c18;
1008 m_curbeData.DW16[13].m_value = 0x34302c28;
1009 m_curbeData.DW16[14].m_value = 0x50484038;
1010 m_curbeData.DW16[15].m_value = 0x70686058;
1011
1012 for (uint8_t idx = 0; idx < 10 ; idx++)
1013 {
1014 m_curbeData.DW32[idx].m_bindingTableIndex = idx;
1015 }
1016 }
1017
1018 const uint8_t CodechalEncodeMpeg2::m_qpAdjustmentDistThresholdMaxFrameThresholdI[] = {
1019 0x01, 0x02, 0x03, 0x04, 0x05, 0x01, 0x01, 0x02, 0x03, 0x04,
1020 0x00, 0x00, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02,
1021 0xff, 0x00, 0x00, 0x00, 0x01, 0xfe, 0xfe, 0xff, 0x00, 0x00,
1022 0xfd, 0xfd, 0xff, 0xff, 0x00, 0xfc, 0xfd, 0xfe, 0xff, 0xff,
1023 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 0x00, 0x04, 0x1e, 0x3c, 0x50,
1024 0x78, 0x8c, 0xc8, 0xff, 0x0a, 0x0b, 0x0c, 0x0c, 0x0d, 0x00,
1025 0x00, 0x00, 0x00, 0x00};
1026
1027 const uint8_t CodechalEncodeMpeg2::m_qpAdjustmentDistThresholdMaxFrameThresholdP[] = {
1028 0x01, 0x02, 0x03, 0x04, 0x05, 0x01, 0x01, 0x02, 0x03, 0x04,
1029 0x00, 0x01, 0x01, 0x02, 0x03, 0x00, 0x00, 0x00, 0x01, 0x02,
1030 0xff, 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00,
1031 0xfe, 0xff, 0xff, 0xff, 0x00, 0xfc, 0xfe, 0xff, 0xff, 0x00,
1032 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x04, 0x1e, 0x3c, 0x50,
1033 0x78, 0x8c, 0xc8, 0xff, 0x04, 0x05, 0x06, 0x06, 0x07, 0x00,
1034 0x00, 0x00, 0x00, 0x00 };
1035
1036 const uint8_t CodechalEncodeMpeg2::m_qpAdjustmentDistThresholdMaxFrameThresholdB[] = {
1037 0x01, 0x01, 0x02, 0x03, 0x04, 0x01, 0x01, 0x01, 0x02, 0x03,
1038 0x00, 0x00, 0x01, 0x01, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01,
1039 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
1040 0xfe, 0xff, 0xff, 0xff, 0x00, 0xfd, 0xfe, 0xff, 0xff, 0x01,
1041 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x02, 0x14, 0x28, 0x46,
1042 0x82, 0xa0, 0xc8, 0xff, 0x04, 0x05, 0x06, 0x06, 0x07, 0x00,
1043 0x00, 0x00, 0x00, 0x00 };
1044
1045 const uint8_t CodechalEncodeMpeg2::m_distQpAdjustmentI[] = {
1046 0x00, 0x01, 0x01, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06, 0x00,
1047 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0xff, 0x00,
1048 0x00, 0x00, 0x01, 0x02, 0x02, 0x04, 0x05, 0xff, 0xff, 0x00,
1049 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0xfd, 0xfe, 0xff, 0x00,
1050 0x00, 0x00, 0x01, 0x02, 0x04, 0xfe, 0xfe, 0xff, 0xff, 0x00,
1051 0x00, 0x00, 0x01, 0x03, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00,
1052 0x00, 0x00, 0x02, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff,
1053 0x00, 0x01, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff,
1054 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1055 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1056
1057 const uint8_t CodechalEncodeMpeg2::m_distQpAdjustmentP[] = {
1058 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x05, 0x00,
1059 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0xff, 0x00,
1060 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x04, 0xff, 0xff, 0x00,
1061 0x00, 0x00, 0x01, 0x01, 0x01, 0x03, 0xfe, 0xff, 0xff, 0x00,
1062 0x00, 0x00, 0x01, 0x01, 0x03, 0xfe, 0xfe, 0xff, 0xff, 0x00,
1063 0x00, 0x00, 0x01, 0x02, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0x00,
1064 0x00, 0x00, 0x02, 0xfc, 0xfd, 0xfd, 0xfe, 0xfe, 0xff, 0xff,
1065 0x00, 0x01, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff,
1066 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1067 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1068
1069 const uint8_t CodechalEncodeMpeg2::m_distQpAdjustmentB[] = {
1070 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x04, 0x04, 0x00,
1071 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x00, 0x00,
1072 0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0xff, 0x00, 0x00,
1073 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0xfe, 0xff, 0x00, 0x00,
1074 0x00, 0x00, 0x01, 0x01, 0x02, 0xfe, 0xfe, 0xff, 0x00, 0x00,
1075 0x00, 0x00, 0x01, 0x01, 0xfd, 0xfe, 0xff, 0xff, 0x00, 0x00,
1076 0x00, 0x00, 0x01, 0xfc, 0xfd, 0xfd, 0xfe, 0xff, 0xff, 0x00,
1077 0x00, 0x00, 0xfb, 0xfc, 0xfd, 0xfe, 0xfe, 0xff, 0xff, 0xff,
1078 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1079 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1080
1081 const uint8_t CodechalEncodeMpeg2::m_targetUsageToKernelMode[] = {
1082 encodeNormalMode, encodeNormalMode,
1083 encodeNormalMode, encodeNormalMode,
1084 encodeNormalMode, encodeNormalMode,
1085 encodeNormalMode, encodeNormalMode };
1086
1087 const uint32_t CodechalEncodeMpeg2::m_vmeLutXyP[] = { 0x34262410, 0x46454436 };
1088
1089 const uint32_t CodechalEncodeMpeg2::m_vmeLutXyB[] = { 0x44363410, 0x56555446 };
1090
1091 const uint32_t CodechalEncodeMpeg2::m_vmeSPathP0[] = {
1092 0x1F11F10F, 0x2E22E2FE, 0x20E220DF, 0x2EDD06FC, 0x11D33FF1, 0xEB1FF33D, 0x02F1F1F1, 0x1F201111,
1093 0xF1EFFF0C, 0xF01104F1, 0x10FF0A50, 0x000FF1C0, 0x00000000, 0x00000000, 0x00000000, 0x00000000
1094 };
1095
1096 const uint32_t CodechalEncodeMpeg2::m_vmeSPathP1[] = {
1097 0x1F11F10F, 0x2E22E2FE, 0x20E220DF, 0xF1FB06FC, 0x0000D33F, 0x00000000, 0x00000000, 0x00000000,
1098 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
1099 };
1100
1101 const uint32_t CodechalEncodeMpeg2::m_vmeSPathB0[] = {
1102 0x120FF10F, 0x20E20F1F, 0x201EE2FD, 0x000D02D1, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1103 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
1104 };
1105
1106 const uint32_t CodechalEncodeMpeg2::m_vmeSPathB1[] = {
1107 0x120FF10F, 0x20E20F1F, 0x0000E2FD, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
1108 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000
1109 };
1110
1111 MOS_STATUS CodechalEncodeMpeg2::InitMmcState()
1112 {
1113 CODECHAL_ENCODE_FUNCTION_ENTER;
1114
1115 m_mmcState = MOS_New(CodechalMmcEncodeMpeg2, m_hwInterface, this);
1116 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
1117
1118 return MOS_STATUS_SUCCESS;
1119 }
1120
1121 CodechalEncodeMpeg2::CodechalEncodeMpeg2(
1122 CodechalHwInterface* hwInterface,
1123 CodechalDebugInterface* debugInterface,
1124 PCODECHAL_STANDARD_INFO standardInfo) :
1125 CodechalEncoderState(hwInterface, debugInterface, standardInfo)
1126 {
1127 CODECHAL_ENCODE_FUNCTION_ENTER;
1128
1129 CODECHAL_ENCODE_ASSERT(hwInterface);
1130 m_hwInterface = hwInterface;
1131 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetOsInterface());
1132 m_osInterface = m_hwInterface->GetOsInterface();
1133 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetMfxInterface());
1134 m_mfxInterface = m_hwInterface->GetMfxInterface();
1135 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetHcpInterface());
1136 m_hcpInterface = m_hwInterface->GetHcpInterface();
1137 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetHucInterface());
1138 m_hucInterface = m_hwInterface->GetHucInterface();
1139 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetVdencInterface());
1140 m_vdencInterface = m_hwInterface->GetVdencInterface();
1141 CODECHAL_ENCODE_ASSERT(m_hwInterface->GetMiInterface());
1142 m_miInterface = m_hwInterface->GetMiInterface();
1143 auto renderInterface = m_hwInterface->GetRenderInterface();
1144 CODECHAL_ENCODE_ASSERT(renderInterface);
1145 m_stateHeapInterface = renderInterface->m_stateHeapInterface;
1146 CODECHAL_ENCODE_ASSERT(m_stateHeapInterface);
1147
1148 MOS_ZeroMemory(&m_picIdx, sizeof(m_picIdx));
1149 MOS_ZeroMemory(&m_refList, sizeof(m_refList));
1150 MOS_ZeroMemory(&m_4xMEMVDataBuffer, sizeof(m_4xMEMVDataBuffer));
1151 MOS_ZeroMemory(&m_batchBufForMEDistBuffer, sizeof(m_batchBufForMEDistBuffer));
1152 MOS_ZeroMemory(&m_mbEncBindingTable, sizeof(m_mbEncBindingTable));
1153 MOS_ZeroMemory(&m_4xMEDistortionBuffer, sizeof(m_4xMEDistortionBuffer));
1154 MOS_ZeroMemory(&m_brcBuffers, sizeof(m_brcBuffers));
1155 MOS_ZeroMemory(&m_mbQpDataSurface, sizeof(m_mbQpDataSurface));
1156
1157 uint8_t i;
1158 for (i = 0; i < CODECHAL_ENCODE_BRC_IDX_NUM; i++)
1159 {
1160 m_brcKernelStates[i] = MHW_KERNEL_STATE();
1161 }
1162 for (i = 0; i < mbEncKernelIdxNum; i++)
1163 {
1164 m_mbEncKernelStates[i] = MHW_KERNEL_STATE();
1165 }
1166
1167 m_interlacedFieldDisabled = true;
1168
1169 // Always true since interlaced field is no longer supported.
1170 m_firstField = true;
1171 m_hwWalker = true;
1172 m_fieldScalingOutputInterleaved = true;
1173 m_hmeSupported = true;
1174 m_kuid = IDR_CODEC_AllMPEG2Enc;
1175
1176 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1177 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1178 MOS_UserFeature_ReadValue_ID(
1179 nullptr,
1180 __MEDIA_USER_FEATURE_VALUE_SINGLE_TASK_PHASE_ENABLE_ID,
1181 &userFeatureData,
1182 m_osInterface->pOsContext);
1183 m_singleTaskPhaseSupported = (userFeatureData.i32Data) ? true : false;
1184
1185 m_hwInterface->GetStateHeapSettings()->dwNumSyncTags = m_numSyncTags;
1186 m_hwInterface->GetStateHeapSettings()->dwDshSize = m_initDshSize;
1187
1188 m_useCmScalingKernel = true;
1189
1190 }
1191
1192 CodechalEncodeMpeg2::~CodechalEncodeMpeg2()
1193 {
1194 MOS_Delete(m_hmeKernel);
1195 }
1196
1197 MOS_STATUS CodechalEncodeMpeg2::Initialize(CodechalSetting * codecHalSettings)
1198 {
1199 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1200
1201 CODECHAL_ENCODE_FUNCTION_ENTER;
1202
1203 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::Initialize(codecHalSettings));
1204
1205 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface);
1206 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface);
1207 CODECHAL_ENCODE_CHK_NULL_RETURN(m_miInterface);
1208 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface);
1209
1210 m_frameNumB = 0;
1211
1212 // Offset + Size of MB + size of MV
1213 m_mbCodeStrideInDW = 16;
1214 uint32_t fieldNumMBs = m_picWidthInMb * ((m_picHeightInMb + 1) >> 1);
1215 // 12 DW for MB + 4 DW for MV
1216 m_mbCodeSize = fieldNumMBs * 2 * 16 * sizeof(uint32_t);
1217
1218 #if (_DEBUG || _RELEASE_INTERNAL)
1219 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
1220 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1221 MOS_UserFeature_ReadValue_ID(
1222 nullptr,
1223 __MEDIA_USER_FEATURE_VALUE_MPEG2_ENCODE_BRC_DISTORTION_BUFFER_ENABLE_ID,
1224 &userFeatureData,
1225 m_osInterface->pOsContext);
1226 m_brcDistortionBufferSupported = (userFeatureData.i32Data) ? true : false;
1227
1228 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
1229 MOS_UserFeature_ReadValue_ID(
1230 nullptr,
1231 __MEDIA_USER_FEATURE_VALUE_MPEG2_SLICE_STATE_ENABLE_ID,
1232 &userFeatureData,
1233 m_osInterface->pOsContext);
1234 m_sliceStateEnable = (userFeatureData.i32Data) ? true : false;
1235
1236 #endif
1237 // Initialize kernel State
1238 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelState());
1239
1240 if (m_singleTaskPhaseSupported)
1241 {
1242 m_maxBtCount = GetMaxBtCount();
1243 }
1244
1245 // Picture Level Commands
1246 m_hwInterface->GetMfxStateCommandsDataSize(
1247 CODECHAL_ENCODE_MODE_MPEG2,
1248 &m_pictureStatesSize,
1249 &m_picturePatchListSize,
1250 0);
1251
1252 // Slice Level Commands (cannot be placed in 2nd level batch)
1253 m_hwInterface->GetMfxPrimitiveCommandsDataSize(
1254 CODECHAL_ENCODE_MODE_MPEG2,
1255 &m_sliceStatesSize,
1256 &m_slicePatchListSize,
1257 0);
1258
1259 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitMmcState());
1260
1261 return eStatus;
1262 }
1263
1264 MOS_STATUS CodechalEncodeMpeg2::AllocateBuffer(
1265 PMOS_RESOURCE buffer,
1266 uint32_t bufSize,
1267 PCCHAR name)
1268 {
1269 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1270
1271 CODECHAL_ENCODE_CHK_NULL_RETURN(buffer);
1272
1273 MOS_ALLOC_GFXRES_PARAMS allocParams;
1274 MOS_ZeroMemory(&allocParams, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1275 allocParams.Type = MOS_GFXRES_BUFFER;
1276 allocParams.TileType = MOS_TILE_LINEAR;
1277 allocParams.Format = Format_Buffer;
1278 allocParams.dwBytes = bufSize;
1279 allocParams.pBufName = name;
1280
1281 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
1282 m_osInterface,
1283 &allocParams,
1284 buffer);
1285
1286 if (eStatus != MOS_STATUS_SUCCESS)
1287 {
1288 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
1289 return eStatus;
1290 }
1291
1292 CodechalResLock bufLock(m_osInterface, buffer);
1293 auto data = bufLock.Lock(CodechalResLock::writeOnly);
1294 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
1295
1296 MOS_ZeroMemory(data, bufSize);
1297
1298 return eStatus;
1299 }
1300
1301 MOS_STATUS CodechalEncodeMpeg2::AllocateBuffer2D(
1302 PMOS_SURFACE surface,
1303 uint32_t surfWidth,
1304 uint32_t surfHeight,
1305 PCCHAR name)
1306 {
1307 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1308
1309 CODECHAL_ENCODE_CHK_NULL_RETURN(surface);
1310
1311 MOS_ZeroMemory(surface, sizeof(*surface));
1312
1313 surface->TileType = MOS_TILE_LINEAR;
1314 surface->bArraySpacing = true;
1315 surface->Format = Format_Buffer_2D;
1316 surface->dwWidth = MOS_ALIGN_CEIL(surfWidth, 64);
1317 surface->dwHeight = surfHeight;
1318 surface->dwPitch = surface->dwWidth;
1319
1320 MOS_ALLOC_GFXRES_PARAMS AllocParamsForBuffer2D;
1321 MOS_ZeroMemory(&AllocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1322 AllocParamsForBuffer2D.Type = MOS_GFXRES_2D;
1323 AllocParamsForBuffer2D.TileType = surface->TileType;
1324 AllocParamsForBuffer2D.Format = surface->Format;
1325 AllocParamsForBuffer2D.dwWidth = surface->dwWidth;
1326 AllocParamsForBuffer2D.dwHeight = surface->dwHeight;
1327 AllocParamsForBuffer2D.pBufName = name;
1328
1329 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
1330 m_osInterface,
1331 &AllocParamsForBuffer2D,
1332 &surface->OsResource);
1333
1334 if (eStatus != MOS_STATUS_SUCCESS)
1335 {
1336 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
1337 return eStatus;
1338 }
1339
1340 surface->dwPitch = (uint32_t)surface->OsResource.pGmmResInfo->GetRenderPitch();
1341
1342 CodechalResLock bufLock(m_osInterface, &surface->OsResource);
1343 auto data = bufLock.Lock(CodechalResLock::writeOnly);
1344 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
1345
1346 MOS_ZeroMemory(data, surface->dwPitch * surface->dwHeight);
1347
1348 return eStatus;
1349 }
1350
1351 MOS_STATUS CodechalEncodeMpeg2::AllocateBatchBuffer(
1352 PMHW_BATCH_BUFFER batchBuffer,
1353 uint32_t bufSize,
1354 PCCHAR name)
1355 {
1356 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1357
1358 CODECHAL_ENCODE_CHK_NULL_RETURN(batchBuffer);
1359
1360 MOS_ZeroMemory(
1361 batchBuffer,
1362 sizeof(MHW_BATCH_BUFFER));
1363
1364 batchBuffer->bSecondLevel = true;
1365
1366 eStatus = Mhw_AllocateBb(
1367 m_osInterface,
1368 batchBuffer,
1369 nullptr,
1370 bufSize);
1371
1372 if (eStatus != MOS_STATUS_SUCCESS)
1373 {
1374 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate %s.", name);
1375 return eStatus;
1376 }
1377
1378 eStatus = Mhw_LockBb(m_osInterface, batchBuffer);
1379
1380 if (eStatus != MOS_STATUS_SUCCESS)
1381 {
1382 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to lock %s.", name);
1383 return eStatus;
1384 }
1385
1386 MOS_ZeroMemory(batchBuffer->pData, bufSize);
1387
1388 eStatus = Mhw_UnlockBb(
1389 m_osInterface,
1390 batchBuffer,
1391 false);
1392
1393 if (eStatus != MOS_STATUS_SUCCESS)
1394 {
1395 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to unlock %s.", name);
1396 return eStatus;
1397 }
1398
1399 return eStatus;
1400 }
1401
1402 MOS_STATUS CodechalEncodeMpeg2::AllocateBrcResources()
1403 {
1404 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1405
1406 CODECHAL_ENCODE_FUNCTION_ENTER;
1407
1408 // BRC history buffer
1409 uint32_t bufSize = m_brcHistoryBufferSize;
1410 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1411 &m_brcBuffers.resBrcHistoryBuffer,
1412 bufSize,
1413 "BRC History Buffer"));
1414
1415 // PAK Statistics buffer
1416 bufSize = m_brcPakStatisticsSize;
1417 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1418 &m_brcBuffers.resBrcPakStatisticBuffer[0],
1419 bufSize,
1420 "BRC PAK Statistics Buffer"));
1421
1422 // PAK IMG_STATEs buffer
1423 bufSize = BRC_IMG_STATE_SIZE_PER_PASS * m_mfxInterface->GetBrcNumPakPasses();
1424 for (uint8_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1425 {
1426 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1427 &m_brcBuffers.resBrcImageStatesReadBuffer[i],
1428 bufSize,
1429 "PAK IMG State Read Buffer"));
1430 }
1431
1432 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1433 &m_brcBuffers.resBrcImageStatesWriteBuffer,
1434 bufSize,
1435 "PAK IMG State Write Buffer"));
1436
1437 // Picture header input and output buffers
1438 bufSize = m_brcPicHeaderSurfaceSize;
1439 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1440 &m_brcBuffers.resBrcPicHeaderInputBuffer,
1441 bufSize,
1442 "Picture Header Input Buffer"));
1443 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer(
1444 &m_brcBuffers.resBrcPicHeaderOutputBuffer,
1445 bufSize,
1446 "Picture Header Output Buffer"));
1447
1448 uint32_t surfWidth = m_hwInterface->m_mpeg2BrcConstantSurfaceWidth;
1449 uint32_t surfHeight = m_hwInterface->m_mpeg2BrcConstantSurfaceHeight;
1450 for (uint8_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1451 {
1452 //BRC Constant Data Surfaces
1453 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
1454 &m_brcBuffers.sBrcConstantDataBuffer[i],
1455 surfWidth,
1456 surfHeight,
1457 "BRC Constant Data Buffer"));
1458 }
1459
1460 // BRC Distortion Surface
1461 uint32_t downscaledFieldHeightInMB4x =
1462 (m_downscaledHeightInMb4x + 1) >> 1;
1463 surfWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
1464 surfHeight = 2 * MOS_ALIGN_CEIL((downscaledFieldHeightInMB4x * 4), 8);
1465 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
1466 &m_brcBuffers.sMeBrcDistortionBuffer,
1467 surfWidth,
1468 surfHeight,
1469 "BRC Distortion Surface Buffer"));
1470
1471 // VME batch buffer for distortion surface
1472 for (uint8_t i = 0; i < NUM_ENCODE_BB_TYPE; i++)
1473 {
1474 uint32_t currNumMBs;
1475 if (i == MB_ENC_Frame_BB)
1476 {
1477 currNumMBs = m_downscaledWidthInMb4x * m_downscaledHeightInMb4x;
1478 }
1479 else
1480 {
1481 currNumMBs = m_downscaledWidthInMb4x * downscaledFieldHeightInMB4x;
1482 }
1483
1484 bufSize = m_hwInterface->GetMediaObjectBufferSize(
1485 currNumMBs,
1486 sizeof(MediaObjectInlineDataMpeg2));
1487
1488 AllocateBatchBuffer(&m_batchBufForMEDistBuffer[i], bufSize, "ME Distortion Buffer");
1489 }
1490
1491 return eStatus;
1492 }
1493
1494 MOS_STATUS CodechalEncodeMpeg2::AllocateEncResources()
1495 {
1496 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1497
1498 CODECHAL_ENCODE_FUNCTION_ENTER;
1499
1500 uint32_t downscaledFieldHeightInMB4x = (m_downscaledHeightInMb4x + 1) >> 1;
1501
1502 if (m_hmeSupported)
1503 {
1504 if (m_hmeKernel)
1505 {
1506 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hmeKernel->AllocateResources());
1507 }
1508 else
1509 {
1510 uint32_t bufWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 32), 64); // MediaBlockRW requires pitch multiple of 64 bytes when linear.
1511 uint32_t bufHeight = (m_downscaledHeightInMb4x * 2 * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER);
1512 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
1513 &m_4xMEMVDataBuffer,
1514 bufWidth,
1515 bufHeight,
1516 "4xME MV Data Buffer"));
1517
1518 bufWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
1519 bufHeight = 2 * MOS_ALIGN_CEIL((downscaledFieldHeightInMB4x * 4 * 10), 8);
1520 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBuffer2D(
1521 &m_4xMEDistortionBuffer,
1522 bufWidth,
1523 bufHeight,
1524 "4xME Distortion Buffer"));
1525 }
1526 }
1527
1528 return eStatus;
1529 }
1530
1531 MOS_STATUS CodechalEncodeMpeg2::AllocateResources()
1532 {
1533 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1534
1535 CODECHAL_ENCODE_FUNCTION_ENTER;
1536
1537 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::AllocateResources());
1538
1539 // Allocate Ref Lists
1540 CodecHalAllocateDataList(
1541 m_refList,
1542 CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2);
1543
1544 if (m_encEnabled)
1545 {
1546 eStatus = AllocateEncResources();
1547 if (eStatus != MOS_STATUS_SUCCESS)
1548 {
1549 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate ENC resources.");
1550 return eStatus;
1551 }
1552
1553 eStatus = AllocateBrcResources();
1554 if (eStatus != MOS_STATUS_SUCCESS)
1555 {
1556 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate BRC resources.");
1557 return eStatus;
1558 }
1559 }
1560
1561 return eStatus;
1562 }
1563
1564 MOS_STATUS CodechalEncodeMpeg2::FreeBrcResources()
1565 {
1566 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1567 CODECHAL_ENCODE_FUNCTION_ENTER;
1568
1569 if (!Mos_ResourceIsNull(&m_brcBuffers.resBrcHistoryBuffer))
1570 {
1571 m_osInterface->pfnFreeResource(
1572 m_osInterface,
1573 &m_brcBuffers.resBrcHistoryBuffer);
1574 }
1575
1576 if (!Mos_ResourceIsNull(&m_brcBuffers.resBrcPakStatisticBuffer[0]))
1577 {
1578 m_osInterface->pfnFreeResource(
1579 m_osInterface,
1580 &m_brcBuffers.resBrcPakStatisticBuffer[0]);
1581 }
1582
1583 uint32_t i;
1584 for (i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1585 {
1586 if (!Mos_ResourceIsNull(&m_brcBuffers.resBrcImageStatesReadBuffer[i]))
1587 {
1588 m_osInterface->pfnFreeResource(
1589 m_osInterface,
1590 &m_brcBuffers.resBrcImageStatesReadBuffer[i]);
1591 }
1592 }
1593
1594 if (!Mos_ResourceIsNull(&m_brcBuffers.resBrcImageStatesWriteBuffer))
1595 {
1596 m_osInterface->pfnFreeResource(
1597 m_osInterface,
1598 &m_brcBuffers.resBrcImageStatesWriteBuffer);
1599 }
1600
1601 for (i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1602 {
1603 if (!Mos_ResourceIsNull(&m_brcBuffers.sBrcConstantDataBuffer[i].OsResource))
1604 {
1605 m_osInterface->pfnFreeResource(
1606 m_osInterface,
1607 &m_brcBuffers.sBrcConstantDataBuffer[i].OsResource);
1608 }
1609 }
1610
1611 if (!Mos_ResourceIsNull(&m_brcBuffers.sMeBrcDistortionBuffer.OsResource))
1612 {
1613 m_osInterface->pfnFreeResource(
1614 m_osInterface,
1615 &m_brcBuffers.sMeBrcDistortionBuffer.OsResource);
1616 }
1617
1618 if(!Mos_ResourceIsNull(&m_brcBuffers.resBrcPicHeaderInputBuffer))
1619 {
1620 m_osInterface->pfnFreeResource(
1621 m_osInterface,
1622 &m_brcBuffers.resBrcPicHeaderInputBuffer);
1623 }
1624 if(!Mos_ResourceIsNull(&m_brcBuffers.resBrcPicHeaderOutputBuffer))
1625 {
1626 m_osInterface->pfnFreeResource(
1627 m_osInterface,
1628 &m_brcBuffers.resBrcPicHeaderOutputBuffer);
1629 }
1630
1631 for (i = 0; i < NUM_ENCODE_BB_TYPE; i++)
1632 {
1633 if (!Mos_ResourceIsNull(&m_batchBufForMEDistBuffer[i].OsResource))
1634 {
1635 Mhw_FreeBb(m_osInterface, &m_batchBufForMEDistBuffer[i], nullptr);
1636 }
1637 }
1638
1639 return eStatus;
1640 }
1641
1642 MOS_STATUS CodechalEncodeMpeg2::FreeEncResources()
1643 {
1644 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1645
1646 CODECHAL_ENCODE_FUNCTION_ENTER;
1647
1648 if (m_hmeSupported)
1649 {
1650 // 4xME ME MV data buffer
1651 if (!Mos_ResourceIsNull(&m_4xMEMVDataBuffer.OsResource))
1652 {
1653 m_osInterface->pfnFreeResource(
1654 m_osInterface,
1655 &m_4xMEMVDataBuffer.OsResource);
1656 }
1657
1658 // 4xME distortion buffer
1659 if (!Mos_ResourceIsNull(&m_4xMEDistortionBuffer.OsResource))
1660 {
1661 m_osInterface->pfnFreeResource(
1662 m_osInterface,
1663 &m_4xMEDistortionBuffer.OsResource);
1664 }
1665 }
1666
1667 return eStatus;
1668
1669 }
1670
1671 void CodechalEncodeMpeg2::FreeResources()
1672 {
1673 CODECHAL_ENCODE_FUNCTION_ENTER;
1674
1675 CodechalEncoderState::FreeResources();
1676
1677 // Release Ref Lists
1678 CodecHalFreeDataList(m_refList, CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2);
1679
1680 if (m_encEnabled)
1681 {
1682 FreeBrcResources();
1683
1684 FreeEncResources();
1685 }
1686 }
1687
1688 MOS_STATUS CodechalEncodeMpeg2::CheckProfileAndLevel()
1689 {
1690 MOS_STATUS eStatus = MOS_STATUS_INVALID_PARAMETER;
1691
1692 CODECHAL_ENCODE_FUNCTION_ENTER;
1693
1694 switch(m_seqParams->m_profile)
1695 {
1696 case highProfile:
1697 case mainProfile:
1698 case simpleProfile:
1699 break;
1700 default:
1701 return eStatus;
1702 break;
1703 }
1704
1705 switch(m_seqParams->m_level)
1706 {
1707 case levelHigh:
1708 case levelHigh1440:
1709 case levelMain:
1710 case levelLow:
1711 case levelHighP:
1712 break;
1713 default:
1714 return eStatus;
1715 break;
1716 }
1717
1718 eStatus = MOS_STATUS_SUCCESS;
1719
1720 return eStatus;
1721 }
1722
1723 MOS_STATUS CodechalEncodeMpeg2::SetSequenceStructs()
1724 {
1725 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1726
1727 CODECHAL_ENCODE_FUNCTION_ENTER;
1728
1729 m_oriFrameHeight = m_seqParams->m_frameHeight;
1730 m_oriFrameWidth = m_seqParams->m_frameWidth;
1731 if (m_seqParams->m_progressiveSequence)
1732 {
1733 m_picHeightInMb =
1734 (uint16_t)(CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_oriFrameHeight));
1735 }
1736 else
1737 {
1738 // For interlaced frame, align to 32 pixels.
1739 m_picHeightInMb =
1740 (uint16_t)((CODECHAL_GET_WIDTH_IN_BLOCKS(m_oriFrameHeight, (CODECHAL_MACROBLOCK_WIDTH << 1))) << 1);
1741 }
1742 m_picWidthInMb =
1743 (uint16_t)(CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_oriFrameWidth));
1744 m_frameWidth = m_picWidthInMb * CODECHAL_MACROBLOCK_WIDTH;
1745 m_frameHeight = m_picHeightInMb * CODECHAL_MACROBLOCK_HEIGHT;
1746
1747 // HME Scaling WxH
1748 m_downscaledWidthInMb4x =
1749 CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_frameWidth / SCALE_FACTOR_4x);
1750 m_downscaledHeightInMb4x =
1751 CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameHeight / SCALE_FACTOR_4x);
1752 m_downscaledWidth4x =
1753 m_downscaledWidthInMb4x * CODECHAL_MACROBLOCK_WIDTH;
1754 m_downscaledHeight4x =
1755 m_downscaledHeightInMb4x * CODECHAL_MACROBLOCK_HEIGHT;
1756
1757 MotionEstimationDisableCheck();
1758
1759 m_targetUsage = m_seqParams->m_targetUsage & 0x7;
1760 m_kernelMode = m_targetUsageToKernelMode[m_targetUsage];
1761
1762 CODECHAL_ENCODE_CHK_STATUS_RETURN(CheckProfileAndLevel());
1763
1764 m_brcEnabled = CodecHalIsRateControlBrc(m_seqParams->m_rateControlMethod, CODECHAL_MPEG2);
1765
1766 // Mb Qp data is only enabled for CQP
1767 if (m_brcEnabled)
1768 {
1769 m_mbQpDataEnabled = false;
1770 }
1771
1772 m_brcReset = m_seqParams->m_resetBRC;
1773
1774 m_avbrAccuracy = 30;
1775 m_avbrConvergence = 150;
1776
1777 return eStatus;
1778 }
1779
1780 MOS_STATUS CodechalEncodeMpeg2::SetPictureStructs()
1781 {
1782 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1783
1784 CODECHAL_ENCODE_FUNCTION_ENTER;
1785
1786 if ((m_picParams->m_pictureCodingType < I_TYPE) ||
1787 (m_picParams->m_pictureCodingType > B_TYPE))
1788 {
1789 eStatus = MOS_STATUS_INVALID_PARAMETER;
1790 return eStatus;
1791 }
1792
1793 if (Mos_ResourceIsNull(&m_reconSurface.OsResource) &&
1794 (!m_picParams->m_useRawPicForRef || m_pakEnabled))
1795 {
1796 eStatus = MOS_STATUS_INVALID_PARAMETER;
1797 return eStatus;
1798 }
1799
1800 // Sync initialize
1801 if ((m_firstFrame) ||
1802 (m_codecFunction == CODECHAL_FUNCTION_ENC) ||
1803 (!m_brcEnabled && m_picParams->m_useRawPicForRef) ||
1804 (!m_brcEnabled && (m_picParams->m_pictureCodingType == I_TYPE)))
1805 {
1806 m_waitForPak = false;
1807 }
1808 else
1809 {
1810 m_waitForPak = true;
1811 }
1812
1813 if (m_codecFunction != CODECHAL_FUNCTION_ENC)
1814 {
1815 m_signalEnc = true;
1816 }
1817 else
1818 {
1819 m_signalEnc = false;
1820 }
1821 m_pictureCodingType = m_picParams->m_pictureCodingType;
1822 m_mbEncForcePictureCodingType = 0;
1823
1824 // f_code checking.
1825 uint32_t fcodeX = CODECHAL_ENCODE_MPEG2_FCODE_X(m_frameWidth);
1826 uint32_t fcodeY = CODECHAL_ENCODE_MPEG2_FCODE_Y(fcodeX);
1827
1828 if (m_pictureCodingType == I_TYPE)
1829 {
1830 if ((m_picParams->m_fcode00 > fcodeX) ||
1831 (m_picParams->m_fcode01 > fcodeY) ||
1832 (m_picParams->m_fcode00 == 0) ||
1833 (m_picParams->m_fcode01 == 0))
1834 {
1835 m_picParams->m_fcode00 = fcodeX;
1836 m_picParams->m_fcode01 = fcodeY;
1837 }
1838 }
1839 else if (m_pictureCodingType == P_TYPE)
1840 {
1841 if ((m_picParams->m_fcode00 > fcodeX) ||
1842 (m_picParams->m_fcode01 > fcodeY) ||
1843 (m_picParams->m_fcode00 == 0) ||
1844 (m_picParams->m_fcode01 == 0))
1845 {
1846 m_picParams->m_fcode00 = fcodeX;
1847 m_picParams->m_fcode01 = fcodeY;
1848 }
1849 }
1850 else // B picture
1851 {
1852 if ((m_picParams->m_fcode00 > fcodeX) ||
1853 (m_picParams->m_fcode01 > fcodeY) ||
1854 (m_picParams->m_fcode10 > fcodeX) ||
1855 (m_picParams->m_fcode11 > fcodeY) ||
1856 (m_picParams->m_fcode00 == 0) ||
1857 (m_picParams->m_fcode01 == 0) ||
1858 (m_picParams->m_fcode10 == 0) ||
1859 (m_picParams->m_fcode11 == 0))
1860 {
1861 m_picParams->m_fcode00 = fcodeX;
1862 m_picParams->m_fcode01 = fcodeY;
1863 m_picParams->m_fcode10 = fcodeX;
1864 m_picParams->m_fcode11 = fcodeY;
1865 }
1866 }
1867
1868 if (m_picParams->m_fieldCodingFlag == 0)
1869 {
1870 m_frameFieldHeight = m_frameHeight;
1871 m_frameFieldHeightInMb = m_picHeightInMb;
1872 m_downscaledFrameFieldHeightInMb4x = m_downscaledHeightInMb4x;
1873 }
1874 else
1875 {
1876 m_frameFieldHeight = ((m_frameHeight + 1) >> 1);
1877 m_frameFieldHeightInMb = ((m_picHeightInMb + 1) >> 1);
1878 m_downscaledFrameFieldHeightInMb4x = ((m_downscaledHeightInMb4x + 1) >> 1);
1879 }
1880
1881 m_statusReportFeedbackNumber = m_picParams->m_statusReportFeedbackNumber;
1882 m_lastPicInStream = m_picParams->m_lastPicInStream;
1883 m_currOriginalPic = m_picParams->m_currOriginalPic;
1884 m_currReconstructedPic = m_picParams->m_currReconstructedPic;
1885
1886 uint8_t currRefIdx = m_picParams->m_currReconstructedPic.FrameIdx;
1887
1888 ENCODE_CHK_COND_RETURN(currRefIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2, "currRefIdx cannot bigger than 128.");
1889 m_refList[currRefIdx]->sRefRawBuffer = m_rawSurface;
1890 m_refList[currRefIdx]->sRefReconBuffer = m_reconSurface;
1891 m_refList[currRefIdx]->resBitstreamBuffer = m_resBitstreamBuffer;
1892
1893 if (m_pictureCodingType == I_TYPE)
1894 {
1895 m_picIdx[0].bValid = m_picIdx[1].bValid = 0;
1896 m_refList[currRefIdx]->bUsedAsRef = true;
1897 m_refList[currRefIdx]->ucNumRef = 0;
1898 }
1899 else if (m_pictureCodingType == P_TYPE)
1900 {
1901 if (m_picParams->m_refFrameList[0].PicFlags != PICTURE_INVALID)
1902 {
1903 m_picIdx[0].bValid = 1;
1904 m_picIdx[0].ucPicIdx = m_picParams->m_refFrameList[0].FrameIdx;
1905 }
1906 m_picIdx[1].bValid = 0;
1907 m_refList[currRefIdx]->bUsedAsRef = true;
1908 m_refList[currRefIdx]->RefList[0] = m_picParams->m_refFrameList[0];
1909 m_refList[currRefIdx]->ucNumRef = 1;
1910 }
1911 else// B_TYPE
1912 {
1913 if (m_picParams->m_refFrameList[0].PicFlags != PICTURE_INVALID)
1914 {
1915 m_picIdx[0].bValid = 1;
1916 m_picIdx[0].ucPicIdx = m_picParams->m_refFrameList[0].FrameIdx;
1917 }
1918
1919 if (m_picParams->m_refFrameList[1].PicFlags != PICTURE_INVALID)
1920 {
1921 m_picIdx[1].bValid = 1;
1922 m_picIdx[1].ucPicIdx = m_picParams->m_refFrameList[1].FrameIdx;
1923 }
1924 m_refList[currRefIdx]->bUsedAsRef = false;
1925 }
1926 m_currRefList = m_refList[currRefIdx];
1927
1928 if (m_codecFunction == CODECHAL_FUNCTION_ENC)
1929 {
1930 CODECHAL_ENCODE_CHK_NULL_RETURN(m_encodeParams.presMbCodeSurface);
1931 m_resMbCodeSurface = *(m_encodeParams.presMbCodeSurface);
1932 }
1933 else if (m_codecFunction == CODECHAL_FUNCTION_ENC_PAK)
1934 {
1935 // the actual MbCode/MvData surface to be allocated later
1936 m_trackedBuf->SetAllocationFlag(true);
1937 }
1938
1939 m_hmeEnabled = m_hmeSupported && m_pictureCodingType != I_TYPE;
1940
1941 if (m_brcEnabled)
1942 {
1943 m_numPasses = (uint8_t)(m_mfxInterface->GetBrcNumPakPasses() - 1); // 1 original plus extra to handle BRC
1944 }
1945
1946 // if GOP structure is I-frame only, we use 3 non-ref slots for tracked buffer
1947 m_gopIsIdrFrameOnly = (m_picParams->m_gopPicSize == 1 && m_picParams->m_gopRefDist == 0);
1948
1949 return eStatus;
1950 }
1951
1952 MOS_STATUS CodechalEncodeMpeg2::SetSliceGroups()
1953 {
1954 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1955
1956 CODECHAL_ENCODE_FUNCTION_ENTER;
1957
1958 uint32_t mbCount = 0;
1959 auto bsBuffer = &m_bsBuffer;
1960 auto slcParams = m_sliceParams;
1961 auto slcData = m_slcData;
1962 PCODEC_ENCODER_SLCDATA slcDataPrevStart = nullptr;
1963
1964 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
1965 {
1966 // Slice width should equal picture width, MBs should be on same row
1967 CODECHAL_ENCODE_CHK_NULL_RETURN(slcData);
1968 CODECHAL_ENCODE_CHK_NULL_RETURN(slcParams);
1969 CODECHAL_ENCODE_ASSERT((slcParams->m_numMbsForSlice % m_picWidthInMb) == 0);
1970 CODECHAL_ENCODE_ASSERT(slcParams->m_numMbsForSlice <= m_picWidthInMb);
1971
1972 if ((slcParams->m_quantiserScaleCode < 1) ||
1973 (slcParams->m_quantiserScaleCode > 31))
1974 {
1975 slcParams->m_quantiserScaleCode = 1;
1976 }
1977
1978 // Determine slice groups
1979 if (slcCount == 0)
1980 {
1981 // First slice
1982 slcDataPrevStart = slcData;
1983 slcData->SliceGroup |= SLICE_GROUP_START;
1984
1985 if (m_codecFunction == (CODECHAL_FUNCTION_ENC | CODECHAL_FUNCTION_PAK))
1986 {
1987 slcData->SliceOffset = bsBuffer->SliceOffset;
1988 // Make slice header uint8_t aligned, all start codes are uint8_t aligned
1989 while (bsBuffer->BitOffset)
1990 {
1991 PutBit(bsBuffer, 0);
1992 }
1993 for (uint32_t i = 0; i < 8; i++)
1994 {
1995 PutBit(bsBuffer, 0);
1996 }
1997
1998 slcData->BitSize = bsBuffer->BitSize =
1999 (uint32_t)((bsBuffer->pCurrent - bsBuffer->SliceOffset - bsBuffer->pBase) * 8 + bsBuffer->BitOffset);
2000 bsBuffer->SliceOffset =
2001 (uint32_t)(bsBuffer->pCurrent - bsBuffer->pBase + (bsBuffer->BitOffset != 0)); // start at next byte
2002 }
2003 else
2004 {
2005 slcData->SliceOffset = bsBuffer->SliceOffset;
2006 slcData->BitSize = bsBuffer->BitSize;
2007 }
2008 }
2009 else
2010 {
2011 // Compare with prev slice to see if curr slice is start of new slice group
2012 PCODEC_ENCODER_SLCDATA slcDataPrev = slcData - 1;
2013 CodecEncodeMpeg2SliceParmas *slcParamsPrev = slcParams - 1;
2014
2015 // Start of a new slice group if gap in slices or quantiser_scale_code/IntraSlice changes
2016 uint32_t mbPrevEnd =
2017 (slcParamsPrev->m_firstMbY * m_picWidthInMb) +
2018 slcParamsPrev->m_firstMbX +
2019 slcParamsPrev->m_numMbsForSlice;
2020 uint32_t mbCurrStart = (slcParams->m_firstMbY * m_picWidthInMb) + slcParams->m_firstMbX;
2021
2022 if ((mbPrevEnd != mbCurrStart) ||
2023 (slcParamsPrev->m_quantiserScaleCode != slcParams->m_quantiserScaleCode) ||
2024 (slcParamsPrev->m_intraSlice != slcParams->m_intraSlice))
2025 {
2026 slcDataPrev->SliceGroup |= SLICE_GROUP_END;
2027 slcData->SliceGroup |= SLICE_GROUP_START;
2028
2029 slcDataPrevStart->NextSgMbXCnt = slcParams->m_firstMbX;
2030 slcDataPrevStart->NextSgMbYCnt = slcParams->m_firstMbY;
2031 slcDataPrevStart = slcData;
2032
2033 slcData->SliceOffset = bsBuffer->SliceOffset;
2034 // Make slice header uint8_t aligned, all start codes are uint8_t aligned
2035 while (bsBuffer->BitOffset)
2036 {
2037 PutBit(bsBuffer, 0);
2038 }
2039 for (uint32_t i = 0; i < 8; i++)
2040 {
2041 PutBit(bsBuffer, 0);
2042 }
2043
2044 slcData->BitSize = bsBuffer->BitSize =
2045 (uint32_t)((bsBuffer->pCurrent - bsBuffer->SliceOffset - bsBuffer->pBase) * 8 + bsBuffer->BitOffset);
2046 bsBuffer->SliceOffset =
2047 (uint32_t)(bsBuffer->pCurrent - bsBuffer->pBase + (bsBuffer->BitOffset != 0)); // start at next byte
2048 }
2049 }
2050
2051 if (slcCount == (m_numSlices - 1))
2052 {
2053 // Last slice
2054 slcData->SliceGroup |= SLICE_GROUP_END;
2055 slcDataPrevStart->SliceGroup |= SLICE_GROUP_LAST;
2056 slcDataPrevStart->NextSgMbXCnt = 0;
2057 slcDataPrevStart->NextSgMbYCnt = m_frameFieldHeightInMb;
2058 }
2059
2060 slcData->CmdOffset = mbCount * m_mbCodeStrideInDW * sizeof(uint32_t);
2061
2062 mbCount += slcParams->m_numMbsForSlice;
2063 slcParams++;
2064 slcData++;
2065 }
2066
2067 return eStatus;
2068
2069 }
2070
2071 uint32_t CodechalEncodeMpeg2::GetCurByteOffset(BSBuffer* bsBuffer)
2072 {
2073 return (uint32_t)(bsBuffer->pCurrent - bsBuffer->pBase);
2074 }
2075
2076 MOS_STATUS CodechalEncodeMpeg2::PackDisplaySeqExtension()
2077 {
2078 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2079
2080 CODECHAL_ENCODE_FUNCTION_ENTER;
2081
2082 auto bsBuffer = &m_bsBuffer;
2083
2084 // Make start code uint8_t aligned
2085 while (bsBuffer->BitOffset)
2086 {
2087 PutBit(bsBuffer, 0);
2088 }
2089
2090 // extension_start_code
2091 PutBits(bsBuffer, startCodePrefix, 24);
2092 PutBits(bsBuffer, startCodeExtension, 8);
2093
2094 // extension_start_code_identifier
2095 PutBits(bsBuffer, Mpeg2sequenceDisplayExtension, 4);
2096
2097 // video_format
2098 PutBits(bsBuffer, m_vuiParams->m_videoFormat, 3);
2099
2100 // colour_description
2101 PutBit(bsBuffer, m_vuiParams->m_colourDescription);
2102
2103 if (m_vuiParams->m_colourDescription)
2104 {
2105 // colour_primaries
2106 PutBits(bsBuffer, m_vuiParams->m_colourPrimaries, 8);
2107
2108 // transfer_characteristics
2109 PutBits(bsBuffer, m_vuiParams->m_transferCharacteristics, 8);
2110
2111 // matrix_coefficients
2112 PutBits(bsBuffer, m_vuiParams->m_matrixCoefficients, 8);
2113 }
2114
2115 // display_horizontal_size
2116 PutBits(bsBuffer, m_vuiParams->m_displayHorizontalSize, 14);
2117
2118 // marker_bit
2119 PutBit(bsBuffer, 1);
2120
2121 // display_vertical_size
2122 PutBits(bsBuffer, m_vuiParams->m_displayVerticalSize, 14);
2123
2124 return eStatus;
2125
2126 }
2127
2128 MOS_STATUS CodechalEncodeMpeg2::PackSeqExtension()
2129 {
2130 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2131
2132 CODECHAL_ENCODE_FUNCTION_ENTER;
2133
2134 auto bsBuffer = &m_bsBuffer;
2135
2136 // Make start code uint8_t aligned
2137 while (bsBuffer->BitOffset)
2138 {
2139 PutBit(bsBuffer, 0);
2140 }
2141
2142 // extension_start_code
2143 PutBits(bsBuffer, startCodePrefix, 24);
2144 PutBits(bsBuffer, startCodeExtension, 8);
2145
2146 // extension_start_code_identifier
2147 PutBits(bsBuffer, Mpeg2sequenceExtension, 4);
2148
2149 // profile_and_level_indication
2150 PutBits(bsBuffer, ((m_seqParams->m_profile & 0x70) | (m_seqParams->m_level & 0xF)), 8);
2151
2152 // progressive_sequence
2153 PutBit(bsBuffer, m_seqParams->m_progressiveSequence);
2154
2155 // chroma_format
2156 PutBits(bsBuffer, m_seqParams->m_chromaFormat, 2);
2157
2158 // horizontal_size_extension
2159 PutBits(bsBuffer, ((m_seqParams->m_frameWidth >> 12) & 0x3), 2);
2160
2161 // vertical_size_extension
2162 PutBits(bsBuffer, ((m_seqParams->m_frameHeight >> 12) & 0x3), 2);
2163
2164 // bit_rate_extension
2165 PutBits(bsBuffer, ((MOS_ROUNDUP_DIVIDE(m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS, 400)) >> 18) & 0xFFF, 12);
2166
2167 // marker_bit
2168 PutBit(bsBuffer, 1);
2169
2170 // vbv_buffer_size_extension 8 uimsbf
2171 PutBits(bsBuffer, ((m_seqParams->m_vbvBufferSize >> 10) & 0xFF), 8);
2172
2173 // low_delay
2174 PutBit(bsBuffer, m_seqParams->m_lowDelay);
2175
2176 // frame_rate_extension_n
2177 PutBits(bsBuffer, m_seqParams->m_frameRateExtN, 2);
2178
2179 // frame_rate_extension_d
2180 PutBits(bsBuffer, m_seqParams->m_frameRateExtD, 5);
2181
2182 return eStatus;
2183
2184 }
2185
2186 MOS_STATUS CodechalEncodeMpeg2::PackSeqHeader()
2187 {
2188 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2189
2190 CODECHAL_ENCODE_FUNCTION_ENTER;
2191
2192 auto bsBuffer = &m_bsBuffer;
2193
2194 // Make start code uint8_t aligned
2195 while (bsBuffer->BitOffset)
2196 {
2197 PutBit(bsBuffer, 0);
2198 }
2199
2200 // sequence_start_code
2201 PutBits(bsBuffer, startCodePrefix, 24);
2202 PutBits(bsBuffer, startCodeSequenceHeader, 8);
2203
2204 // horizontal_size_value
2205 CODECHAL_ENCODE_ASSERT((m_seqParams->m_frameWidth & 0xFFF) != 0); // Avoid start code emulation
2206 PutBits(bsBuffer, (m_seqParams->m_frameWidth & 0xFFF), 12);
2207
2208 // vertical_size_value
2209 CODECHAL_ENCODE_ASSERT((m_seqParams->m_frameHeight & 0xFFF) != 0); // Avoid start code emulation
2210 PutBits(bsBuffer, (m_seqParams->m_frameHeight & 0xFFF), 12);
2211
2212 // aspect_ratio_information
2213 CODECHAL_ENCODE_ASSERT((m_seqParams->m_aspectRatio > 0) && (m_seqParams->m_aspectRatio < 5));
2214 PutBits(bsBuffer, m_seqParams->m_aspectRatio, 4);
2215
2216 // frame_rate_code
2217 CODECHAL_ENCODE_ASSERT((m_seqParams->m_frameRateCode > 0) & (m_seqParams->m_frameRateCode < 15));
2218 PutBits(bsBuffer, m_seqParams->m_frameRateCode, 4);
2219
2220 // bit_rate_value
2221 if (m_seqParams->m_rateControlMethod == RATECONTROL_VBR)
2222 {
2223 // In Architecture prototype, the bit_rate_value of sequence header is set to m_maxBitRate not the target bit-rate for VBR case.
2224 PutBits(bsBuffer, ((MOS_ROUNDUP_DIVIDE(m_seqParams->m_maxBitRate * CODECHAL_ENCODE_BRC_KBPS, 400)) & 0x3FFFF), 18);
2225 }
2226 else
2227 {
2228 PutBits(bsBuffer, ((MOS_ROUNDUP_DIVIDE(m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS, 400)) & 0x3FFFF), 18);
2229 }
2230
2231 // marker_bit
2232 PutBit(bsBuffer, 1);
2233
2234 // vbv_buffer_size_value
2235 PutBits(bsBuffer, (m_seqParams->m_vbvBufferSize & 0x3FF), 10);
2236
2237 // constrained_parameters_flag
2238 PutBit(bsBuffer, 0);
2239
2240 // m_loadIntraQuantiserMatrix
2241 PutBit(bsBuffer, m_qMatrixParams->m_newQmatrix[0]);
2242 if (m_qMatrixParams->m_newQmatrix[0])
2243 {
2244 // m_intraQuantiserMatrix[64]
2245 for (uint8_t i = 0; i < 64; i++)
2246 {
2247 // Already in zig-zag scan order
2248 PutBits(bsBuffer, m_qMatrixParams->m_qmatrix[0][i], 8);
2249 }
2250 }
2251
2252 // m_loadNonIntraQuantiserMatrix
2253 PutBit(bsBuffer, m_qMatrixParams->m_newQmatrix[1]);
2254 if (m_qMatrixParams->m_newQmatrix[1])
2255 {
2256 // m_nonIntraQuantiserMatrix[64]
2257 for (uint8_t i = 0; i < 64; i++)
2258 {
2259 // Already in zig-zag scan order
2260 PutBits(bsBuffer, m_qMatrixParams->m_qmatrix[1][i], 8);
2261 }
2262 }
2263
2264 return eStatus;
2265
2266 }
2267
2268 MOS_STATUS CodechalEncodeMpeg2::PackSequenceParams()
2269 {
2270 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2271
2272 CODECHAL_ENCODE_FUNCTION_ENTER;
2273
2274 // picture header
2275 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackSeqHeader());
2276
2277 // picture coding extension
2278 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackSeqExtension());
2279
2280 // optional sequence display extension (& user data)
2281 if (m_newVuiData)
2282 {
2283 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackDisplaySeqExtension());
2284
2285 m_newVuiData = false;
2286 }
2287
2288 return eStatus;
2289 }
2290
2291 MOS_STATUS CodechalEncodeMpeg2::PackPicCodingExtension()
2292 {
2293 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2294
2295 CODECHAL_ENCODE_FUNCTION_ENTER;
2296
2297 auto bsBuffer = &m_bsBuffer;
2298
2299 // All start codes are uint8_t aligned
2300 while (bsBuffer->BitOffset)
2301 {
2302 PutBit(bsBuffer, 0);
2303 }
2304
2305 // extension_start_code
2306 PutBits(bsBuffer, startCodePrefix, 24);
2307 PutBits(bsBuffer, startCodeExtension, 8);
2308
2309 // extension_start_code_identifier
2310 PutBits(bsBuffer, Mpeg2pictureCodingExtension, 4);
2311
2312 // f_codes values 1-9 or 15; 0 or 1-14 are reserved
2313 if ((m_picParams->m_pictureCodingType == I_TYPE) && !m_picParams->m_concealmentMotionVectors)
2314 {
2315 // f_code[0][0], forward horizontal
2316 PutBits(bsBuffer, 0xF, 4);
2317 // f_code[0][1], forward vertical
2318 PutBits(bsBuffer, 0xF, 4);
2319 // f_code[1][0], backward horizontal
2320 PutBits(bsBuffer, 0xF, 4);
2321 // f_code[1][1], backward vertical
2322 PutBits(bsBuffer, 0xF, 4);
2323 }
2324 else
2325 {
2326 // f_code[0][0], forward horizontal
2327 PutBits(bsBuffer, m_picParams->m_fcode00, 4);
2328 // f_code[0][1], forward vertical
2329 PutBits(bsBuffer, m_picParams->m_fcode01, 4);
2330
2331 if ((m_picParams->m_pictureCodingType == I_TYPE) || (m_picParams->m_pictureCodingType == P_TYPE))
2332 {
2333 // f_code[1][0], backward horizontal
2334 PutBits(bsBuffer, 0xF, 4);
2335 // f_code[1][1], backward vertical
2336 PutBits(bsBuffer, 0xF, 4);
2337 }
2338 else
2339 {
2340 // f_code[1][0], backward horizontal
2341 PutBits(bsBuffer, m_picParams->m_fcode10, 4);
2342 // f_code[1][1], backward vertical
2343 PutBits(bsBuffer, m_picParams->m_fcode11, 4);
2344 }
2345 }
2346
2347 // store byte offset of intra_dc_precision
2348 m_intraDcPrecisionOffset = GetCurByteOffset(bsBuffer);
2349 // intra_dc_precision
2350 PutBits(bsBuffer, m_picParams->m_intraDCprecision, 2);
2351
2352 // picture_structure
2353 PutBits(bsBuffer, (!m_picParams->m_fieldCodingFlag) ? 3 : ((m_picParams->m_interleavedFieldBFF) ? 2 : 1), 2);
2354
2355 bool progressiveSequence = m_seqParams->m_progressiveSequence & 0x1;
2356 bool actual_tff = (!m_picParams->m_fieldCodingFlag && !progressiveSequence) || (m_picParams->m_repeatFirstField != 0);
2357
2358 // top_field_first
2359 PutBit(bsBuffer, (actual_tff ) ? (!m_picParams->m_interleavedFieldBFF) : 0);
2360 bool progressive = true;
2361 if (m_picParams->m_fieldCodingFlag || m_picParams->m_fieldFrameCodingFlag)
2362 {
2363 progressive = false;
2364 }
2365
2366 // frame_pred_frame_dct
2367 if (progressive)
2368 {
2369 PutBit(bsBuffer, 1);
2370 }
2371 else if (m_picParams->m_fieldCodingFlag)
2372 {
2373 PutBit(bsBuffer, 0);
2374 }
2375 else
2376 {
2377 PutBit(bsBuffer, m_picParams->m_framePredFrameDCT);
2378 }
2379
2380 // concealment_motion_vectors
2381 PutBit(bsBuffer, m_picParams->m_concealmentMotionVectors);
2382
2383 // Store the byte offset of the q_scale_type
2384 m_qScaleTypeByteOffse = GetCurByteOffset(bsBuffer);
2385 // q_scale_type
2386 PutBit(bsBuffer, m_picParams->m_qscaleType);
2387
2388 // intra_vlc_format
2389 PutBit(bsBuffer, m_picParams->m_intraVlcFormat);
2390
2391 // alternate_scan
2392 PutBit(bsBuffer, m_picParams->m_alternateScan);
2393
2394 // repeat_first_field
2395 PutBit(bsBuffer, (!m_picParams->m_fieldCodingFlag) ? m_picParams->m_repeatFirstField : 0);
2396
2397 // chroma_420_type
2398 PutBit(bsBuffer, progressive);
2399
2400 // progressive_frame
2401 PutBit(bsBuffer, progressive);
2402
2403 // composite_display_flag
2404 PutBit(bsBuffer, m_picParams->m_compositeDisplayFlag);
2405
2406 if (m_picParams->m_compositeDisplayFlag)
2407 {
2408 // v_axis
2409 PutBit(bsBuffer, m_picParams->m_vaxis);
2410 // field_sequence
2411 PutBits(bsBuffer, m_picParams->m_fieldSequence, 3);
2412 // sub_carrier
2413 PutBit(bsBuffer, m_picParams->m_subCarrier);
2414 // burst_amplitude
2415 PutBits(bsBuffer, m_picParams->m_burstAmplitude, 7);
2416 // sub_carrier_phase
2417 PutBits(bsBuffer, m_picParams->m_subCarrierPhase, 8);
2418 }
2419
2420 return eStatus;
2421 }
2422
2423 MOS_STATUS CodechalEncodeMpeg2::PackPicUserData()
2424 {
2425 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2426
2427 CODECHAL_ENCODE_FUNCTION_ENTER;
2428
2429 auto userDataListHead = (CodecEncodeMpeg2UserDataList *)m_encodeParams.pMpeg2UserDataListHead;
2430 CODECHAL_ENCODE_CHK_NULL_RETURN(userDataListHead);
2431
2432 auto bsBuffer = &m_bsBuffer;
2433
2434 for (auto p = userDataListHead; p; p = p->m_nextItem)
2435 {
2436 auto userData = (uint8_t*)p->m_userData;
2437
2438 while (bsBuffer->BitOffset)
2439 {
2440 PutBit(bsBuffer, 0);
2441 }
2442
2443 for(unsigned int i = 0; i < p->m_userDataSize; ++i)
2444 {
2445 PutBits(bsBuffer, (uint32_t) (userData[i]), 8);
2446 }
2447 }
2448
2449 return eStatus;
2450 }
2451
2452 MOS_STATUS CodechalEncodeMpeg2::PackPicHeader()
2453 {
2454 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2455
2456 CODECHAL_ENCODE_FUNCTION_ENTER;
2457
2458 auto bsBuffer = &m_bsBuffer;
2459
2460 // All start codes are uint8_t aligned
2461 while (bsBuffer->BitOffset)
2462 {
2463 PutBit(bsBuffer, 0);
2464 }
2465
2466 // picture_start_code
2467 PutBits(bsBuffer, startCodePrefix, 24);
2468 PutBits(bsBuffer, startCodePicture, 8);
2469
2470 // temporal_reference
2471 PutBits(bsBuffer, m_picParams->m_temporalReference, 10);
2472
2473 // picture_coding_type
2474 PutBits(bsBuffer, m_picParams->m_pictureCodingType, 3);
2475
2476 // Store the byte offset of the q_scale_type
2477 m_vbvDelayOffset = GetCurByteOffset(bsBuffer);
2478 // vbv_delay
2479 PutBits(bsBuffer, m_picParams->m_vbvDelay, 16);
2480
2481 if ((m_picParams->m_pictureCodingType == P_TYPE) || (m_picParams->m_pictureCodingType == B_TYPE))
2482 {
2483 // full_pel_forward_vector, '0'
2484 PutBit(bsBuffer, 0);
2485 // forward_f_code, '111'
2486 PutBits(bsBuffer, 0x7, 3);
2487 }
2488
2489 if (m_picParams->m_pictureCodingType == B_TYPE)
2490 {
2491 // full_pel_backward_vector, '0'
2492 PutBit(bsBuffer, 0);
2493 // backward_f_code '111'
2494 PutBits(bsBuffer, 0x7, 3);
2495 }
2496
2497 // extra_bit_picture, '0'
2498 PutBit(bsBuffer, 0);
2499
2500 return eStatus;
2501
2502 }
2503
2504 MOS_STATUS CodechalEncodeMpeg2::PackGroupOfPicHeader()
2505 {
2506 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2507
2508 CODECHAL_ENCODE_FUNCTION_ENTER;
2509
2510 auto bsBuffer = &m_bsBuffer;
2511
2512 // All start codes are uint8_t aligned
2513 while (bsBuffer->BitOffset)
2514 {
2515 PutBit(bsBuffer, 0);
2516 }
2517
2518 // group_start_code
2519 PutBits(bsBuffer, startCodePrefix, 24);
2520 PutBits(bsBuffer, startCodeGroupStart, 8);
2521
2522 // time_code, 25 bits total
2523 // drop_flag
2524 PutBit(bsBuffer, ((m_picParams->m_timeCode >> 24) & 1));
2525 // hour
2526 PutBits(bsBuffer, ((m_picParams->m_timeCode >> 19) & 0x1F), 5);
2527 // minute
2528 PutBits(bsBuffer, ((m_picParams->m_timeCode >> 13) & 0x3F), 6);
2529 // marker_bit
2530 PutBit(bsBuffer, 1);
2531 // sec
2532 PutBits(bsBuffer, ((m_picParams->m_timeCode >> 6) & 0x3F), 6);
2533 // frame
2534 PutBits(bsBuffer, ((m_picParams->m_timeCode) & 0x3F), 6);
2535
2536 // closed_gop
2537 PutBit(bsBuffer, m_picParams->m_gopOptFlag & 1);
2538 // broken_link, used in editing
2539 PutBit(bsBuffer, 0);
2540
2541 return eStatus;
2542
2543 }
2544
2545 MOS_STATUS CodechalEncodeMpeg2::PackPictureParams()
2546 {
2547 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2548
2549 CODECHAL_ENCODE_FUNCTION_ENTER;
2550
2551 // optional GOP header (& user data)
2552 if (m_picParams->m_newGop)
2553 {
2554 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackGroupOfPicHeader());
2555 }
2556
2557 // picture header
2558 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackPicHeader());
2559
2560 // picture coding extension
2561 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackPicCodingExtension());
2562
2563 // user data
2564 if(m_encodeParams.pMpeg2UserDataListHead)
2565 {
2566 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackPicUserData());
2567 }
2568
2569 return eStatus;
2570 }
2571
2572 MOS_STATUS CodechalEncodeMpeg2::PackPictureHeader()
2573 {
2574 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2575
2576 CODECHAL_ENCODE_FUNCTION_ENTER;
2577
2578 auto bsBuffer = &m_bsBuffer;
2579
2580 *(bsBuffer->pBase) = 0; // init first byte to 0
2581 bsBuffer->pCurrent = bsBuffer->pBase;
2582 bsBuffer->SliceOffset = 0;
2583 bsBuffer->BitOffset = 0;
2584 bsBuffer->BitSize = 0;
2585
2586 // If this is a new sequence, write the seq set
2587 if (m_newSeq)
2588 {
2589 // Pack SPS
2590 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackSequenceParams());
2591 }
2592
2593 // Pack PPS
2594 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackPictureParams());
2595
2596 // HW will insert next slice start code, but need to byte align for HW
2597 while (bsBuffer->BitOffset)
2598 {
2599 PutBit(bsBuffer, 0);
2600 }
2601 bsBuffer->BitSize = (uint32_t)(bsBuffer->pCurrent - bsBuffer->SliceOffset - bsBuffer->pBase) * 8 + bsBuffer->BitOffset;
2602
2603 return eStatus;
2604 }
2605
2606 MOS_STATUS CodechalEncodeMpeg2::InitializePicture(const EncoderParams& params)
2607 {
2608 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2609
2610 CODECHAL_ENCODE_FUNCTION_ENTER;
2611
2612 m_seqParams = (CodecEncodeMpeg2SequenceParams *)(params.pSeqParams);
2613 m_vuiParams = (CodecEncodeMpeg2VuiParams *)(params.pVuiParams);
2614 m_picParams = (CodecEncodeMpeg2PictureParams *)(params.pPicParams);
2615 m_sliceParams = (CodecEncodeMpeg2SliceParmas *)(params.pSliceParams);
2616 m_qMatrixParams = (CodecEncodeMpeg2QmatixParams *)(params.pIQMatrixBuffer);
2617
2618 CODECHAL_ENCODE_CHK_NULL_RETURN(m_seqParams);
2619 CODECHAL_ENCODE_CHK_NULL_RETURN(m_vuiParams);
2620 CODECHAL_ENCODE_CHK_NULL_RETURN(m_picParams);
2621 CODECHAL_ENCODE_CHK_NULL_RETURN(m_sliceParams);
2622 CODECHAL_ENCODE_CHK_NULL_RETURN(m_qMatrixParams);
2623
2624 // Mb Qp data
2625 m_mbQpDataEnabled = params.bMbQpDataEnabled;
2626 if (m_mbQpDataEnabled)
2627 {
2628 m_mbQpDataSurface = *(params.psMbQpDataSurface);
2629 }
2630 m_skipFrameFlag = m_picParams->m_skipFrameFlag;
2631
2632 m_verticalLineStride = CODECHAL_VLINESTRIDE_FRAME;
2633 m_verticalLineStrideOffset = CODECHAL_VLINESTRIDEOFFSET_TOP_FIELD;
2634 m_mbcodeBottomFieldOffset = 0;
2635 m_mvBottomFieldOffset = 0;
2636 m_scaledBottomFieldOffset = 0;
2637 m_scaled16xBottomFieldOffset = 0;
2638
2639 if (m_newSeq)
2640 {
2641 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSequenceStructs());
2642 }
2643
2644 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetPictureStructs());
2645
2646 // 4x downscaled surface needed by MbEnc IDist (for BRC) kernel or HME kernel
2647 m_scalingEnabled = (m_hmeSupported || m_brcEnabled);
2648
2649 if (CodecHal_PictureIsField(m_currOriginalPic))
2650 {
2651 m_verticalLineStride = CODECHAL_VLINESTRIDE_FIELD;
2652 m_frameHeight = m_frameFieldHeightInMb * 2 * 16;
2653 m_picHeightInMb = (uint16_t)(m_frameHeight / 16);
2654 if (CodecHal_PictureIsBottomField(m_currOriginalPic))
2655 {
2656 m_verticalLineStrideOffset = CODECHAL_VLINESTRIDEOFFSET_BOT_FIELD;
2657 m_mbcodeBottomFieldOffset = m_frameFieldHeightInMb * m_picWidthInMb * 64;
2658 m_mvBottomFieldOffset = MOS_ALIGN_CEIL(m_frameFieldHeightInMb * m_picWidthInMb * (32 * 4), 0x1000);
2659 }
2660 }
2661
2662 if (m_pictureCodingType == B_TYPE)
2663 {
2664 m_frameNumB += 1;
2665 }
2666 else
2667 {
2668 m_frameNumB = 0;
2669 }
2670
2671 if (m_pakEnabled)
2672 {
2673 CODECHAL_ENCODE_CHK_STATUS_RETURN(PackPictureHeader());
2674
2675 if (m_brcEnabled)
2676 {
2677 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
2678 uint32_t dwPicHeaderDataStartOffset,dwPicHeaderDataBufferSize;
2679
2680 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
2681 pakInsertObjectParams.pBsBuffer = &m_bsBuffer;
2682 pakInsertObjectParams.pdwMpeg2PicHeaderDataStartOffset = &dwPicHeaderDataStartOffset;
2683 pakInsertObjectParams.pdwMpeg2PicHeaderTotalBufferSize = &dwPicHeaderDataBufferSize;
2684
2685 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfcMpeg2PakInsertBrcBuffer(
2686 &m_brcBuffers.resBrcPicHeaderInputBuffer,
2687 &pakInsertObjectParams));
2688
2689 // The q_scale_type offset is relative to the beginning of the picture header buffer.
2690 // Since it starts off with the INSERT command, include its size in the offset for the
2691 // q_scale_type. Do the same for the vbv_delay offset.
2692 m_picHeaderDataBufferSize = dwPicHeaderDataBufferSize;
2693 m_qScaleTypeByteOffse += dwPicHeaderDataStartOffset;
2694 m_vbvDelayOffset += dwPicHeaderDataStartOffset;
2695 m_intraDcPrecisionOffset += dwPicHeaderDataStartOffset;
2696 }
2697
2698 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSliceGroups());
2699 }
2700
2701 CODECHAL_DEBUG_TOOL(
2702 m_debugInterface->m_currPic = m_picParams->m_currOriginalPic;
2703 m_debugInterface->m_bufferDumpFrameNum = m_storeData;
2704 m_debugInterface->m_frameType = m_pictureCodingType;
2705
2706 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpVuiParams(
2707 m_vuiParams));
2708
2709 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpPicParams(
2710 m_picParams));
2711
2712 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSeqParams(
2713 m_seqParams));
2714
2715 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSliceParams(
2716 m_sliceParams));)
2717
2718 if (m_currReconstructedPic.FrameIdx >= CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
2719 {
2720 return MOS_STATUS_INVALID_PARAMETER;
2721 }
2722 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetStatusReportParams(
2723 m_refList[m_currReconstructedPic.FrameIdx]));
2724
2725 m_bitstreamUpperBound = m_encodeParams.dwBitstreamSize;
2726
2727 return eStatus;
2728 }
2729
2730 MOS_STATUS CodechalEncodeMpeg2::InitKernelStateBrc()
2731 {
2732 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2733
2734 CODECHAL_ENCODE_FUNCTION_ENTER;
2735 uint32_t brcBtCount[CODECHAL_ENCODE_BRC_IDX_NUM] = {
2736 brcInitResetNumBindingTableEntries,
2737 brcUpdateNumBindingTableEntries,
2738 brcInitResetNumBindingTableEntries,
2739 0, // IFrameDist uses MBEnc I kernel
2740 0, // BlockCopy kernel is not needed
2741 0 // MbBRCUpdate kernel is not needed
2742 };
2743
2744 uint32_t brcCurbeSize[CODECHAL_ENCODE_BRC_IDX_NUM] = {
2745 BrcInitResetCurbe::m_byteSize,
2746 BrcUpdateCurbe::m_byteSize,
2747 BrcInitResetCurbe::m_byteSize,
2748 0, // IFrameDist uses MBEnc I kernel
2749 0, // BlockCopy kernel is not needed
2750 0 // MbBRCUpdate kernel is not needed
2751 };
2752
2753 CODECHAL_KERNEL_HEADER currKrnHeader;
2754 // CODECHAL_ENCODE_BRC_IDX_NUM - 2: BlockCopy and MbBRCUpdate kernel not needed
2755 for (uint8_t krnStateIdx = 0; krnStateIdx < CODECHAL_ENCODE_BRC_IDX_NUM - 2; krnStateIdx++)
2756 {
2757 // IFrameDist doesn't have separate kernel for MPEG2, needs to use MbEnc I kernel
2758 if (krnStateIdx == CODECHAL_ENCODE_BRC_IDX_IFRAMEDIST)
2759 {
2760 m_brcKernelStates[krnStateIdx] = m_mbEncKernelStates[mbEncKernelIdxI];
2761 continue;
2762 }
2763
2764 auto kernelState = &m_brcKernelStates[krnStateIdx];
2765 uint32_t kernelSize = m_combinedKernelSize;
2766 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
2767 m_kernelBinary,
2768 ENC_BRC,
2769 krnStateIdx,
2770 &currKrnHeader,
2771 &kernelSize));
2772
2773 kernelState->KernelParams.iBTCount = brcBtCount[krnStateIdx];
2774 kernelState->KernelParams.iThreadCount = m_hwInterface->GetRenderInterface()->GetHwCaps()->dwMaxThreads;
2775 kernelState->KernelParams.iCurbeLength = brcCurbeSize[krnStateIdx];
2776 kernelState->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
2777 kernelState->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
2778 kernelState->KernelParams.iIdCount = 1;
2779
2780 kernelState->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
2781 kernelState->KernelParams.pBinary = m_kernelBinary + (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
2782 kernelState->KernelParams.iSize = kernelSize;
2783
2784 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
2785 m_stateHeapInterface,
2786 kernelState->KernelParams.iBTCount,
2787 &kernelState->dwSshSize,
2788 &kernelState->dwBindingTableSize));
2789
2790 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelState));
2791 }
2792
2793 return eStatus;
2794 }
2795
2796 uint32_t CodechalEncodeMpeg2::GetMaxBtCount()
2797 {
2798 uint32_t scalingBtCount = MOS_ALIGN_CEIL(
2799 m_scaling4xKernelStates[0].KernelParams.iBTCount,
2800 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
2801 uint32_t meBtCount = MOS_ALIGN_CEIL(
2802 m_hmeKernel ? m_hmeKernel->GetBTCount() : m_meKernelStates[0].KernelParams.iBTCount,
2803 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
2804 uint32_t mbEncBtCount = MOS_ALIGN_CEIL(
2805 m_mbEncKernelStates[0].KernelParams.iBTCount,
2806 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
2807
2808 uint32_t brcBtCount = 0;
2809 for (uint32_t i = 0; i < CODECHAL_ENCODE_BRC_IDX_NUM; i++)
2810 {
2811 brcBtCount += MOS_ALIGN_CEIL(
2812 m_brcKernelStates[i].KernelParams.iBTCount,
2813 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
2814 }
2815
2816 return MOS_MAX(scalingBtCount + meBtCount, mbEncBtCount + brcBtCount);
2817 }
2818
2819 MOS_STATUS CodechalEncodeMpeg2::EncodeMeKernel()
2820 {
2821 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2822
2823 CODECHAL_ENCODE_FUNCTION_ENTER;
2824
2825 PerfTagSetting perfTag;
2826 perfTag.Value = 0;
2827 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
2828 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_ME_KERNEL;
2829 perfTag.PictureCodingType = m_pictureCodingType;
2830 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
2831
2832 uint32_t krnStateIdx =
2833 (m_pictureCodingType == P_TYPE) ? CODECHAL_ENCODE_ME_IDX_P : CODECHAL_ENCODE_ME_IDX_B;
2834
2835 if (m_pictureCodingType == B_TYPE && CodecHal_PictureIsInvalid(m_picParams->m_refFrameList[1]))
2836 {
2837 krnStateIdx = CODECHAL_ENCODE_ME_IDX_P;
2838 }
2839
2840 auto kernelState = &m_meKernelStates[krnStateIdx];
2841
2842 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
2843 {
2844 uint32_t maxBtCount = m_singleTaskPhaseSupported ?
2845 m_maxBtCount : kernelState->KernelParams.iBTCount;
2846 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
2847 m_stateHeapInterface,
2848 maxBtCount));
2849 m_vmeStatesSize =
2850 m_hwInterface->GetKernelLoadCommandSize(maxBtCount);
2851 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
2852 }
2853
2854 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
2855 m_stateHeapInterface,
2856 kernelState,
2857 false,
2858 0,
2859 false,
2860 m_storeData));
2861
2862 MHW_INTERFACE_DESCRIPTOR_PARAMS interfaceParams;
2863 MOS_ZeroMemory(&interfaceParams, sizeof(interfaceParams));
2864 interfaceParams.pKernelState = kernelState;
2865 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
2866 m_stateHeapInterface,
2867 1,
2868 &interfaceParams));
2869
2870 // This parameter is used to select correct mode mv cost
2871 // and search path from the predefined tables specifically
2872 // for Mpeg2 BRC encoding path
2873 m_seqParams->m_targetUsage = 8;
2874 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeMe());
2875
2876 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_4X_ME;
2877
2878 CODECHAL_DEBUG_TOOL(
2879 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
2880 encFunctionType,
2881 MHW_DSH_TYPE,
2882 kernelState));
2883 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
2884 encFunctionType,
2885 kernelState));
2886 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
2887 encFunctionType,
2888 MHW_ISH_TYPE,
2889 kernelState));
2890 )
2891
2892 MOS_COMMAND_BUFFER cmdBuffer;
2893 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(
2894 m_osInterface,
2895 &cmdBuffer,
2896 0));
2897
2898 SendKernelCmdsParams sendKernelCmdsParams;
2899 sendKernelCmdsParams.EncFunctionType = encFunctionType;
2900 sendKernelCmdsParams.pKernelState = kernelState;
2901
2902 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(
2903 &cmdBuffer,
2904 &sendKernelCmdsParams));
2905
2906 // Add binding table
2907 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
2908 m_stateHeapInterface,
2909 kernelState));
2910
2911 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendMeSurfaces(&cmdBuffer));
2912
2913 // Dump SSH for ME kernel
2914 CODECHAL_DEBUG_TOOL(
2915 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
2916 encFunctionType,
2917 MHW_SSH_TYPE,
2918 kernelState)));
2919
2920 // HW walker
2921 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
2922 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
2923 walkerCodecParams.WalkerMode = m_walkerMode;
2924 walkerCodecParams.dwResolutionX = m_downscaledWidthInMb4x;
2925 walkerCodecParams.dwResolutionY = m_downscaledFrameFieldHeightInMb4x;
2926 walkerCodecParams.bNoDependency = true;
2927
2928 MHW_WALKER_PARAMS walkerParams;
2929 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
2930 m_hwInterface,
2931 &walkerParams,
2932 &walkerCodecParams));
2933
2934 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetRenderInterface()->AddMediaObjectWalkerCmd(
2935 &cmdBuffer,
2936 &walkerParams));
2937
2938 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
2939 m_stateHeapInterface,
2940 kernelState));
2941 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
2942 {
2943 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
2944 m_stateHeapInterface));
2945
2946 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
2947 &cmdBuffer,
2948 nullptr));
2949 }
2950
2951 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
2952 &cmdBuffer,
2953 encFunctionType,
2954 nullptr)));
2955
2956 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(
2957 &cmdBuffer,
2958 m_singleTaskPhaseSupported,
2959 m_lastTaskInPhase));
2960
2961 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
2962
2963 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
2964 {
2965 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
2966 m_osInterface,
2967 &cmdBuffer,
2968 m_renderContextUsesNullHw));
2969 m_lastTaskInPhase = false;
2970 }
2971
2972 return eStatus;
2973 }
2974
2975 uint32_t CodechalEncodeMpeg2::CalcFrameRateValue(
2976 uint16_t frameRateCode,
2977 uint32_t factor)
2978 {
2979 uint32_t ret;
2980 switch(frameRateCode)
2981 {
2982 // Note a frame rate code of 0 is forbidden according to MPEG-2 spec
2983 case 0x1:
2984 ret = (uint32_t)((24000/1001.0)*factor);
2985 break;
2986 case 0x2:
2987 ret = 24 * factor;
2988 break;
2989 case 0x3:
2990 ret = 25*factor;
2991 break;
2992 case 0x4:
2993 ret = (uint32_t)((30000/1001.0)*factor);
2994 break;
2995 case 0x5:
2996 ret = 30 * factor;
2997 break;
2998 case 0x6:
2999 ret = 50 * factor;
3000 break;
3001 case 0x7:
3002 ret = (uint32_t)((60000/1001.0)*factor);
3003 break;
3004 case 0x8:
3005 ret = 60*factor;
3006 break;
3007 default:
3008 ret = 0xdeadbeef;
3009 }
3010
3011 return ret;
3012 }
3013
3014 MOS_STATUS CodechalEncodeMpeg2::SetCurbeBrcInitReset()
3015 {
3016 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3017
3018 CODECHAL_ENCODE_FUNCTION_ENTER;
3019
3020 BrcInitResetCurbe cmd;
3021
3022 cmd.m_curbeData.DW1.m_initBufFullInBits = m_seqParams->m_initVBVBufferFullnessInBit;
3023 cmd.m_curbeData.DW2.m_bufSizeInBits = m_seqParams->m_vbvBufferSize * CODEC_ENCODE_MPEG2_VBV_BUFFER_SIZE_UNITS;
3024 cmd.m_curbeData.DW3.m_averageBitRate = m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS;
3025 cmd.m_curbeData.DW4.m_maxBitRate = m_seqParams->m_maxBitRate * CODECHAL_ENCODE_BRC_KBPS;
3026
3027 if (m_picParams->m_gopPicSize == 1)
3028 {
3029 cmd.m_curbeData.DW8.m_gopP = 0;
3030 cmd.m_curbeData.DW9.m_gopB = 0;
3031 }
3032 else
3033 {
3034 cmd.m_curbeData.DW8.m_gopP = (m_picParams->m_gopRefDist) ? ((m_picParams->m_gopPicSize - 1) / m_picParams->m_gopRefDist) : 0;
3035 cmd.m_curbeData.DW9.m_gopB = (m_picParams->m_gopRefDist - 1) * cmd.m_curbeData.DW8.m_gopP;
3036 }
3037 cmd.m_curbeData.DW9.m_frameWidthInBytes = m_frameWidth;
3038 cmd.m_curbeData.DW10.m_frameHeightInBytes = m_frameHeight;
3039 cmd.m_curbeData.DW11.m_minQP = 1;
3040 cmd.m_curbeData.DW12.m_noSlices = ((m_frameHeight + 31) >> 5) << 1;
3041
3042 // Frame Rate m_value Scaled by m_frameRateDenom
3043 uint32_t scaledFrameRateValue = CalcFrameRateValue(m_seqParams->m_frameRateCode, m_frameRateDenom);
3044
3045 if (CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic))
3046 {
3047 cmd.m_curbeData.DW6.m_frameRateM = scaledFrameRateValue;
3048 }
3049 else // This else clause will only be taken when interlaced field support is added to MPEG-2.
3050 {
3051 cmd.m_curbeData.DW6.m_frameRateM = scaledFrameRateValue * 2;
3052 }
3053
3054 cmd.m_curbeData.DW7.m_frameRateD = m_frameRateDenom;
3055 cmd.m_curbeData.DW8.m_brcFlag = (CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic)) ? (0) : (CODECHAL_ENCODE_BRCINIT_FIELD_PIC);
3056
3057 if (m_seqParams->m_rateControlMethod == RATECONTROL_CBR)
3058 {
3059 cmd.m_curbeData.DW4.m_maxBitRate = cmd.m_curbeData.DW3.m_averageBitRate;
3060 cmd.m_curbeData.DW8.m_brcFlag = cmd.m_curbeData.DW8.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISCBR;
3061 }
3062 else if (m_seqParams->m_rateControlMethod == RATECONTROL_VBR)
3063 {
3064 cmd.m_curbeData.DW8.m_brcFlag = cmd.m_curbeData.DW8.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISVBR;
3065 }
3066 else if (m_seqParams->m_rateControlMethod == RATECONTROL_AVBR)
3067 {
3068 cmd.m_curbeData.DW10.m_avbrAccuracy = m_avbrAccuracy;
3069 cmd.m_curbeData.DW11.m_avbrConvergence = m_avbrConvergence;
3070 cmd.m_curbeData.DW8.m_brcFlag = cmd.m_curbeData.DW8.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISAVBR;
3071 // For AVBR, only honor bitrate from app => InitVBV = Bitrate, Buffer size = 2*Bitrate, max bitrate = target bitrate,
3072 cmd.m_curbeData.DW1.m_initBufFullInBits = m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS; //m_seqParams->bit_rate * ENCODE_BRC_KBPS;
3073 cmd.m_curbeData.DW2.m_bufSizeInBits = 2 * m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS; //m_seqParams->bit_rate * ENCODE_BRC_KBPS;
3074 cmd.m_curbeData.DW3.m_averageBitRate = m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS;
3075 cmd.m_curbeData.DW4.m_maxBitRate = m_seqParams->m_bitrate * CODECHAL_ENCODE_BRC_KBPS;
3076 }
3077
3078 // Profile & level max frame size
3079 uint32_t defaultFrameSize = m_frameWidth * m_frameHeight;
3080 if (m_seqParams->m_userMaxFrameSize > 0)
3081 {
3082 cmd.m_curbeData.DW0.m_profileLevelMaxFrame = MOS_MIN(m_seqParams->m_userMaxFrameSize, defaultFrameSize);
3083 }
3084 else
3085 {
3086 cmd.m_curbeData.DW0.m_profileLevelMaxFrame = defaultFrameSize;
3087 }
3088
3089 uint32_t brcKernelIdx = (m_brcInit) ? CODECHAL_ENCODE_BRC_IDX_INIT : CODECHAL_ENCODE_BRC_IDX_RESET;
3090 PMHW_KERNEL_STATE kernelState = &m_brcKernelStates[brcKernelIdx];
3091 if (m_brcInit)
3092 {
3093 m_brcInitCurrentTargetBufFullInBits = cmd.m_curbeData.DW1.m_initBufFullInBits;
3094 }
3095 m_brcInitResetBufSizeInBits = (double)cmd.m_curbeData.DW2.m_bufSizeInBits;
3096 m_brcInitResetInputBitsPerFrame =
3097 ((double)(cmd.m_curbeData.DW4.m_maxBitRate) * (double)(cmd.m_curbeData.DW7.m_frameRateD) /(double)(cmd.m_curbeData.DW6.m_frameRateM));
3098
3099 CODECHAL_ENCODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
3100 &cmd,
3101 kernelState->dwCurbeOffset,
3102 cmd.m_byteSize));
3103
3104 return eStatus;
3105
3106 }
3107
3108 MOS_STATUS CodechalEncodeMpeg2::SendBrcInitResetSurfaces(
3109 PMOS_COMMAND_BUFFER cmdBuffer)
3110 {
3111 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3112
3113 CODECHAL_ENCODE_FUNCTION_ENTER;
3114
3115 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
3116
3117 uint32_t brcKernelIdx = (m_brcInit) ? CODECHAL_ENCODE_BRC_IDX_INIT : CODECHAL_ENCODE_BRC_IDX_RESET;
3118 PMHW_KERNEL_STATE kernelState = &m_brcKernelStates[brcKernelIdx];
3119
3120 // BRC history buffer
3121 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
3122 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3123 surfaceCodecParams.bIsWritable = true;
3124 surfaceCodecParams.presBuffer = &m_brcBuffers.resBrcHistoryBuffer;
3125 surfaceCodecParams.dwSize = m_brcHistoryBufferSize;
3126 surfaceCodecParams.dwBindingTableOffset = brcInitResetHistory;
3127 surfaceCodecParams.bIsWritable = true;
3128
3129 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3130 m_hwInterface,
3131 cmdBuffer,
3132 &surfaceCodecParams,
3133 kernelState));
3134
3135 // AVC_ME BRC Distortion data buffer - output
3136 m_brcBuffers.sMeBrcDistortionBuffer.dwWidth = MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64);
3137 m_brcBuffers.sMeBrcDistortionBuffer.dwHeight = MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4), 8);
3138 m_brcBuffers.sMeBrcDistortionBuffer.dwPitch = m_brcBuffers.sMeBrcDistortionBuffer.dwWidth;
3139
3140 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3141 surfaceCodecParams.bIs2DSurface = true;
3142 surfaceCodecParams.bMediaBlockRW = true;
3143 surfaceCodecParams.bIsWritable = true;
3144 surfaceCodecParams.psSurface = &m_brcBuffers.sMeBrcDistortionBuffer;
3145 surfaceCodecParams.dwOffset = m_brcBuffers.dwMeBrcDistortionBottomFieldOffset;
3146 surfaceCodecParams.dwBindingTableOffset = brcInitResetDistortion;
3147 surfaceCodecParams.bIsWritable = true;
3148 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3149 m_hwInterface,
3150 cmdBuffer,
3151 &surfaceCodecParams,
3152 kernelState));
3153
3154 return eStatus;
3155 }
3156
3157 MOS_STATUS CodechalEncodeMpeg2::EncodeBrcInitResetKernel()
3158 {
3159 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3160
3161 CODECHAL_ENCODE_FUNCTION_ENTER;
3162
3163 PerfTagSetting perfTag;
3164 perfTag.Value = 0;
3165 perfTag.Mode = (uint32_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
3166 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_INIT_RESET;
3167 perfTag.PictureCodingType = m_pictureCodingType;
3168 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
3169
3170 uint32_t brcKernelIdx = (m_brcInit) ? CODECHAL_ENCODE_BRC_IDX_INIT : CODECHAL_ENCODE_BRC_IDX_RESET;
3171 PMHW_KERNEL_STATE kernelState = &m_brcKernelStates[brcKernelIdx];
3172
3173 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3174 {
3175 uint32_t maxBtCount = m_singleTaskPhaseSupported ?
3176 m_maxBtCount : kernelState->KernelParams.iBTCount;
3177 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
3178 m_stateHeapInterface,
3179 maxBtCount));
3180 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(maxBtCount);
3181 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
3182 }
3183
3184 // Setup Mpeg2 Curbe
3185 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3186 m_stateHeapInterface,
3187 kernelState,
3188 false,
3189 0,
3190 false,
3191 m_storeData));
3192
3193 MHW_INTERFACE_DESCRIPTOR_PARAMS interfaceParams;
3194 MOS_ZeroMemory(&interfaceParams, sizeof(interfaceParams));
3195 interfaceParams.pKernelState = kernelState;
3196 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
3197 m_stateHeapInterface,
3198 1,
3199 &interfaceParams));
3200
3201 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeBrcInitReset());
3202
3203 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_BRC_INIT_RESET;
3204 CODECHAL_DEBUG_TOOL(
3205 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3206 encFunctionType,
3207 MHW_DSH_TYPE,
3208 kernelState));
3209 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
3210 encFunctionType,
3211 kernelState));
3212 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3213 encFunctionType,
3214 MHW_ISH_TYPE,
3215 kernelState));
3216 )
3217
3218 MOS_COMMAND_BUFFER cmdBuffer;
3219 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
3220
3221 SendKernelCmdsParams sendKernelCmdsParams;
3222 sendKernelCmdsParams.EncFunctionType = encFunctionType;
3223 sendKernelCmdsParams.bBrcResetRequested = m_brcReset;
3224 sendKernelCmdsParams.pKernelState = kernelState;
3225
3226 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
3227
3228 // Add binding table
3229 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
3230 m_stateHeapInterface,
3231 kernelState));
3232
3233 //Add surface states
3234 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendBrcInitResetSurfaces(&cmdBuffer));
3235
3236 CODECHAL_DEBUG_TOOL(
3237 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3238 encFunctionType,
3239 MHW_SSH_TYPE,
3240 kernelState));
3241 )
3242
3243 MHW_MEDIA_OBJECT_PARAMS mediaObjectParams;
3244 MOS_ZeroMemory(&mediaObjectParams, sizeof(mediaObjectParams));
3245 MediaObjectInlineDataMpeg2 mediaObjectInlineData;
3246 MOS_ZeroMemory(&mediaObjectInlineData, sizeof(mediaObjectInlineData));
3247 mediaObjectParams.pInlineData = &mediaObjectInlineData;
3248 mediaObjectParams.dwInlineDataSize = sizeof(mediaObjectInlineData);
3249 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetRenderInterface()->AddMediaObject(
3250 &cmdBuffer,
3251 nullptr,
3252 &mediaObjectParams));
3253
3254 // add end of commands here for eStatus report
3255 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
3256
3257 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
3258 m_stateHeapInterface,
3259 kernelState));
3260 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3261 {
3262 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
3263 m_stateHeapInterface));
3264
3265 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
3266 &cmdBuffer,
3267 nullptr));
3268 }
3269
3270 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
3271 &cmdBuffer,
3272 encFunctionType,
3273 nullptr)));
3274
3275 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(
3276 &cmdBuffer,
3277 m_singleTaskPhaseSupported,
3278 m_lastTaskInPhase));
3279
3280 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
3281
3282 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3283 {
3284 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
3285 m_osInterface, &cmdBuffer,
3286 m_renderContextUsesNullHw));
3287 m_lastTaskInPhase = false;
3288 }
3289 return eStatus;
3290 }
3291
3292 MOS_STATUS CodechalEncodeMpeg2::EncodeMbEncKernel(bool mbEncIFrameDistEnabled)
3293 {
3294 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3295
3296 CODECHAL_ENCODE_FUNCTION_ENTER;
3297
3298 PerfTagSetting perfTag;
3299 perfTag.Value = 0;
3300 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
3301 perfTag.CallType =
3302 (mbEncIFrameDistEnabled) ? CODECHAL_ENCODE_PERFTAG_CALL_INTRA_DIST : CODECHAL_ENCODE_PERFTAG_CALL_MBENC_KERNEL;
3303 perfTag.PictureCodingType = m_pictureCodingType;
3304 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
3305
3306 CODECHAL_MEDIA_STATE_TYPE encFunctionType;
3307 if (mbEncIFrameDistEnabled)
3308 {
3309 encFunctionType = CODECHAL_MEDIA_STATE_ENC_I_FRAME_DIST;
3310 }
3311 else if (m_kernelMode == encodeNormalMode)
3312 {
3313 encFunctionType = CODECHAL_MEDIA_STATE_ENC_NORMAL;
3314 }
3315 else if (m_kernelMode == encodePerformanceMode)
3316 {
3317 encFunctionType = CODECHAL_MEDIA_STATE_ENC_PERFORMANCE;
3318 }
3319 else
3320 {
3321 encFunctionType = CODECHAL_MEDIA_STATE_ENC_QUALITY;
3322 }
3323
3324 PMHW_KERNEL_STATE kernelState;
3325 uint8_t codingType = m_mbEncForcePictureCodingType ?
3326 m_mbEncForcePictureCodingType : (uint8_t)m_pictureCodingType;
3327 // Initialize DSH kernel region
3328 if (mbEncIFrameDistEnabled)
3329 {
3330 kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_IFRAMEDIST];
3331 }
3332 else
3333 {
3334 // wPictureCodingType: I_TYPE = 1, P_TYPE = 2, B_TYPE = 3
3335 // KernelStates are I: 0, P: 1, B: 2
3336 // m_mbEncKernelStates: I: m_mbEncKernelStates[0], P: m_mbEncKernelStates[1], B: m_mbEncKernelStates[2]
3337 uint32_t krnStateIdx = codingType - 1;
3338
3339 kernelState = &m_mbEncKernelStates[krnStateIdx];
3340 }
3341
3342 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3343 {
3344 uint32_t maxBtCount = m_singleTaskPhaseSupported ?
3345 m_maxBtCount : kernelState->KernelParams.iBTCount;
3346 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
3347 m_stateHeapInterface,
3348 maxBtCount));
3349 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(maxBtCount);
3350 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
3351 }
3352
3353 if (m_mbEncCurbeSetInBrcUpdate)
3354 {
3355 // single task phase disabled for MPEG2 MbEnc
3356 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3357 m_stateHeapInterface,
3358 kernelState,
3359 true,
3360 0,
3361 m_singleTaskPhaseSupported,
3362 m_storeData));
3363 }
3364 else
3365 {
3366 // Set up the DSH as normal
3367 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3368 m_stateHeapInterface,
3369 kernelState,
3370 false,
3371 0,
3372 false,
3373 m_storeData));
3374
3375 MHW_INTERFACE_DESCRIPTOR_PARAMS interfaceParams;
3376 MOS_ZeroMemory(&interfaceParams, sizeof(interfaceParams));
3377 interfaceParams.pKernelState = kernelState;
3378 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
3379 m_stateHeapInterface,
3380 1,
3381 &interfaceParams));
3382
3383 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeMbEnc(mbEncIFrameDistEnabled, m_mbQpDataEnabled));
3384
3385 CODECHAL_DEBUG_TOOL(
3386 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3387 encFunctionType,
3388 MHW_DSH_TYPE,
3389 kernelState));
3390 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
3391 encFunctionType,
3392 kernelState));
3393 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3394 encFunctionType,
3395 MHW_ISH_TYPE,
3396 kernelState));
3397 )
3398 }
3399
3400 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC; i++)
3401 {
3402 if (m_picIdx[i].bValid)
3403 {
3404 auto Index = m_picIdx[i].ucPicIdx;
3405 m_refList[Index]->sRefBuffer = m_picParams->m_useRawPicForRef ?
3406 m_refList[Index]->sRefRawBuffer : m_refList[Index]->sRefReconBuffer;
3407
3408 if (m_codecFunction == CODECHAL_FUNCTION_ENC_PAK)
3409 {
3410 auto pResRefMbCodeBuffer = (MOS_RESOURCE*)m_allocator->GetResource(m_standard, mbCodeBuffer, m_refList[Index]->ucMbCodeIdx);
3411
3412 if (pResRefMbCodeBuffer)
3413 {
3414 m_refList[Index]->resRefMbCodeBuffer = *pResRefMbCodeBuffer;
3415 }
3416 }
3417
3418 CodecHalGetResourceInfo(m_osInterface, &m_refList[Index]->sRefBuffer);
3419 }
3420 }
3421
3422 MOS_COMMAND_BUFFER cmdBuffer;
3423 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
3424
3425 SendKernelCmdsParams sendKernelCmdsParams;
3426 sendKernelCmdsParams.EncFunctionType = encFunctionType;
3427 sendKernelCmdsParams.pKernelState = kernelState;
3428
3429 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
3430
3431 // Add binding table
3432 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
3433 m_stateHeapInterface,
3434 kernelState));
3435
3436 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendMbEncSurfaces(&cmdBuffer, mbEncIFrameDistEnabled));
3437
3438 if ((codingType != B_TYPE) && (!mbEncIFrameDistEnabled))
3439 {
3440 m_prevMBCodeIdx = m_currReconstructedPic.FrameIdx;
3441 }
3442
3443 // HW walker
3444 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
3445 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
3446 walkerCodecParams.WalkerMode = m_walkerMode;
3447 walkerCodecParams.bUseScoreboard = m_useHwScoreboard;
3448 walkerCodecParams.dwResolutionX = mbEncIFrameDistEnabled ?
3449 m_downscaledWidthInMb4x : (uint32_t)m_picWidthInMb;
3450 walkerCodecParams.dwResolutionY = mbEncIFrameDistEnabled ?
3451 m_downscaledFrameFieldHeightInMb4x : (uint32_t)m_frameFieldHeightInMb;
3452
3453 if (codingType == I_TYPE)
3454 {
3455 walkerCodecParams.bUseScoreboard = false;
3456 walkerCodecParams.bNoDependency = true; /* Enforce no dependency dispatch order for I frame */
3457 }
3458 else if (codingType == P_TYPE)
3459 {
3460 // walkerCodecParams.wPictureCodingType can be different from m_pictureCodingType
3461 walkerCodecParams.wPictureCodingType = I_TYPE; /* Enforce 45 degree dispatch order for P frame, as by default it's 26 degree */
3462 }
3463 else// B_TYPE
3464 {
3465 walkerCodecParams.bUseVerticalRasterScan = true;
3466 }
3467
3468 MHW_WALKER_PARAMS walkerParams;
3469 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
3470 m_hwInterface,
3471 &walkerParams,
3472 &walkerCodecParams));
3473
3474 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetRenderInterface()->AddMediaObjectWalkerCmd(
3475 &cmdBuffer,
3476 &walkerParams));
3477
3478 // add end of commands here for eStatus report
3479 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
3480
3481 CODECHAL_DEBUG_TOOL(
3482 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3483 encFunctionType,
3484 MHW_SSH_TYPE,
3485 kernelState));
3486
3487 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
3488 &cmdBuffer,
3489 encFunctionType,
3490 nullptr));
3491 )
3492
3493 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
3494 m_stateHeapInterface,
3495 kernelState));
3496 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3497 {
3498 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
3499 m_stateHeapInterface));
3500
3501 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
3502 }
3503
3504 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, m_singleTaskPhaseSupported, m_lastTaskInPhase));
3505
3506 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
3507
3508 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3509 {
3510 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw));
3511 m_lastTaskInPhase = false;
3512 }
3513
3514 return eStatus;
3515 }
3516
3517 MOS_STATUS CodechalEncodeMpeg2::SendBrcUpdateSurfaces(
3518 PMOS_COMMAND_BUFFER cmdBuffer)
3519 {
3520 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3521
3522 CODECHAL_ENCODE_FUNCTION_ENTER;
3523
3524 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
3525
3526 auto kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_FrameBRC_UPDATE];
3527 auto mbEncKernelState = m_brcBuffers.pMbEncKernelStateInUse;
3528
3529 // BRC history buffer
3530 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
3531 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3532 surfaceCodecParams.bIsWritable = true;
3533 surfaceCodecParams.presBuffer = &m_brcBuffers.resBrcHistoryBuffer;
3534 surfaceCodecParams.dwSize = m_brcHistoryBufferSize;
3535 surfaceCodecParams.dwBindingTableOffset = brcUpdateHistory;
3536 surfaceCodecParams.bIsWritable = true;
3537 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3538 m_hwInterface,
3539 cmdBuffer,
3540 &surfaceCodecParams,
3541 kernelState));
3542
3543 // PAK Statistics buffer
3544 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3545 surfaceCodecParams.presBuffer = &m_brcBuffers.resBrcPakStatisticBuffer[0];
3546 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(m_brcPakStatisticsSize);
3547 surfaceCodecParams.dwBindingTableOffset = brcUpdatePakStaticOutput;
3548 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3549 m_hwInterface,
3550 cmdBuffer,
3551 &surfaceCodecParams,
3552 kernelState));
3553
3554 // PAK IMG_STATEs buffer - read only
3555 uint32_t bufSize = MOS_BYTES_TO_DWORDS(BRC_IMG_STATE_SIZE_PER_PASS * m_mfxInterface->GetBrcNumPakPasses());
3556 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3557 surfaceCodecParams.presBuffer =
3558 &m_brcBuffers.resBrcImageStatesReadBuffer[m_currRecycledBufIdx];
3559 surfaceCodecParams.dwSize = bufSize;
3560 surfaceCodecParams.dwBindingTableOffset = brcUpdatePictureStateRead;
3561 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3562 m_hwInterface,
3563 cmdBuffer,
3564 &surfaceCodecParams,
3565 kernelState));
3566
3567 // PAK IMG_STATEs buffer - write only
3568 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3569 surfaceCodecParams.bIsWritable = true;
3570 surfaceCodecParams.presBuffer = &m_brcBuffers.resBrcImageStatesWriteBuffer;
3571 surfaceCodecParams.dwSize = bufSize;
3572 surfaceCodecParams.dwBindingTableOffset = brcUpdatePictureStateWrite;
3573 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3574 m_hwInterface,
3575 cmdBuffer,
3576 &surfaceCodecParams,
3577 kernelState));
3578
3579 // BRC ENC CURBE Buffer - read only
3580 MOS_RESOURCE *dsh = nullptr;
3581 CODECHAL_ENCODE_CHK_NULL_RETURN(dsh = mbEncKernelState->m_dshRegion.GetResource());
3582 bufSize = MOS_ALIGN_CEIL(
3583 mbEncKernelState->KernelParams.iCurbeLength,
3584 m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment());
3585 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3586 surfaceCodecParams.presBuffer = dsh;
3587 surfaceCodecParams.dwOffset =
3588 mbEncKernelState->m_dshRegion.GetOffset() +
3589 mbEncKernelState->dwCurbeOffset;
3590 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(bufSize);
3591 surfaceCodecParams.dwBindingTableOffset = brcUpdateMbencCurbeRead;
3592 // If the protection DSH isn't used, the same DSH is used for both the MbEnc CURBE read and write
3593 surfaceCodecParams.bIsWritable = true;
3594 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3595 m_hwInterface,
3596 cmdBuffer,
3597 &surfaceCodecParams,
3598 kernelState));
3599
3600 // BRC ENC CURBE Buffer - write only
3601 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3602 surfaceCodecParams.presBuffer = dsh;
3603 surfaceCodecParams.dwOffset =
3604 mbEncKernelState->m_dshRegion.GetOffset() +
3605 mbEncKernelState->dwCurbeOffset;
3606 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(bufSize);
3607 surfaceCodecParams.dwBindingTableOffset = brcUpdateMbencCurbeWrite;
3608 surfaceCodecParams.bRenderTarget = true;
3609 surfaceCodecParams.bIsWritable = true;
3610 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3611 m_hwInterface,
3612 cmdBuffer,
3613 &surfaceCodecParams,
3614 kernelState));
3615
3616 // MPEG2_ME BRC Distortion data buffer - input
3617 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3618 surfaceCodecParams.bIs2DSurface = true;
3619 surfaceCodecParams.bMediaBlockRW = true;
3620 surfaceCodecParams.psSurface = &m_brcBuffers.sMeBrcDistortionBuffer;
3621 surfaceCodecParams.dwOffset = m_brcBuffers.dwMeBrcDistortionBottomFieldOffset;
3622 surfaceCodecParams.dwSize = bufSize;
3623 surfaceCodecParams.dwBindingTableOffset = brcUpdateDistortion;
3624 surfaceCodecParams.bIsWritable = true;
3625 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3626 m_hwInterface,
3627 cmdBuffer,
3628 &surfaceCodecParams,
3629 kernelState));
3630
3631 // BRC Constant Data Surface
3632 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3633 surfaceCodecParams.bIs2DSurface = true;
3634 surfaceCodecParams.bMediaBlockRW = true;
3635 surfaceCodecParams.psSurface =
3636 &m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx];
3637 surfaceCodecParams.dwBindingTableOffset = brcUpdateConstantData;
3638 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3639 m_hwInterface,
3640 cmdBuffer,
3641 &surfaceCodecParams,
3642 kernelState));
3643
3644 // Picture header input surface
3645 bufSize = m_picHeaderDataBufferSize;
3646 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3647 surfaceCodecParams.presBuffer =
3648 &m_brcBuffers.resBrcPicHeaderInputBuffer;
3649 surfaceCodecParams.dwSize = bufSize;
3650 surfaceCodecParams.dwBindingTableOffset = brcUpdatePicHeaderInputData;
3651 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3652 m_hwInterface,
3653 cmdBuffer,
3654 &surfaceCodecParams,
3655 kernelState));
3656
3657 // Picture header output surface
3658 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
3659 surfaceCodecParams.bIsWritable = true;
3660 surfaceCodecParams.presBuffer = &m_brcBuffers.resBrcPicHeaderOutputBuffer;
3661 surfaceCodecParams.dwSize = bufSize;
3662 surfaceCodecParams.dwBindingTableOffset = brcUpdateOutputData;
3663 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
3664 m_hwInterface,
3665 cmdBuffer,
3666 &surfaceCodecParams,
3667 kernelState));
3668
3669 return eStatus;
3670 }
3671
3672 MOS_STATUS CodechalEncodeMpeg2::SetCurbeBrcUpdate()
3673 {
3674 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3675
3676 CODECHAL_ENCODE_FUNCTION_ENTER;
3677
3678 BrcUpdateCurbe cmd;
3679
3680 cmd.m_curbeData.DW5.m_targetSizeFlag = 0;
3681 if (m_brcInitCurrentTargetBufFullInBits > m_brcInitResetBufSizeInBits)
3682 {
3683 m_brcInitCurrentTargetBufFullInBits -= m_brcInitResetBufSizeInBits;
3684 cmd.m_curbeData.DW5.m_targetSizeFlag = 1;
3685 }
3686 cmd.m_curbeData.DW0.m_targetSize = (uint32_t)m_brcInitCurrentTargetBufFullInBits;
3687 cmd.m_curbeData.DW5.m_currFrameType = m_pictureCodingType - 1;
3688
3689 cmd.m_curbeData.DW5.m_brcFlag = 0;
3690
3691 if (m_seqParams->m_rateControlMethod == RATECONTROL_CBR)
3692 {
3693 cmd.m_curbeData.DW5.m_brcFlag = cmd.m_curbeData.DW5.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISCBR;
3694 }
3695 else if (m_seqParams->m_rateControlMethod == RATECONTROL_VBR)
3696 {
3697 cmd.m_curbeData.DW5.m_brcFlag = cmd.m_curbeData.DW5.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISVBR;
3698 }
3699 else if (m_seqParams->m_rateControlMethod == RATECONTROL_AVBR)
3700 {
3701 cmd.m_curbeData.DW5.m_brcFlag = cmd.m_curbeData.DW5.m_brcFlag | CODECHAL_ENCODE_BRCINIT_ISAVBR;
3702 }
3703
3704 cmd.m_curbeData.DW6.m_qScaleTypeOffset = m_qScaleTypeByteOffse;
3705 cmd.m_curbeData.DW6.m_vbvDelay = m_vbvDelayOffset;
3706 cmd.m_curbeData.DW7.m_picHeaderDataBufferSize = m_picHeaderDataBufferSize;
3707 cmd.m_curbeData.DW15.m_extraHeaders = 1;
3708 cmd.m_curbeData.DW15.m_intraDcPrecisionOffset = m_intraDcPrecisionOffset;
3709
3710 m_brcInitCurrentTargetBufFullInBits += m_brcInitResetInputBitsPerFrame;
3711
3712 if (m_seqParams->m_rateControlMethod == RATECONTROL_AVBR)
3713 {
3714 cmd.m_curbeData.DW3.m_startGAdjFrame0 = (uint32_t)((10 * m_avbrConvergence) / (double)150);
3715 cmd.m_curbeData.DW3.m_startGAdjFrame1 = (uint32_t)((50 * m_avbrConvergence) / (double)150);
3716 cmd.m_curbeData.DW4.m_startGAdjFrame2 = (uint32_t)((100 * m_avbrConvergence) / (double)150);
3717 cmd.m_curbeData.DW4.m_startGAdjFrame3 = (uint32_t)((150 * m_avbrConvergence) / (double)150);
3718 cmd.m_curbeData.DW11.m_gRateRatioThreshold0 = (uint32_t)((100 - (m_avbrAccuracy / (double)30) * (100 - 40)));
3719 cmd.m_curbeData.DW11.m_gRateRatioThreshold1 = (uint32_t)((100 - (m_avbrAccuracy / (double)30) * (100 - 75)));
3720 cmd.m_curbeData.DW12.m_gRateRatioThreshold2 = (uint32_t)((100 - (m_avbrAccuracy / (double)30) * (100 - 97)));
3721 cmd.m_curbeData.DW12.m_gRateRatioThreshold3 = (uint32_t)((100 + (m_avbrAccuracy / (double)30) * (103 - 100)));
3722 cmd.m_curbeData.DW12.m_gRateRatioThreshold4 = (uint32_t)((100 + (m_avbrAccuracy / (double)30) * (125 - 100)));
3723 cmd.m_curbeData.DW12.m_gRateRatioThreshold5 = (uint32_t)((100 + (m_avbrAccuracy / (double)30) * (160 - 100)));
3724 }
3725
3726 if (m_seqParams->m_forcePanicModeControl == 1) {
3727 cmd.m_curbeData.DW14.m_forceToSkip = m_seqParams->m_panicModeDisable ? 0 : 1;
3728 } else {
3729 cmd.m_curbeData.DW14.m_forceToSkip = m_panicEnable ? 1 : 0;
3730 }
3731 auto kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_FrameBRC_UPDATE];
3732 CODECHAL_ENCODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
3733 &cmd,
3734 kernelState->dwCurbeOffset,
3735 cmd.m_byteSize));
3736
3737 return eStatus;
3738 }
3739
3740 MOS_STATUS CodechalEncodeMpeg2::InitBrcConstantBuffer()
3741 {
3742 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3743
3744 CODECHAL_ENCODE_FUNCTION_ENTER;
3745
3746 auto brcConstantDataBuffer =
3747 m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx];
3748
3749 CodechalResLock bufLock(m_osInterface, &brcConstantDataBuffer.OsResource);
3750 auto data = (uint8_t *)bufLock.Lock(CodechalResLock::writeOnly);
3751 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
3752
3753 MOS_ZeroMemory(data, brcConstantDataBuffer.dwPitch * brcConstantDataBuffer.dwHeight);
3754
3755 uint8_t *maxFrameThresholdArray = nullptr;
3756 uint8_t *distQPAdjustmentArray = nullptr;
3757 switch(m_pictureCodingType)
3758 {
3759 case I_TYPE:
3760 maxFrameThresholdArray = (uint8_t *)m_qpAdjustmentDistThresholdMaxFrameThresholdI;
3761 distQPAdjustmentArray = (uint8_t *)m_distQpAdjustmentI;
3762 break;
3763 case P_TYPE:
3764 maxFrameThresholdArray = (uint8_t *)m_qpAdjustmentDistThresholdMaxFrameThresholdP;
3765 distQPAdjustmentArray = (uint8_t *)m_distQpAdjustmentP;
3766 break;
3767 case B_TYPE:
3768 maxFrameThresholdArray = (uint8_t *)m_qpAdjustmentDistThresholdMaxFrameThresholdB;
3769 distQPAdjustmentArray = (uint8_t *)m_distQpAdjustmentB;
3770 break;
3771 default:
3772 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid picture coding type.");
3773 eStatus = MOS_STATUS_INVALID_PARAMETER;
3774 return eStatus;
3775 }
3776
3777 // Fill surface with QP Adjustment table, Distortion threshold table, MaxFrame threshold table for I frame
3778 // The surface width happens to be the size of the array (64), but pitch can be greater.
3779 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
3780 data,
3781 m_frameThresholdArraySize,
3782 maxFrameThresholdArray,
3783 m_frameThresholdArraySize));
3784
3785 data += brcConstantDataBuffer.dwPitch; // advance next row in 2D using pitch
3786
3787 for (uint32_t i = 0; i < m_distQpAdjustmentArraySize; i += m_brcConstantSurfaceWidth, data += brcConstantDataBuffer.dwPitch)
3788 {
3789 uint32_t copySize; // to write <=64 bytes per row
3790 if ((m_distQpAdjustmentArraySize - i) > m_brcConstantSurfaceWidth)
3791 {
3792 copySize = m_brcConstantSurfaceWidth;
3793 }
3794 else
3795 {
3796 copySize = m_distQpAdjustmentArraySize - i;
3797 }
3798 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
3799 data,
3800 copySize,
3801 distQPAdjustmentArray + i,
3802 copySize));
3803 }
3804
3805 return eStatus;
3806 }
3807
3808 MOS_STATUS CodechalEncodeMpeg2::EncodeBrcUpdateKernel()
3809 {
3810 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3811
3812 CODECHAL_ENCODE_FUNCTION_ENTER;
3813
3814 PerfTagSetting perfTag;
3815 perfTag.Value = 0;
3816 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
3817 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE;
3818 perfTag.PictureCodingType = m_pictureCodingType;
3819 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
3820
3821 auto kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_FrameBRC_UPDATE];
3822
3823 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
3824 {
3825 uint32_t maxBtCount = m_singleTaskPhaseSupported ?
3826 m_maxBtCount : kernelState->KernelParams.iBTCount;
3827 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
3828 m_stateHeapInterface,
3829 maxBtCount));
3830 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(maxBtCount);
3831 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
3832 }
3833
3834 // wPictureCodingType: I_TYPE = 1, P_TYPE = 2, B_TYPE = 3
3835 // KernelStates are I: 0, P: 1, B: 2
3836 // m_mbEncKernelStates: I: m_mbEncKernelStates[0], P: m_mbEncKernelStates[1], B: m_mbEncKernelStates[2]
3837 uint32_t krnStateIdx = m_pictureCodingType - 1;
3838
3839 if (m_mbEncForcePictureCodingType)
3840 {
3841 krnStateIdx = m_mbEncForcePictureCodingType - 1;
3842 }
3843
3844 auto mbEncKernelState = &m_mbEncKernelStates[krnStateIdx];
3845
3846 // Setup MbEnc Curbe
3847 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3848 m_stateHeapInterface,
3849 mbEncKernelState,
3850 false,
3851 0,
3852 !m_singleTaskPhaseSupported,
3853 m_storeData));
3854
3855 MHW_INTERFACE_DESCRIPTOR_PARAMS interfaceParams;
3856 MOS_ZeroMemory(&interfaceParams, sizeof(interfaceParams));
3857 interfaceParams.pKernelState = mbEncKernelState;
3858 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
3859 m_stateHeapInterface,
3860 1,
3861 &interfaceParams));
3862
3863 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeMbEnc(0, 0));
3864
3865 // Brc Update
3866 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
3867 m_stateHeapInterface,
3868 kernelState,
3869 false,
3870 0,
3871 false,
3872 m_storeData));
3873
3874 MOS_ZeroMemory(&interfaceParams, sizeof(interfaceParams));
3875 interfaceParams.pKernelState = kernelState;
3876 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
3877 m_stateHeapInterface,
3878 1,
3879 &interfaceParams));
3880
3881 m_mbEncCurbeSetInBrcUpdate = true;
3882
3883 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeBrcUpdate());
3884
3885 CODECHAL_MEDIA_STATE_TYPE encFunctionType = CODECHAL_MEDIA_STATE_BRC_UPDATE;
3886 CODECHAL_MEDIA_STATE_TYPE mbEncFunctionType;
3887 if (m_kernelMode == encodeNormalMode)
3888 {
3889 mbEncFunctionType = CODECHAL_MEDIA_STATE_ENC_NORMAL;
3890 }
3891 else if (m_kernelMode == encodePerformanceMode)
3892 {
3893 mbEncFunctionType = CODECHAL_MEDIA_STATE_ENC_PERFORMANCE;
3894 }
3895 else
3896 {
3897 mbEncFunctionType = CODECHAL_MEDIA_STATE_ENC_QUALITY;
3898 }
3899
3900 CODECHAL_DEBUG_TOOL(
3901 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3902 encFunctionType,
3903 MHW_DSH_TYPE,
3904 kernelState));
3905 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
3906 encFunctionType,
3907 kernelState));
3908 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3909 encFunctionType,
3910 MHW_ISH_TYPE,
3911 kernelState));
3912 )
3913
3914 MOS_COMMAND_BUFFER cmdBuffer;
3915 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
3916
3917 SendKernelCmdsParams sendKernelCmdsParams;
3918 sendKernelCmdsParams.EncFunctionType = encFunctionType;
3919 sendKernelCmdsParams.pKernelState = kernelState;
3920
3921 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
3922
3923 // Add binding table
3924 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
3925 m_stateHeapInterface,
3926 kernelState));
3927
3928 m_brcBuffers.pMbEncKernelStateInUse = mbEncKernelState;
3929
3930 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitBrcConstantBuffer());
3931
3932 //Set MFX_MPEG2_PIC_STATE command
3933 MHW_VDBOX_MPEG2_PIC_STATE mpeg2PicState;
3934 MOS_ZeroMemory(&mpeg2PicState, sizeof(mpeg2PicState));
3935 mpeg2PicState.pEncodeMpeg2PicParams = m_picParams;
3936 mpeg2PicState.pEncodeMpeg2SeqParams = m_seqParams;
3937 mpeg2PicState.wPicWidthInMb = m_picWidthInMb;
3938 mpeg2PicState.wPicHeightInMb = m_picHeightInMb;
3939 mpeg2PicState.ppRefList = &(m_refList[0]);
3940 mpeg2PicState.bBrcEnabled = true;
3941 mpeg2PicState.bTrellisQuantEnable = false;
3942 mpeg2PicState.ucKernelMode = m_kernelMode;
3943
3944 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxMpeg2PicBrcBuffer(
3945 &m_brcBuffers.resBrcImageStatesReadBuffer[m_currRecycledBufIdx],
3946 &mpeg2PicState));
3947
3948 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendBrcUpdateSurfaces(&cmdBuffer));
3949
3950 CODECHAL_DEBUG_TOOL(
3951 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
3952 encFunctionType,
3953 MHW_SSH_TYPE,
3954 kernelState));
3955 )
3956
3957 MHW_MEDIA_OBJECT_PARAMS mediaObjectParams;
3958 MOS_ZeroMemory(&mediaObjectParams, sizeof(mediaObjectParams));
3959 MediaObjectInlineData mediaObjectInlineData;
3960 MOS_ZeroMemory(&mediaObjectInlineData, sizeof(mediaObjectInlineData));
3961 mediaObjectParams.pInlineData = &mediaObjectInlineData;
3962 mediaObjectParams.dwInlineDataSize = sizeof(mediaObjectInlineData);
3963 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetRenderInterface()->AddMediaObject(
3964 &cmdBuffer,
3965 nullptr,
3966 &mediaObjectParams));
3967
3968 // add end of commands here for eStatus report
3969 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
3970
3971 CODECHAL_DEBUG_TOOL(
3972 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
3973 &cmdBuffer,
3974 encFunctionType,
3975 nullptr));
3976
3977 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
3978 &m_brcBuffers.resBrcImageStatesReadBuffer[m_currRecycledBufIdx],
3979 CodechalDbgAttr::attrInput,
3980 "ImgStateRead",
3981 BRC_IMG_STATE_SIZE_PER_PASS * m_hwInterface->GetMfxInterface()->GetBrcNumPakPasses(),
3982 0,
3983 CODECHAL_MEDIA_STATE_BRC_UPDATE));
3984
3985 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
3986 &m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx].OsResource,
3987 CodechalDbgAttr::attrInput,
3988 "ConstData",
3989 m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx].dwPitch * m_brcBuffers.sBrcConstantDataBuffer[m_currRecycledBufIdx].dwHeight,
3990 0,
3991 CODECHAL_MEDIA_STATE_BRC_UPDATE));
3992
3993 // PAK statistics buffer is only dumped for BrcUpdate kernel input
3994 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
3995 &m_brcBuffers.resBrcPakStatisticBuffer[0],
3996 CodechalDbgAttr::attrInput,
3997 "PakStats",
3998 m_brcPakStatisticsSize,
3999 0,
4000 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4001
4002 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4003 &m_brcBuffers.sMeBrcDistortionBuffer.OsResource,
4004 CodechalDbgAttr::attrInput,
4005 "BrcDist",
4006 m_brcBuffers.sMeBrcDistortionBuffer.dwPitch * m_brcBuffers.sMeBrcDistortionBuffer.dwHeight,
4007 m_brcBuffers.dwMeBrcDistortionBottomFieldOffset,
4008 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4009
4010 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4011 &m_brcBuffers.resBrcHistoryBuffer,
4012 CodechalDbgAttr::attrInput,
4013 "HistoryRead",
4014 m_brcHistoryBufferSize,
4015 0,
4016 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4017 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4018 &m_resMbStatsBuffer,
4019 CodechalDbgAttr::attrInput,
4020 "MBStatsSurf",
4021 m_hwInterface->m_avcMbStatBufferSize,
4022 0,
4023 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4024
4025 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4026 &m_brcBuffers.resBrcPicHeaderInputBuffer,
4027 CodechalDbgAttr::attrInput,
4028 "PicHeaderRead",
4029 CODEC_ENCODE_MPEG2_BRC_PIC_HEADER_SURFACE_SIZE,
4030 0,
4031 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4032 )
4033
4034 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
4035 m_stateHeapInterface,
4036 kernelState));
4037 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
4038 {
4039 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
4040 m_stateHeapInterface));
4041
4042 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
4043 &cmdBuffer,
4044 nullptr));
4045 }
4046
4047 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(
4048 &cmdBuffer,
4049 m_singleTaskPhaseSupported,
4050 m_lastTaskInPhase));
4051
4052 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4053
4054 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
4055 {
4056 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(
4057 m_osInterface,
4058 &cmdBuffer,
4059 m_renderContextUsesNullHw));
4060 m_lastTaskInPhase = false;
4061 }
4062
4063 return eStatus;
4064 }
4065 MOS_STATUS CodechalEncodeMpeg2::ExecuteKernelFunctions()
4066 {
4067 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4068
4069 CODECHAL_ENCODE_FUNCTION_ENTER;
4070
4071 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
4072 m_rawSurfaceToEnc,
4073 CodechalDbgAttr::attrEncodeRawInputSurface,
4074 "SrcSurf")));
4075
4076 m_firstTaskInPhase = true;
4077 m_lastTaskInPhase = !m_singleTaskPhaseSupported;
4078 m_lastEncPhase = false;
4079
4080 UpdateSSDSliceCount();
4081
4082 // Csc, Downscaling, and/or 10-bit to 8-bit conversion
4083 // Scaling is only used to calculate distortions in case of Mpeg2
4084 CODECHAL_ENCODE_CHK_NULL_RETURN(m_cscDsState);
4085
4086 CodechalEncodeCscDs::KernelParams cscScalingKernelParams;
4087 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
4088 cscScalingKernelParams.bLastTaskInPhaseCSC =
4089 cscScalingKernelParams.bLastTaskInPhase4xDS = m_pictureCodingType == I_TYPE;
4090
4091 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->KernelFunctions(&cscScalingKernelParams));
4092
4093 // P and B frames distortion calculations
4094 if (m_hmeSupported && (m_pictureCodingType != I_TYPE))
4095 {
4096 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
4097 m_lastTaskInPhase = true;
4098
4099 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel());
4100 }
4101
4102 MOS_SYNC_PARAMS syncParams;
4103
4104 // Scaling and HME are not dependent on the output from PAK
4105 if (m_waitForPak &&
4106 m_semaphoreObjCount &&
4107 !Mos_ResourceIsNull(&m_resSyncObjectVideoContextInUse))
4108 {
4109 // Wait on PAK
4110 syncParams = g_cInitSyncParams;
4111 syncParams.GpuContext = m_renderContext;
4112 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
4113 syncParams.uiSemaphoreCount = m_semaphoreObjCount;
4114
4115 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
4116 m_semaphoreObjCount = 0; //reset
4117 }
4118
4119 m_firstTaskInPhase = true;
4120 if (m_brcEnabled)
4121 {
4122 if (m_pictureCodingType == I_TYPE)
4123 {
4124 // The reset/init is only valid for I frames
4125 if (m_brcInit || m_brcReset)
4126 {
4127 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeBrcInitResetKernel());
4128 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
4129 }
4130
4131 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMbEncKernel(true));
4132 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
4133 }
4134
4135 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeBrcUpdateKernel());
4136 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
4137 }
4138
4139 m_lastTaskInPhase = true;
4140 m_lastEncPhase = true;
4141 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMbEncKernel(false));
4142
4143 if (!Mos_ResourceIsNull(&m_resSyncObjectRenderContextInUse))
4144 {
4145 syncParams = g_cInitSyncParams;
4146 syncParams.GpuContext = m_renderContext;
4147 syncParams.presSyncResource = &m_resSyncObjectRenderContextInUse;
4148
4149 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4150 }
4151
4152 CODECHAL_DEBUG_TOOL(
4153 if (m_hmeEnabled && m_brcEnabled)
4154 {
4155 CODECHAL_ME_OUTPUT_PARAMS meOutputParams;
4156 MOS_ZeroMemory(&meOutputParams, sizeof(CODECHAL_ME_OUTPUT_PARAMS));
4157 meOutputParams.psMeMvBuffer = m_hmeKernel ?
4158 m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xMvDataBuffer) : &m_4xMEMVDataBuffer;
4159 meOutputParams.psMeBrcDistortionBuffer =
4160 m_brcDistortionBufferSupported ? &m_brcBuffers.sMeBrcDistortionBuffer : nullptr;
4161 meOutputParams.psMeDistortionBuffer = m_hmeKernel ?
4162 m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xDistortionBuffer) : &m_4xMEDistortionBuffer;
4163 meOutputParams.b16xMeInUse = false;
4164 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4165 &meOutputParams.psMeMvBuffer->OsResource,
4166 CodechalDbgAttr::attrOutput,
4167 "MvData",
4168 meOutputParams.psMeMvBuffer->dwHeight *meOutputParams.psMeMvBuffer->dwPitch,
4169 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 32), 64) * (m_downscaledFrameFieldHeightInMb4x * 4) : 0,
4170 CODECHAL_MEDIA_STATE_4X_ME));
4171 if (!m_vdencStreamInEnabled && meOutputParams.psMeBrcDistortionBuffer)
4172 {
4173 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4174 &meOutputParams.psMeBrcDistortionBuffer->OsResource,
4175 CodechalDbgAttr::attrOutput,
4176 "BrcDist",
4177 meOutputParams.psMeBrcDistortionBuffer->dwHeight *meOutputParams.psMeBrcDistortionBuffer->dwPitch,
4178 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64) * MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4), 8) : 0,
4179 CODECHAL_MEDIA_STATE_4X_ME));
4180 if (meOutputParams.psMeDistortionBuffer)
4181 {
4182 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4183 &meOutputParams.psMeDistortionBuffer->OsResource,
4184 CodechalDbgAttr::attrOutput,
4185 "MeDist",
4186 meOutputParams.psMeDistortionBuffer->dwHeight *meOutputParams.psMeDistortionBuffer->dwPitch,
4187 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64) * MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4 * 10), 8) : 0,
4188 CODECHAL_MEDIA_STATE_4X_ME));
4189 }
4190 }
4191 // dump VDEncStreamin
4192 if (m_vdencStreamInEnabled)
4193 {
4194 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4195 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
4196 CodechalDbgAttr::attrOutput,
4197 "MvData",
4198 m_picWidthInMb * m_picHeightInMb* CODECHAL_CACHELINE_SIZE,
4199 0,
4200 CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN));
4201 }
4202 }
4203
4204 if(m_mbQpDataEnabled)
4205 {
4206 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4207 &m_mbQpDataSurface.OsResource,
4208 CodechalDbgAttr::attrInput,
4209 "MbQp",
4210 m_mbQpDataSurface.dwHeight*m_mbQpDataSurface.dwPitch,
4211 0,
4212 CODECHAL_MEDIA_STATE_ENC_QUALITY));
4213 }
4214 if (m_brcEnabled)
4215 {
4216 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4217 &m_brcBuffers.resBrcImageStatesWriteBuffer,
4218 CodechalDbgAttr::attrOutput,
4219 "ImgStateWrite",
4220 BRC_IMG_STATE_SIZE_PER_PASS * m_hwInterface->GetMfxInterface()->GetBrcNumPakPasses(),
4221 0,
4222 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4223
4224 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4225 &m_brcBuffers.resBrcHistoryBuffer,
4226 CodechalDbgAttr::attrOutput,
4227 "HistoryWrite",
4228 m_brcHistoryBufferSize,
4229 0,
4230 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4231 if (m_brcBuffers.pMbEncKernelStateInUse)
4232 {
4233 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
4234 CODECHAL_MEDIA_STATE_BRC_UPDATE,
4235 m_brcBuffers.pMbEncKernelStateInUse));
4236 }
4237 if (m_mbencBrcBufferSize > 0)
4238 {
4239 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
4240 &m_brcBuffers.resMbEncBrcBuffer,
4241 CodechalDbgAttr::attrOutput,
4242 "MbEncBRCWrite",
4243 m_mbencBrcBufferSize,
4244 0,
4245 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4246 }
4247
4248 CODECHAL_ENCODE_CHK_STATUS_RETURN(
4249 m_debugInterface->DumpBuffer(
4250 &m_brcBuffers.resBrcPicHeaderOutputBuffer,
4251 CodechalDbgAttr::attrOutput,
4252 "PicHeaderWrite",
4253 CODEC_ENCODE_MPEG2_BRC_PIC_HEADER_SURFACE_SIZE,
4254 0,
4255 CODECHAL_MEDIA_STATE_BRC_UPDATE));
4256 }
4257 )
4258
4259 // Reset after BRC Init has been processed
4260 m_brcInit = false;
4261
4262 m_setRequestedEUSlices = false;
4263
4264 // Reset indices for next frame
4265 if (m_brcEnabled)
4266 {
4267 m_mbEncCurbeSetInBrcUpdate = false;
4268 }
4269
4270 return eStatus;
4271 }
4272
4273 MOS_STATUS CodechalEncodeMpeg2::ExecutePictureLevel()
4274 {
4275 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4276
4277 CODECHAL_ENCODE_FUNCTION_ENTER;
4278
4279 PerfTagSetting perfTag;
4280 perfTag.Value = 0;
4281 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
4282 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE;
4283 perfTag.PictureCodingType = m_pictureCodingType;
4284 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
4285
4286 // set MFX_PIPE_MODE_SELECT values
4287 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
4288 pipeModeSelectParams.Mode = m_mode;
4289 pipeModeSelectParams.bStreamOutEnabled = true;
4290 bool suppressReconPic =
4291 (!m_refList[m_currReconstructedPic.FrameIdx]->bUsedAsRef) &&
4292 m_suppressReconPicSupported;
4293 pipeModeSelectParams.bPreDeblockOutEnable = !suppressReconPic;
4294 pipeModeSelectParams.bPostDeblockOutEnable = 0;
4295
4296 // set MFX_PIPE_BUF_ADDR_STATE values
4297 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
4298 pipeBufAddrParams.Mode = m_mode;
4299 pipeBufAddrParams.psPreDeblockSurface = &m_reconSurface;
4300
4301 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
4302 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetPipeBufAddr(&pipeBufAddrParams));
4303
4304 pipeBufAddrParams.psPostDeblockSurface = &m_reconSurface;
4305 pipeBufAddrParams.psRawSurface = m_rawSurfaceToPak;
4306 pipeBufAddrParams.presStreamOutBuffer = &m_resStreamOutBuffer[m_currRecycledBufIdx];
4307 pipeBufAddrParams.presMfdDeblockingFilterRowStoreScratchBuffer = &m_resDeblockingFilterRowStoreScratchBuffer;
4308
4309 // Setting invalid entries to nullptr
4310 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
4311 {
4312 pipeBufAddrParams.presReferences[i]= nullptr;
4313 }
4314
4315 //divide by two to account for interlace. for now only 0 and 1 will be valid.
4316 for (uint32_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_NON_AVC / 2; i++)
4317 {
4318 if (m_picIdx[i].bValid)
4319 {
4320 uint8_t picIdx = m_picIdx[i].ucPicIdx;
4321 CodecHalGetResourceInfo(
4322 m_osInterface,
4323 &(m_refList[picIdx]->sRefReconBuffer));
4324 pipeBufAddrParams.presReferences[i] = &(m_refList[picIdx]->sRefReconBuffer.OsResource);
4325
4326 //HSW MPEG2 Interlaced VME refine, need extra references
4327 pipeBufAddrParams.presReferences[i + 2] = &(m_refList[picIdx]->sRefReconBuffer.OsResource);
4328
4329 CODECHAL_DEBUG_TOOL(
4330 CODECHAL_ENCODE_CHK_NULL_RETURN(m_debugInterface);
4331
4332 MOS_SURFACE refSurface;
4333 MOS_ZeroMemory(&refSurface, sizeof(refSurface));
4334 refSurface.Format = Format_NV12;
4335 refSurface.OsResource = *(pipeBufAddrParams.presReferences[i]);
4336 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalGetResourceInfo(
4337 m_osInterface,
4338 &refSurface));
4339
4340 m_debugInterface->m_refIndex = (uint16_t)i;
4341 std::string refSurfName = "RefSurf[" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex)) + "]";
4342 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
4343 &refSurface,
4344 CodechalDbgAttr::attrReferenceSurfaces,
4345 refSurfName.c_str()));)
4346 }
4347 }
4348
4349 // set MFX_SURFACE_STATE values
4350 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
4351 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
4352 surfaceParams.Mode = m_mode;
4353
4354 // set MFX_IND_OBJ_BASE_ADDR_STATE values
4355 // MPEG2 doesn't really use presMvObjectBuffer, different from AVC, the MV Data portion of the bitstream is loaded as part of MB control data
4356 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
4357 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
4358 indObjBaseAddrParams.Mode = CODECHAL_ENCODE_MODE_MPEG2;
4359 indObjBaseAddrParams.presMvObjectBuffer = &m_resMbCodeSurface;
4360 indObjBaseAddrParams.dwMvObjectOffset = m_mvOffset + m_mvBottomFieldOffset;
4361 indObjBaseAddrParams.dwMvObjectSize = m_mbCodeSize - m_mvOffset;
4362 indObjBaseAddrParams.presPakBaseObjectBuffer = &m_resBitstreamBuffer;
4363 indObjBaseAddrParams.dwPakBaseObjectSize = m_bitstreamUpperBound;
4364
4365 // set MFX_BSP_BUF_BASE_ADDR_STATE values
4366 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
4367 MOS_ZeroMemory(&bspBufBaseAddrParams, sizeof(bspBufBaseAddrParams));
4368 bspBufBaseAddrParams.presBsdMpcRowStoreScratchBuffer = &m_resMPCRowStoreScratchBuffer;
4369
4370 //Set MFX_MPEG2_PIC_STATE command
4371 MHW_VDBOX_MPEG2_PIC_STATE mpeg2PicState;
4372 MOS_ZeroMemory(&mpeg2PicState, sizeof(mpeg2PicState));
4373 mpeg2PicState.pEncodeMpeg2PicParams = m_picParams;
4374 mpeg2PicState.pEncodeMpeg2SeqParams = m_seqParams;
4375 mpeg2PicState.wPicWidthInMb = m_picWidthInMb;
4376 mpeg2PicState.wPicHeightInMb = m_picHeightInMb;
4377 mpeg2PicState.ppRefList = &(m_refList[0]);
4378 mpeg2PicState.bBrcEnabled = m_brcEnabled;
4379 mpeg2PicState.bTrellisQuantEnable = false;
4380 mpeg2PicState.ucKernelMode = m_kernelMode;
4381
4382 m_hwInterface->m_numRequestedEuSlices = (m_brcEnabled &&
4383 m_sliceStateEnable &&
4384 ((m_frameHeight * m_frameWidth) >= m_hwInterface->m_mpeg2SSDResolutionThreshold)) ?
4385 m_sliceShutdownRequestState : m_sliceShutdownDefaultState;
4386
4387 MHW_VDBOX_QM_PARAMS qmParams;
4388 qmParams.Standard = CODECHAL_MPEG2;
4389 qmParams.Mode = CODECHAL_ENCODE_MODE_MPEG2;
4390 qmParams.pMpeg2IqMatrix = (CodecMpeg2IqMatrix *)m_qMatrixParams;
4391
4392 MHW_VDBOX_QM_PARAMS fqmParams;
4393 fqmParams.Standard = CODECHAL_MPEG2;
4394 fqmParams.Mode = CODECHAL_ENCODE_MODE_MPEG2;
4395 fqmParams.pMpeg2IqMatrix = (CodecMpeg2IqMatrix *)m_qMatrixParams;
4396
4397 MOS_COMMAND_BUFFER cmdBuffer;
4398 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4399
4400 // Send command buffer header at the beginning (OS dependent)
4401 if (!m_singleTaskPhaseSupported || m_firstTaskInPhase)
4402 {
4403 // frame tracking tag is only added in the last command buffer header
4404 auto requestFrameTracking =
4405 m_singleTaskPhaseSupported ? m_firstTaskInPhase : m_lastTaskInPhase;
4406 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
4407
4408 m_hwInterface->m_numRequestedEuSlices = CODECHAL_SLICE_SHUTDOWN_DEFAULT;
4409 }
4410
4411 if (m_currPass)
4412 {
4413 // Insert conditional batch buffer end
4414 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS miConditionalBatchBufferEndParams;
4415 MOS_ZeroMemory(
4416 &miConditionalBatchBufferEndParams,
4417 sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
4418
4419 miConditionalBatchBufferEndParams.presSemaphoreBuffer =
4420 &m_encodeStatusBuf.resStatusBuffer;
4421 miConditionalBatchBufferEndParams.dwOffset =
4422 (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) +
4423 m_encodeStatusBuf.dwImageStatusMaskOffset +
4424 (sizeof(uint32_t) * 2);
4425 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
4426 &cmdBuffer,
4427 &miConditionalBatchBufferEndParams));
4428 }
4429
4430 if (!m_currPass && m_osInterface->bTagResourceSync)
4431 {
4432 // This is a solution to solve the sync tag issue: the sync tag write for PAK is inserted at the end of 2nd pass PAK BB
4433 // which may be skipped in multi-pass PAK enabled case. The idea here is to insert the previous frame's tag at the beginning
4434 // of the BB and keep the current frame's tag at the end of the BB. There will be a delay for tag update but it should be fine
4435 // as long as Dec/VP/Enc won't depend on this PAK so soon.
4436 PMOS_RESOURCE globalGpuContextSyncTagBuffer = nullptr;
4437 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetGpuStatusBufferResource(
4438 m_osInterface,
4439 globalGpuContextSyncTagBuffer));
4440 CODECHAL_ENCODE_CHK_NULL_RETURN(globalGpuContextSyncTagBuffer);
4441
4442 uint32_t statusTag = m_osInterface->pfnGetGpuStatusTag(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
4443 MHW_MI_STORE_DATA_PARAMS params;
4444 params.pOsResource = globalGpuContextSyncTagBuffer;
4445 params.dwResourceOffset = m_osInterface->pfnGetGpuStatusTagOffset(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
4446 params.dwValue = (statusTag > 0)? (statusTag - 1) : 0;
4447 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &params));
4448 }
4449
4450 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
4451
4452 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
4453
4454 // Ref surface
4455 surfaceParams.ucSurfaceStateId = CODECHAL_MFX_REF_SURFACE_ID;
4456 surfaceParams.psSurface = &m_reconSurface;
4457 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));
4458 // Src surface
4459 surfaceParams.ucSurfaceStateId = CODECHAL_MFX_SRC_SURFACE_ID;
4460 surfaceParams.psSurface = m_rawSurfaceToPak;
4461 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams));
4462
4463 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
4464
4465 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams));
4466
4467 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams));
4468
4469 if (m_brcEnabled)
4470 {
4471 MHW_BATCH_BUFFER batchBuffer;
4472 MOS_ZeroMemory(&batchBuffer, sizeof(batchBuffer));
4473 batchBuffer.OsResource = m_brcBuffers.resBrcImageStatesWriteBuffer;
4474 batchBuffer.dwOffset = m_currPass * BRC_IMG_STATE_SIZE_PER_PASS;
4475 batchBuffer.bSecondLevel = true;
4476
4477 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
4478 &cmdBuffer,
4479 &batchBuffer));
4480 }
4481 else
4482 {
4483 auto picStateCmdStart = cmdBuffer.pCmdPtr;
4484 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxMpeg2PicCmd(&cmdBuffer, &mpeg2PicState));
4485
4486 CODECHAL_DEBUG_TOOL(
4487 auto picStateCmdEnd = cmdBuffer.pCmdPtr;
4488 uint32_t picStateCmdSize = ((uint32_t)(picStateCmdEnd - picStateCmdStart))*sizeof(uint32_t);
4489 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpData(
4490 (void *)picStateCmdStart,
4491 picStateCmdSize,
4492 CodechalDbgAttr::attrPicParams,
4493 "PicState")));
4494 }
4495
4496 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(&cmdBuffer, &qmParams));
4497
4498 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxFqmCmd(&cmdBuffer, &fqmParams));
4499
4500 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4501
4502 return eStatus;
4503
4504 }
4505
4506 MOS_STATUS CodechalEncodeMpeg2::SendSliceParams(
4507 PMOS_COMMAND_BUFFER cmdBuffer,
4508 PMHW_VDBOX_MPEG2_SLICE_STATE params)
4509 {
4510 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4511
4512 CODECHAL_ENCODE_FUNCTION_ENTER;
4513
4514 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
4515 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
4516 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presDataBuffer);
4517 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pBsBuffer);
4518 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSlcData);
4519
4520 if (params->pSlcData->SliceGroup & SLICE_GROUP_START)
4521 {
4522 // add Mpeg2 Slice group commands
4523 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfcMpeg2SliceGroupCmd(cmdBuffer, params));
4524 MHW_BATCH_BUFFER secondLevelBatchBuffer;
4525 if (params->bBrcEnabled && params->dwSliceIndex == 0)
4526 {
4527 MOS_ZeroMemory(&secondLevelBatchBuffer, sizeof(MHW_BATCH_BUFFER));
4528 secondLevelBatchBuffer.OsResource = *(params->presPicHeaderBBSurf);
4529 secondLevelBatchBuffer.dwOffset = 0;
4530 secondLevelBatchBuffer.bSecondLevel = true;
4531 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(cmdBuffer, &secondLevelBatchBuffer));
4532 }
4533 else
4534 {
4535 // Insert pre-slice headers
4536 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
4537 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
4538 pakInsertObjectParams.bLastHeader = true;
4539 pakInsertObjectParams.pBsBuffer = params->pBsBuffer;
4540 pakInsertObjectParams.dwBitSize = params->dwLength;
4541 pakInsertObjectParams.dwOffset = params->dwOffset;
4542
4543 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPakInsertObject(cmdBuffer, nullptr, &pakInsertObjectParams));
4544 }
4545
4546 // Insert Batch Buffer Start command to send Mpeg2_PAK_OBJ data for MBs in this slice
4547 MOS_ZeroMemory(&secondLevelBatchBuffer, sizeof(MHW_BATCH_BUFFER));
4548 secondLevelBatchBuffer.OsResource = *params->presDataBuffer;
4549 secondLevelBatchBuffer.dwOffset = params->dwDataBufferOffset;
4550 secondLevelBatchBuffer.bSecondLevel = true;
4551
4552 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(cmdBuffer, &secondLevelBatchBuffer));
4553 }
4554
4555 return eStatus;
4556 }
4557
4558 MOS_STATUS CodechalEncodeMpeg2::ExecuteSliceLevel()
4559 {
4560 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4561
4562 CODECHAL_ENCODE_FUNCTION_ENTER;
4563
4564 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
4565
4566 auto cpInterface = m_hwInterface->GetCpInterface();
4567
4568 MOS_COMMAND_BUFFER cmdBuffer;
4569 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4570
4571 if (m_osInterface->osCpInterface->IsCpEnabled())
4572 {
4573 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
4574 sliceInfoParam.bLastPass = (m_currPass == m_numPasses) ? true : false;
4575 CODECHAL_ENCODE_CHK_STATUS_RETURN(cpInterface->SetMfxProtectionState(m_mfxInterface->IsDecodeInUse(), &cmdBuffer, nullptr, &sliceInfoParam));
4576
4577 CODECHAL_ENCODE_CHK_STATUS_RETURN(cpInterface->UpdateParams(false));
4578 }
4579
4580 MHW_VDBOX_MPEG2_SLICE_STATE sliceState;
4581 MOS_ZeroMemory(&sliceState, sizeof(sliceState));
4582 sliceState.presDataBuffer = &m_resMbCodeSurface;
4583 sliceState.pMpeg2PicIdx = &(m_picIdx[0]);
4584 sliceState.ppMpeg2RefList = &(m_refList[0]);
4585 sliceState.pEncodeMpeg2SeqParams = m_seqParams;
4586 sliceState.pEncodeMpeg2PicParams = m_picParams;
4587 sliceState.pEncodeMpeg2SliceParams = m_sliceParams;
4588 sliceState.pBsBuffer = &m_bsBuffer;
4589 sliceState.bBrcEnabled = m_brcEnabled;
4590 if (m_seqParams->m_forcePanicModeControl == 1) {
4591 sliceState.bRCPanicEnable = !m_seqParams->m_panicModeDisable;
4592 } else {
4593 sliceState.bRCPanicEnable = m_panicEnable;
4594 }
4595 sliceState.presPicHeaderBBSurf = &m_brcBuffers.resBrcPicHeaderOutputBuffer;
4596
4597 for (uint16_t slcCount = 0; slcCount < m_numSlices; slcCount++)
4598 {
4599 //we should not need to call pfnPackSliceHeader this it's done by hw
4600 PCODEC_ENCODER_SLCDATA slcData = m_slcData;
4601 CODECHAL_ENCODE_CHK_NULL_RETURN(slcData);
4602 sliceState.dwDataBufferOffset =
4603 m_slcData[slcCount].CmdOffset + m_mbcodeBottomFieldOffset;
4604 sliceState.dwOffset = slcData[slcCount].SliceOffset;
4605 sliceState.dwLength = slcData[slcCount].BitSize;
4606 sliceState.dwSliceIndex = slcCount;
4607 sliceState.bFirstPass = true;
4608 sliceState.bLastPass = false;
4609 sliceState.pSlcData = &slcData[slcCount];
4610 sliceState.bFirstPass = (m_currPass == 0);
4611 sliceState.bLastPass = (m_currPass == m_numPasses);
4612
4613 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendSliceParams(&cmdBuffer, &sliceState));
4614 }
4615
4616 // Insert end of stream if set
4617 if (m_lastPicInStream)
4618 {
4619 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
4620 MOS_ZeroMemory(&pakInsertObjectParams,sizeof(pakInsertObjectParams));
4621 pakInsertObjectParams.bLastPicInStream = true;
4622 if (m_codecFunction == CODECHAL_FUNCTION_ENC_PAK)
4623 {
4624 pakInsertObjectParams.bSetLastPicInStreamData = true;
4625 pakInsertObjectParams.dwBitSize = 32; // use dwBitSize for SrcDataEndingBitInclusion
4626 pakInsertObjectParams.dwLastPicInStreamData = (uint32_t)((1 << 16) | startCodeSequenceEnd << 24);
4627 }
4628 else
4629 {
4630 pakInsertObjectParams.bSetLastPicInStreamData = false;
4631 pakInsertObjectParams.dwBitSize = 8; // use dwBitSize for SrcDataEndingBitInclusion
4632 pakInsertObjectParams.dwLastPicInStreamData = 0;
4633 }
4634 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr, &pakInsertObjectParams));
4635 }
4636
4637 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadMfcStatus(&cmdBuffer));
4638
4639 // BRC PAK statistics different for each pass
4640 if (m_brcEnabled)
4641 {
4642 uint32_t frameOffset =
4643 (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) +
4644 m_encodeStatusBuf.dwNumPassesOffset + // Num passes offset
4645 sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
4646
4647 EncodeReadBrcPakStatsParams readBrcPakStatsParams;
4648 readBrcPakStatsParams.pHwInterface = m_hwInterface;
4649 readBrcPakStatsParams.presBrcPakStatisticBuffer = &m_brcBuffers.resBrcPakStatisticBuffer[0];
4650 readBrcPakStatsParams.presStatusBuffer = &m_encodeStatusBuf.resStatusBuffer;
4651 readBrcPakStatsParams.dwStatusBufNumPassesOffset = frameOffset;
4652 readBrcPakStatsParams.ucPass = m_currPass;
4653 readBrcPakStatsParams.VideoContext = m_videoContext;
4654
4655 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadBrcPakStatistics(
4656 &cmdBuffer,
4657 &readBrcPakStatsParams));
4658 }
4659
4660 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(
4661 &cmdBuffer,
4662 CODECHAL_NUM_MEDIA_STATES));
4663
4664 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
4665 {
4666 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(
4667 &cmdBuffer,
4668 nullptr));
4669 }
4670
4671 std::string Pak_pass = "PAK_PASS[" + std::to_string(static_cast<uint32_t>(m_currPass))+"]";
4672 CODECHAL_DEBUG_TOOL(
4673 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
4674 &cmdBuffer,
4675 CODECHAL_NUM_MEDIA_STATES,
4676 Pak_pass.c_str()));
4677
4678 //CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
4679 // m_debugInterface,
4680 // &cmdBuffer));
4681 )
4682
4683 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4684
4685 MOS_SYNC_PARAMS syncParams;
4686 if ((m_currPass == 0) &&
4687 !Mos_ResourceIsNull(&m_resSyncObjectRenderContextInUse))
4688 {
4689 syncParams = g_cInitSyncParams;
4690 syncParams.GpuContext = m_videoContext;
4691 syncParams.presSyncResource = &m_resSyncObjectRenderContextInUse;
4692
4693 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
4694 }
4695
4696 if (!m_singleTaskPhaseSupported ||
4697 m_lastTaskInPhase)
4698 {
4699 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, m_videoContextUsesNullHw));
4700
4701 CODECHAL_DEBUG_TOOL(
4702 if (m_mmcState)
4703 {
4704 m_mmcState->UpdateUserFeatureKey(&m_reconSurface);
4705 }
4706 )
4707
4708 if ((m_currPass == m_numPasses) &&
4709 m_signalEnc &&
4710 !Mos_ResourceIsNull(&m_resSyncObjectVideoContextInUse))
4711 {
4712 // Check if the signal obj count exceeds max m_value
4713 if (m_semaphoreObjCount == MOS_MIN(m_semaphoreMaxCount, MOS_MAX_OBJECT_SIGNALED))
4714 {
4715 syncParams = g_cInitSyncParams;
4716 syncParams.GpuContext = m_renderContext;
4717 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
4718
4719 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
4720 m_semaphoreObjCount--;
4721 }
4722
4723 // signal semaphore
4724 syncParams = g_cInitSyncParams;
4725 syncParams.GpuContext = m_videoContext;
4726 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
4727
4728 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4729 m_semaphoreObjCount++;
4730 }
4731 }
4732
4733 // Reset parameters for next PAK execution
4734 if (m_currPass == m_numPasses)
4735 {
4736 m_newPpsHeader = 0;
4737 m_newSeqHeader = 0;
4738 }
4739
4740 return eStatus;
4741 }
4742
4743 MOS_STATUS CodechalEncodeMpeg2::PackSkippedMB(uint32_t mbIncrement)
4744 {
4745 CODECHAL_ENCODE_FUNCTION_ENTER;
4746
4747 auto bsBuffer = &m_bsBuffer;
4748 //macroblock_escap: The macroblock_escap`e is a fixed bit-string "0000 0001 000" which is used
4749 //when the difference between macroblock_address and previous_macroblock_address is greater than 33
4750 while(mbIncrement > 33)
4751 {
4752 PutBits(bsBuffer,0x08,11);
4753 mbIncrement -= 33;
4754 }
4755 // macroblock_address_increment: This is a variable length coded integer
4756 //which indicates the difference between macroblock_address and previous_macroblock_address
4757 PutBits(bsBuffer, mpeg2AddrIncreamentTbl[mbIncrement].m_code, mpeg2AddrIncreamentTbl[mbIncrement].m_len);
4758 // macroblock_modes()
4759 //macroblock_type: Variable length coded indicator which indicates the method of coding and
4760 //content of the macroblock according to the Tables B-2 through B-8 in spec ISO 13818-2,
4761 //for skip mb, we should choose "MC, NotCoded" for P frame which means there are no quant, backward mv, mb pattern ...
4762 //choose "Bwd,Not Coded" for B frame
4763 if(m_pictureCodingType == P_TYPE)
4764 {
4765 PutBits(bsBuffer, mpeg2MbTypeTbl[1][8].m_code, mpeg2MbTypeTbl[1][8].m_len);
4766 }
4767 else if(m_pictureCodingType == B_TYPE)
4768 {
4769 PutBits(bsBuffer, mpeg2MbTypeTbl[2][4].m_code, mpeg2MbTypeTbl[2][4].m_len);
4770 }
4771 // frame_motion_type This is a two bit code indicating the macroblock prediction, 0b10 -- frame-based
4772 // 0b01 --field based 0b11---Dual-Prime
4773 // attention: currently, mpeg2 encode only support frame encoding and field frame encoding , so Picture_Struct should be 3
4774 if(m_picParams->m_framePredFrameDCT == 0)
4775 {
4776 PutBits(bsBuffer, 2, 2);
4777 }
4778 // motion_vectors // motion_vector ( 0, 0 ) //
4779 // set the MV to zero for skip MB.
4780 PutBits(bsBuffer, mpeg2MvVlcTbl[16 + 0].m_code, mpeg2MvVlcTbl[16 + 0].m_len);
4781 PutBits(bsBuffer, mpeg2MvVlcTbl[16 + 0].m_code, mpeg2MvVlcTbl[16 + 0].m_len);
4782
4783 return MOS_STATUS_SUCCESS;
4784 }
4785 MOS_STATUS CodechalEncodeMpeg2::PackSkipSliceData()
4786 {
4787 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4788
4789 CODECHAL_ENCODE_FUNCTION_ENTER;
4790
4791 auto slcParams = m_sliceParams;
4792 auto bsBuffer = &m_bsBuffer;
4793
4794 while (bsBuffer->BitOffset)
4795 {
4796 PutBits(bsBuffer, 0, 1);
4797 }
4798
4799 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
4800 {
4801 //slice start code
4802 PutBits(bsBuffer,0x000001,24);
4803 PutBits(bsBuffer,slcParams->m_firstMbY + 1,8);
4804 // quantiser_scale_code
4805 PutBits(bsBuffer,slcParams->m_quantiserScaleCode, 5);
4806 // intra_slice_flag
4807 PutBits(bsBuffer, 1, 1);
4808 // intra_slice
4809 PutBits(bsBuffer, slcParams->m_intraSlice, 1);
4810 // reserved_bits
4811 PutBits(bsBuffer, 0, 7);
4812 // extra_bit_slice
4813 PutBits(bsBuffer, 0, 1);
4814
4815 PackSkippedMB(1);
4816 PackSkippedMB(slcParams->m_numMbsForSlice - 1);
4817 while (bsBuffer->BitOffset)
4818 {
4819 PutBits(bsBuffer, 0, 1);
4820 }
4821 slcParams++;
4822 }
4823
4824 return eStatus;
4825 }
4826
4827 MOS_STATUS CodechalEncodeMpeg2::EncodeCopySkipFrame()
4828 {
4829 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4830
4831 CODECHAL_ENCODE_FUNCTION_ENTER;
4832
4833 PackSkipSliceData();
4834
4835 CodechalResLock bufLock(m_osInterface, &m_resBitstreamBuffer);
4836 auto data = bufLock.Lock(CodechalResLock::writeOnly);;
4837 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
4838
4839 auto bsBuffer = &m_bsBuffer;
4840 auto bsSize = (uint32_t)(bsBuffer->pCurrent - bsBuffer->pBase);
4841
4842 //copy skipped frame
4843 MOS_SecureMemcpy(data, bsSize, bsBuffer->pBase, bsSize);
4844 //unlock bitstream buffer
4845 m_osInterface->pfnUnlockResource( m_osInterface, &m_resBitstreamBuffer );
4846
4847 //get cmd buffer
4848 MOS_COMMAND_BUFFER cmdBuffer;
4849 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4850 //start status report
4851 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
4852
4853 //fill status report
4854 auto encodeStatus = (EncodeStatus*)(m_encodeStatusBuf.pEncodeStatus +
4855 m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize);
4856 encodeStatus->dwMFCBitstreamByteCountPerFrame = bsSize;
4857 encodeStatus->dwHeaderBytesInserted = 0; // set dwHeaderBytesInserted to 0
4858
4859 //end status report
4860 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
4861
4862 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4863
4864 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw));
4865
4866 return eStatus;
4867 }
4868
4869 MOS_STATUS CodechalEncodeMpeg2::SendMbEncSurfaces(
4870 PMOS_COMMAND_BUFFER cmdBuffer,
4871 bool mbEncIFrameDistEnabled)
4872 {
4873 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4874
4875 CODECHAL_ENCODE_FUNCTION_ENTER;
4876
4877 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
4878
4879 PMHW_KERNEL_STATE kernelState;
4880 if (mbEncIFrameDistEnabled)
4881 {
4882 kernelState = &m_brcKernelStates[CODECHAL_ENCODE_BRC_IDX_IFRAMEDIST];
4883 }
4884 else
4885 {
4886 // wPictureCodingType: I_TYPE = 1, P_TYPE = 2, B_TYPE = 3
4887 // KernelStates are I: 0, P: 1, B: 2
4888 // m_mbEncKernelStates: I: m_mbEncKernelStates[0], P: m_mbEncKernelStates[1], B: m_mbEncKernelStates[2]
4889 uint32_t krnStateIdx = m_pictureCodingType - 1;
4890
4891 if (m_mbEncForcePictureCodingType)
4892 {
4893 krnStateIdx = m_mbEncForcePictureCodingType - 1;
4894 }
4895
4896 kernelState = &m_mbEncKernelStates[krnStateIdx];
4897 }
4898
4899 auto presMbCodeBuffer = &m_refList[m_currReconstructedPic.FrameIdx]->resRefMbCodeBuffer;
4900 auto presPrevMbCodeBuffer = &m_refList[m_prevMBCodeIdx]->resRefMbCodeBuffer;
4901
4902 // Caution: if PAFF supports added, need to make sure each field get correct surface pointer
4903 // PAK Obj command buffer
4904 uint32_t pakSize = (uint32_t)m_picWidthInMb * m_frameFieldHeightInMb * 16 * 4; // 12 DW for MB + 4 DW for MV
4905 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
4906
4907 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4908 surfaceCodecParams.presBuffer = presMbCodeBuffer;
4909 surfaceCodecParams.dwSize = pakSize;
4910 surfaceCodecParams.dwOffset = (uint32_t)m_mbcodeBottomFieldOffset;
4911 surfaceCodecParams.dwCacheabilityControl =
4912 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PAK_OBJECT_ENCODE].Value;
4913 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncPakObj;
4914 surfaceCodecParams.bRenderTarget = true;
4915 surfaceCodecParams.bIsWritable = true;
4916 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4917 m_hwInterface,
4918 cmdBuffer,
4919 &surfaceCodecParams,
4920 kernelState));
4921
4922 // Prev PAK Obj command buffer
4923 pakSize = (uint32_t)m_picWidthInMb * m_frameFieldHeightInMb * 16 * 4; // 12 DW for MB + 4 DW for MV
4924
4925 // verify if the current frame is not the first frame
4926 if (!Mos_ResourceIsNull(presPrevMbCodeBuffer) &&
4927 !m_firstFrame)
4928 {
4929 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4930 surfaceCodecParams.presBuffer = presPrevMbCodeBuffer;
4931 surfaceCodecParams.dwSize = pakSize;
4932 surfaceCodecParams.dwOffset = (uint32_t)m_mbcodeBottomFieldOffset;
4933 surfaceCodecParams.dwCacheabilityControl =
4934 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_PAK_OBJECT_ENCODE].Value;
4935 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncPakObjPrev;
4936 surfaceCodecParams.bRenderTarget = true;
4937 surfaceCodecParams.bIsWritable = true;
4938 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4939 m_hwInterface,
4940 cmdBuffer,
4941 &surfaceCodecParams,
4942 kernelState));
4943 }
4944 auto currPicSurface = mbEncIFrameDistEnabled ? m_trackedBuf->Get4xDsSurface(CODEC_CURR_TRACKED_BUFFER) : m_rawSurfaceToEnc;
4945
4946 // Current Picture Y
4947 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4948 surfaceCodecParams.bIs2DSurface = true;
4949 surfaceCodecParams.psSurface = currPicSurface;
4950 surfaceCodecParams.dwCacheabilityControl =
4951 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
4952 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncCurrentY;
4953 surfaceCodecParams.dwVerticalLineStride = m_verticalLineStride;
4954 surfaceCodecParams.dwVerticalLineStrideOffset = m_verticalLineStrideOffset;
4955
4956 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
4957
4958 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4959 m_hwInterface,
4960 cmdBuffer,
4961 &surfaceCodecParams,
4962 kernelState));
4963
4964 bool currBottomField = CodecHal_PictureIsBottomField(m_currOriginalPic) ? 1 : 0;
4965 uint8_t vDirection = (CodecHal_PictureIsFrame(m_currOriginalPic)) ? CODECHAL_VDIRECTION_FRAME :
4966 (currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD;
4967
4968 // Current Picture
4969 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4970 surfaceCodecParams.bUseAdvState = true;
4971 surfaceCodecParams.psSurface = currPicSurface;
4972 surfaceCodecParams.dwCacheabilityControl =
4973 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
4974 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncCurrentPic;
4975 surfaceCodecParams.ucVDirection = vDirection;
4976
4977 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
4978
4979 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4980 m_hwInterface,
4981 cmdBuffer,
4982 &surfaceCodecParams,
4983 kernelState));
4984
4985 uint8_t picIdx0 = CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2;
4986 uint8_t picIdx1 = CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2;
4987 bool refL0BottomField = false;
4988 bool refL1BottomField = false;
4989
4990 if (m_picIdx[0].bValid)
4991 {
4992 picIdx0 = m_picIdx[0].ucPicIdx;
4993 refL0BottomField = (CodecHal_PictureIsBottomField(m_currOriginalPic)) ? 1 : 0;
4994 }
4995
4996 if (m_picIdx[1].bValid)
4997 {
4998 picIdx1 = m_picIdx[1].ucPicIdx;
4999 refL1BottomField = (CodecHal_PictureIsBottomField(m_currOriginalPic)) ? 1 : 0;
5000 }
5001
5002 // forward reference
5003 if (picIdx0 < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
5004 {
5005 if (m_verticalLineStride == CODECHAL_VLINESTRIDE_FIELD)
5006 {
5007 vDirection = (refL0BottomField ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
5008 }
5009
5010 // Picture Y
5011 CodecHalGetResourceInfo(m_osInterface, &m_refList[picIdx0]->sRefBuffer);
5012
5013 // Picture Y VME
5014 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5015 surfaceCodecParams.bUseAdvState = true;
5016 surfaceCodecParams.psSurface = &m_refList[picIdx0]->sRefBuffer;
5017 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncForwardPic;
5018 surfaceCodecParams.ucVDirection = vDirection;
5019 surfaceCodecParams.dwCacheabilityControl =
5020 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
5021
5022 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
5023
5024 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5025 m_hwInterface,
5026 cmdBuffer,
5027 &surfaceCodecParams,
5028 kernelState));
5029 }
5030
5031 // backward reference
5032 if (picIdx1 < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
5033 {
5034 if (m_verticalLineStride == CODECHAL_VLINESTRIDE_FIELD)
5035 {
5036 vDirection = (refL1BottomField ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
5037 }
5038
5039 CodecHalGetResourceInfo(m_osInterface, &m_refList[picIdx1]->sRefBuffer);
5040
5041 // Picture Y VME
5042 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5043 surfaceCodecParams.bUseAdvState = true;
5044 surfaceCodecParams.psSurface = &m_refList[picIdx1]->sRefBuffer;
5045 surfaceCodecParams.dwCacheabilityControl =
5046 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
5047 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncBackwardPic;
5048 surfaceCodecParams.ucVDirection = vDirection;
5049
5050 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
5051
5052 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5053 m_hwInterface,
5054 cmdBuffer,
5055 &surfaceCodecParams,
5056 kernelState));
5057 }
5058
5059 // Interlace Frame
5060 if ((CodecHal_PictureIsFrame(m_picParams->m_currOriginalPic)) &&
5061 (m_picParams->m_fieldCodingFlag || m_picParams->m_fieldFrameCodingFlag))
5062 {
5063 // Current Picture Interlace
5064 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5065 surfaceCodecParams.bUseAdvState = true;
5066 surfaceCodecParams.psSurface = currPicSurface;
5067 surfaceCodecParams.dwCacheabilityControl =
5068 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
5069 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncInterlaceFrameCurrentPic;
5070 surfaceCodecParams.ucVDirection = vDirection;
5071
5072 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
5073
5074 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5075 m_hwInterface,
5076 cmdBuffer,
5077 &surfaceCodecParams,
5078 kernelState));
5079
5080 if (picIdx1 < CODECHAL_NUM_UNCOMPRESSED_SURFACE_MPEG2)
5081 {
5082 // Picture Y VME
5083 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5084 surfaceCodecParams.bUseAdvState = true;
5085 surfaceCodecParams.psSurface = &m_refList[picIdx1]->sRefBuffer;
5086 surfaceCodecParams.dwCacheabilityControl =
5087 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
5088 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncInterlaceFrameBackwardPic;
5089 surfaceCodecParams.ucVDirection = vDirection;
5090
5091 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SetSurfaceParams(&surfaceCodecParams));
5092
5093 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5094 m_hwInterface,
5095 cmdBuffer,
5096 &surfaceCodecParams,
5097 kernelState));
5098 }
5099 }
5100
5101 // BRC distortion data buffer for I frame
5102 if (mbEncIFrameDistEnabled)
5103 {
5104 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5105 surfaceCodecParams.bIs2DSurface = true;
5106 surfaceCodecParams.bMediaBlockRW = true;
5107 surfaceCodecParams.psSurface = &m_brcBuffers.sMeBrcDistortionBuffer;
5108 surfaceCodecParams.dwOffset = m_brcBuffers.dwMeBrcDistortionBottomFieldOffset;
5109 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncBrcDistortionSurface;
5110 surfaceCodecParams.bRenderTarget = true;
5111 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5112 m_hwInterface,
5113 cmdBuffer,
5114 &surfaceCodecParams,
5115 kernelState));
5116 }
5117
5118 // MB-control surface for MB level QP, SkipEnable and NonSkipEnable
5119 if (m_mbQpDataEnabled)
5120 {
5121 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
5122 surfaceCodecParams.bIs2DSurface = true;
5123 surfaceCodecParams.bMediaBlockRW = true;
5124 surfaceCodecParams.psSurface = &m_mbQpDataSurface;
5125 surfaceCodecParams.dwCacheabilityControl =
5126 m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MB_QP_CODEC].Value;
5127 surfaceCodecParams.dwBindingTableOffset = m_mbEncBindingTable.m_mbEncMbControl;
5128 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5129 m_hwInterface,
5130 cmdBuffer,
5131 &surfaceCodecParams,
5132 kernelState));
5133 }
5134
5135 return eStatus;
5136 }
5137
5138 MOS_STATUS CodechalEncodeMpeg2::SendPrologWithFrameTracking(
5139 PMOS_COMMAND_BUFFER cmdBuffer,
5140 bool frameTracking,
5141 MHW_MI_MMIOREGISTERS *mmioRegister)
5142 {
5143 return CodechalEncoderState::SendPrologWithFrameTracking(cmdBuffer, frameTracking, mmioRegister);
5144 }
5145
5146 void CodechalEncodeMpeg2::UpdateSSDSliceCount()
5147 {
5148 m_setRequestedEUSlices = (m_brcEnabled &&
5149 m_sliceStateEnable &&
5150 (m_frameHeight * m_frameWidth) >= m_hwInterface->m_mpeg2SSDResolutionThreshold) ? true : false;
5151
5152 m_hwInterface->m_numRequestedEuSlices = (m_setRequestedEUSlices) ?
5153 m_sliceShutdownRequestState : m_sliceShutdownDefaultState;
5154 }
5155
5156 MOS_STATUS CodechalEncodeMpeg2::AddMediaVfeCmd(
5157 PMOS_COMMAND_BUFFER cmdBuffer,
5158 SendKernelCmdsParams *params)
5159 {
5160 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5161
5162 MHW_VFE_PARAMS vfeParams = {};
5163 vfeParams.pKernelState = params->pKernelState;
5164 vfeParams.eVfeSliceDisable = MHW_VFE_SLICE_ALL;
5165 vfeParams.dwMaximumNumberofThreads = m_encodeVfeMaxThreads;
5166
5167 if (!m_useHwScoreboard)
5168 {
5169 vfeParams.Scoreboard.ScoreboardMask = 0;
5170 }
5171 else
5172 {
5173 vfeParams.Scoreboard.ScoreboardEnable = true;
5174 vfeParams.Scoreboard.ScoreboardType = m_hwScoreboardType;
5175 vfeParams.Scoreboard.ScoreboardMask = 0xFF;
5176
5177 // Scoreboard 0
5178 vfeParams.Scoreboard.ScoreboardDelta[0].x = 0xF;
5179 vfeParams.Scoreboard.ScoreboardDelta[0].y = 0;
5180
5181 // Scoreboard 1
5182 vfeParams.Scoreboard.ScoreboardDelta[1].x = 0;
5183 vfeParams.Scoreboard.ScoreboardDelta[1].y = 0xF;
5184
5185 // Scoreboard 2
5186 vfeParams.Scoreboard.ScoreboardDelta[2].x = 0xE;
5187 vfeParams.Scoreboard.ScoreboardDelta[2].y = 0;
5188 }
5189
5190 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaVfeCmd(cmdBuffer, &vfeParams));
5191
5192 return MOS_STATUS_SUCCESS;
5193 }
5194
5195 #if USE_CODECHAL_DEBUG_TOOL
5196 MOS_STATUS CodechalEncodeMpeg2::DumpSeqParams(
5197 CodecEncodeMpeg2SequenceParams *seqParams)
5198 {
5199 CODECHAL_DEBUG_FUNCTION_ENTER;
5200
5201 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSeqParams))
5202 {
5203 return MOS_STATUS_SUCCESS;
5204 }
5205
5206 CODECHAL_DEBUG_CHK_NULL(seqParams);
5207
5208 std::ostringstream oss;
5209 oss.setf(std::ios::showbase | std::ios::uppercase);
5210
5211 oss << "m_frameWidth: " << +seqParams->m_frameWidth << std::endl;
5212 oss << "m_frameHeight: " << +seqParams->m_frameHeight << std::endl;
5213 oss << "m_profile: " << +seqParams->m_profile << std::endl;
5214 oss << "m_profile: " << +seqParams->m_level << std::endl;
5215 oss << "m_chromaFormat: " << +seqParams->m_chromaFormat << std::endl;
5216 oss << "m_targetUsage: " << +seqParams->m_targetUsage << std::endl;
5217 oss << "m_aratioFrate: " << +seqParams->m_aratioFrate << std::endl;
5218 oss << "m_aspectRatio: " << +seqParams->m_aspectRatio << std::endl;
5219 oss << "m_frameRateCode: " << +seqParams->m_frameRateCode << std::endl;
5220 oss << "m_frameRateExtN: " << +seqParams->m_frameRateExtN << std::endl;
5221 oss << "m_frameRateExtD: " << +seqParams->m_frameRateExtD << std::endl;
5222 oss << "m_bitrate: " << +seqParams->m_bitrate << std::endl;
5223 oss << "m_vbvBufferSize: " << +seqParams->m_vbvBufferSize << std::endl;
5224 oss << "m_progressiveSequence: " << +seqParams->m_progressiveSequence << std::endl;
5225 oss << "m_lowDelay: " << +seqParams->m_lowDelay << std::endl;
5226 oss << "m_resetBRC: " << +seqParams->m_resetBRC << std::endl;
5227 oss << "m_noAcceleratorSPSInsertion: " << +seqParams->m_noAcceleratorSPSInsertion << std::endl;
5228 oss << "m_reserved0: " << +seqParams->m_reserved0 << std::endl;
5229 oss << "m_rateControlMethod: " << +seqParams->m_rateControlMethod << std::endl;
5230 oss << "m_reserved1: " << +seqParams->m_reserved1 << std::endl;
5231 oss << "m_maxBitRate: " << +seqParams->m_maxBitRate << std::endl;
5232 oss << "m_minBitRate: " << +seqParams->m_minBitRate << std::endl;
5233 oss << "m_userMaxFrameSize: " << +seqParams->m_userMaxFrameSize << std::endl;
5234 oss << "m_initVBVBufferFullnessInBit: " << +seqParams->m_initVBVBufferFullnessInBit << std::endl;
5235
5236 const char *fileName = m_debugInterface->CreateFileName(
5237 "_DDIEnc",
5238 CodechalDbgBufferType::bufSeqParams,
5239 CodechalDbgExtType::txt);
5240
5241 std::ofstream ofs(fileName, std::ios::out);
5242 ofs << oss.str();
5243 ofs.close();
5244 return MOS_STATUS_SUCCESS;
5245 }
5246
5247 MOS_STATUS CodechalEncodeMpeg2::DumpPicParams(
5248 CodecEncodeMpeg2PictureParams *picParams)
5249 {
5250 CODECHAL_DEBUG_FUNCTION_ENTER;
5251
5252 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrPicParams))
5253 {
5254 return MOS_STATUS_SUCCESS;
5255 }
5256
5257 CODECHAL_DEBUG_CHK_NULL(picParams);
5258
5259 std::ostringstream oss;
5260 oss.setf(std::ios::showbase | std::ios::uppercase);
5261
5262 oss << "m_currOriginalPic: " << +picParams->m_currOriginalPic.FrameIdx << std::endl;
5263 oss << "m_currReconstructedPic: " << +picParams->m_currReconstructedPic.FrameIdx << std::endl;
5264 oss << "m_pictureCodingType: " << +picParams->m_pictureCodingType << std::endl;
5265 oss << "m_fieldCodingFlag: " << +picParams->m_fieldCodingFlag << std::endl;
5266 oss << "m_fieldFrameCodingFlag: " << +picParams->m_fieldFrameCodingFlag << std::endl;
5267 oss << "m_interleavedFieldBFF: " << +picParams->m_interleavedFieldBFF << std::endl;
5268 oss << "m_progressiveField: " << +picParams->m_progressiveField << std::endl;
5269 oss << "m_numSlice: " << +picParams->m_numSlice << std::endl;
5270 oss << "m_picBackwardPrediction: " << +picParams->m_picBackwardPrediction << std::endl;
5271 oss << "m_bidirectionalAveragingMode: " << +picParams->m_bidirectionalAveragingMode << std::endl;
5272 oss << "m_pic4MVallowed: " << +picParams->m_pic4MVallowed << std::endl;
5273 oss << "m_refFrameList: " << +picParams->m_refFrameList[0].FrameIdx << " " << +picParams->m_refFrameList[1].FrameIdx << std::endl;
5274 oss << "m_useRawPicForRef: " << +picParams->m_useRawPicForRef << std::endl;
5275 oss << "m_statusReportFeedbackNumber: " << +picParams->m_statusReportFeedbackNumber << std::endl;
5276 oss << "m_alternateScan: " << +picParams->m_alternateScan << std::endl;
5277 oss << "m_intraVlcFormat: " << +picParams->m_intraVlcFormat << std::endl;
5278 oss << "m_qscaleType: " << +picParams->m_qscaleType << std::endl;
5279 oss << "m_concealmentMotionVectors: " << +picParams->m_concealmentMotionVectors << std::endl;
5280 oss << "m_framePredFrameDCT: " << +picParams->m_framePredFrameDCT << std::endl;
5281 oss << "m_disableMismatchControl: " << +picParams->m_disableMismatchControl << std::endl;
5282 oss << "m_intraDCprecision: " << +picParams->m_intraDCprecision << std::endl;
5283 oss << "m_fcode00: " << +picParams->m_fcode00 << std::endl;
5284 oss << "m_fcode01: " << +picParams->m_fcode01 << std::endl;
5285 oss << "m_fcode10: " << +picParams->m_fcode10 << std::endl;
5286 oss << "m_fcode11: " << +picParams->m_fcode11 << std::endl;
5287 oss << "m_lastPicInStream: " << +picParams->m_lastPicInStream << std::endl;
5288 oss << "m_newGop: " << +picParams->m_newGop << std::endl;
5289 oss << "m_gopPicSize: " << +picParams->m_gopPicSize << std::endl;
5290 oss << "m_gopRefDist: " << +picParams->m_gopRefDist << std::endl;
5291 oss << "m_gopOptFlag: " << +picParams->m_gopOptFlag << std::endl;
5292 oss << "m_timeCode: " << +picParams->m_timeCode << std::endl;
5293 oss << "m_temporalReference: " << +picParams->m_temporalReference << std::endl;
5294 oss << "m_vbvDelay: " << +picParams->m_vbvDelay << std::endl;
5295 oss << "m_repeatFirstField: " << +picParams->m_repeatFirstField << std::endl;
5296 oss << "m_compositeDisplayFlag: " << +picParams->m_compositeDisplayFlag << std::endl;
5297 oss << "m_vaxis: " << +picParams->m_vaxis << std::endl;
5298 oss << "m_fieldSequence: " << +picParams->m_fieldSequence << std::endl;
5299 oss << "m_subCarrier: " << +picParams->m_subCarrier << std::endl;
5300 oss << "m_burstAmplitude: " << +picParams->m_burstAmplitude << std::endl;
5301 oss << "m_subCarrierPhase: " << +picParams->m_subCarrierPhase << std::endl;
5302
5303 const char *fileName = m_debugInterface->CreateFileName(
5304 "_DDIEnc",
5305 CodechalDbgBufferType::bufPicParams,
5306 CodechalDbgExtType::txt);
5307
5308 std::ofstream ofs(fileName, std::ios::out);
5309 ofs << oss.str();
5310 ofs.close();
5311 return MOS_STATUS_SUCCESS;
5312 }
5313
5314 MOS_STATUS CodechalEncodeMpeg2::DumpSliceParams(
5315 CodecEncodeMpeg2SliceParmas *sliceParams)
5316 {
5317 CODECHAL_DEBUG_FUNCTION_ENTER;
5318
5319 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrSlcParams))
5320 {
5321 return MOS_STATUS_SUCCESS;
5322 }
5323
5324 CODECHAL_DEBUG_CHK_NULL(sliceParams);
5325
5326 std::ostringstream oss;
5327 oss.setf(std::ios::showbase | std::ios::uppercase);
5328
5329 oss << "m_numMbsForSlice: " << +sliceParams->m_numMbsForSlice << std::endl;
5330 oss << "m_firstMbX: " << +sliceParams->m_firstMbX << std::endl;
5331 oss << "m_firstMbY: " << +sliceParams->m_firstMbY << std::endl;
5332 oss << "m_intraSlice: " << +sliceParams->m_intraSlice << std::endl;
5333 oss << "m_quantiserScaleCode: " << +sliceParams->m_quantiserScaleCode << std::endl;
5334
5335 const char *fileName = m_debugInterface->CreateFileName(
5336 "_DDIEnc",
5337 CodechalDbgBufferType::bufSlcParams,
5338 CodechalDbgExtType::txt);
5339
5340 std::ofstream ofs(fileName, std::ios::out);
5341 ofs << oss.str();
5342 ofs.close();
5343
5344 return MOS_STATUS_SUCCESS;
5345 }
5346
5347 MOS_STATUS CodechalEncodeMpeg2::DumpVuiParams(
5348 CodecEncodeMpeg2VuiParams *vuiParams)
5349 {
5350 CODECHAL_DEBUG_FUNCTION_ENTER;
5351 CODECHAL_DEBUG_CHK_NULL(vuiParams);
5352
5353 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrVuiParams))
5354 {
5355 return MOS_STATUS_SUCCESS;
5356 }
5357
5358 std::ostringstream oss;
5359 oss.setf(std::ios::showbase | std::ios::uppercase);
5360
5361 oss << "m_videoFormat: " << +vuiParams->m_videoFormat << std::endl;
5362 oss << "m_colourDescription: " << +vuiParams->m_colourDescription << std::endl;
5363 oss << "m_colourPrimaries: " << +vuiParams->m_colourPrimaries << std::endl;
5364 oss << "m_transferCharacteristics: " << +vuiParams->m_transferCharacteristics << std::endl;
5365 oss << "m_matrixCoefficients: " << +vuiParams->m_matrixCoefficients << std::endl;
5366 oss << "m_displayHorizontalSize: " << +vuiParams->m_displayHorizontalSize << std::endl;
5367 oss << "m_displayVerticalSize: " << +vuiParams->m_displayVerticalSize << std::endl;
5368
5369 const char *fileName = m_debugInterface->CreateFileName(
5370 "_DDIEnc",
5371 CodechalDbgBufferType::bufVuiParams,
5372 CodechalDbgExtType::txt);
5373
5374 std::ofstream ofs(fileName, std::ios::out);
5375 ofs << oss.str();
5376 ofs.close();
5377 return MOS_STATUS_SUCCESS;
5378 }
5379 #endif
5380
5381 /**************************************************************************
5382 * MB sequence in a non-MBAFF picture with WidthInMB = 5 & HeightInMB = 6
5383 * 26 degree walking pattern
5384 * 0 1 2 3 4
5385 * -----------------------
5386 * 0 | 0 1 2 4 6
5387 * 1 | 3 5 7 9 11
5388 * 2 | 8 10 12 14 16
5389 * 3 | 13 15 17 19 21
5390 * 4 | 18 20 22 24 26
5391 * 5 | 23 25 27 28 29
5392 ***************************************************************************/
5393 void CodechalEncodeMpeg2::MBWalker(uint16_t picWidthInMB, uint16_t picHeightInMB, uint16_t *mbmap)
5394 {
5395 uint16_t i, j;
5396 uint16_t numMBs = picWidthInMB * picHeightInMB;
5397 uint16_t curX = 0, curY = 0, wflenX, wflenY;
5398 uint16_t wfstart = 0, wflen;
5399 uint16_t walkX, walkY;
5400
5401 wflenY = picHeightInMB - 1;
5402 for (i = 0; i < numMBs; i++)
5403 {
5404 // Get current region length
5405 wflenX = curX / 2;
5406 wflen = (wflenX < wflenY) ? wflenX : wflenY;
5407
5408 mbmap[wfstart] = curY * picWidthInMB + curX;
5409
5410 if (wfstart == (numMBs - 1))
5411 break;
5412
5413 walkX = curX - 2;
5414 walkY = curY + 1;
5415 for (j = 0; j < wflen; j++)
5416 {
5417 mbmap[wfstart + j + 1] = walkY * picWidthInMB + walkX;
5418 walkX -= 2;
5419 walkY++;
5420 }
5421
5422 // Start new region
5423 if (curX == (picWidthInMB - 1))
5424 {
5425 // Right picture boundary reached, adjustment required
5426 curX--;
5427 curY++;
5428 wflenY--;
5429 }
5430 else
5431 {
5432 curX++;
5433 }
5434 wfstart += (wflen + 1);
5435 }
5436 }
5437
5438 /**************************************************************************
5439 * MB sequence in a non-MBAFF picture with WidthInMB = 5 & HeightInMB = 6
5440 * 45 degree pattern
5441 * 0 1 2 3 4
5442 * -----------------------
5443 * 0 | 0 1 3 6 10
5444 * 1 | 2 4 7 11 15
5445 * 2 | 5 8 12 16 20
5446 * 3 | 9 13 17 21 24
5447 * 4 | 14 18 22 25 27
5448 * 5 | 19 23 26 28 29
5449 ***************************************************************************/
5450 void CodechalEncodeMpeg2::MBWalker45Degree(uint16_t picWidthInMB, uint16_t picHeightInMB, uint16_t *mbmap)
5451 {
5452 uint16_t i, j;
5453 uint16_t numMBs = picWidthInMB * picHeightInMB;
5454 uint16_t curX = 0, curY = 0, wflenX, wflenY;
5455 uint16_t wfstart = 0, wflen;
5456 uint16_t walkX, walkY;
5457
5458 wflenY = picHeightInMB - 1;
5459 for (i = 0; i < numMBs; i++)
5460 {
5461 // Get current region length
5462 wflenX = curX;
5463 wflen = (wflenX < wflenY) ? wflenX : wflenY;
5464
5465 mbmap[wfstart] = curY * picWidthInMB + curX;
5466
5467 if (wfstart == (numMBs - 1))
5468 break;
5469
5470 walkX = curX - 1;
5471 walkY = curY + 1;
5472 for (j = 0; j < wflen; j++)
5473 {
5474 mbmap[wfstart + j + 1] = walkY * picWidthInMB + walkX;
5475 walkX -= 1;
5476 walkY++;
5477 }
5478
5479 // Start new region
5480 if (curX == (picWidthInMB - 1))
5481 {
5482 // Right picture boundary reached, adjustment required
5483 curY++;
5484 wflenY--;
5485 }
5486 else
5487 {
5488 curX++;
5489 }
5490 wfstart += (wflen + 1);
5491 }
5492 }
5493
5494 /**************************************************************************
5495 * MB sequence in a MBAFF picture with WidthInMB = 5 & HeightInMB = 6
5496 * 26 degree walking pattern
5497 * 0 1 2 3 4
5498 * -----------------------
5499 * 0 | 0 2 4 8 12
5500 * 1 | 1 3 6 10 15
5501 * 2 | 5 9 13 18 22
5502 * 3 | 7 11 16 20 24
5503 * 4 | 14 19 23 26 28
5504 * 5 | 17 21 25 27 29
5505 ***************************************************************************/
5506 void CodechalEncodeMpeg2::MBWalkerMBAFF(uint16_t picWidthInMB, uint16_t picHeightInMB, uint16_t *mbmap)
5507 {
5508 uint16_t i, j, k;
5509 uint16_t numMBs = picWidthInMB * picHeightInMB;
5510 uint16_t curX = 0, curY = 0, wflenX, wflenY;
5511 uint16_t wfstart = 0, wflen;
5512 uint16_t walkX, walkY;
5513
5514 wflenY = picHeightInMB / 2 - 1;
5515 for (i = 0; i < numMBs; i++)
5516 {
5517 // Get current region length
5518 wflenX = curX / 2;
5519 wflen = (wflenX < wflenY) ? wflenX : wflenY;
5520
5521 mbmap[wfstart] = curY * picWidthInMB + curX * 2;
5522 mbmap[wfstart + wflen + 1] = mbmap[wfstart] + 1;
5523
5524 if ((wfstart + wflen + 1) == (numMBs - 1))
5525 break;
5526
5527 walkX = curX - 2;
5528 walkY = curY + 2;
5529 for (j = 0; j < wflen; j++)
5530 {
5531 k = wfstart + j + 1;
5532 mbmap[k] = walkY * picWidthInMB + walkX * 2;
5533 mbmap[k + wflen + 1] = mbmap[k] + 1;
5534 walkX -= 2;
5535 walkY += 2;
5536 }
5537
5538 // Start new region
5539 if (curX == (picWidthInMB - 1))
5540 {
5541 // Right picture boundary reached, adjustment required
5542 curX--;
5543 curY += 2;
5544 wflenY--;
5545 }
5546 else
5547 {
5548 curX++;
5549 }
5550 wfstart += ((wflen + 1) * 2);
5551 }
5552 }
5553
5554 /**************************************************************************
5555 * MB sequence in a non-MBAFF picture with WidthInMB = 5 & HeightInMB = 5
5556 * Raster scan pattern
5557 * 0 1 2 3 4
5558 * -----------------------
5559 * 0 | 0 1 2 3 4
5560 * 1 | 5 6 7 8 9
5561 * 2 | 10 11 12 13 14
5562 * 3 | 15 16 17 18 19
5563 * 4 | 20 21 22 23 24
5564 ***************************************************************************/
5565 void CodechalEncodeMpeg2::MBWalkerRasterScan(uint16_t picWidthInMB, uint16_t picHeightInMB, uint16_t *mbmap)
5566 {
5567 uint32_t i;
5568 uint32_t numMBs = picWidthInMB * picHeightInMB;
5569
5570 for (i = 0; i < numMBs; i++)
5571 {
5572 mbmap[i] = (uint16_t)i;
5573 }
5574 }
5575
5576 /**************************************************************************
5577 * MB sequence in a non-MBAFF picture with WidthInMB = 5 & HeightInMB = 5
5578 * Vertical scan pattern
5579 * 0 1 2 3 4
5580 * -----------------------
5581 * 0 | 0 5 10 15 20
5582 * 1 | 1 6 11 16 21
5583 * 2 | 2 7 12 17 22
5584 * 3 | 3 8 13 18 23
5585 * 4 | 4 9 14 19 24
5586 ***************************************************************************/
5587 void CodechalEncodeMpeg2::MBWalkerVerticalScan(uint16_t picWidthInMB, uint16_t picHeightInMB, uint16_t *mbmap)
5588 {
5589 uint32_t i, j, k;
5590
5591 for (i = 0, k = 0; i < picWidthInMB; i++)
5592 {
5593 for (j = 0; j < picHeightInMB; j++)
5594 {
5595 mbmap[k++] = (uint16_t)(i + j * picWidthInMB);
5596 }
5597 }
5598 }