Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2011-2023, 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_vdenc_avc.cpp
24 //! \brief This file implements the base C++ class/interface for AVC VDENC encoding
25 //! to be used across CODECHAL components.
26 //!
27
28 #include "codechal_vdenc_avc.h"
29 #include "hal_oca_interface.h"
30 #include "mos_os_cp_interface_specific.h"
31
32 #define CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE 128
33 #define CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE 52
34 #define CODECHAL_ENCODE_AVC_SEI_BUFFER_SIZE 10240 // 10K is just estimation
35 #define CODECHAL_ENCODE_AVC_DEFAULT_TRELLIS_QUANT_ROUNDING 3
36 #define CODECHAL_ENCODE_AVC_SKIP_BIAS_ADJUSTMENT_QP_THRESHOLD 22
37 #define CODECHAL_ENCODE_AVC_HME_FIRST_STEP 0
38 #define CODECHAL_ENCODE_AVC_HME_FOLLOWING_STEP 1
39 #define CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_32x 1
40 #define CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_16x 2
41 #define CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_4x 2
42 #define CODECHAL_ENCODE_AVC_PREV_MV_READ_POSITION_16x 1
43 #define CODECHAL_ENCODE_AVC_PREV_MV_READ_POSITION_4x 0
44
45 #define CODECHAL_ENCODE_VDENC_IMG_STATE_CMD_SIZE 140
46 #define CODECHAL_ENCODE_MI_BATCH_BUFFER_END_CMD_SIZE 4
47
48 typedef enum _CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_ME
49 {
50 CODECHAL_ENCODE_AVC_ME_MV_DATA_SURFACE = 0,
51 CODECHAL_ENCODE_AVC_16xME_MV_DATA_SURFACE = 1,
52 CODECHAL_ENCODE_AVC_32xME_MV_DATA_SURFACE = 1,
53 CODECHAL_ENCODE_AVC_ME_DISTORTION_SURFACE = 2,
54 CODECHAL_ENCODE_AVC_ME_BRC_DISTORTION = 3,
55 CODECHAL_ENCODE_AVC_ME_RESERVED0 = 4,
56 CODECHAL_ENCODE_AVC_ME_CURR_FOR_FWD_REF = 5,
57 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX0 = 6,
58 CODECHAL_ENCODE_AVC_ME_RESERVED1 = 7,
59 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX1 = 8,
60 CODECHAL_ENCODE_AVC_ME_RESERVED2 = 9,
61 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX2 = 10,
62 CODECHAL_ENCODE_AVC_ME_RESERVED3 = 11,
63 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX3 = 12,
64 CODECHAL_ENCODE_AVC_ME_RESERVED4 = 13,
65 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX4 = 14,
66 CODECHAL_ENCODE_AVC_ME_RESERVED5 = 15,
67 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX5 = 16,
68 CODECHAL_ENCODE_AVC_ME_RESERVED6 = 17,
69 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX6 = 18,
70 CODECHAL_ENCODE_AVC_ME_RESERVED7 = 19,
71 CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX7 = 20,
72 CODECHAL_ENCODE_AVC_ME_RESERVED8 = 21,
73 CODECHAL_ENCODE_AVC_ME_CURR_FOR_BWD_REF = 22,
74 CODECHAL_ENCODE_AVC_ME_BWD_REF_IDX0 = 23,
75 CODECHAL_ENCODE_AVC_ME_RESERVED9 = 24,
76 CODECHAL_ENCODE_AVC_ME_BWD_REF_IDX1 = 25,
77 CODECHAL_ENCODE_AVC_ME_VDENC_STREAMIN = 26,
78 CODECHAL_ENCODE_AVC_ME_NUM_SURFACES = 27
79 } CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_ME;
80
81 // binding table for State Content Detection
82 typedef enum _CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_SFD_COMMON
83 {
84 CODECHAL_ENCODE_AVC_SFD_VDENC_INPUT_IMAGE_STATE_COMMON = 0,
85 CODECHAL_ENCODE_AVC_SFD_MV_DATA_SURFACE_COMMON = 1,
86 CODECHAL_ENCODE_AVC_SFD_INTER_DISTORTION_SURFACE_COMMON = 2,
87 CODECHAL_ENCODE_AVC_SFD_OUTPUT_DATA_SURFACE_COMMON = 3,
88 CODECHAL_ENCODE_AVC_SFD_VDENC_OUTPUT_IMAGE_STATE_COMMON = 4,
89 CODECHAL_ENCODE_AVC_SFD_NUM_SURFACES = 5
90 } CODECHAL_ENCODE_AVC_BINDING_TABLE_OFFSET_SFD_COMMON;
91
92 const uint32_t CodechalVdencAvcState::AVC_Mode_Cost[2][12][CODEC_AVC_NUM_QP] =
93 {
94 //INTRASLICE
95 {
96 //LUTMODE_INTRA_NONPRED
97 {
98 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, //QP=[0 ~12]
99 16,
100 18,
101 22,
102 24,
103 13,
104 15,
105 16,
106 18,
107 13,
108 15,
109 15,
110 12,
111 14, //QP=[13~25]
112 12,
113 12,
114 10,
115 10,
116 11,
117 10,
118 10,
119 10,
120 9,
121 9,
122 8,
123 8,
124 8, //QP=[26~38]
125 8,
126 8,
127 8,
128 8,
129 8,
130 8,
131 8,
132 8,
133 7,
134 7,
135 7,
136 7,
137 7, //QP=[39~51]
138 },
139 //LUTMODE_INTRA_16x16, LUTMODE_INTRA
140 {
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //QP=[0 ~12]
142 0,
143 0,
144 0,
145 0,
146 0,
147 0,
148 0,
149 0,
150 0,
151 0,
152 0,
153 0,
154 0, //QP=[13~25]
155 0,
156 0,
157 0,
158 0,
159 0,
160 0,
161 0,
162 0,
163 0,
164 0,
165 0,
166 0,
167 0, //QP=[26~38]
168 0,
169 0,
170 0,
171 0,
172 0,
173 0,
174 0,
175 0,
176 0,
177 0,
178 0,
179 0,
180 0, //QP=[39~51]
181 },
182 //LUTMODE_INTRA_8x8
183 {
184 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //QP=[0 ~12]
185 0,
186 0,
187 0,
188 0,
189 0,
190 0,
191 1,
192 1,
193 1,
194 1,
195 1,
196 1,
197 1, //QP=[13~25]
198 1,
199 1,
200 1,
201 1,
202 1,
203 4,
204 4,
205 4,
206 4,
207 6,
208 6,
209 6,
210 6, //QP=[26~38]
211 6,
212 6,
213 6,
214 6,
215 6,
216 6,
217 6,
218 6,
219 7,
220 7,
221 7,
222 7,
223 7, //QP=[39~51]
224 },
225 //LUTMODE_INTRA_4x4
226 {
227 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, //QP=[0 ~12]
228 64,
229 72,
230 80,
231 88,
232 48,
233 56,
234 64,
235 72,
236 53,
237 59,
238 64,
239 56,
240 64, //QP=[13~25]
241 57,
242 64,
243 58,
244 55,
245 64,
246 64,
247 64,
248 64,
249 59,
250 59,
251 60,
252 57,
253 50, //QP=[26~38]
254 46,
255 42,
256 38,
257 34,
258 31,
259 27,
260 23,
261 22,
262 19,
263 18,
264 16,
265 14,
266 13, //QP=[39~51]
267 },
268
269 //LUTMODE_INTER_16x8, LUTMODE_INTER_8x16
270 {
271 0,
272 },
273 //LUTMODE_INTER_8x8q
274 {
275 0,
276 },
277 //LUTMODE_INTER_8x4q, LUTMODE_INTER_4x8q, LUTMODE_INTER_16x8_FIELD
278 {
279 0,
280 },
281 //LUTMODE_INTER_4x4q, LUTMODE_INTER_8x8_FIELD
282 {
283 0,
284 },
285 //LUTMODE_INTER_16x16, LUTMODE_INTER
286 {
287 0,
288 },
289 //LUTMODE_INTER_BWD
290 {
291 0,
292 },
293 //LUTMODE_REF_ID
294 {
295 0,
296 },
297 //LUTMODE_INTRA_CHROMA
298 {
299 0,
300 },
301 },
302 //PREDSLICE
303 {
304 //LUTMODE_INTRA_NONPRED
305 {
306 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, //QP=[0 ~12]
307 7,
308 8,
309 9,
310 10,
311 5,
312 6,
313 7,
314 8,
315 6,
316 7,
317 7,
318 7,
319 7, //QP=[13~25]
320 6,
321 7,
322 7,
323 6,
324 7,
325 7,
326 7,
327 7,
328 7,
329 7,
330 7,
331 7,
332 7, //QP=[26~38]
333 7,
334 7,
335 7,
336 7,
337 7,
338 7,
339 7,
340 7,
341 7,
342 7,
343 7,
344 7,
345 7, //QP=[39~51]
346 },
347 {
348 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, //QP=[0 ~12]
349 24,
350 28,
351 31,
352 35,
353 19,
354 21,
355 24,
356 28,
357 20,
358 24,
359 25,
360 21,
361 24, //QP=[13~25]
362 24,
363 24,
364 24,
365 21,
366 24,
367 24,
368 26,
369 24,
370 24,
371 24,
372 24,
373 24,
374 24, //QP=[26~38]
375 24,
376 24,
377 24,
378 24,
379 24,
380 24,
381 24,
382 24,
383 24,
384 24,
385 24,
386 24,
387 24, //QP=[39~51]
388 },
389
390 //LUTMODE_INTRA_8x8
391 {
392 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, //QP=[0 ~12]
393 28,
394 32,
395 36,
396 40,
397 22,
398 26,
399 28,
400 32,
401 24,
402 26,
403 30,
404 26,
405 28, //QP=[13~25]
406 26,
407 28,
408 26,
409 26,
410 30,
411 28,
412 28,
413 28,
414 26,
415 28,
416 28,
417 26,
418 28, //QP=[26~38]
419 28,
420 28,
421 28,
422 28,
423 28,
424 28,
425 28,
426 28,
427 28,
428 28,
429 28,
430 28,
431 28, //QP=[39~51]
432 },
433 //LUTMODE_INTRA_4x4
434 {
435 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, //QP=[0 ~12]
436 72,
437 80,
438 88,
439 104,
440 56,
441 64,
442 72,
443 80,
444 58,
445 68,
446 76,
447 64,
448 68, //QP=[13~25]
449 64,
450 68,
451 68,
452 64,
453 70,
454 70,
455 70,
456 70,
457 68,
458 68,
459 68,
460 68,
461 68, //QP=[26~38]
462 68,
463 68,
464 68,
465 68,
466 68,
467 68,
468 68,
469 68,
470 68,
471 68,
472 68,
473 68,
474 68, //QP=[39~51]
475 },
476 //LUTMODE_INTER_16x8, LUTMODE_INTER_8x16
477 {
478 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, //QP=[0 ~12]
479 8,
480 9,
481 11,
482 12,
483 6,
484 7,
485 9,
486 10,
487 7,
488 8,
489 9,
490 8,
491 9, //QP=[13~25]
492 8,
493 9,
494 8,
495 8,
496 9,
497 9,
498 9,
499 9,
500 8,
501 8,
502 8,
503 8,
504 8, //QP=[26~38]
505 8,
506 8,
507 8,
508 9,
509 9,
510 9,
511 9,
512 9,
513 9,
514 9,
515 9,
516 9,
517 9, //QP=[39~51]
518 },
519 //LUTMODE_INTER_8x8q
520 {
521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, //QP=[0 ~12]
522 2,
523 3,
524 3,
525 3,
526 2,
527 2,
528 2,
529 3,
530 2,
531 2,
532 2,
533 2,
534 3, //QP=[13~25]
535 2,
536 2,
537 3,
538 3,
539 3,
540 3,
541 3,
542 3,
543 3,
544 3,
545 3,
546 3,
547 3, //QP=[26~38]
548 3,
549 3,
550 3,
551 3,
552 3,
553 3,
554 3,
555 3,
556 3,
557 3,
558 3,
559 3,
560 3, //QP=[39~51]
561 },
562 //LUTMODE_INTER_8x4q, LUTMODE_INTER_4x8q, LUTMODE_INTER_16x8_FIELD
563 {
564 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //QP=[0 ~12]
565 5,
566 5,
567 5,
568 5,
569 5,
570 5,
571 5,
572 5,
573 5,
574 5,
575 5,
576 5,
577 5, //QP=[13~25]
578 5,
579 5,
580 5,
581 5,
582 5,
583 5,
584 5,
585 5,
586 5,
587 5,
588 5,
589 5,
590 5, //QP=[26~38]
591 5,
592 5,
593 5,
594 5,
595 5,
596 5,
597 5,
598 5,
599 5,
600 5,
601 5,
602 5,
603 5, //QP=[39~51]
604 },
605 //LUTMODE_INTER_4x4q, LUTMODE_INTER_8x8_FIELD
606 {
607 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, //QP=[0 ~12]
608 7,
609 7,
610 7,
611 7,
612 7,
613 7,
614 7,
615 7,
616 7,
617 7,
618 7,
619 7,
620 7, //QP=[13~25]
621 7,
622 7,
623 7,
624 7,
625 7,
626 7,
627 7,
628 7,
629 7,
630 7,
631 7,
632 7,
633 7, //QP=[26~38]
634 7,
635 7,
636 7,
637 7,
638 7,
639 7,
640 7,
641 7,
642 7,
643 7,
644 7,
645 7,
646 7, //QP=[39~51]
647 },
648 //LUTMODE_INTER_16x16, LUTMODE_INTER
649 {
650 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, //QP=[0 ~12]
651 6,
652 6,
653 6,
654 6,
655 6,
656 6,
657 6,
658 6,
659 6,
660 6,
661 6,
662 6,
663 6, //QP=[13~25]
664 6,
665 6,
666 6,
667 6,
668 6,
669 6,
670 6,
671 6,
672 6,
673 6,
674 6,
675 6,
676 6, //QP=[26~38]
677 6,
678 6,
679 6,
680 6,
681 6,
682 6,
683 6,
684 6,
685 6,
686 6,
687 6,
688 6,
689 6, //QP=[39~51]
690 },
691 //LUTMODE_INTER_BWD
692 {
693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //QP=[0 ~12]
694 0,
695 0,
696 0,
697 0,
698 0,
699 0,
700 0,
701 0,
702 0,
703 0,
704 0,
705 0,
706 0, //QP=[13~25]
707 0,
708 0,
709 0,
710 0,
711 0,
712 0,
713 0,
714 0,
715 0,
716 0,
717 0,
718 0,
719 0, //QP=[26~38]
720 0,
721 0,
722 0,
723 0,
724 0,
725 0,
726 0,
727 0,
728 0,
729 0,
730 0,
731 0,
732 0, //QP=[39~51]
733 },
734 //LUTMODE_REF_ID
735 {
736 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, //QP=[0 ~12]
737 4,
738 4,
739 4,
740 4,
741 4,
742 4,
743 4,
744 4,
745 4,
746 4,
747 4,
748 4,
749 4, //QP=[13~25]
750 4,
751 4,
752 4,
753 4,
754 4,
755 4,
756 4,
757 4,
758 4,
759 4,
760 4,
761 4,
762 4, //QP=[26~38]
763 4,
764 4,
765 4,
766 4,
767 4,
768 4,
769 4,
770 4,
771 4,
772 4,
773 4,
774 4,
775 4, //QP=[39~51]
776 },
777 //LUTMODE_INTRA_CHROMA
778 {
779 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //QP=[0 ~12]
780 0,
781 0,
782 0,
783 0,
784 0,
785 0,
786 0,
787 0,
788 0,
789 0,
790 0,
791 0,
792 0, //QP=[13~25]
793 0,
794 0,
795 0,
796 0,
797 0,
798 0,
799 0,
800 0,
801 0,
802 0,
803 0,
804 0,
805 0, //QP=[26~38]
806 0,
807 0,
808 0,
809 0,
810 0,
811 0,
812 0,
813 0,
814 0,
815 0,
816 0,
817 0,
818 0, //QP=[39~51]
819 },
820 },
821 };
822
823 const int8_t CodechalVdencAvcState::BRC_UPD_GlobalRateQPAdjTabI_U8[64] =
824 {
825 48,
826 40,
827 32,
828 24,
829 16,
830 8,
831 0,
832 -8,
833 40,
834 32,
835 24,
836 16,
837 8,
838 0,
839 -8,
840 -16,
841 32,
842 24,
843 16,
844 8,
845 0,
846 -8,
847 -16,
848 -24,
849 24,
850 16,
851 8,
852 0,
853 -8,
854 -16,
855 -24,
856 -32,
857 16,
858 8,
859 0,
860 -8,
861 -16,
862 -24,
863 -32,
864 -40,
865 8,
866 0,
867 -8,
868 -16,
869 -24,
870 -32,
871 -40,
872 -48,
873 0,
874 -8,
875 -16,
876 -24,
877 -32,
878 -40,
879 -48,
880 -56,
881 48,
882 40,
883 32,
884 24,
885 16,
886 8,
887 0,
888 -8,
889 };
890
891 const int8_t CodechalVdencAvcState::BRC_UPD_GlobalRateQPAdjTabP_U8[64] =
892 {
893 48, 40, 32, 24, 16, 8, 0, -8, 40, 32, 24, 16, 8, 0, -8, -16, 16, 8, 8, 4, -8, -16, -16, -24, 8, 0, 0, -8, -16, -16, -16, -24, 8, 0, 0, -24, -32, -32, -32, -48, 0, -16, -16, -24, -32, -48, -56, -64, -8, -16, -32, -32, -48, -48, -56, -64, -16, -32, -48, -48, -48, -56, -64, -80};
894
895 // P picture global rate QP Adjustment table for sliding window BRC
896 const int8_t CodechalVdencAvcState::BRC_UPD_SlWinGlobalRateQPAdjTabP_U8[64] =
897 {
898 48,
899 40,
900 32,
901 24,
902 16,
903 8,
904 0,
905 -8,
906 40,
907 32,
908 24,
909 16,
910 8,
911 0,
912 -8,
913 -16,
914 16,
915 8,
916 8,
917 4,
918 -8,
919 -16,
920 -16,
921 -24,
922 8,
923 0,
924 0,
925 -8,
926 -16,
927 -16,
928 -16,
929 -24,
930 8,
931 0,
932 0,
933 -24,
934 -32,
935 -32,
936 -32,
937 -48,
938 0,
939 -16,
940 -24,
941 -32,
942 -40,
943 -56,
944 -64,
945 -72,
946 -8,
947 -16,
948 -32,
949 -40,
950 -48,
951 -56,
952 -64,
953 -64,
954 -16,
955 -32,
956 -48,
957 -48,
958 -48,
959 -56,
960 -64,
961 -80,
962 };
963
964 const int8_t CodechalVdencAvcState::BRC_UPD_GlobalRateQPAdjTabB_U8[64] =
965 {
966 48, 40, 32, 24, 16, 8, 0, -8, 40, 32, 24, 16, 8, 0, -8, -16, 32, 24, 16, 8, 0, -8, -16, -24, 24, 16, 8, 0, -8, -8, -16, -24, 16, 8, 0, 0, -8, -16, -24, -32, 16, 8, 0, 0, -8, -16, -24, -32, 0, -8, -8, -16, -32, -48, -56, -64, 0, -8, -8, -16, -32, -48, -56, -64};
967
968 const uint8_t CodechalVdencAvcState::BRC_UPD_DistThreshldI_U8[10] =
969 {
970 2, 4, 8, 12, 19, 32, 64, 128, 0, 0};
971
972 const uint8_t CodechalVdencAvcState::BRC_UPD_DistThreshldP_U8[10] =
973 {
974 2, 4, 8, 12, 19, 32, 64, 128, 0, 0};
975
976 const int8_t CodechalVdencAvcState::CBR_UPD_DistQPAdjTabI_U8[81] =
977 {
978 0,
979 0,
980 0,
981 0,
982 0,
983 3,
984 4,
985 6,
986 8,
987 0,
988 0,
989 0,
990 0,
991 0,
992 2,
993 3,
994 5,
995 7,
996 -1,
997 0,
998 0,
999 0,
1000 0,
1001 2,
1002 2,
1003 4,
1004 5,
1005 -1,
1006 -1,
1007 0,
1008 0,
1009 0,
1010 1,
1011 2,
1012 2,
1013 4,
1014 -2,
1015 -2,
1016 -1,
1017 0,
1018 0,
1019 0,
1020 1,
1021 2,
1022 4,
1023 -2,
1024 -2,
1025 -1,
1026 0,
1027 0,
1028 0,
1029 1,
1030 2,
1031 4,
1032 -3,
1033 -2,
1034 -1,
1035 -1,
1036 0,
1037 0,
1038 1,
1039 2,
1040 5,
1041 -3,
1042 -2,
1043 -1,
1044 -1,
1045 0,
1046 0,
1047 2,
1048 4,
1049 7,
1050 -4,
1051 -3,
1052 -2,
1053 -1,
1054 0,
1055 1,
1056 3,
1057 5,
1058 8,
1059 };
1060
1061 const int8_t CodechalVdencAvcState::CBR_UPD_DistQPAdjTabP_U8[81] =
1062 {
1063 -1,
1064 0,
1065 0,
1066 0,
1067 0,
1068 1,
1069 1,
1070 2,
1071 3,
1072 -1,
1073 -1,
1074 0,
1075 0,
1076 0,
1077 1,
1078 1,
1079 2,
1080 3,
1081 -2,
1082 -1,
1083 -1,
1084 0,
1085 0,
1086 1,
1087 1,
1088 2,
1089 3,
1090 -3,
1091 -2,
1092 -2,
1093 -1,
1094 0,
1095 0,
1096 1,
1097 2,
1098 3,
1099 -3,
1100 -2,
1101 -1,
1102 -1,
1103 0,
1104 0,
1105 1,
1106 2,
1107 3,
1108 -3,
1109 -2,
1110 -1,
1111 -1,
1112 0,
1113 0,
1114 1,
1115 2,
1116 3,
1117 -3,
1118 -2,
1119 -1,
1120 -1,
1121 0,
1122 0,
1123 1,
1124 2,
1125 3,
1126 -3,
1127 -2,
1128 -1,
1129 -1,
1130 0,
1131 0,
1132 1,
1133 2,
1134 3,
1135 -3,
1136 -2,
1137 -1,
1138 -1,
1139 0,
1140 0,
1141 1,
1142 2,
1143 3,
1144 };
1145
1146 const int8_t CodechalVdencAvcState::CBR_UPD_DistQPAdjTabB_U8[81] =
1147 {
1148 0,
1149 0,
1150 0,
1151 0,
1152 0,
1153 2,
1154 3,
1155 3,
1156 4,
1157 0,
1158 0,
1159 0,
1160 0,
1161 0,
1162 2,
1163 3,
1164 3,
1165 4,
1166 -1,
1167 0,
1168 0,
1169 0,
1170 0,
1171 2,
1172 2,
1173 3,
1174 3,
1175 -1,
1176 -1,
1177 0,
1178 0,
1179 0,
1180 1,
1181 2,
1182 2,
1183 2,
1184 -1,
1185 -1,
1186 -1,
1187 0,
1188 0,
1189 0,
1190 1,
1191 2,
1192 2,
1193 -2,
1194 -1,
1195 -1,
1196 0,
1197 0,
1198 0,
1199 0,
1200 1,
1201 2,
1202 -2,
1203 -1,
1204 -1,
1205 -1,
1206 0,
1207 0,
1208 0,
1209 1,
1210 3,
1211 -2,
1212 -2,
1213 -1,
1214 -1,
1215 0,
1216 0,
1217 1,
1218 1,
1219 3,
1220 -2,
1221 -2,
1222 -1,
1223 -1,
1224 0,
1225 1,
1226 1,
1227 2,
1228 4,
1229 };
1230
1231 const int8_t CodechalVdencAvcState::VBR_UPD_DistQPAdjTabI_U8[81] =
1232 {
1233 0,
1234 0,
1235 0,
1236 0,
1237 0,
1238 3,
1239 4,
1240 6,
1241 8,
1242 0,
1243 0,
1244 0,
1245 0,
1246 0,
1247 2,
1248 3,
1249 5,
1250 7,
1251 -1,
1252 0,
1253 0,
1254 0,
1255 0,
1256 2,
1257 2,
1258 4,
1259 5,
1260 -1,
1261 -1,
1262 0,
1263 0,
1264 0,
1265 1,
1266 2,
1267 2,
1268 4,
1269 -2,
1270 -2,
1271 -1,
1272 0,
1273 0,
1274 0,
1275 1,
1276 2,
1277 4,
1278 -2,
1279 -2,
1280 -1,
1281 0,
1282 0,
1283 0,
1284 1,
1285 2,
1286 4,
1287 -3,
1288 -2,
1289 -1,
1290 -1,
1291 0,
1292 0,
1293 1,
1294 2,
1295 5,
1296 -3,
1297 -2,
1298 -1,
1299 -1,
1300 0,
1301 0,
1302 2,
1303 4,
1304 7,
1305 -4,
1306 -3,
1307 -2,
1308 -1,
1309 0,
1310 1,
1311 3,
1312 5,
1313 8,
1314 };
1315
1316 const int8_t CodechalVdencAvcState::VBR_UPD_DistQPAdjTabP_U8[81] =
1317 {
1318 -1,
1319 0,
1320 0,
1321 0,
1322 0,
1323 1,
1324 1,
1325 2,
1326 3,
1327 -1,
1328 -1,
1329 0,
1330 0,
1331 0,
1332 1,
1333 1,
1334 2,
1335 3,
1336 -2,
1337 -1,
1338 -1,
1339 0,
1340 0,
1341 1,
1342 1,
1343 2,
1344 3,
1345 -3,
1346 -2,
1347 -2,
1348 -1,
1349 0,
1350 0,
1351 1,
1352 2,
1353 3,
1354 -3,
1355 -2,
1356 -1,
1357 -1,
1358 0,
1359 0,
1360 1,
1361 2,
1362 3,
1363 -3,
1364 -2,
1365 -1,
1366 -1,
1367 0,
1368 0,
1369 1,
1370 2,
1371 3,
1372 -3,
1373 -2,
1374 -1,
1375 -1,
1376 0,
1377 0,
1378 1,
1379 2,
1380 3,
1381 -3,
1382 -2,
1383 -1,
1384 -1,
1385 0,
1386 0,
1387 1,
1388 2,
1389 3,
1390 -3,
1391 -2,
1392 -1,
1393 -1,
1394 0,
1395 0,
1396 1,
1397 2,
1398 3,
1399 };
1400
1401 const int8_t CodechalVdencAvcState::VBR_UPD_DistQPAdjTabB_U8[81] =
1402 {
1403 0,
1404 0,
1405 0,
1406 0,
1407 0,
1408 2,
1409 3,
1410 3,
1411 4,
1412 0,
1413 0,
1414 0,
1415 0,
1416 0,
1417 2,
1418 3,
1419 3,
1420 4,
1421 -1,
1422 0,
1423 0,
1424 0,
1425 0,
1426 2,
1427 2,
1428 3,
1429 3,
1430 -1,
1431 -1,
1432 0,
1433 0,
1434 0,
1435 1,
1436 2,
1437 2,
1438 2,
1439 -1,
1440 -1,
1441 -1,
1442 0,
1443 0,
1444 0,
1445 1,
1446 2,
1447 2,
1448 -2,
1449 -1,
1450 -1,
1451 0,
1452 0,
1453 0,
1454 0,
1455 1,
1456 2,
1457 -2,
1458 -1,
1459 -1,
1460 -1,
1461 0,
1462 0,
1463 0,
1464 1,
1465 3,
1466 -2,
1467 -2,
1468 -1,
1469 -1,
1470 0,
1471 0,
1472 1,
1473 1,
1474 3,
1475 -2,
1476 -2,
1477 -1,
1478 -1,
1479 0,
1480 1,
1481 1,
1482 2,
1483 4,
1484 };
1485
1486 const int8_t CodechalVdencAvcState::CBR_UPD_FrmSzAdjTabI_S8[72] =
1487 {
1488 -4,
1489 -20,
1490 -28,
1491 -36,
1492 -40,
1493 -44,
1494 -48,
1495 -80,
1496 0,
1497 -8,
1498 -12,
1499 -20,
1500 -24,
1501 -28,
1502 -32,
1503 -36,
1504 0,
1505 0,
1506 -8,
1507 -16,
1508 -20,
1509 -24,
1510 -28,
1511 -32,
1512 8,
1513 4,
1514 0,
1515 0,
1516 -8,
1517 -16,
1518 -24,
1519 -28,
1520 32,
1521 24,
1522 16,
1523 2,
1524 -4,
1525 -8,
1526 -16,
1527 -20,
1528 36,
1529 32,
1530 28,
1531 16,
1532 8,
1533 0,
1534 -4,
1535 -8,
1536 40,
1537 36,
1538 24,
1539 20,
1540 16,
1541 8,
1542 0,
1543 -8,
1544 48,
1545 40,
1546 28,
1547 24,
1548 20,
1549 12,
1550 0,
1551 -4,
1552 64,
1553 48,
1554 28,
1555 20,
1556 16,
1557 12,
1558 8,
1559 4,
1560 };
1561
1562 const int8_t CodechalVdencAvcState::CBR_UPD_FrmSzAdjTabP_S8[72] =
1563 {
1564 -8,
1565 -24,
1566 -32,
1567 -44,
1568 -48,
1569 -56,
1570 -64,
1571 -80,
1572 -8,
1573 -16,
1574 -32,
1575 -40,
1576 -44,
1577 -52,
1578 -56,
1579 -64,
1580 0,
1581 0,
1582 -16,
1583 -28,
1584 -36,
1585 -40,
1586 -44,
1587 -48,
1588 8,
1589 4,
1590 0,
1591 0,
1592 -8,
1593 -16,
1594 -24,
1595 -36,
1596 20,
1597 12,
1598 4,
1599 0,
1600 -8,
1601 -8,
1602 -8,
1603 -16,
1604 24,
1605 16,
1606 8,
1607 8,
1608 8,
1609 0,
1610 -4,
1611 -8,
1612 40,
1613 36,
1614 24,
1615 20,
1616 16,
1617 8,
1618 0,
1619 -8,
1620 48,
1621 40,
1622 28,
1623 24,
1624 20,
1625 12,
1626 0,
1627 -4,
1628 64,
1629 48,
1630 28,
1631 20,
1632 16,
1633 12,
1634 8,
1635 4,
1636 };
1637
1638 const int8_t CodechalVdencAvcState::CBR_UPD_FrmSzAdjTabB_S8[72] =
1639 {
1640 0,
1641 -4,
1642 -8,
1643 -16,
1644 -24,
1645 -32,
1646 -40,
1647 -48,
1648 1,
1649 0,
1650 -4,
1651 -8,
1652 -16,
1653 -24,
1654 -32,
1655 -40,
1656 4,
1657 2,
1658 0,
1659 -1,
1660 -3,
1661 -8,
1662 -16,
1663 -24,
1664 8,
1665 4,
1666 2,
1667 0,
1668 -1,
1669 -4,
1670 -8,
1671 -16,
1672 20,
1673 16,
1674 4,
1675 0,
1676 -1,
1677 -4,
1678 -8,
1679 -16,
1680 24,
1681 20,
1682 16,
1683 8,
1684 4,
1685 0,
1686 -4,
1687 -8,
1688 28,
1689 24,
1690 20,
1691 16,
1692 8,
1693 4,
1694 0,
1695 -8,
1696 32,
1697 24,
1698 20,
1699 16,
1700 8,
1701 4,
1702 0,
1703 -4,
1704 64,
1705 48,
1706 28,
1707 20,
1708 16,
1709 12,
1710 8,
1711 4,
1712 };
1713
1714 const int8_t CodechalVdencAvcState::VBR_UPD_FrmSzAdjTabI_S8[72] =
1715 {
1716 -4,
1717 -20,
1718 -28,
1719 -36,
1720 -40,
1721 -44,
1722 -48,
1723 -80,
1724 0,
1725 -8,
1726 -12,
1727 -20,
1728 -24,
1729 -28,
1730 -32,
1731 -36,
1732 0,
1733 0,
1734 -8,
1735 -16,
1736 -20,
1737 -24,
1738 -28,
1739 -32,
1740 8,
1741 4,
1742 0,
1743 0,
1744 -8,
1745 -16,
1746 -24,
1747 -28,
1748 32,
1749 24,
1750 16,
1751 2,
1752 -4,
1753 -8,
1754 -16,
1755 -20,
1756 36,
1757 32,
1758 28,
1759 16,
1760 8,
1761 0,
1762 -4,
1763 -8,
1764 40,
1765 36,
1766 24,
1767 20,
1768 16,
1769 8,
1770 0,
1771 -8,
1772 48,
1773 40,
1774 28,
1775 24,
1776 20,
1777 12,
1778 0,
1779 -4,
1780 64,
1781 48,
1782 28,
1783 20,
1784 16,
1785 12,
1786 8,
1787 4,
1788 };
1789
1790 const int8_t CodechalVdencAvcState::VBR_UPD_FrmSzAdjTabP_S8[72] =
1791 {
1792 -8,
1793 -24,
1794 -32,
1795 -44,
1796 -48,
1797 -56,
1798 -64,
1799 -80,
1800 -8,
1801 -16,
1802 -32,
1803 -40,
1804 -44,
1805 -52,
1806 -56,
1807 -64,
1808 0,
1809 0,
1810 -16,
1811 -28,
1812 -36,
1813 -40,
1814 -44,
1815 -48,
1816 8,
1817 4,
1818 0,
1819 0,
1820 -8,
1821 -16,
1822 -24,
1823 -36,
1824 20,
1825 12,
1826 4,
1827 0,
1828 -8,
1829 -8,
1830 -8,
1831 -16,
1832 24,
1833 16,
1834 8,
1835 8,
1836 8,
1837 0,
1838 -4,
1839 -8,
1840 40,
1841 36,
1842 24,
1843 20,
1844 16,
1845 8,
1846 0,
1847 -8,
1848 48,
1849 40,
1850 28,
1851 24,
1852 20,
1853 12,
1854 0,
1855 -4,
1856 64,
1857 48,
1858 28,
1859 20,
1860 16,
1861 12,
1862 8,
1863 4,
1864 };
1865
1866 const int8_t CodechalVdencAvcState::VBR_UPD_FrmSzAdjTabB_S8[72] =
1867 {
1868 0,
1869 -4,
1870 -8,
1871 -16,
1872 -24,
1873 -32,
1874 -40,
1875 -48,
1876 1,
1877 0,
1878 -4,
1879 -8,
1880 -16,
1881 -24,
1882 -32,
1883 -40,
1884 4,
1885 2,
1886 0,
1887 -1,
1888 -3,
1889 -8,
1890 -16,
1891 -24,
1892 8,
1893 4,
1894 2,
1895 0,
1896 -1,
1897 -4,
1898 -8,
1899 -16,
1900 20,
1901 16,
1902 4,
1903 0,
1904 -1,
1905 -4,
1906 -8,
1907 -16,
1908 24,
1909 20,
1910 16,
1911 8,
1912 4,
1913 0,
1914 -4,
1915 -8,
1916 28,
1917 24,
1918 20,
1919 16,
1920 8,
1921 4,
1922 0,
1923 -8,
1924 32,
1925 24,
1926 20,
1927 16,
1928 8,
1929 4,
1930 0,
1931 -4,
1932 64,
1933 48,
1934 28,
1935 20,
1936 16,
1937 12,
1938 8,
1939 4,
1940 };
1941
1942 const int8_t CodechalVdencAvcState::QVBR_UPD_FrmSzAdjTabP_S8[72] =
1943 {
1944 -8,
1945 -24,
1946 -32,
1947 -44,
1948 -48,
1949 -56,
1950 -64,
1951 -80,
1952 -8,
1953 -16,
1954 -32,
1955 -40,
1956 -44,
1957 -52,
1958 -56,
1959 -64,
1960 0,
1961 0,
1962 -16,
1963 -28,
1964 -36,
1965 -40,
1966 -44,
1967 -48,
1968 16,
1969 16,
1970 8,
1971 0,
1972 -8,
1973 -16,
1974 -24,
1975 -36,
1976 20,
1977 16,
1978 8,
1979 0,
1980 -8,
1981 -8,
1982 -8,
1983 -16,
1984 24,
1985 16,
1986 8,
1987 8,
1988 8,
1989 0,
1990 -4,
1991 -8,
1992 40,
1993 36,
1994 24,
1995 20,
1996 16,
1997 8,
1998 0,
1999 -8,
2000 48,
2001 40,
2002 28,
2003 24,
2004 20,
2005 12,
2006 0,
2007 -4,
2008 64,
2009 48,
2010 28,
2011 20,
2012 16,
2013 12,
2014 8,
2015 4,
2016 };
2017
2018 const int8_t CodechalVdencAvcState::LOW_DELAY_UPD_FrmSzAdjTabI_S8[72] =
2019 {
2020 0,
2021 0,
2022 -8,
2023 -12,
2024 -16,
2025 -20,
2026 -28,
2027 -36,
2028 0,
2029 0,
2030 -4,
2031 -8,
2032 -12,
2033 -16,
2034 -24,
2035 -32,
2036 4,
2037 2,
2038 0,
2039 -1,
2040 -3,
2041 -8,
2042 -16,
2043 -24,
2044 8,
2045 4,
2046 2,
2047 0,
2048 -1,
2049 -4,
2050 -8,
2051 -16,
2052 20,
2053 16,
2054 4,
2055 0,
2056 -1,
2057 -4,
2058 -8,
2059 -16,
2060 24,
2061 20,
2062 16,
2063 8,
2064 4,
2065 0,
2066 -4,
2067 -8,
2068 28,
2069 24,
2070 20,
2071 16,
2072 8,
2073 4,
2074 0,
2075 -8,
2076 32,
2077 24,
2078 20,
2079 16,
2080 8,
2081 4,
2082 0,
2083 -4,
2084 64,
2085 48,
2086 28,
2087 20,
2088 16,
2089 12,
2090 8,
2091 4,
2092 };
2093
2094 const int8_t CodechalVdencAvcState::LOW_DELAY_UPD_FrmSzAdjTabP_S8[72] =
2095 {
2096 -8,
2097 -24,
2098 -32,
2099 -40,
2100 -44,
2101 -48,
2102 -52,
2103 -80,
2104 -8,
2105 -16,
2106 -32,
2107 -40,
2108 -40,
2109 -44,
2110 -44,
2111 -56,
2112 0,
2113 0,
2114 -12,
2115 -20,
2116 -24,
2117 -28,
2118 -32,
2119 -36,
2120 8,
2121 4,
2122 0,
2123 0,
2124 -8,
2125 -16,
2126 -24,
2127 -32,
2128 32,
2129 16,
2130 8,
2131 4,
2132 -4,
2133 -8,
2134 -16,
2135 -20,
2136 36,
2137 24,
2138 16,
2139 8,
2140 4,
2141 -2,
2142 -4,
2143 -8,
2144 40,
2145 36,
2146 24,
2147 20,
2148 16,
2149 8,
2150 0,
2151 -8,
2152 48,
2153 40,
2154 28,
2155 24,
2156 20,
2157 12,
2158 0,
2159 -4,
2160 64,
2161 48,
2162 28,
2163 20,
2164 16,
2165 12,
2166 8,
2167 4,
2168 };
2169
2170 const int8_t CodechalVdencAvcState::LOW_DELAY_UPD_FrmSzAdjTabB_S8[72] =
2171 {
2172 0,
2173 -4,
2174 -8,
2175 -16,
2176 -24,
2177 -32,
2178 -40,
2179 -48,
2180 1,
2181 0,
2182 -4,
2183 -8,
2184 -16,
2185 -24,
2186 -32,
2187 -40,
2188 4,
2189 2,
2190 0,
2191 -1,
2192 -3,
2193 -8,
2194 -16,
2195 -24,
2196 8,
2197 4,
2198 2,
2199 0,
2200 -1,
2201 -4,
2202 -8,
2203 -16,
2204 20,
2205 16,
2206 4,
2207 0,
2208 -1,
2209 -4,
2210 -8,
2211 -16,
2212 24,
2213 20,
2214 16,
2215 8,
2216 4,
2217 0,
2218 -4,
2219 -8,
2220 28,
2221 24,
2222 20,
2223 16,
2224 8,
2225 4,
2226 0,
2227 -8,
2228 32,
2229 24,
2230 20,
2231 16,
2232 8,
2233 4,
2234 0,
2235 -4,
2236 64,
2237 48,
2238 28,
2239 20,
2240 16,
2241 12,
2242 8,
2243 4,
2244 };
2245
2246 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzMinTabP_U8[9] =
2247 {
2248 1, 2, 4, 6, 8, 10, 16, 16, 16};
2249
2250 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzMinTabI_U8[9] =
2251 {
2252 1, 2, 4, 8, 16, 20, 24, 32, 36};
2253
2254 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzMaxTabP_U8[9] =
2255 {
2256 48, 64, 80, 96, 112, 128, 144, 160, 160};
2257
2258 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzMaxTabI_U8[9] =
2259 {
2260 48, 64, 80, 96, 112, 128, 144, 160, 160};
2261
2262 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzSCGTabP_U8[9] =
2263 {
2264 4, 8, 12, 16, 20, 24, 24, 0, 0};
2265
2266 const uint8_t CodechalVdencAvcState::BRC_UPD_FrmSzSCGTabI_U8[9] =
2267 {
2268 4, 8, 12, 16, 20, 24, 24, 0, 0};
2269
2270 // Cost Table 14*42 = 588 bytes
2271 const uint8_t CodechalVdencAvcState::BRC_UPD_I_IntraNonPred[42] =
2272 {
2273 0x0e, 0x0e, 0x0e, 0x18, 0x19, 0x1b, 0x1c, 0x0d, 0x0f, 0x18, 0x19, 0x0d, 0x0f, 0x0f, 0x0c, 0x0e, 0x0c, 0x0c, 0x0a, 0x0a, 0x0b, 0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x07};
2274
2275 const uint8_t CodechalVdencAvcState::BRC_UPD_I_Intra8x8[42] =
2276 {
2277 0x00,
2278 0x00,
2279 0x00,
2280 0x00,
2281 0x00,
2282 0x00,
2283 0x00,
2284 0x00,
2285 0x00,
2286 0x01,
2287 0x01,
2288 0x01,
2289 0x01,
2290 0x01,
2291 0x01,
2292 0x01,
2293 0x01,
2294 0x01,
2295 0x01,
2296 0x01,
2297 0x01,
2298 0x04,
2299 0x04,
2300 0x04,
2301 0x04,
2302 0x06,
2303 0x06,
2304 0x06,
2305 0x06,
2306 0x06,
2307 0x06,
2308 0x06,
2309 0x06,
2310 0x06,
2311 0x06,
2312 0x06,
2313 0x06,
2314 0x07,
2315 0x07,
2316 0x07,
2317 0x07,
2318 0x07,
2319 };
2320
2321 const uint8_t CodechalVdencAvcState::BRC_UPD_I_Intra4x4[42] =
2322 {
2323 0x2e, 0x2e, 0x2e, 0x38, 0x39, 0x3a, 0x3b, 0x2c, 0x2e, 0x38, 0x39, 0x2d, 0x2f, 0x38, 0x2e, 0x38, 0x2e, 0x38, 0x2f, 0x2e, 0x38, 0x38, 0x38, 0x38, 0x2f, 0x2f, 0x2f, 0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x28, 0x1e, 0x1c, 0x1b, 0x1a, 0x19, 0x18, 0x0e, 0x0d};
2324
2325 const uint8_t CodechalVdencAvcState::BRC_UPD_I_IntraChroma[42] =
2326 {
2327 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
2328
2329 const uint8_t CodechalVdencAvcState::BRC_UPD_P_IntraNonPred[42] =
2330 {
2331 0x06, 0x06, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x05, 0x06, 0x07, 0x08, 0x06, 0x07, 0x07, 0x07, 0x07, 0x06, 0x07, 0x07, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07};
2332
2333 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Intra16x16[42] =
2334 {
2335 0x1b, 0x1b, 0x1b, 0x1c, 0x1e, 0x28, 0x29, 0x1a, 0x1b, 0x1c, 0x1e, 0x1a, 0x1c, 0x1d, 0x1b, 0x1c, 0x1c, 0x1c, 0x1c, 0x1b, 0x1c, 0x1c, 0x1d, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c};
2336
2337 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Intra8x8[42] =
2338 {
2339 0x1d,
2340 0x1d,
2341 0x1d,
2342 0x1e,
2343 0x28,
2344 0x29,
2345 0x2a,
2346 0x1b,
2347 0x1d,
2348 0x1e,
2349 0x28,
2350 0x1c,
2351 0x1d,
2352 0x1f,
2353 0x1d,
2354 0x1e,
2355 0x1d,
2356 0x1e,
2357 0x1d,
2358 0x1d,
2359 0x1f,
2360 0x1e,
2361 0x1e,
2362 0x1e,
2363 0x1d,
2364 0x1e,
2365 0x1e,
2366 0x1d,
2367 0x1e,
2368 0x1e,
2369 0x1e,
2370 0x1e,
2371 0x1e,
2372 0x1e,
2373 0x1e,
2374 0x1e,
2375 0x1e,
2376 0x1e,
2377 0x1e,
2378 0x1e,
2379 0x1e,
2380 0x1e,
2381 };
2382
2383 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Intra4x4[42] =
2384 {
2385 0x38,
2386 0x38,
2387 0x38,
2388 0x39,
2389 0x3a,
2390 0x3b,
2391 0x3d,
2392 0x2e,
2393 0x38,
2394 0x39,
2395 0x3a,
2396 0x2f,
2397 0x39,
2398 0x3a,
2399 0x38,
2400 0x39,
2401 0x38,
2402 0x39,
2403 0x39,
2404 0x38,
2405 0x39,
2406 0x39,
2407 0x39,
2408 0x39,
2409 0x39,
2410 0x39,
2411 0x39,
2412 0x39,
2413 0x39,
2414 0x39,
2415 0x39,
2416 0x39,
2417 0x39,
2418 0x39,
2419 0x39,
2420 0x39,
2421 0x39,
2422 0x39,
2423 0x39,
2424 0x39,
2425 0x39,
2426 0x39,
2427 };
2428
2429 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Inter16x8[42] =
2430 {
2431 0x07,
2432 0x07,
2433 0x07,
2434 0x08,
2435 0x09,
2436 0x0b,
2437 0x0c,
2438 0x06,
2439 0x07,
2440 0x09,
2441 0x0a,
2442 0x07,
2443 0x08,
2444 0x09,
2445 0x08,
2446 0x09,
2447 0x08,
2448 0x09,
2449 0x08,
2450 0x08,
2451 0x09,
2452 0x09,
2453 0x09,
2454 0x09,
2455 0x08,
2456 0x08,
2457 0x08,
2458 0x08,
2459 0x08,
2460 0x08,
2461 0x08,
2462 0x08,
2463 0x09,
2464 0x09,
2465 0x09,
2466 0x09,
2467 0x09,
2468 0x09,
2469 0x09,
2470 0x09,
2471 0x09,
2472 0x09,
2473 };
2474
2475 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Inter8x8[42] =
2476 {
2477 0x02,
2478 0x02,
2479 0x02,
2480 0x02,
2481 0x03,
2482 0x03,
2483 0x03,
2484 0x02,
2485 0x02,
2486 0x02,
2487 0x03,
2488 0x02,
2489 0x02,
2490 0x02,
2491 0x02,
2492 0x03,
2493 0x02,
2494 0x02,
2495 0x03,
2496 0x03,
2497 0x03,
2498 0x03,
2499 0x03,
2500 0x03,
2501 0x03,
2502 0x03,
2503 0x03,
2504 0x03,
2505 0x03,
2506 0x03,
2507 0x03,
2508 0x03,
2509 0x03,
2510 0x03,
2511 0x03,
2512 0x03,
2513 0x03,
2514 0x03,
2515 0x03,
2516 0x03,
2517 0x03,
2518 0x03,
2519 };
2520
2521 const uint8_t CodechalVdencAvcState::BRC_UPD_P_Inter16x16[42] =
2522 {
2523 0x05,
2524 0x05,
2525 0x05,
2526 0x06,
2527 0x06,
2528 0x06,
2529 0x06,
2530 0x06,
2531 0x06,
2532 0x06,
2533 0x06,
2534 0x06,
2535 0x06,
2536 0x06,
2537 0x06,
2538 0x06,
2539 0x06,
2540 0x06,
2541 0x06,
2542 0x06,
2543 0x06,
2544 0x06,
2545 0x06,
2546 0x06,
2547 0x06,
2548 0x06,
2549 0x06,
2550 0x06,
2551 0x06,
2552 0x06,
2553 0x06,
2554 0x06,
2555 0x06,
2556 0x06,
2557 0x06,
2558 0x06,
2559 0x06,
2560 0x06,
2561 0x06,
2562 0x06,
2563 0x06,
2564 0x06,
2565 };
2566
2567 const uint8_t CodechalVdencAvcState::BRC_UPD_P_RefId[42] =
2568 {
2569 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04};
2570
2571 const bool CodechalVdencAvcState::SHMEEnabled[NUM_VDENC_TARGET_USAGE_MODES] =
2572 {
2573 0, 1, 1, 0, 0, 0, 0, 0};
2574
2575 const bool CodechalVdencAvcState::UHMEEnabled[NUM_VDENC_TARGET_USAGE_MODES] =
2576 {
2577 0, 1, 1, 0, 0, 0, 0, 0};
2578
2579 const uint8_t CodechalVdencAvcState::AdaptiveInterRoundingPWithoutB[CODEC_AVC_NUM_QP] =
2580 {
2581 //QP = 0 1 2 3 4 5 6 7 8 9 10 11 12
2582 3,
2583 3,
2584 3,
2585 3,
2586 3,
2587 3,
2588 3,
2589 3,
2590 3,
2591 3,
2592 3,
2593 3,
2594 3, //QP=[0~12]
2595 3,
2596 3,
2597 3,
2598 3,
2599 3,
2600 3,
2601 3,
2602 3,
2603 1,
2604 0,
2605 0,
2606 0,
2607 0, //QP=[13~25]
2608 0,
2609 0,
2610 0,
2611 0,
2612 0,
2613 0,
2614 0,
2615 0,
2616 0,
2617 0,
2618 0,
2619 0,
2620 0, //QP=[26~38]
2621 0,
2622 0,
2623 0,
2624 0,
2625 0,
2626 0,
2627 0,
2628 0,
2629 0,
2630 0,
2631 0,
2632 0,
2633 0 //QP=[39~51]
2634 };
2635
2636 const uint8_t CodechalVdencAvcState::AdaptiveInterRoundingP[CODEC_AVC_NUM_QP] =
2637 {
2638 //QP = 0 1 2 3 4 5 6 7 8 9 10 11 12
2639 4,
2640 4,
2641 4,
2642 4,
2643 4,
2644 4,
2645 4,
2646 4,
2647 4,
2648 4,
2649 4,
2650 4,
2651 4, //QP=[0~12]
2652 4,
2653 4,
2654 4,
2655 4,
2656 4,
2657 3,
2658 3,
2659 3,
2660 3,
2661 3,
2662 3,
2663 3,
2664 3, //QP=[13~25]
2665 3,
2666 3,
2667 3,
2668 3,
2669 3,
2670 3,
2671 3,
2672 3,
2673 3,
2674 3,
2675 3,
2676 3,
2677 3, //QP=[26~38]
2678 3,
2679 3,
2680 3,
2681 3,
2682 3,
2683 3,
2684 3,
2685 3,
2686 3,
2687 3,
2688 3,
2689 3,
2690 3 //QP=[39~51]
2691 };
2692
2693 const uint32_t CodechalVdencAvcState::InterRoundingP[NUM_TARGET_USAGE_MODES] =
2694 {
2695 0, 3, 3, 3, 3, 3, 3, 3};
2696
2697 const uint32_t CodechalVdencAvcState::InterRoundingB[NUM_TARGET_USAGE_MODES] =
2698 {
2699 0, 0, 0, 0, 0, 0, 0, 0};
2700
2701 const uint32_t CodechalVdencAvcState::InterRoundingBRef[NUM_TARGET_USAGE_MODES] =
2702 {
2703 0, 2, 2, 2, 2, 2, 2, 2};
2704
2705 const uint8_t CodechalVdencAvcState::AdaptiveInterRoundingB[CODEC_AVC_NUM_QP] =
2706 {
2707 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, //QP=[0~12]
2708 4,
2709 3,
2710 3,
2711 3,
2712 3,
2713 3,
2714 3,
2715 0,
2716 0,
2717 0,
2718 0,
2719 0,
2720 0, //QP=[13~25]
2721 0,
2722 0,
2723 0,
2724 0,
2725 0,
2726 0,
2727 0,
2728 0,
2729 0,
2730 0,
2731 0,
2732 0,
2733 0, //QP=[26~38]
2734 0,
2735 0,
2736 0,
2737 0,
2738 0,
2739 0,
2740 0,
2741 0,
2742 0,
2743 0,
2744 0,
2745 0,
2746 0 //QP=[39~51]
2747 };
2748
2749 /* real thresholds are computed as multiplication on -50 and casting to int */
2750 const double CodechalVdencAvcState::BRC_DevThreshI0_FP_NEG[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2751 {
2752 0.80, 0.60, 0.34, 0.2};
2753
2754 /* real thresholds are computed as multiplication on 50 and casting to int */
2755 const double CodechalVdencAvcState::BRC_DevThreshI0_FP_POS[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2756 {
2757 0.2, 0.4, 0.66, 0.9};
2758
2759 /* real thresholds are computed as multiplication on 50 and casting to int */
2760 const double CodechalVdencAvcState::BRC_DevThreshPB0_FP_NEG[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2761 {
2762 0.90, 0.66, 0.46, 0.3};
2763
2764 /* real thresholds are computed as multiplication on 50 and casting to int */
2765 const double CodechalVdencAvcState::BRC_DevThreshPB0_FP_POS[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2766 {
2767 0.3, 0.46, 0.70, 0.90};
2768
2769 /* real negative thresholds are computed as multiplication on -50 and casting to int */
2770 const double CodechalVdencAvcState::BRC_DevThreshVBR0_NEG[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2771 {
2772 0.90, 0.70, 0.50, 0.3};
2773
2774 /* positive thresholds are computed as multiplication on 100 and casting to int */
2775 const double CodechalVdencAvcState::BRC_DevThreshVBR0_POS[CODECHAL_VDENC_AVC_N_DEV_THRESHLDS / 2] =
2776 {
2777 0.4, 0.5, 0.75, 0.90};
2778
2779 const int8_t CodechalVdencAvcState::BRC_LowDelay_DevThreshPB0_S8[8] =
2780 {
2781 -45, -33, -23, -15, -8, 0, 15, 25};
2782
2783 const int8_t CodechalVdencAvcState::BRC_LowDelay_DevThreshI0_S8[8] =
2784 {
2785 -40, -30, -17, -10, -5, 0, 10, 20};
2786
2787 const int8_t CodechalVdencAvcState::BRC_LowDelay_DevThreshVBR0_S8[8] =
2788 {
2789 -45, -35, -25, -15, -8, 0, 20, 40};
2790
2791 const int8_t CodechalVdencAvcState::BRC_INIT_DistQPDelta_I8[4] =
2792 {
2793 -5, -2, 2, 5};
2794
2795 const uint8_t CodechalVdencAvcState::BRC_EstRateThreshP0_U8[7] =
2796 {
2797 4, 8, 12, 16, 20, 24, 28};
2798
2799 const uint8_t CodechalVdencAvcState::BRC_EstRateThreshI0_U8[7] =
2800 {
2801 4, 8, 12, 16, 20, 24, 28};
2802
2803 const uint16_t CodechalVdencAvcState::BRC_UPD_start_global_adjust_frame[4] =
2804 {
2805 10, 50, 100, 150};
2806
2807 const uint8_t CodechalVdencAvcState::BRC_UPD_global_rate_ratio_threshold[7] =
2808 {
2809 80, 90, 95, 101, 105, 115, 130};
2810
2811 // global rate ratio threshold table for sliding window BRC
2812 const uint8_t CodechalVdencAvcState::BRC_UPD_slwin_global_rate_ratio_threshold[7] =
2813 {
2814 80, 90, 95, 101, 105, 110, 120};
2815
2816 const uint8_t CodechalVdencAvcState::BRC_UPD_start_global_adjust_mult[5] =
2817 {
2818 1, 1, 3, 2, 1};
2819
2820 const uint8_t CodechalVdencAvcState::BRC_UPD_start_global_adjust_div[5] =
2821 {
2822 40, 5, 5, 3, 1};
2823
2824 const uint16_t CodechalVdencAvcState::SliceSizeThrsholdsP[52] = // slice size threshold delta for P frame targeted for 99% compliance
2825 {
2826 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, //[ 0- 9]
2827 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1250, 1100, 950, //[10-19]
2828 850, 750, 650, 600, 550, 525, 500, 450, 400, 390, //[20-29]
2829 380, 300, 300, 300, 250, 200, 175, 150, 150, 150, //[30-39]
2830 150, 100, 100, 100, 100, 100, 100, 100, 100, 100, //[40-49]
2831 100, 100 //[50-51]
2832 };
2833
2834 const uint16_t CodechalVdencAvcState::SliceSizeThrsholdsI[52] = // slice size threshold delta for I frame targeted for 99% compliance
2835 {
2836 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, //[ 0- 9]
2837 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1400, 1350, //[10-19]
2838 1300, 1300, 1200, 1155, 1120, 1075, 1000, 975, 950, 800, //[20-29]
2839 750, 650, 600, 550, 500, 450, 400, 350, 300, 300, //[30-39]
2840 300, 250, 200, 200, 200, 200, 200, 200, 200, 200, //[40-49]
2841 200, 200 //[50-51]
2842 };
2843
2844 const int8_t CodechalVdencAvcState::BRC_UPD_global_rate_ratio_threshold_qp[8] =
2845 {
2846 -3, -2, -1, 0, 1, 1, 2, 3};
2847
2848 const uint8_t CodechalVdencAvcState::MaxRefIdx0[NUM_VDENC_TARGET_USAGE_MODES] =
2849 {
2850 0, 2, 2, 1, 1, 1, 0, 0};
2851
2852 const uint32_t CodechalVdencAvcState::TrellisQuantizationRounding[NUM_VDENC_TARGET_USAGE_MODES] =
2853 {
2854 0, 7, 7, 7, 7, 7, 7, 0};
2855
2856 const bool CodechalVdencAvcState::TrellisQuantizationEnable[NUM_VDENC_TARGET_USAGE_MODES] =
2857 {
2858 0, 0, 0, 0, 0, 0, 0, 0};
2859
2860 MOS_STATUS CodechalVdencAvcState::ComputeBRCInitQP(
2861 PCODEC_AVC_ENCODE_SEQUENCE_PARAMS seqParams,
2862 int32_t * initQP)
2863 {
2864 const float x0 = 0, y0 = 1.19f, x1 = 1.75f, y1 = 1.75f;
2865 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2866 uint32_t frameSize;
2867 int32_t QP, deltaQ;
2868
2869 CODECHAL_ENCODE_CHK_NULL_RETURN(seqParams);
2870 CODECHAL_ENCODE_CHK_NULL_RETURN(initQP);
2871
2872 // InitQPIP calculation
2873 frameSize = ((m_frameWidth * m_frameHeight * 3) >> 1);
2874 QP = (int32_t)(1. / 1.2 * pow(10.0, (log10(frameSize * 2. / 3. * ((float)seqParams->FramesPer100Sec) / ((float)(seqParams->TargetBitRate) * 100)) - x0) * (y1 - y0) / (x1 - x0) + y0) + 0.5);
2875 QP += 2;
2876 //add additional change based on buffer size. It is especially useful for low delay
2877 deltaQ = (int32_t)(9 - (seqParams->VBVBufferSizeInBit * ((float)seqParams->FramesPer100Sec) / ((float)(seqParams->TargetBitRate) * 100)));
2878 QP += deltaQ < 0 ? 0 : deltaQ;
2879 QP = CodecHal_Clip3(CODECHAL_ENCODE_AVC_BRC_MIN_QP, CODECHAL_ENCODE_AVC_MAX_SLICE_QP, QP);
2880 QP--;
2881 if (QP < 0)
2882 QP = 1;
2883
2884 *initQP = QP;
2885
2886 return eStatus;
2887 }
2888
2889 MOS_STATUS CodechalVdencAvcState::AvcVdencStoreHuCStatus2Register(
2890 CodechalHwInterface *hwInterface,
2891 PMOS_COMMAND_BUFFER cmdBuffer)
2892 {
2893 MhwMiInterface * miInterface;
2894 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
2895 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2896 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2897
2898 CODECHAL_ENCODE_FUNCTION_ENTER;
2899
2900 CODECHAL_ENCODE_CHK_NULL_RETURN(hwInterface);
2901 CODECHAL_ENCODE_CHK_NULL_RETURN(hwInterface->GetMiInterface());
2902 miInterface = hwInterface->GetMiInterface();
2903
2904 // Write HUC_STATUS2 mask - bit 6 - valid IMEM loaded
2905 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2906 storeDataParams.pOsResource = &m_resHucStatus2Buffer;
2907 storeDataParams.dwResourceOffset = 0;
2908 storeDataParams.dwValue = hwInterface->GetHucInterface()->GetHucStatus2ImemLoadedMask();
2909 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
2910
2911 // Store HUC_STATUS2 register
2912 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
2913 storeRegParams.presStoreBuffer = &m_resHucStatus2Buffer;
2914 storeRegParams.dwOffset = sizeof(uint32_t);
2915
2916 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
2917 storeRegParams.dwRegister = hwInterface->GetHucInterface()->GetMmioRegisters(m_vdboxIndex)->hucStatus2RegOffset;
2918
2919 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &storeRegParams));
2920
2921 return eStatus;
2922 }
2923
2924 MOS_STATUS CodechalVdencAvcState::SetTLBAllocation(
2925 PMOS_COMMAND_BUFFER cmdBuffer,
2926 PTLBAllocationParams params)
2927 {
2928 MhwMiInterface * miInterface;
2929 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
2930 MHW_MI_LOAD_REGISTER_IMM_PARAMS miLoadRegImmParams;
2931 MmioRegistersMfx * mmioRegisters;
2932 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2933
2934 CODECHAL_ENCODE_FUNCTION_ENTER;
2935
2936 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
2937 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
2938 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presTlbMmioBuffer);
2939
2940 miInterface = m_hwInterface->GetMiInterface();
2941
2942 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
2943 mmioRegisters = m_hwInterface->SelectVdboxAndGetMmioRegister(m_vdboxIndex, cmdBuffer);
2944
2945 // Save MFX_LRA_0/1/2 registers to a temp buffer so we can restore registers after frame encoding
2946 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2947
2948 miStoreRegMemParams.presStoreBuffer = params->presTlbMmioBuffer;
2949 miStoreRegMemParams.dwOffset = 0;
2950 miStoreRegMemParams.dwRegister = mmioRegisters->mfxLra0RegOffset;
2951 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2952
2953 miStoreRegMemParams.dwOffset = sizeof(uint32_t);
2954 miStoreRegMemParams.dwRegister = mmioRegisters->mfxLra1RegOffset;
2955 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2956
2957 miStoreRegMemParams.dwOffset = 2 * sizeof(uint32_t);
2958 miStoreRegMemParams.dwRegister = mmioRegisters->mfxLra2RegOffset;
2959 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
2960
2961 // Update MFX_LRA_0/1/2 registers to set TBL for VMC=240
2962 // =======================================================
2963 // Clients LRA LRA range Min LRA range Max
2964 // =======================================================
2965 // VMXRA + VMC LRA0 0 239
2966 // VMX LRA1 240 245
2967 // BSP LRA2 246 250
2968 // VCR + VCS LRA3 251 255
2969 // =======================================================
2970 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
2971 miLoadRegImmParams.dwRegister = mmioRegisters->mfxLra0RegOffset;
2972 miLoadRegImmParams.dwData = (params->dwMmioMfxLra0Override > 0) ? params->dwMmioMfxLra0Override : CODECHAL_VDENC_AVC_MMIO_MFX_LRA_0_VMC240;
2973 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
2974
2975 miLoadRegImmParams.dwRegister = mmioRegisters->mfxLra1RegOffset;
2976 miLoadRegImmParams.dwData = (params->dwMmioMfxLra1Override > 0) ? params->dwMmioMfxLra1Override : CODECHAL_VDENC_AVC_MMIO_MFX_LRA_1_VMC240;
2977 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
2978
2979 miLoadRegImmParams.dwRegister = mmioRegisters->mfxLra2RegOffset;
2980 miLoadRegImmParams.dwData = (params->dwMmioMfxLra2Override > 0) ? params->dwMmioMfxLra2Override : CODECHAL_VDENC_AVC_MMIO_MFX_LRA_2_VMC240;
2981 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
2982
2983 return eStatus;
2984 }
2985
2986 MOS_STATUS CodechalVdencAvcState::RestoreTLBAllocation(
2987 PMOS_COMMAND_BUFFER cmdBuffer,
2988 PMOS_RESOURCE tlbMmioBuffer)
2989 {
2990 MhwMiInterface * miInterface;
2991 MHW_MI_LOAD_REGISTER_MEM_PARAMS miLoadRegMemParams;
2992 MmioRegistersMfx * mmioRegisters;
2993 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2994
2995 CODECHAL_ENCODE_FUNCTION_ENTER;
2996
2997 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
2998 CODECHAL_ENCODE_CHK_NULL_RETURN(tlbMmioBuffer);
2999
3000 miInterface = m_hwInterface->GetMiInterface();
3001
3002 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
3003 mmioRegisters = m_hwInterface->SelectVdboxAndGetMmioRegister(m_vdboxIndex, cmdBuffer);
3004
3005 // Restore MFX_LRA_0/1/2 registers
3006 miLoadRegMemParams.presStoreBuffer = tlbMmioBuffer;
3007 miLoadRegMemParams.dwOffset = 0;
3008 miLoadRegMemParams.dwRegister = mmioRegisters->mfxLra0RegOffset;
3009 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
3010
3011 miLoadRegMemParams.dwOffset = sizeof(uint32_t);
3012 miLoadRegMemParams.dwRegister = mmioRegisters->mfxLra1RegOffset;
3013 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
3014
3015 miLoadRegMemParams.dwOffset = 2 * sizeof(uint32_t);
3016 miLoadRegMemParams.dwRegister = mmioRegisters->mfxLra2RegOffset;
3017 CODECHAL_ENCODE_CHK_STATUS_RETURN(miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
3018
3019 return eStatus;
3020 }
3021
3022 CodechalVdencAvcState::CodechalVdencAvcState(
3023 CodechalHwInterface * hwInterface,
3024 CodechalDebugInterface *debugInterface,
3025 PCODECHAL_STANDARD_INFO standardInfo) : CodechalEncodeAvcBase(hwInterface, debugInterface, standardInfo)
3026 {
3027 CODECHAL_ENCODE_FUNCTION_ENTER;
3028
3029 InitializeDataMember();
3030
3031 // Setup initial data
3032 m_brcInit = true;
3033 // enable codec specific user feature key reporting for AVC
3034 m_userFeatureKeyReport = true;
3035
3036 m_swBrcMode = nullptr;
3037
3038 m_cmKernelEnable = true;
3039 m_brcRoiSupported = true;
3040 m_nonNativeBrcRoiSupported = false;
3041 m_codecGetStatusReportDefined = true; // Codec specific GetStatusReport is implemented.
3042
3043 if (m_cmKernelEnable)
3044 {
3045 m_useCmScalingKernel = 1;
3046 }
3047
3048 MOS_ZeroMemory(&m_vdencIntraRowStoreScratchBuffer, sizeof(MOS_RESOURCE));
3049 MOS_ZeroMemory(&m_pakStatsBuffer, sizeof(MOS_RESOURCE));
3050 MOS_ZeroMemory(&m_vdencStatsBuffer, sizeof(MOS_RESOURCE));
3051 MOS_ZeroMemory(&m_vdencTlbMmioBuffer, sizeof(MOS_RESOURCE));
3052 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
3053 {
3054 MOS_ZeroMemory(&m_pakStatsBufferFull[i], sizeof(MOS_RESOURCE));
3055 }
3056 }
3057
3058 CodechalVdencAvcState::~CodechalVdencAvcState()
3059 {
3060 CODECHAL_ENCODE_FUNCTION_ENTER;
3061
3062 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencIntraRowStoreScratchBuffer);
3063 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencStatsBuffer);
3064 m_osInterface->pfnFreeResource(m_osInterface, &m_pakStatsBuffer);
3065 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencTlbMmioBuffer);
3066
3067 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
3068 {
3069 m_osInterface->pfnFreeResource(m_osInterface, &m_pakStatsBufferFull[i]);
3070 }
3071
3072 if (m_vdencBrcImgStatAllocated)
3073 {
3074 for (uint8_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
3075 {
3076 Mhw_FreeBb(m_osInterface, &m_batchBufferForVdencImgStat[i], nullptr);
3077 }
3078 }
3079 else
3080 {
3081 Mhw_FreeBb(m_osInterface, &m_batchBufferForVdencImgStat[0], nullptr);
3082 }
3083
3084 if (m_seiData.pSEIBuffer)
3085 {
3086 MOS_FreeMemory(m_seiData.pSEIBuffer);
3087 m_seiData.pSEIBuffer = nullptr;
3088 }
3089
3090 MOS_Delete(m_sfdKernelState);
3091 m_sfdKernelState = nullptr;
3092
3093 if (m_pakEnabled)
3094 {
3095 // release skip frame copy buffer
3096 m_osInterface->pfnFreeResource(m_osInterface, &m_resSkipFrameBuffer);
3097 }
3098
3099 // SFD surfaces
3100 {
3101 // SFD output buffer
3102 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
3103 {
3104 m_osInterface->pfnFreeResource(
3105 m_osInterface,
3106 &m_resSfdOutputBuffer[i]);
3107 }
3108
3109 m_osInterface->pfnFreeResource(
3110 m_osInterface,
3111 &m_resSfdCostTablePFrameBuffer);
3112
3113 m_osInterface->pfnFreeResource(
3114 m_osInterface,
3115 &m_resSfdCostTableBFrameBuffer);
3116 }
3117
3118 if (m_swBrcMode != nullptr)
3119 {
3120 m_osInterface->pfnFreeLibrary(m_swBrcMode);
3121 m_swBrcMode = nullptr;
3122 }
3123
3124 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
3125 {
3126 for (uint32_t j = 0; j < CODECHAL_VDENC_BRC_NUM_OF_PASSES; j++)
3127 {
3128 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcUpdateDmemBuffer[i][j]);
3129 }
3130 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcInitDmemBuffer[i]);
3131 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcImageStatesReadBuffer[i]);
3132 if (m_nonNativeBrcRoiSupported)
3133 {
3134 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcRoiBuffer[i]);
3135 }
3136 }
3137
3138 for (uint32_t i = 0; i < CODECHAL_ENCODE_VDENC_BRC_CONST_BUFFER_NUM; i++)
3139 {
3140 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcConstDataBuffer[i]);
3141 }
3142
3143 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcHistoryBuffer);
3144 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencSfdImageStateReadBuffer);
3145 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdencBrcDbgBuffer);
3146 }
3147
3148 MOS_STATUS CodechalVdencAvcState::Initialize(CodechalSetting *settings)
3149 {
3150 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3151 MOS_STATUS statusKey = MOS_STATUS_SUCCESS;
3152
3153 CODECHAL_ENCODE_FUNCTION_ENTER;
3154
3155 CODECHAL_ENCODE_CHK_NULL_RETURN(settings);
3156
3157 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::Initialize(settings));
3158
3159 if (m_cscDsState)
3160 {
3161 // for AVC: the Ds+Copy kernel is by default used to do CSC and copy
3162 // non-aligned surface
3163 m_cscDsState->EnableCopy();
3164 m_cscDsState->EnableColor();
3165 m_cscDsState->EnableSfc();
3166 }
3167
3168 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
3169 #if (_DEBUG || _RELEASE_INTERNAL)
3170 /*MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3171 MOS_UserFeature_ReadValue_ID(
3172 nullptr,
3173 __MEDIA_USER_FEATURE_VALUE_AVC_BRC_SOFTWARE_ID,
3174 &userFeatureData,
3175 m_osInterface->pOsContext);
3176
3177 if (userFeatureData.i32Data)
3178 {
3179 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnLoadLibrary(m_osInterface, CODECHAL_DBG_STRING_SWAVCBRCLIBRARY, &m_swBrcMode));
3180 }*/
3181
3182 // SW BRC DLL Reporting
3183 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_AVC_BRC_SOFTWARE_IN_USE_ID, (m_swBrcMode == nullptr) ? false : true, m_osInterface->pOsContext);
3184 #endif // (_DEBUG || _RELEASE_INTERNAL)
3185
3186 if (m_codecFunction != CODECHAL_FUNCTION_PAK)
3187 {
3188 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3189 statusKey = MOS_UserFeature_ReadValue_ID(
3190 nullptr,
3191 __MEDIA_USER_FEATURE_VALUE_AVC_ENCODE_ME_ENABLE_ID,
3192 &userFeatureData,
3193 m_osInterface->pOsContext);
3194 if (statusKey == MOS_STATUS_SUCCESS)
3195 {
3196 m_hmeSupported = (userFeatureData.u32Data) ? true : false;
3197 }
3198
3199 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3200 statusKey = MOS_UserFeature_ReadValue_ID(
3201 nullptr,
3202 __MEDIA_USER_FEATURE_VALUE_AVC_ENCODE_16xME_ENABLE_ID,
3203 &userFeatureData,
3204 m_osInterface->pOsContext);
3205
3206 if (statusKey == MOS_STATUS_SUCCESS)
3207 {
3208 m_16xMeSupported = (userFeatureData.i32Data) ? true : false;
3209 }
3210
3211 #ifndef _FULL_OPEN_SOURCE
3212 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3213 MOS_UserFeature_ReadValue_ID(
3214 nullptr,
3215 __MEDIA_USER_FEATURE_VALUE_STATIC_FRAME_DETECTION_ENABLE_ID,
3216 &userFeatureData,
3217 m_osInterface->pOsContext);
3218 m_staticFrameDetectionEnable = (userFeatureData.i32Data) ? true : false;
3219 #endif
3220
3221 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3222 MOS_UserFeature_ReadValue_ID(
3223 nullptr,
3224 __MEDIA_USER_FEATURE_VALUE_AVC_FORCE_TO_SKIP_ENABLE_ID,
3225 &userFeatureData,
3226 m_osInterface->pOsContext);
3227 m_forceToSkipEnable = (userFeatureData.u32Data) ? true : false;
3228
3229 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3230 MOS_UserFeature_ReadValue_ID(
3231 nullptr,
3232 __MEDIA_USER_FEATURE_VALUE_AVC_SLIDING_WINDOW_SIZE_ID,
3233 &userFeatureData,
3234 m_osInterface->pOsContext);
3235 m_slidingWindowSize = userFeatureData.u32Data;
3236
3237 m_groupIdSelectSupported = 0; // Disabled by default for AVC for now
3238 #if (_DEBUG || _RELEASE_INTERNAL)
3239 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3240 MOS_UserFeature_ReadValue_ID(
3241 nullptr,
3242 __MEDIA_USER_FEATURE_VALUE_GROUP_ID_SELECT_ENABLE_ID,
3243 &userFeatureData,
3244 m_osInterface->pOsContext);
3245 m_groupIdSelectSupported = (userFeatureData.i32Data) ? true : false;
3246 #endif
3247
3248 m_groupId = 0; // default value for group ID = 0
3249 #if (_DEBUG || _RELEASE_INTERNAL)
3250 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3251 MOS_UserFeature_ReadValue_ID(
3252 nullptr,
3253 __MEDIA_USER_FEATURE_VALUE_GROUP_ID_ID,
3254 &userFeatureData,
3255 m_osInterface->pOsContext);
3256 m_groupId = (uint8_t)userFeatureData.i32Data;
3257 #endif
3258
3259 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3260 MOS_UserFeature_ReadValue_ID(
3261 nullptr,
3262 __MEDIA_USER_FEATURE_VALUE_VDENC_CRE_PREFETCH_ENABLE_ID,
3263 &userFeatureData,
3264 m_osInterface->pOsContext);
3265 m_crePrefetchEnable = userFeatureData.bData == 1;
3266
3267 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3268 MOS_UserFeature_ReadValue_ID(
3269 nullptr,
3270 __MEDIA_USER_FEATURE_VALUE_VDENC_SINGLE_PASS_ENABLE_ID,
3271 &userFeatureData,
3272 m_osInterface->pOsContext);
3273 m_vdencSinglePassEnable = userFeatureData.bData == 1;
3274
3275 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3276 MOS_UserFeature_ReadValue_ID(
3277 nullptr,
3278 __MEDIA_USER_FEATURE_VALUE_VDENC_TLB_PREFETCH_ENABLE_ID,
3279 &userFeatureData,
3280 m_osInterface->pOsContext);
3281 m_tlbPrefetchEnable = userFeatureData.bData == 1;
3282
3283 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3284 MOS_UserFeature_ReadValue_ID(
3285 nullptr,
3286 __MEDIA_USER_FEATURE_VALUE_VDENC_TLB_ALLOCATION_WA_ENABLE_ID,
3287 &userFeatureData,
3288 m_osInterface->pOsContext);
3289 if (userFeatureData.u32Data == 0) // MFX_LRA_0/1/2 offsets might not be available
3290 {
3291 MEDIA_WR_WA(m_waTable, WaTlbAllocationForAvcVdenc, false);
3292 }
3293
3294 if (MEDIA_IS_WA(m_waTable, WaTlbAllocationForAvcVdenc))
3295 {
3296 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3297 MOS_UserFeature_ReadValue_ID(
3298 nullptr,
3299 __MEDIA_USER_FEATURE_VALUE_MMIO_MFX_LRA_0_OVERRIDE_ID,
3300 &userFeatureData,
3301 m_osInterface->pOsContext);
3302 m_mmioMfxLra0Override = userFeatureData.u32Data;
3303
3304 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3305 MOS_UserFeature_ReadValue_ID(
3306 nullptr,
3307 __MEDIA_USER_FEATURE_VALUE_MMIO_MFX_LRA_1_OVERRIDE_ID,
3308 &userFeatureData,
3309 m_osInterface->pOsContext);
3310 m_mmioMfxLra1Override = userFeatureData.u32Data;
3311
3312 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3313 MOS_UserFeature_ReadValue_ID(
3314 nullptr,
3315 __MEDIA_USER_FEATURE_VALUE_MMIO_MFX_LRA_2_OVERRIDE_ID,
3316 &userFeatureData,
3317 m_osInterface->pOsContext);
3318 m_mmioMfxLra2Override = userFeatureData.u32Data;
3319 }
3320 }
3321 #if (_DEBUG || _RELEASE_INTERNAL)
3322 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3323 MOS_UserFeature_ReadValue_ID(
3324 nullptr,
3325 __MEDIA_USER_FEATURE_VALUE_VDENC_PERMB_STREAMOUT_ENABLE_ID,
3326 &userFeatureData,
3327 m_osInterface->pOsContext);
3328 m_perMBStreamOutEnable = (userFeatureData.u32Data) ? true : false;
3329 #endif
3330
3331 // Initialize hardware resources for the current Os/Platform
3332 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitializeState());
3333
3334 MotionEstimationDisableCheck();
3335
3336 CODECHAL_ENCODE_CHK_STATUS_RETURN(Initialize());
3337
3338 // common function for all codecs needed
3339 if (m_cscDsState && m_hwInterface->UsesRenderEngine(m_codecFunction, m_standard))
3340 {
3341 if (m_hmeSupported)
3342 {
3343 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMe());
3344 }
3345
3346 if (m_singleTaskPhaseSupported)
3347 {
3348 uint32_t i;
3349 uint32_t scalingBtCount, meBtCount, mbEncBtCount, brcBtCount, encOneBtCount, encTwoBtCount;
3350
3351 scalingBtCount = MOS_ALIGN_CEIL(
3352 m_scaling4xKernelStates[0].KernelParams.iBTCount,
3353 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
3354 meBtCount = MOS_ALIGN_CEIL(
3355 m_hmeKernel ? m_hmeKernel->GetBTCount() : m_meKernelStates[0].KernelParams.iBTCount,
3356 m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment());
3357 mbEncBtCount = 0;
3358 brcBtCount = 0;
3359
3360 encOneBtCount = scalingBtCount + meBtCount;
3361 encOneBtCount += (m_16xMeSupported) ? encOneBtCount : 0;
3362 encOneBtCount += (m_32xMeSupported) ? encOneBtCount : 0;
3363 encTwoBtCount = mbEncBtCount + brcBtCount;
3364 m_maxBtCount = MOS_MAX(encOneBtCount, encTwoBtCount);
3365 }
3366 }
3367
3368 // Picture Level Commands
3369 m_hwInterface->GetMfxStateCommandsDataSize(
3370 CODECHAL_ENCODE_MODE_AVC,
3371 &m_pictureStatesSize,
3372 &m_picturePatchListSize,
3373 false);
3374
3375 // Slice Level Commands
3376 m_hwInterface->GetMfxPrimitiveCommandsDataSize(
3377 CODECHAL_ENCODE_MODE_AVC,
3378 &m_sliceStatesSize,
3379 &m_slicePatchListSize,
3380 false);
3381
3382 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalculateVdencCommandsSize());
3383
3384 return eStatus;
3385 }
3386
3387 MOS_STATUS CodechalVdencAvcState::CalculateVdencCommandsSize()
3388 {
3389 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3390 CODECHAL_ENCODE_FUNCTION_ENTER;
3391
3392 PMHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams = CreateMhwVdboxStateCmdsizeParams();
3393 CODECHAL_ENCODE_CHK_NULL_RETURN(stateCmdSizeParams);
3394 uint32_t vdencPictureStatesSize, vdencPicturePatchListSize;
3395 uint32_t vdencSliceStatesSize, vdencSlicePatchListSize;
3396
3397 m_hwInterface->GetHxxStateCommandSize(
3398 CODECHAL_ENCODE_MODE_AVC,
3399 &vdencPictureStatesSize,
3400 &vdencPicturePatchListSize,
3401 stateCmdSizeParams);
3402 MOS_Delete(stateCmdSizeParams);
3403
3404 m_pictureStatesSize += vdencPictureStatesSize;
3405 m_picturePatchListSize += vdencPicturePatchListSize;
3406
3407 // Picture Level Commands
3408 m_hwInterface->GetVdencStateCommandsDataSize(
3409 CODECHAL_ENCODE_MODE_AVC,
3410 &vdencPictureStatesSize,
3411 &vdencPicturePatchListSize);
3412
3413 m_pictureStatesSize += vdencPictureStatesSize;
3414 m_picturePatchListSize += vdencPicturePatchListSize;
3415
3416 // Slice Level Commands
3417 m_hwInterface->GetVdencPrimitiveCommandsDataSize(
3418 CODECHAL_ENCODE_MODE_AVC,
3419 &vdencSliceStatesSize,
3420 &vdencSlicePatchListSize
3421 );
3422
3423 m_sliceStatesSize += vdencSliceStatesSize;
3424 m_slicePatchListSize += vdencSlicePatchListSize;
3425
3426 return eStatus;
3427 }
3428
3429 void CodechalVdencAvcState::InitializeDataMember()
3430 {
3431 CODECHAL_ENCODE_FUNCTION_ENTER;
3432
3433 // SEI
3434 MOS_ZeroMemory(&m_seiData, sizeof(m_seiData));
3435 m_seiDataOffset = false;
3436 m_seiParamBuffer = nullptr;
3437
3438 m_brcInit = false;
3439 m_brcReset = false;
3440 m_mbBrcEnabled = false;
3441 m_mbBrcUserFeatureKeyControl = false;
3442 m_dBrcTargetSize = 0.0f;
3443 m_trellis = false;
3444 m_acceleratorHeaderPackingCaps = false; //flag set by driver from driver caps
3445
3446 m_dBrcInitCurrentTargetBufFullInBits = 0;
3447 m_dBrcInitResetInputBitsPerFrame = 0;
3448 m_brcInitResetBufSizeInBits = false;
3449 m_brcInitPreviousTargetBufFullInBits = false;
3450 // Below values will be set if qp control params are sent by app
3451 m_minMaxQpControlEnabled = false; // Flag to indicate if min/max QP feature is enabled or not.
3452 m_iMinQp = 0;
3453 m_iMaxQp = 0;
3454 m_pMinQp = 0;
3455 m_pMaxQp = 0;
3456 m_pFrameMinMaxQpControl = false; // Indicates min/max QP values for P-frames are set separately or not.
3457
3458 m_skipFrameBufferSize = false; // size of skip frame packed data
3459 MOS_ZeroMemory(&m_resSkipFrameBuffer, sizeof(MOS_RESOURCE)); // copy skip frame packed data from DDI
3460
3461 // VDENC BRC Buffers
3462 MOS_ZeroMemory(&m_resVdencBrcUpdateDmemBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_RECYCLED_BUFFER_NUM * CODECHAL_VDENC_BRC_NUM_OF_PASSES);
3463
3464 MOS_ZeroMemory(&m_resVdencBrcInitDmemBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_RECYCLED_BUFFER_NUM);
3465
3466 MOS_ZeroMemory(&m_resVdencBrcImageStatesReadBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_RECYCLED_BUFFER_NUM);
3467
3468 MOS_ZeroMemory(&m_resVdencBrcConstDataBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_VDENC_BRC_CONST_BUFFER_NUM);
3469 MOS_ZeroMemory(&m_resVdencBrcHistoryBuffer, sizeof(MOS_RESOURCE));
3470 MOS_ZeroMemory(&m_resVdencBrcRoiBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_RECYCLED_BUFFER_NUM);
3471 MOS_ZeroMemory(&m_resVdencBrcDbgBuffer, sizeof(MOS_RESOURCE));
3472
3473 // Static frame detection
3474 m_staticFrameDetectionEnable = false; // Static frame detection enable
3475 MOS_ZeroMemory(&m_resSfdOutputBuffer, sizeof(MOS_RESOURCE) * CODECHAL_ENCODE_RECYCLED_BUFFER_NUM);
3476
3477 MOS_ZeroMemory(&m_resSfdCostTablePFrameBuffer, sizeof(MOS_RESOURCE));
3478 MOS_ZeroMemory(&m_resSfdCostTableBFrameBuffer, sizeof(MOS_RESOURCE));
3479 MOS_ZeroMemory(&m_resVdencSfdImageStateReadBuffer, sizeof(MOS_RESOURCE));
3480 m_sfdKernelState = nullptr;
3481
3482 // Generation Specific Support Flags & User Feature Key Reads
3483 m_mbBrcSupportCaps = 0;
3484 m_ftqEnable = false; // FTQEnable
3485 m_skipBiasAdjustmentSupported = false; // SkipBiasAdjustment support for P frame
3486 m_sliceLevelReportSupported = false; // Slice Level Report support
3487 m_brcRoiSupported = false;
3488 m_brcMotionAdaptiveEnable = false;
3489
3490 m_brcAdaptiveRegionBoostSupported = false;
3491 m_brcAdaptiveRegionBoostEnable = false;
3492
3493 m_roundingInterEnable = false;
3494 m_adaptiveRoundingInterEnable = false;
3495 m_roundingInterP = false;
3496
3497 MOS_ZeroMemory(m_vdEncModeCost, 12 * sizeof(uint8_t));
3498
3499 MOS_ZeroMemory(m_vdEncMvCost, 8 * sizeof(uint8_t));
3500
3501 MOS_ZeroMemory(m_vdEncHmeMvCost, 8 * sizeof(uint8_t));
3502
3503 m_slidingWindowSize = false;
3504 m_forceToSkipEnable = false;
3505 m_vdencBrcInitDmemBufferSize = false;
3506 m_vdencBrcUpdateDmemBufferSize = false;
3507 m_vdencStaticFrame = false;
3508 m_vdencStaticRegionPct = false;
3509 m_perMBStreamOutEnable = false;
3510
3511 m_vdencSSCThrsTblI = SliceSizeThrsholdsI;
3512 m_vdencSSCThrsTblP = SliceSizeThrsholdsP;
3513 }
3514
3515 MOS_STATUS CodechalVdencAvcState::InitializeState()
3516 {
3517 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3518 MOS_STATUS statusKey = MOS_STATUS_SUCCESS;
3519
3520 CODECHAL_ENCODE_FUNCTION_ENTER;
3521
3522 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
3523 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3524 MOS_UserFeature_ReadValue_ID(
3525 nullptr,
3526 __MEDIA_USER_FEATURE_VALUE_SINGLE_TASK_PHASE_ENABLE_ID,
3527 &userFeatureData,
3528 m_osInterface->pOsContext);
3529 m_singleTaskPhaseSupported = (userFeatureData.i32Data) ? true : false;
3530
3531 // Set interleaved scaling output to support PAFF.
3532 m_fieldScalingOutputInterleaved = true;
3533
3534 if (m_encEnabled)
3535 {
3536 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3537 MOS_UserFeature_ReadValue_ID(
3538 nullptr,
3539 __MEDIA_USER_FEATURE_VALUE_AVC_FTQ_ENABLE_ID,
3540 &userFeatureData,
3541 m_osInterface->pOsContext);
3542 m_ftqEnable = (userFeatureData.i32Data) ? true : false;
3543
3544 m_mbBrcSupportCaps = 1;
3545 if (m_mbBrcSupportCaps)
3546 {
3547 // If the MBBRC user feature key does not exist, MBBRC will be set in SPS parsing
3548 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3549 MOS_UserFeature_ReadValue_ID(
3550 nullptr,
3551 __MEDIA_USER_FEATURE_VALUE_AVC_MB_BRC_ENABLE_ID,
3552 &userFeatureData,
3553 m_osInterface->pOsContext);
3554 if (userFeatureData.i32Data == 0 || userFeatureData.i32Data == 1)
3555 {
3556 m_mbBrcUserFeatureKeyControl = true;
3557 m_mbBrcEnabled = userFeatureData.i32Data ? true : false;
3558 }
3559 }
3560
3561 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3562 statusKey = MOS_UserFeature_ReadValue_ID(
3563 nullptr,
3564 __MEDIA_USER_FEATURE_VALUE_AVC_ENCODE_32xME_ENABLE_ID,
3565 &userFeatureData,
3566 m_osInterface->pOsContext);
3567
3568 if (statusKey == MOS_STATUS_SUCCESS)
3569 {
3570 m_32xMeSupported = (userFeatureData.i32Data) ? true : false;
3571 }
3572 }
3573
3574 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3575 MOS_UserFeature_ReadValue_ID(
3576 nullptr,
3577 __MEDIA_USER_FEATURE_VALUE_AVC_ROUNDING_INTER_ENABLE_ID,
3578 &userFeatureData,
3579 m_osInterface->pOsContext);
3580 m_roundingInterEnable = (userFeatureData.i32Data) ? true : false;
3581
3582 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3583 userFeatureData.i32Data = CODECHAL_ENCODE_AVC_INVALID_ROUNDING;
3584 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
3585 MOS_UserFeature_ReadValue_ID(
3586 nullptr,
3587 __MEDIA_USER_FEATURE_VALUE_AVC_ROUNDING_INTER_P_ID,
3588 &userFeatureData,
3589 m_osInterface->pOsContext);
3590 m_roundingInterP = userFeatureData.i32Data;
3591
3592 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3593 userFeatureData.i32Data = 1;
3594 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
3595 MOS_UserFeature_ReadValue_ID(
3596 nullptr,
3597 __MEDIA_USER_FEATURE_VALUE_AVC_ADAPTIVE_ROUNDING_INTER_ENABLE_ID,
3598 &userFeatureData,
3599 m_osInterface->pOsContext);
3600 m_adaptiveRoundingInterEnable = (userFeatureData.i32Data) ? true : false;
3601
3602 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3603 MOS_UserFeature_ReadValue_ID(
3604 nullptr,
3605 __MEDIA_USER_FEATURE_VALUE_AVC_SKIP_BIAS_ADJUSTMENT_ENABLE_ID,
3606 &userFeatureData,
3607 m_osInterface->pOsContext);
3608 m_skipBiasAdjustmentSupported = (userFeatureData.i32Data) ? true : false;
3609
3610 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3611 userFeatureData.i32Data = MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
3612 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
3613 MOS_UserFeature_ReadValue_ID(
3614 nullptr,
3615 __MEDIA_USER_FEATURE_VALUE_VDENC_TAIL_INSERTION_DELAY_COUNT_ID,
3616 &userFeatureData,
3617 m_osInterface->pOsContext);
3618 m_vdencFlushDelayCount = (userFeatureData.i32Data);
3619
3620 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
3621 MOS_UserFeature_ReadValue_ID(
3622 nullptr,
3623 __MEDIA_USER_FEATURE_VALUE_VDENC_BRC_MOTION_ADAPTIVE_ENABLE_ID,
3624 &userFeatureData,
3625 m_osInterface->pOsContext);
3626 m_brcMotionAdaptiveEnable = (userFeatureData.i32Data) ? true : false;
3627
3628 m_vdencBrcStatsBufferSize = AVC_BRC_STATS_BUF_SIZE;
3629 m_vdencBrcPakStatsBufferSize = AVC_BRC_PAK_STATS_BUF_SIZE;
3630
3631 return eStatus;
3632 }
3633
3634 MOS_STATUS CodechalVdencAvcState::ValidateNumReferences(PCODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS params)
3635 {
3636 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3637
3638 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
3639 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pSeqParams);
3640 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pAvcSliceParams);
3641
3642 uint8_t numRefIdx0MinusOne = params->pAvcSliceParams->num_ref_idx_l0_active_minus1;
3643 uint8_t numRefIdx1MinusOne = params->pAvcSliceParams->num_ref_idx_l1_active_minus1;
3644
3645 // Nothing to do here if numRefIdx = 0 and frame encoded
3646 if (numRefIdx0MinusOne == 0 && !CodecHal_PictureIsField(params->pPicParams->CurrOriginalPic))
3647 {
3648 if (params->wPictureCodingType == P_TYPE ||
3649 (params->wPictureCodingType == B_TYPE && numRefIdx1MinusOne == 0))
3650 {
3651 return eStatus;
3652 }
3653 }
3654
3655 if (params->wPictureCodingType == P_TYPE)
3656 {
3657 uint8_t maxPNumRefIdx0MinusOne = MaxRefIdx0[params->pSeqParams->TargetUsage];
3658 if (numRefIdx0MinusOne > maxPNumRefIdx0MinusOne)
3659 {
3660 CODECHAL_ENCODE_NORMALMESSAGE("Invalid active reference list size.");
3661 numRefIdx0MinusOne = maxPNumRefIdx0MinusOne;
3662 }
3663
3664 numRefIdx1MinusOne = 0;
3665 }
3666
3667 // Override number of references used by VME. PAK uses value from DDI (num_ref_idx_l*_active_minus1_from_DDI)
3668 params->pAvcSliceParams->num_ref_idx_l0_active_minus1 = numRefIdx0MinusOne;
3669 params->pAvcSliceParams->num_ref_idx_l1_active_minus1 = numRefIdx1MinusOne;
3670
3671 return eStatus;
3672 }
3673
3674 MOS_STATUS CodechalVdencAvcState::SetRounding(PCODECHAL_ENCODE_AVC_ROUNDING_PARAMS param, PMHW_VDBOX_AVC_SLICE_STATE sliceState)
3675 {
3676 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3677
3678 CODECHAL_ENCODE_FUNCTION_ENTER;
3679
3680 if (param != nullptr && param->bEnableCustomRoudingIntra)
3681 {
3682 sliceState->dwRoundingIntraValue = param->dwRoundingIntra;
3683 }
3684 else
3685 {
3686 sliceState->dwRoundingIntraValue = 5;
3687 }
3688
3689 if (param != nullptr && param->bEnableCustomRoudingInter)
3690 {
3691 sliceState->bRoundingInterEnable = true;
3692 sliceState->dwRoundingValue = param->dwRoundingInter;
3693 }
3694 else
3695 {
3696 sliceState->bRoundingInterEnable = m_roundingInterEnable;
3697
3698 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceState);
3699 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceState->pEncodeAvcSeqParams);
3700 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceState->pEncodeAvcPicParams);
3701 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceState->pEncodeAvcSliceParams);
3702
3703 auto avcSeqParams = sliceState->pEncodeAvcSeqParams;
3704 auto avcPicParams = sliceState->pEncodeAvcPicParams;
3705 auto avcSliceParams = sliceState->pEncodeAvcSliceParams;
3706 uint8_t sliceQP = avcPicParams->pic_init_qp_minus26 + 26 + avcSliceParams->slice_qp_delta;
3707
3708 switch (Slice_Type[avcSliceParams->slice_type])
3709 {
3710 case SLICE_P:
3711 if (m_roundingInterP == CODECHAL_ENCODE_AVC_INVALID_ROUNDING)
3712 {
3713 // Adaptive Rounding is only used in CQP case
3714 if (m_adaptiveRoundingInterEnable && !m_vdencBrcEnabled)
3715 {
3716 // If IPPP scenario
3717 if (avcSeqParams->GopRefDist == 1)
3718 {
3719 sliceState->dwRoundingValue = CodechalVdencAvcState::AdaptiveInterRoundingPWithoutB[sliceQP];
3720 }
3721 else
3722 {
3723 sliceState->dwRoundingValue = CodechalVdencAvcState::AdaptiveInterRoundingP[sliceQP];
3724 }
3725 }
3726 else
3727 {
3728 sliceState->dwRoundingValue = CodechalVdencAvcState::InterRoundingP[avcSeqParams->TargetUsage];
3729 }
3730 }
3731 else
3732 {
3733 sliceState->dwRoundingValue = m_roundingInterP;
3734 }
3735 break;
3736 case SLICE_B:
3737 if (m_refList[m_currReconstructedPic.FrameIdx]->bUsedAsRef)
3738 {
3739 sliceState->dwRoundingValue = InterRoundingBRef[avcSeqParams->TargetUsage];
3740 }
3741 else
3742 {
3743 if (m_adaptiveRoundingInterEnable && !m_vdencBrcEnabled)
3744 {
3745 sliceState->dwRoundingValue = AdaptiveInterRoundingB[sliceQP];
3746 }
3747 else
3748 {
3749 sliceState->dwRoundingValue = InterRoundingB[avcSeqParams->TargetUsage];
3750 }
3751 }
3752 break;
3753 default:
3754 // do nothing
3755 break;
3756 }
3757 }
3758
3759 return eStatus;
3760 }
3761
3762 MOS_STATUS CodechalVdencAvcState::GetSkipBiasAdjustment(uint8_t sliceQP, uint16_t gopRefDist, bool *skipBiasAdjustmentEnable)
3763 {
3764 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3765
3766 CODECHAL_ENCODE_CHK_NULL_RETURN(skipBiasAdjustmentEnable);
3767
3768 // Determine if SkipBiasAdjustment should be enabled for P picture
3769 // 1. No B frame 2. Qp >= 22 3. CQP mode
3770 *skipBiasAdjustmentEnable = m_skipBiasAdjustmentSupported && (m_pictureCodingType == P_TYPE) && (gopRefDist == 1) && (sliceQP >= CODECHAL_ENCODE_AVC_SKIP_BIAS_ADJUSTMENT_QP_THRESHOLD);
3771
3772 return eStatus;
3773 }
3774
3775 MOS_STATUS CodechalVdencAvcState::GetHmeSupportedBasedOnTU(HmeLevel hmeLevel, bool *supported)
3776 {
3777 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3778
3779 CODECHAL_ENCODE_CHK_NULL_RETURN(supported);
3780
3781 switch (hmeLevel)
3782 {
3783 case HME_LEVEL_4x:
3784 //HME always supported
3785 *supported = true;
3786 break;
3787 case HME_LEVEL_16x:
3788 *supported = SHMEEnabled[m_targetUsage & 0x7] ? true : false;
3789 break;
3790 case HME_LEVEL_32x:
3791 *supported = UHMEEnabled[m_targetUsage & 0x7] ? true : false;
3792 break;
3793 default:
3794 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid hme Level");
3795 eStatus = MOS_STATUS_INVALID_PARAMETER;
3796 break;
3797 }
3798
3799 return eStatus;
3800 }
3801
3802 MOS_STATUS CodechalVdencAvcState::InitKernelStateSFD()
3803 {
3804 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3805
3806 CODECHAL_ENCODE_FUNCTION_ENTER;
3807
3808 uint8_t *kernelBinary;
3809 uint32_t kernelSize;
3810
3811 uint32_t kuid = m_useCommonKernel ? m_kuidCommon : m_kuid;
3812 MOS_STATUS status = CodecHalGetKernelBinaryAndSize(m_kernelBase, kuid, &kernelBinary, &kernelSize);
3813 CODECHAL_ENCODE_CHK_STATUS_RETURN(status);
3814
3815 CODECHAL_KERNEL_HEADER currKrnHeader;
3816
3817 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
3818 kernelBinary,
3819 ENC_SFD,
3820 0,
3821 &currKrnHeader,
3822 &kernelSize));
3823
3824 auto kernelStatePtr = m_sfdKernelState;
3825 kernelStatePtr->KernelParams.iBTCount = CODECHAL_ENCODE_AVC_SFD_NUM_SURFACES;
3826 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
3827 kernelStatePtr->KernelParams.iCurbeLength = sizeof(CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON);
3828 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
3829 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
3830 kernelStatePtr->KernelParams.iIdCount = 1;
3831 kernelStatePtr->KernelParams.iInlineDataLength = 0;
3832
3833 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
3834 kernelStatePtr->KernelParams.pBinary =
3835 kernelBinary +
3836 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
3837 kernelStatePtr->KernelParams.iSize = kernelSize;
3838
3839 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
3840 m_stateHeapInterface,
3841 kernelStatePtr->KernelParams.iBTCount,
3842 &kernelStatePtr->dwSshSize,
3843 &kernelStatePtr->dwBindingTableSize));
3844
3845 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
3846
3847 return eStatus;
3848 }
3849
3850 MOS_STATUS CodechalVdencAvcState::SetCurbeSFD(PCODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS params)
3851 {
3852 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3853
3854 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
3855 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
3856
3857 CODECHAL_ENCODE_AVC_SFD_CURBE_COMMON curbe;
3858 MOS_ZeroMemory(&curbe, sizeof(curbe));
3859 curbe.DW0.EnableIntraCostScalingForStaticFrame = 1;
3860 curbe.DW0.EnableAdaptiveMvStreamIn = 0; // VDEnc
3861 curbe.DW0.StreamInType = 7; // VDEnc
3862 curbe.DW0.SliceType = (m_pictureCodingType + 1) % 3;
3863 curbe.DW0.BRCModeEnable = (m_vdencBrcEnabled != 0);
3864 curbe.DW0.VDEncModeDisable = false;
3865
3866 curbe.DW1.HMEStreamInRefCost = 5;
3867 curbe.DW1.NumOfRefs = m_avcSliceParams->num_ref_idx_l0_active_minus1; // VDEnc
3868 curbe.DW1.QPValue = m_avcPicParam->QpY + m_avcSliceParams->slice_qp_delta;
3869
3870 // SFD kernel requires to round-down to 4-MB aligned
3871 curbe.DW2.FrameHeightInMBs = (m_oriFrameHeight / CODECHAL_MACROBLOCK_HEIGHT >> 2) << 2;
3872 curbe.DW2.FrameWidthInMBs = (m_oriFrameWidth / CODECHAL_MACROBLOCK_WIDTH >> 2) << 2;
3873 curbe.DW3.LargeMvThresh = 128;
3874 uint32_t totalMb = curbe.DW2.FrameWidthInMBs * curbe.DW2.FrameHeightInMBs;
3875 curbe.DW4.TotalLargeMvThreshold = totalMb / 100;
3876 curbe.DW5.ZMVThreshold = 4;
3877 curbe.DW6.TotalZMVThreshold = totalMb * m_avcPicParam->dwZMvThreshold / 100;
3878 curbe.DW7.MinDistThreshold = 10;
3879
3880 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(curbe.CostTable, CODEC_AVC_NUM_QP * sizeof(uint8_t), m_codechalEncodeAvcSfdCostTableVdEnc, CODEC_AVC_NUM_QP * sizeof(uint8_t)),
3881 "Failed to copy VDEnc SFD cost table");
3882
3883 curbe.DW21.ActualHeightInMB = curbe.DW2.FrameHeightInMBs;
3884 curbe.DW21.ActualWidthInMB = curbe.DW2.FrameWidthInMBs;
3885 curbe.DW24.VDEncInputImagStateIndex = CODECHAL_ENCODE_AVC_SFD_VDENC_INPUT_IMAGE_STATE_COMMON;
3886 curbe.DW26.MVDataSurfaceIndex = CODECHAL_ENCODE_AVC_SFD_MV_DATA_SURFACE_COMMON;
3887 curbe.DW27.InterDistortionSurfaceIndex = CODECHAL_ENCODE_AVC_SFD_INTER_DISTORTION_SURFACE_COMMON;
3888 curbe.DW28.OutputDataSurfaceIndex = CODECHAL_ENCODE_AVC_SFD_OUTPUT_DATA_SURFACE_COMMON;
3889 curbe.DW29.VDEncOutputImagStateIndex = CODECHAL_ENCODE_AVC_SFD_VDENC_OUTPUT_IMAGE_STATE_COMMON;
3890
3891 CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
3892 &curbe,
3893 params->pKernelState->dwCurbeOffset,
3894 sizeof(curbe)));
3895
3896 CODECHAL_DEBUG_TOOL(
3897 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateSfdParam(
3898 &curbe));)
3899
3900 return eStatus;
3901 }
3902
3903 MOS_STATUS CodechalVdencAvcState::SetSequenceStructs()
3904 {
3905 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3906
3907 CODECHAL_ENCODE_FUNCTION_ENTER;
3908
3909 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
3910
3911 auto seqParams = m_avcSeqParam;
3912
3913 if (m_targetUsageOverride)
3914 {
3915 seqParams->TargetUsage = m_targetUsageOverride;
3916 }
3917
3918 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::SetSequenceStructs());
3919
3920 // App does tail insertion in VDEnc dynamic slice non-CP case
3921 m_vdencNoTailInsertion =
3922 seqParams->EnableSliceLevelRateCtrl &&
3923 (!m_osInterface->osCpInterface->IsCpEnabled());
3924
3925 // If 16xMe is supported then check if it is supported in the TU settings
3926 if (m_16xMeSupported)
3927 {
3928 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetHmeSupportedBasedOnTU(HME_LEVEL_16x, &m_16xMeSupported));
3929 }
3930
3931 // If 32xMe is supported then check if it is supported in the TU settings
3932 if (m_32xMeSupported)
3933 {
3934 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetHmeSupportedBasedOnTU(HME_LEVEL_32x, &m_32xMeSupported));
3935 }
3936
3937 if (m_firstFrame)
3938 {
3939 m_oriFrameHeight = seqParams->FrameHeight;
3940 m_oriFrameWidth = seqParams->FrameWidth;
3941 }
3942
3943 // check if there is a dynamic resolution change
3944 if ((m_oriFrameHeight && (m_oriFrameHeight != seqParams->FrameHeight)) ||
3945 (m_oriFrameWidth && (m_oriFrameWidth != seqParams->FrameWidth)))
3946 {
3947 m_resolutionChanged = true;
3948 m_oriFrameHeight = seqParams->FrameHeight;
3949 m_oriFrameWidth = seqParams->FrameWidth;
3950 // Need to call BRCInit instead of BRCReset for dynamic resolution change
3951 m_brcInit = true;
3952 }
3953 else
3954 {
3955 m_resolutionChanged = false;
3956 }
3957
3958 // HuC based BRC should be used when 1) BRC is requested by App and 2) HuC FW is loaded and HuC is enabled for use.
3959 if (CodecHalIsRateControlBrc(seqParams->RateControlMethod, CODECHAL_AVC))
3960 {
3961 if (!MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrEnableMediaKernels))
3962 {
3963 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_STATUS_UNKNOWN, "Failed to load HuC firmware!");
3964 }
3965
3966 m_vdencBrcEnabled = MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrEnableMediaKernels);
3967 }
3968
3969 if (m_mbBrcSupportCaps && (m_vdencBrcEnabled))
3970 {
3971 // control MBBRC if the user feature key does not exist
3972 if (!m_mbBrcUserFeatureKeyControl)
3973 {
3974 if (seqParams->RateControlMethod == RATECONTROL_ICQ || seqParams->RateControlMethod == RATECONTROL_QVBR)
3975 {
3976 // If the rate control method is ICQ or QVBR then enable MBBRC by default for all TUs and ignore the app input
3977 m_mbBrcEnabled = true;
3978 CODECHAL_ENCODE_NORMALMESSAGE("MBBRC enabled with rate control = %d", seqParams->RateControlMethod);
3979 }
3980 else if (seqParams->RateControlMethod == RATECONTROL_VCM)
3981 {
3982 // If the rate control method is VCM then disable MBBRC by default for all TUs and ignore the app input
3983 m_mbBrcEnabled = false;
3984 }
3985 else
3986 {
3987 switch (seqParams->MBBRC)
3988 {
3989 case mbBrcInternal:
3990 m_mbBrcEnabled = true;
3991 break;
3992 case mbBrcDisabled:
3993 m_mbBrcEnabled = false;
3994 break;
3995 case mbBrcEnabled:
3996 m_mbBrcEnabled = true;
3997 break;
3998 }
3999 }
4000 }
4001 }
4002
4003 m_trellis = seqParams->Trellis;
4004
4005 // Simple check for BRC parameters; if error, disable BRC and continue encoding
4006 if ((m_vdencBrcEnabled) &&
4007 ((((!seqParams->InitVBVBufferFullnessInBit ||
4008 !seqParams->VBVBufferSizeInBit ||
4009 !seqParams->MaxBitRate) &&
4010 (seqParams->RateControlMethod != RATECONTROL_AVBR)) ||
4011 !seqParams->TargetBitRate ||
4012 !seqParams->FramesPer100Sec) &&
4013 seqParams->RateControlMethod != RATECONTROL_ICQ))
4014 {
4015 CODECHAL_ENCODE_ASSERTMESSAGE("Fatal error in AVC Encoding BRC parameters.");
4016 CODECHAL_ENCODE_ASSERTMESSAGE("RateControlMethod = %d, InitVBVBufferFullnessInBit = %d, VBVBufferSizeInBit = %d, MaxBitRate = %d, TargetBitRate = %d, FramesPer100Sec = %d",
4017 seqParams->RateControlMethod,
4018 seqParams->InitVBVBufferFullnessInBit,
4019 seqParams->VBVBufferSizeInBit,
4020 seqParams->MaxBitRate,
4021 seqParams->TargetBitRate,
4022 seqParams->FramesPer100Sec);
4023 m_vdencBrcEnabled = false;
4024 }
4025
4026 if (Mos_ResourceIsNull(&m_batchBufferForVdencImgStat[0].OsResource))
4027 {
4028 // VDENC uses second level batch buffer for image state cmds
4029 if (!m_vdencBrcEnabled)
4030 {
4031 // CQP mode needs a set of buffers for concurrency between SFD and VDEnc
4032 for (uint8_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
4033 {
4034 MOS_ZeroMemory(
4035 &m_batchBufferForVdencImgStat[i],
4036 sizeof(m_batchBufferForVdencImgStat[i]));
4037 m_batchBufferForVdencImgStat[i].bSecondLevel = true;
4038 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
4039 m_osInterface,
4040 &m_batchBufferForVdencImgStat[i],
4041 nullptr,
4042 m_hwInterface->m_vdencBrcImgStateBufferSize));
4043 }
4044 m_vdencBrcImgStatAllocated = true;
4045 }
4046 else
4047 {
4048 MOS_ZeroMemory(
4049 &m_batchBufferForVdencImgStat[0],
4050 sizeof(m_batchBufferForVdencImgStat[0]));
4051 m_batchBufferForVdencImgStat[0].bSecondLevel = true;
4052 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
4053 m_osInterface,
4054 &m_batchBufferForVdencImgStat[0],
4055 nullptr,
4056 GetVdencBRCImgStateBufferSize()));
4057 }
4058 }
4059
4060 // BRC Init or Reset
4061 if (seqParams->bInitBRC)
4062 {
4063 m_brcInit = seqParams->bInitBRC;
4064 }
4065 else
4066 {
4067 m_brcReset = seqParams->bResetBRC;
4068 }
4069
4070 if (seqParams->RateControlMethod == RATECONTROL_ICQ)
4071 {
4072 if (seqParams->ICQQualityFactor < CODECHAL_ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR ||
4073 seqParams->ICQQualityFactor > CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR)
4074 {
4075 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid ICQ Quality Factor input %d\n", seqParams->ICQQualityFactor);
4076 seqParams->ICQQualityFactor = (uint16_t)CodecHal_Clip3(CODECHAL_ENCODE_AVC_VDENC_MIN_ICQ_QUALITYFACTOR,
4077 CODECHAL_ENCODE_AVC_MAX_ICQ_QUALITYFACTOR,
4078 seqParams->ICQQualityFactor);
4079 }
4080 }
4081
4082 if (seqParams->EnableSliceLevelRateCtrl)
4083 {
4084 m_waReadVDEncOverflowStatus = MEDIA_IS_WA(m_hwInterface->GetWaTable(), WaReadVDEncOverflowStatus);
4085 }
4086
4087 // if GOP structure is I-frame only, we use 3 non-ref slots for tracked buffer
4088 m_gopIsIdrFrameOnly = (seqParams->GopPicSize == 1 && seqParams->GopRefDist == 0);
4089
4090 // Set sliding window size to one second by default, up to 60
4091 if (m_slidingWindowSize == 0)
4092 {
4093 m_slidingWindowSize = MOS_MIN((uint32_t)(seqParams->FramesPer100Sec / 100), 60);
4094 }
4095
4096 if (seqParams->FramesPer100Sec == 0)
4097 {
4098 return MOS_STATUS_INVALID_PARAMETER;
4099 }
4100 m_maxNumSlicesAllowed = CodecHalAvcEncode_GetMaxNumSlicesAllowed(
4101 (CODEC_AVC_PROFILE_IDC)(seqParams->Profile),
4102 (CODEC_AVC_LEVEL_IDC)(seqParams->Level),
4103 seqParams->FramesPer100Sec);
4104
4105 m_lookaheadDepth = seqParams->LookaheadDepth;
4106 if (m_lookaheadDepth > 0)
4107 {
4108 uint64_t targetBitRate = (uint64_t)seqParams->TargetBitRate;
4109 if ((seqParams->FramesPer100Sec < 100) || ((targetBitRate * 100) < seqParams->FramesPer100Sec))
4110 {
4111 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid FrameRate or TargetBitRate in lookahead pass!");
4112 return MOS_STATUS_INVALID_PARAMETER;
4113 }
4114 m_averageFrameSize = (uint32_t)(targetBitRate * 100 / seqParams->FramesPer100Sec);
4115
4116 if (seqParams->VBVBufferSizeInBit < seqParams->InitVBVBufferFullnessInBit)
4117 {
4118 CODECHAL_ENCODE_ASSERTMESSAGE("VBVBufferSizeInBit is less than InitVBVBufferFullnessInBit\n");
4119 eStatus = MOS_STATUS_INVALID_PARAMETER;
4120 return eStatus;
4121 }
4122
4123 if (m_targetBufferFulness == 0)
4124 {
4125 m_targetBufferFulness = seqParams->VBVBufferSizeInBit - seqParams->InitVBVBufferFullnessInBit;
4126 }
4127 }
4128
4129 return eStatus;
4130 }
4131
4132 MOS_STATUS CodechalVdencAvcState::SetPictureStructs()
4133 {
4134 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4135
4136 CODECHAL_ENCODE_FUNCTION_ENTER;
4137
4138 auto picParams = m_avcPicParam;
4139 auto seqParams = m_avcSeqParam;
4140 auto avcRefList = &m_refList[0];
4141 auto avcPicIdx = &m_picIdx[0];
4142
4143 uint8_t prevRefIdx = m_currReconstructedPic.FrameIdx;
4144 uint8_t currRefIdx = picParams->CurrReconstructedPic.FrameIdx;
4145
4146 int16_t prevFrameNum = m_frameNum;
4147 int16_t currFrameNum = picParams->frame_num;
4148
4149 if (m_firstFrame)
4150 {
4151 m_oriFieldCodingFlag = picParams->FieldCodingFlag;
4152 }
4153
4154 if (Mos_ResourceIsNull(&m_reconSurface.OsResource) &&
4155 (!picParams->UserFlags.bUseRawPicForRef || m_codecFunction != CODECHAL_FUNCTION_ENC))
4156 {
4157 return MOS_STATUS_INVALID_PARAMETER;
4158 }
4159
4160 // Sync initialize
4161 if ((m_firstFrame) ||
4162 (picParams->UserFlags.bUseRawPicForRef) || // No need to wait for previous PAK if reconstructed pic is not used as reference (but RAW pic is used for ref)
4163 ((picParams->CodingType == I_TYPE)) || // No need to wait for I-Frames
4164 ((currFrameNum == prevFrameNum) &&
4165 CodecHal_PictureIsFrame(picParams->CurrOriginalPic)) || // No need to wait if current and previous pics have same frame numbers (Same reference list is used for two pictures with same frame numbers)
4166 (!avcRefList[prevRefIdx]->bUsedAsRef &&
4167 CodecHal_PictureIsField(picParams->CurrOriginalPic)))
4168 {
4169 m_waitForPak = false;
4170 }
4171 else
4172 {
4173 m_waitForPak = true;
4174 }
4175
4176 m_signalEnc = false;
4177
4178 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::SetPictureStructs());
4179
4180 m_hwInterface->GetMfxInterface()->SetBrcNumPakPasses(GetNumBrcPakPasses(picParams->BRCPrecision));
4181 if (m_vdencBrcEnabled)
4182 {
4183 m_numPasses = CODECHAL_VDENC_BRC_NUM_OF_PASSES - 1; // 2-pass VDEnc BRC
4184
4185 if (picParams->BRCPrecision == 1)
4186 {
4187 m_vdencSinglePassEnable = true;
4188 m_numPasses = 0;
4189 }
4190 }
4191 else
4192 {
4193 // legacy AVC : 1 original plus extra to handle IPCM MBs
4194 // VDENC : single PAK pass
4195 m_numPasses = (CODECHAL_VDENC_AVC_CQP_NUM_OF_PASSES - 1);
4196 }
4197
4198 if (seqParams->RateControlMethod == RATECONTROL_VCM && m_pictureCodingType == B_TYPE)
4199 {
4200 CODECHAL_ENCODE_ASSERTMESSAGE("VCM BRC mode does not support B-frames\n");
4201 eStatus = MOS_STATUS_INVALID_PARAMETER;
4202 return eStatus;
4203 }
4204
4205 if (seqParams->RateControlMethod == RATECONTROL_VCM && (picParams->FieldCodingFlag || picParams->FieldFrameCodingFlag))
4206 {
4207 CODECHAL_ENCODE_ASSERTMESSAGE("VCM BRC mode does not support interlaced\n");
4208 eStatus = MOS_STATUS_INVALID_PARAMETER;
4209 return eStatus;
4210 }
4211
4212 if (picParams->FieldCodingFlag || picParams->FieldFrameCodingFlag)
4213 {
4214 CODECHAL_ENCODE_ASSERTMESSAGE("VDEnc does not support interlaced picture\n");
4215 eStatus = MOS_STATUS_INVALID_PARAMETER;
4216 return eStatus;
4217 }
4218
4219 avcRefList[currRefIdx]->pRefPicSelectListEntry = nullptr;
4220
4221 if (m_brcAdaptiveRegionBoostSupported && m_avcPicParam->TargetFrameSize && !m_lookaheadDepth)
4222 { // Adaptive region boost is enabled for TCBRC only
4223 m_brcAdaptiveRegionBoostEnable = true;
4224 m_vdencStreamInEnabled = true;
4225 } else
4226 {
4227 m_brcAdaptiveRegionBoostEnable = false;
4228 }
4229
4230 if (!m_brcAdaptiveRegionBoostEnable && m_avcPicParam->NumDirtyROI) // ROI is not supported with ARB now
4231 {
4232 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupDirtyROI(
4233 &(m_resVdencStreamInBuffer[m_currRecycledBufIdx])));
4234 }
4235
4236 if (!m_brcAdaptiveRegionBoostEnable && m_avcPicParam->NumROI) // ROI is not supported with ARB now
4237 {
4238 m_avcPicParam->bNativeROI = ProcessRoiDeltaQp();
4239 if (m_vdencBrcEnabled && !m_avcPicParam->bNativeROI)
4240 {
4241 if (!m_nonNativeBrcRoiSupported)
4242 {
4243 MOS_OS_ASSERTMESSAGE("Non native ROIs are not supported on this platform with BRC");
4244 return MOS_STATUS_INVALID_PARAMETER;
4245 }
4246
4247 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupBrcROIBuffer(
4248 m_avcPicParam,
4249 &(m_resVdencBrcRoiBuffer[m_currRecycledBufIdx])));
4250 }
4251 else
4252 {
4253 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupROIStreamIn(
4254 m_avcPicParam,
4255 m_avcSliceParams,
4256 &(m_resVdencStreamInBuffer[m_currRecycledBufIdx])));
4257 }
4258 }
4259 if(m_avcPicParam->ForceSkip.Enable && (m_pictureCodingType != I_TYPE))
4260 {
4261 m_avcPicParam->ForceSkip.Enable = 1;
4262 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupForceSkipStreamIn(
4263 m_avcPicParam,
4264 &(m_resVdencStreamInBuffer[m_currRecycledBufIdx])));
4265 }
4266 else
4267 m_avcPicParam->ForceSkip.Enable = 0;
4268
4269 if ((m_lookaheadDepth > 0) && (m_prevTargetFrameSize > 0))
4270 {
4271 int64_t targetBufferFulness = (int64_t)m_targetBufferFulness;
4272 targetBufferFulness += (((int64_t)m_prevTargetFrameSize) << 3) - (int64_t)m_averageFrameSize;
4273 m_targetBufferFulness = targetBufferFulness < 0 ?
4274 0 : (targetBufferFulness > 0xFFFFFFFF ? 0xFFFFFFFF : (uint32_t)targetBufferFulness);
4275 }
4276 m_prevTargetFrameSize = m_avcPicParam->TargetFrameSize;
4277
4278 if (m_brcAdaptiveRegionBoostEnable)
4279 {
4280 uint16_t rowOffset[8] = {0, 3, 5, 2, 7, 4, 1, 6};
4281 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupRegionBoosting(&(m_resVdencStreamInBuffer[m_currRecycledBufIdx]), rowOffset[(m_storeData - 1) & 7]));
4282 }
4283
4284 return eStatus;
4285 }
4286
4287 MOS_STATUS CodechalVdencAvcState::SetSliceStructs()
4288 {
4289 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4290
4291 CODECHAL_ENCODE_FUNCTION_ENTER;
4292
4293 auto slcParams = m_avcSliceParams;
4294 auto seqParams = m_avcSeqParam;
4295 auto picParams = m_avcPicParam;
4296
4297 if (m_pictureCodingType != I_TYPE)
4298 {
4299 CODECHAL_ENCODE_AVC_VALIDATE_NUM_REFS_PARAMS validateNumRefsParams;
4300 validateNumRefsParams.pSeqParams = seqParams;
4301 validateNumRefsParams.pPicParams = picParams;
4302 validateNumRefsParams.pAvcSliceParams = slcParams;
4303 validateNumRefsParams.wPictureCodingType = m_pictureCodingType;
4304 validateNumRefsParams.wPicHeightInMB = m_picHeightInMb;
4305 validateNumRefsParams.wFrameFieldHeightInMB = m_frameFieldHeightInMb;
4306 validateNumRefsParams.bFirstFieldIPic = m_firstFieldIdrPic;
4307 validateNumRefsParams.bVDEncEnabled = true;
4308
4309 CODECHAL_ENCODE_CHK_STATUS_RETURN(ValidateNumReferences(&validateNumRefsParams));
4310 }
4311 else
4312 {
4313 slcParams->num_ref_idx_l0_active_minus1 = 0;
4314 slcParams->num_ref_idx_l1_active_minus1 = 0;
4315 }
4316
4317 if (seqParams->NumRefFrames == CODEC_AVC_MAX_NUM_REF_FRAME)
4318 {
4319 const uint8_t hwInvalidFrameId = CODEC_AVC_MAX_NUM_REF_FRAME - 1;
4320 bool isActiveRef[hwInvalidFrameId] = {};
4321 uint8_t swapIndex = CODEC_AVC_NUM_UNCOMPRESSED_SURFACE;
4322
4323 for (uint32_t sliceCount = 0; sliceCount < m_numSlices; sliceCount++)
4324 {
4325 if (m_pictureCodingType != I_TYPE)
4326 {
4327 for (uint8_t i = 0; i < (slcParams->num_ref_idx_l0_active_minus1 + 1); i++)
4328 {
4329 if (slcParams->RefPicList[0][i].FrameIdx >= CODEC_AVC_MAX_NUM_REF_FRAME)
4330 {
4331 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid slice parameters.");
4332 return MOS_STATUS_INVALID_PARAMETER;
4333 }
4334 auto index = m_picIdx[slcParams->RefPicList[0][i].FrameIdx].ucPicIdx;
4335 if (m_refList[index]->ucFrameId < hwInvalidFrameId)
4336 {
4337 isActiveRef[m_refList[index]->ucFrameId] = true;
4338 }
4339 else if (m_refList[index]->ucFrameId == hwInvalidFrameId && swapIndex == CODEC_AVC_NUM_UNCOMPRESSED_SURFACE)
4340 {
4341 swapIndex = index;
4342 }
4343 else
4344 {
4345 // should never happen, something must be wrong
4346 CODECHAL_PUBLIC_ASSERT(false);
4347 }
4348 }
4349 }
4350 if (m_pictureCodingType == B_TYPE)
4351 {
4352 for (uint8_t i = 0; i < (slcParams->num_ref_idx_l1_active_minus1 + 1); i++)
4353 {
4354 if (slcParams->RefPicList[1][i].FrameIdx >= CODEC_AVC_MAX_NUM_REF_FRAME)
4355 {
4356 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid slice parameters.");
4357 return MOS_STATUS_INVALID_PARAMETER;
4358 }
4359 auto index = m_picIdx[slcParams->RefPicList[1][i].FrameIdx].ucPicIdx;
4360 if (m_refList[index]->ucFrameId < hwInvalidFrameId)
4361 {
4362 isActiveRef[m_refList[index]->ucFrameId] = true;
4363 }
4364 else if (m_refList[index]->ucFrameId == hwInvalidFrameId && swapIndex == CODEC_AVC_NUM_UNCOMPRESSED_SURFACE)
4365 {
4366 swapIndex = index;
4367 }
4368 else
4369 {
4370 // should never happen, something must be wrong
4371 CODECHAL_PUBLIC_ASSERT(false);
4372 }
4373 }
4374 }
4375 slcParams++;
4376 }
4377
4378 if (swapIndex < CODEC_AVC_NUM_UNCOMPRESSED_SURFACE)
4379 {
4380 uint8_t i = 0;
4381 for (i = 0; i < hwInvalidFrameId; i++)
4382 {
4383 if (isActiveRef[i])
4384 {
4385 continue;
4386 }
4387 uint8_t j = 0;
4388 for (j = 0; j < CODEC_AVC_MAX_NUM_REF_FRAME; j++)
4389 {
4390 if (m_picIdx[j].bValid && m_refList[m_picIdx[j].ucPicIdx]->ucFrameId == i)
4391 {
4392 std::swap(m_refList[m_picIdx[j].ucPicIdx]->ucFrameId, m_refList[swapIndex]->ucFrameId);
4393 break;
4394 }
4395 }
4396 if (j != CODEC_AVC_MAX_NUM_REF_FRAME)
4397 {
4398 break;
4399 }
4400 }
4401 if (i == hwInvalidFrameId)
4402 {
4403 // should never happen, something must be wrong
4404 CODECHAL_PUBLIC_ASSERT(false);
4405 }
4406 }
4407 }
4408
4409 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::SetSliceStructs());
4410
4411 if (eStatus == MOS_STATUS_INVALID_PARAMETER)
4412 {
4413 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid slice parameters.");
4414 }
4415 return eStatus;
4416 }
4417
4418 MOS_STATUS CodechalVdencAvcState::SendSFDSurfaces(PMOS_COMMAND_BUFFER cmdBuffer, PCODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS params)
4419 {
4420 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4421
4422 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
4423 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
4424
4425 // VDEnc input/output image state (CQP mode)
4426 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
4427 auto kernelState = params->pKernelState;
4428 if (params->bVdencActive && !params->bVdencBrcEnabled)
4429 {
4430 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presVDEncImageStateInputBuffer);
4431 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4432 surfaceCodecParams.presBuffer = params->presVDEncImageStateInputBuffer;
4433 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(m_hwInterface->m_vdencBrcImgStateBufferSize);
4434 surfaceCodecParams.dwOffset = 0;
4435 surfaceCodecParams.bRenderTarget = false;
4436 surfaceCodecParams.bIsWritable = false;
4437 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE].Value;
4438 surfaceCodecParams.dwBindingTableOffset = CODECHAL_ENCODE_AVC_SFD_VDENC_INPUT_IMAGE_STATE_COMMON;
4439 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4440 m_hwInterface,
4441 cmdBuffer,
4442 &surfaceCodecParams,
4443 kernelState));
4444
4445 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presVDEncImageStateOutputBuffer);
4446 surfaceCodecParams.presBuffer = params->presVDEncImageStateOutputBuffer;
4447 surfaceCodecParams.bRenderTarget = true;
4448 surfaceCodecParams.bIsWritable = true;
4449 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_VDENC_IMAGESTATE_ENCODE].Value;
4450 surfaceCodecParams.dwBindingTableOffset = CODECHAL_ENCODE_AVC_SFD_VDENC_OUTPUT_IMAGE_STATE_COMMON;
4451 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4452 m_hwInterface,
4453 cmdBuffer,
4454 &surfaceCodecParams,
4455 kernelState));
4456 }
4457
4458 // HME MV Data surface
4459 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psMeMvDataSurface);
4460 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4461 surfaceCodecParams.bIs2DSurface = true;
4462 surfaceCodecParams.bMediaBlockRW = true;
4463 surfaceCodecParams.psSurface = params->psMeMvDataSurface;
4464 surfaceCodecParams.dwOffset = params->dwMeMvBottomFieldOffset;
4465 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
4466 surfaceCodecParams.dwBindingTableOffset = CODECHAL_ENCODE_AVC_SFD_MV_DATA_SURFACE_COMMON;
4467 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4468 m_hwInterface,
4469 cmdBuffer,
4470 &surfaceCodecParams,
4471 kernelState));
4472
4473 // HME distortion surface
4474 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psMeDistortionSurface);
4475 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4476 surfaceCodecParams.bIs2DSurface = true;
4477 surfaceCodecParams.bMediaBlockRW = true;
4478 surfaceCodecParams.psSurface = params->psMeDistortionSurface;
4479 surfaceCodecParams.dwOffset = params->dwMeDistortionBottomFieldOffset;
4480 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
4481 surfaceCodecParams.dwBindingTableOffset = CODECHAL_ENCODE_AVC_SFD_INTER_DISTORTION_SURFACE_COMMON;
4482 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4483 m_hwInterface,
4484 cmdBuffer,
4485 &surfaceCodecParams,
4486 kernelState));
4487
4488 // output buffer
4489 CODECHAL_ENCODE_CHK_NULL_RETURN(params->presOutputBuffer);
4490 MOS_ZeroMemory(&surfaceCodecParams, sizeof(CODECHAL_SURFACE_CODEC_PARAMS));
4491 surfaceCodecParams.presBuffer = params->presOutputBuffer;
4492 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE);
4493 surfaceCodecParams.dwOffset = 0;
4494 surfaceCodecParams.bRenderTarget = true;
4495 surfaceCodecParams.bIsWritable = true;
4496 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
4497 surfaceCodecParams.dwBindingTableOffset = CODECHAL_ENCODE_AVC_SFD_OUTPUT_DATA_SURFACE_COMMON;
4498 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
4499 m_hwInterface,
4500 cmdBuffer,
4501 &surfaceCodecParams,
4502 kernelState));
4503
4504 return eStatus;
4505 }
4506
4507 MOS_STATUS CodechalVdencAvcState::SFDKernel()
4508 {
4509 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4510
4511 CODECHAL_ENCODE_FUNCTION_ENTER;
4512
4513 if (!m_sfdKernelState)
4514 {
4515 CODECHAL_ENCODE_CHK_NULL_RETURN(m_sfdKernelState = MOS_New(MHW_KERNEL_STATE));
4516 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateSFD());
4517 }
4518
4519 PerfTagSetting perfTag;
4520 perfTag.Value = 0;
4521 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
4522 perfTag.CallType = m_singleTaskPhaseSupported ? CODECHAL_ENCODE_PERFTAG_CALL_SCALING_KERNEL : CODECHAL_ENCODE_PERFTAG_CALL_SFD_KERNEL;
4523 perfTag.PictureCodingType = m_pictureCodingType;
4524 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
4525
4526 // set function type and kernel state pointer
4527 auto encFunctionType = CODECHAL_MEDIA_STATE_STATIC_FRAME_DETECTION;
4528 auto kernelState = m_sfdKernelState;
4529
4530 // If Single Task Phase is not enabled, use BT count for the kernel state.
4531 if (m_firstTaskInPhase == true || !m_singleTaskPhaseSupported)
4532 {
4533 uint32_t dwMaxBtCount = m_singleTaskPhaseSupported ? m_maxBtCount : kernelState->KernelParams.iBTCount;
4534 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
4535 m_stateHeapInterface,
4536 dwMaxBtCount));
4537 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(dwMaxBtCount);
4538 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
4539 }
4540
4541 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
4542 m_stateHeapInterface,
4543 kernelState,
4544 false,
4545 0,
4546 false,
4547 m_storeData));
4548
4549 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
4550 MOS_ZeroMemory(&idParams, sizeof(idParams));
4551 idParams.pKernelState = kernelState;
4552 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
4553 m_stateHeapInterface,
4554 1,
4555 &idParams));
4556
4557 // set-up SFD Curbe
4558 CODECHAL_ENCODE_AVC_SFD_CURBE_PARAMS sfdcurbeParams;
4559 MOS_ZeroMemory(&sfdcurbeParams, sizeof(sfdcurbeParams));
4560 sfdcurbeParams.pKernelState = kernelState;
4561 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCurbeSFD(&sfdcurbeParams));
4562
4563 // dump DSH/Curbe/ISH
4564 CODECHAL_DEBUG_TOOL(
4565 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4566 encFunctionType,
4567 MHW_DSH_TYPE,
4568 kernelState));
4569
4570 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
4571 encFunctionType,
4572 kernelState));
4573
4574 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4575 encFunctionType,
4576 MHW_ISH_TYPE,
4577 kernelState));)
4578
4579 MOS_COMMAND_BUFFER cmdBuffer;
4580 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
4581
4582 SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams();
4583 sendKernelCmdsParams.EncFunctionType = encFunctionType;
4584 sendKernelCmdsParams.pKernelState = kernelState;
4585 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
4586
4587 // Add binding table
4588 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
4589 m_stateHeapInterface,
4590 kernelState));
4591
4592 if (!m_vdencBrcEnabled)
4593 {
4594 //Set VDENC image state command in VDENC buffer for CQP mode
4595 PMHW_VDBOX_AVC_IMG_PARAMS imageStateParams = CreateMhwVdboxAvcImgParams();
4596 CODECHAL_ENCODE_CHK_NULL_RETURN(imageStateParams);
4597
4598 imageStateParams->pEncodeAvcPicParams = m_avcPicParam;
4599 imageStateParams->pEncodeAvcSeqParams = m_avcSeqParam;
4600 imageStateParams->pEncodeAvcSliceParams = m_avcSliceParams;
4601 imageStateParams->wPicWidthInMb = m_picWidthInMb;
4602 imageStateParams->wPicHeightInMb = m_picHeightInMb;
4603 imageStateParams->wSlcHeightInMb = m_sliceHeight;
4604 imageStateParams->dwMaxVmvR = CodecHalAvcEncode_GetMaxVmvR(m_avcSeqParam->Level);
4605 imageStateParams->bVdencBRCEnabled = m_vdencBrcEnabled;
4606 imageStateParams->bVdencStreamInEnabled = m_vdencStreamInEnabled;
4607 imageStateParams->bCrePrefetchEnable = m_crePrefetchEnable;
4608
4609 if (m_avcSeqParam->EnableSliceLevelRateCtrl)
4610 {
4611 uint8_t qpY = m_avcPicParam->QpY;
4612 imageStateParams->dwMbSlcThresholdValue = CODECHAL_VDENC_AVC_MB_SLICE_TRHESHOLD;
4613 imageStateParams->dwVdencSliceMinusBytes = (m_pictureCodingType == I_TYPE) ? m_vdencSSCThrsTblI[qpY] : m_vdencSSCThrsTblP[qpY];
4614 }
4615
4616 imageStateParams->pVDEncModeCost = m_vdencModeCostTbl;
4617 imageStateParams->pVDEncHmeMvCost = m_vdencHmeMvCostTbl;
4618 imageStateParams->pVDEncMvCost = m_vdencMvCostTbl;
4619
4620 eStatus = m_hwInterface->AddVdencSfdImgBuffer(&m_resVdencSfdImageStateReadBuffer, imageStateParams);
4621 MOS_Delete(imageStateParams);
4622 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);
4623
4624 CODECHAL_DEBUG_TOOL(
4625 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateEncParam(
4626 0,
4627 nullptr));)
4628 }
4629
4630 // Add surface states
4631 CODECHAL_ENCODE_AVC_SFD_SURFACE_PARAMS sfdsurfaceParams;
4632 MOS_ZeroMemory(&sfdsurfaceParams, sizeof(sfdsurfaceParams));
4633 sfdsurfaceParams.dwDownscaledWidthInMb4x = m_downscaledWidthInMb4x;
4634 sfdsurfaceParams.dwDownscaledHeightInMb4x = m_downscaledFrameFieldHeightInMb4x;
4635 sfdsurfaceParams.psMeMvDataSurface = m_hmeKernel ? m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xMvDataBuffer) : &m_4xMeMvDataBuffer;
4636 sfdsurfaceParams.dwMeMvBottomFieldOffset = m_hmeKernel ? m_hmeKernel->Get4xMeMvBottomFieldOffset() : (uint32_t)m_meMvBottomFieldOffset;
4637 sfdsurfaceParams.psMeDistortionSurface = m_hmeKernel ? m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xDistortionBuffer) : &m_4xMeDistortionBuffer;
4638 sfdsurfaceParams.dwMeDistortionBottomFieldOffset = m_hmeKernel ? m_hmeKernel->GetDistortionBottomFieldOffset() : (uint32_t)m_meDistortionBottomFieldOffset;
4639 sfdsurfaceParams.bVdencActive = true;
4640 sfdsurfaceParams.bVdencBrcEnabled = m_vdencBrcEnabled;
4641 sfdsurfaceParams.presOutputBuffer = &m_resSfdOutputBuffer[m_currRecycledBufIdx];
4642 sfdsurfaceParams.pKernelState = kernelState;
4643 if (!m_vdencBrcEnabled)
4644 {
4645 sfdsurfaceParams.presVDEncImageStateInputBuffer = &m_resVdencSfdImageStateReadBuffer;
4646 sfdsurfaceParams.presVDEncImageStateOutputBuffer = &m_batchBufferForVdencImgStat[m_currRecycledBufIdx].OsResource;
4647 }
4648
4649 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendSFDSurfaces(
4650 &cmdBuffer,
4651 &sfdsurfaceParams));
4652
4653 // dump SSH
4654 CODECHAL_DEBUG_TOOL(
4655 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
4656 encFunctionType,
4657 MHW_SSH_TYPE,
4658 kernelState));)
4659
4660 HalOcaInterface::TraceMessage(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, __FUNCTION__, sizeof(__FUNCTION__));
4661 HalOcaInterface::OnDispatch(cmdBuffer, *m_osInterface, *m_miInterface, *m_renderEngineInterface->GetMmioRegisters());
4662
4663 MHW_MEDIA_OBJECT_PARAMS mediaObjectParams;
4664 MediaObjectInlineData mediaObjectInlineData;
4665 MOS_ZeroMemory(&mediaObjectParams, sizeof(mediaObjectParams));
4666 MOS_ZeroMemory(&mediaObjectInlineData, sizeof(mediaObjectInlineData));
4667 mediaObjectParams.pInlineData = &mediaObjectInlineData;
4668 mediaObjectParams.dwInlineDataSize = sizeof(mediaObjectInlineData);
4669 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObject(
4670 &cmdBuffer,
4671 nullptr,
4672 &mediaObjectParams));
4673
4674 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
4675
4676 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSubmitBlocks(
4677 m_stateHeapInterface,
4678 kernelState));
4679 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
4680 {
4681 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
4682 m_stateHeapInterface));
4683 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
4684 }
4685
4686 CODECHAL_DEBUG_TOOL(
4687 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
4688 &cmdBuffer,
4689 encFunctionType,
4690 nullptr));)
4691
4692 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, m_singleTaskPhaseSupported, m_lastTaskInPhase));
4693
4694 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
4695
4696 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
4697 {
4698 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
4699 m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw);
4700 m_lastTaskInPhase = false;
4701 }
4702
4703 return eStatus;
4704 }
4705
4706 MOS_STATUS CodechalVdencAvcState::SetupROIStreamIn(
4707 PCODEC_AVC_ENCODE_PIC_PARAMS picParams,
4708 PCODEC_AVC_ENCODE_SLICE_PARAMS slcParams,
4709 PMOS_RESOURCE vdencStreamIn)
4710 {
4711 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4712
4713 CODECHAL_ENCODE_FUNCTION_ENTER;
4714
4715 CODECHAL_ENCODE_CHK_NULL_RETURN(picParams);
4716 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencStreamIn);
4717
4718 MOS_LOCK_PARAMS lockFlags;
4719 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4720 lockFlags.WriteOnly = 1;
4721
4722 CODECHAL_VDENC_STREAMIN_STATE *pData = (CODECHAL_VDENC_STREAMIN_STATE *)m_osInterface->pfnLockResource(
4723 m_osInterface,
4724 vdencStreamIn,
4725 &lockFlags);
4726 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
4727
4728 uint32_t picSizeInMb = m_picHeightInMb * m_picWidthInMb;
4729 MOS_ZeroMemory(pData, picSizeInMb * CODECHAL_VDENC_STREAMIN_STATE::byteSize);
4730 m_vdencStreamInEnabled = true;
4731
4732 // legacy AVC ROI[n]->VDEnc ROI[n+1], ROI 1 has higher priority than 2 and so on
4733 if (picParams->bNativeROI)
4734 {
4735 for (int32_t i = picParams->NumROI - 1; i >= 0; i--)
4736 {
4737 int32_t dqpidx = -1;
4738 for (int32_t j = 0; j < m_maxNumNativeRoi; j++)
4739 {
4740 if (m_avcPicParam->ROIDistinctDeltaQp[j] == m_avcPicParam->ROI[i].PriorityLevelOrDQp)
4741 {
4742 dqpidx = j;
4743 break;
4744 }
4745 }
4746 CODECHAL_ENCODE_CHK_COND_RETURN(dqpidx == -1, "Max number of supported different dQP for ROI is %u", m_maxNumNativeRoi);
4747
4748 uint32_t curX, curY;
4749 for (curY = picParams->ROI[i].Top; curY < picParams->ROI[i].Bottom; curY++)
4750 {
4751 for (curX = picParams->ROI[i].Left; curX < picParams->ROI[i].Right; curX++)
4752 {
4753 (pData + (m_picWidthInMb * curY + curX))->DW0.RegionOfInterestRoiSelection = dqpidx + 1; //Shift ROI by 1
4754 }
4755 }
4756 }
4757 }
4758 else
4759 {
4760 int8_t qpPrimeY = (int8_t)CodecHal_Clip3(10, 51, picParams->QpY + slcParams->slice_qp_delta);
4761 for (int32_t i = 0; i < m_picHeightInMb * m_picWidthInMb; i++)
4762 {
4763 (pData + i)->DW1.Qpprimey = qpPrimeY;
4764 }
4765 for (int32_t i = picParams->NumROI - 1; i >= 0; i--)
4766 {
4767 uint32_t curX, curY;
4768 int8_t newQp = (int8_t)CodecHal_Clip3(10, 51, qpPrimeY + picParams->ROI[i].PriorityLevelOrDQp);
4769 for (curY = picParams->ROI[i].Top; curY < picParams->ROI[i].Bottom; curY++)
4770 {
4771 for (curX = picParams->ROI[i].Left; curX < picParams->ROI[i].Right; curX++)
4772 {
4773 (pData + (m_picWidthInMb * curY + curX))->DW1.Qpprimey = newQp;
4774 }
4775 }
4776 }
4777 }
4778
4779 m_osInterface->pfnUnlockResource(
4780 m_osInterface,
4781 vdencStreamIn);
4782
4783 return eStatus;
4784 }
4785
4786 bool CodechalVdencAvcState::ProcessRoiDeltaQp()
4787 {
4788 CODECHAL_ENCODE_FUNCTION_ENTER;
4789
4790 // Intialize ROIDistinctDeltaQp to be min expected delta qp, setting to -128
4791 // Check if forceQp is needed or not
4792 // forceQp is enabled if there are greater than 3 distinct delta qps or if the deltaqp is beyond range (-8, 7)
4793 for (auto k = 0; k < m_maxNumRoi; k++)
4794 {
4795 m_avcPicParam->ROIDistinctDeltaQp[k] = -128;
4796 }
4797
4798 int32_t numQp = 0;
4799 for (int32_t i = 0; i < m_avcPicParam->NumROI; i++)
4800 {
4801 bool dqpNew = true;
4802
4803 //Get distinct delta Qps among all ROI regions, index 0 having the lowest delta qp
4804 int32_t k = numQp - 1;
4805 for (; k >= 0; k--)
4806 {
4807 if (m_avcPicParam->ROI[i].PriorityLevelOrDQp == m_avcPicParam->ROIDistinctDeltaQp[k] ||
4808 m_avcPicParam->ROI[i].PriorityLevelOrDQp == 0)
4809 {
4810 dqpNew = false;
4811 break;
4812 }
4813 else if (m_avcPicParam->ROI[i].PriorityLevelOrDQp < m_avcPicParam->ROIDistinctDeltaQp[k])
4814 {
4815 continue;
4816 }
4817 else
4818 {
4819 break;
4820 }
4821 }
4822
4823 if (dqpNew)
4824 {
4825 for (int32_t j = numQp - 1; (j >= k + 1 && j >= 0); j--)
4826 {
4827 m_avcPicParam->ROIDistinctDeltaQp[j + 1] = m_avcPicParam->ROIDistinctDeltaQp[j];
4828 }
4829 m_avcPicParam->ROIDistinctDeltaQp[k + 1] = m_avcPicParam->ROI[i].PriorityLevelOrDQp;
4830 numQp++;
4831 }
4832 }
4833
4834 //Set the ROI DeltaQp to zero for remaining array elements
4835 for (auto k = numQp; k < m_maxNumRoi; k++)
4836 {
4837 m_avcPicParam->ROIDistinctDeltaQp[k] = 0;
4838 }
4839 m_avcPicParam->NumROIDistinctDeltaQp = (int8_t)numQp;
4840
4841 bool bIsNativeROI = (!(numQp > m_maxNumNativeRoi || m_avcPicParam->ROIDistinctDeltaQp[0] < -8 || m_avcPicParam->ROIDistinctDeltaQp[numQp - 1] > 7));
4842 bool bIsNativeROIAllowed = !m_vdencBrcEnabled || m_mbBrcEnabled; // BRC native ROI require MBBRC on
4843
4844 // return whether is native ROI or not
4845 return bIsNativeROI && bIsNativeROIAllowed;
4846 }
4847
4848
4849 MOS_STATUS CodechalVdencAvcState::SetupDirtyROI(PMOS_RESOURCE vdencStreamIn)
4850 {
4851 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4852
4853 CODECHAL_ENCODE_FUNCTION_ENTER;
4854
4855 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencStreamIn);
4856
4857 m_vdencStaticFrame = false;
4858 m_vdencStaticRegionPct = 0;
4859
4860 //Dirty ROI feature just for p frame
4861 if (m_pictureCodingType != P_TYPE)
4862 {
4863 return eStatus;
4864 }
4865
4866 //Dirty ROI feature just for the previous frame reference
4867 auto ppsIdx = m_avcSliceParams->pic_parameter_set_id;
4868 auto refPicListIdx = m_avcSliceParams[ppsIdx].RefPicList[0][0].FrameIdx;
4869 ENCODE_CHK_COND_RETURN(refPicListIdx >= CODEC_AVC_MAX_NUM_REF_FRAME, "refPicListIdx cannot bigger than 16.");
4870 auto refFrameListIdx = m_avcPicParam[ppsIdx].RefFrameList[refPicListIdx].FrameIdx;
4871 if (m_prevReconFrameIdx != refFrameListIdx)
4872 {
4873 return eStatus;
4874 }
4875
4876 auto picParams = m_avcPicParam;
4877 CODECHAL_ENCODE_CHK_NULL_RETURN(picParams);
4878
4879 // calculate the non-dirty percentage
4880 uint16_t staticArea = m_picHeightInMb * m_picWidthInMb;
4881
4882 for (int32_t i = picParams->NumDirtyROI - 1; i >= 0; i--)
4883 {
4884 staticArea -= (picParams->DirtyROI[i].Right - picParams->DirtyROI[i].Left) *
4885 (picParams->DirtyROI[i].Bottom - picParams->DirtyROI[i].Top);
4886 }
4887
4888 uint16_t staticRegionPct = (MOS_MAX(0, staticArea * 256)) / (m_picHeightInMb * m_picWidthInMb);
4889 m_vdencStaticFrame = staticRegionPct > (uint16_t)(CODECHAL_VDENC_AVC_STATIC_FRAME_ZMV_PERCENT * 256 / 100.0);
4890 m_vdencStaticRegionPct = staticRegionPct;
4891
4892 //BRC + MBQP => streamIn
4893 if (m_vdencBrcEnabled && m_mbBrcEnabled)
4894 {
4895 m_vdencStreamInEnabled = true;
4896
4897 MOS_LOCK_PARAMS lockFlags;
4898 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4899 lockFlags.WriteOnly = 1;
4900
4901 auto pData = (CODECHAL_VDENC_STREAMIN_STATE *)m_osInterface->pfnLockResource(
4902 m_osInterface,
4903 vdencStreamIn,
4904 &lockFlags);
4905 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
4906
4907 uint32_t picSizeInMb = m_picHeightInMb * m_picWidthInMb;
4908 MOS_ZeroMemory(pData, picSizeInMb * CODECHAL_VDENC_STREAMIN_STATE::byteSize);
4909
4910 for (int32_t i = picParams->NumDirtyROI - 1; i >= 0; i--)
4911 {
4912 for (uint32_t curY = picParams->DirtyROI[i].Top; curY < picParams->DirtyROI[i].Bottom; curY++)
4913 {
4914 for (uint32_t curX = picParams->DirtyROI[i].Left; curX < picParams->DirtyROI[i].Right; curX++)
4915 {
4916 (pData + (m_picWidthInMb * curY + curX))->DW0.RegionOfInterestRoiSelection = 1;
4917 }
4918 }
4919 }
4920
4921 m_osInterface->pfnUnlockResource(
4922 m_osInterface,
4923 vdencStreamIn);
4924 }
4925
4926 return eStatus;
4927 }
4928
4929 MOS_STATUS CodechalVdencAvcState::SetupBrcROIBuffer(PCODEC_AVC_ENCODE_PIC_PARAMS picParams, PMOS_RESOURCE brcRoiBuffer)
4930 {
4931 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4932
4933 CODECHAL_ENCODE_FUNCTION_ENTER;
4934
4935 CODECHAL_ENCODE_CHK_NULL_RETURN(picParams);
4936 CODECHAL_ENCODE_CHK_NULL_RETURN(brcRoiBuffer);
4937
4938 m_vdencStreamInEnabled = true;
4939
4940 MOS_LOCK_PARAMS lockFlags;
4941 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4942 lockFlags.WriteOnly = 1;
4943
4944 int8_t* pData = (int8_t*)m_osInterface->pfnLockResource(
4945 m_osInterface,
4946 &m_resVdencBrcRoiBuffer[m_currRecycledBufIdx],
4947 &lockFlags);
4948 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
4949
4950 uint32_t picSizeInMb = m_picHeightInMb * m_picWidthInMb;
4951 MOS_ZeroMemory(pData, picSizeInMb);
4952
4953
4954 for (int32_t i = picParams->NumROI - 1; i >= 0; i--)
4955 {
4956 int32_t dqpidx = -1;
4957 for (int32_t j = 0; j < m_maxNumBrcRoi; j++)
4958 {
4959 if (m_avcPicParam->ROIDistinctDeltaQp[j] == m_avcPicParam->ROI[i].PriorityLevelOrDQp)
4960 {
4961 dqpidx = j;
4962 break;
4963 }
4964 }
4965 CODECHAL_ENCODE_CHK_COND_RETURN(dqpidx == -1, "Max number of supported different dQP for ROI is %u", m_maxNumBrcRoi);
4966
4967 uint32_t curX, curY;
4968 for (curY = picParams->ROI[i].Top; curY < picParams->ROI[i].Bottom; curY++)
4969 {
4970 for (curX = picParams->ROI[i].Left; curX < picParams->ROI[i].Right; curX++)
4971 {
4972 *(pData + (m_picWidthInMb * curY + curX)) = dqpidx + 1; // Shift ROI by 1
4973 }
4974 }
4975 }
4976
4977 m_osInterface->pfnUnlockResource(
4978 m_osInterface,
4979 &m_resVdencBrcRoiBuffer[m_currRecycledBufIdx]);
4980 return MOS_STATUS_SUCCESS;
4981 }
4982
4983 MOS_STATUS CodechalVdencAvcState::SetupForceSkipStreamIn(PCODEC_AVC_ENCODE_PIC_PARAMS picParams, PMOS_RESOURCE vdencStreamIn)
4984 {
4985 int32_t i;
4986 uint32_t uiCurX, uiCurY;
4987 //PVDENC_STREAMIN_STATE_CMD pData;
4988 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4989
4990 uint32_t CleanHorizontalStartMB = (picParams->ForceSkip.Xpos >> 4);
4991 uint32_t CleanHorizontalEndMB = (picParams->ForceSkip.Xpos + picParams->ForceSkip.Width) >> 4;
4992 uint32_t CleanVerticalStartMB = (picParams->ForceSkip.Ypos >> 4);
4993 uint32_t CleanVerticalEndMB = (picParams->ForceSkip.Ypos + picParams->ForceSkip.Height) >> 4;
4994
4995 CODECHAL_ENCODE_FUNCTION_ENTER;
4996 CODECHAL_ENCODE_CHK_NULL_RETURN(picParams);
4997 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencStreamIn);
4998
4999 MOS_LOCK_PARAMS lockFlags;
5000 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
5001 lockFlags.WriteOnly = 1;
5002
5003 CODECHAL_VDENC_STREAMIN_STATE *pData = (CODECHAL_VDENC_STREAMIN_STATE*)m_osInterface->pfnLockResource(
5004 m_osInterface,
5005 vdencStreamIn,
5006 &lockFlags);
5007 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
5008 uint32_t picSizeInMb = m_picHeightInMb * m_picWidthInMb;
5009 MOS_ZeroMemory(pData, picSizeInMb * CODECHAL_VDENC_STREAMIN_STATE::byteSize);
5010
5011 for (uint16_t i = 0; i < m_picHeightInMb * m_picWidthInMb; i++)
5012 {
5013 uint32_t XPosInMbs = (i % m_picWidthInMb);
5014 uint32_t YPosInMbs = (i / m_picWidthInMb);
5015
5016 if (XPosInMbs < CleanHorizontalStartMB || YPosInMbs < CleanVerticalStartMB
5017 || XPosInMbs >= CleanHorizontalEndMB || YPosInMbs >= CleanVerticalEndMB)
5018 {
5019 pData->DW0.Forceskip = true;
5020 }
5021 else
5022 {
5023 pData->DW0.Forceskip = false;
5024 }
5025
5026 pData++;
5027 }
5028
5029 m_osInterface->pfnUnlockResource(
5030 m_osInterface,
5031 vdencStreamIn);
5032 return eStatus;
5033 }
5034
5035 MOS_STATUS CodechalVdencAvcState::SetupRegionBoosting(PMOS_RESOURCE vdencStreamIn, uint16_t boostIndex)
5036 {
5037 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5038
5039 CODECHAL_ENCODE_FUNCTION_ENTER;
5040 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencStreamIn);
5041
5042 MOS_LOCK_PARAMS lockFlags;
5043 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
5044 lockFlags.WriteOnly = 1;
5045
5046 CODECHAL_VDENC_STREAMIN_STATE *pData = (CODECHAL_VDENC_STREAMIN_STATE *)m_osInterface->pfnLockResource(
5047 m_osInterface,
5048 vdencStreamIn,
5049 &lockFlags);
5050 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
5051 uint32_t picSizeInMb = m_picHeightInMb * m_picWidthInMb;
5052 MOS_ZeroMemory(pData, picSizeInMb * CODECHAL_VDENC_STREAMIN_STATE::byteSize);
5053
5054 for (uint16_t y = 0; y < m_picHeightInMb; y++)
5055 {
5056 if ((y & 7) == boostIndex)
5057 {
5058 for (uint16_t x = 0; x < m_picWidthInMb; x++)
5059 {
5060 pData->DW0.RegionOfInterestRoiSelection = 1;
5061 pData++;
5062 }
5063 }
5064 else
5065 {
5066 pData += m_picWidthInMb;
5067 }
5068 }
5069
5070 m_osInterface->pfnUnlockResource(
5071 m_osInterface,
5072 vdencStreamIn);
5073
5074 return eStatus;
5075 }
5076
5077 MOS_STATUS CodechalVdencAvcState::StoreHucErrorStatus(
5078 MmioRegistersHuc* mmioRegisters,
5079 PMOS_COMMAND_BUFFER cmdBuffer,
5080 bool addToEncodeStatus)
5081 {
5082 CODECHAL_ENCODE_FUNCTION_ENTER;
5083
5084 CODECHAL_ENCODE_CHK_NULL_RETURN(mmioRegisters);
5085 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
5086
5087 // Write Huc Error Flag mask: DW1 (mask value)
5088 MHW_MI_STORE_DATA_PARAMS storeDataParams;
5089 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
5090 storeDataParams.pOsResource = &m_resHucErrorStatusBuffer;
5091 storeDataParams.dwResourceOffset = sizeof(uint32_t);
5092 storeDataParams.dwValue = CODECHAL_VDENC_AVC_BRC_HUC_STATUS_MEMORY_ACCESS_ERROR_MASK;
5093 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
5094
5095 // store HUC_STATUS register: DW0 (actual value)
5096 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
5097 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
5098 storeRegParams.presStoreBuffer = &m_resHucErrorStatusBuffer;
5099 storeRegParams.dwOffset = 0;
5100 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
5101 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &storeRegParams));
5102
5103 if (addToEncodeStatus)
5104 {
5105 EncodeStatusBuffer encodeStatusBuf = m_encodeStatusBuf;
5106
5107 uint32_t baseOffset =
5108 (encodeStatusBuf.wCurrIndex * encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
5109
5110 // store HUC_STATUS register
5111 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
5112 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
5113 storeRegParams.presStoreBuffer = &encodeStatusBuf.resStatusBuffer;
5114 storeRegParams.dwOffset = baseOffset + encodeStatusBuf.dwHuCStatusRegOffset;
5115 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
5116 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &storeRegParams));
5117 }
5118
5119 return MOS_STATUS_SUCCESS;
5120 }
5121
5122 MOS_STATUS CodechalVdencAvcState::HuCBrcInitReset()
5123 {
5124 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5125
5126 CODECHAL_ENCODE_FUNCTION_ENTER;
5127 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
5128 auto avcSeqParams = m_avcSeqParam;
5129
5130 MOS_COMMAND_BUFFER cmdBuffer;
5131 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
5132
5133 if (!m_singleTaskPhaseSupported || m_firstTaskInPhase)
5134 {
5135 MHW_MI_MMIOREGISTERS mmioRegister;
5136 bool validMmio = m_mfxInterface->ConvertToMiRegister(m_vdboxIndex, mmioRegister);
5137 // Send command buffer header at the beginning (OS dependent)
5138 bool bRequestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : 0;
5139 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(
5140 &cmdBuffer, bRequestFrameTracking, validMmio ? &mmioRegister: nullptr));
5141 }
5142 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void*)this, m_osInterface, m_miInterface, &cmdBuffer));
5143
5144 // load kernel from WOPCM into L2 storage RAM
5145 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
5146 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
5147 imemParams.dwKernelDescriptor = m_vdboxHucVdencBrcInitKernelDescriptor;
5148
5149 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
5150
5151 // pipe mode select
5152 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams = m_vdencInterface->CreateMhwVdboxPipeModeSelectParams();
5153 CODECHAL_ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
5154
5155 pipeModeSelectParams->Mode = m_mode;
5156 eStatus = m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams);
5157 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
5158 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);
5159
5160 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcInitReset());
5161
5162 // set HuC DMEM param
5163 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
5164 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
5165 dmemParams.presHucDataSource = &m_resVdencBrcInitDmemBuffer[m_currRecycledBufIdx];
5166 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencBrcInitDmemBufferSize, CODECHAL_CACHELINE_SIZE);
5167 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
5168 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
5169
5170 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
5171 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
5172 virtualAddrParams.regionParams[0].presRegion = &m_resVdencBrcHistoryBuffer;
5173 virtualAddrParams.regionParams[0].isWritable = true;
5174 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &virtualAddrParams));
5175
5176 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcDummyStreamObject(&cmdBuffer));
5177
5178 // Store HUC_STATUS2 register bit 6 before HUC_Start command
5179 // BitField: VALID IMEM LOADED - This bit will be cleared by HW at the end of a HUC workload
5180 // (HUC_Start command with last start bit set).
5181 CODECHAL_ENCODE_CHK_STATUS_RETURN(AvcVdencStoreHuCStatus2Register(m_hwInterface, &cmdBuffer));
5182
5183 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
5184
5185 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
5186
5187 // wait Huc completion (use HEVC bit for now)
5188 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
5189 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
5190 vdpipeFlushParams.Flags.bFlushHEVC = 1;
5191 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
5192 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdpipeFlushParams));
5193
5194 // Flush the engine to ensure memory written out
5195 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
5196 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
5197 flushDwParams.bVideoPipelineCacheInvalidate = true;
5198 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
5199
5200 // Collect HuC Init/Reset kernel performance data
5201 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void*)this, m_osInterface, m_miInterface, &cmdBuffer));
5202
5203 // Handle HUC_STATUS error codes
5204 CODECHAL_ENCODE_CHK_STATUS_RETURN(AddHucOutputRegistersHandling(mmioRegisters, &cmdBuffer, true));
5205
5206 if (!m_singleTaskPhaseSupported && (m_osInterface->bNoParsingAssistanceInKmd))
5207 {
5208 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
5209 }
5210
5211 if (!m_singleTaskPhaseSupported)
5212 {
5213 CODECHAL_DEBUG_TOOL(
5214 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
5215 &cmdBuffer,
5216 CODECHAL_NUM_MEDIA_STATES,
5217 "BRCINIT"));
5218 )
5219 }
5220 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
5221
5222 if (!m_singleTaskPhaseSupported)
5223 {
5224 bool renderingFlags = m_videoContextUsesNullHw;
5225 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
5226 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, renderingFlags));
5227 }
5228
5229 CODECHAL_DEBUG_TOOL(DumpHucBrcInit());
5230 m_firstTaskInPhase = false;
5231
5232 return eStatus;
5233 }
5234
5235 MOS_STATUS CodechalVdencAvcState::HuCBrcUpdate()
5236 {
5237 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5238
5239 CODECHAL_ENCODE_FUNCTION_ENTER;
5240
5241 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
5242 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
5243 auto avcSeqParams = m_avcSeqParam;
5244 auto avcPicParams = m_avcPicParam;
5245
5246 MOS_COMMAND_BUFFER cmdBuffer;
5247 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
5248
5249 if (!m_singleTaskPhaseSupported || (m_firstTaskInPhase && !m_brcInit))
5250 {
5251 MHW_MI_MMIOREGISTERS mmioRegister;
5252 bool validMmio = m_mfxInterface->ConvertToMiRegister(m_vdboxIndex, mmioRegister);
5253
5254 // Send command buffer header at the beginning (OS dependent)
5255 bool bRequestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : 0;
5256 CODECHAL_ENCODE_CHK_STATUS_RETURN(
5257 SendPrologWithFrameTracking(&cmdBuffer, bRequestFrameTracking, validMmio ? &mmioRegister : nullptr));
5258 }
5259 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectStartCmd((void*)this, m_osInterface, m_miInterface, &cmdBuffer));
5260
5261 if (m_brcInit || m_brcReset)
5262 {
5263 // Insert conditional batch buffer end for HuC valid IMEM loaded check
5264 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS miConditionalBatchBufferEndParams;
5265
5266 MOS_ZeroMemory(
5267 &miConditionalBatchBufferEndParams,
5268 sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
5269
5270 miConditionalBatchBufferEndParams.presSemaphoreBuffer =
5271 &m_resHucStatus2Buffer;
5272
5273 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
5274 &cmdBuffer,
5275 &miConditionalBatchBufferEndParams));
5276 }
5277
5278 // Update HuC DMEM data from other HW buffer if needed
5279 CODECHAL_ENCODE_CHK_STATUS_RETURN(AddMiStoreForHWOutputToHucDmem(&cmdBuffer));
5280
5281 //Set MFX/VDENC image state command in VDENC BRC buffer
5282 PMHW_VDBOX_AVC_IMG_PARAMS imageStateParams = CreateMhwVdboxAvcImgParams();
5283 CODECHAL_ENCODE_CHK_NULL_RETURN(imageStateParams);
5284 SetMfxAvcImgStateParams(*imageStateParams);
5285 imageStateParams->bVdencBRCEnabled = 1;
5286 imageStateParams->bSliceSizeStreamOutEnabled = m_sliceSizeStreamoutSupported;
5287
5288 if (avcSeqParams->EnableSliceLevelRateCtrl)
5289 {
5290 uint8_t qpY = m_avcPicParam->QpY;
5291 imageStateParams->dwMbSlcThresholdValue = CODECHAL_VDENC_AVC_MB_SLICE_TRHESHOLD;
5292 imageStateParams->dwVdencSliceMinusBytes = (m_pictureCodingType == I_TYPE) ? m_vdencSSCThrsTblI[qpY] : m_vdencSSCThrsTblP[qpY];
5293 }
5294
5295 if (m_minMaxQpControlEnabled)
5296 {
5297 // Convert range [1,51] to [10,51] for VDEnc due to HW limitation
5298 if (m_pictureCodingType == I_TYPE)
5299 {
5300 imageStateParams->pEncodeAvcPicParams->ucMaximumQP = MOS_MAX(m_iMaxQp, 10);
5301 imageStateParams->pEncodeAvcPicParams->ucMinimumQP = MOS_MAX(m_iMinQp, 10);
5302 }
5303 else if (m_pictureCodingType == P_TYPE)
5304 {
5305 imageStateParams->pEncodeAvcPicParams->ucMaximumQP = MOS_MAX(m_pMaxQp, 10);
5306 imageStateParams->pEncodeAvcPicParams->ucMinimumQP = MOS_MAX(m_pMinQp, 10);
5307 }
5308 }
5309
5310 eStatus = AddVdencBrcImgBuffer(&m_resVdencBrcImageStatesReadBuffer[m_currRecycledBufIdx],imageStateParams);
5311 MOS_Delete(imageStateParams);
5312 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);
5313
5314 CODECHAL_DEBUG_TOOL(
5315 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulatePakParam(
5316 nullptr,
5317 nullptr));
5318
5319 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateEncParam(
5320 0,
5321 nullptr));)
5322
5323 // load kernel from WOPCM into L2 storage RAM
5324 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
5325 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
5326 imemParams.dwKernelDescriptor = m_vdboxHucVdencBrcUpdateKernelDescriptor;
5327
5328 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
5329
5330 // pipe mode select
5331 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams = m_vdencInterface->CreateMhwVdboxPipeModeSelectParams();
5332 CODECHAL_ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
5333
5334 pipeModeSelectParams->Mode = m_mode;
5335 eStatus = m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams);
5336 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
5337 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);
5338
5339 // DMEM set
5340 SetDmemHuCBrcUpdate();
5341 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
5342 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
5343
5344 dmemParams.presHucDataSource = &(m_resVdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][m_currPass]);
5345 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencBrcUpdateDmemBufferSize, CODECHAL_CACHELINE_SIZE);
5346 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
5347
5348 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
5349
5350 // Set Const Data buffer
5351 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetConstDataHuCBrcUpdate());
5352
5353 // Copy data from m_pakStatsBufferFull to m_pakStatsBuffer if m_perMBStreamOutEnable is true
5354 if (m_perMBStreamOutEnable)
5355 {
5356 CodechalHucStreamoutParams hucStreamOutParams;
5357 MOS_ZeroMemory(&hucStreamOutParams, sizeof(hucStreamOutParams));
5358
5359 PMOS_RESOURCE sourceSurface = &m_pakStatsBufferFull[m_currRecycledBufIdx];
5360 PMOS_RESOURCE destSurface = &m_pakStatsBuffer;
5361 uint32_t copySize = m_vdencBrcPakStatsBufferSize;
5362 uint32_t sourceOffset = m_picWidthInMb * m_picHeightInMb * 64;
5363 uint32_t destOffset = 0;
5364
5365 // Ind Obj Addr command
5366 hucStreamOutParams.dataBuffer = sourceSurface;
5367 hucStreamOutParams.dataSize = copySize + sourceOffset;
5368 hucStreamOutParams.dataOffset = MOS_ALIGN_FLOOR(sourceOffset, CODECHAL_PAGE_SIZE);
5369 hucStreamOutParams.streamOutObjectBuffer = destSurface;
5370 hucStreamOutParams.streamOutObjectSize = copySize + destOffset;
5371 hucStreamOutParams.streamOutObjectOffset = MOS_ALIGN_FLOOR(destOffset, CODECHAL_PAGE_SIZE);
5372
5373 // Stream object params
5374 hucStreamOutParams.indStreamInLength = copySize;
5375 hucStreamOutParams.inputRelativeOffset = sourceOffset - hucStreamOutParams.dataOffset;
5376 hucStreamOutParams.outputRelativeOffset = destOffset - hucStreamOutParams.streamOutObjectOffset;
5377
5378 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->PerformHucStreamOut(
5379 &hucStreamOutParams,
5380 &cmdBuffer));
5381 }
5382
5383 // Add Virtual addr
5384 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
5385 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
5386 // Input regions
5387 virtualAddrParams.regionParams[1].presRegion = &m_vdencStatsBuffer;
5388 virtualAddrParams.regionParams[2].presRegion = &m_pakStatsBuffer;
5389 virtualAddrParams.regionParams[3].presRegion = &m_resVdencBrcImageStatesReadBuffer[m_currRecycledBufIdx];
5390 if (m_staticFrameDetectionInUse)
5391 {
5392 virtualAddrParams.regionParams[4].presRegion = &m_resSfdOutputBuffer[m_currRecycledBufIdx];
5393 }
5394 virtualAddrParams.regionParams[5].presRegion = &m_resVdencBrcConstDataBuffer[GetCurrConstDataBufIdx()];
5395
5396 if (m_nonNativeBrcRoiSupported && m_avcPicParam->NumROI && !m_avcPicParam->bNativeROI) // Only for BRC non-native ROI
5397 {
5398 if (m_osInterface->osCpInterface != nullptr && m_osInterface->osCpInterface->IsCpEnabled())
5399 {
5400 CODECHAL_ENCODE_ASSERTMESSAGE("Non-native BRC ROI doesn't supports in CP case");
5401 return MOS_STATUS_UNIMPLEMENTED;
5402 }
5403 virtualAddrParams.regionParams[8].presRegion = &m_resVdencBrcRoiBuffer[m_currRecycledBufIdx];
5404 virtualAddrParams.regionParams[9].presRegion = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
5405 }
5406
5407 // Output regions
5408 virtualAddrParams.regionParams[0].presRegion = &m_resVdencBrcHistoryBuffer;
5409 virtualAddrParams.regionParams[0].isWritable = true;
5410 virtualAddrParams.regionParams[6].presRegion = &m_batchBufferForVdencImgStat[0].OsResource;
5411 virtualAddrParams.regionParams[6].isWritable = true;
5412 if (m_nonNativeBrcRoiSupported && m_avcPicParam->NumROI && !m_avcPicParam->bNativeROI) // Only for BRC non-native ROI
5413 {
5414 if (m_osInterface->osCpInterface != nullptr && m_osInterface->osCpInterface->IsCpEnabled())
5415 {
5416 CODECHAL_ENCODE_ASSERTMESSAGE("Non-native BRC ROI doesn't supports in CP case");
5417 return MOS_STATUS_UNIMPLEMENTED;
5418 }
5419 virtualAddrParams.regionParams[10].presRegion = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
5420 virtualAddrParams.regionParams[10].isWritable = true;
5421 }
5422
5423 // region 15 always in clear
5424 virtualAddrParams.regionParams[15].presRegion = &m_resVdencBrcDbgBuffer;
5425
5426 if (m_sliceSizeStreamoutSupported)
5427 {
5428 virtualAddrParams.regionParams[7].presRegion = &m_pakSliceSizeStreamoutBuffer;
5429 }
5430
5431 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &virtualAddrParams));
5432
5433 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcDummyStreamObject(&cmdBuffer));
5434
5435 // Store HUC_STATUS2 register bit 6 before HUC_Start command
5436 // BitField: VALID IMEM LOADED - This bit will be cleared by HW at the end of a HUC workload
5437 // (HUC_Start command with last start bit set).
5438 CODECHAL_ENCODE_CHK_STATUS_RETURN(AvcVdencStoreHuCStatus2Register(m_hwInterface, &cmdBuffer));
5439
5440 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
5441
5442 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
5443
5444 // wait Huc completion (use HEVC bit for now)
5445 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdpipeFlushParams;
5446 MOS_ZeroMemory(&vdpipeFlushParams, sizeof(vdpipeFlushParams));
5447 vdpipeFlushParams.Flags.bFlushHEVC = 1;
5448 vdpipeFlushParams.Flags.bWaitDoneHEVC = 1;
5449 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdpipeFlushParams));
5450
5451 // Flush the engine to ensure memory written out
5452 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
5453 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
5454 flushDwParams.bVideoPipelineCacheInvalidate = true;
5455 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
5456
5457 // Write HUC_STATUS mask
5458 MHW_MI_STORE_DATA_PARAMS storeDataParams;
5459 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
5460 storeDataParams.pOsResource = &m_resPakMmioBuffer;
5461 storeDataParams.dwResourceOffset = sizeof(uint32_t);
5462 storeDataParams.dwValue = CODECHAL_VDENC_AVC_BRC_HUC_STATUS_REENCODE_MASK;
5463 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &storeDataParams));
5464
5465 // store HUC_STATUS register
5466 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
5467 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
5468 storeRegParams.presStoreBuffer = &m_resPakMmioBuffer;
5469 storeRegParams.dwOffset = 0;
5470 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
5471 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&cmdBuffer, &storeRegParams));
5472
5473 // Collect HuC Update kernel performance data
5474 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_perfProfiler->AddPerfCollectEndCmd((void*)this, m_osInterface, m_miInterface, &cmdBuffer));
5475
5476 // Handle HUC_STATUS error codes
5477 CODECHAL_ENCODE_CHK_STATUS_RETURN(AddHucOutputRegistersHandling(mmioRegisters, &cmdBuffer, true));
5478
5479 if ((!m_singleTaskPhaseSupported) && (m_osInterface->bNoParsingAssistanceInKmd))
5480 {
5481 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
5482 }
5483
5484 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(true));
5485
5486 if (!m_singleTaskPhaseSupported)
5487 {
5488 std::string pak_pass = "BRCUPDATE_PASS" + std::to_string(static_cast<uint32_t>(m_currPass));
5489 CODECHAL_DEBUG_TOOL(
5490 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
5491 &cmdBuffer,
5492 CODECHAL_NUM_MEDIA_STATES,
5493 pak_pass.data()));
5494 )
5495 }
5496
5497 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
5498
5499 if (!m_singleTaskPhaseSupported)
5500 {
5501 bool renderingFlags = m_videoContextUsesNullHw;
5502 HalOcaInterface::On1stLevelBBEnd(cmdBuffer, *m_osInterface);
5503 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, renderingFlags));
5504 }
5505
5506 return eStatus;
5507 }
5508
5509 MOS_STATUS CodechalVdencAvcState::LoadCosts(uint16_t pictureCodingType, uint8_t qp)
5510 {
5511 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5512
5513 CODECHAL_ENCODE_ASSERT(qp < CODEC_AVC_NUM_QP);
5514
5515 MOS_ZeroMemory(m_vdEncModeCost, 12);
5516 MOS_ZeroMemory(m_vdEncMvCost, 8);
5517 MOS_ZeroMemory(m_vdEncHmeMvCost, 8);
5518
5519 m_vdEncModeCost[LutMode_INTRA_NONPRED] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTRA_NONPRED][qp]), 0x6f);
5520 m_vdEncModeCost[LutMode_INTRA_16x16] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTRA_16x16][qp]), 0x8f);
5521 m_vdEncModeCost[LutMode_INTRA_8x8] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTRA_8x8][qp]), 0x8f);
5522 m_vdEncModeCost[LutMode_INTRA_4x4] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTRA_4x4][qp]), 0x8f);
5523
5524 if (pictureCodingType == P_TYPE)
5525 {
5526 // adjustment due to dirty ROI
5527 if (m_vdencStaticFrame)
5528 {
5529 uint32_t temp = AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTRA_16x16][qp];
5530 temp = (uint32_t)(temp * CODECHAL_VDENC_AVC_STATIC_FRAME_INTRACOSTSCLRatioP / 100.0 + 0.5);
5531 m_vdEncModeCost[LutMode_INTRA_16x16] = Map44LutValue(temp, 0x8f);
5532 }
5533 m_vdEncModeCost[LutMode_INTER_16x16] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTER_16x16][qp]), 0x8f);
5534 m_vdEncModeCost[LutMode_INTER_16x8] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTER_16x8][qp]), 0x8f);
5535 m_vdEncModeCost[LutMode_INTER_8x8q] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTER_8x8q][qp]), 0x6f);
5536 m_vdEncModeCost[LutMode_INTER_8x4q] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTER_8x4q][qp]), 0x6f);
5537 m_vdEncModeCost[LutMode_INTER_4x4q] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_INTER_4x4q][qp]), 0x6f);
5538 m_vdEncModeCost[LutMode_REF_ID] = Map44LutValue((uint32_t)(AVC_Mode_Cost[pictureCodingType - 1][LutMode_REF_ID][qp]), 0x6f);
5539
5540 CODECHAL_ENCODE_CHK_STATUS_RETURN(LoadMvCost(qp));
5541 CODECHAL_ENCODE_CHK_STATUS_RETURN(LoadHmeMvCost(qp));
5542 }
5543
5544 return eStatus;
5545 }
5546
5547 MOS_STATUS CodechalVdencAvcState::HuCBrcDummyStreamObject(PMOS_COMMAND_BUFFER cmdBuffer)
5548 {
5549 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5550
5551 CODECHAL_ENCODE_FUNCTION_ENTER;
5552
5553 // pass dummy buffer by Ind Obj Addr command
5554 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjParams;
5555 MOS_ZeroMemory(&indObjParams, sizeof(indObjParams));
5556 indObjParams.presDataBuffer = &m_resVdencBrcDbgBuffer;
5557 indObjParams.dwDataSize = 1;
5558 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucIndObjBaseAddrStateCmd(cmdBuffer, &indObjParams));
5559
5560 MHW_VDBOX_HUC_STREAM_OBJ_PARAMS streamObjParams;
5561 MOS_ZeroMemory(&streamObjParams, sizeof(streamObjParams));
5562 streamObjParams.dwIndStreamInLength = 1;
5563 streamObjParams.bHucProcessing = true;
5564 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStreamObjectCmd(cmdBuffer, &streamObjParams));
5565
5566 return eStatus;
5567 }
5568
5569 MOS_STATUS CodechalVdencAvcState::SetConstDataHuCBrcUpdate()
5570 {
5571 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5572
5573 CODECHAL_ENCODE_FUNCTION_ENTER;
5574
5575 // Set VDENC BRC constant buffer, data remains the same till BRC Init is called
5576 if (m_brcInit)
5577 {
5578 MOS_LOCK_PARAMS lockFlagsWriteOnly = {};
5579 for (uint8_t picType = 0; picType < CODECHAL_ENCODE_VDENC_BRC_CONST_BUFFER_NUM; picType++)
5580 {
5581 auto hucConstData = (uint8_t*)m_osInterface->pfnLockResource(
5582 m_osInterface, &m_resVdencBrcConstDataBuffer[picType], &lockFlagsWriteOnly);
5583 CODECHAL_ENCODE_CHK_NULL_RETURN(hucConstData);
5584
5585 FillHucConstData(hucConstData, picType);
5586 m_osInterface->pfnUnlockResource(m_osInterface, &m_resVdencBrcConstDataBuffer[picType]);
5587 }
5588 }
5589
5590 if (m_vdencStaticFrame)
5591 {
5592 MOS_LOCK_PARAMS lockFlagsWriteOnly = {};
5593 auto hucConstData = (PAVCVdencBRCCostantData)m_osInterface->pfnLockResource(
5594 m_osInterface, &m_resVdencBrcConstDataBuffer[GetCurrConstDataBufIdx()], &lockFlagsWriteOnly);
5595 CODECHAL_ENCODE_CHK_NULL_RETURN(hucConstData);
5596
5597 // adjustment due to dirty ROI
5598 for (int j = 0; j < 42; j++)
5599 {
5600 uint32_t temp = AVC_Mode_Cost[1][LutMode_INTRA_16x16][10 + j];
5601 temp = (uint32_t)(temp * CODECHAL_VDENC_AVC_STATIC_FRAME_INTRACOSTSCLRatioP / 100.0 + 0.5);
5602 hucConstData->UPD_P_Intra16x16[j] = Map44LutValue(temp, 0x8f);
5603 }
5604 m_osInterface->pfnUnlockResource(m_osInterface, &m_resVdencBrcConstDataBuffer[GetCurrConstDataBufIdx()]);
5605 }
5606
5607 return eStatus;
5608 }
5609
5610 MOS_STATUS CodechalVdencAvcState::InitializePicture(const EncoderParams &params)
5611 {
5612 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5613
5614 CODECHAL_ENCODE_FUNCTION_ENTER;
5615
5616 auto ppsidx = ((PCODEC_AVC_ENCODE_SLICE_PARAMS)(params.pSliceParams))->pic_parameter_set_id;
5617 auto spsidx = ((PCODEC_AVC_ENCODE_PIC_PARAMS)(params.pPicParams))->seq_parameter_set_id;
5618
5619 if (ppsidx >= CODEC_AVC_MAX_PPS_NUM || spsidx >= CODEC_AVC_MAX_SPS_NUM)
5620 {
5621 //should never happen
5622 return MOS_STATUS_UNKNOWN;
5623 }
5624
5625 m_madEnabled = params.bMADEnabled;
5626
5627 m_avcSeqParams[spsidx] = (PCODEC_AVC_ENCODE_SEQUENCE_PARAMS)(params.pSeqParams);
5628 m_avcPicParams[ppsidx] = (PCODEC_AVC_ENCODE_PIC_PARAMS)(params.pPicParams);
5629 m_avcQCParams = (PCODECHAL_ENCODE_AVC_QUALITY_CTRL_PARAMS)params.pAVCQCParams;
5630 m_avcRoundingParams = (PCODECHAL_ENCODE_AVC_ROUNDING_PARAMS)params.pAVCRoundingParams;
5631
5632 m_avcSeqParam = m_avcSeqParams[spsidx];
5633 m_avcPicParam = m_avcPicParams[ppsidx];
5634 m_avcVuiParams = (PCODECHAL_ENCODE_AVC_VUI_PARAMS)params.pVuiParams;
5635 m_avcSliceParams = (PCODEC_AVC_ENCODE_SLICE_PARAMS)params.pSliceParams;
5636 m_avcFeiPicParams = (CodecEncodeAvcFeiPicParams *)params.pFeiPicParams;
5637 m_avcIQMatrixParams = (PCODEC_AVC_IQ_MATRIX_PARAMS)params.pIQMatrixBuffer;
5638 m_avcIQWeightScaleLists = (PCODEC_AVC_ENCODE_IQ_WEIGTHSCALE_LISTS)params.pIQWeightScaleLists;
5639 m_nalUnitParams = params.ppNALUnitParams;
5640 m_sliceStructCaps = params.uiSlcStructCaps;
5641
5642 m_skipFrameFlag = m_avcPicParam->SkipFrameFlag;
5643
5644 // Picture and slice header packing flag from DDI caps
5645 m_acceleratorHeaderPackingCaps = params.bAcceleratorHeaderPackingCaps;
5646
5647 if (m_avcSliceParams->num_ref_idx_l0_active_minus1 >= CODEC_MAX_NUM_REF_FIELD || m_avcSliceParams->num_ref_idx_l1_active_minus1 >= CODEC_MAX_NUM_REF_FIELD)
5648 {
5649 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid slice parameters.");
5650 return MOS_STATUS_INVALID_PARAMETER;
5651 }
5652
5653 CODECHAL_ENCODE_CHK_NULL_RETURN(m_avcIQMatrixParams);
5654
5655 // so far this only applies to AVC
5656 // can move to MotionEstimationDisableCheck() if the logic applies to other codecs later
5657 if (m_avcQCParams)
5658 {
5659 // disable 4x/16x/32 HME if DDI wants to do so, enabling logic is not affected
5660 if (m_avcQCParams->HMEDisable)
5661 {
5662 m_hmeSupported = false;
5663 m_16xMeSupported = false;
5664 m_32xMeSupported = false;
5665 }
5666 else if (m_avcQCParams->SuperHMEDisable)
5667 {
5668 m_16xMeSupported = false;
5669 m_32xMeSupported = false;
5670 }
5671 else if (m_avcQCParams->UltraHMEDisable)
5672 {
5673 m_32xMeSupported = false;
5674 }
5675 }
5676
5677 // Sei for AVC
5678 if (params.pSeiData != nullptr)
5679 {
5680 if (params.pSeiData->dwSEIBufSize > 0) // sei is present
5681 {
5682 if (params.pSeiData->dwSEIBufSize > m_seiData.dwSEIBufSize)
5683 {
5684 // Destroy and re-allocate
5685 if (m_seiData.pSEIBuffer)
5686 {
5687 MOS_FreeMemory(m_seiData.pSEIBuffer);
5688 m_seiData.pSEIBuffer = nullptr;
5689 }
5690 m_seiData.dwSEIBufSize = params.pSeiData->dwSEIBufSize;
5691 m_seiData.pSEIBuffer = (uint8_t *)MOS_AllocAndZeroMemory(m_seiData.dwSEIBufSize);
5692 CODECHAL_ENCODE_CHK_NULL_RETURN(m_seiData.pSEIBuffer);
5693 }
5694
5695 m_seiParamBuffer = params.pSeiParamBuffer;
5696 m_seiDataOffset = params.dwSEIDataOffset;
5697 m_seiData.newSEIData = params.pSeiData->newSEIData;
5698 m_seiData.dwSEIDataSize = params.pSeiData->dwSEIDataSize;
5699
5700 eStatus = MOS_SecureMemcpy(m_seiData.pSEIBuffer,
5701 m_seiData.dwSEIDataSize,
5702 (m_seiParamBuffer + m_seiDataOffset),
5703 m_seiData.dwSEIDataSize);
5704 if (eStatus != MOS_STATUS_SUCCESS)
5705 {
5706 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
5707 return eStatus;
5708 }
5709 }
5710
5711 m_extraPictureStatesSize = m_seiData.dwSEIDataSize;
5712 }
5713
5714 m_deblockingEnabled = 0;
5715 for (uint32_t i = 0; i < m_numSlices; i++)
5716 {
5717 if (m_avcSliceParams[i].disable_deblocking_filter_idc != 1)
5718 {
5719 m_deblockingEnabled = 1;
5720 break;
5721 }
5722 }
5723
5724 if (m_newSeq)
5725 {
5726 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSequenceStructs());
5727 }
5728
5729 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetPictureStructs());
5730 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSliceStructs());
5731
5732 m_scalingEnabled = m_16xMeSupported;
5733 m_useRawForRef = m_userFlags.bUseRawPicForRef;
5734
5735 CODECHAL_DEBUG_TOOL(
5736 m_debugInterface->m_currPic = m_avcPicParam->CurrOriginalPic;
5737 m_debugInterface->m_bufferDumpFrameNum = m_storeData;
5738 m_debugInterface->m_frameType = m_pictureCodingType;
5739
5740 if (m_newSeq) {
5741 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSeqParams(
5742 m_avcSeqParam,
5743 m_avcIQMatrixParams));
5744
5745 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateConstParam());
5746 }
5747
5748 if (m_newVuiData) {
5749 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpVuiParams(
5750 m_avcVuiParams));
5751 }
5752
5753 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpPicParams(
5754 m_avcPicParam,
5755 m_avcIQMatrixParams));
5756
5757 for (uint32_t i = 0; i < m_numSlices; i++) {
5758 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpSliceParams(
5759 &m_avcSliceParams[i],
5760 m_avcPicParam));
5761
5762 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateDdiParam(
5763 m_avcSeqParam,
5764 m_avcPicParam,
5765 &m_avcSliceParams[i]));
5766 }
5767
5768 // BRC non-native ROI dump as HuC_region8[in], HuC_region9[in] and HuC_region10[out]
5769 if (m_avcPicParam->NumROI && (!m_vdencBrcEnabled || m_avcPicParam->bNativeROI) ||
5770 m_avcPicParam->NumDirtyROI || m_encodeParams.bMbQpDataEnabled)
5771 {
5772 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
5773 &(m_resVdencStreamInBuffer[m_currRecycledBufIdx]),
5774 CodechalDbgAttr::attrStreamIn,
5775 m_encodeParams.bMbQpDataEnabled ? "_MBQP" : "_ROI",
5776 m_picWidthInMb * m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
5777 0,
5778 CODECHAL_NUM_MEDIA_STATES));
5779 })
5780
5781 // Set min/max QP values in AVC State based on frame type if atleast one of them is non-zero
5782 if (m_avcPicParam->ucMinimumQP || m_avcPicParam->ucMaximumQP)
5783 {
5784 m_minMaxQpControlEnabled = true;
5785 if (m_avcPicParam->CodingType == I_TYPE)
5786 {
5787 m_iMaxQp = MOS_MIN(MOS_MAX(m_avcPicParam->ucMaximumQP, 1), 51); // Clamp to the max QP to [1, 51] . Zero is not used by our Kernel.
5788 m_iMinQp = MOS_MIN(MOS_MAX(m_avcPicParam->ucMinimumQP, 1), m_iMaxQp); // Clamp the min QP to [1, maxQP] to make sure minQP <= maxQP
5789 if (!m_pFrameMinMaxQpControl)
5790 {
5791 m_pMinQp = m_iMinQp;
5792 m_pMaxQp = m_iMaxQp;
5793 }
5794 }
5795 else if (m_avcPicParam->CodingType == P_TYPE)
5796 {
5797 m_pFrameMinMaxQpControl = true;
5798 m_pMaxQp = MOS_MIN(MOS_MAX(m_avcPicParam->ucMaximumQP, 1), 51); // Clamp to the max QP to [1, 51]. Zero is not used by our Kernel.
5799 m_pMinQp = MOS_MIN(MOS_MAX(m_avcPicParam->ucMinimumQP, 1), m_pMaxQp); // Clamp the min QP to [1, maxQP] to make sure minQP <= maxQP
5800 }
5801
5802 // Zero out the QP values, so we don't update the AVCState settings until new values are sent in MiscParamsRC
5803 m_avcPicParam->ucMinimumQP = 0;
5804 m_avcPicParam->ucMaximumQP = 0;
5805 }
5806
5807 if (m_codecFunction != CODECHAL_FUNCTION_ENC && !m_userFlags.bDisableAcceleratorHeaderPacking && m_acceleratorHeaderPackingCaps)
5808 {
5809 CODECHAL_ENCODE_AVC_PACK_PIC_HEADER_PARAMS packPicHeaderParams;
5810 packPicHeaderParams.pBsBuffer = &m_bsBuffer;
5811 packPicHeaderParams.pPicParams = m_avcPicParam;
5812 packPicHeaderParams.pSeqParams = m_avcSeqParam;
5813 packPicHeaderParams.pAvcVuiParams = m_avcVuiParams;
5814 packPicHeaderParams.pAvcIQMatrixParams = m_avcIQMatrixParams;
5815 packPicHeaderParams.ppNALUnitParams = m_nalUnitParams;
5816 packPicHeaderParams.pSeiData = &m_seiData;
5817 packPicHeaderParams.dwFrameHeight = m_frameHeight;
5818 packPicHeaderParams.dwOriFrameHeight = m_oriFrameHeight;
5819 packPicHeaderParams.wPictureCodingType = m_avcPicParam->CodingType;
5820 packPicHeaderParams.bNewSeq = m_newSeq;
5821 packPicHeaderParams.pbNewPPSHeader = &m_newPpsHeader;
5822 packPicHeaderParams.pbNewSeqHeader = &m_newSeqHeader;
5823
5824 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalAvcEncode_PackPictureHeader(&packPicHeaderParams));
5825 }
5826
5827 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetStatusReportParams(m_refList[m_currReconstructedPic.FrameIdx]));
5828
5829 m_bitstreamUpperBound = m_encodeParams.dwBitstreamSize;
5830 uint8_t sliceQP = m_avcPicParam->pic_init_qp_minus26 + 26 + m_avcSliceParams->slice_qp_delta;
5831
5832 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetSkipBiasAdjustment(sliceQP, m_avcSeqParam->GopRefDist, &m_skipBiasAdjustmentEnable));
5833
5834 // Determine if Trellis Quantization should be enabled
5835 MOS_ZeroMemory(&m_trellisQuantParams, sizeof(m_trellisQuantParams));
5836 // Trellis must remain switched off if it is explicitly disabled or picture is encoded with CAVLC
5837 if (!(m_trellis & trellisDisabled) && m_avcPicParam->entropy_coding_mode_flag)
5838 {
5839 if (m_trellis == trellisInternal)
5840 {
5841 CODECHAL_ENCODE_AVC_TQ_INPUT_PARAMS tqInputParams;
5842 tqInputParams.ucQP = sliceQP;
5843 tqInputParams.ucTargetUsage = m_avcSeqParam->TargetUsage;
5844 if (tqInputParams.ucTargetUsage >= NUM_VDENC_TARGET_USAGE_MODES)
5845 {
5846 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid sequence parameter.");
5847 return MOS_STATUS_INVALID_PARAMETER;
5848 }
5849 tqInputParams.wPictureCodingType = m_pictureCodingType;
5850 tqInputParams.bBrcEnabled = false;
5851 tqInputParams.bVdEncEnabled = true;
5852
5853 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetTrellisQuantization(
5854 &tqInputParams,
5855 &m_trellisQuantParams));
5856 }
5857 else if ((m_pictureCodingType == I_TYPE && (m_trellis & trellisEnabledI)) ||
5858 (m_pictureCodingType == P_TYPE && (m_trellis & trellisEnabledP)) ||
5859 (m_pictureCodingType == B_TYPE && (m_trellis & trellisEnabledB)))
5860 {
5861 m_trellisQuantParams.dwTqEnabled = true;
5862 m_trellisQuantParams.dwTqRounding = CODECHAL_ENCODE_AVC_DEFAULT_TRELLIS_QUANT_ROUNDING;
5863 }
5864 }
5865
5866 m_resVdencStatsBuffer = &(m_vdencStatsBuffer);
5867 m_resPakStatsBuffer = &(m_pakStatsBuffer);
5868
5869 // HW limitation, skip block count for B frame must be acquired in GetAvcVdencMBLevelStatusExt
5870 if (m_avcPicParam->StatusReportEnable.fields.BlockStats ||
5871 (m_avcPicParam->StatusReportEnable.fields.FrameStats && m_avcPicParam->CodingType == B_TYPE))
5872 {
5873 m_perMBStreamOutEnable = true;
5874 }
5875
5876 return eStatus;
5877 }
5878
5879 MOS_STATUS CodechalVdencAvcState::ExecuteKernelFunctions()
5880 {
5881 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5882
5883 CODECHAL_ENCODE_FUNCTION_ENTER;
5884 if (!m_cscDsState)
5885 {
5886 return eStatus;
5887 }
5888
5889 if (m_avcPicParam->bRepeatFrame)
5890 {
5891 m_cscDsState->ResetCscFlag();
5892 m_rawSurfaceToEnc = &m_prevRawSurface;
5893 m_rawSurfaceToPak = &m_prevRawSurface;
5894 }
5895
5896 // SHME and CSC require calling EU kernels
5897 if (!(m_16xMeSupported || m_cscDsState->RequireCsc()))
5898 {
5899 return eStatus;
5900 }
5901
5902 CODECHAL_DEBUG_TOOL(
5903 if (MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrFlatPhysCCS))
5904 {
5905 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBltOutput(
5906 m_rawSurfaceToEnc,
5907 CodechalDbgAttr::attrDecodeBltOutput))
5908 }
5909 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
5910 m_rawSurfaceToEnc,
5911 CodechalDbgAttr::attrEncodeRawInputSurface,
5912 "SrcSurf"))
5913 CODECHAL_DEBUG_TOOL(m_debugInterface->DumpSurfaceInfo(m_rawSurfaceToEnc, "RawSurfaceToEnc")));
5914
5915 m_firstTaskInPhase = true;
5916
5917 if (!m_avcPicParam->bRepeatFrame &&
5918 ((m_rawSurfaceToEnc->Format == Format_A8R8G8B8) || m_rawSurfaceToEnc->Format == Format_A8B8G8R8))
5919 {
5920 m_pollingSyncEnabled = m_avcPicParam->bEnableSync;
5921 m_syncMarkerOffset = m_rawSurfaceToEnc->dwPitch * m_avcPicParam->SyncMarkerY + m_avcPicParam->SyncMarkerX * 4;
5922 if ((m_avcPicParam->SyncMarkerSize >= 4) && (m_avcPicParam->pSyncMarkerValue != nullptr))
5923 {
5924 // driver only uses the lower 4 bytes as marker for now, as MI_SEMAPHORE_WAIT only supports 32-bit semaphore data.
5925 m_syncMarkerValue = *((uint32_t *)m_avcPicParam->pSyncMarkerValue);
5926 }
5927 else // application is not sending valid marker, use default value.
5928 {
5929 m_syncMarkerValue = 0x01234501;
5930 }
5931 }
5932 else
5933 {
5934 m_pollingSyncEnabled = false;
5935 }
5936 // Only CodechalVdencAvcStateXe_Hpm may call EnableMediaCopy and IsMediaCopyEnabled can be true.
5937 // However, CodechalEncodeInterfacesXe_Hpm does not has CscDs and m_cscDsState will always be nullptr.
5938 if (m_cscDsState->IsMediaCopyEnabled() && m_cscDsState->RequireCopyOnly())
5939 {
5940 // No condition can go into RawSurfaceMediaCopy function now
5941 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->RawSurfaceMediaCopy(m_rawSurfaceToEnc->Format));
5942 return eStatus;
5943 }
5944
5945 if (m_cscDsState->UseSfc() && m_cscDsState->RequireCsc())
5946 {
5947 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->CscUsingSfc(m_avcSeqParam->InputColorSpace));
5948 return eStatus;
5949 }
5950
5951 UpdateSSDSliceCount();
5952
5953 // Csc, Downscaling, and/or 10-bit to 8-bit conversion
5954 CodechalEncodeCscDs::KernelParams cscScalingKernelParams;
5955 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
5956 cscScalingKernelParams.bLastTaskInPhaseCSC = !m_scalingEnabled;
5957 cscScalingKernelParams.bLastTaskInPhase4xDS = false;
5958 cscScalingKernelParams.bLastTaskInPhase16xDS = !(m_32xMeSupported || m_pictureCodingType != I_TYPE);
5959 cscScalingKernelParams.bLastTaskInPhase32xDS = m_pictureCodingType == I_TYPE;
5960 cscScalingKernelParams.inputColorSpace = m_avcSeqParam->InputColorSpace;
5961
5962 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->KernelFunctions(&cscScalingKernelParams));
5963
5964 if (!m_16xMeSupported)
5965 {
5966 // for 4xME VDEnc used its internal 4x scaled surface, no more operation needed
5967 return eStatus;
5968 }
5969
5970 // Static frame detection
5971 // no need to call for I-frame
5972 m_staticFrameDetectionInUse = m_staticFrameDetectionEnable && m_hmeEnabled;
5973
5974 CODECHAL_ENCODE_CHK_STATUS_RETURN(ExecuteMeKernel());
5975
5976 // call SFD kernel after HME in same command buffer
5977 if (m_staticFrameDetectionInUse)
5978 {
5979 // Load VDEnc Costs
5980 CODECHAL_ENCODE_CHK_STATUS_RETURN(LoadCosts(m_avcPicParam->CodingType,
5981 m_avcPicParam->QpY + m_avcSliceParams->slice_qp_delta));
5982
5983 m_vdencHmeMvCostTbl = m_vdEncHmeMvCost;
5984 m_vdencModeCostTbl = m_vdEncModeCost;
5985 m_vdencMvCostTbl = m_vdEncMvCost;
5986
5987 m_lastTaskInPhase = true;
5988 CODECHAL_ENCODE_CHK_STATUS_RETURN(SFDKernel());
5989 }
5990
5991 CODECHAL_DEBUG_TOOL(
5992 CODECHAL_ME_OUTPUT_PARAMS meOutputParams;
5993
5994 MOS_ZeroMemory(&meOutputParams, sizeof(meOutputParams));
5995 meOutputParams.psMeMvBuffer = m_hmeKernel ? m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me16xMvDataBuffer) : &m_16xMeMvDataBuffer;
5996 meOutputParams.b16xMeInUse = true;
5997 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
5998 &meOutputParams.psMeMvBuffer->OsResource,
5999 CodechalDbgAttr::attrOutput,
6000 "MvData",
6001 meOutputParams.psMeMvBuffer->dwHeight * meOutputParams.psMeMvBuffer->dwPitch,
6002 m_hmeKernel ? m_hmeKernel->Get16xMeMvBottomFieldOffset() : (uint32_t)m_meMv16xBottomFieldOffset,
6003 CODECHAL_MEDIA_STATE_16X_ME));
6004
6005 meOutputParams.pResVdenStreamInBuffer = &(m_resVdencStreamInBuffer[m_currRecycledBufIdx]);
6006 meOutputParams.psMeMvBuffer = m_hmeKernel ? m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xMvDataBuffer) : &m_4xMeMvDataBuffer;
6007 meOutputParams.psMeDistortionBuffer = m_hmeKernel ? m_hmeKernel->GetSurface(CodechalKernelHme::SurfaceId::me4xDistortionBuffer) : &m_4xMeDistortionBuffer;
6008 meOutputParams.b16xMeInUse = false;
6009 meOutputParams.bVdencStreamInInUse = true;
6010 if (m_vdencStreamInEnabled) {
6011 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
6012 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
6013 CodechalDbgAttr::attrOutput,
6014 "MvData",
6015 m_picWidthInMb * m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
6016 0,
6017 CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN));
6018 }
6019
6020 if (m_staticFrameDetectionInUse) {
6021 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
6022 &m_resSfdOutputBuffer[m_currRecycledBufIdx],
6023 CodechalDbgAttr::attrOutput,
6024 "Out",
6025 SFD_OUTPUT_BUFFER_SIZE,
6026 0,
6027 CODECHAL_MEDIA_STATE_STATIC_FRAME_DETECTION));
6028 }
6029
6030 );
6031
6032 return eStatus;
6033 }
6034
6035 MOS_STATUS CodechalVdencAvcState::SendPrologWithFrameTracking(
6036 PMOS_COMMAND_BUFFER cmdBuffer,
6037 bool frameTracking,
6038 MHW_MI_MMIOREGISTERS *mmioRegister)
6039 {
6040 // Set flag bIsMdfLoad in remote gaming scenario to boost GPU frequency for low latency
6041 cmdBuffer->Attributes.bFrequencyBoost = (m_avcSeqParam->ScenarioInfo == ESCENARIO_REMOTEGAMING);
6042 return CodechalEncoderState::SendPrologWithFrameTracking(cmdBuffer, frameTracking, mmioRegister);
6043 }
6044
6045 MOS_STATUS CodechalVdencAvcState::ExecutePictureLevel()
6046 {
6047 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6048
6049 CODECHAL_ENCODE_FUNCTION_ENTER;
6050
6051 #if MHW_HWCMDPARSER_ENABLED
6052 char frameType = '\0';
6053 switch (m_avcPicParam->CodingType)
6054 {
6055 case I_TYPE:
6056 frameType = 'I';
6057 break;
6058 case P_TYPE:
6059 frameType = 'P';
6060 break;
6061 case B_TYPE:
6062 frameType = m_avcPicParam->RefPicFlag ? 'B' : 'b';
6063 break;
6064 }
6065
6066 auto instance = mhw::HwcmdParser::GetInstance();
6067 if (instance)
6068 {
6069 instance->Update(frameType, nullptr);
6070 }
6071 #endif
6072
6073 MHW_BATCH_BUFFER batchBuffer;
6074 MOS_ZeroMemory(&batchBuffer, sizeof(batchBuffer));
6075 batchBuffer.dwOffset = m_currPass * BRC_IMG_STATE_SIZE_PER_PASS;
6076 batchBuffer.bSecondLevel = true;
6077
6078 CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS encodePictureLevelParams;
6079 MOS_ZeroMemory(&encodePictureLevelParams, sizeof(encodePictureLevelParams));
6080 encodePictureLevelParams.psPreDeblockSurface = &m_reconSurface;
6081 encodePictureLevelParams.psPostDeblockSurface = &m_reconSurface;
6082 encodePictureLevelParams.bBrcEnabled = false;
6083 encodePictureLevelParams.pImgStateBatchBuffer = &batchBuffer;
6084
6085 bool suppressReconPic =
6086 ((!m_refList[m_currReconstructedPic.FrameIdx]->bUsedAsRef) && m_suppressReconPicSupported);
6087 encodePictureLevelParams.bDeblockerStreamOutEnable = 0;
6088 encodePictureLevelParams.bPreDeblockOutEnable = !m_deblockingEnabled && !suppressReconPic;
6089 encodePictureLevelParams.bPostDeblockOutEnable = m_deblockingEnabled && !suppressReconPic;
6090 encodePictureLevelParams.bPerMBStreamOutEnable = m_perMBStreamOutEnable;
6091 if (!m_staticFrameDetectionInUse)
6092 {
6093 CODECHAL_ENCODE_CHK_STATUS_RETURN(LoadCosts(m_avcPicParam->CodingType,
6094 m_avcPicParam->QpY + m_avcSliceParams->slice_qp_delta));
6095
6096 m_vdencHmeMvCostTbl = m_vdEncHmeMvCost;
6097 m_vdencModeCostTbl = m_vdEncModeCost;
6098 m_vdencMvCostTbl = m_vdEncMvCost;
6099 }
6100
6101 // VDEnc HuC BRC
6102 if (m_vdencBrcEnabled)
6103 {
6104 PerfTagSetting perfTag;
6105 perfTag.Value = 0;
6106 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
6107 perfTag.CallType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_INIT_RESET;
6108 perfTag.PictureCodingType = m_pictureCodingType;
6109 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
6110
6111 SetBufferToStorePakStatistics();
6112
6113 // Invoke BRC init/reset FW
6114 if (m_brcInit || m_brcReset)
6115 {
6116 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcInitReset());
6117 }
6118
6119 perfTag.CallType = m_currPass == 0 ? CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE : CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE_SECOND_PASS;
6120 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
6121
6122 // Invoke BRC update FW
6123 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcUpdate());
6124 m_brcInit = m_brcReset = false;
6125 }
6126
6127 PerfTagSetting perfTag;
6128 perfTag.Value = 0;
6129 perfTag.Mode = (uint16_t)m_mode & CODECHAL_ENCODE_MODE_BIT_MASK;
6130 perfTag.CallType = m_currPass == 0 ? CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE : CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE_SECOND_PASS;
6131 perfTag.PictureCodingType = m_pictureCodingType;
6132 m_osInterface->pfnSetPerfTag(m_osInterface, perfTag.Value);
6133
6134 MOS_COMMAND_BUFFER cmdBuffer;
6135 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
6136
6137 // PAK cmd buffer header insertion for 1) non STF 2) STF (except VDEnc BRC case inserted in HuC cmd buffer)
6138 if (!m_singleTaskPhaseSupported || (m_firstTaskInPhase && (!m_vdencBrcEnabled)))
6139 {
6140 bool requestFrameTracking = false;
6141
6142 m_hwInterface->m_numRequestedEuSlices = ((m_frameHeight * m_frameWidth) >= m_ssdResolutionThreshold &&
6143 m_targetUsage <= m_ssdTargetUsageThreshold)
6144 ? m_sliceShutdownRequestState
6145 : m_sliceShutdownDefaultState;
6146
6147 MHW_MI_MMIOREGISTERS mmioRegister;
6148 bool validMmio = m_mfxInterface->ConvertToMiRegister(m_vdboxIndex, mmioRegister);
6149
6150 // Send command buffer header at the beginning (OS dependent)
6151 // frame tracking tag is only added in the last command buffer header
6152 requestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : m_lastTaskInPhase;
6153 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking, validMmio ? &mmioRegister : nullptr));
6154
6155 m_hwInterface->m_numRequestedEuSlices = CODECHAL_SLICE_SHUTDOWN_DEFAULT;
6156 }
6157
6158 // Set TBL distribution to VMC = 240 for VDEnc performance
6159 if (MEDIA_IS_WA(m_waTable, WaTlbAllocationForAvcVdenc) &&
6160 (!m_singleTaskPhaseSupported || !m_currPass))
6161 {
6162 TLBAllocationParams tlbAllocationParams;
6163 tlbAllocationParams.presTlbMmioBuffer = &m_vdencTlbMmioBuffer;
6164 tlbAllocationParams.dwMmioMfxLra0Override = m_mmioMfxLra0Override;
6165 tlbAllocationParams.dwMmioMfxLra1Override = m_mmioMfxLra1Override;
6166 tlbAllocationParams.dwMmioMfxLra2Override = m_mmioMfxLra2Override;
6167 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetTLBAllocation(&cmdBuffer, &tlbAllocationParams));
6168 }
6169
6170 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS miConditionalBatchBufferEndParams;
6171 if (m_vdencBrcEnabled && !m_swBrcMode)
6172 {
6173 // Insert conditional batch buffer end for HuC valid IMEM loaded check
6174 MOS_ZeroMemory(&miConditionalBatchBufferEndParams, sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
6175 miConditionalBatchBufferEndParams.presSemaphoreBuffer = &m_resHucStatus2Buffer;
6176
6177 CODECHAL_ENCODE_CHK_STATUS_RETURN(
6178 m_miInterface->AddMiConditionalBatchBufferEndCmd(
6179 &cmdBuffer,
6180 &miConditionalBatchBufferEndParams));
6181 }
6182
6183 if (m_currPass)
6184 {
6185 if (m_inlineEncodeStatusUpdate && m_vdencBrcEnabled)
6186 {
6187 // inc dwStoreData conditionaly
6188 UpdateEncodeStatus(&cmdBuffer, false);
6189 }
6190
6191 // Insert conditional batch buffer end
6192 MOS_ZeroMemory(&miConditionalBatchBufferEndParams, sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
6193
6194 if (!m_vdencBrcEnabled)
6195 {
6196 miConditionalBatchBufferEndParams.presSemaphoreBuffer = &m_encodeStatusBuf.resStatusBuffer;
6197 miConditionalBatchBufferEndParams.dwOffset =
6198 (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) +
6199 m_encodeStatusBuf.dwImageStatusMaskOffset + (sizeof(uint32_t) * 2);
6200 }
6201 else
6202 {
6203 // VDENC uses HuC BRC FW generated semaphore for conditional 2nd pass
6204 miConditionalBatchBufferEndParams.presSemaphoreBuffer = &m_resPakMmioBuffer;
6205 }
6206 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
6207 &cmdBuffer,
6208 &miConditionalBatchBufferEndParams));
6209 }
6210
6211 if (!m_currPass && m_osInterface->bTagResourceSync)
6212 {
6213 // This is a short term solution to solve the sync tag issue: the sync tag write for PAK is inserted at the end of 2nd pass PAK BB
6214 // which may be skipped in multi-pass PAK enabled case. The idea here is to insert the previous frame's tag at the beginning
6215 // 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
6216 // as long as Dec/VP/Enc won't depend on this PAK so soon.
6217 PMOS_RESOURCE globalGpuContextSyncTagBuffer = nullptr;
6218 CODECHAL_HW_CHK_STATUS_RETURN(m_osInterface->pfnGetGpuStatusBufferResource(
6219 m_osInterface,
6220 globalGpuContextSyncTagBuffer));
6221 CODECHAL_ENCODE_CHK_NULL_RETURN(globalGpuContextSyncTagBuffer);
6222
6223 uint32_t value = m_osInterface->pfnGetGpuStatusTag(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
6224 MHW_MI_STORE_DATA_PARAMS params;
6225 params.pOsResource = globalGpuContextSyncTagBuffer;
6226 params.dwResourceOffset = m_osInterface->pfnGetGpuStatusTagOffset(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
6227 params.dwValue = (value > 0) ? (value - 1) : 0;
6228 CODECHAL_HW_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &params));
6229 }
6230
6231 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
6232
6233 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencControlStateCmd(&cmdBuffer));
6234
6235 // set MFX_SURFACE_STATE values
6236 // Ref surface
6237 MHW_VDBOX_SURFACE_PARAMS reconSurfaceParams;
6238 MOS_ZeroMemory(&reconSurfaceParams, sizeof(reconSurfaceParams));
6239 reconSurfaceParams.Mode = m_mode;
6240 reconSurfaceParams.ucSurfaceStateId = CODECHAL_MFX_REF_SURFACE_ID;
6241 reconSurfaceParams.psSurface = &m_reconSurface;
6242 CODECHAL_DEBUG_TOOL(m_debugInterface->DumpSurfaceInfo(&m_reconSurface, "ReconSurface"));
6243
6244 // Src surface
6245 MHW_VDBOX_SURFACE_PARAMS surfaceParams;
6246 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
6247 surfaceParams.Mode = m_mode;
6248 surfaceParams.ucSurfaceStateId = CODECHAL_MFX_SRC_SURFACE_ID;
6249 surfaceParams.psSurface = m_rawSurfaceToPak;
6250 surfaceParams.dwActualHeight = m_avcSeqParam->FrameHeight;
6251 surfaceParams.dwActualWidth = m_avcSeqParam->FrameWidth;
6252 surfaceParams.bDisplayFormatSwizzle = m_avcPicParam->bDisplayFormatSwizzle;
6253 surfaceParams.bColorSpaceSelection = (m_avcSeqParam->InputColorSpace == ECOLORSPACE_P709) ? 1 : 0;
6254 CODECHAL_DEBUG_TOOL(m_debugInterface->DumpSurfaceInfo(m_rawSurfaceToPak, "RawSurfaceToPak"));
6255
6256 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS pipeBufAddrParams;
6257 pipeBufAddrParams.pRawSurfParam = &surfaceParams;
6258 pipeBufAddrParams.pDecodedReconParam = &reconSurfaceParams;
6259 SetMfxPipeBufAddrStateParams(encodePictureLevelParams, pipeBufAddrParams);
6260 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
6261 m_mmcState->SetPipeBufAddr(&pipeBufAddrParams, &cmdBuffer);
6262
6263 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams = m_vdencInterface->CreateMhwVdboxPipeModeSelectParams();
6264 CODECHAL_ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
6265
6266 auto release_func = [&]()
6267 {
6268 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
6269 pipeModeSelectParams = nullptr;
6270 };
6271
6272 SetMfxPipeModeSelectParams(encodePictureLevelParams, *pipeModeSelectParams);
6273 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams), release_func);
6274
6275 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &reconSurfaceParams), release_func);
6276
6277 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &surfaceParams), release_func);
6278
6279 // 4xDS surface
6280 MHW_VDBOX_SURFACE_PARAMS dsSurfaceParams;
6281 MOS_ZeroMemory(&dsSurfaceParams, sizeof(dsSurfaceParams));
6282 dsSurfaceParams.Mode = m_mode;
6283 dsSurfaceParams.ucSurfaceStateId = CODECHAL_MFX_DSRECON_SURFACE_ID;
6284 dsSurfaceParams.psSurface = m_trackedBuf->Get4xDsReconSurface(CODEC_CURR_TRACKED_BUFFER);
6285 CODECHAL_DEBUG_TOOL(m_debugInterface->DumpSurfaceInfo(dsSurfaceParams.psSurface, "4xDsReconSurface"));
6286 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxSurfaceCmd(&cmdBuffer, &dsSurfaceParams), release_func);
6287 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams), release_func);
6288
6289 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
6290 SetMfxIndObjBaseAddrStateParams(indObjBaseAddrParams);
6291 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams), release_func);
6292
6293 MHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS bspBufBaseAddrParams;
6294 SetMfxBspBufBaseAddrStateParams(bspBufBaseAddrParams);
6295 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_mfxInterface->AddMfxBspBufBaseAddrCmd(&cmdBuffer, &bspBufBaseAddrParams), release_func);
6296
6297 if (m_avcPicParam->StatusReportEnable.fields.FrameStats)
6298 {
6299 pipeModeSelectParams->bFrameStatisticsStreamOutEnable = true;
6300 }
6301 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams), release_func);
6302 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
6303
6304 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencSrcSurfaceStateCmd(&cmdBuffer, &surfaceParams));
6305
6306 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencRefSurfaceStateCmd(&cmdBuffer, &reconSurfaceParams));
6307
6308 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencDsRefSurfaceStateCmd(&cmdBuffer, &dsSurfaceParams, 1));
6309
6310 // PerfMode is enabled only on BXT, KBL+, replace all 4x Ds refs with the 1st L0 ref
6311 if (m_vdencInterface->IsPerfModeSupported() && m_perfModeEnabled[m_avcSeqParam->TargetUsage] &&
6312 pipeBufAddrParams.dwNumRefIdxL0ActiveMinus1 == 0)
6313 {
6314 pipeBufAddrParams.dwNumRefIdxL0ActiveMinus1 = 1;
6315 pipeBufAddrParams.presVdencReferences[1] = nullptr;
6316 pipeBufAddrParams.presVdenc4xDsSurface[1] = pipeBufAddrParams.presVdenc4xDsSurface[0];
6317 }
6318
6319 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencPipeBufAddrCmd(&cmdBuffer, &pipeBufAddrParams));
6320
6321 MHW_VDBOX_VDENC_CQPT_STATE_PARAMS vdencCQPTStateParams;
6322 SetVdencCqptStateParams(vdencCQPTStateParams);
6323 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencConstQPStateCmd(&cmdBuffer, &vdencCQPTStateParams));
6324
6325 if (encodePictureLevelParams.bBrcEnabled && m_avcSeqParam->RateControlMethod != RATECONTROL_ICQ)
6326 {
6327 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(
6328 &cmdBuffer,
6329 encodePictureLevelParams.pImgStateBatchBuffer));
6330 }
6331 else
6332 {
6333 //Set MFX_AVC_IMG_STATE command
6334 PMHW_VDBOX_AVC_IMG_PARAMS imageStateParams = CreateMhwVdboxAvcImgParams();
6335 CODECHAL_ENCODE_CHK_NULL_RETURN(imageStateParams);
6336 SetMfxAvcImgStateParams(*imageStateParams);
6337
6338 PMHW_BATCH_BUFFER secondLevelBatchBufferUsed = nullptr;
6339
6340 // VDENC CQP case
6341 if (!m_vdencBrcEnabled)
6342 {
6343 // VDENC case uses multiple buffers for concurrency between SFD and VDENC
6344 secondLevelBatchBufferUsed = &(m_batchBufferForVdencImgStat[m_currRecycledBufIdx]);
6345
6346 if (!m_staticFrameDetectionInUse)
6347 {
6348 // CQP case, driver programs the 2nd Level BB
6349 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_LockBb(m_osInterface, secondLevelBatchBufferUsed));
6350
6351 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcImgCmd(nullptr, secondLevelBatchBufferUsed, imageStateParams));
6352
6353 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencAvcCostStateCmd(nullptr, secondLevelBatchBufferUsed, imageStateParams));
6354
6355 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencCmd3Cmd(nullptr, secondLevelBatchBufferUsed, imageStateParams));
6356
6357 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencImgStateCmd(nullptr, secondLevelBatchBufferUsed, imageStateParams));
6358
6359 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, secondLevelBatchBufferUsed));
6360
6361 #if MHW_HWCMDPARSER_ENABLED
6362 auto instance = mhw::HwcmdParser::GetInstance();
6363 if (instance)
6364 {
6365 instance->ParseCmdBuf(IGFX_UNKNOWN, (uint32_t *)(secondLevelBatchBufferUsed->pData),
6366 secondLevelBatchBufferUsed->iCurrent / sizeof(uint32_t));
6367 }
6368 #endif
6369
6370 CODECHAL_DEBUG_TOOL(
6371 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulatePakParam(
6372 nullptr,
6373 secondLevelBatchBufferUsed));
6374
6375 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateEncParam(
6376 0,
6377 nullptr));
6378
6379 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpEncodeImgStats(nullptr));)
6380
6381 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_UnlockBb(m_osInterface, secondLevelBatchBufferUsed, true));
6382 }
6383 else
6384 {
6385 // SFD enabled, SFD kernel updates VDENC IMG STATE
6386 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcImgCmd(&cmdBuffer, nullptr, imageStateParams));
6387 #if (_DEBUG || _RELEASE_INTERNAL)
6388 secondLevelBatchBufferUsed->iLastCurrent = CODECHAL_ENCODE_VDENC_IMG_STATE_CMD_SIZE + CODECHAL_ENCODE_MI_BATCH_BUFFER_END_CMD_SIZE;
6389 #endif
6390 CODECHAL_DEBUG_TOOL(
6391 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulatePakParam(
6392 &cmdBuffer,
6393 nullptr));
6394 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpEncodeImgStats(&cmdBuffer));)
6395 }
6396 }
6397 else
6398 {
6399 // current location to add cmds in 2nd level batch buffer
6400 m_batchBufferForVdencImgStat[0].iCurrent = 0;
6401 // reset starting location (offset) executing 2nd level batch buffer for each frame & each pass
6402 m_batchBufferForVdencImgStat[0].dwOffset = 0;
6403 secondLevelBatchBufferUsed = &(m_batchBufferForVdencImgStat[0]);
6404 }
6405 MOS_Delete(imageStateParams);
6406
6407 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &secondLevelBatchBufferUsed->OsResource, 0, true, 0);
6408
6409 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, secondLevelBatchBufferUsed));
6410
6411 CODECHAL_DEBUG_TOOL(
6412 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
6413 secondLevelBatchBufferUsed,
6414 CODECHAL_MEDIA_STATE_ENC_NORMAL,
6415 nullptr));)
6416 }
6417
6418 MHW_VDBOX_QM_PARAMS qmParams;
6419 MHW_VDBOX_QM_PARAMS fqmParams;
6420 SetMfxQmStateParams(qmParams, fqmParams);
6421 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxQmCmd(&cmdBuffer, &qmParams));
6422 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxFqmCmd(&cmdBuffer, &fqmParams));
6423
6424 if (m_pictureCodingType == B_TYPE)
6425 {
6426 // Add AVC Direct Mode command
6427 MHW_VDBOX_AVC_DIRECTMODE_PARAMS directmodeParams;
6428 MOS_ZeroMemory(&directmodeParams, sizeof(directmodeParams));
6429 directmodeParams.CurrPic = m_avcPicParam->CurrReconstructedPic;
6430 directmodeParams.isEncode = true;
6431 directmodeParams.uiUsedForReferenceFlags = 0xFFFFFFFF;
6432 directmodeParams.pAvcPicIdx = &(m_picIdx[0]);
6433 directmodeParams.avcRefList = (void**)m_refList;
6434 directmodeParams.bPicIdRemappingInUse = false;
6435 directmodeParams.bDisableDmvBuffers = true;
6436 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxAvcDirectmodeCmd(&cmdBuffer, &directmodeParams));
6437 }
6438
6439 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
6440
6441 return eStatus;
6442 }
6443
6444 MOS_STATUS CodechalVdencAvcState::ExecuteSliceLevel()
6445 {
6446 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6447
6448 CODECHAL_ENCODE_FUNCTION_ENTER;
6449
6450 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
6451
6452 auto cpInterface = m_hwInterface->GetCpInterface();
6453 auto avcSlcParams = m_avcSliceParams;
6454 auto avcPicParams = m_avcPicParams[avcSlcParams->pic_parameter_set_id];
6455 auto avcSeqParams = m_avcSeqParams[avcPicParams->seq_parameter_set_id];
6456 auto slcData = m_slcData;
6457
6458 // *** Temporarily commented until ULT fully support multislice ROW mode
6459
6460 // For use with the single task phase implementation
6461 //if (m_sliceStructCaps != CODECHAL_SLICE_STRUCT_ARBITRARYMBSLICE)
6462 //{
6463 // uint32_t numSlc = (m_frameFieldHeightInMb + m_sliceHeight - 1) / m_sliceHeight;
6464
6465 // if (numSlc != m_numSlices)
6466 // {
6467 // return MOS_STATUS_INVALID_PARAMETER;
6468 // }
6469 //}
6470
6471 bool useBatchBufferForPakSlices = false;
6472 if (m_singleTaskPhaseSupported && m_singleTaskPhaseSupportedInPak)
6473 {
6474 if (m_currPass == 0)
6475 {
6476 // The same buffer is used for all slices for all passes.
6477 uint32_t batchBufferForPakSlicesSize =
6478 (m_numPasses + 1) * m_numSlices * m_pakSliceSize;
6479 if (batchBufferForPakSlicesSize >
6480 (uint32_t)m_batchBufferForPakSlices[m_currRecycledBufIdx].iSize)
6481 {
6482 if (m_batchBufferForPakSlices[m_currRecycledBufIdx].iSize)
6483 {
6484 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReleaseBatchBufferForPakSlices(m_currRecycledBufIdx));
6485 }
6486
6487 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateBatchBufferForPakSlices(
6488 m_numSlices,
6489 m_numPasses,
6490 m_currRecycledBufIdx));
6491 }
6492 }
6493 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_LockBb(
6494 m_osInterface,
6495 &m_batchBufferForPakSlices[m_currRecycledBufIdx]));
6496 useBatchBufferForPakSlices = true;
6497 }
6498
6499 MOS_COMMAND_BUFFER cmdBuffer;
6500 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
6501
6502 if (m_osInterface->osCpInterface->IsCpEnabled())
6503 {
6504 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
6505 sliceInfoParam.bLastPass = (m_currPass == m_numPasses) ? true : false;
6506 CODECHAL_ENCODE_CHK_STATUS_RETURN(cpInterface->SetMfxProtectionState(false, &cmdBuffer, nullptr, &sliceInfoParam));
6507
6508 CODECHAL_ENCODE_CHK_STATUS_RETURN(cpInterface->UpdateParams(false));
6509 }
6510
6511 avcSlcParams = m_avcSliceParams;
6512
6513 CODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS packSlcHeaderParams = {};
6514 MHW_VDBOX_AVC_SLICE_STATE sliceState = {};
6515 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetCommonSliceState(packSlcHeaderParams, sliceState));
6516
6517 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipelineFlushParams;
6518 for (uint16_t slcCount = 0; slcCount < m_numSlices; slcCount++)
6519 {
6520 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSliceState(packSlcHeaderParams, sliceState, slcCount));
6521 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendSlice(&cmdBuffer, &sliceState));
6522
6523 // Report slice size
6524 if (m_presMetadataBuffer != nullptr)
6525 {
6526 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReportSliceSizeMetaData(m_presMetadataBuffer, &cmdBuffer, slcCount));
6527 }
6528
6529 // Add dumps for 2nd level batch buffer
6530 if (sliceState.bSingleTaskPhaseSupported && !sliceState.bVdencInUse)
6531 {
6532 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceState.pBatchBufferForPakSlices);
6533
6534 CODECHAL_DEBUG_TOOL(
6535 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->Dump2ndLvlBatch(
6536 sliceState.pBatchBufferForPakSlices,
6537 CODECHAL_MEDIA_STATE_ENC_NORMAL,
6538 nullptr));)
6539 }
6540
6541 // For SKL, only the 1st slice state should be programmed for VDENC
6542 if (!m_hwInterface->m_isVdencSuperSliceEnabled)
6543 {
6544 break;
6545 }
6546 else // For CNL slice state is programmed per Super slice
6547 {
6548 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
6549 // MfxPipeDone should be set for all super slices except the last super slice and should not be set for tail insertion.
6550 vdPipelineFlushParams.Flags.bWaitDoneMFX =
6551 (slcCount == (m_numSlices)-1) ? ((m_lastPicInStream || m_lastPicInSeq) ? 0 : 1) : 1;
6552 vdPipelineFlushParams.Flags.bWaitDoneVDENC = 1;
6553 vdPipelineFlushParams.Flags.bFlushVDENC = 1;
6554 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
6555
6556 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipelineFlushParams));
6557
6558 //Do not send MI_FLUSH for last Super slice now
6559 if (slcCount != ((m_numSlices)-1))
6560 {
6561 // Send MI_FLUSH for every Super slice
6562 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
6563 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
6564 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
6565 &cmdBuffer,
6566 &flushDwParams));
6567 }
6568 }
6569 }
6570
6571 if (useBatchBufferForPakSlices)
6572 {
6573 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_UnlockBb(
6574 m_osInterface,
6575 &m_batchBufferForPakSlices[m_currRecycledBufIdx],
6576 m_lastTaskInPhase));
6577 }
6578
6579 //Send VDENC WALKER cmd per every frame for SKL
6580 if (!m_hwInterface->m_isVdencSuperSliceEnabled)
6581 {
6582 PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS vdencWalkerStateParams = CreateMhwVdboxVdencWalkerStateParams();
6583 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencWalkerStateParams);
6584 vdencWalkerStateParams->Mode = CODECHAL_ENCODE_MODE_AVC;
6585 vdencWalkerStateParams->pAvcSeqParams = avcSeqParams;
6586 vdencWalkerStateParams->pAvcSlcParams = avcSlcParams;
6587 eStatus = m_vdencInterface->AddVdencWalkerStateCmd(&cmdBuffer, vdencWalkerStateParams);
6588 MOS_Delete(vdencWalkerStateParams);
6589 CODECHAL_ENCODE_CHK_STATUS_RETURN(eStatus);
6590
6591 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
6592 // MFXPipeDone should not be set for tail insertion
6593 vdPipelineFlushParams.Flags.bWaitDoneMFX =
6594 (m_lastPicInStream || m_lastPicInSeq) ? 0 : 1;
6595 vdPipelineFlushParams.Flags.bWaitDoneVDENC = 1;
6596 vdPipelineFlushParams.Flags.bFlushVDENC = 1;
6597 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
6598
6599 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipelineFlushParams));
6600 }
6601
6602 // Insert end of sequence/stream if set
6603 if (m_lastPicInStream || m_lastPicInSeq)
6604 {
6605 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
6606 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
6607 pakInsertObjectParams.bLastPicInSeq = m_lastPicInSeq;
6608 pakInsertObjectParams.bLastPicInStream = m_lastPicInStream;
6609 pakInsertObjectParams.dwBitSize = 32; // use dwBitSize for SrcDataEndingBitInclusion
6610 if (m_lastPicInSeq)
6611 {
6612 pakInsertObjectParams.dwLastPicInSeqData = (uint32_t)((1 << 16) | CODECHAL_ENCODE_AVC_NAL_UT_EOSEQ << 24);
6613 }
6614 if (m_lastPicInStream)
6615 {
6616 pakInsertObjectParams.dwLastPicInStreamData = (uint32_t)((1 << 16) | CODECHAL_ENCODE_AVC_NAL_UT_EOSTREAM << 24);
6617 }
6618 pakInsertObjectParams.bHeaderLengthExcludeFrmSize = true;
6619 if (pakInsertObjectParams.bEmulationByteBitsInsert)
6620 {
6621 //Does not matter here, but keeping for consistency
6622 CODECHAL_ENCODE_ASSERTMESSAGE("The emulation prevention bytes are not inserted by the app and are requested to be inserted by HW.");
6623 }
6624 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mfxInterface->AddMfxPakInsertObject(&cmdBuffer, nullptr, &pakInsertObjectParams));
6625 }
6626
6627 if (m_hwInterface->m_isVdencSuperSliceEnabled)
6628 {
6629 // Send MI_FLUSH with bVideoPipelineCacheInvalidate set to true for last Super slice
6630 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
6631 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
6632 flushDwParams.bVideoPipelineCacheInvalidate = true;
6633 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
6634 &cmdBuffer,
6635 &flushDwParams));
6636 }
6637
6638 // On-demand sync for VDEnc StreamIn surface and CSC surface
6639 if (m_cscDsState && m_currPass == 0)
6640 {
6641 if (m_cscDsState->RequireCsc())
6642 {
6643 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->WaitCscSurface(m_videoContext, true));
6644 }
6645
6646 if (m_16xMeSupported)
6647 {
6648 auto syncParams = g_cInitSyncParams;
6649 syncParams.GpuContext = m_videoContext;
6650 syncParams.bReadOnly = true;
6651 syncParams.presSyncResource = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
6652 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
6653 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
6654 }
6655 }
6656
6657 // Prepare MetaData
6658 if (m_presMetadataBuffer != nullptr)
6659 {
6660 CODECHAL_ENCODE_CHK_STATUS_RETURN(PrepareHWMetaData(m_presMetadataBuffer, &m_pakSliceSizeStreamoutBuffer, &cmdBuffer));
6661 }
6662
6663 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadMfcStatus(&cmdBuffer));
6664
6665 if (m_vdencBrcEnabled)
6666 {
6667 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreNumPasses(
6668 &(m_encodeStatusBuf),
6669 m_miInterface,
6670 &cmdBuffer,
6671 m_currPass));
6672 }
6673
6674 #if USE_CODECHAL_DEBUG_TOOL
6675 if (m_vdencBrcEnabled && m_enableFakeHrdSize)
6676 {
6677 CODECHAL_ENCODE_CHK_STATUS_RETURN(ModifyEncodedFrameSizeWithFakeHeaderSize( &cmdBuffer));
6678 }
6679 #endif
6680
6681 if (m_avcPicParam->StatusReportEnable.fields.FrameStats)
6682 {
6683 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetAvcVdencFrameLevelStatusExt(m_avcPicParam->StatusReportFeedbackNumber, &cmdBuffer));
6684 }
6685
6686 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
6687
6688 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
6689 {
6690 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
6691 }
6692
6693 std::string pak_pass = "PAK_PASS" + std::to_string(static_cast<uint32_t>(m_currPass));
6694 CODECHAL_DEBUG_TOOL(
6695 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
6696 &cmdBuffer,
6697 CODECHAL_NUM_MEDIA_STATES,
6698 pak_pass.data()));
6699
6700 //CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgReplaceAllCommands(
6701 // m_debugInterface,
6702 // &cmdBuffer));
6703 )
6704
6705 #if MHW_HWCMDPARSER_ENABLED
6706 auto instance = mhw::HwcmdParser::GetInstance();
6707 if (instance)
6708 {
6709 instance->ParseCmdBuf(IGFX_UNKNOWN, cmdBuffer.pCmdBase, cmdBuffer.iOffset / sizeof(uint32_t));
6710 }
6711 #endif
6712 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
6713
6714 bool renderingFlags = m_videoContextUsesNullHw;
6715
6716 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
6717 {
6718 // Restore TLB allocation
6719 if (MEDIA_IS_WA(m_waTable, WaTlbAllocationForAvcVdenc))
6720 {
6721 CODECHAL_ENCODE_CHK_STATUS_RETURN(RestoreTLBAllocation(&cmdBuffer, &m_vdencTlbMmioBuffer));
6722 }
6723
6724 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, renderingFlags));
6725
6726 CODECHAL_DEBUG_TOOL(
6727 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
6728 m_trackedBuf->Get4xDsReconSurface(CODEC_CURR_TRACKED_BUFFER),
6729 CodechalDbgAttr::attrReconstructedSurface,
6730 "4XScaling"))
6731 if (avcSlcParams->slice_type == SLICE_P || avcSlcParams->slice_type == SLICE_SP
6732 || avcSlcParams->slice_type == SLICE_B)
6733 {
6734 for (int i = 0; i < (avcSlcParams->num_ref_idx_l0_active_minus1 + 1); i++)
6735 {
6736 std::string refSurfName = "4XScaling_RefL0[" + std::to_string(static_cast<uint32_t>(i)) + "]";
6737 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
6738 (m_trackedBuf->Get4xDsReconSurface(m_refList[m_avcSliceParams->RefPicList[0][i].FrameIdx]->ucScalingIdx)),
6739 CodechalDbgAttr::attrReconstructedSurface,
6740 refSurfName.c_str()))
6741 }
6742 }
6743 if (MEDIA_IS_SKU(m_hwInterface->GetSkuTable(), FtrFlatPhysCCS)){
6744 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBltOutput(
6745 &m_reconSurface,
6746 CodechalDbgAttr::attrDecodeBltOutput))}
6747 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
6748 &m_reconSurface,
6749 CodechalDbgAttr::attrReconstructedSurface,
6750 "ReconSurf")))
6751
6752 CODECHAL_DEBUG_TOOL(
6753 if (m_mmcState) {
6754 m_mmcState->UpdateUserFeatureKey(&m_reconSurface);
6755 })
6756
6757 if (m_sliceSizeStreamoutSupported)
6758 {
6759 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
6760 &m_pakSliceSizeStreamoutBuffer,
6761 CodechalDbgAttr::attrOutput,
6762 "SliceSizeStreamout",
6763 CODECHAL_ENCODE_SLICESIZE_BUF_SIZE,
6764 0,
6765 CODECHAL_NUM_MEDIA_STATES)));
6766 }
6767
6768 if ((m_currPass == m_numPasses) &&
6769 m_signalEnc &&
6770 !Mos_ResourceIsNull(&m_resSyncObjectVideoContextInUse))
6771 {
6772 // Check if the signal obj count exceeds max value
6773 if (m_semaphoreObjCount == MOS_MIN(m_semaphoreMaxCount, MOS_MAX_OBJECT_SIGNALED))
6774 {
6775 auto syncParams = g_cInitSyncParams;
6776 syncParams.GpuContext = m_renderContext;
6777 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
6778
6779 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineWait(m_osInterface, &syncParams));
6780 m_semaphoreObjCount--;
6781 }
6782
6783 // signal semaphore
6784 auto syncParams = g_cInitSyncParams;
6785 syncParams.GpuContext = m_videoContext;
6786 syncParams.presSyncResource = &m_resSyncObjectVideoContextInUse;
6787
6788 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
6789 m_semaphoreObjCount++;
6790 }
6791 }
6792
6793 CODECHAL_DEBUG_TOOL(
6794 // here add the dump buffer for PAK statistics.
6795 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
6796 &m_pakStatsBufferFull[m_currRecycledBufIdx],
6797 CodechalDbgAttr::attrPakOutput,
6798 "MB and FrameLevel PAK staistics vdenc",
6799 m_vdencBrcPakStatsBufferSize + m_picWidthInMb * m_picHeightInMb * 64, //size
6800 0, //offset
6801 CODECHAL_MEDIA_STATE_16X_ME));
6802 )
6803
6804 if (m_vdencBrcEnabled)
6805 {
6806 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(false));
6807 CODECHAL_DEBUG_TOOL(DumpEncodeImgStats(nullptr));
6808 }
6809
6810 // Reset parameters for next PAK execution
6811 if (m_currPass == m_numPasses)
6812 {
6813 if (!m_singleTaskPhaseSupported)
6814 {
6815 m_osInterface->pfnResetPerfBufferID(m_osInterface);
6816 }
6817
6818 m_newPpsHeader = 0;
6819 m_newSeqHeader = 0;
6820 }
6821
6822 CODECHAL_DEBUG_TOOL(
6823 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateSliceStateParam(
6824 m_adaptiveRoundingInterEnable,
6825 &sliceState));
6826
6827 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpFrameParFile());)
6828
6829 return eStatus;
6830 }
6831
6832 MOS_STATUS CodechalVdencAvcState::AddVdencWalkerStateCmd(
6833 PMOS_COMMAND_BUFFER cmdBuffer)
6834 {
6835 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6836
6837 CODECHAL_ENCODE_FUNCTION_ENTER;
6838
6839 PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS vdencWalkerStateParams = CreateMhwVdboxVdencWalkerStateParams();
6840 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencWalkerStateParams);
6841 auto avcSlcParams = m_avcSliceParams;
6842 auto avcPicParams = m_avcPicParams[avcSlcParams->pic_parameter_set_id];
6843 auto avcSeqParams = m_avcSeqParams[avcPicParams->seq_parameter_set_id];
6844
6845 vdencWalkerStateParams->Mode = CODECHAL_ENCODE_MODE_AVC;
6846 vdencWalkerStateParams->pAvcSeqParams = avcSeqParams;
6847 vdencWalkerStateParams->pAvcSlcParams = m_avcSliceParams;
6848 eStatus = m_vdencInterface->AddVdencWalkerStateCmd(cmdBuffer, vdencWalkerStateParams);
6849
6850 MOS_Delete(vdencWalkerStateParams);
6851 return eStatus;
6852 }
6853
6854 MOS_STATUS CodechalVdencAvcState::UserFeatureKeyReport()
6855 {
6856 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6857
6858 CODECHAL_ENCODE_FUNCTION_ENTER;
6859
6860 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::UserFeatureKeyReport());
6861
6862 // AVC HME Reporting
6863 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_ME_IN_USE_ID, m_hmeSupported, m_osInterface->pOsContext);
6864
6865 // AVC SuperHME Reporting
6866 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_16xME_IN_USE_ID, m_16xMeSupported, m_osInterface->pOsContext);
6867
6868 // AVC UltraHME Reporting
6869 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_32xME_IN_USE_ID, m_32xMeSupported, m_osInterface->pOsContext);
6870
6871 // AVC RateControl Method Reporting
6872 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_RATECONTROL_METHOD_ID, m_avcSeqParam->RateControlMethod, m_osInterface->pOsContext);
6873
6874 // Static frame detection Enable Reporting
6875 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_STATIC_FRAME_DETECTION_ENABLE_ID, m_staticFrameDetectionEnable, m_osInterface->pOsContext);
6876
6877 // AVC FTQ Reporting
6878 #if (_DEBUG || _RELEASE_INTERNAL)
6879 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_AVC_FTQ_IN_USE_ID, m_ftqEnable, m_osInterface->pOsContext);
6880
6881 // VDENC Reporting
6882 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_VDENC_IN_USE_ID, true, m_osInterface->pOsContext);
6883 #endif // _DEBUG || _RELEASE_INTERNAL
6884
6885 return eStatus;
6886 }
6887
6888 MOS_STATUS CodechalVdencAvcState::AllocateResources()
6889 {
6890 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6891
6892 CODECHAL_ENCODE_FUNCTION_ENTER;
6893
6894 CodechalEncodeAvcBase::AllocateResources();
6895
6896 // Allocate SEI buffer
6897 m_seiData.pSEIBuffer = (uint8_t *)MOS_AllocAndZeroMemory(CODECHAL_ENCODE_AVC_SEI_BUFFER_SIZE);
6898 if (m_seiData.pSEIBuffer == nullptr)
6899 {
6900 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SEI Buffer.");
6901 eStatus = MOS_STATUS_UNKNOWN;
6902 return eStatus;
6903 }
6904 m_seiData.dwSEIBufSize = CODECHAL_ENCODE_AVC_SEI_BUFFER_SIZE;
6905
6906 // initiate allocation parameters and lock flags
6907 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
6908 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
6909 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
6910 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
6911 allocParamsForBufferLinear.Format = Format_Buffer;
6912
6913 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
6914 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
6915 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
6916 allocParamsForBuffer2D.TileType = MOS_TILE_LINEAR;
6917 allocParamsForBuffer2D.Format = Format_Buffer_2D;
6918
6919 // initiate allocation parameters
6920 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferNV12;
6921 MOS_ZeroMemory(&allocParamsForBufferNV12, sizeof(MOS_ALLOC_GFXRES_PARAMS));
6922 allocParamsForBufferNV12.Type = MOS_GFXRES_2D;
6923 allocParamsForBufferNV12.TileType = MOS_TILE_Y;
6924 allocParamsForBufferNV12.Format = Format_NV12;
6925
6926 MOS_LOCK_PARAMS lockFlagsWriteOnly;
6927 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
6928 lockFlagsWriteOnly.WriteOnly = 1;
6929
6930 if (m_pakEnabled)
6931 {
6932 // Allocate skip frame copy buffer
6933 allocParamsForBufferLinear.dwBytes = m_skipFrameBufferSize = CODECHAL_PAGE_SIZE;
6934 allocParamsForBufferLinear.pBufName = "Skip Frame Copy Buffer";
6935
6936 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
6937 m_osInterface,
6938 &allocParamsForBufferLinear,
6939 &m_resSkipFrameBuffer),
6940 "Failed to allocate Skip Frame Copy Buffer\n");
6941 }
6942
6943 if (m_staticFrameDetectionEnable)
6944 {
6945 // SFD output buffer
6946 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE, CODECHAL_CACHELINE_SIZE);
6947 allocParamsForBufferLinear.pBufName = "Static frame detection output buffer";
6948
6949 // VDENC case needs a set of buffers for concurrency between SFD and HuC BRC FW
6950 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
6951 {
6952 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
6953 m_osInterface,
6954 &allocParamsForBufferLinear,
6955 &m_resSfdOutputBuffer[i]),
6956 "Failed to allocate static frame detection output buffer\n");
6957 }
6958
6959 // SFD P-frame cost table buffer
6960 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE, CODECHAL_CACHELINE_SIZE);
6961 allocParamsForBufferLinear.pBufName = "SFD P-frame cost table buffer";
6962
6963 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
6964 m_osInterface,
6965 &allocParamsForBufferLinear,
6966 &m_resSfdCostTablePFrameBuffer),
6967 "Failed to allocate SFD P-frame cost table buffer\n");
6968
6969 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
6970 m_osInterface,
6971 &allocParamsForBufferLinear,
6972 &m_resSfdCostTableBFrameBuffer),
6973 "Failed to allocate SFD B-frame cost table buffer\n");
6974
6975 // copy SFD P-frame cost table
6976 uint8_t *data;
6977 if (nullptr == (data = (uint8_t *)m_osInterface->pfnLockResource(
6978 m_osInterface,
6979 &m_resSfdCostTablePFrameBuffer,
6980 &lockFlagsWriteOnly)))
6981 {
6982 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock SFD P-frame cost table Buffer.");
6983 eStatus = MOS_STATUS_UNKNOWN;
6984 return eStatus;
6985 }
6986 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(data,
6987 CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE * sizeof(uint8_t),
6988 m_codechalEncodeAvcSfdCostTablePFrame,
6989 CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE * sizeof(uint8_t)),
6990 "Failed to copy SFD P-frame cost table");
6991 m_osInterface->pfnUnlockResource(m_osInterface, &m_resSfdCostTablePFrameBuffer);
6992
6993 // copy SFD B-frame cost table
6994 if (nullptr == (data = (uint8_t *)m_osInterface->pfnLockResource(
6995 m_osInterface,
6996 &m_resSfdCostTableBFrameBuffer,
6997 &lockFlagsWriteOnly)))
6998 {
6999 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock SFD B-frame cost table Buffer.");
7000 eStatus = MOS_STATUS_UNKNOWN;
7001 return eStatus;
7002 }
7003 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(data,
7004 CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE * sizeof(uint8_t),
7005 m_codechalEncodeAvcSfdCostTableBFrame,
7006 CODECHAL_ENCODE_AVC_SFD_COST_TABLE_BUFFER_SIZE * sizeof(uint8_t)),
7007 "Failed to copy SFD B-frame cost table");
7008 m_osInterface->pfnUnlockResource(m_osInterface, &m_resSfdCostTableBFrameBuffer);
7009 }
7010
7011 // VDENC BRC buffer allocation
7012 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
7013 {
7014 // BRC update DMEM
7015 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_vdencBrcUpdateDmemBufferSize, CODECHAL_CACHELINE_SIZE);
7016 allocParamsForBufferLinear.pBufName = "VDENC BrcUpdate DmemBuffer";
7017 for (uint32_t j = 0; j < CODECHAL_VDENC_BRC_NUM_OF_PASSES; j++)
7018 {
7019 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7020 m_osInterface,
7021 &allocParamsForBufferLinear,
7022 &m_resVdencBrcUpdateDmemBuffer[i][j]);
7023 if (eStatus != MOS_STATUS_SUCCESS)
7024 {
7025 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC Update DMEM Buffer\n", __FUNCTION__);
7026 return eStatus;
7027 }
7028
7029 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(
7030 m_osInterface,
7031 &(m_resVdencBrcUpdateDmemBuffer[i][j]),
7032 &lockFlagsWriteOnly);
7033
7034 if (data == nullptr)
7035 {
7036 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock VDEnc BRC Update DMEM Buffer.");
7037 eStatus = MOS_STATUS_UNKNOWN;
7038 return eStatus;
7039 }
7040
7041 MOS_ZeroMemory(data, allocParamsForBufferLinear.dwBytes);
7042 m_osInterface->pfnUnlockResource(m_osInterface, &m_resVdencBrcUpdateDmemBuffer[i][j]);
7043 }
7044
7045 // BRC init/reset DMEM
7046 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_vdencBrcInitDmemBufferSize, CODECHAL_CACHELINE_SIZE);
7047 allocParamsForBufferLinear.pBufName = "VDENC BrcInit DmemBuffer";
7048 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7049 m_osInterface,
7050 &allocParamsForBufferLinear,
7051 &m_resVdencBrcInitDmemBuffer[i]);
7052 if (eStatus != MOS_STATUS_SUCCESS)
7053 {
7054 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC Init DMEM Buffer\n", __FUNCTION__);
7055 return eStatus;
7056 }
7057
7058 // VDENC IMG STATE read buffer
7059 allocParamsForBufferLinear.dwBytes = GetVdencBRCImgStateBufferSize();
7060 allocParamsForBufferLinear.pBufName = "VDENC BRC IMG State Read Buffer";
7061
7062 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7063 m_osInterface,
7064 &allocParamsForBufferLinear,
7065 &m_resVdencBrcImageStatesReadBuffer[i]);
7066
7067 if (eStatus != MOS_STATUS_SUCCESS)
7068 {
7069 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC IMG State Read Buffer\n", __FUNCTION__);
7070 return eStatus;
7071 }
7072 }
7073
7074 // Const Data buffer
7075 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(GetBRCCostantDataSize(), CODECHAL_PAGE_SIZE);
7076 allocParamsForBufferLinear.pBufName = "VDENC BRC Const Data Buffer";
7077 for (uint32_t i = 0; i < CODECHAL_ENCODE_VDENC_BRC_CONST_BUFFER_NUM; i++)
7078 {
7079 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
7080 m_osInterface,
7081 &allocParamsForBufferLinear,
7082 &m_resVdencBrcConstDataBuffer[i]),
7083 "%s: Failed to allocate 's'", __FUNCTION__, allocParamsForBufferLinear.pBufName);
7084
7085 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(
7086 m_osInterface,
7087 &m_resVdencBrcConstDataBuffer[i],
7088 &lockFlagsWriteOnly);
7089
7090 if (data == nullptr)
7091 {
7092 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock '%s'", allocParamsForBufferLinear.pBufName);
7093 eStatus = MOS_STATUS_UNKNOWN;
7094 return eStatus;
7095 }
7096
7097 MOS_ZeroMemory(data, allocParamsForBufferLinear.dwBytes);
7098 m_osInterface->pfnUnlockResource(m_osInterface, &m_resVdencBrcConstDataBuffer[i]);
7099 }
7100
7101 // BRC history buffer
7102 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(CODECHAL_VDENC_AVC_BRC_HISTORY_BUF_SIZE, CODECHAL_PAGE_SIZE);
7103 allocParamsForBufferLinear.pBufName = "VDENC BRC History Buffer";
7104
7105 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7106 m_osInterface,
7107 &allocParamsForBufferLinear,
7108 &m_resVdencBrcHistoryBuffer);
7109
7110 if (eStatus != MOS_STATUS_SUCCESS)
7111 {
7112 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC History Buffer\n", __FUNCTION__);
7113 return eStatus;
7114 }
7115
7116 if (!m_vdencBrcEnabled && m_staticFrameDetectionEnable)
7117 {
7118 // SFD VDENC IMG STATE input buffer (CQP mode)
7119 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_hwInterface->m_vdencBrcImgStateBufferSize, CODECHAL_PAGE_SIZE);
7120 allocParamsForBufferLinear.pBufName = "VDENC IMG SFD input Buffer";
7121
7122 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7123 m_osInterface,
7124 &allocParamsForBufferLinear,
7125 &m_resVdencSfdImageStateReadBuffer);
7126
7127 if (eStatus != MOS_STATUS_SUCCESS)
7128 {
7129 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC IMG SFD input Buffer\n", __FUNCTION__);
7130 return eStatus;
7131 }
7132 }
7133
7134 if (m_nonNativeBrcRoiSupported)
7135 {
7136 // BRC ROI Buffer
7137 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_picWidthInMb * m_picHeightInMb, MHW_CACHELINE_SIZE);
7138 allocParamsForBufferLinear.pBufName = "VDENC BRC ROI Buffer";
7139
7140 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
7141 {
7142 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
7143 m_osInterface,
7144 &allocParamsForBufferLinear,
7145 &m_resVdencBrcRoiBuffer[i]),
7146 "%s: Failed to allocate '%s'\n", __FUNCTION__, allocParamsForBufferLinear.pBufName);
7147
7148
7149 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(
7150 m_osInterface,
7151 &(m_resVdencBrcRoiBuffer[i]),
7152 &lockFlagsWriteOnly);
7153
7154 if (data == nullptr)
7155 {
7156 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to Lock '%s'.", allocParamsForBufferLinear.pBufName);
7157 eStatus = MOS_STATUS_UNKNOWN;
7158 return eStatus;
7159 }
7160 MOS_ZeroMemory(data, allocParamsForBufferLinear.dwBytes);
7161 m_osInterface->pfnUnlockResource(m_osInterface, &m_resVdencBrcRoiBuffer[i]);
7162 }
7163 }
7164
7165 // Debug buffer
7166 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(CODECHAL_VDENC_AVC_BRC_DEBUG_BUF_SIZE, CODECHAL_PAGE_SIZE);
7167 allocParamsForBufferLinear.pBufName = "VDENC BRC Debug Buffer";
7168
7169 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7170 m_osInterface,
7171 &allocParamsForBufferLinear,
7172 &m_resVdencBrcDbgBuffer);
7173
7174 if (eStatus != MOS_STATUS_SUCCESS)
7175 {
7176 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC Debug Buffer\n", __FUNCTION__);
7177 return eStatus;
7178 }
7179
7180 // VDENC Intra Row Store Scratch buffer
7181 // 1 cacheline per MB
7182 allocParamsForBufferLinear.dwBytes = m_picWidthInMb * CODECHAL_CACHELINE_SIZE;
7183 allocParamsForBufferLinear.pBufName = "VDENC Intra Row Store Scratch Buffer";
7184
7185 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7186 m_osInterface,
7187 &allocParamsForBufferLinear,
7188 &m_vdencIntraRowStoreScratchBuffer);
7189
7190 if (eStatus != MOS_STATUS_SUCCESS)
7191 {
7192 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate VDENC Intra Row Store Scratch Buffer.");
7193 return eStatus;
7194 }
7195
7196 // VDENC Statistics buffer
7197 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_vdencBrcStatsBufferSize, CODECHAL_PAGE_SIZE);
7198 allocParamsForBufferLinear.pBufName = "VDENC BRC Statistics Buffer";
7199
7200 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7201 m_osInterface,
7202 &allocParamsForBufferLinear,
7203 &m_vdencStatsBuffer);
7204
7205 if (eStatus != MOS_STATUS_SUCCESS)
7206 {
7207 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate BRC VDENC Statistics Buffer\n", __FUNCTION__);
7208 return eStatus;
7209 }
7210
7211 // PAK Statistics buffer
7212 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_vdencBrcPakStatsBufferSize, CODECHAL_PAGE_SIZE);
7213 allocParamsForBufferLinear.pBufName = "VDENC BRC PAK Statistics Buffer";
7214
7215 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7216 m_osInterface,
7217 &allocParamsForBufferLinear,
7218 &m_pakStatsBuffer);
7219
7220 if (eStatus != MOS_STATUS_SUCCESS)
7221 {
7222 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC PAK Statistics Buffer\n", __FUNCTION__);
7223 return eStatus;
7224 }
7225
7226 // Here allocate the buffer for MB+FrameLevel PAK statistics.
7227 uint32_t size = m_vdencBrcPakStatsBufferSize + m_picWidthInMb*m_picHeightInMb*64;
7228 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(size, CODECHAL_PAGE_SIZE);
7229 allocParamsForBufferLinear.pBufName = "VDENC BRC PAK Full Statistics Buffer";
7230
7231 if (m_osInterface->osCpInterface == nullptr || !m_osInterface->osCpInterface->IsCpEnabled())
7232 {
7233 allocParamsForBufferLinear.dwMemType = MOS_MEMPOOL_SYSTEMMEMORY;
7234 allocParamsForBufferLinear.Flags.bCacheable = true;
7235 }
7236
7237 for (uint32_t i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
7238 {
7239 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7240 m_osInterface,
7241 &allocParamsForBufferLinear,
7242 &m_pakStatsBufferFull[i]);
7243
7244 if (eStatus != MOS_STATUS_SUCCESS)
7245 {
7246 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC BRC PerMB and framel level PAK Statistics Buffer\n", __FUNCTION__);
7247 return eStatus;
7248 }
7249 }
7250
7251 // Buffer to store VDEnc TLB MMIO values (registers MFX_LRA_0/1/2)
7252 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(3 * sizeof(uint32_t), CODECHAL_PAGE_SIZE);
7253 allocParamsForBufferLinear.pBufName = "VDENC TLB MMIO Buffer";
7254
7255 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
7256 m_osInterface,
7257 &allocParamsForBufferLinear,
7258 &m_vdencTlbMmioBuffer);
7259
7260 if (eStatus != MOS_STATUS_SUCCESS)
7261 {
7262 CODECHAL_ENCODE_ASSERTMESSAGE("%s: Failed to allocate VDENC TLB MMIO Buffer\n", __FUNCTION__);
7263 return eStatus;
7264 }
7265
7266 return eStatus;
7267 }
7268
7269 MOS_STATUS CodechalVdencAvcState::Initialize()
7270 {
7271 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7272 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeAvcBase::Initialize());
7273
7274 return eStatus;
7275 }
7276
7277 MOS_STATUS CodechalVdencAvcState::InitKernelStateMe()
7278 {
7279 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7280
7281 CODECHAL_ENCODE_FUNCTION_ENTER;
7282
7283 uint8_t *kernelBinary;
7284 uint32_t kernelSize;
7285
7286 uint32_t kuid = m_useCommonKernel ? m_kuidCommon : m_kuid;
7287 MOS_STATUS status = CodecHalGetKernelBinaryAndSize(m_kernelBase, kuid, &kernelBinary, &kernelSize);
7288 CODECHAL_ENCODE_CHK_STATUS_RETURN(status);
7289
7290 for (auto krnStateIdx = 0; krnStateIdx < 2; krnStateIdx++)
7291 {
7292 CODECHAL_KERNEL_HEADER currKrnHeader;
7293 auto kernelStatePtr = &m_meKernelStates[krnStateIdx];
7294
7295 auto EncOperation = (krnStateIdx > 0) ? VDENC_ME : ENC_ME;
7296 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
7297 kernelBinary,
7298 EncOperation,
7299 (EncOperation == VDENC_ME) ? 0 : krnStateIdx,
7300 &currKrnHeader,
7301 &kernelSize));
7302
7303 kernelStatePtr->KernelParams.iBTCount = CODECHAL_ENCODE_AVC_ME_NUM_SURFACES;
7304 kernelStatePtr->KernelParams.iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
7305 kernelStatePtr->KernelParams.iCurbeLength = sizeof(CODECHAL_ENCODE_AVC_ME_CURBE);
7306 kernelStatePtr->KernelParams.iBlockWidth = CODECHAL_MACROBLOCK_WIDTH;
7307 kernelStatePtr->KernelParams.iBlockHeight = CODECHAL_MACROBLOCK_HEIGHT;
7308 kernelStatePtr->KernelParams.iIdCount = 1;
7309
7310 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
7311 kernelStatePtr->KernelParams.pBinary =
7312 kernelBinary +
7313 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
7314 kernelStatePtr->KernelParams.iSize = kernelSize;
7315 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
7316 m_stateHeapInterface,
7317 kernelStatePtr->KernelParams.iBTCount,
7318 &kernelStatePtr->dwSshSize,
7319 &kernelStatePtr->dwBindingTableSize));
7320
7321 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
7322
7323 if (m_noMeKernelForPFrame)
7324 {
7325 m_meKernelStates[1] = m_meKernelStates[0];
7326 break;
7327 }
7328 }
7329
7330 // Until a better way can be found, maintain old binding table structures
7331 auto bindingTable = &m_meBindingTable;
7332 bindingTable->dwMEMVDataSurface = CODECHAL_ENCODE_AVC_ME_MV_DATA_SURFACE;
7333 bindingTable->dw16xMEMVDataSurface = CODECHAL_ENCODE_AVC_16xME_MV_DATA_SURFACE;
7334 bindingTable->dw32xMEMVDataSurface = CODECHAL_ENCODE_AVC_32xME_MV_DATA_SURFACE;
7335 bindingTable->dwMEDist = CODECHAL_ENCODE_AVC_ME_DISTORTION_SURFACE;
7336 bindingTable->dwMEBRCDist = CODECHAL_ENCODE_AVC_ME_BRC_DISTORTION;
7337 bindingTable->dwMECurrForFwdRef = CODECHAL_ENCODE_AVC_ME_CURR_FOR_FWD_REF;
7338 bindingTable->dwMEFwdRefPicIdx[0] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX0;
7339 bindingTable->dwMEFwdRefPicIdx[1] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX1;
7340 bindingTable->dwMEFwdRefPicIdx[2] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX2;
7341 bindingTable->dwMEFwdRefPicIdx[3] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX3;
7342 bindingTable->dwMEFwdRefPicIdx[4] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX4;
7343 bindingTable->dwMEFwdRefPicIdx[5] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX5;
7344 bindingTable->dwMEFwdRefPicIdx[6] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX6;
7345 bindingTable->dwMEFwdRefPicIdx[7] = CODECHAL_ENCODE_AVC_ME_FWD_REF_IDX7;
7346 bindingTable->dwMECurrForBwdRef = CODECHAL_ENCODE_AVC_ME_CURR_FOR_BWD_REF;
7347 bindingTable->dwMEBwdRefPicIdx[0] = CODECHAL_ENCODE_AVC_ME_BWD_REF_IDX0;
7348 bindingTable->dwMEBwdRefPicIdx[1] = CODECHAL_ENCODE_AVC_ME_BWD_REF_IDX1;
7349 bindingTable->dwVdencStreamInSurface = CODECHAL_ENCODE_AVC_ME_VDENC_STREAMIN;
7350
7351 return eStatus;
7352 }
7353
7354 MOS_STATUS CodechalVdencAvcState::SetCurbeMe(MeCurbeParams *params)
7355 {
7356 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7357
7358 CODECHAL_ENCODE_FUNCTION_ENTER;
7359 CODECHAL_ENCODE_ASSERT(m_avcSeqParam->TargetUsage <= NUM_TARGET_USAGE_MODES);
7360
7361 auto slcParams = m_avcSliceParams;
7362 auto framePicture = CodecHal_PictureIsFrame(m_avcPicParam->CurrOriginalPic);
7363 auto qpPrimeY =
7364 (m_avcPicParam->pic_init_qp_minus26 + 26) +
7365 m_avcSliceParams->slice_qp_delta;
7366
7367 auto mvShiftFactor = 0;
7368 auto prevMvReadPosFactor = 0;
7369 bool useMvFromPrevStep, writeDistortions;
7370 uint32_t scaleFactor;
7371
7372 switch (params->hmeLvl)
7373 {
7374 case HME_LEVEL_32x:
7375 useMvFromPrevStep = CODECHAL_ENCODE_AVC_HME_FIRST_STEP;
7376 writeDistortions = false;
7377 scaleFactor = SCALE_FACTOR_32x;
7378 mvShiftFactor = CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_32x;
7379 break;
7380 case HME_LEVEL_16x:
7381 useMvFromPrevStep = (m_32xMeEnabled) ? CODECHAL_ENCODE_AVC_HME_FOLLOWING_STEP : CODECHAL_ENCODE_AVC_HME_FIRST_STEP;
7382 writeDistortions = false;
7383 scaleFactor = SCALE_FACTOR_16x;
7384 mvShiftFactor = CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_16x;
7385 prevMvReadPosFactor = CODECHAL_ENCODE_AVC_PREV_MV_READ_POSITION_16x;
7386 break;
7387 case HME_LEVEL_4x:
7388 useMvFromPrevStep = (m_16xMeEnabled) ? CODECHAL_ENCODE_AVC_HME_FOLLOWING_STEP : CODECHAL_ENCODE_AVC_HME_FIRST_STEP;
7389 writeDistortions = true;
7390 scaleFactor = SCALE_FACTOR_4x;
7391 mvShiftFactor = CODECHAL_ENCODE_AVC_MV_SHIFT_FACTOR_4x;
7392 prevMvReadPosFactor = CODECHAL_ENCODE_AVC_PREV_MV_READ_POSITION_4x;
7393 break;
7394 default:
7395 eStatus = MOS_STATUS_INVALID_PARAMETER;
7396 return eStatus;
7397 break;
7398 }
7399
7400 CODECHAL_ENCODE_AVC_ME_CURBE cmd;
7401 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
7402 &cmd,
7403 sizeof(CODECHAL_ENCODE_AVC_ME_CURBE),
7404 g_cInit_CODECHAL_ENCODE_AVC_ME_CURBE,
7405 sizeof(CODECHAL_ENCODE_AVC_ME_CURBE)));
7406
7407 cmd.DW3.SubPelMode = 3;
7408 if (m_fieldScalingOutputInterleaved)
7409 {
7410 cmd.DW3.SrcAccess =
7411 cmd.DW3.RefAccess = CodecHal_PictureIsField(m_avcPicParam->CurrOriginalPic) ? 1 : 0;
7412 cmd.DW7.SrcFieldPolarity = CodecHal_PictureIsBottomField(m_avcPicParam->CurrOriginalPic) ? 1 : 0;
7413 }
7414
7415 cmd.DW4.PictureHeightMinus1 = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight / scaleFactor) - 1;
7416 cmd.DW4.PictureWidth = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth / scaleFactor);
7417 cmd.DW5.QpPrimeY = qpPrimeY;
7418 cmd.DW6.WriteDistortions = writeDistortions;
7419 cmd.DW6.UseMvFromPrevStep = useMvFromPrevStep;
7420
7421 cmd.DW6.SuperCombineDist = m_superCombineDistGeneric[m_avcSeqParam->TargetUsage];
7422 cmd.DW6.MaxVmvR = (framePicture) ? CodecHalAvcEncode_GetMaxMvLen(m_avcSeqParam->Level) * 4 : (CodecHalAvcEncode_GetMaxMvLen(m_avcSeqParam->Level) >> 1) * 4;
7423
7424 if (m_pictureCodingType == B_TYPE)
7425 {
7426 // This field is irrelevant since we are not using the bi-direct search.
7427 // set it to 32
7428 cmd.DW1.BiWeight = 32;
7429 cmd.DW13.NumRefIdxL1MinusOne =
7430 m_avcSliceParams->num_ref_idx_l1_active_minus1;
7431 }
7432
7433 if (m_pictureCodingType == P_TYPE ||
7434 m_pictureCodingType == B_TYPE)
7435 {
7436 if (m_16xMeSupported)
7437 {
7438 cmd.DW30.ActualMBHeight = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight);
7439 cmd.DW30.ActualMBWidth = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth);
7440 }
7441 cmd.DW13.NumRefIdxL0MinusOne =
7442 m_avcSliceParams->num_ref_idx_l0_active_minus1;
7443 }
7444
7445 cmd.DW13.RefStreaminCost = 5;
7446 // This flag is to indicate the ROI source type instead of indicating ROI is enabled or not
7447 cmd.DW13.ROIEnable = 0;
7448
7449 if (!framePicture)
7450 {
7451 if (m_pictureCodingType != I_TYPE)
7452 {
7453 cmd.DW14.List0RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_0);
7454 cmd.DW14.List0RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_1);
7455 cmd.DW14.List0RefID2FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_2);
7456 cmd.DW14.List0RefID3FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_3);
7457 cmd.DW14.List0RefID4FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_4);
7458 cmd.DW14.List0RefID5FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_5);
7459 cmd.DW14.List0RefID6FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_6);
7460 cmd.DW14.List0RefID7FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_0, CODECHAL_ENCODE_REF_ID_7);
7461 }
7462 if (m_pictureCodingType == B_TYPE)
7463 {
7464 cmd.DW14.List1RefID0FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_0);
7465 cmd.DW14.List1RefID1FieldParity = CodecHalAvcEncode_GetFieldParity(slcParams, LIST_1, CODECHAL_ENCODE_REF_ID_1);
7466 }
7467 }
7468
7469 cmd.DW15.MvShiftFactor = mvShiftFactor;
7470 cmd.DW15.PrevMvReadPosFactor = prevMvReadPosFactor;
7471
7472 // r3 & r4
7473 uint8_t tu = m_avcSeqParam->TargetUsage;
7474 uint8_t ucMeMethod = m_meMethodTable ? // use the ME table dependent on prototype or codec standard
7475 m_meMethodTable[tu]
7476 : m_meMethodGeneric[tu];
7477 uint8_t tableIdx = 0;
7478 eStatus = MOS_SecureMemcpy(&(cmd.SPDelta), 14 * sizeof(uint32_t), m_encodeSearchPath[tableIdx][ucMeMethod], 14 * sizeof(uint32_t));
7479 if (eStatus != MOS_STATUS_SUCCESS)
7480 {
7481 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
7482 return eStatus;
7483 }
7484
7485 // r5
7486 cmd.DW32._4xMeMvOutputDataSurfIndex = CODECHAL_ENCODE_AVC_ME_MV_DATA_SURFACE;
7487 cmd.DW33._16xOr32xMeMvInputDataSurfIndex = (params->hmeLvl == HME_LEVEL_32x) ? CODECHAL_ENCODE_AVC_32xME_MV_DATA_SURFACE : CODECHAL_ENCODE_AVC_16xME_MV_DATA_SURFACE;
7488 cmd.DW34._4xMeOutputDistSurfIndex = CODECHAL_ENCODE_AVC_ME_DISTORTION_SURFACE;
7489 cmd.DW35._4xMeOutputBrcDistSurfIndex = CODECHAL_ENCODE_AVC_ME_BRC_DISTORTION;
7490 cmd.DW36.VMEFwdInterPredictionSurfIndex = CODECHAL_ENCODE_AVC_ME_CURR_FOR_FWD_REF;
7491 cmd.DW37.VMEBwdInterPredictionSurfIndex = CODECHAL_ENCODE_AVC_ME_CURR_FOR_BWD_REF;
7492 cmd.DW38.VDEncStreamInSurfIndex = CODECHAL_ENCODE_AVC_ME_VDENC_STREAMIN;
7493
7494 CODECHAL_ENCODE_CHK_STATUS_RETURN(params->pKernelState->m_dshRegion.AddData(
7495 &cmd,
7496 params->pKernelState->dwCurbeOffset,
7497 sizeof(cmd)));
7498
7499 CODECHAL_DEBUG_TOOL(
7500 CODECHAL_ENCODE_CHK_STATUS_RETURN(PopulateHmeParam(m_16xMeEnabled, m_32xMeEnabled, ucMeMethod, &cmd));)
7501
7502 return eStatus;
7503 }
7504
7505 MOS_STATUS CodechalVdencAvcState::SendMeSurfaces(PMOS_COMMAND_BUFFER cmdBuffer, MeSurfaceParams *params)
7506 {
7507 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7508
7509 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7510 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
7511 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pKernelState);
7512 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pCurrOriginalPic);
7513 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps4xMeMvDataBuffer);
7514 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psMeDistortionBuffer);
7515 CODECHAL_ENCODE_CHK_NULL_RETURN(params->psMeVdencStreamInBuffer);
7516
7517 CODECHAL_MEDIA_STATE_TYPE encMediaStateType;
7518 encMediaStateType = (params->b32xMeInUse) ? CODECHAL_MEDIA_STATE_32X_ME : params->b16xMeInUse ? CODECHAL_MEDIA_STATE_16X_ME : CODECHAL_MEDIA_STATE_4X_ME;
7519
7520 if (params->bVdencStreamInEnabled && encMediaStateType == CODECHAL_MEDIA_STATE_4X_ME)
7521 {
7522 encMediaStateType = CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN;
7523 }
7524
7525 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pMeBindingTable);
7526 auto meBindingTable = params->pMeBindingTable;
7527
7528 auto currFieldPicture = CodecHal_PictureIsField(*(params->pCurrOriginalPic)) ? 1 : 0;
7529 auto currBottomField = CodecHal_PictureIsBottomField(*(params->pCurrOriginalPic)) ? 1 : 0;
7530 uint8_t ucCurrVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME : ((currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
7531
7532 PMOS_SURFACE currScaledSurface = nullptr, meMvDataBuffer = nullptr;
7533 uint32_t meMvBottomFieldOffset = 0, currScaledBottomFieldOffset = 0, refScaledBottomFieldOffset = 0;
7534 if (params->b32xMeInUse)
7535 {
7536 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps32xMeMvDataBuffer);
7537 currScaledSurface = m_trackedBuf->Get32xDsSurface(CODEC_CURR_TRACKED_BUFFER);
7538 meMvDataBuffer = params->ps32xMeMvDataBuffer;
7539 meMvBottomFieldOffset = params->dw32xMeMvBottomFieldOffset;
7540 currScaledBottomFieldOffset = params->dw32xScaledBottomFieldOffset;
7541 }
7542 else if (params->b16xMeInUse)
7543 {
7544 CODECHAL_ENCODE_CHK_NULL_RETURN(params->ps16xMeMvDataBuffer);
7545 currScaledSurface = m_trackedBuf->Get16xDsSurface(CODEC_CURR_TRACKED_BUFFER);
7546 meMvDataBuffer = params->ps16xMeMvDataBuffer;
7547 meMvBottomFieldOffset = params->dw16xMeMvBottomFieldOffset;
7548 currScaledBottomFieldOffset = params->dw16xScaledBottomFieldOffset;
7549 }
7550 else
7551 {
7552 currScaledSurface = m_trackedBuf->Get4xDsSurface(CODEC_CURR_TRACKED_BUFFER);
7553 meMvDataBuffer = params->ps4xMeMvDataBuffer;
7554 meMvBottomFieldOffset = params->dw4xMeMvBottomFieldOffset;
7555 currScaledBottomFieldOffset = params->dw4xScaledBottomFieldOffset;
7556 }
7557
7558 // Reference height and width information should be taken from the current scaled surface rather
7559 // than from the reference scaled surface in the case of PAFF.
7560 auto refScaledSurface = *currScaledSurface;
7561
7562 auto width = MOS_ALIGN_CEIL(params->dwDownscaledWidthInMb * 32, 64);
7563 auto height = params->dwDownscaledHeightInMb * 4 * CODECHAL_ENCODE_ME_DATA_SIZE_MULTIPLIER;
7564
7565 // Force the values
7566 meMvDataBuffer->dwWidth = width;
7567 meMvDataBuffer->dwHeight = height;
7568 meMvDataBuffer->dwPitch = width;
7569
7570 CODECHAL_SURFACE_CODEC_PARAMS surfaceParams;
7571 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7572 surfaceParams.bIs2DSurface = true;
7573 surfaceParams.bMediaBlockRW = true;
7574 surfaceParams.psSurface = meMvDataBuffer;
7575 surfaceParams.dwOffset = meMvBottomFieldOffset;
7576 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
7577 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEMVDataSurface;
7578 surfaceParams.bIsWritable = true;
7579 surfaceParams.bRenderTarget = true;
7580 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7581 m_hwInterface,
7582 cmdBuffer,
7583 &surfaceParams,
7584 params->pKernelState));
7585
7586 if (params->b16xMeInUse && params->b32xMeEnabled)
7587 {
7588 // Pass 32x MV to 16x ME operation
7589 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7590 surfaceParams.bIs2DSurface = true;
7591 surfaceParams.bMediaBlockRW = true;
7592 surfaceParams.psSurface = params->ps32xMeMvDataBuffer;
7593 surfaceParams.dwOffset =
7594 currBottomField ? params->dw32xMeMvBottomFieldOffset : 0;
7595 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
7596 surfaceParams.dwBindingTableOffset = meBindingTable->dw32xMEMVDataSurface;
7597 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7598 m_hwInterface,
7599 cmdBuffer,
7600 &surfaceParams,
7601 params->pKernelState));
7602 }
7603 else if (!params->b32xMeInUse && params->b16xMeEnabled)
7604 {
7605 // Pass 16x MV to 4x ME operation
7606 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7607 surfaceParams.bIs2DSurface = true;
7608 surfaceParams.bMediaBlockRW = true;
7609 surfaceParams.psSurface = params->ps16xMeMvDataBuffer;
7610 surfaceParams.dwOffset =
7611 currBottomField ? params->dw16xMeMvBottomFieldOffset : 0;
7612 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
7613 surfaceParams.dwBindingTableOffset = meBindingTable->dw16xMEMVDataSurface;
7614 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7615 m_hwInterface,
7616 cmdBuffer,
7617 &surfaceParams,
7618 params->pKernelState));
7619 }
7620
7621 // Insert Distortion buffers only for 4xMe case
7622 if (!params->b32xMeInUse && !params->b16xMeInUse)
7623 {
7624 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7625 surfaceParams.bIs2DSurface = true;
7626 surfaceParams.bMediaBlockRW = true;
7627 surfaceParams.psSurface = params->psMeDistortionBuffer;
7628 surfaceParams.dwOffset = params->dwMeDistortionBottomFieldOffset;
7629 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEDist;
7630 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
7631 surfaceParams.bIsWritable = true;
7632 surfaceParams.bRenderTarget = true;
7633 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7634 m_hwInterface,
7635 cmdBuffer,
7636 &surfaceParams,
7637 params->pKernelState));
7638 }
7639
7640 // Setup references 1...n
7641 // LIST 0 references
7642 uint8_t refPicIdx;
7643 CODEC_PICTURE refPic;
7644 bool refFieldPicture, refBottomField;
7645 for (uint8_t refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++)
7646 {
7647 refPic = params->pL0RefFrameList[refIdx];
7648
7649 if (!CodecHal_PictureIsInvalid(refPic) && params->pPicIdx[refPic.FrameIdx].bValid)
7650 {
7651 if (refIdx == 0)
7652 {
7653 // Current Picture Y - VME
7654 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7655 surfaceParams.bUseAdvState = true;
7656 surfaceParams.psSurface = currScaledSurface;
7657 surfaceParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
7658 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value;
7659 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForFwdRef;
7660 surfaceParams.ucVDirection = ucCurrVDirection;
7661 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7662 m_hwInterface,
7663 cmdBuffer,
7664 &surfaceParams,
7665 params->pKernelState));
7666 }
7667
7668 refFieldPicture = CodecHal_PictureIsField(refPic) ? 1 : 0;
7669 refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
7670 refPicIdx = params->pPicIdx[refPic.FrameIdx].ucPicIdx;
7671 uint8_t scaledIdx = params->ppRefList[refPicIdx]->ucScalingIdx;
7672 if (params->b32xMeInUse)
7673 {
7674 MOS_SURFACE *p32xSurface = m_trackedBuf->Get32xDsSurface(scaledIdx);
7675 if (p32xSurface != nullptr)
7676 {
7677 refScaledSurface.OsResource = p32xSurface->OsResource;
7678 }
7679 else
7680 {
7681 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7682 }
7683 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7684 }
7685 else if (params->b16xMeInUse)
7686 {
7687 MOS_SURFACE *p16xSurface = m_trackedBuf->Get16xDsSurface(scaledIdx);
7688 if (p16xSurface != nullptr)
7689 {
7690 refScaledSurface.OsResource = p16xSurface->OsResource;
7691 }
7692 else
7693 {
7694 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7695 }
7696 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7697 }
7698 else
7699 {
7700 MOS_SURFACE *p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
7701 if (p4xSurface != nullptr)
7702 {
7703 refScaledSurface.OsResource = p4xSurface->OsResource;
7704 }
7705 else
7706 {
7707 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7708 }
7709 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7710 }
7711 // L0 Reference Picture Y - VME
7712 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7713 surfaceParams.bUseAdvState = true;
7714 surfaceParams.psSurface = &refScaledSurface;
7715 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
7716 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value;
7717 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEFwdRefPicIdx[refIdx];
7718 surfaceParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME : ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
7719 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7720 m_hwInterface,
7721 cmdBuffer,
7722 &surfaceParams,
7723 params->pKernelState));
7724 }
7725 }
7726
7727 // Setup references 1...n
7728 // LIST 1 references
7729 for (uint8_t refIdx = 0; refIdx <= params->dwNumRefIdxL1ActiveMinus1; refIdx++)
7730 {
7731 refPic = params->pL1RefFrameList[refIdx];
7732
7733 if (!CodecHal_PictureIsInvalid(refPic) && params->pPicIdx[refPic.FrameIdx].bValid)
7734 {
7735 if (refIdx == 0)
7736 {
7737 // Current Picture Y - VME
7738 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7739 surfaceParams.bUseAdvState = true;
7740 surfaceParams.psSurface = currScaledSurface;
7741 surfaceParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
7742 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value;
7743 surfaceParams.dwBindingTableOffset = meBindingTable->dwMECurrForBwdRef;
7744 surfaceParams.ucVDirection = ucCurrVDirection;
7745 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7746 m_hwInterface,
7747 cmdBuffer,
7748 &surfaceParams,
7749 params->pKernelState));
7750 }
7751
7752 refFieldPicture = CodecHal_PictureIsField(refPic) ? 1 : 0;
7753 refBottomField = (CodecHal_PictureIsBottomField(refPic)) ? 1 : 0;
7754 refPicIdx = params->pPicIdx[refPic.FrameIdx].ucPicIdx;
7755 uint8_t scaledIdx = params->ppRefList[refPicIdx]->ucScalingIdx;
7756 if (params->b32xMeInUse)
7757 {
7758 MOS_SURFACE *p32xSurface = m_trackedBuf->Get32xDsSurface(scaledIdx);
7759 if (p32xSurface != nullptr)
7760 {
7761 refScaledSurface.OsResource = p32xSurface->OsResource;
7762 }
7763 else
7764 {
7765 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7766 }
7767 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7768 }
7769 else if (params->b16xMeInUse)
7770 {
7771 MOS_SURFACE *p16xSurface = m_trackedBuf->Get16xDsSurface(scaledIdx);
7772 if (p16xSurface != nullptr)
7773 {
7774 refScaledSurface.OsResource = p16xSurface->OsResource;
7775 }
7776 else
7777 {
7778 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7779 }
7780 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7781 }
7782 else
7783 {
7784 MOS_SURFACE *p4xSurface = m_trackedBuf->Get4xDsSurface(scaledIdx);
7785 if (p4xSurface != nullptr)
7786 {
7787 refScaledSurface.OsResource = p4xSurface->OsResource;
7788 }
7789 else
7790 {
7791 CODECHAL_ENCODE_ASSERTMESSAGE("NULL pointer of DsSurface");
7792 }
7793 refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
7794 }
7795 // L1 Reference Picture Y - VME
7796 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7797 surfaceParams.bUseAdvState = true;
7798 surfaceParams.psSurface = &refScaledSurface;
7799 surfaceParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
7800 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_HME_DOWNSAMPLED_ENCODE].Value;
7801 surfaceParams.dwBindingTableOffset = meBindingTable->dwMEBwdRefPicIdx[refIdx];
7802 surfaceParams.ucVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME : ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
7803 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7804 m_hwInterface,
7805 cmdBuffer,
7806 &surfaceParams,
7807 params->pKernelState));
7808 }
7809 }
7810
7811 if (encMediaStateType == CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN)
7812 {
7813 MOS_ZeroMemory(&surfaceParams, sizeof(surfaceParams));
7814 surfaceParams.dwSize = params->dwVDEncStreamInSurfaceSize;
7815 surfaceParams.bIs2DSurface = false;
7816 surfaceParams.presBuffer = params->psMeVdencStreamInBuffer;
7817 surfaceParams.dwBindingTableOffset = meBindingTable->dwVdencStreamInSurface;
7818 surfaceParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_BRC_ME_DISTORTION_ENCODE].Value;
7819 surfaceParams.bIsWritable = true;
7820 surfaceParams.bRenderTarget = true;
7821 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
7822 m_hwInterface,
7823 cmdBuffer,
7824 &surfaceParams,
7825 params->pKernelState));
7826 }
7827
7828 return eStatus;
7829 }
7830
7831 MOS_STATUS CodechalVdencAvcState::SetMfxPipeBufAddrStateParams(
7832 CODECHAL_ENCODE_AVC_GENERIC_PICTURE_LEVEL_PARAMS genericParam,
7833 MHW_VDBOX_PIPE_BUF_ADDR_PARAMS & param)
7834 {
7835 MOS_STATUS eStatus = CodechalEncodeAvcBase::SetMfxPipeBufAddrStateParams(genericParam, param);
7836
7837 param.ps4xDsSurface = m_trackedBuf->Get4xDsReconSurface(CODEC_CURR_TRACKED_BUFFER);
7838 param.presVdencIntraRowStoreScratchBuffer = &m_vdencIntraRowStoreScratchBuffer;
7839 param.presVdencStreamOutBuffer = &m_vdencStatsBuffer;
7840 if (m_perMBStreamOutEnable)
7841 {
7842 // Using frame and PerMB level buffer to get PerMB StreamOut PAK Statistic.
7843 param.presStreamOutBuffer = &m_pakStatsBufferFull[m_currRecycledBufIdx];
7844 }
7845 else
7846 {
7847 param.presStreamOutBuffer = &m_pakStatsBuffer;
7848 }
7849 param.dwNumRefIdxL0ActiveMinus1 = m_avcSliceParams->num_ref_idx_l0_active_minus1;
7850 param.dwNumRefIdxL1ActiveMinus1 = m_avcSliceParams->num_ref_idx_l1_active_minus1;
7851 param.oneOnOneMapping = m_oneOnOneMapping;
7852
7853 if (m_pictureCodingType != I_TYPE)
7854 {
7855 // populate the RefPic and DS surface so pfnAddVdencPipeBufAddrCmd() can directly use them
7856 auto l0RefFrameList = m_avcSliceParams->RefPicList[LIST_0];
7857 for (uint8_t refIdx = 0; refIdx <= m_avcSliceParams->num_ref_idx_l0_active_minus1; refIdx++)
7858 {
7859 auto refPic = l0RefFrameList[refIdx];
7860
7861 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
7862 {
7863 // L0 references
7864 auto refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
7865 param.presVdencReferences[refIdx] = &m_refList[refPicIdx]->sRefReconBuffer.OsResource;
7866 param.presVdenc4xDsSurface[refIdx] =
7867 &(m_trackedBuf->Get4xDsReconSurface(m_refList[refPicIdx]->ucScalingIdx))->OsResource;
7868 }
7869 }
7870 }
7871
7872 if (m_vdencStreamInEnabled)
7873 param.presVdencStreamInBuffer = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
7874
7875 return eStatus;
7876 }
7877
7878 void CodechalVdencAvcState::SetVdencCqptStateParams(MHW_VDBOX_VDENC_CQPT_STATE_PARAMS &param)
7879 {
7880 MOS_ZeroMemory(&param, sizeof(param));
7881 param.wPictureCodingType = m_pictureCodingType;
7882 param.bFTQEnabled = m_vdencInterface->VdencFTQEnabled(m_avcSeqParam->TargetUsage);
7883 param.bTransform8x8Flag = m_avcPicParam->transform_8x8_mode_flag;
7884 }
7885
7886 void CodechalVdencAvcState::SetMfxAvcImgStateParams(MHW_VDBOX_AVC_IMG_PARAMS &param)
7887 {
7888 CodechalEncodeAvcBase::SetMfxAvcImgStateParams(param);
7889 if (m_avcSeqParam->EnableSliceLevelRateCtrl)
7890 {
7891 uint8_t qpY = m_avcPicParam->QpY;
7892 param.dwMbSlcThresholdValue = CODECHAL_VDENC_AVC_MB_SLICE_TRHESHOLD;
7893 param.dwVdencSliceMinusBytes = (m_pictureCodingType == I_TYPE) ? m_vdencSSCThrsTblI[qpY] : m_vdencSSCThrsTblP[qpY];
7894 }
7895
7896 if (MEDIA_IS_WA(m_waTable, WaEnableOnlyASteppingFeatures))
7897 {
7898 param.bRollingIRestrictFracCand = true;
7899 }
7900
7901 param.bVdencEnabled = true;
7902 param.pVDEncModeCost = m_vdencModeCostTbl;
7903 param.pVDEncHmeMvCost = m_vdencHmeMvCostTbl;
7904 param.pVDEncMvCost = m_vdencMvCostTbl;
7905 param.bVDEncPerfModeEnabled =
7906 m_vdencInterface->IsPerfModeSupported() && m_perfModeEnabled[m_avcSeqParam->TargetUsage];
7907 }
7908
7909 PMHW_VDBOX_STATE_CMDSIZE_PARAMS CodechalVdencAvcState::CreateMhwVdboxStateCmdsizeParams()
7910 {
7911 PMHW_VDBOX_STATE_CMDSIZE_PARAMS stateCmdSizeParams = MOS_New(MHW_VDBOX_STATE_CMDSIZE_PARAMS);
7912 return stateCmdSizeParams;
7913 }
7914
7915 PMHW_VDBOX_AVC_IMG_PARAMS CodechalVdencAvcState::CreateMhwVdboxAvcImgParams()
7916 {
7917 PMHW_VDBOX_AVC_IMG_PARAMS avcImgParams = MOS_New(MHW_VDBOX_AVC_IMG_PARAMS);
7918
7919 return avcImgParams;
7920 }
7921
7922 PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS CodechalVdencAvcState::CreateMhwVdboxVdencWalkerStateParams()
7923 {
7924 PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS vdencWalkerStateParams = MOS_New(MHW_VDBOX_VDENC_WALKER_STATE_PARAMS);
7925
7926 return vdencWalkerStateParams;
7927 }
7928
7929 MOS_STATUS CodechalVdencAvcState::FillHucConstData(uint8_t *data, uint8_t /*picType*/)
7930 {
7931 auto hucConstData = (PAVCVdencBRCCostantData)data;
7932 auto avcSeqParams = m_avcSeqParam;
7933 CODECHAL_ENCODE_CHK_NULL_RETURN(hucConstData);
7934
7935 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabI_U8, 64 * sizeof(uint8_t), (void *)BRC_UPD_GlobalRateQPAdjTabI_U8, 64 * sizeof(uint8_t));
7936 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW) // Sliding Window BRC
7937 {
7938 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t), (void *)BRC_UPD_SlWinGlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t));
7939 }
7940 else
7941 {
7942 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t), (void *)BRC_UPD_GlobalRateQPAdjTabP_U8, 64 * sizeof(uint8_t));
7943 }
7944 MOS_SecureMemcpy(hucConstData->UPD_GlobalRateQPAdjTabB_U8, 64 * sizeof(uint8_t), (void *)BRC_UPD_GlobalRateQPAdjTabB_U8, 64 * sizeof(uint8_t));
7945
7946 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldI_U8, 10 * sizeof(uint8_t), (void *)BRC_UPD_DistThreshldI_U8, 10 * sizeof(uint8_t));
7947 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldP_U8, 10 * sizeof(uint8_t), (void *)BRC_UPD_DistThreshldP_U8, 10 * sizeof(uint8_t));
7948 MOS_SecureMemcpy(hucConstData->UPD_DistThreshldB_U8, 10 * sizeof(uint8_t), (void *)BRC_UPD_DistThreshldP_U8, 10 * sizeof(uint8_t));
7949
7950 if (avcSeqParams->RateControlMethod == RATECONTROL_CBR)
7951 {
7952 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabI_U8, 81 * sizeof(uint8_t), (void *)CBR_UPD_DistQPAdjTabI_U8, 81 * sizeof(int8_t));
7953 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabP_U8, 81 * sizeof(uint8_t), (void *)CBR_UPD_DistQPAdjTabP_U8, 81 * sizeof(int8_t));
7954 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabB_U8, 81 * sizeof(uint8_t), (void *)CBR_UPD_DistQPAdjTabB_U8, 81 * sizeof(int8_t));
7955 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t), (void *)CBR_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
7956 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t), (void *)CBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
7957 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t), (void *)CBR_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
7958 }
7959 else
7960 {
7961 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabI_U8, 81 * sizeof(uint8_t), (void *)VBR_UPD_DistQPAdjTabI_U8, 81 * sizeof(int8_t));
7962 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabP_U8, 81 * sizeof(uint8_t), (void *)VBR_UPD_DistQPAdjTabP_U8, 81 * sizeof(int8_t));
7963 MOS_SecureMemcpy(hucConstData->UPD_DistQPAdjTabB_U8, 81 * sizeof(uint8_t), (void *)VBR_UPD_DistQPAdjTabB_U8, 81 * sizeof(int8_t));
7964
7965 if (avcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay Mode
7966 {
7967 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t), (void *)LOW_DELAY_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
7968 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t), (void *)LOW_DELAY_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
7969 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t), (void *)LOW_DELAY_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
7970 }
7971 else
7972 {
7973 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabI_S8, 72 * sizeof(uint8_t), (void *)VBR_UPD_FrmSzAdjTabI_S8, 72 * sizeof(int8_t));
7974
7975 if (avcSeqParams->RateControlMethod == RATECONTROL_QVBR)
7976 {
7977 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t), (void *)QVBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
7978 }
7979 else
7980 {
7981 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabP_S8, 72 * sizeof(uint8_t), (void *)VBR_UPD_FrmSzAdjTabP_S8, 72 * sizeof(int8_t));
7982 }
7983
7984 MOS_SecureMemcpy(hucConstData->UPD_BufRateAdjTabB_S8, 72 * sizeof(uint8_t), (void *)VBR_UPD_FrmSzAdjTabB_S8, 72 * sizeof(int8_t));
7985 }
7986 }
7987
7988 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMinTabP_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzMinTabP_U8, 9 * sizeof(uint8_t));
7989 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMinTabI_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzMinTabI_U8, 9 * sizeof(uint8_t));
7990
7991 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMaxTabP_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzMaxTabP_U8, 9 * sizeof(uint8_t));
7992 MOS_SecureMemcpy(hucConstData->UPD_FrmSzMaxTabI_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzMaxTabI_U8, 9 * sizeof(uint8_t));
7993
7994 MOS_SecureMemcpy(hucConstData->UPD_FrmSzSCGTabP_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzSCGTabP_U8, 9 * sizeof(uint8_t));
7995 MOS_SecureMemcpy(hucConstData->UPD_FrmSzSCGTabI_U8, 9 * sizeof(uint8_t), (void *)BRC_UPD_FrmSzSCGTabI_U8, 9 * sizeof(uint8_t));
7996
7997 MOS_SecureMemcpy(hucConstData->UPD_I_IntraNonPred, 42 * sizeof(uint8_t), (void *)BRC_UPD_I_IntraNonPred, 42 * sizeof(uint8_t));
7998 MOS_SecureMemcpy(hucConstData->UPD_I_Intra8x8, 42 * sizeof(uint8_t), (void *)BRC_UPD_I_Intra8x8, 42 * sizeof(uint8_t));
7999 MOS_SecureMemcpy(hucConstData->UPD_I_Intra4x4, 42 * sizeof(uint8_t), (void *)BRC_UPD_I_Intra4x4, 42 * sizeof(uint8_t));
8000
8001 MOS_SecureMemcpy(hucConstData->UPD_P_IntraNonPred, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_IntraNonPred, 42 * sizeof(uint8_t));
8002 MOS_SecureMemcpy(hucConstData->UPD_P_Intra16x16, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Intra16x16, 42 * sizeof(uint8_t));
8003 MOS_SecureMemcpy(hucConstData->UPD_P_Intra8x8, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Intra8x8, 42 * sizeof(uint8_t));
8004 MOS_SecureMemcpy(hucConstData->UPD_P_Intra4x4, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Intra4x4, 42 * sizeof(uint8_t));
8005
8006 MOS_SecureMemcpy(hucConstData->UPD_P_Inter16x8, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Inter16x8, 42 * sizeof(uint8_t));
8007 MOS_SecureMemcpy(hucConstData->UPD_P_Inter8x8, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Inter8x8, 42 * sizeof(uint8_t));
8008 MOS_SecureMemcpy(hucConstData->UPD_P_Inter16x16, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_Inter16x16, 42 * sizeof(uint8_t));
8009 MOS_SecureMemcpy(hucConstData->UPD_P_RefId, 42 * sizeof(uint8_t), (void *)BRC_UPD_P_RefId, 42 * sizeof(uint8_t));
8010
8011 CODECHAL_ENCODE_CHK_STATUS_RETURN(LoadHmeMvCostTable(avcSeqParams, hucConstData->UPD_HMEMVCost));
8012
8013 return MOS_STATUS_SUCCESS;
8014 }
8015
8016 MOS_STATUS CodechalVdencAvcState::ExecuteMeKernel()
8017 {
8018 if (m_hmeEnabled)
8019 {
8020 if (m_16xMeEnabled)
8021 {
8022 m_lastTaskInPhase = false;
8023 if (m_32xMeEnabled)
8024 {
8025 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(nullptr, HME_LEVEL_32x));
8026 }
8027 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(nullptr, HME_LEVEL_16x));
8028 }
8029
8030 // On-demand sync for VDEnc SHME StreamIn surface
8031 auto syncParams = g_cInitSyncParams;
8032 syncParams.GpuContext = m_renderContext;
8033 syncParams.presSyncResource = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
8034
8035 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnResourceWait(m_osInterface, &syncParams));
8036 m_osInterface->pfnSetResourceSyncTag(m_osInterface, &syncParams);
8037
8038 // HME StreamIn
8039 m_lastTaskInPhase = !m_staticFrameDetectionInUse;
8040 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(nullptr, HME_LEVEL_4x));
8041 m_vdencStreamInEnabled = true;
8042 }
8043 return MOS_STATUS_SUCCESS;
8044 }
8045
8046 bool CodechalVdencAvcState::IsMBBRCControlEnabled()
8047 {
8048 return m_mbBrcEnabled || m_avcPicParam->bNativeROI;
8049 }
8050
8051 MOS_STATUS CodechalVdencAvcState::GetVulkanQueryPoolResults(
8052 uint32_t queryFrameIndex,
8053 void *pData,
8054 uint64_t dataOffset,
8055 bool is64bit,
8056 uint8_t reportStatus,
8057 bool reportOffset,
8058 bool reportBitstreamSize)
8059 {
8060 CODECHAL_ENCODE_FUNCTION_ENTER;
8061 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8062
8063 EncodeStatusBuffer *encodeStatusBuf = &m_encodeStatusBuf;
8064
8065 uint32_t baseOffset =
8066 queryFrameIndex * m_encodeStatusBuf.dwReportSize +
8067 sizeof(uint32_t) * 2;
8068
8069 uint8_t *bytePtr = reinterpret_cast<uint8_t *>(pData);
8070 uint64_t vkDataoffset = dataOffset;
8071 uint8_t *statusData = reinterpret_cast<uint8_t *>(m_encodeStatusBuf.pData);
8072
8073 size_t dataSize = is64bit ? sizeof(uint64_t) : sizeof(uint32_t);
8074 uint64_t offsetResult = 0;
8075 uint64_t statusResult = 1;
8076 void *pOffsetResult = &offsetResult;
8077 void *pStatusResult = &statusResult;
8078
8079 if (!is64bit)
8080 {
8081 offsetResult = static_cast<uint32_t>(offsetResult);
8082 statusResult = static_cast<uint32_t>(statusResult);
8083 pOffsetResult = reinterpret_cast<uint32_t *>(&offsetResult);
8084 pStatusResult = reinterpret_cast<uint32_t *>(&statusResult);
8085 }
8086
8087 if (reportOffset)
8088 {
8089 eStatus = MOS_SecureMemcpy(bytePtr + vkDataoffset, dataSize, pOffsetResult, dataSize);
8090 if (eStatus != MOS_STATUS_SUCCESS)
8091 {
8092 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get bitstream offset.");
8093 return eStatus;
8094 }
8095 vkDataoffset += dataSize;
8096 }
8097 if (reportBitstreamSize)
8098 {
8099 eStatus = MOS_SecureMemcpy(
8100 bytePtr + vkDataoffset,
8101 dataSize,
8102 statusData + baseOffset + encodeStatusBuf->dwBSByteCountOffset,
8103 dataSize);
8104 if (eStatus != MOS_STATUS_SUCCESS)
8105 {
8106 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get bitstream size from status buffer.");
8107 return eStatus;
8108 }
8109 vkDataoffset += dataSize;
8110 }
8111 if (reportStatus)
8112 {
8113 eStatus = MOS_SecureMemcpy(bytePtr + vkDataoffset, dataSize, pStatusResult, dataSize);
8114 if (eStatus != MOS_STATUS_SUCCESS)
8115 {
8116 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get encode status");
8117 return eStatus;
8118 }
8119 }
8120
8121 return eStatus;
8122 }
8123
8124
8125 MOS_STATUS CodechalVdencAvcState::PrepareHWMetaData(
8126 PMOS_RESOURCE presMetadataBuffer,
8127 PMOS_RESOURCE presSliceSizeStreamoutBuffer,
8128 PMOS_COMMAND_BUFFER cmdBuffer)
8129 {
8130 CODECHAL_ENCODE_FUNCTION_ENTER;
8131 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8132
8133 if (!presMetadataBuffer)
8134 {
8135 return eStatus;
8136 }
8137
8138 // get access to the MMIO registers
8139 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8140 MmioRegistersMfx *mmioRegisters = m_hwInterface->SelectVdboxAndGetMmioRegister(m_vdboxIndex, cmdBuffer);
8141
8142 MHW_MI_STORE_DATA_PARAMS storeDataParams;
8143 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8144
8145 // Report error flags to metadata buffer
8146 storeDataParams.pOsResource = presMetadataBuffer;
8147 storeDataParams.dwResourceOffset = m_metaDataOffset.dwEncodeErrorFlags;
8148 storeDataParams.dwValue = 0; // No error
8149 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8150
8151 // Report num of slices to metadata buffer
8152 storeDataParams.dwResourceOffset = m_metaDataOffset.dwWrittenSubregionsCount;
8153 storeDataParams.dwValue = m_numSlices;
8154 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8155
8156 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
8157
8158 // Report bitstream size to metadata buffer
8159 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8160 miStoreRegMemParams.presStoreBuffer = presMetadataBuffer;
8161 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodedBitstreamWrittenBytesCount;
8162 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountFrameRegOffset;
8163 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8164
8165 MHW_MI_LOAD_REGISTER_MEM_PARAMS miLoadRegMemParams;
8166 MHW_MI_LOAD_REGISTER_IMM_PARAMS miLoadRegImmParams;
8167 MHW_MI_MATH_PARAMS miMathParams;
8168
8169 // Statistics
8170 // Average QP
8171 if (m_avcSeqParam->RateControlMethod == RATECONTROL_CQP)
8172 {
8173 storeDataParams.dwResourceOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwAverageQP;
8174 storeDataParams.dwValue = m_avcPicParam->QpY + m_avcSliceParams->slice_qp_delta;
8175 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8176 }
8177 else
8178 {
8179 CODECHAL_ENCODE_NORMALMESSAGE("RC mode is temporarily not supported");
8180 }
8181
8182 MOS_RESOURCE *pPakFrameStat = (m_perMBStreamOutEnable) ? &m_pakStatsBufferFull[m_currRecycledBufIdx] : &m_pakStatsBuffer; //& m_resFrameStatStreamOutBuffer; or m_pakStatsBuffer
8183 MHW_MI_LOAD_REGISTER_REG_PARAMS miLoadRegRegParams;
8184 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8185
8186 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8187 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8188 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8189
8190 /*** Intra/Inter/Skip statistics counted by number of MBs (not sub-blocks) ***/
8191
8192 /*** Intra16x16 + Intra8x8 + Intra4x4 ***/
8193
8194 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8195 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8196 miLoadRegImmParams.dwData = 0xFFFF0000;
8197 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8198 miLoadRegImmParams.dwData = 0;
8199 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8200 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8201
8202 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8203 // DW4 Intra16x16:Intra8x8
8204 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8205 miLoadRegMemParams.dwOffset = 4 * sizeof(uint32_t);
8206 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8207 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8208 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8209 miLoadRegImmParams.dwData = 0;
8210 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8211
8212 MOS_ZeroMemory(&miMathParams, sizeof(miMathParams));
8213
8214 MHW_MI_ALU_PARAMS aluParams[4 + 16 * 4];
8215 int aluCount;
8216
8217 auto Reg0OpReg4ToReg0 = [&](MHW_MI_ALU_OPCODE opCode) {
8218 aluCount = 0;
8219 // load SrcA, reg0
8220 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8221 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
8222 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
8223 ++aluCount;
8224 // load SrcB, reg4
8225 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8226 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
8227 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG4;
8228 ++aluCount;
8229 // and SrcA, SrcB
8230 aluParams[aluCount].AluOpcode = opCode;
8231 ++aluCount;
8232
8233 // store reg0, accu
8234 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
8235 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
8236 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
8237 ++aluCount;
8238
8239 miMathParams.dwNumAluParams = aluCount;
8240 miMathParams.pAluPayload = aluParams;
8241 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiMathCmd(cmdBuffer, &miMathParams));
8242 return MOS_STATUS_SUCCESS;
8243 };
8244
8245 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_AND)); // reg0 0:0:intra16x16:0
8246
8247 // DW5 Intra4x4:Inter16x16
8248 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8249 miLoadRegMemParams.dwOffset = 5 * sizeof(uint32_t);
8250 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8251 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8252 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8253 miLoadRegImmParams.dwData = 0;
8254 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams)); // reg4 0:0:intra4x4:inter16x16(garb)
8255
8256 auto AddHighShortsOfReg0Reg4ToReg0 = [&]() {
8257 aluCount = 0;
8258 // load SrcA, reg0
8259 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8260 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
8261 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
8262 ++aluCount;
8263 // load SrcB, reg4
8264 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8265 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
8266 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG4;
8267 ++aluCount;
8268 // add SrcA, SrcB
8269 aluParams[aluCount].AluOpcode = MHW_MI_ALU_ADD;
8270 ++aluCount;
8271
8272 // ACCU keeps now 0:0:reg0+reg4:0
8273
8274 // 16bit shift left
8275 for (int i = 0; i < 16; ++i)
8276 {
8277 // store reg0, accu
8278 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
8279 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
8280 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
8281 ++aluCount;
8282 // load SrcA, accu
8283 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8284 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCA;
8285 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
8286 ++aluCount;
8287 // load SrcB, accu
8288 aluParams[aluCount].AluOpcode = MHW_MI_ALU_LOAD;
8289 aluParams[aluCount].Operand1 = MHW_MI_ALU_SRCB;
8290 aluParams[aluCount].Operand2 = MHW_MI_ALU_GPREG0;
8291 ++aluCount;
8292 // add SrcA, SrcB
8293 aluParams[aluCount].AluOpcode = MHW_MI_ALU_ADD;
8294 ++aluCount;
8295 }
8296
8297 // store reg0, accu
8298 aluParams[aluCount].AluOpcode = MHW_MI_ALU_STORE;
8299 aluParams[aluCount].Operand1 = MHW_MI_ALU_GPREG0;
8300 aluParams[aluCount].Operand2 = MHW_MI_ALU_ACCU;
8301 ++aluCount;
8302
8303 miMathParams.dwNumAluParams = aluCount;
8304 miMathParams.pAluPayload = aluParams;
8305 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiMathCmd(cmdBuffer, &miMathParams));
8306
8307 // move from reg0hi to reg0lo
8308 MOS_ZeroMemory(&miLoadRegRegParams, sizeof(miLoadRegRegParams));
8309 miLoadRegRegParams.dwSrcRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8310 miLoadRegRegParams.dwDstRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8311 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterRegCmd(cmdBuffer, &miLoadRegRegParams));
8312 miLoadRegImmParams.dwData = 0;
8313 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8314 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8315
8316 return MOS_STATUS_SUCCESS;
8317 };
8318
8319 CODECHAL_ENCODE_CHK_STATUS_RETURN(AddHighShortsOfReg0Reg4ToReg0()); // reg0 0:0:(Intra4x4+Intra16x16).hi:(Intra4x4+Intra16x16).lo
8320
8321 // Temp store from reg0 to presMetadataBuffer
8322 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8323 miStoreRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8324 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwIntraCodingUnitsCount;
8325 miStoreRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8326 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8327
8328 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8329 // DW4 Intra16x16:Intra8x8
8330 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8331 miLoadRegMemParams.dwOffset = 4 * sizeof(uint32_t);
8332 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8333 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8334
8335 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8336 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8337 miLoadRegImmParams.dwData = 0x0000FFFF;
8338 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8339 miLoadRegImmParams.dwData = 0;
8340 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8341 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8342 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_AND)); // reg0 0:0:0:Intra8x8
8343 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
8344
8345 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8346 miLoadRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8347 miLoadRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwIntraCodingUnitsCount;
8348 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8349 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8350 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_ADD));
8351
8352 // Store from reg0 to presMetadataBuffer
8353 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8354 miStoreRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8355 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwIntraCodingUnitsCount;
8356 miStoreRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8357 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8358
8359 /*** Inter16x16 + Inter16x8 + Inter8x16 + Intra8x8 ***/
8360
8361 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8362 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8363 miLoadRegImmParams.dwData = 0xFFFF0000;
8364 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8365 miLoadRegImmParams.dwData = 0;
8366 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8367 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8368
8369 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8370 // DW6 Inter16x8:Inter8x16
8371 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8372 miLoadRegMemParams.dwOffset = 6 * sizeof(uint32_t);
8373 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8374 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8375 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8376 miLoadRegImmParams.dwData = 0;
8377 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8378 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_AND)); // reg0 0:0:inter16x8:0
8379
8380 // DW7 Inter8x8:InterSkip16x16
8381 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8382 miLoadRegMemParams.dwOffset = 7 * sizeof(uint32_t);
8383 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8384 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8385 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8386 miLoadRegImmParams.dwData = 0;
8387 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams)); // reg4 0:0:inter8x8:0
8388 CODECHAL_ENCODE_CHK_STATUS_RETURN(AddHighShortsOfReg0Reg4ToReg0()); // reg0 0:0:(Inter16x8+Inter8x8).hi:(Inter16x8+Inter8x8).lo;
8389
8390 // Temp store from reg0 to presMetadataBuffer
8391 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8392 miStoreRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8393 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwInterCodingUnitsCount;
8394 miStoreRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8395 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8396
8397 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8398 // DW6 Inter16x8:Inter8x16
8399 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8400 miLoadRegMemParams.dwOffset = 6 * sizeof(uint32_t);
8401 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8402 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8403 // DW5 Intra4x4 : Inter16x16
8404 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8405 miLoadRegMemParams.dwOffset = 5 * sizeof(uint32_t);
8406 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8407 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8408
8409 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8410 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8411 miLoadRegImmParams.dwData = 0x0000FFFF;
8412 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8413 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8414 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8415 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_AND)); // reg0 0:Inter8x16:0:Inter16x16
8416
8417 // move from reg0hi to reg4lo
8418 MOS_ZeroMemory(&miLoadRegRegParams, sizeof(miLoadRegRegParams));
8419 miLoadRegRegParams.dwSrcRegister = mmioRegisters->generalPurposeRegister0HiOffset;
8420 miLoadRegRegParams.dwDstRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8421 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterRegCmd(cmdBuffer, &miLoadRegRegParams));
8422 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_ADD)); // reg0 0:0:(Inter8x16+Inter16x16).hi::(Inter8x16+Inter16x16).hi
8423 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
8424
8425 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8426 miLoadRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8427 miLoadRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwInterCodingUnitsCount;
8428 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8429 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8430 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_ADD));
8431
8432 // Store from reg0 to presMetadataBuffer
8433 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8434 miStoreRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8435 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwInterCodingUnitsCount;
8436 miStoreRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8437 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8438
8439 /*** Inter skip 16x16 ***/
8440
8441 MOS_ZeroMemory(&miLoadRegImmParams, sizeof(miLoadRegImmParams));
8442 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4LoOffset;
8443 miLoadRegImmParams.dwData = 0x0000FFFF;
8444 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8445 miLoadRegImmParams.dwData = 0;
8446 miLoadRegImmParams.dwRegister = mmioRegisters->generalPurposeRegister4HiOffset;
8447 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(cmdBuffer, &miLoadRegImmParams));
8448
8449 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
8450 // DW7 Inter8x8:InterSkip16x16
8451 miLoadRegMemParams.presStoreBuffer = pPakFrameStat;
8452 miLoadRegMemParams.dwOffset = 7 * sizeof(uint32_t);
8453 miLoadRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8454 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(cmdBuffer, &miLoadRegMemParams));
8455 CODECHAL_ENCODE_CHK_STATUS_RETURN(Reg0OpReg4ToReg0(MHW_MI_ALU_AND));
8456
8457 // Store from reg0 to presMetadataBuffer
8458 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8459 miStoreRegMemParams.presStoreBuffer = m_presMetadataBuffer;
8460 miStoreRegMemParams.dwOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwSkipCodingUnitsCount;
8461 miStoreRegMemParams.dwRegister = mmioRegisters->generalPurposeRegister0LoOffset;
8462 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8463
8464
8465 // Average MV_X/MV_Y, report (0,0) as temp solution, later may need kernel involved
8466 storeDataParams.dwResourceOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwAverageMotionEstimationXDirection;
8467 storeDataParams.dwValue = 0;
8468 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8469
8470 storeDataParams.dwResourceOffset = m_metaDataOffset.dwEncodeStats + m_metaDataOffset.dwAverageMotionEstimationYDirection;
8471 storeDataParams.dwValue = 0;
8472 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8473
8474 return eStatus;
8475 }
8476
8477 MOS_STATUS CodechalVdencAvcState::AddVdencBrcImgBuffer(
8478 PMOS_RESOURCE vdencBrcImgBuffer,
8479 PMHW_VDBOX_AVC_IMG_PARAMS params)
8480 {
8481 CODECHAL_ENCODE_FUNCTION_ENTER;
8482
8483 CODECHAL_ENCODE_CHK_NULL_RETURN(vdencBrcImgBuffer);
8484 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
8485 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hwInterface);
8486
8487 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AddVdencBrcImgBuffer(
8488 vdencBrcImgBuffer,
8489 params));
8490
8491 return MOS_STATUS_SUCCESS;
8492 }
8493
8494 MOS_STATUS CodechalVdencAvcState::SetCommonSliceState(
8495 CODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS &packSlcHeaderParams,
8496 MHW_VDBOX_AVC_SLICE_STATE & sliceState)
8497 {
8498 CODECHAL_ENCODE_FUNCTION_ENTER;
8499
8500 auto avcSlcParams = m_avcSliceParams;
8501 auto avcPicParams = m_avcPicParams[avcSlcParams->pic_parameter_set_id];
8502
8503 MOS_ZeroMemory(&packSlcHeaderParams, sizeof(packSlcHeaderParams));
8504 packSlcHeaderParams.pBsBuffer = &m_bsBuffer;
8505 packSlcHeaderParams.pPicParams = avcPicParams;
8506 packSlcHeaderParams.pSeqParams = m_avcSeqParam;
8507 packSlcHeaderParams.ppRefList = &(m_refList[0]);
8508 packSlcHeaderParams.CurrPic = m_currOriginalPic;
8509 packSlcHeaderParams.CurrReconPic = m_currReconstructedPic;
8510 packSlcHeaderParams.UserFlags = m_userFlags;
8511 packSlcHeaderParams.NalUnitType = m_nalUnitType;
8512 packSlcHeaderParams.wPictureCodingType = m_pictureCodingType;
8513 packSlcHeaderParams.bVdencEnabled = true;
8514
8515 MOS_ZeroMemory(&sliceState, sizeof(sliceState));
8516 sliceState.presDataBuffer = &m_resMbCodeSurface;
8517 sliceState.pAvcPicIdx = &(m_picIdx[0]);
8518 sliceState.pEncodeAvcSeqParams = m_avcSeqParam;
8519 sliceState.pEncodeAvcPicParams = avcPicParams;
8520 sliceState.pBsBuffer = &m_bsBuffer;
8521 sliceState.ppNalUnitParams = m_nalUnitParams;
8522 sliceState.bBrcEnabled = false;
8523 // Disable Panic mode when min/max QP control is on. kernel may disable it, but disable in driver also.
8524 sliceState.bRCPanicEnable = m_panicEnable && (!m_minMaxQpControlEnabled);
8525 sliceState.bAcceleratorHeaderPackingCaps = m_encodeParams.bAcceleratorHeaderPackingCaps;
8526 sliceState.wFrameFieldHeightInMB = m_frameFieldHeightInMb;
8527
8528 return MOS_STATUS_SUCCESS;
8529 }
8530
8531 MOS_STATUS CodechalVdencAvcState::SetSliceState(
8532 CODECHAL_ENCODE_AVC_PACK_SLC_HEADER_PARAMS &packSlcHeaderParams,
8533 MHW_VDBOX_AVC_SLICE_STATE & sliceState,
8534 uint16_t slcIdx)
8535 {
8536 CODECHAL_ENCODE_FUNCTION_ENTER;
8537 auto avcSlcParams = m_avcSliceParams;
8538 auto slcData = m_slcData;
8539
8540 if (m_currPass == 0)
8541 {
8542 packSlcHeaderParams.pAvcSliceParams = &avcSlcParams[slcIdx];
8543 if (m_acceleratorHeaderPackingCaps)
8544 {
8545 slcData[slcIdx].SliceOffset = m_bsBuffer.SliceOffset;
8546 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalAvcEncode_PackSliceHeader(&packSlcHeaderParams));
8547 slcData[slcIdx].BitSize = m_bsBuffer.BitSize;
8548 }
8549 if (m_sliceStructCaps != CODECHAL_SLICE_STRUCT_ARBITRARYMBSLICE)
8550 {
8551 slcData[slcIdx].CmdOffset = slcIdx * m_sliceHeight * m_picWidthInMb * 16 * 4;
8552 }
8553 else
8554 {
8555 slcData[slcIdx].CmdOffset = packSlcHeaderParams.pAvcSliceParams->first_mb_in_slice * 16 * 4;
8556 }
8557 }
8558
8559 sliceState.pEncodeAvcSliceParams = &avcSlcParams[slcIdx];
8560 sliceState.dwDataBufferOffset =
8561 m_slcData[slcIdx].CmdOffset + m_mbcodeBottomFieldOffset;
8562 sliceState.dwOffset = slcData[slcIdx].SliceOffset;
8563 sliceState.dwLength = slcData[slcIdx].BitSize;
8564 sliceState.uiSkipEmulationCheckCount = slcData[slcIdx].SkipEmulationByteCount;
8565 sliceState.dwSliceIndex = slcIdx;
8566 sliceState.bFirstPass = (m_currPass == 0);
8567 sliceState.bLastPass = (m_currPass == m_numPasses);
8568 sliceState.bInsertBeforeSliceHeaders = (slcIdx == 0);
8569 sliceState.bVdencInUse = true;
8570 // App handles tail insertion for VDEnc dynamic slice in non-cp case
8571 sliceState.bVdencNoTailInsertion = m_vdencNoTailInsertion;
8572
8573 uint32_t batchBufferForPakSlicesStartOffset =
8574 (uint32_t)m_batchBufferForPakSlices[m_currRecycledBufIdx].iCurrent;
8575
8576 if (m_avcRoundingParams != nullptr && m_avcRoundingParams->bEnableCustomRoudingIntra)
8577 {
8578 sliceState.dwRoundingIntraValue = m_avcRoundingParams->dwRoundingIntra;
8579 }
8580 else
8581 {
8582 sliceState.dwRoundingIntraValue = 5;
8583 }
8584 if (m_avcRoundingParams != nullptr && m_avcRoundingParams->bEnableCustomRoudingInter)
8585 {
8586 sliceState.bRoundingInterEnable = true;
8587 sliceState.dwRoundingValue = m_avcRoundingParams->dwRoundingInter;
8588 }
8589 else
8590 {
8591 sliceState.bRoundingInterEnable = m_roundingInterEnable;
8592 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRounding(m_avcRoundingParams, &sliceState));
8593 }
8594
8595 sliceState.oneOnOneMapping = m_oneOnOneMapping;
8596
8597 return MOS_STATUS_SUCCESS;
8598 }
8599
8600 MOS_STATUS CodechalVdencAvcState::ReportSliceSizeMetaData(
8601 PMOS_RESOURCE presMetadataBuffer,
8602 PMOS_COMMAND_BUFFER cmdBuffer,
8603 uint32_t slcCount)
8604 {
8605 CODECHAL_ENCODE_FUNCTION_ENTER;
8606 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8607
8608 if (!presMetadataBuffer)
8609 {
8610 return eStatus;
8611 }
8612
8613 MHW_MI_STORE_DATA_PARAMS storeDataParams;
8614 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
8615 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8616
8617 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8618 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
8619 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8620
8621 // get access to the MMIO registers
8622 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8623 MmioRegistersMfx *mmioRegisters = m_hwInterface->SelectVdboxAndGetMmioRegister(m_vdboxIndex, cmdBuffer);
8624
8625 uint32_t subRegionStartOffset = m_metaDataOffset.dwMetaDataSize + slcCount * m_metaDataOffset.dwMetaDataSubRegionSize;
8626
8627 storeDataParams.pOsResource = presMetadataBuffer;
8628
8629 // Add flush command to ensure that slice size has been written to register
8630 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
8631
8632 // Report the slice offset to metadata buffer
8633 storeDataParams.dwResourceOffset = subRegionStartOffset + m_metaDataOffset.dwbStartOffset;
8634 storeDataParams.dwValue = 0; //m_slcData[slcCount].SliceOffset;
8635 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8636
8637 // Report the slice header size to metadata buffer
8638 storeDataParams.dwResourceOffset = subRegionStartOffset + m_metaDataOffset.dwbHeaderSize;
8639 storeDataParams.dwValue = m_slcData[slcCount].BitSize;
8640 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
8641
8642 // Report the slice size from mfcBitstreamBytecountSliceRegOffset to metadata buffer
8643 miStoreRegMemParams.presStoreBuffer = presMetadataBuffer;
8644 miStoreRegMemParams.dwOffset = subRegionStartOffset + m_metaDataOffset.dwbSize;
8645 miStoreRegMemParams.dwRegister = mmioRegisters->mfcBitstreamBytecountSliceRegOffset;
8646 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &miStoreRegMemParams));
8647
8648 return eStatus;
8649 }
8650
8651 void CodechalVdencAvcState::SetBufferToStorePakStatistics()
8652 {
8653 CODECHAL_ENCODE_FUNCTION_ENTER;
8654
8655 // Set HuC DMEM buffers which need to be updated.
8656 // They are first pass of next frame and next pass of current frame, as the 2nd VDEnc+PAK pass may not be triggered.
8657 uint32_t nextRecycledBufIdx = (m_currRecycledBufIdx + 1) % CODECHAL_ENCODE_RECYCLED_BUFFER_NUM;
8658 uint32_t nextPass = (m_currPass + 1) % CODECHAL_VDENC_BRC_NUM_OF_PASSES;
8659 m_resVdencBrcUpdateDmemBufferPtr[0] = &m_resVdencBrcUpdateDmemBuffer[nextRecycledBufIdx][0];
8660 if (m_lastTaskInPhase)
8661 {
8662 // last pass of current frame, no next pass
8663 m_resVdencBrcUpdateDmemBufferPtr[1] = nullptr;
8664 }
8665 else
8666 {
8667 m_resVdencBrcUpdateDmemBufferPtr[1] = &m_resVdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][nextPass];
8668 }
8669 }
8670
8671 uint32_t CodechalVdencAvcState::GetCurrConstDataBufIdx()
8672 {
8673 return m_avcPicParam->CodingType - 1;
8674 }
8675
8676 #if USE_CODECHAL_DEBUG_TOOL
8677 MOS_STATUS CodechalVdencAvcState::DumpHucBrcInit()
8678 {
8679 CODECHAL_ENCODE_FUNCTION_ENTER;
8680
8681 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
8682
8683 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucDmem(
8684 &m_resVdencBrcInitDmemBuffer[m_currRecycledBufIdx],
8685 m_vdencBrcInitDmemBufferSize,
8686 m_currPass,
8687 hucRegionDumpInit));
8688
8689 // History Buffer dump
8690 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8691 &m_resVdencBrcHistoryBuffer,
8692 0,
8693 CODECHAL_VDENC_AVC_BRC_HISTORY_BUF_SIZE,
8694 0,
8695 "_History",
8696 0,
8697 m_currPass,
8698 hucRegionDumpInit));
8699 return MOS_STATUS_SUCCESS;
8700 }
8701
8702 MOS_STATUS CodechalVdencAvcState::DumpHucBrcUpdate(bool isInput)
8703 {
8704 CODECHAL_ENCODE_FUNCTION_ENTER;
8705
8706 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
8707
8708 if (isInput)
8709 {
8710 //HUC DMEM dump
8711 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucDmem(
8712 &m_resVdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][m_currPass],
8713 m_vdencBrcUpdateDmemBufferSize,
8714 m_currPass,
8715 hucRegionDumpUpdate));
8716
8717 // History Buffer dump
8718 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8719 &m_resVdencBrcHistoryBuffer,
8720 0,
8721 CODECHAL_VDENC_AVC_BRC_HISTORY_BUF_SIZE,
8722 0,
8723 "_History",
8724 isInput,
8725 m_currPass,
8726 hucRegionDumpUpdate));
8727
8728 // VDENC Statistics Buffer dump
8729 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8730 &m_vdencStatsBuffer,
8731 0,
8732 m_vdencBrcStatsBufferSize,
8733 1,
8734 "_VdencStats",
8735 isInput,
8736 m_currPass,
8737 hucRegionDumpUpdate));
8738
8739 // PAK Statistics Buffer dump
8740 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8741 &m_pakStatsBuffer,
8742 0,
8743 m_vdencBrcPakStatsBufferSize,
8744 2,
8745 "_PakStats",
8746 isInput,
8747 m_currPass,
8748 hucRegionDumpUpdate));
8749
8750 // VDENC Img State Read Buffer dump
8751 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8752 &m_resVdencBrcImageStatesReadBuffer[m_currRecycledBufIdx],
8753 0,
8754 GetVdencBRCImgStateBufferSize(),
8755 3,
8756 "_ImageStateRead",
8757 isInput,
8758 m_currPass,
8759 hucRegionDumpUpdate));
8760
8761 // SFD output buffer dump
8762 if (m_staticFrameDetectionInUse)
8763 {
8764 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8765 &m_resSfdOutputBuffer[m_currRecycledBufIdx],
8766 0,
8767 sizeof(CODECHAL_ENCODE_AVC_SFD_OUTPUT_BUFFER_SIZE_COMMON),
8768 4,
8769 "_SfdOutput",
8770 isInput,
8771 m_currPass,
8772 hucRegionDumpUpdate));
8773 }
8774
8775 // Constant Data Buffer dump
8776 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8777 &m_resVdencBrcConstDataBuffer[GetCurrConstDataBufIdx()],
8778 0,
8779 GetBRCCostantDataSize(),
8780 5,
8781 "_ConstData",
8782 isInput,
8783 m_currPass,
8784 hucRegionDumpUpdate));
8785
8786 // Slice size Buffer dump
8787 if (m_sliceSizeStreamoutSupported)
8788 {
8789 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8790 &m_pakSliceSizeStreamoutBuffer,
8791 0,
8792 CODECHAL_ENCODE_SLICESIZE_BUF_SIZE,
8793 7,
8794 "_SliceSizeStreamOut",
8795 isInput,
8796 m_currPass,
8797 hucRegionDumpUpdate));
8798 }
8799
8800 // BRC non-native ROI
8801 if (m_avcPicParam->NumROI && !m_avcPicParam->bNativeROI && m_vdencBrcEnabled)
8802 {
8803 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8804 &m_resVdencBrcRoiBuffer[m_currRecycledBufIdx],
8805 0,
8806 m_picWidthInMb * m_picHeightInMb,
8807 8,
8808 "_BrcROI_idxs",
8809 isInput,
8810 m_currPass,
8811 hucRegionDumpUpdate));
8812 }
8813
8814 // VDEnc StreamIn
8815 if (m_avcPicParam->NumROI && !m_avcPicParam->bNativeROI && m_vdencBrcEnabled)
8816 {
8817 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8818 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
8819 0,
8820 m_picWidthInMb * m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
8821 9,
8822 "_VDEnc_StreamIn",
8823 isInput,
8824 m_currPass,
8825 hucRegionDumpUpdate));
8826 }
8827 }
8828 else
8829 {
8830 // History Buffer dump
8831 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8832 &m_resVdencBrcHistoryBuffer,
8833 0,
8834 CODECHAL_VDENC_AVC_BRC_HISTORY_BUF_SIZE,
8835 0,
8836 "_History",
8837 isInput,
8838 m_currPass,
8839 hucRegionDumpUpdate));
8840
8841 // VDENC Img State Write Buffer dump
8842 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8843 &m_batchBufferForVdencImgStat[0].OsResource,
8844 0,
8845 GetVdencBRCImgStateBufferSize(),
8846 6,
8847 "_ImageStateWrite",
8848 isInput,
8849 m_currPass,
8850 hucRegionDumpUpdate));
8851
8852 // VDEnc StreamIn
8853 if (m_avcPicParam->NumROI && !m_avcPicParam->bNativeROI && m_vdencBrcEnabled)
8854 {
8855 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8856 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
8857 0,
8858 m_picWidthInMb * m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
8859 10,
8860 "_VDEnc_StreamIn",
8861 isInput,
8862 m_currPass,
8863 hucRegionDumpUpdate));
8864 }
8865
8866 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
8867 &m_resVdencBrcDbgBuffer,
8868 0,
8869 CODECHAL_VDENC_AVC_BRC_DEBUG_BUF_SIZE,
8870 15,
8871 "_Debug",
8872 isInput,
8873 m_currPass,
8874 hucRegionDumpUpdate));
8875 }
8876
8877 return MOS_STATUS_SUCCESS;
8878 }
8879
8880 uint32_t CodechalVdencAvcState::GetPakVDEncPassDumpSize()
8881 {
8882 return m_mfxInterface->GetAvcImgStateSize() +
8883 m_vdencInterface->GetVdencAvcCostStateSize() +
8884 m_vdencInterface->GetVdencCmd3Size() +
8885 m_vdencInterface->GetVdencAvcImgStateSize();
8886 }
8887
8888 MOS_STATUS CodechalVdencAvcState::DumpEncodeImgStats(
8889 PMOS_COMMAND_BUFFER cmdbuffer)
8890 {
8891 CODECHAL_DEBUG_FUNCTION_ENTER;
8892
8893 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
8894
8895 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrImageState))
8896 {
8897 return MOS_STATUS_SUCCESS;
8898 }
8899
8900 uint32_t size = GetPakVDEncPassDumpSize();
8901
8902 std::string SurfName = "Pak_VDEnc_Pass[" + std::to_string(static_cast<uint32_t>(m_currPass)) + "]";
8903
8904 // MFX_AVC_IMG_STATE
8905 if (m_vdencBrcEnabled)
8906 {
8907 // BRC case: both MFX_AVC_IMG_STATE and VDENC_IMG_STATE are updated by HuC FW
8908 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
8909 &m_batchBufferForVdencImgStat[0].OsResource,
8910 CodechalDbgAttr::attrImageState,
8911 SurfName.c_str(),
8912 size,
8913 0,
8914 CODECHAL_NUM_MEDIA_STATES));
8915 }
8916 else
8917 {
8918 // CQP case: updated by driver or SFD kernel
8919 if (!m_staticFrameDetectionInUse)
8920 {
8921 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
8922 &m_batchBufferForVdencImgStat[m_currRecycledBufIdx].OsResource,
8923 CodechalDbgAttr::attrImageState,
8924 SurfName.c_str(),
8925 size,
8926 0,
8927 CODECHAL_NUM_MEDIA_STATES));
8928 }
8929 else
8930 {
8931 if (!cmdbuffer->pCmdPtr)
8932 {
8933 return MOS_STATUS_INVALID_PARAMETER;
8934 }
8935
8936 uint8_t *data = (uint8_t *)MOS_AllocAndZeroMemory(size);
8937 CODECHAL_DEBUG_CHK_NULL(data);
8938
8939 // MFX AVC IMG STATE is updated by driver
8940 uint8_t *mfxData = (uint8_t *)(cmdbuffer->pCmdPtr - (m_mfxInterface->GetAvcImgStateSize() / sizeof(uint32_t)));
8941 CODECHAL_DEBUG_CHK_NULL(mfxData);
8942 MOS_SecureMemcpy(data, m_mfxInterface->GetAvcImgStateSize(), mfxData, m_mfxInterface->GetAvcImgStateSize());
8943
8944 // VDENC IMG STATE is updated by SFD kernel
8945 MOS_LOCK_PARAMS lockFlags;
8946 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
8947 lockFlags.ReadOnly = 1;
8948 uint8_t *vdencData = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, &m_batchBufferForVdencImgStat[m_currRecycledBufIdx].OsResource, &lockFlags);
8949 CODECHAL_DEBUG_CHK_NULL(vdencData);
8950 MOS_SecureMemcpy((data + m_mfxInterface->GetAvcImgStateSize()), m_vdencInterface->GetVdencAvcImgStateSize(), vdencData, m_vdencInterface->GetVdencAvcImgStateSize());
8951 m_osInterface->pfnUnlockResource(m_osInterface, &m_batchBufferForVdencImgStat[m_currRecycledBufIdx].OsResource);
8952
8953 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpData(
8954 data,
8955 size,
8956 CodechalDbgAttr::attrImageState,
8957 SurfName.c_str()));
8958
8959 MOS_FreeMemory(data);
8960 }
8961 }
8962
8963 return MOS_STATUS_SUCCESS;
8964 }
8965
8966 MOS_STATUS CodechalVdencAvcState::PopulateHmeParam(
8967 bool is16xMeEnabled,
8968 bool is32xMeEnabled,
8969 uint8_t meMethod,
8970 void * cmd)
8971 {
8972 CODECHAL_DEBUG_FUNCTION_ENTER;
8973
8974 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
8975
8976 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDumpEncodePar))
8977 {
8978 return MOS_STATUS_SUCCESS;
8979 }
8980
8981 CODECHAL_ENCODE_AVC_ME_CURBE *curbe = (CODECHAL_ENCODE_AVC_ME_CURBE *)cmd;
8982
8983 if (m_pictureCodingType == P_TYPE)
8984 {
8985 m_avcPar->SuperHME = is16xMeEnabled;
8986 m_avcPar->UltraHME = is32xMeEnabled;
8987 m_avcPar->SuperCombineDist = curbe->DW6.SuperCombineDist;
8988 m_avcPar->StreamInEnable = is16xMeEnabled;
8989 m_avcPar->StreamInL0FromNewRef = is16xMeEnabled ? 7 : 0;
8990 m_avcPar->StreamInL1FromNewRef = 0;
8991 m_avcPar->MEMethod = meMethod;
8992 }
8993
8994 return MOS_STATUS_SUCCESS;
8995 }
8996
8997 MOS_STATUS CodechalVdencAvcState::DumpFrameParFile()
8998 {
8999 CODECHAL_DEBUG_FUNCTION_ENTER;
9000
9001 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
9002
9003 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDumpEncodePar))
9004 {
9005 return MOS_STATUS_SUCCESS;
9006 }
9007
9008 std::ostringstream oss;
9009 oss.setf(std::ios::showbase | std::ios::uppercase);
9010
9011 if (m_pictureCodingType == I_TYPE)
9012 {
9013 // I Slice Parameters
9014 // DDI Params
9015 oss << "ProfileIDC = " << std::dec << +m_avcPar->ProfileIDC << std::endl;
9016 oss << "LevelIDC = " << std::dec << +m_avcPar->LevelIDC << std::endl;
9017 oss << "DisableVUIHeader = " << std::dec << +m_avcPar->DisableVUIHeader << std::endl;
9018 oss << "ChromaFormatIDC = " << std::dec << +m_avcPar->ChromaFormatIDC << std::endl;
9019 oss << "ChromaQpOffset = " << std::dec << +m_avcPar->ChromaQpOffset << std::endl;
9020 oss << "SecondChromaQpOffset = " << std::dec << +m_avcPar->SecondChromaQpOffset << std::endl;
9021 oss << "PictureCodingType = " << std::dec << +m_avcPar->PictureCodingType << std::endl;
9022 oss << "NumP = " << std::dec << +m_avcPar->NumP << std::endl;
9023 oss << "NumB = " << std::dec << +m_avcPar->NumB << std::endl;
9024 oss << "NumSlices = " << std::dec << +m_avcPar->NumSlices << std::endl;
9025 oss << "ISliceQP = " << std::dec << +m_avcPar->ISliceQP << std::endl;
9026 oss << "FrameRateM = " << std::dec << +m_avcPar->FrameRateM << std::endl;
9027 oss << "FrameRateD = " << std::dec << +m_avcPar->FrameRateD << std::endl;
9028 oss << "BRCMethod = " << std::dec << +m_avcPar->BRCMethod << std::endl;
9029 oss << "BRCType = " << std::dec << +m_avcPar->BRCType << std::endl;
9030 oss << "DeblockingIDC = " << std::dec << +m_avcPar->DeblockingIDC << std::endl;
9031 oss << "DeblockingFilterAlpha = " << std::dec << +m_avcPar->DeblockingFilterAlpha << std::endl;
9032 oss << "DeblockingFilterBeta = " << std::dec << +m_avcPar->DeblockingFilterBeta << std::endl;
9033 oss << "EntropyCodingMode = " << std::dec << +m_avcPar->EntropyCodingMode << std::endl;
9034 oss << "DirectInference = " << std::dec << +m_avcPar->DirectInference << std::endl;
9035 oss << "Transform8x8Mode = " << std::dec << +m_avcPar->Transform8x8Mode << std::endl;
9036 oss << "CRFQualityFactor = " << std::dec << +m_avcPar->CRFQualityFactor << std::endl;
9037 oss << "ConstrainedIntraPred = " << std::dec << +m_avcPar->ConstrainedIntraPred << std::endl;
9038 if (m_avcPar->NumP == 0) // There's no P frame
9039 {
9040 oss << "MaxRefIdxL0 = " << std::dec << +m_avcPar->MaxRefIdxL0 << std::endl;
9041 oss << "MaxRefIdxL1 = " << std::dec << +m_avcPar->MaxRefIdxL1 << std::endl;
9042 }
9043 oss << "SliceMode = " << std::dec << +m_avcPar->SliceMode << std::endl;
9044 if (m_avcPar->SliceMode == 2)
9045 {
9046 oss << "MaxNumSlicesCheckEnable = 1" << std::endl;
9047 }
9048
9049 // DS Params
9050 oss << "MBFlatnessThreshold = " << std::dec << +m_encodeParState->m_commonPar->mbFlatnessThreshold << std::endl;
9051
9052 // BRC init Params
9053 oss << "MBBRCEnable = " << std::dec << +m_avcPar->MBBRCEnable << std::endl;
9054 oss << "MBRC = " << std::dec << +m_avcPar->MBRC << std::endl;
9055 oss << "BitRate = " << std::dec << +m_avcPar->BitRate << std::endl;
9056 oss << "InitVbvFullnessInBit = " << std::dec << +m_avcPar->InitVbvFullnessInBit << std::endl;
9057 oss << "MaxBitRate = " << std::dec << +m_avcPar->MaxBitRate << std::endl;
9058 oss << "VbvSzInBit = " << std::dec << +m_avcPar->VbvSzInBit << std::endl;
9059 oss << "UserMaxFrame = " << std::dec << +m_avcPar->UserMaxFrame << std::endl;
9060 oss << "SlidingWindowRCEnable = " << std::dec << +m_avcPar->SlidingWindowEnable << std::endl;
9061 oss << "SlidingWindowSize = " << std::dec << +m_avcPar->SlidingWindowSize << std::endl;
9062 oss << "SlidingWindowMaxRateRatio = " << std::dec << +m_avcPar->SlidingWindowMaxRateRatio << std::endl;
9063 oss << "LowDelayGoldenFrameBoost = " << std::dec << +m_avcPar->LowDelayGoldenFrameBoost << std::endl;
9064 oss << "TopQPDeltaThrforAdaptive2Pass = " << std::dec << +m_avcPar->TopQPDeltaThrforAdaptive2Pass << std::endl;
9065 oss << "BotQPDeltaThrforAdaptive2Pass = " << std::dec << +m_avcPar->BotQPDeltaThrforAdaptive2Pass << std::endl;
9066 oss << "TopFrmSzPctThrforAdaptive2Pass = " << std::dec << +m_avcPar->TopFrmSzPctThrforAdaptive2Pass << std::endl;
9067 oss << "BotFrmSzPctThrforAdaptive2Pass = " << std::dec << +m_avcPar->BotFrmSzPctThrforAdaptive2Pass << std::endl;
9068 oss << "MBHeaderCompensation = " << std::dec << +m_avcPar->MBHeaderCompensation << std::endl;
9069 oss << "QPSelectMethodforFirstPass = " << std::dec << +m_avcPar->QPSelectMethodforFirstPass << std::endl;
9070 oss << "MBQpCtrl = " << std::dec << +m_avcPar->MBQpCtrl << std::endl;
9071 oss << "QPMax = " << std::dec << +m_avcPar->QPMax << std::endl;
9072 oss << "QPMin = " << std::dec << +m_avcPar->QPMin << std::endl;
9073 oss << "HrdConformanceCheckDisable = " << std::dec << +m_avcPar->HrdConformanceCheckDisable << std::endl;
9074 oss << "ICQReEncode = " << std::dec << +m_avcPar->ICQReEncode << std::endl;
9075 oss << "AdaptiveCostAdjustEnable = " << std::dec << +m_avcPar->AdaptiveCostAdjustEnable << std::endl;
9076 oss << "AdaptiveHMEExtension = " << std::dec << +m_avcPar->AdaptiveHMEExtension << std::endl;
9077 oss << "StreamInStaticRegion = " << std::dec << +m_avcPar->StreamInStaticRegion << std::endl;
9078 oss << "ScenarioInfo = " << std::dec << +m_avcPar->ScenarioInfo << std::endl;
9079 if (m_avcPar->SliceMode == 2)
9080 {
9081 oss << "SliceSizeWA = " << std::dec << +m_avcPar->SliceSizeWA << std::endl;
9082 }
9083
9084 // BRC frame update Params
9085 oss << "EnableMultipass = " << std::dec << +m_avcPar->EnableMultipass << std::endl;
9086 oss << "MaxNumPakPasses = " << std::dec << +m_avcPar->MaxNumPakPasses << std::endl;
9087 oss << "SceneChgDetectEn = " << std::dec << +m_avcPar->SceneChgDetectEn << std::endl;
9088 oss << "SceneChgPrevIntraPctThresh = " << std::dec << +m_avcPar->SceneChgPrevIntraPctThresh << std::endl;
9089 oss << "SceneChgCurIntraPctThresh = " << std::dec << +m_avcPar->SceneChgCurIntraPctThresh << std::endl;
9090 oss << "SceneChgWidth0 = " << std::dec << +m_avcPar->SceneChgWidth0 << std::endl;
9091 oss << "SceneChgWidth1 = " << std::dec << +m_avcPar->SceneChgWidth1 << std::endl;
9092 if (m_avcPar->SliceMode == 2)
9093 {
9094 oss << "SliceSizeThr = " << std::dec << +m_avcPar->SliceSizeThr << std::endl;
9095 oss << "SliceMaxSize = " << std::dec << +m_avcPar->SliceMaxSize << std::endl;
9096 }
9097
9098 // Enc Params
9099 oss << "BlockBasedSkip = " << std::dec << +m_avcPar->BlockBasedSkip << std::endl;
9100 oss << "VDEncPerfMode = " << std::dec << +m_avcPar->VDEncPerfMode << std::endl;
9101
9102 // PAK Params
9103 oss << "TrellisQuantizationEnable = " << std::dec << +m_avcPar->TrellisQuantizationEnable << std::endl;
9104 oss << "RoundingIntraEnabled = " << std::dec << +m_avcPar->RoundingIntraEnabled << std::endl;
9105 oss << "RoundingIntra = " << std::dec << +m_avcPar->RoundingIntra << std::endl;
9106 oss << "EnableAdaptiveTrellisQuantization = " << std::dec << +m_avcPar->EnableAdaptiveTrellisQuantization << std::endl;
9107 oss << "TrellisQuantizationRounding = " << std::dec << +m_avcPar->TrellisQuantizationRounding << std::endl;
9108 oss << "TrellisQuantizationChromaDisable = " << std::dec << +m_avcPar->TrellisQuantizationChromaDisable << std::endl;
9109 oss << "ExtendedRhoDomainEn = " << std::dec << +m_avcPar->ExtendedRhoDomainEn << std::endl;
9110 oss << "EnableSEI = " << std::dec << +m_avcPar->EnableSEI << std::endl;
9111 if (m_avcPar->NumP == 0) // There's no P frame
9112 {
9113 oss << "FrmHdrEncodingFrequency = " << std::dec << +m_avcPar->FrmHdrEncodingFrequency << std::endl;
9114 }
9115 oss << "VDEncMode = 1" << std::endl;
9116 oss << "EnableExternalCost = 0" << std::endl;
9117 oss << "EnableNewCost = 1" << std::endl;
9118 oss << "BestDistQPDelta0 = 0" << std::endl;
9119 oss << "BestDistQPDelta1 = 0" << std::endl;
9120 oss << "BestDistQPDelta2 = 0" << std::endl;
9121 oss << "BestDistQPDelta3 = 0" << std::endl;
9122 oss << "BestIntra4x4QPDelta = 0" << std::endl;
9123 oss << "BestIntra8x8QPDelta = 0" << std::endl;
9124 oss << "BestIntra16x16QPDelta = 0" << std::endl;
9125 }
9126 else if (m_pictureCodingType == P_TYPE)
9127 {
9128 // P Slice Parameters
9129 // DDI Params
9130 oss << "PSliceQP = " << std::dec << +m_avcPar->PSliceQP << std::endl;
9131 oss << "CabacInitIDC = " << std::dec << +m_avcPar->CabacInitIDC << std::endl;
9132 oss << "MaxRefIdxL0 = " << std::dec << +m_avcPar->MaxRefIdxL0 << std::endl;
9133 oss << "MaxRefIdxL1 = " << std::dec << +m_avcPar->MaxRefIdxL1 << std::endl;
9134 if (m_avcPar->NumB == 0) // There's no B frame
9135 {
9136 oss << "EnableWeightPredictionDetection = " << std::dec << +m_avcPar->EnableWeightPredictionDetection << std::endl;
9137 }
9138 oss << "WeightedPred = " << std::dec << +m_avcPar->WeightedPred << std::endl;
9139 if (m_avcPar->WeightedPred)
9140 {
9141 oss << "EnableWeightPredictionDetection = 1" << std::endl;
9142 oss << "FadeDetectionMethod = 1" << std::endl;
9143 }
9144 oss << "UseOrigAsRef = " << std::dec << +m_avcPar->UseOrigAsRef << std::endl;
9145 oss << "BiSubMbPartMask = " << std::dec << +m_avcPar->BiSubMbPartMask << std::endl;
9146 oss << "StaticFrameZMVPercent = " << std::dec << +m_avcPar->StaticFrameZMVPercent << std::endl;
9147 oss << "HME0XOffset = " << std::dec << +m_avcPar->hme0XOffset << std::endl;
9148 oss << "HME0YOffset = " << std::dec << +m_avcPar->hme0YOffset << std::endl;
9149 oss << "HME1XOffset = " << std::dec << +m_avcPar->hme1XOffset << std::endl;
9150 oss << "HME1YOffset = " << std::dec << +m_avcPar->hme1YOffset << std::endl;
9151
9152 // HME Params
9153 oss << "SuperHME = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->superHME : m_avcPar->SuperHME) << std::endl;
9154 oss << "UltraHME = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->ultraHME : m_avcPar->UltraHME) << std::endl;
9155 oss << "SuperCombineDist = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->superCombineDist : m_avcPar->SuperCombineDist) << std::endl;
9156 oss << "StreamInEnable = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInEnable : m_avcPar->StreamInEnable) << std::endl;
9157 oss << "StreamInL0FromNewRef = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInL0FromNewRef : m_avcPar->StreamInL0FromNewRef) << std::endl;
9158 oss << "StreamInL1FromNewRef = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInL1FromNewRef : m_avcPar->StreamInL1FromNewRef) << std::endl;
9159 oss << "MEMethod = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->meMethod : m_avcPar->MEMethod) << std::endl;
9160
9161 // Enc Params
9162 oss << "SubPelMode = " << std::dec << +m_avcPar->SubPelMode << std::endl;
9163 oss << "FTQBasedSkip = " << std::dec << +m_avcPar->FTQBasedSkip << std::endl;
9164 oss << "BiMixDisable = " << std::dec << +m_avcPar->BiMixDisable << std::endl;
9165 oss << "SurvivedSkipCost = " << std::dec << +m_avcPar->SurvivedSkipCost << std::endl;
9166 oss << "UniMixDisable = " << std::dec << +m_avcPar->UniMixDisable << std::endl;
9167 oss << "EnableIntraCostScalingForStaticFrame = " << std::dec << +m_avcPar->EnableIntraCostScalingForStaticFrame << std::endl;
9168 if (m_avcPar->EnableIntraCostScalingForStaticFrame)
9169 {
9170 oss << "IntraCostUpdateMethod = 3" << std::endl;
9171 }
9172 oss << "StaticFrameIntraCostScalingRatioP = " << std::dec << +m_avcPar->StaticFrameIntraCostScalingRatioP << std::endl;
9173 oss << "VdencExtPakObjDisable = " << std::dec << +m_avcPar->VdencExtPakObjDisable << std::endl;
9174 oss << "PPMVDisable = " << std::dec << +m_avcPar->PPMVDisable << std::endl;
9175 oss << "AdaptiveMvStreamIn = " << std::dec << +m_avcPar->AdaptiveMvStreamIn << std::endl;
9176 oss << "LargeMvThresh = " << std::dec << +m_avcPar->LargeMvThresh << std::endl;
9177 oss << "LargeMvPctThreshold = " << std::dec << +m_avcPar->LargeMvPctThreshold << std::endl;
9178
9179 // BRC Frame Update
9180 oss << "Transform8x8PDisable = " << std::dec << +m_avcPar->Transform8x8PDisable << std::endl;
9181
9182 // PAK Params
9183 oss << "RoundingInterEnabled = " << std::dec << +m_avcPar->RoundingInterEnabled << std::endl;
9184 oss << "RoundingInter = " << std::dec << +m_avcPar->RoundingInter << std::endl;
9185 oss << "FrmHdrEncodingFrequency = " << std::dec << +m_avcPar->FrmHdrEncodingFrequency << std::endl;
9186 oss << "AdaptiveRoundingEnabled = " << std::dec << +m_avcPar->EnableAdaptiveRounding << std::endl;
9187 }
9188 else
9189 {
9190 oss << "BSliceQP = " << std::dec << +m_avcPar->BSliceQP << std::endl;
9191 }
9192
9193 // Dump per frame par file
9194 const char *fileName = m_debugInterface->CreateFileName(
9195 "EncodeFrame",
9196 "EncodePar",
9197 CodechalDbgExtType::par);
9198
9199 std::ofstream ofs(fileName, std::ios::out);
9200 ofs << oss.str();
9201 ofs.close();
9202
9203 return MOS_STATUS_SUCCESS;
9204 }
9205
9206 MOS_STATUS CodechalVdencAvcState::DumpSeqParFile()
9207 {
9208 CODECHAL_DEBUG_FUNCTION_ENTER;
9209
9210 CODECHAL_DEBUG_CHK_NULL(m_debugInterface);
9211
9212 if (!m_debugInterface->DumpIsEnabled(CodechalDbgAttr::attrDumpEncodePar))
9213 {
9214 return MOS_STATUS_SUCCESS;
9215 }
9216
9217 std::ostringstream oss;
9218 oss.setf(std::ios::showbase | std::ios::uppercase);
9219
9220 // I Slice Parameters
9221 // DDI Params
9222 oss << "ProfileIDC = " << std::dec << +m_avcPar->ProfileIDC << std::endl;
9223 oss << "LevelIDC = " << std::dec << +m_avcPar->LevelIDC << std::endl;
9224 oss << "DisableVUIHeader = " << std::dec << +m_avcPar->DisableVUIHeader << std::endl;
9225 oss << "ChromaFormatIDC = " << std::dec << +m_avcPar->ChromaFormatIDC << std::endl;
9226 oss << "ChromaQpOffset = " << std::dec << +m_avcPar->ChromaQpOffset << std::endl;
9227 oss << "SecondChromaQpOffset = " << std::dec << +m_avcPar->SecondChromaQpOffset << std::endl;
9228 oss << "PictureCodingType = " << std::dec << +m_avcPar->PictureCodingType << std::endl;
9229 oss << "NumP = " << std::dec << +m_avcPar->NumP << std::endl;
9230 oss << "NumB = " << std::dec << +m_avcPar->NumB << std::endl;
9231 oss << "NumSlices = " << std::dec << +m_avcPar->NumSlices << std::endl;
9232 oss << "SliceHeight = " << std::dec << +m_avcPar->SliceHeight << std::endl;
9233 oss << "NumSuperSlices = " << std::dec << +m_avcPar->NumSuperSlices << std::endl;
9234
9235 if (m_avcPar->NumSuperSlices)
9236 {
9237 oss << "SuperSliceHeight = ";
9238 uint32_t sliceIdx = 0;
9239 for (; sliceIdx < m_avcPar->NumSuperSlices - 1; sliceIdx++)
9240 {
9241 oss << +m_avcPar->SuperSliceHeight[sliceIdx] << ",";
9242 }
9243 oss << +m_avcPar->SuperSliceHeight[sliceIdx] << std::endl;
9244 }
9245
9246 oss << "ISliceQP = " << std::dec << +m_avcPar->ISliceQP << std::endl;
9247 oss << "FrameRateM = " << std::dec << +m_avcPar->FrameRateM << std::endl;
9248 oss << "FrameRateD = " << std::dec << +m_avcPar->FrameRateD << std::endl;
9249 oss << "BRCMethod = " << std::dec << +m_avcPar->BRCMethod << std::endl;
9250 oss << "BRCType = " << std::dec << +m_avcPar->BRCType << std::endl;
9251 oss << "DeblockingIDC = " << std::dec << +m_avcPar->DeblockingIDC << std::endl;
9252 oss << "DeblockingFilterAlpha = " << std::dec << +m_avcPar->DeblockingFilterAlpha << std::endl;
9253 oss << "DeblockingFilterBeta = " << std::dec << +m_avcPar->DeblockingFilterBeta << std::endl;
9254 oss << "EntropyCodingMode = " << std::dec << +m_avcPar->EntropyCodingMode << std::endl;
9255 oss << "DirectInference = " << std::dec << +m_avcPar->DirectInference << std::endl;
9256 oss << "Transform8x8Mode = " << std::dec << +m_avcPar->Transform8x8Mode << std::endl;
9257 oss << "CRFQualityFactor = " << std::dec << +m_avcPar->CRFQualityFactor << std::endl;
9258 oss << "ConstrainedIntraPred = " << std::dec << +m_avcPar->ConstrainedIntraPred << std::endl;
9259 if (m_avcPar->NumP == 0) // There's no P frame
9260 {
9261 oss << "MaxRefIdxL0 = " << std::dec << +m_avcPar->MaxRefIdxL0 << std::endl;
9262 oss << "MaxRefIdxL1 = " << std::dec << +m_avcPar->MaxRefIdxL1 << std::endl;
9263 }
9264 oss << "SliceMode = " << std::dec << +m_avcPar->SliceMode << std::endl;
9265 if (m_avcPar->SliceMode == 2)
9266 {
9267 oss << "MaxNumSlicesCheckEnable = 1" << std::endl;
9268 }
9269
9270 // DS Params
9271 oss << "MBFlatnessThreshold = " << std::dec << +m_encodeParState->m_commonPar->mbFlatnessThreshold << std::endl;
9272
9273 // BRC init Params
9274 oss << "MBBRCEnable = " << std::dec << +m_avcPar->MBBRCEnable << std::endl;
9275 oss << "MBRC = " << std::dec << +m_avcPar->MBRC << std::endl;
9276 oss << "BitRate = " << std::dec << +m_avcPar->BitRate << std::endl;
9277 oss << "InitVbvFullnessInBit = " << std::dec << +m_avcPar->InitVbvFullnessInBit << std::endl;
9278 oss << "MaxBitRate = " << std::dec << +m_avcPar->MaxBitRate << std::endl;
9279 oss << "VbvSzInBit = " << std::dec << +m_avcPar->VbvSzInBit << std::endl;
9280 oss << "UserMaxFrame = " << std::dec << +m_avcPar->UserMaxFrame << std::endl;
9281 oss << "SlidingWindowRCEnable = " << std::dec << +m_avcPar->SlidingWindowEnable << std::endl;
9282 oss << "SlidingWindowSize = " << std::dec << +m_avcPar->SlidingWindowSize << std::endl;
9283 oss << "SlidingWindowMaxRateRatio = " << std::dec << +m_avcPar->SlidingWindowMaxRateRatio << std::endl;
9284 oss << "LowDelayGoldenFrameBoost = " << std::dec << +m_avcPar->LowDelayGoldenFrameBoost << std::endl;
9285 oss << "TopQPDeltaThrforAdaptive2Pass = " << std::dec << +m_avcPar->TopQPDeltaThrforAdaptive2Pass << std::endl;
9286 oss << "BotQPDeltaThrforAdaptive2Pass = " << std::dec << +m_avcPar->BotQPDeltaThrforAdaptive2Pass << std::endl;
9287 oss << "TopFrmSzPctThrforAdaptive2Pass = " << std::dec << +m_avcPar->TopFrmSzPctThrforAdaptive2Pass << std::endl;
9288 oss << "BotFrmSzPctThrforAdaptive2Pass = " << std::dec << +m_avcPar->BotFrmSzPctThrforAdaptive2Pass << std::endl;
9289 oss << "MBHeaderCompensation = " << std::dec << +m_avcPar->MBHeaderCompensation << std::endl;
9290 oss << "QPSelectMethodforFirstPass = " << std::dec << +m_avcPar->QPSelectMethodforFirstPass << std::endl;
9291 oss << "MBQpCtrl = " << std::dec << +m_avcPar->MBQpCtrl << std::endl;
9292 oss << "QPMax = " << std::dec << +m_avcPar->QPMax << std::endl;
9293 oss << "QPMin = " << std::dec << +m_avcPar->QPMin << std::endl;
9294 oss << "HrdConformanceCheckDisable = " << std::dec << +m_avcPar->HrdConformanceCheckDisable << std::endl;
9295 oss << "ICQReEncode = " << std::dec << +m_avcPar->ICQReEncode << std::endl;
9296 oss << "AdaptiveCostAdjustEnable = " << std::dec << +m_avcPar->AdaptiveCostAdjustEnable << std::endl;
9297 oss << "AdaptiveHMEExtension = " << std::dec << +m_avcPar->AdaptiveHMEExtension << std::endl;
9298 oss << "StreamInStaticRegion = " << std::dec << +m_avcPar->StreamInStaticRegion << std::endl;
9299 oss << "ScenarioInfo = " << std::dec << +m_avcPar->ScenarioInfo << std::endl;
9300 if (m_avcPar->SliceMode == 2)
9301 {
9302 oss << "SliceSizeWA = " << std::dec << +m_avcPar->SliceSizeWA << std::endl;
9303 }
9304
9305 // BRC frame update Params
9306 oss << "EnableMultipass = " << std::dec << +m_avcPar->EnableMultipass << std::endl;
9307 oss << "MaxNumPakPasses = " << std::dec << +m_avcPar->MaxNumPakPasses << std::endl;
9308 oss << "SceneChgDetectEn = " << std::dec << +m_avcPar->SceneChgDetectEn << std::endl;
9309 oss << "SceneChgPrevIntraPctThresh = " << std::dec << +m_avcPar->SceneChgPrevIntraPctThresh << std::endl;
9310 oss << "SceneChgCurIntraPctThresh = " << std::dec << +m_avcPar->SceneChgCurIntraPctThresh << std::endl;
9311 oss << "SceneChgWidth0 = " << std::dec << +m_avcPar->SceneChgWidth0 << std::endl;
9312 oss << "SceneChgWidth1 = " << std::dec << +m_avcPar->SceneChgWidth1 << std::endl;
9313 if (m_avcPar->SliceMode == 2)
9314 {
9315 oss << "SliceSizeThr = " << std::dec << +m_avcPar->SliceSizeThr << std::endl;
9316 oss << "SliceMaxSize = " << std::dec << +m_avcPar->SliceMaxSize << std::endl;
9317 }
9318
9319 // Enc Params
9320 oss << "BlockBasedSkip = " << std::dec << +m_avcPar->BlockBasedSkip << std::endl;
9321 oss << "VDEncPerfMode = " << std::dec << +m_avcPar->VDEncPerfMode << std::endl;
9322 oss << "SubPelMode = " << std::dec << +m_avcPar->SubPelMode << std::endl;
9323 oss << "LeftNbrPelMode = " << std::dec << +m_avcPar->LeftNbrPelMode << std::endl;
9324 oss << "ImePredOverlapThr = " << std::dec << +m_avcPar->ImePredOverlapThr << std::endl;
9325 oss << "MBSizeEstScalingRatioINTRA = " << std::dec << +m_avcPar->MBSizeEstScalingRatioINTRA << std::endl;
9326 oss << "IntraMBHdrScaleFactor = " << std::dec << +m_avcPar->IntraMBHdrScaleFactor << std::endl;
9327 oss << "MBSizeEstScalingRatioINTER = " << std::dec << +m_avcPar->MBSizeEstScalingRatioINTER << std::endl;
9328 oss << "InterMBHdrScaleFactor = " << std::dec << +m_avcPar->InterMBHdrScaleFactor << std::endl;
9329 oss << "HMERefWindowSize = " << std::dec << +m_avcPar->HMERefWindowSize << std::endl;
9330 oss << "IMELeftPredDep = " << std::dec << +m_avcPar->IMELeftPredDep << std::endl;
9331 oss << "NumFMECandCheck = " << std::dec << +m_avcPar->NumFMECandCheck << std::endl;
9332 oss << "RdoChromaEnable = " << std::dec << +m_avcPar->RdoChromaEnable << std::endl;
9333 oss << "Intra4x4ModeMask = " << std::dec << +m_avcPar->Intra4x4ModeMask << std::endl;
9334 oss << "Intra8x8ModeMask = " << std::dec << +m_avcPar->Intra8x8ModeMask << std::endl;
9335 oss << "RdoIntraChromaSearch = " << std::dec << +m_avcPar->RdoIntraChromaSearch << std::endl;
9336 oss << "Intra16x16ModeMask = " << std::dec << +m_avcPar->Intra16x16ModeMask << std::endl;
9337 oss << "InitMBBudgetTr4x4 = " << std::dec << +m_avcPar->InitMBBudgetTr4x4 << std::endl;
9338 oss << "ROIEnable = " << std::dec << +m_avcPar->ROIEnable << std::endl;
9339 oss << "ForceIPCMMinQP = " << std::dec << +m_avcPar->ForceIPCMMinQP << std::endl;
9340 oss << "IntraTr4x4Percent = " << std::dec << +m_avcPar->IntraTr4x4Percent << std::endl;
9341 oss << "IntraPredictionIFrame = " << std::dec << +m_avcPar->IntraPredictionIFrame << std::endl;
9342 oss << "IntraPrediction = " << std::dec << +m_avcPar->IntraPrediction << std::endl;
9343
9344 // PAK Params
9345 oss << "TrellisQuantizationEnable = " << std::dec << +m_avcPar->TrellisQuantizationEnable << std::endl;
9346 oss << "RoundingIntraEnabled = " << std::dec << +m_avcPar->RoundingIntraEnabled << std::endl;
9347 oss << "RoundingIntra = " << std::dec << +m_avcPar->RoundingIntra << std::endl;
9348 oss << "EnableAdaptiveTrellisQuantization = " << std::dec << +m_avcPar->EnableAdaptiveTrellisQuantization << std::endl;
9349 oss << "TrellisQuantizationRounding = " << std::dec << +m_avcPar->TrellisQuantizationRounding << std::endl;
9350 oss << "TrellisQuantizationChromaDisable = " << std::dec << +m_avcPar->TrellisQuantizationChromaDisable << std::endl;
9351 oss << "ExtendedRhoDomainEn = " << std::dec << +m_avcPar->ExtendedRhoDomainEn << std::endl;
9352 oss << "EnableSEI = " << std::dec << +m_avcPar->EnableSEI << std::endl;
9353 if (m_avcPar->NumP == 0) // There's no P frame
9354 {
9355 oss << "FrmHdrEncodingFrequency = " << std::dec << +m_avcPar->FrmHdrEncodingFrequency << std::endl;
9356 }
9357 oss << "VDEncMode = 1" << std::endl;
9358 oss << "EnableExternalCost = 0" << std::endl;
9359 oss << "EnableNewCost = 1" << std::endl;
9360 oss << "BestDistQPDelta0 = 0" << std::endl;
9361 oss << "BestDistQPDelta1 = 0" << std::endl;
9362 oss << "BestDistQPDelta2 = 0" << std::endl;
9363 oss << "BestDistQPDelta3 = 0" << std::endl;
9364 oss << "BestIntra4x4QPDelta = 0" << std::endl;
9365 oss << "BestIntra8x8QPDelta = 0" << std::endl;
9366 oss << "BestIntra16x16QPDelta = 0" << std::endl;
9367
9368 if (m_avcPar->NumP > 0)
9369 {
9370 // P Slice Parameters
9371 // DDI Params
9372 oss << "PSliceQP = " << std::dec << +m_avcPar->PSliceQP << std::endl;
9373 oss << "CabacInitIDC = " << std::dec << +m_avcPar->CabacInitIDC << std::endl;
9374 oss << "MaxRefIdxL0 = " << std::dec << +m_avcPar->MaxRefIdxL0 << std::endl;
9375 oss << "MaxRefIdxL1 = " << std::dec << +m_avcPar->MaxRefIdxL1 << std::endl;
9376 if (m_avcPar->NumB == 0) // There's no B frame
9377 {
9378 oss << "EnableWeightPredictionDetection = " << std::dec << +m_avcPar->EnableWeightPredictionDetection << std::endl;
9379 }
9380 oss << "WeightedPred = " << std::dec << +m_avcPar->WeightedPred << std::endl;
9381 oss << "WeightedBiPred = " << std::dec << +m_avcPar->WeightedBiPred << std::endl;
9382 if (m_avcPar->WeightedPred)
9383 {
9384 oss << "EnableWeightPredictionDetection = 1" << std::endl;
9385 oss << "FadeDetectionMethod = 1" << std::endl;
9386 }
9387 oss << "UseOrigAsRef = " << std::dec << +m_avcPar->UseOrigAsRef << std::endl;
9388 oss << "BiSubMbPartMask = " << std::dec << +m_avcPar->BiSubMbPartMask << std::endl;
9389 oss << "StaticFrameZMVPercent = " << std::dec << +m_avcPar->StaticFrameZMVPercent << std::endl;
9390 oss << "HME0XOffset = " << std::dec << +m_avcPar->hme0XOffset << std::endl;
9391 oss << "HME0YOffset = " << std::dec << +m_avcPar->hme0YOffset << std::endl;
9392 oss << "HME1XOffset = " << std::dec << +m_avcPar->hme1XOffset << std::endl;
9393 oss << "HME1YOffset = " << std::dec << +m_avcPar->hme1YOffset << std::endl;
9394
9395 // HME Params
9396 oss << "SuperHME = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->superHME : m_avcPar->SuperHME) << std::endl;
9397 oss << "UltraHME = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->ultraHME : m_avcPar->UltraHME) << std::endl;
9398 oss << "SuperCombineDist = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->superCombineDist : m_avcPar->SuperCombineDist) << std::endl;
9399 oss << "StreamInEnable = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInEnable : m_avcPar->StreamInEnable) << std::endl;
9400 oss << "StreamInL0FromNewRef = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInL0FromNewRef : m_avcPar->StreamInL0FromNewRef) << std::endl;
9401 oss << "StreamInL1FromNewRef = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->streamInL1FromNewRef : m_avcPar->StreamInL1FromNewRef) << std::endl;
9402 oss << "MEMethod = " << std::dec << +(m_useCommonKernel ? m_encodeParState->m_commonPar->meMethod : m_avcPar->MEMethod) << std::endl;
9403
9404 // Enc Params
9405 oss << "FTQBasedSkip = " << std::dec << +m_avcPar->FTQBasedSkip << std::endl;
9406 oss << "BiMixDisable = " << std::dec << +m_avcPar->BiMixDisable << std::endl;
9407 oss << "SurvivedSkipCost = " << std::dec << +m_avcPar->SurvivedSkipCost << std::endl;
9408 oss << "UniMixDisable = " << std::dec << +m_avcPar->UniMixDisable << std::endl;
9409 oss << "EnableIntraCostScalingForStaticFrame = " << std::dec << +m_avcPar->EnableIntraCostScalingForStaticFrame << std::endl;
9410 if (m_avcPar->EnableIntraCostScalingForStaticFrame)
9411 {
9412 oss << "IntraCostUpdateMethod = 3" << std::endl;
9413 }
9414 oss << "StaticFrameIntraCostScalingRatioP = " << std::dec << +m_avcPar->StaticFrameIntraCostScalingRatioP << std::endl;
9415 oss << "VdencExtPakObjDisable = " << std::dec << +m_avcPar->VdencExtPakObjDisable << std::endl;
9416 oss << "PPMVDisable = " << std::dec << +m_avcPar->PPMVDisable << std::endl;
9417 oss << "AdaptiveMvStreamIn = " << std::dec << +m_avcPar->AdaptiveMvStreamIn << std::endl;
9418 oss << "LargeMvThresh = " << std::dec << +m_avcPar->LargeMvThresh << std::endl;
9419 oss << "LargeMvPctThreshold = " << std::dec << +m_avcPar->LargeMvPctThreshold << std::endl;
9420 oss << "DisPSubPartMask = " << std::dec << +m_avcPar->DisPSubPartMask << std::endl;
9421 oss << "DisPSubMbMask = " << std::dec << +m_avcPar->DisPSubMbMask << std::endl;
9422 oss << "PFrameMaxNumImePred = " << std::dec << +m_avcPar->PFrameMaxNumImePred << std::endl;
9423 oss << "PFrameImePredLargeSW = " << std::dec << +m_avcPar->PFrameImePredLargeSW << std::endl;
9424 oss << "PFrameZeroCbfEn = " << std::dec << +m_avcPar->PFrameZeroCbfEn << std::endl;
9425 oss << "DirectMode = " << std::dec << +m_avcPar->DirectMode << std::endl;
9426 oss << "MultiPassHmeEnable = " << std::dec << +m_avcPar->MultiPassHmeEnable << std::endl;
9427
9428 // BRC Frame Update
9429 oss << "Transform8x8PDisable = " << std::dec << +m_avcPar->Transform8x8PDisable << std::endl;
9430
9431 // PAK Params
9432 oss << "RoundingInterEnabled = " << std::dec << +m_avcPar->RoundingInterEnabled << std::endl;
9433 oss << "RoundingInter = " << std::dec << +m_avcPar->RoundingInter << std::endl;
9434 oss << "FrmHdrEncodingFrequency = " << std::dec << +m_avcPar->FrmHdrEncodingFrequency << std::endl;
9435 oss << "AdaptiveRoundingEnabled = " << std::dec << +m_avcPar->EnableAdaptiveRounding << std::endl;
9436 }
9437
9438 if (m_avcPar->NumB > 0)
9439 {
9440 oss << "BSliceQP = " << std::dec << +m_avcPar->BSliceQP << std::endl;
9441 oss << "DisBSubPartMask = " << std::dec << +m_avcPar->DisBSubPartMask << std::endl;
9442 oss << "DisBSubMbMask = " << std::dec << +m_avcPar->DisBSubMbMask << std::endl;
9443 oss << "BFrameMaxNumImePred = " << std::dec << +m_avcPar->BFrameMaxNumImePred << std::endl;
9444 oss << "BFrameImePredLargeSW = " << std::dec << +m_avcPar->BFrameImePredLargeSW << std::endl;
9445 oss << "BFrameZeroCbfEn = " << std::dec << +m_avcPar->BFrameZeroCbfEn << std::endl;
9446 }
9447
9448 const char *fileName = m_debugInterface->CreateFileName(
9449 "EncodeSequence",
9450 "EncodePar",
9451 CodechalDbgExtType::par);
9452
9453 std::ofstream ofs(fileName, std::ios::app);
9454 ofs << oss.str();
9455 ofs.close();
9456
9457 return MOS_STATUS_SUCCESS;
9458 }
9459
9460 MOS_STATUS CodechalVdencAvcState::ModifyEncodedFrameSizeWithFakeHeaderSize( PMOS_COMMAND_BUFFER /*cmdBuffer*/)
9461 {
9462 CODECHAL_ENCODE_FUNCTION_ENTER;
9463
9464 return MOS_STATUS_SUCCESS;
9465 }
9466 #endif