Debian Codegraph @

media_driver/agnostic/gen12/codec/hal/codechal_vdenc_hevc_g12.cpp

raw
1 /*
2 * Copyright (c) 2017-2021, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file codechal_vdenc_hevc_g12.cpp
24 //! \brief HEVC VDEnc encoder for GEN12.
25 //!
26
27 #include "codechal_vdenc_hevc_g12.h"
28 #include "codechal_kernel_header_g12.h"
29 #include "codeckrnheader.h"
30 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
31 #include "igcodeckrn_g12.h"
32 #endif
33 #include "mhw_vdbox_g12_X.h"
34 #include "mhw_vdbox_hcp_g12_X.h"
35 #include "mhw_vdbox_vdenc_g12_X.h"
36 #include "mhw_mi_g12_X.h"
37 #include "mhw_render_g12_X.h"
38 #include "codechal_mmc_encode_hevc_g12.h"
39 #include "mhw_mmio_g12.h"
40 #include "hal_oca_interface.h"
41 #ifdef _MEDIA_RESERVED
42 #include "codechal_debug_encode_brc.h"
43 #endif
44 const uint32_t CodechalVdencHevcStateG12::m_VdboxVDENCRegBase[4] = M_VDBOX_VDENC_REG_BASE;
45
46 const double CodechalVdencHevcStateG12::m_devThreshIFPNEG[] = {
47 0.80, 0.60, 0.34, 0.2,
48 };
49
50 const double CodechalVdencHevcStateG12::m_devThreshIFPPOS[] = {
51 0.2, 0.4 , 0.66, 0.9,
52 };
53
54 const double CodechalVdencHevcStateG12::m_devThreshPBFPNEG[] = {
55 0.90, 0.66, 0.46, 0.3,
56 };
57
58 const double CodechalVdencHevcStateG12::m_devThreshPBFPPOS[] = {
59 0.3, 0.46, 0.70, 0.90,
60 };
61
62 const double CodechalVdencHevcStateG12::m_devThreshVBRNEG[] = {
63 0.90, 0.70, 0.50, 0.3,
64 };
65
66 const double CodechalVdencHevcStateG12::m_devThreshVBRPOS[] = {
67 0.4, 0.5, 0.75, 0.90,
68 };
69
70 const int8_t CodechalVdencHevcStateG12::m_lowdelayDevThreshPB[] = {
71 -45, -33, -23, -15, -8, 0, 15, 25,
72 };
73 const int8_t CodechalVdencHevcStateG12::m_lowdelayDevThreshVBR[] = {
74 -45, -35, -25, -15, -8, 0, 20, 40,
75 };
76 const int8_t CodechalVdencHevcStateG12::m_lowdelayDevThreshI[] = {
77 -40, -30, -17, -10, -5, 0, 10, 20,
78 };
79
80 const int8_t CodechalVdencHevcStateG12::m_lowdelayDeltaFrmszI[][8] = {
81 { 0, 0, -8, -12, -16, -20, -28, -36 },
82 { 0, 0, -4, -8, -12, -16, -24, -32 },
83 { 4, 2, 0, -1, -3, -8, -16, -24 },
84 { 8, 4, 2, 0, -1, -4, -8, -16 },
85 { 20, 16, 4, 0, -1, -4, -8, -16 },
86 { 24, 20, 16, 8, 4, 0, -4, -8 },
87 { 28, 24, 20, 16, 8, 4, 0, -8 },
88 { 32, 24, 20, 16, 8, 4, 0, -4 },
89 { 64, 48, 28, 20, 16, 12, 8, 4 },
90 };
91
92 const int8_t CodechalVdencHevcStateG12::m_lowdelayDeltaFrmszP[][8] = {
93 { -8, -24, -32, -40, -44, -48, -52, -80 },
94 { -8, -16, -32, -40, -40, -44, -44, -56 },
95 { 0, 0, -12, -20, -24, -28, -32, -36 },
96 { 8, 4, 0, 0, -8, -16, -24, -32 },
97 { 32, 16, 8, 4, -4, -8, -16, -20 },
98 { 36, 24, 16, 8, 4, -2, -4, -8 },
99 { 40, 36, 24, 20, 16, 8, 0, -8 },
100 { 48, 40, 28, 24, 20, 12, 0, -4 },
101 { 64, 48, 28, 20, 16, 12, 8, 4 },
102 };
103
104 const int8_t CodechalVdencHevcStateG12::m_lowdelayDeltaFrmszB[][8] = {
105 { 0, -4, -8, -16, -24, -32, -40, -48 },
106 { 1, 0, -4, -8, -16, -24, -32, -40 },
107 { 4, 2, 0, -1, -3, -8, -16, -24 },
108 { 8, 4, 2, 0, -1, -4, -8, -16 },
109 { 20, 16, 4, 0, -1, -4, -8, -16 },
110 { 24, 20, 16, 8, 4, 0, -4, -8 },
111 { 28, 24, 20, 16, 8, 4, 0, -8 },
112 { 32, 24, 20, 16, 8, 4, 0, -4 },
113 { 64, 48, 28, 20, 16, 12, 8, 4 },
114 };
115
116 const uint32_t CodechalVdencHevcStateG12::m_hucConstantData[] = {
117 0x01900190, 0x01900190, 0x01900190, 0x01900190, 0x01900190, 0x012c012c, 0x012c012c, 0x012c012c,
118 0x012c012c, 0x012c012c, 0x00c800c8, 0x00c800c8, 0x00c800c8, 0x00c800c8, 0x00c800c8, 0x00640064,
119 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064,
120 0x00640064, 0x00640064, 0x01900190, 0x01900190, 0x01900190, 0x01900190, 0x01900190, 0x012c012c,
121 0x012c012c, 0x012c012c, 0x012c012c, 0x012c012c, 0x00c800c8, 0x00c800c8, 0x00c800c8, 0x00c800c8,
122 0x00c800c8, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x00640064,
123 0x00640064, 0x00640064, 0x00640064, 0x00640064, 0x503c1e04, 0xffc88c78, 0x3c1e0400, 0xc88c7850,
124 0x140200ff, 0xa0824628, 0x0000ffc8, 0x00000000, 0x04030302, 0x00000000, 0x03030200, 0x0000ff04,
125 0x02020000, 0xffff0303, 0x01000000, 0xff020202, 0x0000ffff, 0x02020100, 0x00fffffe, 0x01010000,
126 0xfffffe02, 0x010000ff, 0xfefe0201, 0x0000ffff, 0xfe010100, 0x00fffffe, 0x01010000, 0x00000000,
127 0x03030200, 0x00000004, 0x03020000, 0x00ff0403, 0x02000000, 0xff030302, 0x000000ff, 0x02020201,
128 0x00ffffff, 0x02010000, 0xfffffe02, 0x01000000, 0xfffe0201, 0x0000ffff, 0xfe020101, 0x00fffffe,
129 0x01010000, 0xfffffefe, 0x01000000, 0x00000001, 0x03020000, 0x00000403, 0x02000000, 0xff040303,
130 0x00000000, 0x03030202, 0x0000ffff, 0x02020100, 0xffffff02, 0x01000000, 0xfffe0202, 0x000000ff,
131 0xfe020101, 0x00ffffff, 0x02010100, 0xfffffefe, 0x01000000, 0xfffefe01, 0x000000ff, 0xe0e00101,
132 0xc0d0d0d0, 0xe0e0b0c0, 0xd0d0d0e0, 0xf0f0c0d0, 0xd0e0e0e0, 0x0408d0d0, 0xe8f0f800, 0x1820dce0,
133 0xf8fc0210, 0x2024ecf0, 0x0008101c, 0x2428f8fc, 0x08101418, 0x2830f800, 0x0c14181c, 0x3040fc00,
134 0x0c10141c, 0xe8f80408, 0xc8d0d4e0, 0xf0f8b0c0, 0xccd4d8e0, 0x0000c0c8, 0xd8dce4f0, 0x0408d0d4,
135 0xf0f80000, 0x0808dce8, 0xf0f80004, 0x0810dce8, 0x00080808, 0x0810f8fc, 0x08080808, 0x1010f800,
136 0x08080808, 0x1020fc00, 0x08080810, 0xfc000408, 0xe0e8f0f8, 0x0001d0d8, 0xe8f0f8fc, 0x0204d8e0,
137 0xf8fdff00, 0x0408e8f0, 0xfcff0002, 0x1014f0f8, 0xfcff0004, 0x1418f0f8, 0x00040810, 0x181cf8fc,
138 0x04081014, 0x1820f800, 0x04081014, 0x3040fc00, 0x0c10141c, 0x40300408, 0x80706050, 0x30a0a090,
139 0x70605040, 0xa0a09080, 0x60504030, 0xa0908070, 0x040201a0, 0x18141008, 0x02012420, 0x0a080604,
140 0x01101010, 0x0c080402, 0x10101010, 0x05030201, 0x02010106, 0x00000503, 0xff030201, 0x02010000,
141 0x000000ff, 0xfffefe01, 0xfdfd0100, 0xfb00ffff, 0xfffffefd, 0xfefdfbfa, 0x030201ff, 0x01010605,
142 0x00050302, 0x03020101, 0x010000ff, 0x0000ff02, 0xffff0100, 0xfe0100ff, 0x00ffffff, 0xfffffefc,
143 0xfefcfb00, 0x0101ffff, 0x01050402, 0x04020101, 0x01010000, 0x0000ff02, 0x00ff0101, 0xff000000,
144 0x0100ffff, 0xfffffffe, 0xfffefd00, 0xfcfb00ff, 0x1efffffe, 0x070d0e10, 0x00003207, 0x00000000,
145 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
146 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
147 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
148 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
149 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
150 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
151 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
152 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
153 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
154 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
155 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
156 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
157 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
158 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
159 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
160 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
161 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
162 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
163 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
164 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
165 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
166 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
167 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
168 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
169 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
170 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
171 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
172 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
173 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
174 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
175 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
176 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
177 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
178 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
179 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
180 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
181 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
182 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
183 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000,
184 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10,
185 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207,
186 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000,
187 0x00000000, 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000,
188 0x00000000, 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000,
189 0x00000000, 0x1e000000, 0x070d0e10, 0x00003207, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
190 0x00000000, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff,
191 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff,
192 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff,
193 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000,
194 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff,
195 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff,
196 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000,
197 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff,
198 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff,
199 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff,
200 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff,
201 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff,
202 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000,
203 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff,
204 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff,
205 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000,
206 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff,
207 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff,
208 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff,
209 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff,
210 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff,
211 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000,
212 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff,
213 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff,
214 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000,
215 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff,
216 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff,
217 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff,
218 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff,
219 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff,
220 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000,
221 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff,
222 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff,
223 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000,
224 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff,
225 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff, 0x0000ffff,
226 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff, 0xffffffff,
227 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff, 0xffffffff,
228 0xffffffff, 0x0000ffff, 0xffffffff, 0xffff0000, 0xffffffff, 0xffffffff, 0xffff0000, 0x0000ffff,
229 0xffffffff, 0xffffffff, 0x0000ffff, 0xffffffff
230 };
231
232 uint32_t CodechalVdencHevcStateG12::GetMaxBtCount()
233 {
234 CODECHAL_ENCODE_FUNCTION_ENTER;
235
236 uint32_t maxBtCount = 0;
237
238 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
239 auto btIdxAlignment = m_stateHeapInterface->pStateHeapInterface->GetBtIdxAlignment();
240
241 // DsConversion kernel
242 maxBtCount = (m_32xMeSupported ? 3 : 2) * (MOS_ALIGN_CEIL(m_cscDsState->GetBTCount(), btIdxAlignment));
243
244 // add ME and stream-in kernel
245 if(m_b16XMeEnabled)
246 {
247 MHW_KERNEL_STATE kernelState = m_lowDelay ? m_vdencMeKernelState : m_vdencMeKernelStateRAB;
248 if(m_b32XMeEnabled)
249 {
250 maxBtCount += MOS_ALIGN_CEIL(kernelState.KernelParams.iBTCount, btIdxAlignment);
251 }
252 maxBtCount += MOS_ALIGN_CEIL(kernelState.KernelParams.iBTCount, btIdxAlignment);
253
254 kernelState = m_lowDelay ? m_vdencStreaminKernelState : m_vdencStreaminKernelStateRAB;
255 maxBtCount += MOS_ALIGN_CEIL(kernelState.KernelParams.iBTCount, btIdxAlignment);
256 }
257 #endif
258
259 return maxBtCount;
260 }
261
262 MOS_STATUS CodechalVdencHevcStateG12::InitKernelStateMe()
263 {
264 CODECHAL_ENCODE_FUNCTION_ENTER;
265
266 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
267
268 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface);
269 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface->pStateHeapInterface);
270
271 uint32_t kernelSize = m_combinedKernelSize;
272 CODECHAL_KERNEL_HEADER currKrnHeader;
273 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
274 m_kernelBinary,
275 VDENC_ME_P,
276 0,
277 &currKrnHeader,
278 &kernelSize));
279
280 auto kernelStatePtr = &m_vdencMeKernelState;
281 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetKernelParams(
282 VDENC_ME_P,
283 &kernelStatePtr->KernelParams));
284
285 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetBindingTable(
286 VDENC_ME_P,
287 &m_vdencMeKernelBindingTable));
288
289 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
290 kernelStatePtr->KernelParams.pBinary =
291 m_kernelBinary +
292 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
293 kernelStatePtr->KernelParams.iSize = kernelSize;
294
295 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
296 m_stateHeapInterface,
297 kernelStatePtr->KernelParams.iBTCount,
298 &kernelStatePtr->dwSshSize,
299 &kernelStatePtr->dwBindingTableSize));
300
301 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
302
303 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
304 m_kernelBinary,
305 VDENC_ME_B,
306 0,
307 &currKrnHeader,
308 &kernelSize));
309
310 kernelStatePtr = &m_vdencMeKernelStateRAB;
311 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetKernelParams(
312 VDENC_ME_B,
313 &kernelStatePtr->KernelParams));
314
315 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetBindingTable(
316 VDENC_ME_B,
317 &m_vdencStreaminKernelBindingTable));
318
319 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
320 kernelStatePtr->KernelParams.pBinary =
321 m_kernelBinary +
322 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
323 kernelStatePtr->KernelParams.iSize = kernelSize;
324
325 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
326 m_stateHeapInterface,
327 kernelStatePtr->KernelParams.iBTCount,
328 &kernelStatePtr->dwSshSize,
329 &kernelStatePtr->dwBindingTableSize));
330
331 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
332
333 return eStatus;
334 }
335
336 MOS_STATUS CodechalVdencHevcStateG12::InitKernelStateStreamIn()
337 {
338 CODECHAL_ENCODE_FUNCTION_ENTER;
339 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
340
341 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface);
342 CODECHAL_ENCODE_CHK_NULL_RETURN(m_stateHeapInterface->pStateHeapInterface);
343
344 uint32_t kernelSize = m_combinedKernelSize;
345 CODECHAL_KERNEL_HEADER currKrnHeader;
346 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
347 m_kernelBinary,
348 VDENC_STREAMIN_HEVC,
349 0,
350 &currKrnHeader,
351 &kernelSize));
352
353 auto kernelStatePtr = &m_vdencStreaminKernelState;
354 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetKernelParams(
355 VDENC_STREAMIN_HEVC,
356 &kernelStatePtr->KernelParams));
357
358 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetBindingTable(
359 VDENC_STREAMIN_HEVC,
360 &m_vdencStreaminKernelBindingTable));
361
362 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
363 kernelStatePtr->KernelParams.pBinary =
364 m_kernelBinary +
365 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
366 kernelStatePtr->KernelParams.iSize = kernelSize;
367
368 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
369 m_stateHeapInterface,
370 kernelStatePtr->KernelParams.iBTCount,
371 &kernelStatePtr->dwSshSize,
372 &kernelStatePtr->dwBindingTableSize));
373
374 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
375
376 CODECHAL_ENCODE_CHK_STATUS_RETURN(pfnGetKernelHeaderAndSize(
377 m_kernelBinary,
378 VDENC_STREAMIN_HEVC_RAB,
379 0,
380 &currKrnHeader,
381 &kernelSize));
382
383 kernelStatePtr = &m_vdencStreaminKernelStateRAB;
384 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetKernelParams(
385 VDENC_STREAMIN_HEVC_RAB,
386 &kernelStatePtr->KernelParams));
387
388 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetBindingTable(
389 VDENC_STREAMIN_HEVC_RAB,
390 &m_vdencStreaminKernelBindingTable));
391
392 kernelStatePtr->dwCurbeOffset = m_stateHeapInterface->pStateHeapInterface->GetSizeofCmdInterfaceDescriptorData();
393 kernelStatePtr->KernelParams.pBinary =
394 m_kernelBinary +
395 (currKrnHeader.KernelStartPointer << MHW_KERNEL_OFFSET_SHIFT);
396 kernelStatePtr->KernelParams.iSize = kernelSize;
397
398 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnCalculateSshAndBtSizesRequested(
399 m_stateHeapInterface,
400 kernelStatePtr->KernelParams.iBTCount,
401 &kernelStatePtr->dwSshSize,
402 &kernelStatePtr->dwBindingTableSize));
403
404 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->MhwInitISH(m_stateHeapInterface, kernelStatePtr));
405
406 return eStatus;
407 }
408
409 MOS_STATUS CodechalVdencHevcStateG12::InitKernelState()
410 {
411 CODECHAL_ENCODE_FUNCTION_ENTER;
412
413 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
414
415 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
416 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateMe());
417 CODECHAL_ENCODE_CHK_STATUS_RETURN(InitKernelStateStreamIn());
418 #endif
419
420 return eStatus;
421 }
422
423 MOS_STATUS CodechalVdencHevcStateG12::DecideEncodingPipeNumber()
424 {
425 CODECHAL_ENCODE_FUNCTION_ENTER;
426
427 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
428
429 m_numPipePre = m_numPipe;
430 m_numPipe = m_numVdbox;
431
432 uint8_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
433
434 CODECHAL_ENCODE_VERBOSEMESSAGE("Tile Columns = %d.", numTileColumns);
435
436 if (numTileColumns > m_numPipe)
437 {
438 // Streaming buffer does does work if numTileColumns > m_numPipe
439 if (m_hevcSeqParams->EnableStreamingBufferLLC || m_hevcSeqParams->EnableStreamingBufferDDR)
440 {
441 CODECHAL_ENCODE_ASSERTMESSAGE("Streaming buffer does does work if numTileColumns > m_numPipe!");
442 return MOS_STATUS_INVALID_PARAMETER;
443 }
444 m_numPipe = 1;
445 }
446
447 if (numTileColumns < m_numPipe)
448 {
449 if (numTileColumns >= 1 && numTileColumns <= 4)
450 {
451 m_numPipe = numTileColumns;
452 }
453 else
454 {
455 m_numPipe = 1; // invalid tile column test cases and switch back to the single VDBOX mode
456 }
457 }
458
459 // Tile replay needs scalability enabled, Remove Resolution check for scalability
460
461 m_useVirtualEngine = true; // always use virtual engine interface for single pipe and scalability mode
462
463 m_numUsedVdbox = m_numPipe;
464 m_numberTilesInFrame = (m_hevcPicParams->num_tile_rows_minus1 + 1) * (m_hevcPicParams->num_tile_columns_minus1 + 1);
465
466 if (m_scalabilityState)
467 {
468 // Create/ re-use a GPU context with 2 pipes
469 m_scalabilityState->ucScalablePipeNum = m_numPipe;
470 }
471
472 CODECHAL_ENCODE_VERBOSEMESSAGE("System VDBOX number = %d, decided pipe num = %d.", m_numVdbox, m_numPipe);
473
474 return eStatus;
475 }
476
477 bool CodechalVdencHevcStateG12::CheckSupportedFormat(PMOS_SURFACE surface)
478 {
479 CODECHAL_ENCODE_FUNCTION_ENTER;
480
481 bool isColorFormatSupported = false;
482
483 if (nullptr == surface)
484 {
485 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid (nullptr) Pointer.");
486 return isColorFormatSupported;
487 }
488
489 switch (surface->Format)
490 {
491 case Format_NV12:
492 case Format_NV21:
493 case Format_P010: // Planar 4:2:0
494 case Format_YUY2:
495 case Format_YUYV:
496 case Format_YVYU:
497 case Format_UYVY:
498 case Format_VYUY:
499 case Format_A8R8G8B8:
500 case Format_A8B8G8R8:
501 case Format_R10G10B10A2:// Packed RGB 4:4:4
502 case Format_B10G10R10A2:// Packed RGB 4:4:4
503 case Format_AYUV:
504 case Format_Y410: // Packed 4:4:4
505 isColorFormatSupported = true;
506 break;
507 case Format_Y210: // Packed 4:2:2
508 if (MEDIA_IS_WA(m_waTable, WaHEVCVDEncY210LinearInputNotSupported))
509 {
510 isColorFormatSupported = surface->TileType == MOS_TILE_Y;
511 }
512 else
513 {
514 isColorFormatSupported = true;
515 }
516 break;
517 default:
518 CODECHAL_ENCODE_ASSERTMESSAGE("Input surface color format = %d not supported!", surface->Format);
519 break;
520 }
521
522 return isColorFormatSupported;
523 }
524
525 MOS_STATUS CodechalVdencHevcStateG12::PlatformCapabilityCheck()
526 {
527 CODECHAL_ENCODE_FUNCTION_ENTER;
528
529 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
530
531 CODECHAL_ENCODE_CHK_STATUS_RETURN(DecideEncodingPipeNumber());
532
533 if (MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
534 {
535 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeScalability_ChkGpuCtxReCreation(this, m_scalabilityState,
536 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
537 }
538
539 if (m_frameWidth * m_frameHeight > ENCODE_HEVC_MAX_16K_PIC_WIDTH * ENCODE_HEVC_MAX_16K_PIC_HEIGHT)
540 {
541 eStatus = MOS_STATUS_INVALID_PARAMETER;
542 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Frame resolution greater than 16k not supported");
543 }
544
545 if (m_hevcSeqParams->SliceSizeControl && m_frameWidth * m_frameHeight < ENCODE_HEVC_MIN_DSS_PIC_WIDTH * ENCODE_HEVC_MIN_DSS_PIC_HEIGHT)
546 {
547 eStatus = MOS_STATUS_INVALID_PARAMETER;
548 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "DSS is not supported when frame resolution less than 320p");
549 }
550
551 if (m_hevcSeqParams->ParallelBRC)
552 {
553 eStatus = MOS_STATUS_INVALID_PARAMETER;
554 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Parallel BRC is not supported on VDENC");
555 }
556
557 if (m_hevcSeqParams->bit_depth_luma_minus8 >= 4 || m_hevcSeqParams->bit_depth_chroma_minus8 >= 4)
558 {
559 eStatus = MOS_STATUS_INVALID_PARAMETER;
560 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "12bit encoding is not supported on VDENC");
561 }
562
563 if (m_hevcSeqParams->chroma_format_idc == 2)
564 {
565 eStatus = MOS_STATUS_INVALID_PARAMETER;
566 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "422 recon format encoding is not supported on HEVC VDENC");
567 }
568
569 // TU configuration for RDOQ
570 if (m_hevcRdoqEnabled)
571 {
572 m_hevcRdoqEnabled = (m_hevcSeqParams->TargetUsage < 7);
573 }
574
575 // set RDOQ Intra blocks Threshold for Gen11+
576 m_rdoqIntraTuThreshold = 0;
577 if (m_hevcRdoqEnabled)
578 {
579 if (1 == m_hevcSeqParams->TargetUsage)
580 {
581 m_rdoqIntraTuThreshold = 0xffff;
582 }
583 else if (4 == m_hevcSeqParams->TargetUsage)
584 {
585 m_rdoqIntraTuThreshold = m_picWidthInMb * m_picHeightInMb;
586 m_rdoqIntraTuThreshold = MOS_MIN(m_rdoqIntraTuThreshold / 10, 0xffff);
587 }
588 }
589
590 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
591 {
592 if (m_hevcPicParams->tiles_enabled_flag)
593 {
594 for (auto i = 0; i < m_hevcPicParams->num_tile_columns_minus1 + 1; i++)
595 {
596 if (m_hevcPicParams->tile_column_width[i] < 5)
597 {
598 CODECHAL_ENCODE_ASSERTMESSAGE("SCC IBC mode can't support tile width < 5 LCU");
599 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
600 }
601 }
602 }
603 else
604 {
605 if (MOS_ROUNDUP_DIVIDE(m_frameWidth, MAX_LCU_SIZE) < 5)
606 {
607 CODECHAL_ENCODE_ASSERTMESSAGE("in tiling disabled case, SCC IBC mode can't support picture width < 5 LCU");
608 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
609 }
610 }
611 }
612
613 return eStatus;
614 }
615
616 CodechalVdencHevcStateG12::~CodechalVdencHevcStateG12()
617 {
618 CODECHAL_ENCODE_FUNCTION_ENTER;
619
620 if (m_scalabilityState)
621 {
622 MOS_FreeMemAndSetNull(m_scalabilityState);
623 }
624 //Note: virtual engine interface destroy is done in MOS layer
625
626 CODECHAL_DEBUG_TOOL(
627 MOS_Delete(m_encodeParState);
628 )
629 #ifdef _MEDIA_RESERVED
630 if (m_rsvdState)
631 {
632 MOS_Delete(m_rsvdState);
633 m_rsvdState = nullptr;
634 }
635 #endif
636 if(m_gpuCtxCreatOpt)
637 {
638 MOS_Delete(m_gpuCtxCreatOpt);
639 m_gpuCtxCreatOpt = nullptr;
640 }
641 return;
642 }
643
644 MOS_STATUS CodechalVdencHevcStateG12::AllocatePakResources()
645 {
646 CODECHAL_ENCODE_FUNCTION_ENTER;
647
648 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
649
650 uint32_t mvt_size = MOS_ALIGN_CEIL(((m_frameWidth + 63) >> 6)*((m_frameHeight + 15) >> 4), 2) * CODECHAL_CACHELINE_SIZE;
651 uint32_t mvtb_size = MOS_ALIGN_CEIL(((m_frameWidth + 31) >> 5)*((m_frameHeight + 31) >> 5), 2) * CODECHAL_CACHELINE_SIZE;
652 m_sizeOfMvTemporalBuffer = MOS_MAX(mvt_size, mvtb_size);
653
654 const uint32_t picWidthInMinLCU = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max width
655 const uint32_t picHeightInMinLCU = MOS_ROUNDUP_DIVIDE(m_frameHeight, CODECHAL_HEVC_MIN_LCU_SIZE); //assume smallest LCU to get max height
656
657 MHW_VDBOX_HCP_BUFFER_SIZE_PARAMS hcpBufSizeParam;
658 MOS_ZeroMemory(&hcpBufSizeParam, sizeof(hcpBufSizeParam));
659 hcpBufSizeParam.ucMaxBitDepth = m_bitDepth;
660 hcpBufSizeParam.ucChromaFormat = m_chromaFormat;
661 // We should move the buffer allocation to picture level if the size is dependent on LCU size
662 hcpBufSizeParam.dwCtbLog2SizeY = 6; //assume Max LCU size
663 hcpBufSizeParam.dwPicWidth = MOS_ALIGN_CEIL(m_frameWidth, MAX_LCU_SIZE);
664 hcpBufSizeParam.dwPicHeight = MOS_ALIGN_CEIL(m_frameHeight, MAX_LCU_SIZE);
665
666 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
667 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
668 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
669 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
670 allocParamsForBufferLinear.Format = Format_Buffer;
671
672 // Deblocking Filter Row Store Scratch data surface
673 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
674 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_LINE,
675 &hcpBufSizeParam);
676
677 if (eStatus != MOS_STATUS_SUCCESS)
678 {
679 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Deblocking Filter Row Store Scratch Buffer.");
680 return eStatus;
681 }
682
683 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
684 allocParamsForBufferLinear.pBufName = "DeblockingScratchBuffer";
685
686 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
687 m_osInterface,
688 &allocParamsForBufferLinear,
689 &m_resDeblockingFilterRowStoreScratchBuffer);
690
691 if (eStatus != MOS_STATUS_SUCCESS)
692 {
693 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Row Store Scratch Buffer.");
694 return eStatus;
695 }
696
697 // Deblocking Filter Tile Row Store Scratch data surface
698 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
699 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_LINE,
700 &hcpBufSizeParam);
701
702 if (eStatus != MOS_STATUS_SUCCESS)
703 {
704 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Deblocking Filter Tile Row Store Scratch Buffer.");
705 return eStatus;
706 }
707
708 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
709 allocParamsForBufferLinear.pBufName = "DeblockingTileRowScratchBuffer";
710
711 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
712 m_osInterface,
713 &allocParamsForBufferLinear,
714 &m_resDeblockingFilterTileRowStoreScratchBuffer);
715
716 if (eStatus != MOS_STATUS_SUCCESS)
717 {
718 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Tile Row Store Scratch Buffer.");
719 return eStatus;
720 }
721
722 // Deblocking Filter Column Row Store Scratch data surface
723 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
724 MHW_VDBOX_HCP_INTERNAL_BUFFER_DBLK_TILE_COL,
725 &hcpBufSizeParam);
726
727 if (eStatus != MOS_STATUS_SUCCESS)
728 {
729 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Deblocking Filter Tile Column Store Scratch Buffer.");
730 return eStatus;
731 }
732
733 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
734 allocParamsForBufferLinear.pBufName = "DeblockingColumnScratchBuffer";
735
736 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
737 m_osInterface,
738 &allocParamsForBufferLinear,
739 &m_resDeblockingFilterColumnRowStoreScratchBuffer);
740
741 if (eStatus != MOS_STATUS_SUCCESS)
742 {
743 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Deblocking Filter Tile Column Row Store Scratch Buffer.");
744 return eStatus;
745 }
746
747 // Metadata Line buffer
748 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
749 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_LINE,
750 &hcpBufSizeParam);
751
752 if (eStatus != MOS_STATUS_SUCCESS)
753 {
754 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Metadata Line Buffer.");
755 return eStatus;
756 }
757
758 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
759 allocParamsForBufferLinear.pBufName = "MetadataLineBuffer";
760
761 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
762 m_osInterface,
763 &allocParamsForBufferLinear,
764 &m_resMetadataLineBuffer);
765
766 if (eStatus != MOS_STATUS_SUCCESS)
767 {
768 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Line Buffer.");
769 return eStatus;
770 }
771
772 // Metadata Tile Line buffer
773 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
774 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_LINE,
775 &hcpBufSizeParam);
776
777 if (eStatus != MOS_STATUS_SUCCESS)
778 {
779 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Metadata Tile Line Buffer.");
780 return eStatus;
781 }
782
783 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
784 allocParamsForBufferLinear.pBufName = "MetadataTileLineBuffer";
785
786 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
787 m_osInterface,
788 &allocParamsForBufferLinear,
789 &m_resMetadataTileLineBuffer);
790
791 if (eStatus != MOS_STATUS_SUCCESS)
792 {
793 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Tile Line Buffer.");
794 return eStatus;
795 }
796
797 // Metadata Tile Column buffer
798 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
799 MHW_VDBOX_HCP_INTERNAL_BUFFER_META_TILE_COL,
800 &hcpBufSizeParam);
801
802 if (eStatus != MOS_STATUS_SUCCESS)
803 {
804 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for Metadata Tile Column Buffer.");
805 return eStatus;
806 }
807
808 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
809 allocParamsForBufferLinear.pBufName = "MetadataTileColumnBuffer";
810
811 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
812 m_osInterface,
813 &allocParamsForBufferLinear,
814 &m_resMetadataTileColumnBuffer);
815
816 if (eStatus != MOS_STATUS_SUCCESS)
817 {
818 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate Metadata Tile Column Buffer.");
819 return eStatus;
820 }
821
822 // SAO Line buffer
823 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
824 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_LINE,
825 &hcpBufSizeParam);
826
827 if (eStatus != MOS_STATUS_SUCCESS)
828 {
829 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Line Buffer.");
830 return eStatus;
831 }
832
833 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
834 allocParamsForBufferLinear.pBufName = "SaoLineBuffer";
835
836 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
837 m_osInterface,
838 &allocParamsForBufferLinear,
839 &m_resSaoLineBuffer);
840
841 if (eStatus != MOS_STATUS_SUCCESS)
842 {
843 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Line Buffer.");
844 return eStatus;
845 }
846
847 // SAO Tile Line buffer
848 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
849 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_LINE,
850 &hcpBufSizeParam);
851
852 if (eStatus != MOS_STATUS_SUCCESS)
853 {
854 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Tile Line Buffer.");
855 return eStatus;
856 }
857
858 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
859 allocParamsForBufferLinear.pBufName = "SaoTileLineBuffer";
860
861 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
862 m_osInterface,
863 &allocParamsForBufferLinear,
864 &m_resSaoTileLineBuffer);
865
866 if (eStatus != MOS_STATUS_SUCCESS)
867 {
868 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Tile Line Buffer.");
869 return eStatus;
870 }
871
872 // SAO Tile Column buffer
873 eStatus = (MOS_STATUS)m_hcpInterface->GetHevcBufferSize(
874 MHW_VDBOX_HCP_INTERNAL_BUFFER_SAO_TILE_COL,
875 &hcpBufSizeParam);
876
877 if (eStatus != MOS_STATUS_SUCCESS)
878 {
879 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to get the size for SAO Tile Column Buffer.");
880 return eStatus;
881 }
882
883 allocParamsForBufferLinear.dwBytes = hcpBufSizeParam.dwBufferSize;
884 allocParamsForBufferLinear.pBufName = "SaoTileColumnBuffer";
885
886 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
887 m_osInterface,
888 &allocParamsForBufferLinear,
889 &m_resSaoTileColumnBuffer);
890
891 if (eStatus != MOS_STATUS_SUCCESS)
892 {
893 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO Tile Column Buffer.");
894 return eStatus;
895 }
896
897 // Lcu ILDB StreamOut buffer
898 allocParamsForBufferLinear.dwBytes = CODECHAL_CACHELINE_SIZE;
899 allocParamsForBufferLinear.pBufName = "LcuILDBStreamOutBuffer";
900
901 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
902 m_osInterface,
903 &allocParamsForBufferLinear,
904 &m_resLcuIldbStreamOutBuffer);
905
906 if (eStatus != MOS_STATUS_SUCCESS)
907 {
908 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate LCU ILDB StreamOut Buffer.");
909 return eStatus;
910 }
911
912 // Lcu Base Address buffer
913 // HEVC Encoder Mode: Slice size is written to this buffer when slice size conformance is enabled.
914 // 1 CL (= 16 DWs = 64 bytes) per slice * Maximum number of slices in a frame.
915 // Align to page for HUC requirement
916 uint32_t maxLcu = picWidthInMinLCU * picHeightInMinLCU;
917 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(maxLcu * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
918 allocParamsForBufferLinear.pBufName = "LcuBaseAddressBuffer";
919
920 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
921 m_osInterface,
922 &allocParamsForBufferLinear,
923 &m_resLcuBaseAddressBuffer);
924
925 if (eStatus != MOS_STATUS_SUCCESS)
926 {
927 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate LCU Base Address Buffer.");
928 return eStatus;
929 }
930
931 // SAO Row Store buffer
932 // Aligned to 4 for each tile column
933 uint32_t maxTileColumn = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE);
934 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(picWidthInMinLCU + 3 * maxTileColumn, 4) * 16;
935 allocParamsForBufferLinear.pBufName = "SaoRowStoreBuffer";
936
937 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
938 m_osInterface,
939 &allocParamsForBufferLinear,
940 &m_vdencSAORowStoreBuffer);
941
942 if (eStatus != MOS_STATUS_SUCCESS)
943 {
944 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO row store Buffer.");
945 return eStatus;
946 }
947
948 // SAO StreamOut buffer
949 uint32_t size = MOS_ALIGN_CEIL(picWidthInMinLCU, 4) * CODECHAL_HEVC_SAO_STRMOUT_SIZE_PERLCU;
950 //extra added size to cover tile enabled case, per tile width aligned to 4. 20: max tile column No.
951 size += 3 * 20 * CODECHAL_HEVC_SAO_STRMOUT_SIZE_PERLCU;
952 allocParamsForBufferLinear.dwBytes = size;
953 allocParamsForBufferLinear.pBufName = "SaoStreamOutBuffer";
954
955 eStatus = (MOS_STATUS)m_osInterface->pfnAllocateResource(
956 m_osInterface,
957 &allocParamsForBufferLinear,
958 &m_resSaoStreamOutBuffer);
959
960 if (eStatus != MOS_STATUS_SUCCESS)
961 {
962 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to allocate SAO StreamOut Buffer.");
963 return eStatus;
964 }
965
966 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
967 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
968 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
969 allocParamsForBufferLinear.Format = Format_Buffer;
970
971 // Allocate Frame Statistics Streamout Data Destination Buffer. DW98-100 in HCP PipeBufAddr command
972 size = MOS_ALIGN_CEIL(m_sizeOfHcpPakFrameStats * m_maxTileNumber, CODECHAL_PAGE_SIZE); //Each tile has 9 cache size bytes of data, Align to page is HuC requirement
973 allocParamsForBufferLinear.dwBytes = size;
974 allocParamsForBufferLinear.pBufName = "FrameStatStreamOutBuffer";
975
976 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
977 m_osInterface,
978 &allocParamsForBufferLinear,
979 &m_resFrameStatStreamOutBuffer),
980 "Failed to create VDENC FrameStatStreamOutBuffer Buffer");
981
982 // PAK Statistics buffer
983 size = MOS_ALIGN_CEIL(m_vdencBrcPakStatsBufferSize, CODECHAL_PAGE_SIZE);
984 CODECHAL_ENCODE_CHK_NULL_RETURN(m_allocator->AllocateResource(
985 m_standard, size, 1, pakStats, "pakStats"));
986
987 // Slice Count buffer 1 DW = 4 Bytes
988 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(4, CODECHAL_CACHELINE_SIZE);
989 allocParamsForBufferLinear.pBufName = "Slice Count Buffer";
990
991 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
992 m_osInterface,
993 &allocParamsForBufferLinear,
994 &m_sliceCountBuffer),
995 "Failed to create VDENC Slice Count Buffer");
996
997 // VDEncMode Timer buffer 1 DW = 4 Bytes
998 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(4, CODECHAL_CACHELINE_SIZE);
999 allocParamsForBufferLinear.pBufName = "VDEncMode Timer Buffer";
1000
1001 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1002 m_osInterface,
1003 &allocParamsForBufferLinear,
1004 &m_vdencModeTimerBuffer),
1005 "Failed to create VDEncMode Timer Buffer");
1006
1007 uint32_t frameWidthInCus = CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameWidth, CODECHAL_HEVC_MIN_CU_SIZE);
1008 uint32_t frameHeightInCus = CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameHeight, CODECHAL_HEVC_MIN_CU_SIZE);
1009 uint32_t frameWidthInLcus = CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameWidth, CODECHAL_HEVC_MAX_LCU_SIZE_G10);
1010 uint32_t frameHeightInLcus = CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameHeight, CODECHAL_HEVC_MAX_LCU_SIZE_G10);
1011 uint32_t maxTileColumns = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE);
1012
1013 // PAK CU Level Streamout Data: DW57-59 in HCP pipe buffer address command
1014 // One CU has 16-byte. But, each tile needs to be aliged to the cache line
1015 size = MOS_ALIGN_CEIL(frameWidthInCus * frameHeightInCus * 16, CODECHAL_CACHELINE_SIZE);
1016 allocParamsForBufferLinear.dwBytes = size;
1017 allocParamsForBufferLinear.pBufName = "PAK CU Level Streamout Data";
1018
1019 CODECHAL_ENCODE_CHK_STATUS_RETURN((MOS_STATUS)m_osInterface->pfnAllocateResource(
1020 m_osInterface,
1021 &allocParamsForBufferLinear,
1022 &m_resPakcuLevelStreamoutData.sResource));
1023 m_resPakcuLevelStreamoutData.dwSize = size;
1024 CODECHAL_ENCODE_VERBOSEMESSAGE("first allocate cu steam out buffer, size=0x%x.\n", size);
1025
1026 // these 2 buffers are not used so far, but put the correct size calculation here
1027 // PAK CU Level Streamout Data: DW57-59 in HCP pipe buffer address command
1028 // One CU has 16-byte. But, each tile needs to be aliged to the cache line
1029 // size = MOS_ALIGN_CEIL(frameWidthInCus * frameHeightInCus * 16, CODECHAL_CACHELINE_SIZE);
1030
1031 // PAK Slice Level Streamut Data. DW60-DW62 in HCP pipe buffer address command
1032 // one LCU has one cache line. Use CU as LCU during creation
1033 // size = frameWidthInLcus * frameHeightInLcus * CODECHAL_CACHELINE_SIZE;
1034
1035 // Allocate SSE Source Pixel Row Store Buffer
1036 m_sizeOfSseSrcPixelRowStoreBufferPerLcu = CODECHAL_CACHELINE_SIZE * (4 + 4) << 1;
1037 allocParamsForBufferLinear.dwBytes = 2 * m_sizeOfSseSrcPixelRowStoreBufferPerLcu * (m_widthAlignedMaxLcu + 3 * maxTileColumns);
1038 allocParamsForBufferLinear.pBufName = "SseSrcPixelRowStoreBuffer";
1039
1040 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1041 m_osInterface,
1042 &allocParamsForBufferLinear,
1043 &m_resSseSrcPixelRowStoreBuffer),
1044 "Failed to create SseSrcPixelRowStoreBuffer");
1045
1046 //HCP scalability Sync buffer
1047 allocParamsForBufferLinear.dwBytes = CODECHAL_HEVC_MAX_NUM_HCP_PIPE * CODECHAL_CACHELINE_SIZE;
1048 allocParamsForBufferLinear.pBufName = "GEN11 HCP scalability Sync buffer ";
1049
1050 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1051 m_osInterface,
1052 &allocParamsForBufferLinear,
1053 &m_resHcpScalabilitySyncBuffer.sResource),
1054 "Failed to create GEN11 HCP scalability Sync Buffer");
1055
1056 // create the tile coding state parameters
1057 for (auto i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; i++)
1058 {
1059 m_tileParams[i] = (PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12)MOS_AllocAndZeroMemory(
1060 sizeof(MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12)* m_maxTileNumber);
1061 }
1062
1063 if (m_enableHWSemaphore)
1064 {
1065 // Create the HW sync objects which will be used by each reference frame and BRC in GEN11
1066 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1067 allocParamsForBufferLinear.pBufName = "SemaphoreMemory";
1068
1069 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1070 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1071 lockFlagsWriteOnly.WriteOnly = 1;
1072
1073 uint32_t* data = nullptr;
1074
1075 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_refSync); i++)
1076 {
1077 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1078 m_osInterface,
1079 &allocParamsForBufferLinear,
1080 &m_refSync[i].resSemaphoreMem.sResource),
1081 "Failed to create HW Semaphore Memory.");
1082 m_refSync[i].resSemaphoreMem.dwSize = allocParamsForBufferLinear.dwBytes;
1083
1084 CODECHAL_ENCODE_CHK_NULL_RETURN(data = (uint32_t *)m_osInterface->pfnLockResource(
1085 m_osInterface,
1086 &m_refSync[i].resSemaphoreMem.sResource,
1087 &lockFlagsWriteOnly));
1088
1089 *data = 1;
1090
1091 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnUnlockResource(
1092 m_osInterface,
1093 &m_refSync[i].resSemaphoreMem.sResource));
1094 }
1095 }
1096
1097 // create the HW semaphore buffer to sync up between VDBOXes. This is used to WA HW internal lock issue
1098 if (m_enableVdBoxHWSemaphore)
1099 {
1100 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1101 allocParamsForBufferLinear.pBufName = "VDBOX SemaphoreMemory";
1102
1103 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1104 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1105 lockFlagsWriteOnly.WriteOnly = 1;
1106
1107 uint32_t* data = nullptr;
1108
1109 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_resVdBoxSemaphoreMem); i++)
1110 {
1111 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1112 m_osInterface,
1113 &allocParamsForBufferLinear,
1114 &m_resVdBoxSemaphoreMem[i].sResource),
1115 "Failed to create VDBOX HW Semaphore Memory.");
1116
1117 CODECHAL_ENCODE_CHK_NULL_RETURN(data = (uint32_t *)m_osInterface->pfnLockResource(
1118 m_osInterface,
1119 &m_resVdBoxSemaphoreMem[i].sResource,
1120 &lockFlagsWriteOnly));
1121
1122 *data = 0;
1123
1124 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnUnlockResource(
1125 m_osInterface,
1126 &m_resVdBoxSemaphoreMem[i].sResource));
1127 }
1128
1129 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_resPipeStartSemaMem); i++)
1130 {
1131 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1132 m_osInterface,
1133 &allocParamsForBufferLinear,
1134 &m_resPipeStartSemaMem[i].sResource),
1135 "Failed to create VDBOX HW Semaphore Memory.");
1136
1137 CODECHAL_ENCODE_CHK_NULL_RETURN(data = (uint32_t *)m_osInterface->pfnLockResource(
1138 m_osInterface,
1139 &m_resPipeStartSemaMem[i].sResource,
1140 &lockFlagsWriteOnly));
1141
1142 *data = 0;
1143
1144 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnUnlockResource(
1145 m_osInterface,
1146 &m_resPipeStartSemaMem[i].sResource));
1147 }
1148 }
1149
1150 uint32_t* data = nullptr;
1151 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1152 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1153 lockFlagsWriteOnly.WriteOnly = 1;
1154
1155 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1156 allocParamsForBufferLinear.pBufName = "BrcPakSemaphoreMemory";
1157
1158 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1159 m_osInterface,
1160 &allocParamsForBufferLinear,
1161 &m_resBrcPakSemaphoreMem.sResource),
1162 "Failed to create BRC PAK Semaphore Memory.");
1163
1164 CODECHAL_ENCODE_CHK_NULL_RETURN(data = (uint32_t *)m_osInterface->pfnLockResource(
1165 m_osInterface,
1166 &m_resBrcPakSemaphoreMem.sResource,
1167 &lockFlagsWriteOnly));
1168
1169 *data = 0;
1170
1171 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnUnlockResource(
1172 m_osInterface,
1173 &m_resBrcPakSemaphoreMem.sResource));
1174
1175 // 3rd level batch buffer
1176 // To be moved to a more proper place later
1177 MOS_ZeroMemory(&m_thirdLevelBatchBuffer, sizeof(m_thirdLevelBatchBuffer));
1178 m_thirdLevelBatchBuffer.bSecondLevel = true;
1179 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
1180 m_osInterface,
1181 &m_thirdLevelBatchBuffer,
1182 nullptr,
1183 m_thirdLBSize));
1184
1185 if (m_enableTileStitchByHW)
1186 {
1187 if (Mos_ResourceIsNull(&m_resHucStatus2Buffer))
1188 {
1189 // HUC STATUS 2 Buffer for HuC status check in COND_BB_END
1190 allocParamsForBufferLinear.dwBytes = sizeof(uint64_t);
1191 allocParamsForBufferLinear.pBufName = "HUC STATUS 2 Buffer";
1192 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(
1193 m_osInterface->pfnAllocateResource(
1194 m_osInterface,
1195 &allocParamsForBufferLinear,
1196 &m_resHucStatus2Buffer),
1197 "%s: Failed to allocate HUC STATUS 2 Buffer\n",
1198 __FUNCTION__);
1199 }
1200 uint8_t *data;
1201 for (auto i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1202 {
1203 for (auto j = 0; j < CODECHAL_HEVC_MAX_NUM_BRC_PASSES; j++)
1204 {
1205 // HuC stitching Data buffer
1206 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(sizeof(HucCommandDataVdencG12), CODECHAL_PAGE_SIZE);
1207 allocParamsForBufferLinear.pBufName = "HEVC HuC Stitch Data Buffer";
1208 CODECHAL_ENCODE_CHK_STATUS_RETURN(
1209 m_osInterface->pfnAllocateResource(
1210 m_osInterface,
1211 &allocParamsForBufferLinear,
1212 &m_resHucStitchDataBuffer[i][j]));
1213 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1214 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1215 lockFlagsWriteOnly.WriteOnly = 1;
1216 uint8_t *pData = (uint8_t *)m_osInterface->pfnLockResource(
1217 m_osInterface,
1218 &m_resHucStitchDataBuffer[i][j],
1219 &lockFlagsWriteOnly);
1220 CODECHAL_ENCODE_CHK_NULL_RETURN(pData);
1221 MOS_ZeroMemory(pData, allocParamsForBufferLinear.dwBytes);
1222 m_osInterface->pfnUnlockResource(m_osInterface, &m_resHucStitchDataBuffer[i][j]);
1223 }
1224 }
1225 //Second level BB for huc stitching cmd
1226 MOS_ZeroMemory(&m_HucStitchCmdBatchBuffer, sizeof(m_HucStitchCmdBatchBuffer));
1227 m_HucStitchCmdBatchBuffer.bSecondLevel = true;
1228 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
1229 m_osInterface,
1230 &m_HucStitchCmdBatchBuffer,
1231 nullptr,
1232 m_hwInterface->m_HucStitchCmdBatchBufferSize));
1233 }
1234
1235 if (m_numDelay)
1236 {
1237 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1238 allocParamsForBufferLinear.pBufName = "DelayMinusMemory";
1239
1240 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1241 m_osInterface,
1242 &allocParamsForBufferLinear,
1243 &m_resDelayMinus), "Failed to allocate delay minus memory.");
1244
1245 uint8_t* data;
1246 MOS_LOCK_PARAMS lockFlags;
1247 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1248 lockFlags.WriteOnly = 1;
1249 data = (uint8_t*)m_osInterface->pfnLockResource(
1250 m_osInterface,
1251 &m_resDelayMinus,
1252 &lockFlags);
1253
1254 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
1255
1256 MOS_ZeroMemory(data, sizeof(uint32_t));
1257
1258 m_osInterface->pfnUnlockResource(m_osInterface, &m_resDelayMinus);
1259 }
1260
1261 return eStatus;
1262 }
1263
1264 MOS_STATUS CodechalVdencHevcStateG12::FreePakResources()
1265 {
1266 CODECHAL_ENCODE_FUNCTION_ENTER;
1267
1268 m_osInterface->pfnFreeResource(m_osInterface, &m_resSseSrcPixelRowStoreBuffer);
1269 m_osInterface->pfnFreeResource(m_osInterface, &m_resHcpScalabilitySyncBuffer.sResource);
1270 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencSAORowStoreBuffer);
1271 m_osInterface->pfnFreeResource(m_osInterface, &m_resPakcuLevelStreamoutData.sResource);
1272 if (!Mos_ResourceIsNull(&m_resHwCountTileReplay))
1273 {
1274 m_osInterface->pfnFreeResource(m_osInterface, &m_resHwCountTileReplay);
1275 }
1276
1277 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_resTileBasedStatisticsBuffer); i++)
1278 {
1279 m_osInterface->pfnFreeResource(m_osInterface, &m_resTileBasedStatisticsBuffer[i].sResource);
1280 }
1281 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_tileRecordBuffer); i++)
1282 {
1283 m_osInterface->pfnFreeResource(m_osInterface, &m_tileRecordBuffer[i].sResource);
1284 }
1285 m_osInterface->pfnFreeResource(m_osInterface, &m_resHuCPakAggregatedFrameStatsBuffer.sResource);
1286
1287 m_osInterface->pfnFreeResource(m_osInterface, &m_resBrcDataBuffer);
1288
1289 for (auto k = 0; k < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; k++)
1290 {
1291 for (auto i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
1292 {
1293 m_osInterface->pfnFreeResource(m_osInterface, &m_resHucPakStitchDmemBuffer[k][i]);
1294 }
1295 }
1296
1297 if (m_numDelay)
1298 {
1299 m_osInterface->pfnFreeResource(m_osInterface, &m_resDelayMinus);
1300 }
1301
1302 for (auto i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; i++)
1303 {
1304 MOS_FreeMemory(m_tileParams[i]);
1305 }
1306
1307 // command buffer for VE, allocated in MOS_STATUS CodechalEncodeHevcBase::VerifyCommandBufferSize()
1308 for (auto i = 0; i < CODECHAL_NUM_UNCOMPRESSED_SURFACE_HEVC; i++)
1309 {
1310 for (auto j = 0; j < CODECHAL_HEVC_MAX_NUM_HCP_PIPE; j++)
1311 {
1312 for (auto k = 0; k < CODECHAL_HEVC_MAX_NUM_BRC_PASSES; k++)
1313 {
1314 PMOS_COMMAND_BUFFER cmdBuffer = &m_veBatchBuffer[i][j][k];
1315
1316 if (!Mos_ResourceIsNull(&cmdBuffer->OsResource))
1317 {
1318 if (cmdBuffer->pCmdBase)
1319 {
1320 m_osInterface->pfnUnlockResource(m_osInterface, &cmdBuffer->OsResource);
1321 }
1322 m_osInterface->pfnFreeResource(m_osInterface, &cmdBuffer->OsResource);
1323 }
1324 }
1325 }
1326 }
1327
1328 for (auto i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_refSync); i++)
1329 {
1330 auto sync = &m_refSync[i];
1331
1332 if (!Mos_ResourceIsNull(&sync->resSyncObject))
1333 {
1334 // if this object has been signaled before, we need to wait to ensure singal-wait is in pair.
1335 if (sync->uiSemaphoreObjCount || sync->bInUsed)
1336 {
1337 MOS_SYNC_PARAMS syncParams = g_cInitSyncParams;
1338 syncParams.GpuContext = m_renderContext;
1339 syncParams.presSyncResource = &sync->resSyncObject;
1340 syncParams.uiSemaphoreCount = sync->uiSemaphoreObjCount;
1341 m_osInterface->pfnEngineWait(m_osInterface, &syncParams);
1342 }
1343 }
1344 m_osInterface->pfnFreeResource(m_osInterface, &sync->resSemaphoreMem.sResource);
1345 }
1346
1347 for (uint32_t i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_resVdBoxSemaphoreMem); i++)
1348 {
1349 m_osInterface->pfnFreeResource(m_osInterface, &m_resVdBoxSemaphoreMem[i].sResource);
1350 }
1351
1352 for (uint32_t i = 0; i < CODECHAL_GET_ARRAY_LENGTH(m_resPipeStartSemaMem); i++)
1353 {
1354 m_osInterface->pfnFreeResource(m_osInterface, &m_resPipeStartSemaMem[i].sResource);
1355 }
1356
1357 if (m_enableTileStitchByHW)
1358 {
1359 for (auto i = 0; i < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; i++)
1360 {
1361 for (auto j = 0; j < CODECHAL_HEVC_MAX_NUM_BRC_PASSES; j++)
1362 {
1363 // HuC stitching Data buffer
1364 m_osInterface->pfnFreeResource(
1365 m_osInterface,
1366 &m_resHucStitchDataBuffer[i][j]);
1367 }
1368 }
1369 //Second level BB for huc stitching cmd
1370 Mhw_FreeBb(m_osInterface, &m_HucStitchCmdBatchBuffer, nullptr);
1371 }
1372
1373 Mhw_FreeBb(m_osInterface, &m_thirdLevelBatchBuffer, nullptr);
1374 FreeTileLevelBatch();
1375 FreeTileRowLevelBRCBatch();
1376
1377 m_osInterface->pfnFreeResource(m_osInterface, &m_resBrcPakSemaphoreMem.sResource);
1378
1379 return CodechalVdencHevcState::FreePakResources();
1380 }
1381
1382 MOS_STATUS CodechalVdencHevcStateG12::AllocateEncResources()
1383 {
1384 CODECHAL_ENCODE_FUNCTION_ENTER;
1385
1386 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1387
1388 //CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::AllocateEncResources());
1389
1390 if (m_hmeSupported)
1391 {
1392 HmeParams hmeParams;
1393
1394 MOS_ZeroMemory(&hmeParams, sizeof(hmeParams));
1395 hmeParams.b4xMeDistortionBufferSupported = true;
1396 hmeParams.ps16xMeMvDataBuffer = &m_s16XMeMvDataBuffer;
1397 hmeParams.ps32xMeMvDataBuffer = &m_s32XMeMvDataBuffer;
1398 hmeParams.ps4xMeDistortionBuffer = &m_s4XMeDistortionBuffer;
1399 hmeParams.ps4xMeMvDataBuffer = &m_s4XMeMvDataBuffer;
1400 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateResources4xME(&hmeParams));
1401 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateResources16xME(&hmeParams));
1402 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateResources32xME(&hmeParams));
1403 }
1404
1405 // VDENC tile row store buffer
1406 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
1407 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1408 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
1409 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
1410 allocParamsForBufferLinear.Format = Format_Buffer;
1411 allocParamsForBufferLinear.dwBytes = MOS_ROUNDUP_DIVIDE(m_frameWidth, 32) * CODECHAL_CACHELINE_SIZE * 2;
1412 allocParamsForBufferLinear.pBufName = "VDENC Tile Row Store Buffer";
1413
1414 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1415 m_osInterface,
1416 &allocParamsForBufferLinear,
1417 &m_vdencTileRowStoreBuffer),
1418 "Failed to allocate VDENC Tile Row Store Buffer");
1419
1420 MOS_ALLOC_GFXRES_PARAMS allocParamsForSurface;
1421 MOS_ZeroMemory(&allocParamsForSurface, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1422 allocParamsForSurface.Type = MOS_GFXRES_BUFFER;
1423 allocParamsForSurface.TileType = MOS_TILE_LINEAR;
1424 allocParamsForSurface.Format = Format_Buffer;
1425 allocParamsForSurface.dwBytes = m_numLcu * 4;
1426 allocParamsForSurface.pBufName = "VDEnc Cumulative CU Count Streamout Surface";
1427
1428 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1429 m_osInterface,
1430 &allocParamsForSurface,
1431 &m_vdencCumulativeCuCountStreamoutSurface),
1432 "Failed to allocate VDEnc Cumulative CU Count Streamout Surface");
1433
1434 // Move from CodechalVdencHevcState::AllocateEncResources()
1435
1436 // PAK stream-out buffer
1437 allocParamsForBufferLinear.dwBytes = CODECHAL_HEVC_PAK_STREAMOUT_SIZE;
1438 allocParamsForBufferLinear.pBufName = "Pak StreamOut Buffer";
1439 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1440 m_osInterface,
1441 &allocParamsForBufferLinear,
1442 &m_resStreamOutBuffer[0]),
1443 "Failed to allocate Pak Stream Out Buffer.");
1444
1445 // VDENC Intra Row Store Scratch buffer
1446 // 1 cacheline per MB
1447 // Double the size for Tile Replay
1448 uint32_t size = MOS_ROUNDUP_DIVIDE(m_frameWidth, MAX_LCU_SIZE) * CODECHAL_CACHELINE_SIZE * 2 * 2;
1449 CODECHAL_ENCODE_CHK_NULL_RETURN(m_allocator->AllocateResource(
1450 m_standard, size, 1, vdencIntraRowStoreScratch, "vdencIntraRowStoreScratch"));
1451
1452 // VDENC Statistics buffer
1453 // Enabled for BRC only
1454 size = MOS_ALIGN_CEIL(m_vdencBrcStatsBufferSize * m_maxTileNumber, CODECHAL_PAGE_SIZE);
1455 CODECHAL_ENCODE_CHK_NULL_RETURN(m_allocator->AllocateResource(
1456 m_standard, size, 1, vdencStats, "vdencStats"));
1457
1458 // end of CodechalVdencHevcState::AllocateEncResources()
1459
1460 if (m_enableSCC)
1461 {
1462 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1463 MOS_ALLOC_GFXRES_PARAMS allocParamsForBuffer2D;
1464 uint32_t alignedWidth, alignedHeight;
1465
1466 // Allocate the recon not filtered surface for IBC
1467 // First align to LCU size 64x64
1468 alignedWidth = MOS_ALIGN_CEIL(m_frameWidth, MAX_LCU_SIZE);
1469 alignedHeight = MOS_ALIGN_CEIL(m_frameHeight, MAX_LCU_SIZE);
1470
1471 MOS_ZeroMemory(&allocParamsForBuffer2D, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1472 allocParamsForBuffer2D.Type = MOS_GFXRES_2D;
1473 allocParamsForBuffer2D.TileType = MOS_TILE_Y;
1474 // default setting
1475 allocParamsForBuffer2D.Format = Format_NV12;
1476 allocParamsForBuffer2D.pBufName = "Recon not Filtered Surface";
1477 allocParamsForBuffer2D.dwWidth = alignedWidth;
1478 allocParamsForBuffer2D.dwHeight = alignedHeight;
1479
1480 // The format and size is dependent on chroma format and bit depth
1481 CODECHAL_ENCODE_ASSERT(m_bitDepth < 12);
1482
1483 if (HCP_CHROMA_FORMAT_YUV420 == m_chromaFormat)
1484 {
1485 if (10 == m_bitDepth)
1486 {
1487 if (m_mmcState && m_mmcState->IsMmcEnabled())
1488 {
1489 allocParamsForBuffer2D.dwWidth = alignedWidth * 2;
1490 }
1491 else
1492 {
1493 allocParamsForBuffer2D.Format = Format_P010;
1494 }
1495 }
1496 }
1497 else if (HCP_CHROMA_FORMAT_YUV444 == m_chromaFormat)
1498 {
1499 if (8 == m_bitDepth)
1500 {
1501 allocParamsForBuffer2D.Format = Format_AYUV;
1502 allocParamsForBuffer2D.dwWidth = alignedWidth >> 2;
1503 allocParamsForBuffer2D.dwHeight = alignedHeight * 3;
1504 }
1505 else
1506 {
1507 allocParamsForBuffer2D.Format = Format_Y410;
1508 allocParamsForBuffer2D.dwWidth = alignedWidth >> 1;
1509 allocParamsForBuffer2D.dwHeight = alignedHeight * 3;
1510 }
1511 }
1512 else
1513 {
1514 CODECHAL_ENCODE_ASSERTMESSAGE("4:2:2 is not supported for SCC feature!");
1515 eStatus = MOS_STATUS_INVALID_PARAMETER;
1516 return eStatus;
1517 }
1518
1519 if (m_mmcState && m_mmcState->IsMmcEnabled())
1520 {
1521 allocParamsForBuffer2D.bIsCompressible = true;
1522 allocParamsForBuffer2D.CompressionMode = MOS_MMC_MC;
1523 }
1524 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1525 m_osInterface,
1526 &allocParamsForBuffer2D,
1527 &m_vdencRecNotFilteredBuffer),
1528 "Failed to allocate Recon not filtered surface for IBC");
1529 }
1530
1531 return eStatus;
1532 }
1533
1534 MOS_STATUS CodechalVdencHevcStateG12::FreeEncResources()
1535 {
1536 CODECHAL_ENCODE_FUNCTION_ENTER;
1537
1538 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencTileRowStoreBuffer);
1539 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencCumulativeCuCountStreamoutSurface);
1540
1541 // Free ME resources
1542 HmeParams hmeParams;
1543
1544 MOS_ZeroMemory(&hmeParams, sizeof(hmeParams));
1545 hmeParams.ps16xMeMvDataBuffer = &m_s16XMeMvDataBuffer;
1546 hmeParams.ps32xMeMvDataBuffer = &m_s32XMeMvDataBuffer;
1547 hmeParams.ps4xMeDistortionBuffer = &m_s4XMeDistortionBuffer;
1548 hmeParams.ps4xMeMvDataBuffer = &m_s4XMeMvDataBuffer;
1549 DestroyMEResources(&hmeParams);
1550
1551 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencRecNotFilteredBuffer);
1552
1553 return CodechalVdencHevcState::FreeEncResources();
1554 }
1555
1556 MOS_STATUS CodechalVdencHevcStateG12::AllocateBrcResources()
1557 {
1558 CODECHAL_ENCODE_FUNCTION_ENTER;
1559 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1560
1561 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::AllocateBrcResources());
1562
1563 uint32_t* data = nullptr;
1564 MOS_LOCK_PARAMS lockFlagsWriteOnly;
1565 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
1566 lockFlagsWriteOnly.WriteOnly = 1;
1567
1568 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
1569 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1570 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
1571 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
1572 allocParamsForBufferLinear.Format = Format_Buffer;
1573 allocParamsForBufferLinear.dwBytes = sizeof(uint32_t);
1574 allocParamsForBufferLinear.pBufName = "TileRowBRCSyncSemaphore";
1575
1576 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1577 m_osInterface,
1578 &allocParamsForBufferLinear,
1579 &m_resTileRowBRCsyncSemaphore),
1580 "Failed to create Tile Row BRC sync Semaphore Memory.");
1581
1582 CODECHAL_ENCODE_CHK_NULL_RETURN(data = (uint32_t *)m_osInterface->pfnLockResource(
1583 m_osInterface,
1584 &m_resTileRowBRCsyncSemaphore,
1585 &lockFlagsWriteOnly));
1586
1587 *data = 0;
1588
1589 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnUnlockResource(
1590 m_osInterface,
1591 &m_resTileRowBRCsyncSemaphore));
1592
1593 return eStatus;
1594 }
1595
1596 MOS_STATUS CodechalVdencHevcStateG12::FreeBrcResources()
1597 {
1598 CODECHAL_ENCODE_FUNCTION_ENTER;
1599
1600 m_osInterface->pfnFreeResource(m_osInterface, &m_resTileRowBRCsyncSemaphore);
1601 return CodechalVdencHevcState::FreeBrcResources();
1602 }
1603
1604 MOS_STATUS CodechalVdencHevcStateG12::AllocateTileLevelBatch()
1605 {
1606 CODECHAL_ENCODE_FUNCTION_ENTER;
1607
1608 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1609
1610 // Only allocate when the number of tile changed
1611 if (m_numTileBatchAllocated >= m_numTiles)
1612 {
1613 return eStatus;
1614 }
1615
1616 // Make it simple, free first if need reallocate
1617 if (m_numTileBatchAllocated > 0)
1618 {
1619 CODECHAL_ENCODE_CHK_STATUS_RETURN(FreeTileLevelBatch());
1620 }
1621
1622 // First allocate the batch buffer array
1623 for (int32_t idx = 0; idx < CODECHAL_VDENC_BRC_NUM_OF_PASSES; idx++)
1624 {
1625 if (m_tileLevelBatchBuffer[idx] == nullptr)
1626 {
1627 m_tileLevelBatchBuffer[idx] = (PMHW_BATCH_BUFFER)MOS_AllocAndZeroMemory(sizeof(MHW_BATCH_BUFFER) * m_numTiles);
1628
1629 if (nullptr == m_tileLevelBatchBuffer[idx])
1630 {
1631 CODECHAL_ENCODE_ASSERTMESSAGE("Allocate memory for tile batch buffer failed");
1632 return MOS_STATUS_NO_SPACE;
1633 }
1634 }
1635
1636 // Allocate the batch buffer for each tile
1637 uint32_t i = 0;
1638 for (i = 0; i < m_numTiles; i++)
1639 {
1640 MOS_ZeroMemory(&m_tileLevelBatchBuffer[idx][i], sizeof(MHW_BATCH_BUFFER));
1641 m_tileLevelBatchBuffer[idx][i].bSecondLevel = true;
1642 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
1643 m_osInterface,
1644 &m_tileLevelBatchBuffer[idx][i],
1645 nullptr,
1646 m_tileLevelBatchSize));
1647 }
1648 }
1649
1650 // Record the number of allocated batch buffer for tiles
1651 m_numTileBatchAllocated = m_numTiles;
1652 return eStatus;
1653 }
1654
1655 MOS_STATUS CodechalVdencHevcStateG12::FreeTileLevelBatch()
1656 {
1657 CODECHAL_ENCODE_FUNCTION_ENTER;
1658
1659 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1660
1661 // Free the batch buffer for each tile
1662 uint32_t i = 0;
1663 uint32_t j = 0;
1664 for (i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
1665 {
1666 for (j = 0; j < m_numTileBatchAllocated; j++)
1667 {
1668 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_FreeBb(m_osInterface, &m_tileLevelBatchBuffer[i][j], nullptr));
1669 }
1670
1671 MOS_FreeMemory(m_tileLevelBatchBuffer[i]);
1672 m_tileLevelBatchBuffer[i] = nullptr;
1673 }
1674
1675 // Reset the number of tile batch allocated
1676 m_numTileBatchAllocated = 0;
1677
1678 return eStatus;
1679 }
1680
1681 MOS_STATUS CodechalVdencHevcStateG12::AllocateTileRowLevelBRCBatch()
1682 {
1683 CODECHAL_ENCODE_FUNCTION_ENTER;
1684
1685 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1686
1687 // Only allocate when the number of tile row changed
1688 if (m_numTileRowBRCBatchAllocated >= m_numTileRows)
1689 {
1690 return eStatus;
1691 }
1692
1693 // Make it simple, free first if need reallocate
1694 if (m_numTileRowBRCBatchAllocated > 0)
1695 {
1696 CODECHAL_ENCODE_CHK_STATUS_RETURN(FreeTileRowLevelBRCBatch());
1697 }
1698
1699 // First allocate the batch buffer array
1700 for (int32_t idx = 0; idx < CODECHAL_VDENC_BRC_NUM_OF_PASSES; idx++)
1701 {
1702 if (m_TileRowBRCBatchBuffer[idx] == nullptr)
1703 {
1704 m_TileRowBRCBatchBuffer[idx] = (PMHW_BATCH_BUFFER)MOS_AllocAndZeroMemory(sizeof(MHW_BATCH_BUFFER) * m_numTileRows);
1705
1706 if (nullptr == m_TileRowBRCBatchBuffer[idx])
1707 {
1708 CODECHAL_ENCODE_ASSERTMESSAGE("Allocate memory for tile row level BRC batch buffer failed");
1709 return MOS_STATUS_NO_SPACE;
1710 }
1711 }
1712
1713 // Allocate the batch buffer for each tile row
1714 uint32_t i = 0;
1715 for (i = 0; i < m_numTileRows; i++)
1716 {
1717 MOS_ZeroMemory(&m_TileRowBRCBatchBuffer[idx][i], sizeof(MHW_BATCH_BUFFER));
1718 m_TileRowBRCBatchBuffer[idx][i].bSecondLevel = true;
1719 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_AllocateBb(
1720 m_osInterface,
1721 &m_TileRowBRCBatchBuffer[idx][i],
1722 nullptr,
1723 m_hwInterface->m_hucCommandBufferSize));
1724 }
1725 }
1726
1727 // Record the number of allocated batch buffer for tiles
1728 m_numTileRowBRCBatchAllocated = m_numTileRows;
1729 return eStatus;
1730 }
1731
1732 MOS_STATUS CodechalVdencHevcStateG12::FreeTileRowLevelBRCBatch()
1733 {
1734 CODECHAL_ENCODE_FUNCTION_ENTER;
1735
1736 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1737
1738 // Free the batch buffer for each tile row
1739 uint32_t i = 0;
1740 uint32_t j = 0;
1741 for (i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
1742 {
1743 for (j = 0; j < m_numTileRowBRCBatchAllocated; j++)
1744 {
1745 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_FreeBb(m_osInterface, &m_TileRowBRCBatchBuffer[i][j], nullptr));
1746 }
1747
1748 MOS_FreeMemory(m_TileRowBRCBatchBuffer[i]);
1749 m_TileRowBRCBatchBuffer[i] = nullptr;
1750 }
1751
1752 // Reset the number of tile row BRC batch allocated
1753 m_numTileRowBRCBatchAllocated = 0;
1754
1755 return eStatus;
1756 }
1757
1758 MOS_STATUS CodechalVdencHevcStateG12::InitializePicture(const EncoderParams& params)
1759 {
1760 CODECHAL_ENCODE_FUNCTION_ENTER;
1761
1762 m_numNAL = params.uiNumNalUnits;
1763 m_overallNALPayload = params.uiOverallNALPayload;
1764
1765 // common initilization
1766 return CodechalVdencHevcState::InitializePicture(params);
1767 }
1768
1769 MOS_STATUS CodechalVdencHevcStateG12::SetSequenceStructs()
1770 {
1771 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1772
1773 CODECHAL_ENCODE_FUNCTION_ENTER;
1774
1775 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
1776 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
1777 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
1778 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
1779 allocParamsForBufferLinear.Format = Format_Buffer;
1780 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_hwInterface->m_vdencReadBatchBufferSize, CODECHAL_PAGE_SIZE);
1781 allocParamsForBufferLinear.pBufName = "VDENC Read Batch Buffer";
1782
1783 uint32_t batchBufferSize = m_hwInterface->m_vdencReadBatchBufferSize +
1784 ENCODE_HEVC_VDENC_NUM_MAX_SLICES * (m_numNAL * mhw_vdbox_hcp_g12_X::HCP_PAK_INSERT_OBJECT_CMD::byteSize + m_overallNALPayload);
1785
1786 if (batchBufferSize > allocParamsForBufferLinear.dwBytes && allocParamsForBufferLinear.dwBytes != m_prevVdencReadBatchBufferSize)
1787 {
1788 m_hwInterface->m_vdencReadBatchBufferSize = batchBufferSize;
1789 m_hwInterface->m_vdenc2ndLevelBatchBufferSize = batchBufferSize;
1790 m_tileLevelBatchSize = batchBufferSize;
1791 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_hwInterface->m_vdencReadBatchBufferSize, CODECHAL_PAGE_SIZE);
1792 m_prevVdencReadBatchBufferSize = allocParamsForBufferLinear.dwBytes;
1793
1794 for (auto k = 0; k < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; k++)
1795 {
1796 for (auto i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
1797 {
1798 if (!Mos_ResourceIsNull(&m_vdencReadBatchBuffer[k][i]))
1799 {
1800 m_osInterface->pfnFreeResource(m_osInterface, &m_vdencReadBatchBuffer[k][i]);
1801 }
1802 }
1803
1804 for (auto i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
1805 {
1806 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
1807 m_osInterface,
1808 &allocParamsForBufferLinear,
1809 &m_vdencReadBatchBuffer[k][i]),
1810 "Failed to allocate VDENC Read Batch Buffer");
1811 }
1812 }
1813 }
1814
1815 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::SetSequenceStructs());
1816
1817 return eStatus;
1818 }
1819
1820 MOS_STATUS CodechalVdencHevcStateG12::SetPictureStructs()
1821 {
1822 CODECHAL_ENCODE_FUNCTION_ENTER;
1823
1824 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1825
1826 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::SetPictureStructs());
1827
1828 if ((uint8_t)HCP_CHROMA_FORMAT_YUV422 == m_chromaFormat &&
1829 (uint8_t)HCP_CHROMA_FORMAT_YUV422 == m_outputChromaFormat)
1830 {
1831 if (Format_YUY2 != m_reconSurface.Format)
1832 {
1833 eStatus = MOS_STATUS_INVALID_PARAMETER;
1834 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Recon surface format is not correct!");
1835 }
1836 else if (m_reconSurface.dwHeight < m_oriFrameHeight * 2 ||
1837 m_reconSurface.dwWidth < m_oriFrameWidth / 2)
1838 {
1839 eStatus = MOS_STATUS_INVALID_PARAMETER;
1840 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(eStatus, "Recon surface allocation size is not correct!");
1841 }
1842 else
1843 {
1844 // update Recon surface to Variant format
1845 CodechalEncodeHevcBase::UpdateYUY2SurfaceInfo(&m_reconSurface, m_is10BitHevc);
1846 }
1847 }
1848
1849 // Frame level BRC pass set to one pass when tile replay is enabled
1850 if (m_enableTileReplay)
1851 {
1852 m_numPasses = 0;
1853 }
1854
1855 // Error concealment, disable IBC if slice coding type is I type
1856 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
1857 {
1858 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
1859 {
1860 if (m_hevcSliceParams[slcCount].slice_type == CODECHAL_ENCODE_HEVC_I_SLICE)
1861 {
1862 m_hevcPicParams->pps_curr_pic_ref_enabled_flag = false;
1863 break;
1864 }
1865 }
1866 }
1867
1868 // EOS is not working on GEN12, disable it by setting below to false (WA)
1869 m_lastPicInSeq = false;
1870 m_lastPicInStream = false;
1871 return eStatus;
1872 }
1873
1874 MOS_STATUS CodechalVdencHevcStateG12::GetStatusReport(
1875 EncodeStatus *encodeStatus,
1876 EncodeStatusReport *encodeStatusReport)
1877 {
1878 CODECHAL_ENCODE_FUNCTION_ENTER;
1879
1880 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1881
1882 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatus);
1883 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatusReport);
1884
1885 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpVdencOutputs()));
1886
1887 // When tile replay is enabled with tile replay, need to report out the tile size and the bit stream is not continous
1888 if ((encodeStatusReport->UsedVdBoxNumber == 1) && (!m_enableTileReplay || (m_enableTileReplay && encodeStatusReport->NumberTilesInFrame == 1)))
1889 {
1890 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::GetStatusReport(encodeStatus, encodeStatusReport));
1891 return eStatus;
1892 }
1893
1894 // Allocate the tile size report memory
1895 encodeStatusReport->SizeOfTileInfoBuffer = encodeStatusReport->NumberTilesInFrame * sizeof(CodechalTileInfo);
1896 if (encodeStatusReport->pHEVCTileinfo)
1897 {
1898 MOS_FreeMemory(encodeStatusReport->pHEVCTileinfo);
1899 encodeStatusReport->pHEVCTileinfo = nullptr;
1900 }
1901 encodeStatusReport->pHEVCTileinfo = (CodechalTileInfo *)MOS_AllocAndZeroMemory(encodeStatusReport->SizeOfTileInfoBuffer);
1902 CODECHAL_ENCODE_CHK_NULL_RETURN(encodeStatusReport->pHEVCTileinfo);
1903
1904 // In case of CQP, PAK integration kernel is not called, so used tile size record from HW
1905 // PAK integration kernel does not handle stitching for single pipe mode
1906 PCODECHAL_ENCODE_BUFFER tileSizeStatusReport = &m_tileRecordBuffer[encodeStatusReport->CurrOriginalPic.FrameIdx];
1907 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[encodeStatusReport->CurrOriginalPic.FrameIdx];
1908
1909 MOS_LOCK_PARAMS lockFlags;
1910 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1911 lockFlags.ReadOnly = 1;
1912 HCPPakHWTileSizeRecord_G12* tileStatusReport = (HCPPakHWTileSizeRecord_G12*)m_osInterface->pfnLockResource(
1913 m_osInterface,
1914 &tileSizeStatusReport->sResource,
1915 &lockFlags);
1916 CODECHAL_ENCODE_CHK_NULL_RETURN(tileStatusReport);
1917
1918 encodeStatusReport->CodecStatus = CODECHAL_STATUS_SUCCESSFUL;
1919 encodeStatusReport->PanicMode = false;
1920 encodeStatusReport->AverageQp = 0;
1921 encodeStatusReport->QpY = 0;
1922 encodeStatusReport->SuggestedQpYDelta = 0;
1923 encodeStatusReport->NumberPasses = 1;
1924 encodeStatusReport->bitstreamSize = 0;
1925 encodeStatus->ImageStatusCtrlOfLastBRCPass.hcpCumulativeFrameDeltaQp = 0;
1926 encodeStatusReport->NumberSlices = 0;
1927
1928 uint32_t* sliceSize = nullptr;
1929
1930 // pSliceSize is set/ allocated only when dynamic slice is enabled. Cannot use SSC flag here, as it is an asynchronous call
1931 if (encodeStatus->sliceReport.pSliceSize)
1932 {
1933 sliceSize = (uint32_t*)m_osInterface->pfnLockResource(m_osInterface, encodeStatus->sliceReport.pSliceSize, &lockFlags);
1934 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceSize);
1935 }
1936
1937 uint32_t totalCU = 0;
1938 uint32_t sliceCount = 0;
1939 double sumQp = 0.0;
1940 for (uint32_t i = 0; i < encodeStatusReport->NumberTilesInFrame; i++)
1941 {
1942 if (tileStatusReport[i].Length == 0)
1943 {
1944 encodeStatusReport->CodecStatus = CODECHAL_STATUS_INCOMPLETE;
1945 return eStatus;
1946 }
1947 //update tile info with HW counter
1948 if (m_osInterface->osCpInterface->IsCpEnabled() && m_hwInterface->GetCpInterface()->IsHwCounterIncrement(m_osInterface) && m_enableTileReplay)
1949 {
1950 if (Mos_ResourceIsNull(&m_resHwCountTileReplay))
1951 {
1952 CODECHAL_ENCODE_ASSERTMESSAGE("m_resHwCountTileReplay is not allocated");
1953 return MOS_STATUS_NULL_POINTER;
1954 }
1955
1956 MOS_LOCK_PARAMS LockFlagsNoOverWrite;
1957 MOS_ZeroMemory(&LockFlagsNoOverWrite, sizeof(MOS_LOCK_PARAMS));
1958 LockFlagsNoOverWrite.WriteOnly = 1;
1959 LockFlagsNoOverWrite.NoOverWrite = 1;
1960
1961 uint8_t* dataHWCountTileReplay = (uint8_t*)m_osInterface->pfnLockResource(
1962 m_osInterface,
1963 &m_resHwCountTileReplay,
1964 &LockFlagsNoOverWrite);
1965
1966 CODECHAL_ENCODE_CHK_NULL_RETURN(dataHWCountTileReplay);
1967 uint64_t *pAddress2Counter = (uint64_t *)(dataHWCountTileReplay + i * sizeof(HwCounter));
1968 encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.Count = *pAddress2Counter;
1969 encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.Count = SwapEndianness(encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.Count); //Report back in Big endian
1970 encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.IV = *(++pAddress2Counter);
1971 encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.IV = SwapEndianness(encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.IV); //Report back in Big endian
1972 CODECHAL_ENCODE_NORMALMESSAGE("tile = %d, hwCounterValue.Count = 0x%llx, hwCounterValue.IV = 0x%llx", i, encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.Count, encodeStatusReport->pHEVCTileinfo[i].HWCounterValue.IV);
1973 if (dataHWCountTileReplay)
1974 {
1975 m_osInterface->pfnUnlockResource(m_osInterface, &m_resHwCountTileReplay);
1976 }
1977 }
1978 encodeStatusReport->pHEVCTileinfo[i].TileSizeInBytes = tileStatusReport[i].Length;
1979 // The offset only valid if there is no stream stitching
1980 encodeStatusReport->pHEVCTileinfo[i].TileBitStreamOffset = tileParams[i].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE;
1981 encodeStatusReport->pHEVCTileinfo[i].TileRowNum = i / tileParams[i].NumOfTileColumnsInFrame;
1982 encodeStatusReport->pHEVCTileinfo[i].TileColNum = i % tileParams[i].NumOfTileColumnsInFrame;
1983 encodeStatusReport->NumTileReported = i + 1;
1984 encodeStatusReport->bitstreamSize += tileStatusReport[i].Length;
1985 totalCU += (tileParams[i].TileHeightInMinCbMinus1 + 1) * (tileParams[i].TileWidthInMinCbMinus1 + 1);
1986 sumQp += tileStatusReport[i].Hcp_Qp_Status_Count;
1987
1988 if (sliceSize)
1989 {
1990 encodeStatusReport->pSliceSizes = (uint16_t*)sliceSize;
1991 encodeStatusReport->NumberSlices += (uint8_t)tileStatusReport[i].Hcp_Slice_Count_Tile;
1992 uint16_t prevCumulativeSliceSize = 0;
1993 // HW writes out a DW for each slice size. Copy in place the DW into 16bit fields expected by App
1994 for (uint32_t idx = 0; idx < tileStatusReport[i].Hcp_Slice_Count_Tile; idx++)
1995 {
1996 // PAK output the sliceSize at 16DW intervals.
1997 CODECHAL_ENCODE_CHK_NULL_RETURN(&sliceSize[sliceCount * 16]);
1998
1999 //convert cummulative slice size to individual, first slice may have PPS/SPS,
2000 uint32_t CurrAccumulatedSliceSize = sliceSize[sliceCount * 16];
2001 encodeStatusReport->pSliceSizes[sliceCount] = CurrAccumulatedSliceSize - prevCumulativeSliceSize;
2002 prevCumulativeSliceSize += encodeStatusReport->pSliceSizes[sliceCount];
2003 sliceCount++;
2004 }
2005 }
2006 }
2007
2008 if (sliceSize)
2009 {
2010 encodeStatusReport->SizeOfSliceSizesBuffer = sizeof(uint16_t) * encodeStatusReport->NumberSlices;
2011 encodeStatusReport->SliceSizeOverflow = (encodeStatus->sliceReport.SliceSizeOverflow >> 16) & 1;
2012 m_osInterface->pfnUnlockResource(m_osInterface, encodeStatus->sliceReport.pSliceSize);
2013 }
2014
2015 CODECHAL_ENCODE_CHK_STATUS_RETURN(CalculatePSNR(encodeStatus, encodeStatusReport));
2016
2017 if (encodeStatusReport->bitstreamSize == 0 ||
2018 encodeStatusReport->bitstreamSize >m_bitstreamUpperBound)
2019 {
2020 encodeStatusReport->CodecStatus = CODECHAL_STATUS_ERROR;
2021 encodeStatusReport->bitstreamSize = 0;
2022 return MOS_STATUS_INVALID_FILE_SIZE;
2023 }
2024
2025 if (totalCU != 0)
2026 {
2027 encodeStatusReport->QpY = encodeStatusReport->AverageQp =
2028 (uint8_t)((sumQp / (double)totalCU) / 4.0); // due to TU is 4x4 and there are 4 TUs in one CU
2029 }
2030 else
2031 {
2032 return MOS_STATUS_INVALID_PARAMETER;
2033 }
2034
2035 if (m_enableTileStitchByHW)
2036 {
2037 if (tileStatusReport)
2038 {
2039 // clean-up the tile status report buffer
2040 MOS_ZeroMemory(tileStatusReport, sizeof(tileStatusReport[0]) * encodeStatusReport->NumberTilesInFrame);
2041 m_osInterface->pfnUnlockResource(m_osInterface, &tileSizeStatusReport->sResource);
2042 }
2043 return eStatus;
2044 }
2045
2046 //Driver stitching is not allowed for secure encode case
2047 if (!m_osInterface->osCpInterface->IsCpEnabled())
2048 {
2049 uint8_t *tempBsBuffer = nullptr, *bufPtr = nullptr;
2050 tempBsBuffer = bufPtr = (uint8_t*)MOS_AllocAndZeroMemory(encodeStatusReport->bitstreamSize);
2051 CODECHAL_ENCODE_CHK_NULL_RETURN(tempBsBuffer);
2052
2053 PCODEC_REF_LIST currRefList = encodeStatus->encodeStatusReport.pCurrRefList;
2054 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
2055 lockFlags.ReadOnly = 1;
2056 uint8_t* bitstream = (uint8_t*)m_osInterface->pfnLockResource(
2057 m_osInterface,
2058 &currRefList->resBitstreamBuffer,
2059 &lockFlags);
2060
2061 if (bitstream == nullptr)
2062 {
2063 MOS_SafeFreeMemory(tempBsBuffer);
2064 return MOS_STATUS_NULL_POINTER;
2065 }
2066
2067 for (uint32_t i = 0; i < encodeStatusReport->NumberTilesInFrame; i++)
2068 {
2069 uint32_t offset = tileParams[i].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE;
2070 uint32_t len = tileStatusReport[i].Length;
2071
2072 MOS_SecureMemcpy(bufPtr, len, &bitstream[offset], len);
2073 bufPtr += len;
2074 }
2075
2076 MOS_SecureMemcpy(bitstream, encodeStatusReport->bitstreamSize, tempBsBuffer, encodeStatusReport->bitstreamSize);
2077 MOS_ZeroMemory(&bitstream[encodeStatusReport->bitstreamSize], m_bitstreamUpperBound - encodeStatusReport->bitstreamSize);
2078
2079 if (bitstream)
2080 {
2081 m_osInterface->pfnUnlockResource(m_osInterface, &currRefList->resBitstreamBuffer);
2082 }
2083
2084 MOS_FreeMemory(tempBsBuffer);
2085 }
2086
2087 if (tileStatusReport)
2088 {
2089 // clean-up the tile status report buffer
2090 MOS_ZeroMemory(tileStatusReport, sizeof(tileStatusReport[0]) * encodeStatusReport->NumberTilesInFrame);
2091
2092 m_osInterface->pfnUnlockResource(m_osInterface, &tileSizeStatusReport->sResource);
2093 }
2094
2095 return eStatus;
2096 }
2097
2098 MOS_STATUS CodechalVdencHevcStateG12::ValidateRefFrameData(PCODEC_HEVC_ENCODE_SLICE_PARAMS slcParams)
2099 {
2100 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2101 bool isRandomAccess = false;
2102
2103 CODECHAL_ENCODE_CHK_NULL_RETURN(slcParams);
2104
2105 if (slcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
2106 {
2107 if (slcParams->num_ref_idx_l0_active_minus1 != slcParams->num_ref_idx_l1_active_minus1)
2108 {
2109 isRandomAccess = true;
2110 }
2111
2112 for (auto j = 0; j < CODEC_MAX_NUM_REF_FRAME_HEVC; j++)
2113 {
2114 if (slcParams->RefPicList[0][j].PicEntry != slcParams->RefPicList[1][j].PicEntry)
2115 {
2116 isRandomAccess = true;
2117 }
2118 }
2119 }
2120
2121 if (isRandomAccess)
2122 {
2123 if (m_hevcPicParams->bEnableRollingIntraRefresh)
2124 {
2125 CODECHAL_ENCODE_ASSERT(false);
2126 eStatus = MOS_STATUS_INVALID_PARAMETER;
2127 }
2128 }
2129
2130 if (isRandomAccess && m_enableSCC)
2131 {
2132 CODECHAL_ENCODE_ASSERT(false);
2133 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
2134 }
2135
2136 uint8_t maxNumRef0 = isRandomAccess ? 2 : m_numMaxVdencL0Ref;
2137 uint8_t maxNumRef1 = isRandomAccess ? 1 : m_numMaxVdencL1Ref;
2138
2139 if (slcParams->num_ref_idx_l0_active_minus1 > maxNumRef0 - 1)
2140 {
2141 CODECHAL_ENCODE_ASSERT(false);
2142 slcParams->num_ref_idx_l0_active_minus1 = maxNumRef0 - 1;
2143 }
2144
2145 if (slcParams->num_ref_idx_l1_active_minus1 > maxNumRef1 - 1)
2146 {
2147 CODECHAL_ENCODE_ASSERT(false);
2148 slcParams->num_ref_idx_l1_active_minus1 = maxNumRef1 - 1;
2149 }
2150
2151 return eStatus;
2152 }
2153
2154 MOS_STATUS CodechalVdencHevcStateG12::UserFeatureKeyReport()
2155 {
2156 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2157
2158 CODECHAL_ENCODE_FUNCTION_ENTER;
2159
2160 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::UserFeatureKeyReport());
2161
2162 #if (_DEBUG || _RELEASE_INTERNAL)
2163 CodecHalEncode_WriteKey64(__MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ENABLE_VE_DEBUG_OVERRIDE, m_kmdVeOveride.Value, m_osInterface->pOsContext);
2164 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENCODE_USED_VDBOX_NUM_ID, m_numPipe, m_osInterface->pOsContext);
2165 CodecHalEncode_WriteKey(__MEDIA_USER_FEATURE_VALUE_ENABLE_ENCODE_VE_CTXSCHEDULING_ID, MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface), m_osInterface->pOsContext);
2166 #endif
2167 return eStatus;
2168 }
2169
2170 MOS_STATUS CodechalVdencHevcStateG12::EncodeKernelFunctions()
2171 {
2172 CODECHAL_ENCODE_FUNCTION_ENTER;
2173
2174 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2175
2176 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
2177 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2178 m_rawSurfaceToEnc,
2179 CodechalDbgAttr::attrEncodeRawInputSurface,
2180 "SrcSurf")));
2181
2182 CODECHAL_DEBUG_TOOL(
2183 PCODEC_PICTURE l0RefFrameList = m_hevcSliceParams->RefPicList[LIST_0];
2184 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l0_active_minus1; refIdx++)
2185 {
2186 CODEC_PICTURE refPic = l0RefFrameList[refIdx];
2187
2188 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
2189 {
2190 // L0 references
2191 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
2192 m_debugInterface->m_refIndex = (uint16_t)m_refList[refPicIdx]->iFieldOrderCnt[0];
2193 std::string refSurfName = "RefSurf_List0_POC" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex));
2194 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2195 &m_refList[refPicIdx]->sRefBuffer,
2196 CodechalDbgAttr::attrReferenceSurfaces,
2197 refSurfName.data()))
2198 }
2199 }
2200
2201 if (!m_lowDelay)
2202 {
2203 PCODEC_PICTURE l1RefFrameList = m_hevcSliceParams->RefPicList[LIST_1];
2204 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l1_active_minus1; refIdx++)
2205 {
2206 CODEC_PICTURE refPic = l1RefFrameList[refIdx];
2207
2208 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
2209 {
2210 // L1 references
2211 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
2212 m_debugInterface->m_refIndex = (uint16_t)m_refList[refPicIdx]->iFieldOrderCnt[0];
2213 std::string refSurfName = "RefSurf_List1_POC" + std::to_string(static_cast<uint32_t>(m_debugInterface->m_refIndex));
2214 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2215 &m_refList[refPicIdx]->sRefBuffer,
2216 CodechalDbgAttr::attrReferenceSurfaces,
2217 refSurfName.data()))
2218 }
2219 }
2220 });
2221
2222 auto singleTaskPhaseSupported = m_singleTaskPhaseSupported; // local variable to save current setting before overwriting
2223
2224 if (m_16xMeSupported)
2225 {
2226 // Enable SingleTaskPhase for now with SHME
2227 m_singleTaskPhaseSupported = true;
2228 m_maxBtCount = GetMaxBtCount();
2229
2230 CodechalEncodeCscDs::KernelParams cscScalingKernelParams;
2231 MOS_ZeroMemory(&cscScalingKernelParams, sizeof(cscScalingKernelParams));
2232
2233 cscScalingKernelParams.bLastTaskInPhaseCSC =
2234 cscScalingKernelParams.bLastTaskInPhase4xDS = false;
2235 cscScalingKernelParams.bLastTaskInPhase16xDS = !(m_32xMeSupported || m_hmeEnabled);
2236 cscScalingKernelParams.bLastTaskInPhase32xDS = !m_hmeEnabled;
2237
2238 m_firstTaskInPhase = true;
2239 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->SetHevcCscFlagAndRawColor());
2240 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_cscDsState->KernelFunctions(&cscScalingKernelParams));
2241
2242 CODECHAL_DEBUG_TOOL(
2243 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2244 m_trackedBuf->Get4xDsSurface(CODEC_CURR_TRACKED_BUFFER),
2245 CodechalDbgAttr::attrReconstructedSurface,
2246 "4x_Scaled_Surf"));
2247
2248 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2249 m_trackedBuf->Get16xDsSurface(CODEC_CURR_TRACKED_BUFFER),
2250 CodechalDbgAttr::attrReconstructedSurface,
2251 "16x_Scaled_Surf"));
2252
2253 if (m_b32XMeEnabled)
2254 {
2255 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpYUVSurface(
2256 m_trackedBuf->Get32xDsSurface(CODEC_CURR_TRACKED_BUFFER),
2257 CodechalDbgAttr::attrReconstructedSurface,
2258 "32x_Scaled_Surf"));
2259 }
2260 )
2261 }
2262
2263 if (m_b16XMeEnabled)
2264 {
2265 if (m_b32XMeEnabled)
2266 {
2267 //HME_P kernel for 32xME
2268 m_lastTaskInPhase = false;
2269 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(HME_LEVEL_32x));
2270 }
2271
2272 //HME_P kernel for 16xME
2273 m_lastTaskInPhase = false;
2274 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(HME_LEVEL_16x));
2275
2276 //StreamIn kernel, 4xME
2277 m_lastTaskInPhase = true;
2278 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncodeMeKernel(HME_LEVEL_4x));
2279 }
2280
2281 // retrieve SingleTaskPhase setting (SAO will need STP enabled setting)
2282 m_singleTaskPhaseSupported = singleTaskPhaseSupported;
2283
2284 CODECHAL_DEBUG_TOOL(
2285 if (m_hmeEnabled) {
2286 CODECHAL_ME_OUTPUT_PARAMS meOutputParams;
2287
2288 MOS_ZeroMemory(&meOutputParams, sizeof(meOutputParams));
2289 meOutputParams.psMeMvBuffer = &m_s4XMeMvDataBuffer;
2290 meOutputParams.psMeBrcDistortionBuffer = nullptr;
2291 meOutputParams.psMeDistortionBuffer = &m_s4XMeDistortionBuffer;
2292 meOutputParams.b16xMeInUse = false;
2293 meOutputParams.b32xMeInUse = false;
2294
2295 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2296 &meOutputParams.psMeMvBuffer->OsResource,
2297 CodechalDbgAttr::attrOutput,
2298 "MvData",
2299 meOutputParams.psMeMvBuffer->dwHeight *meOutputParams.psMeMvBuffer->dwPitch,
2300 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 32), 64) * (m_downscaledFrameFieldHeightInMb4x * 4) : 0,
2301 CODECHAL_MEDIA_STATE_4X_ME));
2302
2303 //CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2304 // &meOutputParams.psMeBrcDistortionBuffer->OsResource,
2305 // CodechalDbgAttr::attrOutput,
2306 // "BrcDist",
2307 // meOutputParams.psMeBrcDistortionBuffer->dwHeight *meOutputParams.psMeBrcDistortionBuffer->dwPitch,
2308 // CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64) * MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4), 8) : 0,
2309 // CODECHAL_MEDIA_STATE_4X_ME));
2310 if (meOutputParams.psMeDistortionBuffer)
2311 {
2312 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2313 &meOutputParams.psMeDistortionBuffer->OsResource,
2314 CodechalDbgAttr::attrOutput,
2315 "MeDist",
2316 meOutputParams.psMeDistortionBuffer->dwHeight *meOutputParams.psMeDistortionBuffer->dwPitch,
2317 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb4x * 8), 64) * MOS_ALIGN_CEIL((m_downscaledFrameFieldHeightInMb4x * 4 * 10), 8) : 0,
2318 CODECHAL_MEDIA_STATE_4X_ME));
2319 }
2320 if (m_b16XMeEnabled)
2321 {
2322 MOS_ZeroMemory(&meOutputParams, sizeof(meOutputParams));
2323 meOutputParams.psMeMvBuffer = &m_s16XMeMvDataBuffer;
2324 meOutputParams.psMeBrcDistortionBuffer = nullptr;
2325 meOutputParams.psMeDistortionBuffer = nullptr;
2326 meOutputParams.b16xMeInUse = true;
2327 meOutputParams.b32xMeInUse = false;
2328
2329 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2330 m_debugInterface->DumpBuffer(
2331 &meOutputParams.psMeMvBuffer->OsResource,
2332 CodechalDbgAttr::attrOutput,
2333 "MvData",
2334 meOutputParams.psMeMvBuffer->dwHeight *meOutputParams.psMeMvBuffer->dwPitch,
2335 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb16x * 32), 64) * (m_downscaledFrameFieldHeightInMb16x * 4) : 0,
2336 CODECHAL_MEDIA_STATE_16X_ME));
2337 }
2338 if (m_b32XMeEnabled)
2339 {
2340 MOS_ZeroMemory(&meOutputParams, sizeof(meOutputParams));
2341 meOutputParams.psMeMvBuffer = &m_s32XMeMvDataBuffer;
2342 meOutputParams.psMeBrcDistortionBuffer = nullptr;
2343 meOutputParams.psMeDistortionBuffer = nullptr;
2344 meOutputParams.b16xMeInUse = false;
2345 meOutputParams.b32xMeInUse = true;
2346
2347 CODECHAL_ENCODE_CHK_STATUS_RETURN(
2348 m_debugInterface->DumpBuffer(
2349 &meOutputParams.psMeMvBuffer->OsResource,
2350 CodechalDbgAttr::attrOutput,
2351 "MvData",
2352 meOutputParams.psMeMvBuffer->dwHeight *meOutputParams.psMeMvBuffer->dwPitch,
2353 CodecHal_PictureIsBottomField(m_currOriginalPic) ? MOS_ALIGN_CEIL((m_downscaledWidthInMb32x * 32), 64) * (m_downscaledFrameFieldHeightInMb32x * 4) : 0,
2354 CODECHAL_MEDIA_STATE_32X_ME));
2355 }
2356
2357 MOS_ZeroMemory(&meOutputParams, sizeof(meOutputParams));
2358 meOutputParams.pResVdenStreamInBuffer = &(m_resVdencStreamInBuffer[m_currRecycledBufIdx]);
2359 meOutputParams.psMeMvBuffer = &m_s4XMeMvDataBuffer;
2360 meOutputParams.psMeDistortionBuffer = &m_s4XMeDistortionBuffer;
2361 meOutputParams.b16xMeInUse = false;
2362 meOutputParams.bVdencStreamInInUse = true;
2363 if (m_vdencStreamInEnabled) {
2364 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
2365 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
2366 CodechalDbgAttr::attrOutput,
2367 "StreaminData",
2368 m_picWidthInMb * m_picHeightInMb * CODECHAL_CACHELINE_SIZE,
2369 0,
2370 CODECHAL_MEDIA_STATE_ME_VDENC_STREAMIN));
2371 }
2372 })
2373 #endif
2374
2375 return eStatus;
2376 }
2377
2378 MOS_STATUS CodechalVdencHevcStateG12::ReadSliceSize(PMOS_COMMAND_BUFFER cmdBuffer)
2379 {
2380 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2381
2382 CODECHAL_ENCODE_FUNCTION_ENTER;
2383
2384 // Use FrameStats buffer if in single pipe mode.
2385 if (m_numPipe == 1)
2386 {
2387 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::ReadSliceSize(cmdBuffer));
2388 return eStatus;
2389 }
2390
2391 // Report slice size to app only when dynamic scaling is enabled
2392 if (!m_hevcSeqParams->SliceSizeControl)
2393 {
2394 return eStatus;
2395 }
2396
2397 // In multi-tile multi-pipe mode, use PAK integration kernel output
2398 // PAK integration kernel accumulates frame statistics across tiles, which should be used to setup slice size report
2399 MOS_LOCK_PARAMS lockFlags;
2400 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
2401 lockFlags.WriteOnly = true;
2402
2403 uint32_t baseOffset = (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize + sizeof(uint32_t) * 2); // encodeStatus is offset by 2 DWs in the resource
2404 uint32_t sizeOfSliceSizesBuffer = MOS_ALIGN_CEIL(m_numLcu * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
2405
2406 if (IsFirstPipe())
2407 {
2408 if (IsFirstPass())
2409 {
2410 // Create/ Initialize slice report buffer once per frame, to be used across passes
2411 if (Mos_ResourceIsNull(&m_resSliceReport[m_encodeStatusBuf.wCurrIndex]))
2412 {
2413 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
2414 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
2415 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
2416 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
2417 allocParamsForBufferLinear.Format = Format_Buffer;
2418 allocParamsForBufferLinear.dwBytes = sizeOfSliceSizesBuffer;
2419
2420 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
2421 m_osInterface,
2422 &allocParamsForBufferLinear,
2423 &m_resSliceReport[m_encodeStatusBuf.wCurrIndex]),
2424 "Failed to create HEVC VDEnc Slice Report Buffer ");
2425 }
2426
2427 // Clear slice size structure to be sent in EncodeStatusReport buffer
2428 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, &m_resSliceReport[m_encodeStatusBuf.wCurrIndex], &lockFlags);
2429 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
2430 MOS_ZeroMemory(data, sizeOfSliceSizesBuffer);
2431 m_osInterface->pfnUnlockResource(m_osInterface, &m_resSliceReport[m_encodeStatusBuf.wCurrIndex]);
2432
2433 // Set slice size pointer in slice size structure
2434 MHW_MI_FLUSH_DW_PARAMS miFlushDwParams;
2435 MOS_ZeroMemory(&miFlushDwParams, sizeof(miFlushDwParams));
2436 miFlushDwParams.pOsResource = &m_encodeStatusBuf.resStatusBuffer;
2437 miFlushDwParams.dwResourceOffset = CODECHAL_OFFSETOF(EncodeStatusSliceReport, pSliceSize) + baseOffset + m_encodeStatusBuf.dwSliceReportOffset;
2438 miFlushDwParams.dwDataDW1 = (uint32_t)((uint64_t)&m_resSliceReport[m_encodeStatusBuf.wCurrIndex] & 0xFFFFFFFF);
2439 miFlushDwParams.dwDataDW2 = (uint32_t)(((uint64_t)&m_resSliceReport[m_encodeStatusBuf.wCurrIndex] & 0xFFFFFFFF00000000) >> 32);
2440 miFlushDwParams.bQWordEnable = 1;
2441 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(
2442 cmdBuffer,
2443 &miFlushDwParams));
2444 }
2445
2446 // Copy Slize size data buffer from PAK to be sent back to App
2447 CODECHAL_ENCODE_CHK_STATUS_RETURN(CopyDataBlock(cmdBuffer,
2448 &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource,
2449 m_hevcTileStatsOffset.uiHevcSliceStreamout,
2450 &m_resSliceReport[m_encodeStatusBuf.wCurrIndex],
2451 0,
2452 sizeOfSliceSizesBuffer));
2453
2454 MHW_MI_COPY_MEM_MEM_PARAMS miCpyMemMemParams;
2455 MOS_ZeroMemory(&miCpyMemMemParams, sizeof(MHW_MI_COPY_MEM_MEM_PARAMS));
2456 miCpyMemMemParams.presSrc = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Slice size overflow is in m_resFrameStatStreamOutBuffer DW0[16]
2457 miCpyMemMemParams.dwSrcOffset = m_hevcFrameStatsOffset.uiHevcPakStatistics;
2458 miCpyMemMemParams.presDst = &m_encodeStatusBuf.resStatusBuffer;
2459 miCpyMemMemParams.dwDstOffset = baseOffset + m_encodeStatusBuf.dwSliceReportOffset; // Slice size overflow is at DW0 EncodeStatusSliceReport
2460 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(cmdBuffer, &miCpyMemMemParams));
2461 }
2462
2463 return eStatus;
2464 }
2465
2466 MOS_STATUS CodechalVdencHevcStateG12::ExecutePictureLevel()
2467 {
2468 CODECHAL_ENCODE_FUNCTION_ENTER;
2469
2470 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2471
2472 int32_t currentPass = GetCurrentPass();
2473 int32_t currentPipe = GetCurrentPipe();
2474
2475 if (IsFirstPipe() && IsFirstPass())
2476 {
2477 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetTileData(m_tileParams[m_virtualEngineBbIndex]));
2478 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateTileStatistics());
2479 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRoundingValues());
2480 }
2481
2482 if (m_hevcPicParams->bUsedAsRef || m_brcEnabled)
2483 {
2484 if (m_currRefSync == nullptr)
2485 {
2486 m_currRefSync = &m_refSync[m_currMbCodeIdx];
2487 }
2488 }
2489 else
2490 {
2491 m_currRefSync = nullptr;
2492 }
2493
2494 if (m_lookaheadPass && (m_hevcSeqParams->MaxAdaptiveGopPicSize > 0))
2495 {
2496 bool forceIntra = m_intraInterval >= m_hevcSeqParams->MaxAdaptiveGopPicSize;
2497 if ((!IsFirstPass() || forceIntra) && (m_hevcPicParams->CodingType != I_TYPE))
2498 {
2499 m_vdencStreamInEnabled = true;
2500 }
2501
2502 if (!m_lookaheadAdaptiveI)
2503 {
2504 m_intraInterval = forceIntra ? 1 : m_intraInterval + 1;
2505 }
2506 }
2507
2508 m_firstTaskInPhase = m_singleTaskPhaseSupported ? IsFirstPass() : false;
2509 m_lastTaskInPhase = m_singleTaskPhaseSupported ? IsLastPass() : true;
2510
2511 // Per frame maximum HuC kernels is 5 - BRC Init, BRC Update, PAK Int, BRC Update, PAK Int
2512 m_hucCommandsSize = m_hwInterface->m_hucCommandBufferSize * 5;
2513
2514 PerfTagSetting perfTag;
2515 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE);
2516
2517 if (m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()) \
2518 {
2519 CODECHAL_ENCODE_ASSERTMESSAGE("ERROR - vdbox index exceed the maximum");
2520 eStatus = MOS_STATUS_INVALID_PARAMETER;
2521 return eStatus;
2522 }
2523
2524 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifyCommandBufferSize());
2525
2526 if (!m_singleTaskPhaseSupportedInPak)
2527 {
2528 // Command buffer or patch list size are too small and so we cannot submit multiple pass of PAKs together
2529 m_firstTaskInPhase = true;
2530 m_lastTaskInPhase = true;
2531 }
2532
2533 if (m_lookaheadPass)
2534 {
2535 if (m_swLaMode != nullptr)
2536 {
2537 m_lastTaskInPhase = true;
2538 }
2539 else
2540 {
2541 m_lastTaskInPhase = !m_singleTaskPhaseSupported;
2542 }
2543 }
2544 else if (m_swBrcMode != nullptr)
2545 {
2546 m_lastTaskInPhase = !IsFirstPass();
2547 }
2548
2549 // PAK pass type for each pass: VDEnc+PAK vs. PAK-only
2550 SetPakPassType();
2551
2552 bool pakOnlyMultipassEnable = false;
2553
2554 bool panicEnabled = (m_brcEnabled) && (m_panicEnable) && (IsLastPass()) && !m_pakOnlyPass;
2555
2556 uint32_t rollingILimit = (m_hevcPicParams->bEnableRollingIntraRefresh == ROLLING_I_ROW) ? MOS_ROUNDUP_DIVIDE(m_frameHeight, 32) : (m_hevcPicParams->bEnableRollingIntraRefresh == ROLLING_I_COLUMN) ? MOS_ROUNDUP_DIVIDE(m_frameWidth, 32) : 0;
2557
2558 m_refList[m_currReconstructedPic.FrameIdx]->rollingIntraRefreshedPosition =
2559 CodecHal_Clip3(0, rollingILimit, m_hevcPicParams->IntraInsertionLocation + m_hevcPicParams->IntraInsertionSize);
2560
2561 // For ACQP / BRC, update pic params rolling intra reference location here before cmd buffer is prepared.
2562 PCODEC_PICTURE l0RefFrameList = m_hevcSliceParams->RefPicList[LIST_0];
2563 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l0_active_minus1; refIdx++)
2564 {
2565 CODEC_PICTURE refPic = l0RefFrameList[refIdx];
2566
2567 if (!CodecHal_PictureIsInvalid(refPic) && m_picIdx[refPic.FrameIdx].bValid)
2568 {
2569 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
2570 m_hevcPicParams->RollingIntraReferenceLocation[refIdx] = m_refList[refPicIdx]->rollingIntraRefreshedPosition;
2571 }
2572 }
2573
2574 if (IsFirstPass())
2575 {
2576 MOS_COMMAND_BUFFER cmdBuffer;
2577 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2578 MHW_MI_MMIOREGISTERS mmioRegister;
2579 bool validMmio = m_hwInterface->GetMfxInterface()->ConvertToMiRegister(m_vdboxIndex, mmioRegister);
2580 if (validMmio)
2581 {
2582 HalOcaInterface::On1stLevelBBStart(
2583 cmdBuffer,
2584 *m_hwInterface->GetOsInterface()->pOsContext,
2585 m_hwInterface->GetOsInterface()->CurrentGpuContextHandle,
2586 *m_hwInterface->GetMiInterface(),
2587 mmioRegister);
2588 }
2589 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
2590 }
2591
2592 if (m_numPipe >= 2)
2593 {
2594 // Send Cmd Buffer Header for VE in last pipe only
2595 MOS_COMMAND_BUFFER cmdBuffer;
2596 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2597 bool requestFrameTracking = m_singleTaskPhaseSupported ? IsFirstPass() : IsLastPass();
2598 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
2599
2600 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
2601 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
2602 forceWakeupParams.bMFXPowerWellControl = true;
2603 forceWakeupParams.bMFXPowerWellControlMask = true;
2604 forceWakeupParams.bHEVCPowerWellControl = true;
2605 forceWakeupParams.bHEVCPowerWellControlMask = true;
2606 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
2607 &cmdBuffer,
2608 &forceWakeupParams));
2609
2610 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
2611 }
2612 else if (IsFirstPass())
2613 {
2614 // Send force wake command for VDBOX
2615 MOS_COMMAND_BUFFER cmdBuffer;
2616 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2617
2618 MHW_MI_FORCE_WAKEUP_PARAMS forceWakeupParams;
2619 MOS_ZeroMemory(&forceWakeupParams, sizeof(MHW_MI_FORCE_WAKEUP_PARAMS));
2620 forceWakeupParams.bMFXPowerWellControl = true;
2621 forceWakeupParams.bMFXPowerWellControlMask = true;
2622 forceWakeupParams.bHEVCPowerWellControl = true;
2623 forceWakeupParams.bHEVCPowerWellControlMask = true;
2624 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiForceWakeupCmd(
2625 &cmdBuffer,
2626 &forceWakeupParams));
2627 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
2628 }
2629
2630 if (m_numPipe >= 2 && IsFirstPass())
2631 {
2632 MOS_COMMAND_BUFFER cmdBuffer;
2633 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2634
2635 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddWatchdogTimerStopCmd(&cmdBuffer));
2636
2637 //HW Semaphore cmd to make sure all pipes start encode at the same time
2638 for (uint32_t i = 0; i < m_numPipe; i++)
2639 {
2640 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendMIAtomicCmd(
2641 &m_resPipeStartSemaMem[i].sResource,
2642 1,
2643 MHW_MI_ATOMIC_INC,
2644 &cmdBuffer));
2645 }
2646 auto pipeNum = GetCurrentPipe();
2647 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendHWWaitCommand(
2648 &m_resPipeStartSemaMem[pipeNum].sResource,
2649 &cmdBuffer,
2650 m_numPipe));
2651
2652 //clean HW semaphore memory
2653 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSemaphoreMem(
2654 &m_resPipeStartSemaMem[pipeNum].sResource,
2655 &cmdBuffer,
2656 0x0));
2657
2658 //Start Watchdog Timer
2659 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddWatchdogTimerStartCmd(&cmdBuffer));
2660
2661 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
2662 }
2663
2664 if (m_vdencHucUsed && IsFirstPipe())
2665 {
2666 // STF: HuC+VDEnc+PAK single BB, non-STF: HuC Init/HuC Update/(VDEnc+PAK) in separate BBs
2667 uint16_t callType = CODECHAL_ENCODE_PERFTAG_CALL_BRC_INIT_RESET;
2668 if (m_singleTaskPhaseSupported)
2669 {
2670 perfTag.CallType = IsFirstPass() ? CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE : CODECHAL_ENCODE_PERFTAG_CALL_PAK_ENGINE_SECOND_PASS;
2671 }
2672 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, callType);
2673
2674 m_resVdencBrcUpdateDmemBufferPtr[0] = (MOS_RESOURCE*)m_allocator->GetResource(m_standard, pakInfo);
2675
2676 // Invoke BRC init/reset FW
2677 if (m_brcInit || m_brcReset)
2678 {
2679 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcInitReset());
2680 }
2681
2682 if (!m_singleTaskPhaseSupported)
2683 {
2684 CODECHAL_ENCODE_SET_PERFTAG_INFO(perfTag, CODECHAL_ENCODE_PERFTAG_CALL_BRC_UPDATE);
2685 }
2686
2687 // Invoke BRC update FW
2688 // When tile replay is enabled, BRC update is also called at tile row level
2689 if (m_enableTileReplay)
2690 {
2691 m_FrameLevelBRCForTileRow = true;
2692 m_TileRowLevelBRC = false;
2693 }
2694 else
2695 {
2696 m_FrameLevelBRCForTileRow = false;
2697 m_TileRowLevelBRC = false;
2698 }
2699 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCBrcUpdate());
2700
2701 m_brcInit = m_brcReset = false;
2702 }
2703
2704 MOS_COMMAND_BUFFER cmdBuffer;
2705 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
2706
2707 if ((!m_singleTaskPhaseSupported || (m_firstTaskInPhase && !m_hevcVdencAcqpEnabled)) && (m_numPipe == 1))
2708 {
2709 // Send command buffer header at the beginning (OS dependent)
2710 // frame tracking tag is only added in the last command buffer header
2711 bool requestFrameTracking = m_singleTaskPhaseSupported ?
2712 m_firstTaskInPhase :
2713 ((m_lookaheadPass && (!m_swLaMode || (m_currPass < m_numPasses))) ? false : m_lastTaskInPhase);
2714 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
2715 }
2716
2717 // clean-up per VDBOX semaphore memory
2718 if (currentPipe < 0)
2719 {
2720 eStatus = MOS_STATUS_INVALID_PARAMETER;
2721 return eStatus;
2722 }
2723
2724 // Ensure the previous BRC Update is done, before executing PAK
2725 if (m_vdencHucUsed && (m_numPipe >= 2))
2726 {
2727 int32_t currentPass = GetCurrentPass() + 1;
2728 if (IsFirstPipe())
2729 {
2730 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSemaphoreMem(
2731 &m_resBrcPakSemaphoreMem.sResource,
2732 &cmdBuffer,
2733 currentPass));
2734 }
2735 else
2736 {
2737 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendHWWaitCommand(
2738 &m_resBrcPakSemaphoreMem.sResource,
2739 &cmdBuffer,
2740 currentPass));
2741
2742 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSemaphoreMem(
2743 &m_resBrcPakSemaphoreMem.sResource,
2744 &cmdBuffer,
2745 0x0));
2746 }
2747 }
2748
2749 if ((!IsFirstPass()) && m_vdencHuCConditional2ndPass)
2750 {
2751 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS miConditionalBatchBufferEndParams;
2752
2753 // Insert conditional batch buffer end
2754 MOS_ZeroMemory(
2755 &miConditionalBatchBufferEndParams,
2756 sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
2757
2758 // VDENC uses HuC FW generated semaphore for conditional 2nd pass
2759 miConditionalBatchBufferEndParams.presSemaphoreBuffer =
2760 &m_resPakMmioBuffer;
2761
2762 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
2763 &cmdBuffer,
2764 &miConditionalBatchBufferEndParams));
2765
2766 auto mmioRegisters = m_hcpInterface->GetMmioRegisters(m_vdboxIndex);
2767 CODECHAL_ENCODE_CHK_NULL_RETURN(mmioRegisters);
2768 uint32_t baseOffset = (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2; // encodeStatus is offset by 2 DWs in the resource
2769
2770 // Write back the HCP image control register for RC6 may clean it out
2771 MHW_MI_LOAD_REGISTER_MEM_PARAMS miLoadRegMemParams;
2772 MOS_ZeroMemory(&miLoadRegMemParams, sizeof(miLoadRegMemParams));
2773 miLoadRegMemParams.presStoreBuffer = &m_encodeStatusBuf.resStatusBuffer;
2774 miLoadRegMemParams.dwOffset = baseOffset + m_encodeStatusBuf.dwImageStatusCtrlOffset;
2775 miLoadRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
2776 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiLoadRegisterMemCmd(&cmdBuffer, &miLoadRegMemParams));
2777
2778 MHW_MI_STORE_REGISTER_MEM_PARAMS miStoreRegMemParams;
2779 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2780 miStoreRegMemParams.presStoreBuffer = &m_vdencBrcBuffers.resBrcPakStatisticBuffer[m_vdencBrcBuffers.uiCurrBrcPakStasIdxForWrite];
2781 miStoreRegMemParams.dwOffset = CODECHAL_OFFSETOF(CODECHAL_ENCODE_HEVC_PAK_STATS_BUFFER, HCP_IMAGE_STATUS_CONTROL_FOR_LAST_PASS);
2782 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
2783 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&cmdBuffer, &miStoreRegMemParams));
2784
2785 MOS_ZeroMemory(&miStoreRegMemParams, sizeof(miStoreRegMemParams));
2786 miStoreRegMemParams.presStoreBuffer = &m_encodeStatusBuf.resStatusBuffer;
2787 miStoreRegMemParams.dwOffset = baseOffset + m_encodeStatusBuf.dwImageStatusCtrlOfLastBRCPassOffset;
2788 miStoreRegMemParams.dwRegister = mmioRegisters->hcpEncImageStatusCtrlRegOffset;
2789 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&cmdBuffer, &miStoreRegMemParams));
2790 }
2791
2792 if (IsFirstPass() && m_osInterface->bTagResourceSync)
2793 {
2794 // This is a short term WA to solve the sync tag issue: the sync tag write for PAK is inserted at the end of 2nd pass PAK BB
2795 // which may be skipped in multi-pass PAK enabled case. The idea here is to insert the previous frame's tag at the beginning
2796 // 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
2797 // as long as Dec/VP/Enc won't depend on this PAK so soon.
2798
2799 PMOS_RESOURCE globalGpuContextSyncTagBuffer = nullptr;
2800
2801 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetGpuStatusBufferResource(
2802 m_osInterface,
2803 globalGpuContextSyncTagBuffer));
2804 CODECHAL_ENCODE_CHK_NULL_RETURN(globalGpuContextSyncTagBuffer);
2805
2806 MHW_MI_STORE_DATA_PARAMS params;
2807 params.pOsResource = globalGpuContextSyncTagBuffer;
2808 params.dwResourceOffset = m_osInterface->pfnGetGpuStatusTagOffset(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
2809 uint32_t value = m_osInterface->pfnGetGpuStatusTag(m_osInterface, m_osInterface->CurrentGpuContextOrdinal);
2810 params.dwValue = (value > 0) ? (value - 1) : 0;
2811 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &params));
2812 }
2813
2814 if (IsFirstPipe())
2815 {
2816 if (IsFirstPass())
2817 {
2818 // Check other dependent VDBOXs if they are ready
2819 // The inter frame sync method was changed, remove this first, to be tuned
2820 // CODECHAL_ENCODE_CHK_STATUS_RETURN(WaitForVDBOX(&cmdBuffer));
2821
2822 // clean-up HW semaphore memory
2823 if (m_currRefSync && !Mos_ResourceIsNull(&m_currRefSync->resSemaphoreMem.sResource))
2824 {
2825 // Ensure this semaphore is not used before. If yes, wait until it is done.
2826 // The inter frame sync method was changed, remove this first, to be tuned
2827 // CODECHAL_ENCODE_CHK_STATUS_RETURN(
2828 // SendHWWaitCommand(&pCurrRefSync->resSemaphoreMem.sResource, &cmdBuffer, 1));
2829
2830 MHW_MI_STORE_DATA_PARAMS storeDataParams;
2831 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
2832 storeDataParams.pOsResource = &m_currRefSync->resSemaphoreMem.sResource;
2833 storeDataParams.dwResourceOffset = 0;
2834 storeDataParams.dwValue = 0;
2835
2836 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
2837 &cmdBuffer,
2838 &storeDataParams));
2839 }
2840 }
2841
2842 if (!m_lookaheadPass || m_swLaMode)
2843 {
2844 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
2845 }
2846 }
2847
2848 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 pipeModeSelectParams = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(m_vdencInterface->CreateMhwVdboxPipeModeSelectParams());
2849 ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
2850
2851 auto release_func = [&]()
2852 {
2853 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
2854 pipeModeSelectParams = nullptr;
2855 };
2856
2857 SetHcpPipeModeSelectParams(*pipeModeSelectParams);
2858
2859 // HCP_PIPE_SELECT can not be generated by FW in BRC mode for GEN11+
2860 {
2861 MHW_VDBOX_VDENC_CONTROL_STATE_PARAMS vdencControlStateParams;
2862 MHW_MI_VD_CONTROL_STATE_PARAMS vdControlStateParams;
2863
2864 //set up VDENC_CONTROL_STATE command
2865 {
2866 MOS_ZeroMemory(&vdencControlStateParams, sizeof(MHW_VDBOX_VDENC_CONTROL_STATE_PARAMS));
2867 vdencControlStateParams.bVdencInitialization = true;
2868 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(
2869 static_cast<MhwVdboxVdencInterfaceG12X*>(m_vdencInterface)->AddVdencControlStateCmd(&cmdBuffer, &vdencControlStateParams), release_func);
2870 }
2871
2872 //set up VD_CONTROL_STATE command
2873 {
2874 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
2875 vdControlStateParams.initialization = true;
2876 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(
2877 static_cast<MhwMiInterfaceG12*>(m_miInterface)->AddMiVdControlStateCmd(&cmdBuffer, &vdControlStateParams), release_func);
2878 }
2879
2880 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams), release_func);
2881 }
2882
2883 MHW_VDBOX_SURFACE_PARAMS srcSurfaceParams;
2884 SetHcpSrcSurfaceParams(srcSurfaceParams);
2885 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpSurfaceCmd(&cmdBuffer, &srcSurfaceParams), release_func);
2886
2887 MHW_VDBOX_SURFACE_PARAMS reconSurfaceParams{};
2888 SetHcpReconSurfaceParams(reconSurfaceParams);
2889
2890 // Recon P010v MMC state set from RC for compression write
2891 MOS_MEMCOMP_STATE tempMmcState = reconSurfaceParams.mmcState;
2892 if (m_reconSurface.Format == Format_P010 && MmcEnable(tempMmcState))
2893 {
2894 reconSurfaceParams.mmcState = MOS_MEMCOMP_RC;
2895 }
2896
2897 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpSurfaceCmd(&cmdBuffer, &reconSurfaceParams), release_func); //this is for Recon surf cmd set
2898
2899 MHW_VDBOX_SURFACE_PARAMS refSurfaceParams{};
2900 SetHcpRefSurfaceParams(refSurfaceParams); //it set MMC state and MMCFormat
2901
2902 // Add the surface state for reference picture, GEN12 HW change
2903 *m_pipeBufAddrParams = {};
2904 SetHcpPipeBufAddrParams(*m_pipeBufAddrParams);
2905
2906 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
2907 {
2908 refSurfaceParams.mmcSkipMask = (1 << m_slotForRecNotFiltered); //add this for ref
2909 }
2910
2911 if (m_mmcState->IsMmcEnabled())
2912 {
2913
2914 refSurfaceParams.refsMmcEnable = 0;
2915 refSurfaceParams.refsMmcType = 0;
2916 refSurfaceParams.dwCompressionFormat = 0;
2917
2918 //add for B frame support
2919 if (m_pictureCodingType != I_TYPE)
2920 {
2921 for (uint8_t i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
2922 {
2923 if (i < CODEC_MAX_NUM_REF_FRAME_HEVC &&
2924 m_picIdx[i].bValid && m_currUsedRefPic[i])
2925 {
2926 uint8_t idx = m_picIdx[i].ucPicIdx;
2927 uint8_t frameStoreId = m_refIdxMapping[i];
2928
2929 MOS_MEMCOMP_STATE mmcState = MOS_MEMCOMP_DISABLED;
2930 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcState(const_cast<PMOS_SURFACE>(&m_refList[idx]->sRefReconBuffer), &mmcState));
2931 refSurfaceParams.refsMmcEnable |= (mmcState == MOS_MEMCOMP_RC || mmcState == MOS_MEMCOMP_MC) ? (1 << frameStoreId) : 0;
2932 refSurfaceParams.refsMmcType |= (mmcState == MOS_MEMCOMP_RC) ? (1 << frameStoreId) : 0;
2933 if (mmcState == MOS_MEMCOMP_RC || mmcState == MOS_MEMCOMP_MC)
2934 {
2935 ENCODE_CHK_STATUS_RETURN(m_mmcState->GetSurfaceMmcFormat(const_cast<PMOS_SURFACE>(&m_refList[idx]->sRefReconBuffer), &refSurfaceParams.dwCompressionFormat));
2936 }
2937 }
2938 }
2939 }
2940 }
2941
2942 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpSurfaceCmd(&cmdBuffer, &refSurfaceParams), release_func);
2943
2944 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(AddHcpPipeBufAddrCmd(&cmdBuffer), release_func);
2945
2946 MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS indObjBaseAddrParams;
2947 SetHcpIndObjBaseAddrParams(indObjBaseAddrParams);
2948 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpIndObjBaseAddrCmd(&cmdBuffer, &indObjBaseAddrParams), release_func);
2949
2950 MHW_VDBOX_QM_PARAMS fqmParams, qmParams;
2951 SetHcpQmStateParams(fqmParams, qmParams);
2952 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpFqmStateCmd(&cmdBuffer, &fqmParams), release_func);
2953 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpQmStateCmd(&cmdBuffer, &qmParams), release_func);
2954
2955 SetVdencPipeModeSelectParams(*pipeModeSelectParams);
2956 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencPipeModeSelectCmd(&cmdBuffer, pipeModeSelectParams), release_func);
2957
2958 MHW_VDBOX_SURFACE_PARAMS dsSurfaceParams[2] = {};
2959 SetVdencSurfaceStateParams(srcSurfaceParams, refSurfaceParams, dsSurfaceParams[0], dsSurfaceParams[1]);
2960 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencSrcSurfaceStateCmd(&cmdBuffer, &srcSurfaceParams), release_func);
2961 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencRefSurfaceStateCmd(&cmdBuffer, &refSurfaceParams), release_func); // this is for Ref, no mmc related setting
2962 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencDsRefSurfaceStateCmd(&cmdBuffer, &dsSurfaceParams[0], 2), release_func);
2963
2964 SetVdencPipeBufAddrParams(*m_pipeBufAddrParams);
2965 m_pipeBufAddrParams->pRawSurfParam = &srcSurfaceParams;
2966 m_pipeBufAddrParams->pDecodedReconParam = &reconSurfaceParams;
2967
2968 m_mmcState->SetPipeBufAddr(m_pipeBufAddrParams);
2969
2970 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencPipeBufAddrCmd(&cmdBuffer, m_pipeBufAddrParams), release_func);
2971
2972 MHW_VDBOX_HEVC_PIC_STATE_G12 picStateParams;
2973 SetHcpPicStateParams(picStateParams);
2974
2975 if (m_vdencHucUsed && (!m_hevcPicParams->tiles_enabled_flag))
2976 {
2977 // 2nd level batch buffer
2978 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset = m_hwInterface->m_vdencBatchBuffer1stGroupSize;
2979 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource, 0, true, 0);
2980 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx]), release_func);
2981
2982 // save offset for next 2nd level batch buffer usage
2983 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset += m_hwInterface->m_vdencBatchBuffer2ndGroupSize;
2984 }
2985 // When tile is enabled, below commands are needed for each tile instead of each picture
2986 else if (!m_hevcPicParams->tiles_enabled_flag)
2987 {
2988 SetAddCommands(CODECHAL_CMD1, &cmdBuffer, true, m_roundInterValue, m_roundIntraValue, m_lowDelay);
2989
2990 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpPicStateCmd(&cmdBuffer, &picStateParams), release_func);
2991
2992 SetAddCommands(CODECHAL_CMD2, &cmdBuffer, true, m_roundInterValue, m_roundIntraValue, m_lowDelay, m_refIdxMapping, m_slotForRecNotFiltered);
2993 }
2994
2995 // Send HEVC_VP9_RDOQ_STATE command
2996 if (m_hevcRdoqEnabled && !m_hevcPicParams->tiles_enabled_flag)
2997 {
2998 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpHevcVp9RdoqStateCmd(&cmdBuffer, &picStateParams), release_func);
2999 }
3000
3001 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(ReturnCommandBuffer(&cmdBuffer), release_func);
3002
3003 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
3004
3005 return eStatus;
3006 }
3007
3008 MOS_STATUS CodechalVdencHevcStateG12::ExecuteSliceLevel()
3009 {
3010 CODECHAL_ENCODE_FUNCTION_ENTER;
3011
3012 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3013
3014 if (!m_hevcPicParams->tiles_enabled_flag)
3015 {
3016 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::ExecuteSliceLevel());
3017
3018 if (m_lookaheadPass)
3019 {
3020 CODECHAL_ENCODE_CHK_STATUS_RETURN(AnalyzeLookaheadStats());
3021
3022 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
3023 &m_vdencLaStatsBuffer,
3024 CodechalDbgAttr::attrVdencOutput,
3025 "_LookaheadStats",
3026 m_brcLooaheadStatsBufferSize,
3027 0,
3028 CODECHAL_NUM_MEDIA_STATES)));
3029 }
3030 }
3031 else
3032 {
3033 if (m_vdencHucUsed && m_enableTileReplay)
3034 {
3035 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncWithTileRowLevelBRC());
3036 }
3037 else
3038 {
3039 CODECHAL_ENCODE_CHK_STATUS_RETURN(EncTileLevel());
3040 }
3041 }
3042
3043 return eStatus;
3044 }
3045
3046 MOS_STATUS CodechalVdencHevcStateG12::EncTileLevel()
3047 {
3048 CODECHAL_ENCODE_FUNCTION_ENTER;
3049
3050 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3051
3052 int32_t currentPipe = GetCurrentPipe();
3053 int32_t currentPass = GetCurrentPass();
3054
3055 if (currentPipe < 0 || currentPass < 0)
3056 {
3057 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid pipe number or pass number");
3058 return MOS_STATUS_INVALID_PARAMETER;
3059 }
3060
3061 // Currently this implementation is only for CQP, single pass
3062 // Allocate more tile batch when try multiple passes
3063 if (IsFirstPass() && IsFirstPipe() && (!m_osInterface->bUsesPatchList))
3064 {
3065 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateTileLevelBatch());
3066 }
3067
3068 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 pipeModeSelectParams = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(m_vdencInterface->CreateMhwVdboxPipeModeSelectParams());
3069 ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
3070
3071 auto release_func = [&]()
3072 {
3073 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
3074 pipeModeSelectParams = nullptr;
3075 };
3076
3077 SetHcpPipeModeSelectParams(*pipeModeSelectParams);
3078 SetVdencPipeModeSelectParams(*pipeModeSelectParams);
3079
3080 MHW_VDBOX_HEVC_SLICE_STATE_G12 sliceState;
3081 SetHcpSliceStateCommonParams(sliceState);
3082
3083 MOS_COMMAND_BUFFER cmdBuffer;
3084 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(GetCommandBuffer(&cmdBuffer), release_func);
3085
3086 MHW_MI_VD_CONTROL_STATE_PARAMS vdControlStateParams;
3087 uint32_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
3088 uint32_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
3089 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
3090
3091 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipelineFlushParams;
3092
3093 // Construct The third level batch buffer
3094 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(ConstructTLB(&m_thirdLevelBatchBuffer), release_func);
3095
3096 for (uint32_t tileRow = 0; tileRow < numTileRows; tileRow++)
3097 {
3098 for (uint32_t tileCol = 0; tileCol < numTileColumns; tileCol++)
3099 {
3100 PCODEC_ENCODER_SLCDATA slcData = m_slcData;
3101 uint32_t slcCount, idx, sliceNumInTile = 0;
3102
3103 idx = tileRow * numTileColumns + tileCol;
3104
3105 if ((m_numPipe > 1) && (tileCol != currentPipe))
3106 {
3107 continue;
3108 }
3109
3110 MOS_COMMAND_BUFFER tileBatchBuf;
3111 PMOS_COMMAND_BUFFER tempCmdBuf = &cmdBuffer;
3112 uint8_t *data = nullptr;
3113
3114 // Move tile level commands to first level command buffer when use patch list.
3115 if (!m_osInterface->bUsesPatchList)
3116 {
3117 MOS_LOCK_PARAMS lockFlags;
3118 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
3119 lockFlags.WriteOnly = true;
3120
3121 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, &(m_tileLevelBatchBuffer[currentPass][idx].OsResource), &lockFlags);
3122 CODECHAL_ENCODE_CHK_NULL_WITH_DESTROY_RETURN(data, release_func);
3123
3124 MOS_ZeroMemory(&tileBatchBuf, sizeof(tileBatchBuf));
3125 tileBatchBuf.pCmdBase = tileBatchBuf.pCmdPtr = (uint32_t *)data;
3126 tileBatchBuf.iRemaining = m_tileLevelBatchSize;
3127
3128 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_tileLevelBatchBuffer[m_tileRowPass][idx].OsResource, 0, true, 0);
3129 // Add batch buffer start for tile
3130 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_tileLevelBatchBuffer[currentPass][idx]), release_func);
3131
3132 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->AddProlog(m_osInterface, &cmdBuffer), release_func);
3133
3134 if (m_osInterface->osCpInterface->IsCpEnabled() && m_hwInterface->GetCpInterface()->IsHwCounterIncrement(m_osInterface) && m_enableTileReplay)
3135 {
3136 CODECHAL_ENCODE_CHK_NULL_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface(), release_func);
3137
3138 // Lazy allocation
3139 if (Mos_ResourceIsNull(&m_resHwCountTileReplay))
3140 {
3141 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
3142 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
3143 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
3144 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
3145 allocParamsForBufferLinear.Format = Format_Buffer;
3146
3147 uint32_t maxTileRow = MOS_ROUNDUP_DIVIDE(m_frameHeight, CODECHAL_HEVC_MIN_TILE_SIZE);
3148 uint32_t maxTileColumn = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE);
3149
3150 allocParamsForBufferLinear.dwBytes = maxTileRow*maxTileColumn*(sizeof(HwCounter));
3151 allocParamsForBufferLinear.pBufName = "HWCounter";
3152 allocParamsForBufferLinear.bIsPersistent = true;
3153 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_osInterface->pfnAllocateResource(
3154 m_osInterface,
3155 &allocParamsForBufferLinear,
3156 &m_resHwCountTileReplay),
3157 release_func);
3158 allocParamsForBufferLinear.bIsPersistent = false;
3159 }
3160
3161 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->ReadEncodeCounterFromHW(
3162 m_osInterface,
3163 &tileBatchBuf,
3164 &m_resHwCountTileReplay,
3165 (uint16_t)idx),
3166 release_func);
3167 }
3168
3169 tempCmdBuf = &tileBatchBuf;
3170 }
3171
3172 // Construct the tile batch
3173 // To be moved to one sub function later
3174 // HCP Lock for multiple pipe mode
3175 if (m_numPipe > 1)
3176 {
3177 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3178 vdControlStateParams.scalableModePipeLock = true;
3179 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(tempCmdBuf, &vdControlStateParams), release_func);
3180 }
3181 // VDENC_PIPE_MODE_SELECT
3182 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencPipeModeSelectCmd(tempCmdBuf, pipeModeSelectParams), release_func);
3183 // HCP_PIPE_MODE_SELECT
3184 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(tempCmdBuf, pipeModeSelectParams), release_func);
3185
3186 // 3rd level batch buffer
3187 if (m_hevcVdencAcqpEnabled || m_brcEnabled)
3188 {
3189 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource, 0, true, 0);
3190 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset = m_hwInterface->m_vdencBatchBuffer1stGroupSize;
3191 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(tempCmdBuf, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx]), release_func);
3192 if (m_hevcRdoqEnabled)
3193 {
3194 MHW_VDBOX_HEVC_PIC_STATE_G12 picStateParams;
3195 SetHcpPicStateParams(picStateParams);
3196 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpHevcVp9RdoqStateCmd(tempCmdBuf, &picStateParams), release_func);
3197 }
3198 }
3199 else
3200 {
3201 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_thirdLevelBatchBuffer.OsResource, 0, true, 0);
3202 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(tempCmdBuf, &m_thirdLevelBatchBuffer), release_func);
3203 }
3204
3205 // HCP_TILE_CODING commmand
3206 // Set Tile replay related parameters
3207 tileParams[idx].IsFirstPass = IsFirstPass();
3208 tileParams[idx].IsLastPass = IsLastPass();
3209 tileParams[idx].bTileReplayEnable = m_enableTileReplay;
3210 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwVdboxHcpInterfaceG12 *>(m_hcpInterface)->AddHcpTileCodingCmd(tempCmdBuf, &tileParams[idx]), release_func);
3211
3212 for (slcCount = 0; slcCount < m_numSlices; slcCount++)
3213 {
3214 bool lastSliceInTile = false, sliceInTile = false;
3215
3216 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(IsSliceInTile(slcCount,
3217 &tileParams[idx],
3218 &sliceInTile,
3219 &lastSliceInTile),
3220 release_func);
3221
3222 if (!sliceInTile)
3223 {
3224 continue;
3225 }
3226
3227 if (m_hevcVdencAcqpEnabled || m_brcEnabled)
3228 {
3229 // save offset for next 2nd level batch buffer usage
3230 // This is because we don't know how many times HCP_WEIGHTOFFSET_STATE & HCP_PAK_INSERT_OBJECT will be inserted for each slice
3231 // dwVdencBatchBufferPerSliceConstSize: constant size for each slice
3232 // m_vdencBatchBufferPerSliceVarSize: variable size for each slice
3233
3234 // starting location for executing slice level cmds
3235 // To do: Improvize to only add current slice wSlcCount
3236 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset = m_hwInterface->m_vdencBatchBuffer1stGroupSize + m_hwInterface->m_vdencBatchBuffer2ndGroupSize;
3237
3238 for (uint32_t j = 0; j < slcCount; j++)
3239 {
3240 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset
3241 += (m_hwInterface->m_vdencBatchBufferPerSliceConstSize + m_vdencBatchBufferPerSliceVarSize[j]);
3242 }
3243
3244 }
3245
3246 SetHcpSliceStateParams(sliceState, slcData, (uint16_t)slcCount, tileParams, lastSliceInTile, idx);
3247
3248 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SendHwSliceEncodeCommand(tempCmdBuf, &sliceState), release_func);
3249
3250 // Send VD_PIPELINE_FLUSH command for each slice
3251 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3252 vdPipelineFlushParams.Flags.bWaitDoneMFX = 1;
3253 vdPipelineFlushParams.Flags.bWaitDoneVDENC = 1;
3254 vdPipelineFlushParams.Flags.bFlushVDENC = 1;
3255 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3256 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3257 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(tempCmdBuf, &vdPipelineFlushParams), release_func);
3258
3259 sliceNumInTile++;
3260 } // end of slice
3261
3262 if (0 == sliceNumInTile)
3263 {
3264 // One tile must have at least one slice
3265 CODECHAL_ENCODE_ASSERT(false);
3266 eStatus = MOS_STATUS_INVALID_PARAMETER;
3267 break;
3268 }
3269
3270 if (sliceNumInTile > 1 && (numTileColumns > 1 || numTileRows > 1))
3271 {
3272 CODECHAL_ENCODE_ASSERTMESSAGE("Multi-slices in a tile is not supported!");
3273 release_func();
3274 return MOS_STATUS_INVALID_PARAMETER;
3275 }
3276
3277 //HCP unLock for multiple pipe mode
3278 if (m_numPipe > 1)
3279 {
3280 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3281 vdControlStateParams.scalableModePipeUnlock = true;
3282 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(tempCmdBuf, &vdControlStateParams), release_func);
3283 }
3284
3285 // Send VD_PIPELINE_FLUSH command
3286 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3287 vdPipelineFlushParams.Flags.bWaitDoneHEVC = 1;
3288 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3289 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3290 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(tempCmdBuf, &vdPipelineFlushParams), release_func);
3291
3292 // Send MI_FLUSH command
3293 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3294 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3295 flushDwParams.bVideoPipelineCacheInvalidate = true;
3296 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiFlushDwCmd(tempCmdBuf, &flushDwParams), release_func);
3297
3298 // Update head pointer for capture mode
3299 if (m_CaptureModeEnable && IsLastPipe())
3300 {
3301 MHW_MI_LOAD_REGISTER_IMM_PARAMS registerImmParams;
3302 MOS_ZeroMemory(&registerImmParams, sizeof(registerImmParams));
3303 registerImmParams.dwData = 1;
3304 registerImmParams.dwRegister = m_VdboxVDENCRegBase[currentPipe] + 0x90;
3305 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(tempCmdBuf, &registerImmParams), release_func);
3306 }
3307
3308 if (!m_osInterface->bUsesPatchList)
3309 {
3310 // Add batch buffer end at the end of each tile batch, 2nd level batch buffer
3311 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferEnd(tempCmdBuf, nullptr), release_func);
3312
3313 std::string pakPassName = "PAK_PASS[" + std::to_string(GetCurrentPass()) + "]_PIPE[" + std::to_string(GetCurrentPipe()) + "]_TILELEVEL";
3314 CODECHAL_DEBUG_TOOL(
3315 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_debugInterface->DumpCmdBuffer(
3316 tempCmdBuf,
3317 CODECHAL_NUM_MEDIA_STATES,
3318 pakPassName.data()),
3319 release_func);)
3320
3321 if (data)
3322 {
3323 m_osInterface->pfnUnlockResource(m_osInterface, &(m_tileLevelBatchBuffer[currentPass][idx].OsResource));
3324 }
3325 }
3326
3327 } // end of row tile
3328 } // end of column tile
3329
3330 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
3331
3332 // Insert end of sequence/stream if set
3333 // To be moved to slice level?
3334 if ((m_lastPicInStream || m_lastPicInSeq) && IsLastPipe())
3335 {
3336 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
3337 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
3338 pakInsertObjectParams.bLastPicInSeq = m_lastPicInSeq;
3339 pakInsertObjectParams.bLastPicInStream = m_lastPicInStream;
3340 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(&cmdBuffer, &pakInsertObjectParams));
3341 }
3342
3343 // Send VD_CONTROL_STATE (Memory Implict Flush)
3344 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3345 vdControlStateParams.memoryImplicitFlush = true;
3346 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3347 static_cast<MhwMiInterfaceG12*>(m_miInterface)->AddMiVdControlStateCmd(&cmdBuffer, &vdControlStateParams));
3348
3349
3350 // Send VD_PIPELINE_FLUSH command
3351 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3352 vdPipelineFlushParams.Flags.bWaitDoneHEVC = 1;
3353 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3354 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3355 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipelineFlushParams));
3356
3357 // Send MI_FLUSH command
3358 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3359 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3360 flushDwParams.bVideoPipelineCacheInvalidate = true;
3361 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3362
3363 // Set the HW semaphore to indicate current pipe done
3364 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3365 flushDwParams.bVideoPipelineCacheInvalidate = true;
3366 if (!Mos_ResourceIsNull(&m_resVdBoxSemaphoreMem[currentPipe].sResource))
3367 {
3368 flushDwParams.pOsResource = &m_resVdBoxSemaphoreMem[currentPipe].sResource;
3369 flushDwParams.dwDataDW1 = currentPass + 1;
3370 }
3371 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3372
3373 if (IsFirstPipe())
3374 {
3375 // first pipe needs to ensure all other pipes are ready
3376 for (uint32_t i = 0; i < m_numPipe; i++)
3377 {
3378 if (!Mos_ResourceIsNull(&m_resVdBoxSemaphoreMem[i].sResource))
3379 {
3380 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3381 SendHWWaitCommand(&m_resVdBoxSemaphoreMem[i].sResource,
3382 &cmdBuffer,
3383 currentPass + 1));
3384 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3385 SetSemaphoreMem(&m_resVdBoxSemaphoreMem[i].sResource,
3386 &cmdBuffer,
3387 0x0));
3388 }
3389 }
3390
3391 // Whenever ACQP/ BRC is enabled with tiling, PAK Integration kernel is needed.
3392 // ACQP/ BRC need PAK integration kernel to aggregate statistics
3393 if (m_vdencHucUsed)
3394 {
3395 CODECHAL_ENCODE_CHK_STATUS_RETURN(HucPakIntegrate(&cmdBuffer));
3396 }
3397
3398 // Use HW stitch commands only in the scalable mode
3399 // For single pipe with tile replay, stitch also needed
3400 if (m_enableTileStitchByHW)
3401 {
3402 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_CQP && !m_hevcVdencAcqpEnabled)
3403 {
3404 CODECHAL_ENCODE_CHK_STATUS_RETURN(HucPakIntegrateStitch(&cmdBuffer));
3405 }
3406 // 2nd level BB buffer for stitching cmd
3407 // current location to add cmds in 2nd level batch buffer
3408 m_HucStitchCmdBatchBuffer.iCurrent = 0;
3409 // reset starting location (offset) executing 2nd level batch buffer for each frame & each pass
3410 m_HucStitchCmdBatchBuffer.dwOffset = 0;
3411 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_HucStitchCmdBatchBuffer.OsResource, 0, true, 0);
3412 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_HucStitchCmdBatchBuffer));
3413 // This wait cmd is needed to make sure copy command is done as suggested by HW folk in encode cases
3414 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMfxWaitCmd(&cmdBuffer, nullptr, m_osInterface->osCpInterface->IsCpEnabled() ? true : false));
3415 }
3416
3417 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadSseStatistics(&cmdBuffer));
3418
3419 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadSliceSize(&cmdBuffer));
3420
3421 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
3422
3423 if (m_numPipe <= 1) // single pipe mode can read the info from MMIO register. Otherwise, we have to use the tile size statistic buffer
3424 {
3425 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadHcpStatus(&cmdBuffer));
3426
3427 // BRC PAK statistics different for each pass
3428 if (m_brcEnabled)
3429 {
3430 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadBrcPakStats(&cmdBuffer));
3431 }
3432 }
3433
3434 MHW_MI_STORE_DATA_PARAMS storeDataParams;
3435 // Signal HW semaphore for the reference frame dependency (i.e., current coding frame waits for the reference frame being ready)
3436 if (m_currRefSync && !Mos_ResourceIsNull(&m_currRefSync->resSemaphoreMem.sResource))
3437 {
3438 // the reference frame semaphore must be set in each pass because of the conditional BRC batch buffer. Some BRC passes could be skipped.
3439 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
3440 storeDataParams.pOsResource = &m_currRefSync->resSemaphoreMem.sResource;
3441 storeDataParams.dwResourceOffset = 0;
3442 storeDataParams.dwValue = 1;
3443
3444 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiStoreDataImmCmd(
3445 &cmdBuffer,
3446 &storeDataParams));
3447 }
3448 }
3449
3450 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3451 {
3452 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
3453 }
3454
3455 std::string pakPassName = "PAK_PASS[" + std::to_string(GetCurrentPass()) + "]_PIPE[" + std::to_string(GetCurrentPipe()) + "]";
3456 CODECHAL_DEBUG_TOOL(
3457 CODECHAL_ENCODE_CHK_STATUS_RETURN( m_debugInterface->DumpCmdBuffer(
3458 &cmdBuffer,
3459 CODECHAL_NUM_MEDIA_STATES,
3460 pakPassName.data()));)
3461
3462 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
3463
3464 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3465 {
3466 bool nullRendering = m_videoContextUsesNullHw;
3467
3468 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, nullRendering));
3469
3470 CODECHAL_DEBUG_TOOL(
3471 CODECHAL_ENCODE_CHK_STATUS_RETURN(DumpHucDebugOutputBuffers());
3472 if (m_mmcState)
3473 {
3474 m_mmcState->UpdateUserFeatureKey(&m_reconSurface);
3475 }
3476 )
3477
3478 if (IsFirstPipe() &&
3479 IsLastPass() &&
3480 m_signalEnc &&
3481 m_currRefSync &&
3482 !Mos_ResourceIsNull(&m_resSyncObjectVideoContextInUse))
3483 {
3484 // signal semaphore
3485 MOS_SYNC_PARAMS syncParams;
3486 syncParams = g_cInitSyncParams;
3487 syncParams.GpuContext = m_videoContext;
3488 syncParams.presSyncResource = &m_currRefSync->resSyncObject;
3489
3490 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
3491 m_currRefSync->uiSemaphoreObjCount++;
3492 m_currRefSync->bInUsed = true;
3493 }
3494 }
3495
3496 // Reset parameters for next PAK execution
3497 if (IsLastPipe() &&
3498 IsLastPass())
3499 {
3500 if (!m_singleTaskPhaseSupported)
3501 {
3502 m_osInterface->pfnResetPerfBufferID(m_osInterface);
3503 }
3504
3505 m_currPakSliceIdx = (m_currPakSliceIdx + 1) % CODECHAL_HEVC_NUM_PAK_SLICE_BATCH_BUFFERS;
3506
3507 m_newPpsHeader = 0;
3508 m_newSeqHeader = 0;
3509 m_frameNum++;
3510 }
3511
3512 return eStatus;
3513 }
3514
3515 MOS_STATUS CodechalVdencHevcStateG12::EncWithTileRowLevelBRC()
3516 {
3517 CODECHAL_ENCODE_FUNCTION_ENTER;
3518
3519 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
3520
3521 int32_t currentPipe = GetCurrentPipe();
3522 int32_t currentPass = GetCurrentPass();
3523
3524 if (currentPipe < 0 || currentPass < 0)
3525 {
3526 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid pipe number or pass number");
3527 return MOS_STATUS_INVALID_PARAMETER;
3528 }
3529
3530 // Revisit the buffer reuse for multiple frames later
3531 if (IsFirstPass() && IsFirstPipe())
3532 {
3533 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateTileLevelBatch());
3534 CODECHAL_ENCODE_CHK_STATUS_RETURN(AllocateTileRowLevelBRCBatch());
3535 }
3536
3537 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 pipeModeSelectParams = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(m_vdencInterface->CreateMhwVdboxPipeModeSelectParams());
3538 ENCODE_CHK_NULL_RETURN(pipeModeSelectParams);
3539
3540 auto release_func = [&]()
3541 {
3542 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
3543 pipeModeSelectParams = nullptr;
3544 };
3545
3546 SetHcpPipeModeSelectParams(*pipeModeSelectParams);
3547 SetVdencPipeModeSelectParams(*pipeModeSelectParams);
3548
3549 MHW_VDBOX_HEVC_SLICE_STATE_G12 sliceState;
3550 SetHcpSliceStateCommonParams(sliceState);
3551
3552 MOS_COMMAND_BUFFER cmdBuffer;
3553 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(GetCommandBuffer(&cmdBuffer), release_func);
3554
3555 MHW_MI_VD_CONTROL_STATE_PARAMS vdControlStateParams;
3556 uint32_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
3557 uint32_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
3558
3559 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipelineFlushParams;
3560 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
3561
3562 m_FrameLevelBRCForTileRow = false;
3563 m_TileRowLevelBRC = true;
3564
3565 for (uint32_t tileRow = 0; tileRow < numTileRows; tileRow++)
3566 {
3567 for (m_tileRowPass = 0; m_tileRowPass < m_NumPassesForTileReplay; m_tileRowPass++)
3568 {
3569 for (uint32_t tileCol = 0; tileCol < numTileColumns; tileCol++)
3570 {
3571 PCODEC_ENCODER_SLCDATA slcData = m_slcData;
3572 uint32_t slcCount, idx, sliceNumInTile = 0;
3573
3574 idx = tileRow * numTileColumns + tileCol;
3575
3576 if ((m_numPipe > 1) && (tileCol != currentPipe))
3577 {
3578 continue;
3579 }
3580
3581 MOS_LOCK_PARAMS lockFlags;
3582 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
3583 lockFlags.WriteOnly = true;
3584
3585 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, &(m_tileLevelBatchBuffer[m_tileRowPass][idx].OsResource), &lockFlags);
3586 CODECHAL_ENCODE_CHK_NULL_WITH_DESTROY_RETURN(data, release_func);
3587
3588 MOS_COMMAND_BUFFER tileBatchBuf;
3589 MOS_ZeroMemory(&tileBatchBuf, sizeof(tileBatchBuf));
3590 tileBatchBuf.pCmdBase = tileBatchBuf.pCmdPtr = (uint32_t *)data;
3591 tileBatchBuf.iRemaining = m_tileLevelBatchSize;
3592
3593 // Add batch buffer start for tile
3594 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_tileLevelBatchBuffer[m_tileRowPass][idx].OsResource, 0, true, 0);
3595 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_tileLevelBatchBuffer[m_tileRowPass][idx]), release_func);
3596
3597 if (m_numPipe > 1)
3598 {
3599 //wait for last tile row BRC update completion
3600 if ((!IsFirstPipe()) && (!IsFirstPassForTileReplay()))
3601 {
3602 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SendHWWaitCommand(&m_resTileRowBRCsyncSemaphore, &tileBatchBuf, 0xFF), release_func);
3603 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SetSemaphoreMem(&m_resTileRowBRCsyncSemaphore, &tileBatchBuf, 0x0), release_func);
3604 }
3605 }
3606
3607 // Add conditional batch buffer end before tile row level second pass
3608 // To unify the single pipe and multiple pipe cases, add this for each tile
3609
3610 // To add the sync logic here to make sure the previous tile row BRC update is done
3611
3612 if (!IsFirstPassForTileReplay())
3613 {
3614 MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS miEnhancedConditionalBatchBufferEndParams;
3615
3616 MOS_ZeroMemory(
3617 &miEnhancedConditionalBatchBufferEndParams,
3618 sizeof(MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
3619
3620 // VDENC uses HuC FW generated semaphore for conditional 2nd pass
3621 miEnhancedConditionalBatchBufferEndParams.presSemaphoreBuffer =
3622 &m_resPakMmioBuffer;
3623
3624 miEnhancedConditionalBatchBufferEndParams.dwParamsType = MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS::ENHANCED_PARAMS;
3625 miEnhancedConditionalBatchBufferEndParams.enableEndCurrentBatchBuffLevel = true;
3626
3627 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
3628 &tileBatchBuf,
3629 (PMHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS)(&miEnhancedConditionalBatchBufferEndParams)),
3630 release_func);
3631 }
3632
3633 // counter should be read after conditional batch buffer
3634 // in case second pass is not executed then counter should not be read
3635 if (m_osInterface->osCpInterface->IsCpEnabled() && m_hwInterface->GetCpInterface()->IsHwCounterIncrement(m_osInterface) && m_enableTileReplay)
3636 {
3637 CODECHAL_ENCODE_CHK_NULL_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface(), release_func);
3638
3639 // Lazy allocation
3640 if (Mos_ResourceIsNull(&m_resHwCountTileReplay))
3641 {
3642 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
3643 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
3644 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
3645 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
3646 allocParamsForBufferLinear.Format = Format_Buffer;
3647
3648 uint32_t maxTileRow = MOS_ROUNDUP_DIVIDE(m_frameHeight, CODECHAL_HEVC_MIN_TILE_SIZE);
3649 uint32_t maxTileColumn = MOS_ROUNDUP_DIVIDE(m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE);
3650
3651 allocParamsForBufferLinear.dwBytes = maxTileRow*maxTileColumn*(sizeof(HwCounter));
3652 allocParamsForBufferLinear.pBufName = "HWCounter";
3653 allocParamsForBufferLinear.bIsPersistent = true;
3654 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_osInterface->pfnAllocateResource(
3655 m_osInterface,
3656 &allocParamsForBufferLinear,
3657 &m_resHwCountTileReplay),
3658 release_func);
3659 allocParamsForBufferLinear.bIsPersistent = false;
3660 }
3661
3662 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->ReadEncodeCounterFromHW(
3663 m_osInterface,
3664 &tileBatchBuf,
3665 &m_resHwCountTileReplay,
3666 (uint16_t)idx),
3667 release_func);
3668 }
3669
3670 // Construct the tile batch
3671 // To be moved to one sub function later
3672 // HCP Lock for multiple pipe mode
3673 if (m_numPipe > 1)
3674 {
3675 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3676 vdControlStateParams.scalableModePipeLock = true;
3677 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(&tileBatchBuf, &vdControlStateParams), release_func);
3678 }
3679
3680 // VDENC_PIPE_MODE_SELECT
3681 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdencPipeModeSelectCmd(&tileBatchBuf, pipeModeSelectParams), release_func);
3682 // HCP_PIPE_MODE_SELECT
3683 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(&tileBatchBuf, pipeModeSelectParams), release_func);
3684
3685 // 3nd level batch buffer
3686 if (m_hevcVdencAcqpEnabled || m_brcEnabled)
3687 {
3688 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset = m_hwInterface->m_vdencBatchBuffer1stGroupSize;
3689 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource, 0, true, 0);
3690 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&tileBatchBuf, &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx]), release_func);
3691
3692 if (m_hevcRdoqEnabled)
3693 {
3694 MHW_VDBOX_HEVC_PIC_STATE_G12 picStateParams;
3695 SetHcpPicStateParams(picStateParams);
3696 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hcpInterface->AddHcpHevcVp9RdoqStateCmd(&tileBatchBuf, &picStateParams), release_func);
3697 }
3698 }
3699
3700 // HCP_TILE_CODING commmand
3701 // Set Tile replay related parameters
3702 tileParams[idx].IsFirstPass = IsFirstPassForTileReplay();
3703 tileParams[idx].IsLastPass = IsLastPassForTileReplay();
3704 tileParams[idx].bTileReplayEnable = m_enableTileReplay;
3705 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwVdboxHcpInterfaceG12 *>(m_hcpInterface)->AddHcpTileCodingCmd(&tileBatchBuf, &tileParams[idx]), release_func);
3706
3707 for (slcCount = 0; slcCount < m_numSlices; slcCount++)
3708 {
3709 bool lastSliceInTile = false, sliceInTile = false;
3710
3711 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(IsSliceInTile(slcCount,
3712 &tileParams[idx],
3713 &sliceInTile,
3714 &lastSliceInTile),
3715 release_func);
3716
3717 if (!sliceInTile)
3718 {
3719 continue;
3720 }
3721
3722 if (m_hevcVdencAcqpEnabled || m_brcEnabled)
3723 {
3724 // save offset for next 2nd level batch buffer usage
3725 // This is because we don't know how many times HCP_WEIGHTOFFSET_STATE & HCP_PAK_INSERT_OBJECT will be inserted for each slice
3726 // dwVdencBatchBufferPerSliceConstSize: constant size for each slice
3727 // m_vdencBatchBufferPerSliceVarSize: variable size for each slice
3728
3729 // starting location for executing slice level cmds
3730 // To do: Improvize to only add current slice wSlcCount
3731 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset = m_hwInterface->m_vdencBatchBuffer1stGroupSize + m_hwInterface->m_vdencBatchBuffer2ndGroupSize;
3732
3733 for (uint32_t j = 0; j < slcCount; j++)
3734 {
3735 m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].dwOffset
3736 += (m_hwInterface->m_vdencBatchBufferPerSliceConstSize + m_vdencBatchBufferPerSliceVarSize[j]);
3737 }
3738 }
3739
3740 SetHcpSliceStateParams(sliceState, slcData, (uint16_t)slcCount, tileParams, lastSliceInTile, idx);
3741
3742 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SendHwSliceEncodeCommand(&tileBatchBuf, &sliceState), release_func);
3743
3744 // Send VD_PIPELINE_FLUSH command for each slice
3745 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3746 vdPipelineFlushParams.Flags.bWaitDoneMFX = 1;
3747 vdPipelineFlushParams.Flags.bWaitDoneVDENC = 1;
3748 vdPipelineFlushParams.Flags.bFlushVDENC = 1;
3749 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3750 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3751 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&tileBatchBuf, &vdPipelineFlushParams), release_func);
3752
3753 sliceNumInTile++;
3754 } // end of slice
3755
3756 if (0 == sliceNumInTile)
3757 {
3758 // One tile must have at least one slice
3759 CODECHAL_ENCODE_ASSERT(false);
3760 eStatus = MOS_STATUS_INVALID_PARAMETER;
3761 break;
3762 }
3763
3764 if (sliceNumInTile > 1 && (numTileColumns > 1 || numTileRows > 1))
3765 {
3766 CODECHAL_ENCODE_ASSERTMESSAGE("Multi-slices in a tile is not supported!");
3767 release_func();
3768 return MOS_STATUS_INVALID_PARAMETER;
3769 }
3770
3771 //HCP unLock for multiple pipe mode
3772 if (m_numPipe > 1)
3773 {
3774 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3775 vdControlStateParams.scalableModePipeUnlock = true;
3776 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(static_cast<MhwMiInterfaceG12 *>(m_miInterface)->AddMiVdControlStateCmd(&tileBatchBuf, &vdControlStateParams), release_func);
3777 }
3778
3779 // Send VD_PIPELINE_FLUSH command
3780 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3781 vdPipelineFlushParams.Flags.bWaitDoneHEVC = 1;
3782 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3783 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3784 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&tileBatchBuf, &vdPipelineFlushParams), release_func);
3785
3786 // Send MI_FLUSH command
3787 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3788 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3789 flushDwParams.bVideoPipelineCacheInvalidate = true;
3790 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiFlushDwCmd(&tileBatchBuf, &flushDwParams), release_func);
3791
3792 // Add batch buffer end at the end of each tile batch, 2nd level batch buffer
3793 (&m_tileLevelBatchBuffer[m_tileRowPass][idx])->iCurrent = tileBatchBuf.iOffset;
3794 (&m_tileLevelBatchBuffer[m_tileRowPass][idx])->iRemaining = tileBatchBuf.iRemaining;
3795 (&m_tileLevelBatchBuffer[m_tileRowPass][idx])->pData = data;
3796 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &m_tileLevelBatchBuffer[m_tileRowPass][idx]), release_func);
3797
3798 if (data)
3799 {
3800 m_osInterface->pfnUnlockResource(m_osInterface, &(m_tileLevelBatchBuffer[m_tileRowPass][idx].OsResource));
3801 }
3802 } // end of row tile
3803
3804 // Set the semaphore for tile row BRC update
3805 if ((m_numPipe > 1) && (!IsFirstPipe()) && (!IsLastPassForTileReplay()))
3806 {
3807 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(
3808 SetSemaphoreMem(
3809 &m_resVdBoxSemaphoreMem[currentPipe].sResource,
3810 &cmdBuffer,
3811 0xFF),
3812 release_func);
3813 }
3814
3815 //turn on protection again in case conditionalbatchbufferexit turns off the protection
3816 if (m_osInterface->osCpInterface->IsCpEnabled() && m_hwInterface->GetCpInterface()->IsHwCounterIncrement(m_osInterface) && m_enableTileReplay)
3817 {
3818 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->AddProlog(m_osInterface, &cmdBuffer), release_func);
3819 }
3820
3821 // Run tile row based BRC on pipe 0
3822 if (IsFirstPipe() && (!IsLastPassForTileReplay()))
3823 {
3824 m_CurrentTileRow = tileRow;
3825 m_CurrentPassForTileReplay = m_tileRowPass;
3826 m_CurrentPassForOverAll++;
3827
3828 // Before tile row BRC update, make sure all pipes are complete
3829 if (m_numPipe > 1)
3830 {
3831 for (uint32_t i = 1; i < m_numPipe; i++)
3832 {
3833 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SendHWWaitCommand(&m_resVdBoxSemaphoreMem[i].sResource, &cmdBuffer, 0xFF), release_func);
3834 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(SetSemaphoreMem(&m_resVdBoxSemaphoreMem[i].sResource, &cmdBuffer, 0x0), release_func);
3835 }
3836 }
3837
3838 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(HuCBrcTileRowUpdate(&cmdBuffer), release_func);
3839 }
3840
3841 //turn on protection again in case conditionalbatchbufferexit turns off the protection
3842 if (m_osInterface->osCpInterface->IsCpEnabled() && m_hwInterface->GetCpInterface()->IsHwCounterIncrement(m_osInterface) && m_enableTileReplay)
3843 {
3844 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->AddProlog(m_osInterface, &cmdBuffer), release_func);
3845 }
3846
3847 //Refresh counter after every tilerowpass
3848 if (m_tileRowPass < m_NumPassesForTileReplay - 1)
3849 {
3850 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->RefreshCounter(m_osInterface, &cmdBuffer), release_func);
3851 }
3852 }
3853
3854 // Update head pointer for capture mode
3855 if (m_CaptureModeEnable && IsLastPipe())
3856 {
3857 MHW_MI_LOAD_REGISTER_IMM_PARAMS registerImmParams;
3858 MOS_ZeroMemory(&registerImmParams, sizeof(registerImmParams));
3859 registerImmParams.dwData = 1;
3860 registerImmParams.dwRegister = m_VdboxVDENCRegBase[currentPipe] + 0x90;
3861 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_miInterface->AddMiLoadRegisterImmCmd(&cmdBuffer, &registerImmParams), release_func);
3862 }
3863
3864 //refresh encode counter after every rowpass
3865 if (tileRow < numTileRows - 1)
3866 {
3867 CODECHAL_ENCODE_CHK_STATUS_WITH_DESTROY_RETURN(m_hwInterface->GetCpInterface()->RefreshCounter(m_osInterface, &cmdBuffer), release_func);
3868 }
3869 }
3870
3871 m_vdencInterface->ReleaseMhwVdboxPipeModeSelectParams(pipeModeSelectParams);
3872
3873 // Insert end of sequence/stream if se
3874 // To be moved to slice level?
3875 if ((m_lastPicInStream || m_lastPicInSeq) && IsLastPipe())
3876 {
3877 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
3878 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
3879 pakInsertObjectParams.bLastPicInSeq = m_lastPicInSeq;
3880 pakInsertObjectParams.bLastPicInStream = m_lastPicInStream;
3881 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(&cmdBuffer, &pakInsertObjectParams));
3882 }
3883
3884 // Send VD_CONTROL_STATE (Memory Implict Flush)
3885 MOS_ZeroMemory(&vdControlStateParams, sizeof(MHW_MI_VD_CONTROL_STATE_PARAMS));
3886 vdControlStateParams.memoryImplicitFlush = true;
3887 CODECHAL_ENCODE_CHK_STATUS_RETURN(
3888 static_cast<MhwMiInterfaceG12*>(m_miInterface)->AddMiVdControlStateCmd(&cmdBuffer, &vdControlStateParams));
3889
3890 // Send VD_PIPELINE_FLUSH command
3891 MOS_ZeroMemory(&vdPipelineFlushParams, sizeof(vdPipelineFlushParams));
3892 vdPipelineFlushParams.Flags.bWaitDoneHEVC = 1;
3893 vdPipelineFlushParams.Flags.bFlushHEVC = 1;
3894 vdPipelineFlushParams.Flags.bWaitDoneVDCmdMsgParser = 1;
3895 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipelineFlushParams));
3896
3897 // Send MI_FLUSH command
3898 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
3899 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3900 flushDwParams.bVideoPipelineCacheInvalidate = true;
3901 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3902
3903 // Set the HW semaphore to indicate current pipe done
3904 if (m_numPipe > 1)
3905 {
3906 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
3907 flushDwParams.bVideoPipelineCacheInvalidate = true;
3908 if (!Mos_ResourceIsNull(&m_resVdBoxSemaphoreMem[currentPipe].sResource))
3909 {
3910 flushDwParams.pOsResource = &m_resVdBoxSemaphoreMem[currentPipe].sResource;
3911 flushDwParams.dwDataDW1 = 0xFF;
3912 }
3913 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
3914 }
3915
3916 if (IsFirstPipe())
3917 {
3918 // first pipe needs to ensure all other pipes are ready
3919 if (m_numPipe > 1)
3920 {
3921 for (uint32_t i = 0; i < m_numPipe; i++)
3922 {
3923 if (!Mos_ResourceIsNull(&m_resVdBoxSemaphoreMem[i].sResource))
3924 {
3925 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendHWWaitCommand(&m_resVdBoxSemaphoreMem[i].sResource, &cmdBuffer, 0xFF));
3926 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetSemaphoreMem(&m_resVdBoxSemaphoreMem[i].sResource, &cmdBuffer, 0x0));
3927 }
3928 }
3929 }
3930
3931 // Whenever ACQP/ BRC is enabled with tiling, PAK Integration kernel is needed.
3932 // ACQP/ BRC need PAK integration kernel to aggregate statistics
3933 if (m_vdencHucUsed)
3934 {
3935 CODECHAL_ENCODE_CHK_STATUS_RETURN(HucPakIntegrate(&cmdBuffer));
3936 }
3937
3938 // Use HW stitch commands only in the scalable mode
3939 // For single pipe with tile replay, stitch also needed
3940 if (m_enableTileStitchByHW)
3941 {
3942 // 2nd level BB buffer for stitching cmd
3943 // current location to add cmds in 2nd level batch buffer
3944 m_HucStitchCmdBatchBuffer.iCurrent = 0;
3945 // reset starting location (offset) executing 2nd level batch buffer for each frame & each pass
3946 m_HucStitchCmdBatchBuffer.dwOffset = 0;
3947 HalOcaInterface::OnSubLevelBBStart(cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_HucStitchCmdBatchBuffer.OsResource, 0, true, 0);
3948 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(&cmdBuffer, &m_HucStitchCmdBatchBuffer));
3949 // This wait cmd is needed to make sure copy command is done as suggested by HW folk in encode cases
3950 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMfxWaitCmd(&cmdBuffer, nullptr, m_osInterface->osCpInterface->IsCpEnabled() ? true : false));
3951 }
3952
3953 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadSseStatistics(&cmdBuffer));
3954
3955 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
3956
3957 if (m_numPipe <= 1) // single pipe mode can read the info from MMIO register. Otherwise, we have to use the tile size statistic buffer
3958 {
3959 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadHcpStatus(&cmdBuffer));
3960
3961 // BRC PAK statistics different for each pass
3962 if (m_brcEnabled)
3963 {
3964 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReadBrcPakStats(&cmdBuffer));
3965 }
3966 }
3967
3968 MHW_MI_STORE_DATA_PARAMS storeDataParams;
3969 // Signal HW semaphore for the reference frame dependency (i.e., current coding frame waits for the reference frame being ready)
3970 if (m_currRefSync && !Mos_ResourceIsNull(&m_currRefSync->resSemaphoreMem.sResource))
3971 {
3972 // the reference frame semaphore must be set in each pass because of the conditional BRC batch buffer. Some BRC passes could be skipped.
3973 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
3974 storeDataParams.pOsResource = &m_currRefSync->resSemaphoreMem.sResource;
3975 storeDataParams.dwResourceOffset = 0;
3976 storeDataParams.dwValue = 1;
3977
3978 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiStoreDataImmCmd(
3979 &cmdBuffer,
3980 &storeDataParams));
3981 }
3982 }
3983
3984 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase || (m_numPipe >= 2))
3985 {
3986 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetMiInterface()->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
3987 }
3988
3989 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
3990
3991 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
3992 {
3993 bool nullRendering = m_videoContextUsesNullHw;
3994
3995 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, nullRendering));
3996
3997 CODECHAL_DEBUG_TOOL(
3998 if (m_mmcState)
3999 {
4000 m_mmcState->UpdateUserFeatureKey(&m_reconSurface);
4001 }
4002 )
4003
4004 if (IsFirstPipe() &&
4005 IsLastPass() &&
4006 m_signalEnc &&
4007 m_currRefSync &&
4008 !Mos_ResourceIsNull(&m_resSyncObjectVideoContextInUse))
4009 {
4010 // signal semaphore
4011 MOS_SYNC_PARAMS syncParams;
4012 syncParams = g_cInitSyncParams;
4013 syncParams.GpuContext = m_videoContext;
4014 syncParams.presSyncResource = &m_currRefSync->resSyncObject;
4015
4016 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnEngineSignal(m_osInterface, &syncParams));
4017 m_currRefSync->uiSemaphoreObjCount++;
4018 m_currRefSync->bInUsed = true;
4019 }
4020 }
4021
4022 // Reset parameters for next PAK execution
4023 if (IsLastPipe() &&
4024 IsLastPass())
4025 {
4026 if (!m_singleTaskPhaseSupported)
4027 {
4028 m_osInterface->pfnResetPerfBufferID(m_osInterface);
4029 }
4030
4031 m_currPakSliceIdx = (m_currPakSliceIdx + 1) % CODECHAL_HEVC_NUM_PAK_SLICE_BATCH_BUFFERS;
4032
4033 m_newPpsHeader = 0;
4034 m_newSeqHeader = 0;
4035 m_frameNum++;
4036 }
4037
4038 return eStatus;
4039 }
4040
4041 MOS_STATUS CodechalVdencHevcStateG12::ConstructBatchBufferHuCBRC(PMOS_RESOURCE batchBuffer)
4042 {
4043 CODECHAL_ENCODE_FUNCTION_ENTER;
4044
4045 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4046
4047 CODECHAL_ENCODE_CHK_NULL_RETURN(m_slcData);
4048 CODECHAL_ENCODE_CHK_NULL_RETURN(batchBuffer);
4049
4050 MOS_LOCK_PARAMS lockFlags;
4051 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4052 lockFlags.WriteOnly = true;
4053
4054 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, batchBuffer, &lockFlags);
4055 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
4056
4057 MOS_COMMAND_BUFFER constructedCmdBuf;
4058 MOS_ZeroMemory(&constructedCmdBuf, sizeof(constructedCmdBuf));
4059 constructedCmdBuf.pCmdBase = constructedCmdBuf.pCmdPtr = (uint32_t *)data;
4060 constructedCmdBuf.iRemaining = MOS_ALIGN_CEIL(m_hwInterface->m_vdencReadBatchBufferSize, CODECHAL_PAGE_SIZE);
4061
4062 // 1st Group : PIPE_MODE_SELECT
4063 // set PIPE_MODE_SELECT command
4064 // This is not needed for GEN11/GEN12 as single pass SAO is supported
4065 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12 pipeModeSelectParams;
4066 pipeModeSelectParams.Mode = m_mode;
4067 pipeModeSelectParams.bVdencEnabled = true;
4068 pipeModeSelectParams.bAdvancedRateControlEnable = true;
4069 pipeModeSelectParams.bRdoqEnable = m_hevcRdoqEnabled;
4070 pipeModeSelectParams.MultiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY;
4071 pipeModeSelectParams.PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_LEGACY;
4072 pipeModeSelectParams.bStreamOutEnabled = 1;
4073 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeModeSelectCmd(&constructedCmdBuf, &pipeModeSelectParams));
4074
4075 MHW_BATCH_BUFFER TempBatchBuffer;
4076 MOS_ZeroMemory(&TempBatchBuffer, sizeof(MHW_BATCH_BUFFER));
4077 TempBatchBuffer.iSize = MOS_ALIGN_CEIL(m_hwInterface->m_vdencReadBatchBufferSize, CODECHAL_PAGE_SIZE);
4078 TempBatchBuffer.pData = data;
4079
4080 // set MI_BATCH_BUFFER_END command
4081 int32_t cmdBufOffset = constructedCmdBuf.iOffset;
4082
4083 TempBatchBuffer.iCurrent = constructedCmdBuf.iOffset;
4084 TempBatchBuffer.iRemaining = constructedCmdBuf.iRemaining;
4085 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &TempBatchBuffer));
4086 constructedCmdBuf.pCmdPtr += (TempBatchBuffer.iCurrent - constructedCmdBuf.iOffset) / 4;
4087 constructedCmdBuf.iOffset = TempBatchBuffer.iCurrent;
4088 constructedCmdBuf.iRemaining = TempBatchBuffer.iRemaining;
4089
4090 m_miBatchBufferEndCmdSize = constructedCmdBuf.iOffset - cmdBufOffset;
4091 CODECHAL_ENCODE_ASSERT(m_hwInterface->m_vdencBatchBuffer1stGroupSize == constructedCmdBuf.iOffset);
4092
4093 SetAddCommands(CODECHAL_CMD1, &constructedCmdBuf, true, m_roundInterValue, m_roundIntraValue, m_lowDelay);
4094 m_picStateCmdStartInBytes = constructedCmdBuf.iOffset;
4095
4096 // set HCP_PIC_STATE command
4097 MHW_VDBOX_HEVC_PIC_STATE_G12 hevcPicState;
4098 SetHcpPicStateParams(hevcPicState);
4099 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(&constructedCmdBuf, &hevcPicState));
4100 m_cmd2StartInBytes = constructedCmdBuf.iOffset;
4101
4102 SetAddCommands(CODECHAL_CMD2, &constructedCmdBuf, true, m_roundInterValue, m_roundIntraValue, m_lowDelay, m_refIdxMapping, m_slotForRecNotFiltered);
4103
4104 // set MI_BATCH_BUFFER_END command
4105 TempBatchBuffer.iCurrent = constructedCmdBuf.iOffset;
4106 TempBatchBuffer.iRemaining = constructedCmdBuf.iRemaining;
4107 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &TempBatchBuffer));
4108 constructedCmdBuf.pCmdPtr += (TempBatchBuffer.iCurrent - constructedCmdBuf.iOffset) / 4;
4109 constructedCmdBuf.iOffset = TempBatchBuffer.iCurrent;
4110 constructedCmdBuf.iRemaining = TempBatchBuffer.iRemaining;
4111
4112 CODECHAL_ENCODE_ASSERT(m_hwInterface->m_vdencBatchBuffer2ndGroupSize + m_hwInterface->m_vdencBatchBuffer1stGroupSize
4113 == constructedCmdBuf.iOffset);
4114
4115 // 3rd Group : HCP_WEIGHTSOFFSETS_STATE + HCP_SLICE_STATE + HCP_PAK_INSERT_OBJECT + VDENC_WEIGHT_OFFSETS_STATE
4116 MHW_VDBOX_HEVC_SLICE_STATE_G12 sliceState;
4117 SetHcpSliceStateCommonParams(sliceState);
4118
4119 // slice level cmds for each slice
4120 PCODEC_ENCODER_SLCDATA slcData = m_slcData;
4121 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
4122
4123 for (uint32_t startLCU = 0, slcCount = 0; slcCount < m_numSlices; slcCount++)
4124 {
4125 bool lastSliceInTile = false, sliceInTile = false;
4126
4127 if (IsFirstPass())
4128 {
4129 slcData[slcCount].CmdOffset = startLCU * (m_hcpInterface->GetHcpPakObjSize()) * sizeof(uint32_t);
4130 }
4131
4132 uint32_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
4133 uint32_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
4134 uint32_t idx = 0;
4135 for (uint32_t tileRow = 0; tileRow < numTileRows; tileRow++)
4136 {
4137 for (uint32_t tileCol = 0; tileCol < numTileColumns; tileCol++)
4138 {
4139 idx = tileRow * numTileColumns + tileCol;
4140 CODECHAL_ENCODE_CHK_STATUS_RETURN(IsSliceInTile(slcCount,
4141 &tileParams[idx],
4142 &sliceInTile,
4143 &lastSliceInTile));
4144
4145 if (sliceInTile)
4146 {
4147 break;
4148 }
4149 }
4150 if (sliceInTile)
4151 {
4152 break;
4153 }
4154 }
4155
4156 SetHcpSliceStateParams(sliceState, slcData, (uint16_t)slcCount, tileParams, lastSliceInTile, idx);
4157
4158 m_vdencBatchBufferPerSliceVarSize[slcCount] = 0;
4159
4160 // set HCP_WEIGHTOFFSET_STATE command
4161 // This slice level command is issued, if the weighted_pred_flag or weighted_bipred_flag equals one.
4162 // If zero, then this command is not issued.
4163 if (m_hevcVdencWeightedPredEnabled)
4164 {
4165 MHW_VDBOX_HEVC_WEIGHTOFFSET_PARAMS hcpWeightOffsetParams;
4166 MOS_ZeroMemory(&hcpWeightOffsetParams, sizeof(hcpWeightOffsetParams));
4167 // HuC based WP ignores App based weights
4168 if (!m_hevcPicParams->bEnableGPUWeightedPrediction)
4169 {
4170 for (auto k = 0; k < 2; k++) // k=0: LIST_0, k=1: LIST_1
4171 {
4172 // Luma, Chroma Offset
4173 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
4174 {
4175 hcpWeightOffsetParams.LumaOffsets[k][i] = (int16_t)m_hevcSliceParams->luma_offset[k][i];
4176 // Cb, Cr
4177 for (auto j = 0; j < 2; j++)
4178 {
4179 hcpWeightOffsetParams.ChromaOffsets[k][i][j] = (int16_t)m_hevcSliceParams->chroma_offset[k][i][j];
4180 }
4181 }
4182
4183 // Luma Weight
4184 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
4185 &hcpWeightOffsetParams.LumaWeights[k],
4186 sizeof(hcpWeightOffsetParams.LumaWeights[k]),
4187 &m_hevcSliceParams->delta_luma_weight[k],
4188 sizeof(m_hevcSliceParams->delta_luma_weight[k])));
4189 // Chroma Weight
4190 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
4191 &hcpWeightOffsetParams.ChromaWeights[k],
4192 sizeof(hcpWeightOffsetParams.ChromaWeights[k]),
4193 &m_hevcSliceParams->delta_chroma_weight[k],
4194 sizeof(m_hevcSliceParams->delta_chroma_weight[k])));
4195 }
4196 }
4197
4198 // 1st HCP_WEIGHTOFFSET_STATE cmd - P & B
4199 if (m_hevcSliceParams->slice_type == CODECHAL_ENCODE_HEVC_P_SLICE || m_hevcSliceParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
4200 {
4201 hcpWeightOffsetParams.ucList = LIST_0;
4202
4203 cmdBufOffset = constructedCmdBuf.iOffset;
4204 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(&constructedCmdBuf, nullptr, &hcpWeightOffsetParams));
4205 m_hcpWeightOffsetStateCmdSize = constructedCmdBuf.iOffset - cmdBufOffset;
4206 // 1st HcpWeightOffset cmd is not always inserted (except weighted prediction + P, B slices)
4207 m_vdencBatchBufferPerSliceVarSize[slcCount] += m_hcpWeightOffsetStateCmdSize;
4208 }
4209
4210 // 2nd HCP_WEIGHTOFFSET_STATE cmd - B only
4211 if (m_hevcSliceParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
4212 {
4213 hcpWeightOffsetParams.ucList = LIST_1;
4214
4215 cmdBufOffset = constructedCmdBuf.iOffset;
4216 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpWeightOffsetStateCmd(&constructedCmdBuf, nullptr, &hcpWeightOffsetParams));
4217 m_hcpWeightOffsetStateCmdSize = constructedCmdBuf.iOffset - cmdBufOffset;
4218 // 2nd HcpWeightOffset cmd is not always inserted (except weighted prediction + B slices)
4219 m_vdencBatchBufferPerSliceVarSize[slcCount] += m_hcpWeightOffsetStateCmdSize;
4220 }
4221 }
4222
4223 // set HCP_SLICE_STATE command
4224 cmdBufOffset = constructedCmdBuf.iOffset;
4225 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpSliceStateCmd(&constructedCmdBuf, &sliceState));
4226 m_hcpSliceStateCmdSize = constructedCmdBuf.iOffset - cmdBufOffset;
4227
4228 // set 1st HCP_PAK_INSERT_OBJECT command
4229 // insert AU, SPS, PPS headers before first slice header
4230 if (sliceState.bInsertBeforeSliceHeaders)
4231 {
4232 uint32_t maxBytesInPakInsertObjCmd = ((2 << 11) - 1) * 4; // 12 bits for DwordLength field in PAK_INSERT_OBJ cmd
4233 m_1stPakInsertObjectCmdSize = 0;
4234
4235 for (auto i = 0; i < HEVC_MAX_NAL_UNIT_TYPE; i++)
4236 {
4237 uint32_t nalUnitPosiSize = sliceState.ppNalUnitParams[i]->uiSize;
4238 uint32_t nalUnitPosiOffset = sliceState.ppNalUnitParams[i]->uiOffset;
4239
4240 while (nalUnitPosiSize > 0)
4241 {
4242 uint32_t bitSize = MOS_MIN(maxBytesInPakInsertObjCmd * 8, nalUnitPosiSize * 8);
4243 uint32_t offSet = nalUnitPosiOffset;
4244
4245 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
4246 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
4247 pakInsertObjectParams.bEmulationByteBitsInsert = sliceState.ppNalUnitParams[i]->bInsertEmulationBytes;
4248 pakInsertObjectParams.uiSkipEmulationCheckCount = sliceState.ppNalUnitParams[i]->uiSkipEmulationCheckCount;
4249 pakInsertObjectParams.pBsBuffer = sliceState.pBsBuffer;
4250 pakInsertObjectParams.dwBitSize = bitSize;
4251 pakInsertObjectParams.dwOffset = offSet;
4252
4253 if (nalUnitPosiSize > maxBytesInPakInsertObjCmd)
4254 {
4255 nalUnitPosiSize -= maxBytesInPakInsertObjCmd;
4256 nalUnitPosiOffset += maxBytesInPakInsertObjCmd;
4257 }
4258 else
4259 {
4260 nalUnitPosiSize = 0;
4261 }
4262
4263 cmdBufOffset = constructedCmdBuf.iOffset;
4264 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(&constructedCmdBuf, &pakInsertObjectParams));
4265
4266 // this info needed again in BrcUpdate HuC FW const
4267 m_1stPakInsertObjectCmdSize += (constructedCmdBuf.iOffset - cmdBufOffset);
4268 }
4269 }
4270 // 1st PakInsertObject cmd is not always inserted for each slice
4271 m_vdencBatchBufferPerSliceVarSize[slcCount] += m_1stPakInsertObjectCmdSize;
4272 }
4273
4274 // set 2nd HCP_PAK_INSERT_OBJECT command
4275 // Insert slice header
4276 MHW_VDBOX_PAK_INSERT_PARAMS pakInsertObjectParams;
4277 MOS_ZeroMemory(&pakInsertObjectParams, sizeof(pakInsertObjectParams));
4278 pakInsertObjectParams.bLastHeader = true;
4279 pakInsertObjectParams.bEmulationByteBitsInsert = true;
4280
4281 // App does the slice header packing, set the skip count passed by the app
4282 pakInsertObjectParams.uiSkipEmulationCheckCount = sliceState.uiSkipEmulationCheckCount;
4283 pakInsertObjectParams.pBsBuffer = sliceState.pBsBuffer;
4284 pakInsertObjectParams.dwBitSize = sliceState.dwLength;
4285 pakInsertObjectParams.dwOffset = sliceState.dwOffset;
4286
4287 // For HEVC VDEnc Dynamic Slice
4288 if (m_hevcSeqParams->SliceSizeControl)
4289 {
4290 pakInsertObjectParams.bLastHeader = false;
4291 pakInsertObjectParams.bEmulationByteBitsInsert = false;
4292 pakInsertObjectParams.dwBitSize = m_hevcSliceParams->BitLengthSliceHeaderStartingPortion;
4293 pakInsertObjectParams.bResetBitstreamStartingPos = true;
4294 }
4295
4296 uint32_t byteSize = (pakInsertObjectParams.dwBitSize + 7) >> 3;
4297 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(
4298 &constructedCmdBuf,
4299 &pakInsertObjectParams));
4300
4301 // 2nd PakInsertObject cmd is always inserted for each slice
4302 // so already reflected in dwVdencBatchBufferPerSliceConstSize
4303 m_vdencBatchBufferPerSliceVarSize[slcCount] += (MOS_ALIGN_CEIL(byteSize, sizeof(uint32_t))) / sizeof(uint32_t) * 4;
4304
4305 // set 3rd HCP_PAK_INSERT_OBJECT command
4306 if (m_hevcSeqParams->SliceSizeControl)
4307 {
4308 // Send HCP_PAK_INSERT_OBJ command. For dynamic slice, we are skipping the beginning part of slice header.
4309 pakInsertObjectParams.bLastHeader = true;
4310 pakInsertObjectParams.dwBitSize = sliceState.dwLength - m_hevcSliceParams->BitLengthSliceHeaderStartingPortion;
4311 pakInsertObjectParams.dwOffset += ((m_hevcSliceParams->BitLengthSliceHeaderStartingPortion + 7) / 8); // Skips the first 5 bytes which is Start Code + Nal Unit Header
4312 pakInsertObjectParams.bResetBitstreamStartingPos = true;
4313
4314 cmdBufOffset = constructedCmdBuf.iOffset;
4315 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPakInsertObject(
4316 &constructedCmdBuf,
4317 &pakInsertObjectParams));
4318 // 3rd PakInsertObject cmd is not always inserted for each slice
4319 m_vdencBatchBufferPerSliceVarSize[slcCount] += (constructedCmdBuf.iOffset - cmdBufOffset);
4320 }
4321
4322 // set VDENC_WEIGHT_OFFSETS_STATE command
4323 MHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS vdencWeightOffsetParams;
4324 MOS_ZeroMemory(&vdencWeightOffsetParams, sizeof(vdencWeightOffsetParams));
4325 vdencWeightOffsetParams.bWeightedPredEnabled = m_hevcVdencWeightedPredEnabled;
4326 vdencWeightOffsetParams.isLowDelay = m_lowDelay;
4327
4328 if (vdencWeightOffsetParams.bWeightedPredEnabled)
4329 {
4330 uint8_t lumaLog2WeightDenom = m_hevcPicParams->bEnableGPUWeightedPrediction ? 6 : m_hevcSliceParams->luma_log2_weight_denom;
4331 vdencWeightOffsetParams.dwDenom = 1 << lumaLog2WeightDenom;
4332
4333 if (!m_hevcPicParams->bEnableGPUWeightedPrediction)
4334 {
4335 // Luma Offsets
4336 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
4337 {
4338 vdencWeightOffsetParams.LumaOffsets[0][i] = (int16_t)m_hevcSliceParams->luma_offset[0][i];
4339 vdencWeightOffsetParams.LumaOffsets[1][i] = (int16_t)m_hevcSliceParams->luma_offset[1][i];
4340 }
4341
4342 // Luma Weights
4343 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
4344 &vdencWeightOffsetParams.LumaWeights[0],
4345 sizeof(vdencWeightOffsetParams.LumaWeights[0]),
4346 &m_hevcSliceParams->delta_luma_weight[0],
4347 sizeof(m_hevcSliceParams->delta_luma_weight[0])),
4348 "Failed to copy luma weight 0 memory.");
4349
4350 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(MOS_SecureMemcpy(
4351 &vdencWeightOffsetParams.LumaWeights[1],
4352 sizeof(vdencWeightOffsetParams.LumaWeights[1]),
4353 &m_hevcSliceParams->delta_luma_weight[1],
4354 sizeof(m_hevcSliceParams->delta_luma_weight[1])),
4355 "Failed to copy luma weight 1 memory.");
4356 }
4357 }
4358
4359 cmdBufOffset = constructedCmdBuf.iOffset;
4360 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencWeightsOffsetsStateCmd(
4361 &constructedCmdBuf,
4362 nullptr,
4363 &vdencWeightOffsetParams));
4364 m_vdencWeightOffsetStateCmdSize = constructedCmdBuf.iOffset - cmdBufOffset;
4365
4366 // set MI_BATCH_BUFFER_END command
4367 TempBatchBuffer.iCurrent = constructedCmdBuf.iOffset;
4368 TempBatchBuffer.iRemaining = constructedCmdBuf.iRemaining;
4369 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &TempBatchBuffer));
4370 constructedCmdBuf.pCmdPtr += (TempBatchBuffer.iCurrent - constructedCmdBuf.iOffset) / 4;
4371 constructedCmdBuf.iOffset = TempBatchBuffer.iCurrent;
4372 constructedCmdBuf.iRemaining = TempBatchBuffer.iRemaining;
4373
4374 m_vdencBatchBufferPerSliceVarSize[slcCount] += ENCODE_VDENC_HEVC_PADDING_DW_SIZE * 4;
4375 for (auto i = 0; i < ENCODE_VDENC_HEVC_PADDING_DW_SIZE ; i++)
4376 {
4377 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiNoop(&constructedCmdBuf, nullptr));
4378 }
4379 startLCU += m_hevcSliceParams[slcCount].NumLCUsInSlice;
4380 }
4381
4382 if (data)
4383 {
4384 m_osInterface->pfnUnlockResource(m_osInterface, batchBuffer);
4385 }
4386
4387 return eStatus;
4388 }
4389
4390 MOS_STATUS CodechalVdencHevcStateG12::ConstructTLB(PMHW_BATCH_BUFFER thirdLevelBatchBuffer)
4391 {
4392 CODECHAL_ENCODE_FUNCTION_ENTER;
4393
4394 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4395
4396 CODECHAL_ENCODE_CHK_NULL_RETURN(thirdLevelBatchBuffer);
4397
4398 MHW_VDBOX_HEVC_PIC_STATE_G12 picStateParams;
4399 SetHcpPicStateParams(picStateParams);
4400
4401 MOS_LOCK_PARAMS lockFlags;
4402 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
4403 lockFlags.WriteOnly = true;
4404
4405 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, &(thirdLevelBatchBuffer->OsResource), &lockFlags);
4406 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
4407
4408 MOS_COMMAND_BUFFER constructedCmdBuf;
4409 MOS_ZeroMemory(&constructedCmdBuf, sizeof(constructedCmdBuf));
4410 constructedCmdBuf.pCmdBase = constructedCmdBuf.pCmdPtr = (uint32_t *)data;
4411 constructedCmdBuf.iRemaining = m_thirdLBSize;
4412
4413 SetAddCommands(CODECHAL_CMD1, &constructedCmdBuf, true, m_roundInterValue, m_roundIntraValue, m_lowDelay);
4414
4415 // HCP_PIC_STATE
4416 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPicStateCmd(&constructedCmdBuf, &picStateParams));
4417
4418 SetAddCommands(CODECHAL_CMD2, &constructedCmdBuf, true, m_roundInterValue, m_roundIntraValue, m_lowDelay, m_refIdxMapping, m_slotForRecNotFiltered);
4419
4420 // Send HEVC_VP9_RDOQ_STATE command
4421 if (m_hevcRdoqEnabled)
4422 {
4423 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpHevcVp9RdoqStateCmd(&constructedCmdBuf, &picStateParams));
4424 }
4425
4426 thirdLevelBatchBuffer->iCurrent = constructedCmdBuf.iOffset;
4427 thirdLevelBatchBuffer->iRemaining = constructedCmdBuf.iRemaining;
4428 thirdLevelBatchBuffer->pData = data;
4429 // set MI_BATCH_BUFFER_END command
4430 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, thirdLevelBatchBuffer));
4431
4432 std::string pakPassName = "PAK_PASS[" + std::to_string(GetCurrentPass()) + "]_PIPE[" + std::to_string(GetCurrentPipe()) + "]_TLB";
4433 CODECHAL_DEBUG_TOOL(
4434 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
4435 &constructedCmdBuf,
4436 CODECHAL_NUM_MEDIA_STATES,
4437 pakPassName.data()));)
4438
4439 if (data)
4440 {
4441 m_osInterface->pfnUnlockResource(m_osInterface, &(thirdLevelBatchBuffer->OsResource));
4442 }
4443
4444 return eStatus;
4445 }
4446
4447 MOS_STATUS CodechalVdencHevcStateG12::SetDmemHuCBrcInitReset()
4448 {
4449 CODECHAL_ENCODE_FUNCTION_ENTER;
4450
4451 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4452
4453 MOS_LOCK_PARAMS lockFlagsWriteOnly;
4454 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
4455 lockFlagsWriteOnly.WriteOnly = true;
4456
4457 // Setup BrcInit DMEM
4458 auto hucVdencBrcInitDmem = (PCODECHAL_VDENC_HEVC_HUC_BRC_INIT_DMEM_G12)m_osInterface->pfnLockResource(
4459 m_osInterface, &m_vdencBrcInitDmemBuffer[m_currRecycledBufIdx], &lockFlagsWriteOnly);
4460 CODECHAL_ENCODE_CHK_NULL_RETURN(hucVdencBrcInitDmem);
4461 MOS_ZeroMemory(hucVdencBrcInitDmem, sizeof(CODECHAL_VDENC_HEVC_HUC_BRC_INIT_DMEM_G12));
4462
4463 hucVdencBrcInitDmem->BRCFunc_U32 = (m_enableTileReplay ? 1 : 0) << 7; //bit0 0: Init; 1: Reset, bit7 0: frame-based; 1: tile-based
4464 hucVdencBrcInitDmem->UserMaxFrame = GetProfileLevelMaxFrameSize();
4465 hucVdencBrcInitDmem->InitBufFull_U32 = MOS_MIN(m_hevcSeqParams->InitVBVBufferFullnessInBit, m_hevcSeqParams->VBVBufferSizeInBit);
4466 hucVdencBrcInitDmem->BufSize_U32 = m_hevcSeqParams->VBVBufferSizeInBit;
4467 hucVdencBrcInitDmem->TargetBitrate_U32 = m_hevcSeqParams->TargetBitRate * CODECHAL_ENCODE_BRC_KBPS; // map DDI params(in Kbits) to huc (in bits)
4468 hucVdencBrcInitDmem->MaxRate_U32 = m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS;
4469 hucVdencBrcInitDmem->MinRate_U32 = 0;
4470 hucVdencBrcInitDmem->FrameRateM_U32 = m_hevcSeqParams->FrameRate.Numerator;
4471 hucVdencBrcInitDmem->FrameRateD_U32 = m_hevcSeqParams->FrameRate.Denominator;
4472 hucVdencBrcInitDmem->ACQP_U32 = 0;
4473 if (m_hevcSeqParams->UserMaxPBFrameSize > 0)
4474 {
4475 //Backup CodingType as need to set it as B_Tpye to get MaxFrameSize for P/B frames.
4476 auto CodingTypeTemp = m_hevcPicParams->CodingType;
4477 m_hevcPicParams->CodingType = B_TYPE;
4478 hucVdencBrcInitDmem->ProfileLevelMaxFramePB_U32 = GetProfileLevelMaxFrameSize();
4479 m_hevcPicParams->CodingType = CodingTypeTemp;
4480 }
4481 else
4482 {
4483 hucVdencBrcInitDmem->ProfileLevelMaxFramePB_U32 = hucVdencBrcInitDmem->UserMaxFrame;
4484 }
4485
4486 if (m_brcEnabled)
4487 {
4488 switch (m_hevcSeqParams->RateControlMethod)
4489 {
4490 case RATECONTROL_ICQ:
4491 hucVdencBrcInitDmem->BRCFlag = 0;
4492 hucVdencBrcInitDmem->ACQP_U32 = m_hevcSeqParams->ICQQualityFactor;
4493 break;
4494 case RATECONTROL_CBR:
4495 hucVdencBrcInitDmem->BRCFlag = 1;
4496 break;
4497 case RATECONTROL_VBR:
4498 hucVdencBrcInitDmem->BRCFlag = 2;
4499 hucVdencBrcInitDmem->ACQP_U32 = 0;
4500 break;
4501 case RATECONTROL_VCM:
4502 hucVdencBrcInitDmem->BRCFlag = 3;
4503 break;
4504 case RATECONTROL_QVBR:
4505 hucVdencBrcInitDmem->BRCFlag = 2;
4506 hucVdencBrcInitDmem->ACQP_U32 = m_hevcSeqParams->ICQQualityFactor;;
4507 break;
4508 default:
4509 break;
4510 }
4511
4512 // Low Delay BRC
4513 if (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
4514 {
4515 hucVdencBrcInitDmem->BRCFlag = 5;
4516 }
4517
4518 switch (m_hevcSeqParams->MBBRC)
4519 {
4520 case mbBrcInternal:
4521 case mbBrcEnabled:
4522 hucVdencBrcInitDmem->CuQpCtrl_U8 = 3;
4523 break;
4524 case mbBrcDisabled:
4525 hucVdencBrcInitDmem->CuQpCtrl_U8 = 0;
4526 break;
4527 default:
4528 break;
4529 }
4530 }
4531 else if (m_hevcVdencAcqpEnabled)
4532 {
4533 hucVdencBrcInitDmem->BRCFlag = 0;
4534
4535 // 0=No CUQP; 1=CUQP for I-frame; 2=CUQP for P/B-frame
4536 // bit operation, bit 1 for I-frame, bit 2 for P/B frame
4537 // In VDENC mode, the field "Cu_Qp_Delta_Enabled_Flag" should always be set to 1.
4538 if (m_hevcSeqParams->QpAdjustment)
4539 {
4540 hucVdencBrcInitDmem->CuQpCtrl_U8 = 3; // wPictureCodingType I:0, P:1, B:2
4541 }
4542 else
4543 {
4544 hucVdencBrcInitDmem->CuQpCtrl_U8 = 0; // wPictureCodingType I:0, P:1, B:2
4545 }
4546 }
4547
4548 hucVdencBrcInitDmem->SSCFlag = m_hevcSeqParams->SliceSizeControl;
4549
4550 hucVdencBrcInitDmem->FrameWidth_U16 = (uint16_t)m_frameWidth;
4551 hucVdencBrcInitDmem->FrameHeight_U16 = (uint16_t)m_frameHeight;
4552
4553 hucVdencBrcInitDmem->MinQP_U8 = m_hevcPicParams->BRCMinQp < 10 ? 10 : m_hevcPicParams->BRCMinQp; // Setting values from arch spec
4554 hucVdencBrcInitDmem->MaxQP_U8 = m_hevcPicParams->BRCMaxQp < 10 ? 51 : (m_hevcPicParams->BRCMaxQp > 51 ? 51 : m_hevcPicParams->BRCMaxQp); // Setting values from arch spec
4555
4556 hucVdencBrcInitDmem->BRCPyramidEnable_U8 = 0;
4557
4558 //QP modulation settings
4559 m_hevcSeqParams->GopRefDist = m_hevcSeqParams->GopRefDist == 0 ? 1 : m_hevcSeqParams->GopRefDist;
4560 bool bAllowedPyramid = m_hevcSeqParams->GopRefDist != 3;
4561 uint16_t intraPeriod = m_hevcSeqParams->GopPicSize > 4001 ? 4000 : m_hevcSeqParams->GopPicSize - 1;
4562 intraPeriod = ((intraPeriod + m_hevcSeqParams->GopRefDist - 1) / m_hevcSeqParams->GopRefDist) * m_hevcSeqParams->GopRefDist;
4563
4564 if (m_hevcSeqParams->HierarchicalFlag && bAllowedPyramid)
4565 {
4566 hucVdencBrcInitDmem->GopP_U16 = intraPeriod/m_hevcSeqParams->GopRefDist;
4567 hucVdencBrcInitDmem->GopB_U16 = hucVdencBrcInitDmem->GopP_U16;
4568 hucVdencBrcInitDmem->GopB1_U16 = ((hucVdencBrcInitDmem->GopP_U16 + hucVdencBrcInitDmem->GopB_U16) >= intraPeriod) ? 0 : hucVdencBrcInitDmem->GopB_U16 * 2;
4569 hucVdencBrcInitDmem->GopB2_U16 = ((hucVdencBrcInitDmem->GopP_U16 + hucVdencBrcInitDmem->GopB_U16 + hucVdencBrcInitDmem->GopB1_U16) >= intraPeriod) ? 0 : intraPeriod - hucVdencBrcInitDmem->GopP_U16 - hucVdencBrcInitDmem->GopB_U16 - hucVdencBrcInitDmem->GopB1_U16;
4570 hucVdencBrcInitDmem->MaxBRCLevel_U8 = hucVdencBrcInitDmem->GopB1_U16 == 0 ? HEVC_BRC_FRAME_TYPE_B : (hucVdencBrcInitDmem->GopB2_U16 == 0 ? HEVC_BRC_FRAME_TYPE_B1 : HEVC_BRC_FRAME_TYPE_B2);
4571 hucVdencBrcInitDmem->BRCPyramidEnable_U8 = 1;
4572 }
4573 else //FlatB or LDB
4574 {
4575 hucVdencBrcInitDmem->GopP_U16 = intraPeriod/m_hevcSeqParams->GopRefDist;
4576 hucVdencBrcInitDmem->GopB_U16 = intraPeriod - hucVdencBrcInitDmem->GopP_U16;
4577 hucVdencBrcInitDmem->MaxBRCLevel_U8 = hucVdencBrcInitDmem->GopB_U16 == 0? HEVC_BRC_FRAME_TYPE_P_OR_LB : HEVC_BRC_FRAME_TYPE_B;
4578 }
4579
4580 hucVdencBrcInitDmem->LumaBitDepth_U8 = m_hevcSeqParams->bit_depth_luma_minus8 + 8;
4581 hucVdencBrcInitDmem->ChromaBitDepth_U8 = m_hevcSeqParams->bit_depth_chroma_minus8 + 8;
4582
4583 if (m_hevcSeqParams->SourceBitDepth == ENCODE_HEVC_BIT_DEPTH_10)
4584 {
4585 hucVdencBrcInitDmem->LumaBitDepth_U8 = 10;
4586 hucVdencBrcInitDmem->ChromaBitDepth_U8 = 10;
4587 }
4588
4589 if ((hucVdencBrcInitDmem->LowDelayMode_U8 = (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)))
4590 {
4591 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshPB0_S8, 8 * sizeof(int8_t), (void *)m_lowdelayDevThreshPB, 8 * sizeof(int8_t));
4592 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshVBR0_S8, 8 * sizeof(int8_t), (void*)m_lowdelayDevThreshVBR, 8 * sizeof(int8_t));
4593 MOS_SecureMemcpy(hucVdencBrcInitDmem->DevThreshI0_S8, 8 * sizeof(int8_t), (void*)m_lowdelayDevThreshI, 8 * sizeof(int8_t));
4594 }
4595 else
4596 {
4597 uint64_t inputbitsperframe = uint64_t(hucVdencBrcInitDmem->MaxRate_U32*100. / (hucVdencBrcInitDmem->FrameRateM_U32 * 100.0 / hucVdencBrcInitDmem->FrameRateD_U32));
4598 if (m_brcEnabled && !hucVdencBrcInitDmem->BufSize_U32)
4599 {
4600 CODECHAL_ENCODE_ASSERTMESSAGE("VBV BufSize should not be 0 for BRC case\n");
4601 eStatus = MOS_STATUS_INVALID_PARAMETER;
4602 }
4603 uint64_t vbvsz = hucVdencBrcInitDmem->BufSize_U32;
4604 double bps_ratio = inputbitsperframe / (vbvsz / m_devStdFPS);
4605 if (bps_ratio < m_bpsRatioLow) bps_ratio = m_bpsRatioLow;
4606 if (bps_ratio > m_bpsRatioHigh) bps_ratio = m_bpsRatioHigh;
4607
4608 for (int i = 0; i < m_numDevThreshlds / 2; i++) {
4609 hucVdencBrcInitDmem->DevThreshPB0_S8[i] = (signed char)(m_negMultPB*pow(m_devThreshPBFPNEG[i], bps_ratio));
4610 hucVdencBrcInitDmem->DevThreshPB0_S8[i + m_numDevThreshlds / 2] = (signed char)(m_postMultPB*pow(m_devThreshPBFPPOS[i], bps_ratio));
4611
4612 hucVdencBrcInitDmem->DevThreshI0_S8[i] = (signed char)(m_negMultPB*pow(m_devThreshIFPNEG[i], bps_ratio));
4613 hucVdencBrcInitDmem->DevThreshI0_S8[i + m_numDevThreshlds / 2] = (signed char)(m_postMultPB*pow(m_devThreshIFPPOS[i], bps_ratio));
4614
4615 hucVdencBrcInitDmem->DevThreshVBR0_S8[i] = (signed char)(m_negMultPB*pow(m_devThreshVBRNEG[i], bps_ratio));
4616 hucVdencBrcInitDmem->DevThreshVBR0_S8[i + m_numDevThreshlds / 2] = (signed char)(m_posMultVBR*pow(m_devThreshVBRPOS[i], bps_ratio));
4617 }
4618 }
4619
4620 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshP0_S8, 4 * sizeof(int8_t), (void *)m_instRateThreshP0, 4 * sizeof(int8_t));
4621 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshB0_S8, 4 * sizeof(int8_t), (void *)m_instRateThreshB0, 4 * sizeof(int8_t));
4622 MOS_SecureMemcpy(hucVdencBrcInitDmem->InstRateThreshI0_S8, 4 * sizeof(int8_t), (void *)m_instRateThreshI0, 4 * sizeof(int8_t));
4623
4624 if (m_brcEnabled)
4625 {
4626 // initQPIP, initQPB values will be used for BRC in the future
4627 int32_t initQPIP = 0, initQPB = 0;
4628 ComputeVDEncInitQP(initQPIP, initQPB);
4629 hucVdencBrcInitDmem->InitQPIP_U8 = (uint8_t)initQPIP;
4630 hucVdencBrcInitDmem->InitQPB_U8 = (uint8_t)initQPB;
4631 }
4632 else
4633 {
4634 hucVdencBrcInitDmem->InitQPIP_U8 = m_hevcPicParams->QpY + m_hevcSliceParams->slice_qp_delta;
4635 hucVdencBrcInitDmem->InitQPB_U8 = m_hevcPicParams->QpY + m_hevcSliceParams->slice_qp_delta;
4636 }
4637
4638 hucVdencBrcInitDmem->TopFrmSzThrForAdapt2Pass_U8 = 32;
4639 hucVdencBrcInitDmem->BotFrmSzThrForAdapt2Pass_U8 = 24;
4640
4641 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshP0_U8, 7 * sizeof(uint8_t), (void*)m_estRateThreshP0, 7 * sizeof(uint8_t));
4642 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshB0_U8, 7 * sizeof(uint8_t), (void*)m_estRateThreshB0, 7 * sizeof(uint8_t));
4643 MOS_SecureMemcpy(hucVdencBrcInitDmem->EstRateThreshI0_U8, 7 * sizeof(uint8_t), (void*)m_estRateThreshI0, 7 * sizeof(uint8_t));
4644
4645 if (m_vdencStreamInEnabled && m_hevcPicParams->NumROI && !m_vdencNativeROIEnabled)
4646 {
4647 hucVdencBrcInitDmem->StreamInROIEnable_U8 = 1;
4648 hucVdencBrcInitDmem->StreamInSurfaceEnable_U8 = 1;
4649 }
4650
4651 hucVdencBrcInitDmem->TopQPDeltaThrForAdapt2Pass_U8 = 2;
4652 hucVdencBrcInitDmem->BotQPDeltaThrForAdapt2Pass_U8 = 1;
4653
4654 if ((m_hevcSeqParams->SlidingWindowSize != 0) && (m_hevcSeqParams->MaxBitRatePerSlidingWindow != 0))
4655 {
4656 hucVdencBrcInitDmem->SlidingWindow_Size_U32 = m_hevcSeqParams->SlidingWindowSize;
4657 hucVdencBrcInitDmem->SLIDINGWINDOW_MaxRateRatio = m_hevcSeqParams->MaxBitRatePerSlidingWindow * 100 / m_hevcSeqParams->TargetBitRate;
4658 }
4659 else
4660 {
4661 if (m_hevcSeqParams->FrameRate.Denominator == 0)
4662 {
4663 CODECHAL_ENCODE_ASSERTMESSAGE("FrameRate.Deminator is zero!");
4664 return MOS_STATUS_INVALID_PARAMETER;
4665 }
4666 uint32_t framerate = m_hevcSeqParams->FrameRate.Numerator / m_hevcSeqParams->FrameRate.Denominator;
4667 hucVdencBrcInitDmem->SlidingWindow_Size_U32 = MOS_MIN(framerate, 60);
4668 hucVdencBrcInitDmem->SLIDINGWINDOW_MaxRateRatio = 120;
4669 }
4670
4671 // Tile Row based BRC
4672 if (m_enableTileReplay)
4673 {
4674 uint32_t shift = m_hevcSeqParams->log2_max_coding_block_size_minus3 - m_hevcSeqParams->log2_min_coding_block_size_minus3;
4675 uint32_t residual = (1 << shift) - 1;
4676 hucVdencBrcInitDmem->SlideWindowRC = 0; //Reserved for now
4677 hucVdencBrcInitDmem->MaxLogCUSize = m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3;
4678 hucVdencBrcInitDmem->FrameWidthInLCU = (m_hevcSeqParams->wFrameWidthInMinCbMinus1 + 1 + residual) >> shift;
4679 hucVdencBrcInitDmem->FrameHeightInLCU = (m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1 + residual) >> shift;
4680 }
4681
4682 // Long term reference
4683 hucVdencBrcInitDmem->LongTermRefEnable_U8 = true;
4684 hucVdencBrcInitDmem->LongTermRefMsdk_U8 = true;
4685 hucVdencBrcInitDmem->IsLowDelay_U8 = m_lowDelay;
4686
4687 hucVdencBrcInitDmem->LookaheadDepth_U8 = m_lookaheadDepth;
4688
4689 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencBrcInitDmemBuffer[m_currRecycledBufIdx]);
4690
4691 return eStatus;
4692 }
4693
4694 MOS_STATUS CodechalVdencHevcStateG12::SetConstDataHuCBrcUpdate()
4695 {
4696 CODECHAL_ENCODE_FUNCTION_ENTER;
4697
4698 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4699
4700 MOS_LOCK_PARAMS lockFlagsWriteOnly;
4701 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
4702 lockFlagsWriteOnly.WriteOnly = true;
4703
4704 auto hucConstData = (PCODECHAL_VDENC_HEVC_HUC_BRC_CONSTANT_DATA_G12)m_osInterface->pfnLockResource(
4705 m_osInterface, &m_vdencBrcConstDataBuffer[m_currRecycledBufIdx], &lockFlagsWriteOnly);
4706 CODECHAL_ENCODE_CHK_NULL_RETURN(hucConstData);
4707
4708 MOS_SecureMemcpy(hucConstData->SLCSZ_THRDELTAI_U16, sizeof(m_hucConstantData), m_hucConstantData, sizeof(m_hucConstantData));
4709
4710 MOS_SecureMemcpy(hucConstData->RDQPLambdaI, sizeof(m_rdQpLambdaI), m_rdQpLambdaI, sizeof(m_rdQpLambdaI));
4711 MOS_SecureMemcpy(hucConstData->RDQPLambdaP, sizeof(m_rdQpLambdaP), m_rdQpLambdaP, sizeof(m_rdQpLambdaP));
4712
4713 if (m_hevcVisualQualityImprovement)
4714 {
4715 MOS_SecureMemcpy(hucConstData->SADQPLambdaI, sizeof(m_sadQpLambdaI), m_sadQpLambdaI_VQI, sizeof(m_sadQpLambdaI_VQI));
4716 MOS_SecureMemcpy(hucConstData->PenaltyForIntraNonDC32x32PredMode, sizeof(m_penaltyForIntraNonDC32x32PredMode), m_penaltyForIntraNonDC32x32PredMode_VQI, sizeof(m_penaltyForIntraNonDC32x32PredMode_VQI));
4717 }
4718 else
4719 {
4720 MOS_SecureMemcpy(hucConstData->SADQPLambdaI, sizeof(m_sadQpLambdaI), m_sadQpLambdaI, sizeof(m_sadQpLambdaI));
4721 MOS_SecureMemcpy(hucConstData->PenaltyForIntraNonDC32x32PredMode, sizeof(m_penaltyForIntraNonDC32x32PredMode), m_penaltyForIntraNonDC32x32PredMode, sizeof(m_penaltyForIntraNonDC32x32PredMode));
4722 }
4723
4724 MOS_SecureMemcpy(hucConstData->SADQPLambdaP, sizeof(m_sadQpLambdaP), m_sadQpLambdaP, sizeof(m_sadQpLambdaP));
4725
4726 if (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)
4727 {
4728 const int numEstrateThreshlds = 7;
4729
4730 for (int i = 0; i < numEstrateThreshlds + 1; i++)
4731 {
4732 for (int j = 0; j < m_numDevThreshlds + 1; j++)
4733 {
4734 hucConstData->FrmSzAdjTabI_S8[(numEstrateThreshlds + 1)*j + i] = m_lowdelayDeltaFrmszI[j][i];
4735 hucConstData->FrmSzAdjTabP_S8[(numEstrateThreshlds + 1)*j + i] = m_lowdelayDeltaFrmszP[j][i];
4736 hucConstData->FrmSzAdjTabB_S8[(numEstrateThreshlds + 1)*j + i] = m_lowdelayDeltaFrmszB[j][i];
4737 }
4738 }
4739 }
4740
4741 // ModeCosts depends on frame type
4742 if (m_pictureCodingType == I_TYPE)
4743 {
4744 MOS_SecureMemcpy(hucConstData->ModeCosts, sizeof(m_hucModeCostsIFrame), m_hucModeCostsIFrame, sizeof(m_hucModeCostsIFrame));
4745 }
4746 else
4747 {
4748 MOS_SecureMemcpy(hucConstData->ModeCosts, sizeof(m_hucModeCostsPbFrame), m_hucModeCostsPbFrame, sizeof(m_hucModeCostsPbFrame));
4749 }
4750
4751 // starting location in batch buffer for each slice
4752 uint32_t baseLocation = m_hwInterface->m_vdencBatchBuffer1stGroupSize + m_hwInterface->m_vdencBatchBuffer2ndGroupSize;
4753 uint32_t currentLocation = baseLocation;
4754
4755 auto slcData = m_slcData;
4756 // HCP_WEIGHTSOFFSETS_STATE + HCP_SLICE_STATE + HCP_PAK_INSERT_OBJECT + VDENC_WEIGHT_OFFSETS_STATE
4757 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
4758 {
4759 auto hevcSlcParams = &m_hevcSliceParams[slcCount];
4760 // HuC FW require unit in Bytes
4761 hucConstData->Slice[slcCount].SizeOfCMDs
4762 = (uint16_t)(m_hwInterface->m_vdencBatchBufferPerSliceConstSize + m_vdencBatchBufferPerSliceVarSize[slcCount]);
4763
4764 // HCP_WEIGHTOFFSET_STATE cmd
4765 if (m_hevcVdencWeightedPredEnabled)
4766 {
4767 // 1st HCP_WEIGHTOFFSET_STATE cmd - P & B
4768 if (hevcSlcParams->slice_type == CODECHAL_ENCODE_HEVC_P_SLICE || hevcSlcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
4769 {
4770 hucConstData->Slice[slcCount].HcpWeightOffsetL0_StartInBytes = (uint16_t)currentLocation; // HCP_WEIGHTOFFSET_L0 starts in byte from beginning of the SLB. 0xFFFF means unavailable in SLB
4771 currentLocation += m_hcpWeightOffsetStateCmdSize;
4772 }
4773
4774 // 2nd HCP_WEIGHTOFFSET_STATE cmd - B
4775 if (hevcSlcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
4776 {
4777 hucConstData->Slice[slcCount].HcpWeightOffsetL1_StartInBytes = (uint16_t)currentLocation; // HCP_WEIGHTOFFSET_L1 starts in byte from beginning of the SLB. 0xFFFF means unavailable in SLB
4778 currentLocation += m_hcpWeightOffsetStateCmdSize;
4779 }
4780 }
4781 else
4782 {
4783 // 0xFFFF means unavailable in SLB
4784 hucConstData->Slice[slcCount].HcpWeightOffsetL0_StartInBytes = 0xFFFF;
4785 hucConstData->Slice[slcCount].HcpWeightOffsetL1_StartInBytes = 0xFFFF;
4786 }
4787
4788 // HCP_SLICE_STATE cmd
4789 hucConstData->Slice[slcCount].SliceState_StartInBytes = (uint16_t)currentLocation; // HCP_WEIGHTOFFSET is not needed
4790 currentLocation += m_hcpSliceStateCmdSize;
4791
4792 // VDENC_WEIGHT_OFFSETS_STATE cmd
4793 hucConstData->Slice[slcCount].VdencWeightOffset_StartInBytes // VdencWeightOffset cmd is the last one expect BatchBufferEnd cmd
4794 = (uint16_t)(baseLocation + hucConstData->Slice[slcCount].SizeOfCMDs - m_vdencWeightOffsetStateCmdSize - m_miBatchBufferEndCmdSize - ENCODE_VDENC_HEVC_PADDING_DW_SIZE * 4);
4795
4796 // logic from PakInsertObject cmd
4797 uint32_t bitSize = (m_hevcSeqParams->SliceSizeControl) ? (hevcSlcParams->BitLengthSliceHeaderStartingPortion) : slcData[slcCount].BitSize; // 40 for HEVC VDEnc Dynamic Slice
4798 uint32_t byteSize = (bitSize + 7) >> 3;
4799 uint32_t sliceHeaderSizeInBytes = (bitSize + 7) >> 3;
4800 // 1st PakInsertObject cmd with AU, SPS, PPS headers only exists for the first slice
4801 if (slcCount == 0)
4802 {
4803 // assumes that there is no 3rd PakInsertObject cmd for SSC
4804 currentLocation += m_1stPakInsertObjectCmdSize;
4805 }
4806
4807 hucConstData->Slice[slcCount].SliceHeaderPIO_StartInBytes = (uint16_t)currentLocation;
4808
4809 // HuC FW requires true slice header size in bits without byte alignment
4810 hucConstData->Slice[slcCount].SliceHeader_SizeInBits = (uint16_t)(sliceHeaderSizeInBytes * 8);
4811 if (!IsFirstPass())
4812 {
4813 PBSBuffer bsBuffer = &m_bsBuffer;
4814 CODECHAL_ENCODE_CHK_NULL_RETURN(bsBuffer);
4815 CODECHAL_ENCODE_CHK_NULL_RETURN(bsBuffer->pBase);
4816 uint8_t *sliceHeaderLastByte = (uint8_t*)(bsBuffer->pBase + slcData[slcCount].SliceOffset + sliceHeaderSizeInBytes - 1);
4817 for (auto i = 0; i < 8; i++)
4818 {
4819 uint8_t mask = 1 << i;
4820 if (*sliceHeaderLastByte & mask)
4821 {
4822 hucConstData->Slice[slcCount].SliceHeader_SizeInBits -= (i + 1);
4823 break;
4824 }
4825 }
4826 }
4827
4828 if (m_hevcVdencWeightedPredEnabled)
4829 {
4830 hucConstData->Slice[slcCount].WeightTable_StartInBits = (uint16_t)hevcSlcParams->PredWeightTableBitOffset;
4831 hucConstData->Slice[slcCount].WeightTable_EndInBits = (uint16_t)(hevcSlcParams->PredWeightTableBitOffset + (hevcSlcParams->PredWeightTableBitLength));
4832 }
4833 else
4834 {
4835 // number of bits from beginning of slice header, 0xffff means not awailable
4836 hucConstData->Slice[slcCount].WeightTable_StartInBits = 0xFFFF;
4837 hucConstData->Slice[slcCount].WeightTable_EndInBits = 0xFFFF;
4838 }
4839
4840 baseLocation += hucConstData->Slice[slcCount].SizeOfCMDs;
4841 currentLocation = baseLocation;
4842 }
4843
4844 if (m_lookaheadDepth > 0)
4845 {
4846 hucConstData->UPD_LA_TargetFulness_U32 = m_targetBufferFulness;
4847
4848 uint8_t QpStrength = (uint8_t)(m_hevcPicParams->QpModulationStrength + (m_hevcPicParams->QpModulationStrength >> 1));
4849 if (!m_initDeltaQP)
4850 {
4851 hucConstData->UPD_deltaQP = (m_prevQpModulationStrength + QpStrength + 1) >> 1;
4852 }
4853 else
4854 {
4855 hucConstData->UPD_deltaQP = QpStrength;
4856
4857 if (IsLastPass())
4858 {
4859 m_initDeltaQP = false;
4860 }
4861 }
4862
4863 m_prevQpModulationStrength = hucConstData->UPD_deltaQP;
4864 }
4865
4866 hucConstData->UPD_TR_TargetSize_U32 = m_hevcPicParams->TargetFrameSize << 3;// byte to bit
4867 hucConstData->UPD_TCBRC_SCENARIO_U8 = m_tcbrcQualityBoost;
4868
4869 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencBrcConstDataBuffer[m_currRecycledBufIdx]);
4870
4871 return eStatus;
4872 }
4873
4874 MOS_STATUS CodechalVdencHevcStateG12::SetDmemHuCBrcUpdate()
4875 {
4876 CODECHAL_ENCODE_FUNCTION_ENTER;
4877
4878 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
4879
4880 MOS_LOCK_PARAMS lockFlagsWriteOnly;
4881 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
4882 lockFlagsWriteOnly.WriteOnly = true;
4883 uint32_t currentPass = m_enableTileReplay ? m_CurrentPassForOverAll : GetCurrentPass();
4884
4885 // Program update DMEM
4886 auto hucVdencBrcUpdateDmem = (PCODECHAL_VDENC_HEVC_HUC_BRC_UPDATE_DMEM_G12)m_osInterface->pfnLockResource(
4887 m_osInterface, &m_vdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][currentPass], &lockFlagsWriteOnly);
4888 CODECHAL_ENCODE_CHK_NULL_RETURN(hucVdencBrcUpdateDmem);
4889 MOS_ZeroMemory(hucVdencBrcUpdateDmem, sizeof(CODECHAL_VDENC_HEVC_HUC_BRC_UPDATE_DMEM_G12));
4890
4891 hucVdencBrcUpdateDmem->TARGETSIZE_U32 = (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW)? m_hevcSeqParams->InitVBVBufferFullnessInBit :
4892 MOS_MIN(m_hevcSeqParams->InitVBVBufferFullnessInBit, m_hevcSeqParams->VBVBufferSizeInBit);
4893 hucVdencBrcUpdateDmem->FrameID_U32 = m_storeData; // frame number
4894 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjFrame_U16, 4 * sizeof(uint16_t), (void*)m_startGAdjFrame, 4 * sizeof(uint16_t));
4895 hucVdencBrcUpdateDmem->TargetSliceSize_U16 = (uint16_t)m_hevcPicParams->MaxSliceSizeInBytes;
4896 auto slbSliceSize = (m_hwInterface->m_vdenc2ndLevelBatchBufferSize - m_hwInterface->m_vdencBatchBuffer1stGroupSize -
4897 m_hwInterface->m_vdencBatchBuffer2ndGroupSize) / ENCODE_HEVC_VDENC_NUM_MAX_SLICES;
4898 hucVdencBrcUpdateDmem->SLB_Data_SizeInBytes = (uint16_t)(slbSliceSize * m_numSlices +
4899 m_hwInterface->m_vdencBatchBuffer1stGroupSize + m_hwInterface->m_vdencBatchBuffer2ndGroupSize);
4900 hucVdencBrcUpdateDmem->PIPE_MODE_SELECT_StartInBytes = 0xFFFF; // HuC need not need to modify the pipe mode select command in Gen11+
4901 hucVdencBrcUpdateDmem->CMD1_StartInBytes = (uint16_t)m_hwInterface->m_vdencBatchBuffer1stGroupSize;
4902 hucVdencBrcUpdateDmem->PIC_STATE_StartInBytes = (uint16_t)m_picStateCmdStartInBytes;
4903 hucVdencBrcUpdateDmem->CMD2_StartInBytes = (uint16_t)m_cmd2StartInBytes;
4904
4905 if (m_prevStoreData != m_storeData)
4906 {
4907 m_prevStoreData = m_storeData;
4908
4909 int32_t oldestIdx = -1;
4910 int32_t selectedSlot = -1;
4911 uint32_t oldestAge = 0;
4912 for (int i = 0; i < CODECHAL_ENCODE_HEVC_VDENC_WP_DATA_BLOCK_NUMBER; i++)
4913 {
4914 if (slotInfo[i].isUsed == true && slotInfo[i].isRef)
4915 {
4916 slotInfo[i].age++;
4917 if (slotInfo[i].age >= oldestAge)
4918 {
4919 oldestAge = slotInfo[i].age;
4920 oldestIdx = i;
4921 }
4922 }
4923 if ((selectedSlot == -1) && (slotInfo[i].isUsed == false || !slotInfo[i].isRef))
4924 {
4925 selectedSlot = i;
4926 }
4927 }
4928
4929 if (selectedSlot == -1)
4930 {
4931 selectedSlot = oldestIdx;
4932 }
4933
4934 if (selectedSlot == -1)
4935 {
4936 CODECHAL_ENCODE_ASSERTMESSAGE("No valid ref slot index");
4937 return MOS_STATUS_INVALID_PARAMETER;
4938 }
4939
4940 slotInfo[selectedSlot].age = 0;
4941 slotInfo[selectedSlot].poc = m_hevcPicParams->CurrPicOrderCnt;
4942 slotInfo[selectedSlot].isUsed = true;
4943 slotInfo[selectedSlot].isRef = m_hevcPicParams->bUsedAsRef;
4944
4945 m_curPicSlot = selectedSlot;
4946 }
4947
4948 hucVdencBrcUpdateDmem->Current_Data_Offset = m_curPicSlot * m_weightHistSize;
4949
4950 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l0_active_minus1; refIdx++)
4951 {
4952 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[LIST_0][refIdx];
4953 auto refPOC = m_hevcPicParams->RefFramePOCList[refPic.FrameIdx];
4954 for (int i = 0; i < CODECHAL_ENCODE_HEVC_VDENC_WP_DATA_BLOCK_NUMBER; i++)
4955 {
4956 if (slotInfo[i].poc == refPOC)
4957 {
4958 hucVdencBrcUpdateDmem->Ref_Data_Offset[refIdx] = i * m_weightHistSize;
4959 break;
4960 }
4961 }
4962 }
4963
4964 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l1_active_minus1; refIdx++)
4965 {
4966 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[LIST_1][refIdx];
4967 auto refPOC = m_hevcPicParams->RefFramePOCList[refPic.FrameIdx];
4968 for (int i = 0; i < CODECHAL_ENCODE_HEVC_VDENC_WP_DATA_BLOCK_NUMBER; i++)
4969 {
4970 if (slotInfo[i].poc == refPOC)
4971 {
4972 hucVdencBrcUpdateDmem->Ref_Data_Offset[refIdx + m_hevcSliceParams->num_ref_idx_l0_active_minus1 + 1] = i * m_weightHistSize;
4973 break;
4974 }
4975 }
4976 }
4977
4978 hucVdencBrcUpdateDmem->MaxNumSliceAllowed_U16 = (uint16_t)GetMaxAllowedSlices(m_hevcSeqParams->Level);
4979
4980 if (m_FrameLevelBRCForTileRow)
4981 {
4982 hucVdencBrcUpdateDmem->OpMode_U8 = 0x4;
4983 }
4984 else if (m_TileRowLevelBRC)
4985 {
4986 hucVdencBrcUpdateDmem->OpMode_U8 = 0x8;
4987 }
4988 else
4989 {
4990 hucVdencBrcUpdateDmem->OpMode_U8 // 1: BRC (including ACQP), 2: Weighted prediction (should not be enabled in first pass)
4991 = (m_hevcVdencWeightedPredEnabled && m_hevcPicParams->bEnableGPUWeightedPrediction && !IsFirstPass()) ? 3 : 1; // 01: BRC, 10: WP never used, 11: BRC + WP
4992 }
4993
4994 bool bAllowedPyramid = m_hevcSeqParams->GopRefDist != 3;
4995
4996 if (m_pictureCodingType == I_TYPE)
4997 {
4998 hucVdencBrcUpdateDmem->CurrentFrameType_U8 = HEVC_BRC_FRAME_TYPE_I;
4999 }
5000 else if (m_hevcSeqParams->HierarchicalFlag && bAllowedPyramid)
5001 {
5002 if (m_hevcPicParams->HierarchLevelPlus1 > 0)
5003 {
5004 std::map<int, HEVC_BRC_FRAME_TYPE> hierchLevelPlus1_to_brclevel{
5005 {1, HEVC_BRC_FRAME_TYPE_P_OR_LB},
5006 {2, HEVC_BRC_FRAME_TYPE_B},
5007 {3, HEVC_BRC_FRAME_TYPE_B1},
5008 {4, HEVC_BRC_FRAME_TYPE_B2}};
5009 hucVdencBrcUpdateDmem->CurrentFrameType_U8 = hierchLevelPlus1_to_brclevel.count(m_hevcPicParams->HierarchLevelPlus1) ? hierchLevelPlus1_to_brclevel[m_hevcPicParams->HierarchLevelPlus1] : HEVC_BRC_FRAME_TYPE_INVALID;
5010 //Invalid HierarchLevelPlus1 or LBD frames at level 3 eror check.
5011 if ((hucVdencBrcUpdateDmem->CurrentFrameType_U8 == HEVC_BRC_FRAME_TYPE_INVALID) ||
5012 (m_hevcSeqParams->LowDelayMode && hucVdencBrcUpdateDmem->CurrentFrameType_U8 == HEVC_BRC_FRAME_TYPE_B2))
5013 {
5014 CODECHAL_ENCODE_ASSERTMESSAGE("HEVC_BRC_FRAME_TYPE_INVALID or LBD picture doesn't support Level 4\n");
5015 return MOS_STATUS_INVALID_PARAMETER;
5016 }
5017 }
5018 else if(!m_hevcSeqParams->LowDelayMode) //RA
5019 {
5020 //if L0/L1 both points to previous frame, then its LBD otherwise its is level 1 RA B.
5021 auto B_or_LDB_brclevel = m_lowDelay ? HEVC_BRC_FRAME_TYPE_P_OR_LB : HEVC_BRC_FRAME_TYPE_B;
5022 std::map<int, HEVC_BRC_FRAME_TYPE> codingtype_to_brclevel{
5023 {P_TYPE, HEVC_BRC_FRAME_TYPE_P_OR_LB},
5024 {B_TYPE, B_or_LDB_brclevel},
5025 {B1_TYPE, HEVC_BRC_FRAME_TYPE_B1},
5026 {B2_TYPE, HEVC_BRC_FRAME_TYPE_B2}};
5027 hucVdencBrcUpdateDmem->CurrentFrameType_U8 = codingtype_to_brclevel.count(m_pictureCodingType) ? codingtype_to_brclevel[m_pictureCodingType] : HEVC_BRC_FRAME_TYPE_INVALID;
5028 //Invalid CodingType.
5029 if (hucVdencBrcUpdateDmem->CurrentFrameType_U8 == HEVC_BRC_FRAME_TYPE_INVALID)
5030 {
5031 CODECHAL_ENCODE_ASSERTMESSAGE("Invalid CodingType\n");
5032 return MOS_STATUS_INVALID_PARAMETER;
5033 }
5034 }
5035 else //LDB
5036 {
5037 hucVdencBrcUpdateDmem->CurrentFrameType_U8 = HEVC_BRC_FRAME_TYPE_P_OR_LB; //No Hierarchical info for LDB, treated as flat case
5038 }
5039 }
5040 else // FlatB or LDB
5041 {
5042 hucVdencBrcUpdateDmem->CurrentFrameType_U8 = m_lowDelay ? HEVC_BRC_FRAME_TYPE_P_OR_LB : HEVC_BRC_FRAME_TYPE_B;
5043 }
5044
5045 // Num_Ref_L1 should be always same as Num_Ref_L0
5046 hucVdencBrcUpdateDmem->Num_Ref_L0_U8 = m_hevcSliceParams->num_ref_idx_l0_active_minus1 + 1;
5047 hucVdencBrcUpdateDmem->Num_Ref_L1_U8 = m_hevcSliceParams->num_ref_idx_l1_active_minus1 + 1;
5048 hucVdencBrcUpdateDmem->Num_Slices = (uint8_t)m_hevcPicParams->NumSlices;
5049
5050 // CQP_QPValue_U8 setting is needed since ACQP is also part of ICQ
5051 hucVdencBrcUpdateDmem->CQP_QPValue_U8 = m_hevcPicParams->QpY + m_hevcSliceParams->slice_qp_delta;
5052 hucVdencBrcUpdateDmem->CQP_FracQP_U8 = 0;
5053 if (m_hevcPicParams->BRCPrecision == 1)
5054 {
5055 hucVdencBrcUpdateDmem->MaxNumPass_U8 = 1;
5056 }
5057 else
5058 {
5059 hucVdencBrcUpdateDmem->MaxNumPass_U8 = CODECHAL_VDENC_BRC_NUM_OF_PASSES;
5060 }
5061
5062 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->gRateRatioThreshold_U8, 7 * sizeof(uint8_t), (void*)m_rateRatioThreshold, 7 * sizeof(uint8_t));
5063 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjMult_U8, 5 * sizeof(uint8_t), (void*)m_startGAdjMult, 5 * sizeof(uint8_t));
5064 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->startGAdjDiv_U8, 5 * sizeof(uint8_t), (void*)m_startGAdjDiv, 5 * sizeof(uint8_t));
5065 MOS_SecureMemcpy(hucVdencBrcUpdateDmem->gRateRatioThresholdQP_U8, 8 * sizeof(uint8_t), (void*)m_rateRatioThresholdQP, 8 * sizeof(uint8_t));
5066
5067 hucVdencBrcUpdateDmem->IPAverageCoeff_U8 = (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) ? 0 : 64;
5068 hucVdencBrcUpdateDmem->CurrentPass_U8 = (uint8_t)currentPass;
5069
5070 if ((m_hevcVdencAcqpEnabled && m_hevcSeqParams->QpAdjustment) || (m_brcEnabled && (m_hevcSeqParams->MBBRC != 2)))
5071 {
5072 hucVdencBrcUpdateDmem->DeltaQPForSadZone0_S8 = -1;
5073 hucVdencBrcUpdateDmem->DeltaQPForSadZone1_S8 = 0;
5074 hucVdencBrcUpdateDmem->DeltaQPForSadZone2_S8 = 1;
5075 hucVdencBrcUpdateDmem->DeltaQPForSadZone3_S8 = 2;
5076 hucVdencBrcUpdateDmem->DeltaQPForMvZero_S8 = 3;
5077 hucVdencBrcUpdateDmem->DeltaQPForMvZone0_S8 = -2;
5078 hucVdencBrcUpdateDmem->DeltaQPForMvZone1_S8 = 0;
5079 hucVdencBrcUpdateDmem->DeltaQPForMvZone2_S8 = 2;
5080 }
5081
5082 if (m_hevcVdencWeightedPredEnabled)
5083 {
5084 hucVdencBrcUpdateDmem->LumaLog2WeightDenom_S8 = 6;
5085 hucVdencBrcUpdateDmem->ChromaLog2WeightDenom_S8 = 6;
5086 }
5087
5088 // chroma weights are not confirmed to be supported from HW team yet
5089 hucVdencBrcUpdateDmem->DisabledFeature_U8 = 0; // bit mask, 1 (bit0): disable chroma weight setting
5090
5091 hucVdencBrcUpdateDmem->SlidingWindow_Enable_U8 = (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_LOW);
5092 hucVdencBrcUpdateDmem->LOG_LCU_Size_U8 = 6;
5093 hucVdencBrcUpdateDmem->ReEncodePositiveQPDeltaThr_S8 = 4;
5094 hucVdencBrcUpdateDmem->ReEncodeNegativeQPDeltaThr_S8 = -5;
5095 hucVdencBrcUpdateDmem->SceneChgPrevIntraPctThreshold_U8 = 96;
5096 hucVdencBrcUpdateDmem->SceneChgCurIntraPctThreshold_U8 = 192;
5097
5098 // SCC is in conflict with PAK only pass
5099 if (m_enableSCC)
5100 {
5101 hucVdencBrcUpdateDmem->ReEncodePositiveQPDeltaThr_S8 = 0;
5102 hucVdencBrcUpdateDmem->ReEncodeNegativeQPDeltaThr_S8 = 0;
5103 }
5104
5105 // reset skip frame statistics
5106 m_numSkipFrames = 0;
5107 m_sizeSkipFrames = 0;
5108
5109 // For tile row based BRC
5110 if (m_TileRowLevelBRC)
5111 {
5112 hucVdencBrcUpdateDmem->MaxNumTileHuCCallMinus1 = m_hevcPicParams->num_tile_rows_minus1;
5113 hucVdencBrcUpdateDmem->TileHucCallIndex = (uint8_t)m_CurrentTileRow;
5114 hucVdencBrcUpdateDmem->TileHuCCallPassIndex = m_CurrentPassForTileReplay + 1;
5115 hucVdencBrcUpdateDmem->TileHuCCallPassMax = m_NumPassesForTileReplay;
5116
5117 // Need change App to pass real max bit rate rather than to enlarge it with 1000
5118 if (m_hevcSeqParams->FrameRate.Numerator)
5119 {
5120 hucVdencBrcUpdateDmem->TxSizeInBitsPerFrame = (uint32_t)(((uint32_t)m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS *
5121 m_hevcSeqParams->FrameRate.Denominator + (m_hevcSeqParams->FrameRate.Numerator >> 1)) /
5122 m_hevcSeqParams->FrameRate.Numerator);
5123 }
5124 else
5125 {
5126 hucVdencBrcUpdateDmem->TxSizeInBitsPerFrame = (uint32_t)(((uint32_t)m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS + 15) / 30);
5127 }
5128
5129 uint32_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
5130 uint32_t startIdx = m_CurrentTileRow * numTileColumns;
5131 uint32_t endIdx = startIdx + numTileColumns - 1;
5132 uint32_t LCUsInTile = 0;
5133
5134 for (uint32_t idx = 0; idx < numTileColumns; idx ++)
5135 {
5136 LCUsInTile += m_hevcPicParams->tile_row_height[m_CurrentTileRow] * m_hevcPicParams->tile_column_width[idx];
5137 }
5138
5139 hucVdencBrcUpdateDmem->StartTileIdx = (uint8_t)startIdx;
5140 hucVdencBrcUpdateDmem->EndTileIdx = (uint8_t)endIdx;
5141 hucVdencBrcUpdateDmem->TileSizeInLCU = (uint16_t)LCUsInTile;
5142 }
5143 else if (m_FrameLevelBRCForTileRow)
5144 {
5145 hucVdencBrcUpdateDmem->MaxNumTileHuCCallMinus1 = m_hevcPicParams->num_tile_rows_minus1;
5146 hucVdencBrcUpdateDmem->TileHucCallIndex = 0;
5147 hucVdencBrcUpdateDmem->TileHuCCallPassIndex = 0;
5148 hucVdencBrcUpdateDmem->TileHuCCallPassMax = m_NumPassesForTileReplay;
5149
5150 // Need change App to pass real max bit rate rather than to enlarge it with 1000
5151 if (m_hevcSeqParams->FrameRate.Numerator)
5152 {
5153 hucVdencBrcUpdateDmem->TxSizeInBitsPerFrame = (uint32_t)(((uint32_t)m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS *
5154 m_hevcSeqParams->FrameRate.Denominator + (m_hevcSeqParams->FrameRate.Numerator >> 1)) /
5155 m_hevcSeqParams->FrameRate.Numerator);
5156 }
5157 else
5158 {
5159 hucVdencBrcUpdateDmem->TxSizeInBitsPerFrame = (uint32_t)(((uint32_t)m_hevcSeqParams->MaxBitRate * CODECHAL_ENCODE_BRC_KBPS + 15) / 30);
5160 }
5161 }
5162
5163 // Long term reference
5164 hucVdencBrcUpdateDmem->IsLongTermRef = CodecHal_PictureIsLongTermRef(m_currReconstructedPic);
5165 hucVdencBrcUpdateDmem->UPD_CQMEnabled_U8 = m_hevcSeqParams->scaling_list_enable_flag || m_hevcPicParams->scaling_list_data_present_flag;
5166
5167 if (m_lookaheadDepth > 0)
5168 {
5169 hucVdencBrcUpdateDmem->EnableLookAhead = 1;
5170 }
5171 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][currentPass]);
5172
5173 return eStatus;
5174 }
5175
5176 MOS_STATUS CodechalVdencHevcStateG12::SetRegionsHuCBrcUpdate(PMHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams)
5177 {
5178 CODECHAL_ENCODE_FUNCTION_ENTER;
5179
5180 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5181
5182 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::SetRegionsHuCBrcUpdate(virtualAddrParams));
5183
5184 // With multiple tiles, ensure that HuC BRC kernel is fed with vdenc frame level statistics from HuC PAK Int kernel
5185 // Applicable for scalable/ non-scalable mode
5186 if (m_hevcPicParams->tiles_enabled_flag)
5187 {
5188 virtualAddrParams->regionParams[1].presRegion = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Region 1 VDEnc Statistics Buffer (Input) - VDENC_HEVC_VP9_FRAME_BASED_STATISTICS_STREAMOUT
5189 virtualAddrParams->regionParams[1].dwOffset = m_hevcFrameStatsOffset.uiVdencStatistics;
5190 }
5191
5192 if (m_numPipe > 1)
5193 {
5194 virtualAddrParams->regionParams[2].presRegion = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Region 2 PAK Statistics Buffer (Input) - MFX_PAK_FRAME_STATISTICS
5195 virtualAddrParams->regionParams[2].dwOffset = m_hevcFrameStatsOffset.uiHevcPakStatistics;
5196 virtualAddrParams->regionParams[7].presRegion = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Region 7 Slice Stat Streamout (Input)
5197 virtualAddrParams->regionParams[7].dwOffset = m_hevcFrameStatsOffset.uiHevcSliceStreamout;
5198 // In scalable-mode, use PAK Integration kernel output to get bistream size
5199 virtualAddrParams->regionParams[8].presRegion = &m_resBrcDataBuffer;
5200 }
5201
5202 // Tile reset case, use previous frame BRC data
5203 if ((m_numPipe != m_numPipePre) && IsFirstPass())
5204 {
5205 if (m_numPipePre > 1)
5206 {
5207 virtualAddrParams->regionParams[8].presRegion = &m_resBrcDataBuffer;
5208 }
5209 else
5210 {
5211 virtualAddrParams->regionParams[8].presRegion = (MOS_RESOURCE*)m_allocator->GetResource(m_standard, pakInfo);
5212 }
5213 }
5214
5215 return eStatus;
5216 }
5217
5218 MOS_STATUS CodechalVdencHevcStateG12::SetRegionsHuCTileRowBrcUpdate(PMHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams)
5219 {
5220 CODECHAL_ENCODE_FUNCTION_ENTER;
5221
5222 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5223
5224 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::SetRegionsHuCBrcUpdate(virtualAddrParams));
5225
5226 // For tile replay, the tile based statistics is directly passed to HUC kernel
5227 virtualAddrParams->regionParams[1].presRegion = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource; // Region 1 � VDEnc Statistics Buffer (Input)
5228 virtualAddrParams->regionParams[1].dwOffset = m_hevcTileStatsOffset.uiVdencStatistics;
5229
5230 virtualAddrParams->regionParams[2].presRegion = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource; // Region 2 � PAK Statistics Buffer (Input)
5231 virtualAddrParams->regionParams[2].dwOffset = m_hevcTileStatsOffset.uiHevcPakStatistics;
5232
5233 virtualAddrParams->regionParams[7].presRegion = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource; // Region 7 � Slice Stat Streamout (Input)
5234 virtualAddrParams->regionParams[7].dwOffset = m_hevcTileStatsOffset.uiHevcSliceStreamout;
5235
5236 virtualAddrParams->regionParams[12].presRegion = &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource; // Region 12 � Tile encoded information (Input)
5237
5238 return eStatus;
5239 }
5240
5241 void CodechalVdencHevcStateG12::SetHcpSliceStateCommonParams(MHW_VDBOX_HEVC_SLICE_STATE& sliceStateParams)
5242 {
5243 CODECHAL_ENCODE_FUNCTION_ENTER;
5244
5245 CodechalVdencHevcState::SetHcpSliceStateCommonParams(sliceStateParams);
5246
5247 static_cast<MHW_VDBOX_HEVC_SLICE_STATE_G12 &>(sliceStateParams).dwNumPipe = m_numPipe;
5248
5249 if (m_enableSCC)
5250 {
5251 static_cast<MHW_VDBOX_HEVC_SLICE_STATE_G12 &>(sliceStateParams).ucRecNotFilteredID = m_slotForRecNotFiltered;
5252 }
5253 }
5254
5255 void CodechalVdencHevcStateG12::SetHcpSliceStateParams(
5256 MHW_VDBOX_HEVC_SLICE_STATE& sliceState,
5257 PCODEC_ENCODER_SLCDATA slcData,
5258 uint16_t slcCount,
5259 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileCodingParams,
5260 bool lastSliceInTile,
5261 uint32_t idx)
5262 {
5263 CODECHAL_ENCODE_FUNCTION_ENTER;
5264
5265 CodechalEncodeHevcBase::SetHcpSliceStateParams(sliceState, slcData, slcCount);
5266
5267 sliceState.bLastSliceInTile = lastSliceInTile ? true : false;
5268 sliceState.bLastSliceInTileColumn = (lastSliceInTile & tileCodingParams[idx].IsLastTileofColumn) ? true : false;
5269 static_cast<MHW_VDBOX_HEVC_SLICE_STATE_G12&>(sliceState).pTileCodingParams = tileCodingParams + idx;
5270 static_cast<MHW_VDBOX_HEVC_SLICE_STATE_G12&>(sliceState).dwTileID = idx;
5271
5272 // update pass status
5273 if (m_enableTileReplay && m_FrameLevelBRCForTileRow)
5274 {
5275 sliceState.bFirstPass = true;
5276 sliceState.bLastPass = false;
5277 }
5278 else if (m_enableTileReplay && m_TileRowLevelBRC)
5279 {
5280 sliceState.bFirstPass = IsFirstPassForTileReplay();
5281 sliceState.bLastPass = IsLastPassForTileReplay();
5282 }
5283 }
5284
5285 void CodechalVdencHevcStateG12::SetHcpPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS& vdboxPipeModeSelectParams)
5286 {
5287 CODECHAL_ENCODE_FUNCTION_ENTER;
5288
5289 CodechalEncodeHevcBase::SetHcpPipeModeSelectParams(vdboxPipeModeSelectParams);
5290
5291 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12& pipeModeSelectParams = static_cast<MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12&>(vdboxPipeModeSelectParams);
5292
5293 if (m_numPipe > 1)
5294 {
5295 // Running in the multiple VDBOX mode
5296 if (IsFirstPipe())
5297 {
5298 pipeModeSelectParams.MultiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_LEFT;
5299 }
5300 else if (IsLastPipe())
5301 {
5302 pipeModeSelectParams.MultiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_RIGHT;
5303 }
5304 else
5305 {
5306 pipeModeSelectParams.MultiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_MIDDLE;
5307 }
5308 pipeModeSelectParams.PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_CODEC_BE;
5309 }
5310 else
5311 {
5312 pipeModeSelectParams.MultiEngineMode = MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY;
5313 pipeModeSelectParams.PipeWorkMode = MHW_VDBOX_HCP_PIPE_WORK_MODE_LEGACY;
5314 }
5315
5316 // In single pipe mode, if TileBasedReplayMode is enabled, the bit stream for each tile will not be continuous
5317 if (m_hevcPicParams->tiles_enabled_flag)
5318 {
5319 pipeModeSelectParams.bTileBasedReplayMode = m_enableTileReplay;
5320 }
5321 else
5322 {
5323 pipeModeSelectParams.bTileBasedReplayMode = 0;
5324 }
5325
5326 // To enable VDENC/PAK statistics stream out for BRC only
5327 // Is stream out needed for ACQP? check this out!
5328 pipeModeSelectParams.bBRCEnabled = m_hevcVdencAcqpEnabled || m_vdencBrcEnabled;
5329 }
5330
5331 void CodechalVdencHevcStateG12::SetVdencPipeModeSelectParams(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS& vdboxPipeModeSelectParams)
5332 {
5333 CODECHAL_ENCODE_FUNCTION_ENTER;
5334
5335 CodechalVdencHevcState::SetVdencPipeModeSelectParams(vdboxPipeModeSelectParams);
5336
5337 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12& pipeModeSelectParams = static_cast<MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12&>(vdboxPipeModeSelectParams);
5338
5339 // Enable RGB encoding
5340 pipeModeSelectParams.bRGBEncodingMode = m_RGBEncodingEnable;
5341
5342 // Capture mode enable
5343 pipeModeSelectParams.bWirelessEncodeEnabled = m_CaptureModeEnable;
5344 pipeModeSelectParams.ucWirelessSessionId = 0;
5345
5346 // Set random access flag
5347 pipeModeSelectParams.bIsRandomAccess = !m_lowDelay;
5348
5349 // Set lookahead pass flag
5350 pipeModeSelectParams.bLookaheadPass = m_lookaheadPass;
5351
5352 #ifdef _MEDIA_RESERVED
5353 if (m_rsvdState)
5354 {
5355 m_rsvdState->SetVdencPipeModeSelectParams(pipeModeSelectParams);
5356 }
5357 #endif
5358
5359 if (m_enableSCC && (m_hevcPicParams->pps_curr_pic_ref_enabled_flag || m_hevcSeqParams->palette_mode_enabled_flag))
5360 {
5361 pipeModeSelectParams.bVdencPakObjCmdStreamOutEnable = false;
5362 }
5363 }
5364
5365 void CodechalVdencHevcStateG12::SetHcpPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& pipeBufAddrParams)
5366 {
5367 CODECHAL_ENCODE_FUNCTION_ENTER;
5368
5369 CodechalEncodeHevcBase::SetHcpPipeBufAddrParams(pipeBufAddrParams);
5370
5371 //set MMC flag
5372 if (m_mmcState->IsMmcEnabled())
5373 {
5374 pipeBufAddrParams.bMmcEnabled = true;
5375 }
5376
5377 PCODECHAL_ENCODE_BUFFER tileStatisticsBuffer = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex];
5378 if (!Mos_ResourceIsNull(&tileStatisticsBuffer->sResource) && (m_numPipe > 1))
5379 {
5380 pipeBufAddrParams.presLcuBaseAddressBuffer = &tileStatisticsBuffer->sResource;
5381 pipeBufAddrParams.dwLcuStreamOutOffset = m_hevcTileStatsOffset.uiHevcSliceStreamout;
5382 pipeBufAddrParams.presFrameStatStreamOutBuffer = &tileStatisticsBuffer->sResource;
5383 pipeBufAddrParams.dwFrameStatStreamOutOffset = m_hevcTileStatsOffset.uiHevcPakStatistics;
5384 }
5385
5386 // SAO Row Store is GEN12 specific
5387 pipeBufAddrParams.presSaoRowStoreBuffer = &m_vdencSAORowStoreBuffer;
5388
5389 // Set up the recon not filtered surface for IBC
5390 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
5391 {
5392 // I frame is much simpler
5393 if (m_pictureCodingType == I_TYPE)
5394 {
5395 pipeBufAddrParams.presReferences[0] = &m_vdencRecNotFilteredBuffer;
5396 m_slotForRecNotFiltered = 0;
5397 }
5398 // B frame
5399 else
5400 {
5401 unsigned int i;
5402 // Find one available slot
5403 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
5404 {
5405 if (pipeBufAddrParams.presReferences[i] == nullptr)
5406 {
5407 break;
5408 }
5409 }
5410
5411 CODECHAL_ENCODE_ASSERT(i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC);
5412
5413 //record the slot for HCP_REF_IDX_STATE
5414 m_slotForRecNotFiltered = (unsigned char)i;
5415 pipeBufAddrParams.presReferences[i] = &m_vdencRecNotFilteredBuffer;
5416 }
5417 }
5418 }
5419
5420 void CodechalVdencHevcStateG12::SetHcpPicStateParams(MHW_VDBOX_HEVC_PIC_STATE& picStateParams)
5421 {
5422 CODECHAL_ENCODE_FUNCTION_ENTER;
5423
5424 CodechalEncodeHevcBase::SetHcpPicStateParams(picStateParams);
5425 if (m_enableSCC)
5426 {
5427 MHW_VDBOX_HEVC_PIC_STATE_G12& picStateParamsGen12 = dynamic_cast<MHW_VDBOX_HEVC_PIC_STATE_G12&>(picStateParams);
5428 picStateParamsGen12.ucRecNotFilteredID = m_slotForRecNotFiltered;
5429 picStateParamsGen12.IBCControl = m_enableLBCOnly ? SCC_IBC_CONTROL_IBC_ONLY_LBC_G12 : SCC_IBC_CONTROL_IBC_ENABLED_TBCLBC_G12;
5430 }
5431 }
5432
5433 MOS_STATUS CodechalVdencHevcStateG12::AddHcpRefIdxCmd(
5434 PMOS_COMMAND_BUFFER cmdBuffer,
5435 PMHW_BATCH_BUFFER batchBuffer,
5436 PMHW_VDBOX_HEVC_SLICE_STATE params)
5437 {
5438 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5439
5440 CODECHAL_ENCODE_FUNCTION_ENTER;
5441
5442 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
5443 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pEncodeHevcSliceParams);
5444 CODECHAL_ENCODE_CHK_NULL_RETURN(params->pEncodeHevcPicParams);
5445
5446 if (cmdBuffer == nullptr && batchBuffer == nullptr)
5447 {
5448 CODECHAL_ENCODE_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
5449 return MOS_STATUS_NULL_POINTER;
5450 }
5451
5452 PCODEC_HEVC_ENCODE_PICTURE_PARAMS hevcPicParams = params->pEncodeHevcPicParams;
5453 PCODEC_HEVC_ENCODE_SLICE_PARAMS hevcSlcParams = params->pEncodeHevcSliceParams;
5454
5455 if ((hevcPicParams->pps_curr_pic_ref_enabled_flag) || (hevcSlcParams->slice_type != CODECHAL_ENCODE_HEVC_I_SLICE))
5456 {
5457 MHW_VDBOX_HEVC_REF_IDX_PARAMS_G12 refIdxParams;
5458
5459 refIdxParams.CurrPic = hevcPicParams->CurrReconstructedPic;
5460 refIdxParams.isEncode = true;
5461 refIdxParams.ucList = LIST_0;
5462 refIdxParams.ucNumRefForList = hevcSlcParams->num_ref_idx_l0_active_minus1 + 1;
5463 eStatus = MOS_SecureMemcpy(&refIdxParams.RefPicList, sizeof(refIdxParams.RefPicList),
5464 &hevcSlcParams->RefPicList, sizeof(hevcSlcParams->RefPicList));
5465 if (eStatus != MOS_STATUS_SUCCESS)
5466 {
5467 CODECHAL_ENCODE_ASSERTMESSAGE("Failed to copy memory.");
5468 return eStatus;
5469 }
5470
5471 refIdxParams.hevcRefList = (void**)m_refList;
5472 refIdxParams.poc_curr_pic = hevcPicParams->CurrPicOrderCnt;
5473 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
5474 {
5475 refIdxParams.poc_list[i] = hevcPicParams->RefFramePOCList[i];
5476 }
5477
5478 refIdxParams.pRefIdxMapping = params->pRefIdxMapping;
5479 refIdxParams.RefFieldPicFlag = 0; // there is no interlaced support in encoder
5480 refIdxParams.RefBottomFieldFlag = 0; // there is no interlaced support in encoder
5481
5482 if (m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
5483 {
5484 refIdxParams.bIBCEnabled = true;
5485 refIdxParams.ucRecNotFilteredID = m_slotForRecNotFiltered;
5486
5487 if ((m_hevcPicParams->CodingType == I_TYPE) && (m_hevcSliceParams->slice_type == MhwVdboxHcpInterface::hevcSliceP))
5488 {
5489 refIdxParams.ucNumRefForList = 0;
5490 }
5491 }
5492
5493 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(cmdBuffer, batchBuffer, &refIdxParams));
5494
5495 if (hevcSlcParams->slice_type == CODECHAL_ENCODE_HEVC_B_SLICE)
5496 {
5497 refIdxParams.ucList = LIST_1;
5498 refIdxParams.ucNumRefForList = hevcSlcParams->num_ref_idx_l1_active_minus1 + 1;
5499 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpRefIdxStateCmd(cmdBuffer, batchBuffer, &refIdxParams));
5500 }
5501 }
5502
5503 return eStatus;
5504 }
5505
5506 void CodechalVdencHevcStateG12::SetVdencPipeBufAddrParams(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS& pipeBufAddrParams)
5507 {
5508 CODECHAL_ENCODE_FUNCTION_ENTER;
5509
5510 CodechalVdencHevcState::SetVdencPipeBufAddrParams(pipeBufAddrParams);
5511
5512 PCODECHAL_ENCODE_BUFFER tileStatisticsBuffer = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex];
5513 if (!Mos_ResourceIsNull(&tileStatisticsBuffer->sResource))
5514 {
5515 pipeBufAddrParams.presVdencStreamOutBuffer = &tileStatisticsBuffer->sResource;
5516 pipeBufAddrParams.dwVdencStatsStreamOutOffset = m_hevcTileStatsOffset.uiVdencStatistics;
5517 }
5518
5519 // Set up the recon not filtered surface for IBC
5520 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
5521 {
5522 // I frame is much simpler
5523 if (m_pictureCodingType == I_TYPE)
5524 {
5525 pipeBufAddrParams.presVdencReferences[0] = &m_vdencRecNotFilteredBuffer;
5526 }
5527 // LDB
5528 else
5529 {
5530 unsigned int i;
5531
5532 // Find one available slot
5533 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
5534 {
5535 if (pipeBufAddrParams.presVdencReferences[i] == nullptr)
5536 {
5537 break;
5538 }
5539 }
5540
5541 CODECHAL_ENCODE_ASSERT(i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC);
5542 if (i != 0)
5543 {
5544 pipeBufAddrParams.dwNumRefIdxL0ActiveMinus1 += 1;
5545 }
5546 pipeBufAddrParams.presVdencReferences[i] = &m_vdencRecNotFilteredBuffer;
5547 }
5548 }
5549
5550 pipeBufAddrParams.presVdencTileRowStoreBuffer = &m_vdencTileRowStoreBuffer;
5551 pipeBufAddrParams.presVdencCumulativeCuCountStreamoutSurface = &m_vdencCumulativeCuCountStreamoutSurface;
5552 pipeBufAddrParams.isLowDelayB = m_lowDelay;
5553 }
5554
5555 MOS_STATUS CodechalVdencHevcStateG12::SetKernelParams(
5556 EncOperation operation,
5557 MHW_KERNEL_PARAM *kernelParams)
5558 {
5559 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5560
5561 CODECHAL_ENCODE_FUNCTION_ENTER;
5562
5563 CODECHAL_ENCODE_CHK_NULL_RETURN(kernelParams);
5564
5565 auto curbeAlignment = m_stateHeapInterface->pStateHeapInterface->GetCurbeAlignment();
5566
5567 kernelParams->iThreadCount = m_renderEngineInterface->GetHwCaps()->dwMaxThreads;
5568 kernelParams->iIdCount = 1;
5569
5570 switch (operation)
5571 {
5572 case VDENC_ME_P:
5573 case VDENC_ME_B:
5574 case VDENC_STREAMIN:
5575 case VDENC_STREAMIN_HEVC:
5576 case VDENC_STREAMIN_HEVC_RAB:
5577 kernelParams->iBTCount = CODECHAL_VDENC_HME_END_G12 - CODECHAL_VDENC_HME_BEGIN_G12;
5578 kernelParams->iCurbeLength = MOS_ALIGN_CEIL(sizeof(MEDIA_OBJECT_HEVC_VP9_VDENC_ME_CURBE_G12), (size_t)curbeAlignment);
5579 kernelParams->iBlockWidth = 32;
5580 kernelParams->iBlockHeight = 32;
5581 break;
5582 default:
5583 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
5584 eStatus = MOS_STATUS_INVALID_PARAMETER;
5585 }
5586
5587 return eStatus;
5588 }
5589
5590 MOS_STATUS CodechalVdencHevcStateG12::SetBindingTable(
5591 EncOperation operation,
5592 PCODECHAL_ENCODE_BINDING_TABLE_GENERIC bindingTable)
5593 {
5594 CODECHAL_ENCODE_FUNCTION_ENTER;
5595
5596 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5597
5598 CODECHAL_ENCODE_CHK_NULL_RETURN(bindingTable);
5599
5600 MOS_ZeroMemory(bindingTable, sizeof(*bindingTable));
5601
5602 switch (operation)
5603 {
5604 case VDENC_ME_P:
5605 case VDENC_ME_B:
5606 case VDENC_STREAMIN:
5607 case VDENC_STREAMIN_HEVC:
5608 case VDENC_STREAMIN_HEVC_RAB:
5609 bindingTable->dwNumBindingTableEntries = CODECHAL_VDENC_HME_END_G12 - CODECHAL_VDENC_HME_BEGIN_G12;
5610 bindingTable->dwBindingTableStartOffset = CODECHAL_VDENC_HME_BEGIN_G12;
5611 break;
5612 default:
5613 CODECHAL_ENCODE_ASSERTMESSAGE("Unsupported ENC mode requested");
5614 return MOS_STATUS_INVALID_PARAMETER;
5615 }
5616
5617 for (uint32_t i = 0; i < bindingTable->dwNumBindingTableEntries; i++)
5618 {
5619 bindingTable->dwBindingTableEntries[i] = i;
5620 }
5621 return eStatus;
5622 }
5623
5624 MOS_STATUS CodechalVdencHevcStateG12::EncodeMeKernel(HmeLevel hmeLevel)
5625 {
5626 CODECHAL_ENCODE_FUNCTION_ENTER;
5627
5628 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5629
5630 PMHW_KERNEL_STATE kernelState = nullptr;
5631 if(hmeLevel == HME_LEVEL_4x)
5632 {
5633 kernelState = m_lowDelay ? &m_vdencStreaminKernelState : &m_vdencStreaminKernelStateRAB;
5634 }
5635 else
5636 {
5637 kernelState = m_lowDelay ? &m_vdencMeKernelState : &m_vdencMeKernelStateRAB;
5638 }
5639 auto encFunctionType = (hmeLevel == HME_LEVEL_32x) ? CODECHAL_MEDIA_STATE_32X_ME :
5640 (hmeLevel == HME_LEVEL_16x) ? CODECHAL_MEDIA_STATE_16X_ME : CODECHAL_MEDIA_STATE_4X_ME;
5641
5642 // If Single Task Phase is not enabled, use BT count for the kernel state.
5643 if (m_firstTaskInPhase || !m_singleTaskPhaseSupported)
5644 {
5645 uint32_t maxBtCount = m_singleTaskPhaseSupported ?
5646 m_maxBtCount : kernelState->KernelParams.iBTCount;
5647 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnRequestSshSpaceForCmdBuf(
5648 m_stateHeapInterface,
5649 maxBtCount));
5650 m_vmeStatesSize = m_hwInterface->GetKernelLoadCommandSize(maxBtCount);
5651 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
5652 }
5653
5654 // Set up the DSH/SSH as normal
5655 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->AssignDshAndSshSpace(
5656 m_stateHeapInterface,
5657 kernelState,
5658 false,
5659 0,
5660 false,
5661 m_storeData));
5662
5663 MHW_INTERFACE_DESCRIPTOR_PARAMS idParams;
5664 MOS_ZeroMemory(&idParams, sizeof(idParams));
5665 idParams.pKernelState = kernelState;
5666 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetInterfaceDescriptor(
5667 m_stateHeapInterface,
5668 1,
5669 &idParams));
5670
5671 //Setup curbe for StreamIn Kernel
5672 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetMeCurbe(hmeLevel));
5673
5674 CODECHAL_DEBUG_TOOL(
5675 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
5676 encFunctionType,
5677 MHW_DSH_TYPE,
5678 kernelState));
5679 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCurbe(
5680 encFunctionType,
5681 kernelState));
5682 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
5683 encFunctionType,
5684 MHW_ISH_TYPE,
5685 kernelState));
5686 )
5687
5688 MOS_COMMAND_BUFFER cmdBuffer;
5689 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &cmdBuffer, 0));
5690
5691 SendKernelCmdsParams sendKernelCmdsParams = SendKernelCmdsParams();
5692 sendKernelCmdsParams.EncFunctionType = encFunctionType;
5693 sendKernelCmdsParams.pKernelState = kernelState;
5694 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendGenericKernelCmds(&cmdBuffer, &sendKernelCmdsParams));
5695
5696 // Add binding table
5697 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnSetBindingTable(
5698 m_stateHeapInterface,
5699 kernelState));
5700
5701 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendMeSurfaces(hmeLevel, &cmdBuffer));
5702
5703 // Dump SSH for ME kernel
5704 CODECHAL_DEBUG_TOOL(
5705 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpKernelRegion(
5706 encFunctionType,
5707 MHW_SSH_TYPE,
5708 kernelState)));
5709
5710 uint32_t scalingFactor = (hmeLevel == HME_LEVEL_32x) ? SCALE_FACTOR_32x :
5711 (hmeLevel == HME_LEVEL_16x) ? SCALE_FACTOR_16x : SCALE_FACTOR_4x;
5712
5713 uint32_t resolutionX = CODECHAL_GET_WIDTH_IN_MACROBLOCKS(m_frameWidth / scalingFactor);
5714 uint32_t resolutionY = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight / scalingFactor);
5715
5716 CODECHAL_WALKER_CODEC_PARAMS walkerCodecParams;
5717 MOS_ZeroMemory(&walkerCodecParams, sizeof(walkerCodecParams));
5718 walkerCodecParams.WalkerMode = m_walkerMode;
5719 walkerCodecParams.dwResolutionX = resolutionX;
5720 walkerCodecParams.dwResolutionY = resolutionY;
5721 walkerCodecParams.bNoDependency = true;
5722 walkerCodecParams.bMbaff = false;
5723 walkerCodecParams.bGroupIdSelectSupported = m_groupIdSelectSupported;
5724 walkerCodecParams.ucGroupId = m_groupId;
5725
5726 MHW_WALKER_PARAMS walkerParams;
5727 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalInitMediaObjectWalkerParams(
5728 m_hwInterface,
5729 &walkerParams,
5730 &walkerCodecParams));
5731
5732 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaObjectWalkerCmd(
5733 &cmdBuffer,
5734 &walkerParams));
5735
5736 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, encFunctionType));
5737
5738 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
5739 {
5740 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_stateHeapInterface->pfnUpdateGlobalCmdBufId(
5741 m_stateHeapInterface));
5742 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
5743 }
5744
5745 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
5746 &cmdBuffer,
5747 encFunctionType,
5748 nullptr)));
5749
5750 m_hwInterface->UpdateSSEuForCmdBuffer(&cmdBuffer, m_singleTaskPhaseSupported, m_lastTaskInPhase);
5751
5752 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &cmdBuffer, 0);
5753
5754 MHW_MI_STORE_DATA_PARAMS storeDataParams;
5755
5756 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
5757 {
5758 m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &cmdBuffer, m_renderContextUsesNullHw);
5759 m_lastTaskInPhase = false;
5760 }
5761 return eStatus;
5762 }
5763
5764 MOS_STATUS CodechalVdencHevcStateG12::SetMeCurbe(HmeLevel hmeLevel)
5765 {
5766 CODECHAL_ENCODE_FUNCTION_ENTER;
5767
5768 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5769
5770 CODECHAL_VDENC_HEVC_ME_CURBE_G12 curbe;
5771 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(
5772 &curbe,
5773 sizeof(CODECHAL_VDENC_HEVC_ME_CURBE_G12),
5774 ME_CURBE_INIT_G12,
5775 sizeof(CODECHAL_VDENC_HEVC_ME_CURBE_G12)));
5776
5777 PMHW_KERNEL_STATE kernelState = nullptr;
5778 if(hmeLevel == HME_LEVEL_4x)
5779 {
5780 kernelState = m_lowDelay ? &m_vdencStreaminKernelState : &m_vdencStreaminKernelStateRAB;
5781 }
5782 else
5783 {
5784 kernelState = m_lowDelay ? &m_vdencMeKernelState : &m_vdencMeKernelStateRAB;
5785 }
5786
5787 bool useMvFromPrevStep;
5788 bool writeDistortions;
5789 uint32_t scaleFactor;
5790 uint32_t mvShiftFactor = 0;
5791 uint32_t prevMvReadPosFactor = 0;
5792
5793 switch (hmeLevel)
5794 {
5795 case HME_LEVEL_32x:
5796 useMvFromPrevStep = false;
5797 writeDistortions = false;
5798 scaleFactor = SCALE_FACTOR_32x;
5799 mvShiftFactor = 1;
5800 prevMvReadPosFactor = 0;
5801 break;
5802 case HME_LEVEL_16x:
5803 useMvFromPrevStep = (m_b32XMeEnabled) ? true : false;
5804 writeDistortions = false;
5805 scaleFactor = SCALE_FACTOR_16x;
5806 mvShiftFactor = 2;
5807 prevMvReadPosFactor = 1;
5808 break;
5809 case HME_LEVEL_4x:
5810 useMvFromPrevStep = (m_b16XMeEnabled) ? true : false;
5811 writeDistortions = true;
5812 scaleFactor = SCALE_FACTOR_4x;
5813 mvShiftFactor = 2;
5814 prevMvReadPosFactor = 0;
5815 break;
5816 default:
5817 eStatus = MOS_STATUS_INVALID_PARAMETER;
5818 return eStatus;
5819 break;
5820 }
5821
5822 curbe.DW3.SubPelMode = 3;
5823 curbe.DW4.PictureHeightMinus1 = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight / scaleFactor) - 1;
5824 curbe.DW4.PictureWidth = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth / scaleFactor);
5825 curbe.DW5.QpPrimeY = m_hevcPicParams->QpY + m_hevcSliceParams->slice_qp_delta;
5826 curbe.DW6.WriteDistortions = writeDistortions;
5827 curbe.DW6.UseMvFromPrevStep = useMvFromPrevStep;
5828 curbe.DW6.SuperCombineDist = 5;//SuperCombineDist_Generic[pHevcSeqParams->TargetUsage]; Harded coded in KCM
5829 curbe.DW6.MaxVmvR = 511 * 4;
5830 curbe.DW15.MvShiftFactor = mvShiftFactor;
5831 curbe.DW15.PrevMvReadPosFactor = prevMvReadPosFactor;
5832
5833 if (m_pictureCodingType == B_TYPE)
5834 {
5835 // This field is irrelevant since we are not using the bi-direct search.
5836 curbe.DW1.BiWeight = m_bframeMeBidirectionalWeight;
5837 curbe.DW13.NumRefIdxL1MinusOne = m_hevcSliceParams->num_ref_idx_l1_active_minus1;
5838 }
5839
5840 if (m_pictureCodingType == P_TYPE || m_pictureCodingType == B_TYPE)
5841 {
5842 curbe.DW13.NumRefIdxL0MinusOne = m_hevcSliceParams->num_ref_idx_l0_active_minus1;
5843 }
5844
5845 if (hmeLevel == HME_LEVEL_4x)
5846 {
5847 curbe.DW30.ActualMBHeight = m_frameHeight;
5848 curbe.DW30.ActualMBWidth = m_frameWidth;
5849 }
5850 else
5851 {
5852 curbe.DW30.ActualMBHeight = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameFieldHeight);
5853 curbe.DW30.ActualMBWidth = CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(m_frameWidth);
5854 }
5855
5856 curbe.DW13.RefStreaminCost = 0;
5857 // This flag is to indicate the ROI source type instead of indicating ROI is enabled or not
5858 curbe.DW13.ROIEnable = 0;
5859
5860 uint8_t meMethod = (m_pictureCodingType == B_TYPE) ? m_bMeMethodGeneric[m_hevcSeqParams->TargetUsage] : m_meMethodGeneric[m_hevcSeqParams->TargetUsage];
5861 uint8_t tableIdx = (m_pictureCodingType == B_TYPE) ? 1 : 0;
5862 CODECHAL_ENCODE_CHK_STATUS_RETURN(MOS_SecureMemcpy(&(curbe.SPDelta), 14 * sizeof(uint32_t),
5863 m_encodeSearchPath[tableIdx][meMethod], 14 * sizeof(uint32_t)));
5864
5865 if (hmeLevel == HME_LEVEL_4x)
5866 {
5867 //StreamIn CURBE
5868 curbe.DW6.LCUSize = 1;//Only LCU64 supported by the VDEnc HW
5869 // Kernel should use driver-prepared stream-in surface during ROI/ MBQP(LCUQP)/ Dirty-Rect
5870 curbe.DW6.InputStreamInEn = (m_hevcPicParams->NumROI || m_encodeParams.bMbQpDataEnabled || (m_hevcPicParams->NumDirtyRects > 0 && (B_TYPE == m_hevcPicParams->CodingType)));
5871 curbe.DW31.MaxCuSize = 3;
5872 curbe.DW31.MaxTuSize = 3;
5873 switch (m_hevcSeqParams->TargetUsage)
5874 {
5875 case 1:
5876 case 4:
5877 curbe.DW36.NumMergeCandCu64x64 = 4;
5878 curbe.DW36.NumMergeCandCu32x32 = 3;
5879 curbe.DW36.NumMergeCandCu16x16 = 2;
5880 curbe.DW36.NumMergeCandCu8x8 = 1;
5881 curbe.DW31.NumImePredictors = m_imgStateImePredictors;
5882 break;
5883 case 7:
5884 curbe.DW36.NumMergeCandCu64x64 = 2;
5885 curbe.DW36.NumMergeCandCu32x32 = 2;
5886 curbe.DW36.NumMergeCandCu16x16 = 2;
5887 curbe.DW36.NumMergeCandCu8x8 = 0;
5888 curbe.DW31.NumImePredictors = 4;
5889 break;
5890 }
5891 }
5892
5893 curbe.DW40._4xMeMvOutputDataSurfIndex = CODECHAL_VDENC_HME_MV_DATA_SURFACE_CM_G12;
5894 curbe.DW41._16xOr32xMeMvInputDataSurfIndex = (hmeLevel == HME_LEVEL_32x) ? CODECHAL_VDENC_32xME_MV_DATA_SURFACE_CM_G12 : CODECHAL_VDENC_16xME_MV_DATA_SURFACE_CM_G12;
5895 curbe.DW42._4xMeOutputDistSurfIndex = CODECHAL_VDENC_HME_DISTORTION_SURFACE_CM_G12;
5896 curbe.DW43._4xMeOutputBrcDistSurfIndex = CODECHAL_VDENC_HME_BRC_DISTORTION_CM_G12;
5897 curbe.DW44.VMEFwdInterPredictionSurfIndex = CODECHAL_VDENC_HME_CURR_FOR_FWD_REF_CM_G12;
5898 curbe.DW45.VMEBwdInterPredictionSurfIndex = CODECHAL_VDENC_HME_CURR_FOR_BWD_REF_CM_G12;
5899 curbe.DW46.VDEncStreamInOutputSurfIndex = CODECHAL_VDENC_HME_VDENC_STREAMIN_OUTPUT_CM_G12;
5900 curbe.DW47.VDEncStreamInInputSurfIndex = CODECHAL_VDENC_HME_VDENC_STREAMIN_INPUT_CM_G12;
5901
5902 CODECHAL_ENCODE_CHK_STATUS_RETURN(kernelState->m_dshRegion.AddData(
5903 &curbe,
5904 kernelState->dwCurbeOffset,
5905 sizeof(curbe)));
5906
5907 return eStatus;
5908 }
5909
5910 MOS_STATUS CodechalVdencHevcStateG12::SendMeSurfaces(HmeLevel hmeLevel, PMOS_COMMAND_BUFFER cmdBuffer)
5911 {
5912 CODECHAL_ENCODE_FUNCTION_ENTER;
5913 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
5914
5915 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
5916
5917 MOS_SURFACE *meMvDataBuffer;
5918 uint32_t downscaledWidthInMb;
5919 uint32_t downscaledHeightInMb;
5920
5921 if (hmeLevel == HME_LEVEL_32x)
5922 {
5923 meMvDataBuffer = &m_s32XMeMvDataBuffer;
5924 downscaledWidthInMb = m_downscaledWidthInMb32x;
5925 downscaledHeightInMb = m_downscaledHeightInMb32x;
5926 }
5927 else if (hmeLevel == HME_LEVEL_16x)
5928 {
5929 meMvDataBuffer = &m_s16XMeMvDataBuffer;
5930 downscaledWidthInMb = m_downscaledWidthInMb16x;
5931 downscaledHeightInMb = m_downscaledHeightInMb16x;
5932 }
5933 else
5934 {
5935 meMvDataBuffer = &m_s4XMeMvDataBuffer;
5936 downscaledWidthInMb = m_downscaledWidthInMb4x;
5937 downscaledHeightInMb = m_downscaledHeightInMb4x;
5938 }
5939
5940 auto width = MOS_ALIGN_CEIL(downscaledWidthInMb * 32, 64);
5941 auto height = downscaledHeightInMb * 4 * 10;
5942 // Force the values
5943 meMvDataBuffer->dwWidth = width;
5944 meMvDataBuffer->dwHeight = height;
5945 meMvDataBuffer->dwPitch = width;
5946
5947 PMHW_KERNEL_STATE kernelState = nullptr;
5948 if(hmeLevel == HME_LEVEL_4x)
5949 {
5950 kernelState = m_lowDelay ? &m_vdencStreaminKernelState : &m_vdencStreaminKernelStateRAB;
5951 }
5952 else
5953 {
5954 kernelState = m_lowDelay ? &m_vdencMeKernelState : &m_vdencMeKernelStateRAB;
5955 }
5956 auto bindingTable = (hmeLevel == HME_LEVEL_4x) ?
5957 &m_vdencStreaminKernelBindingTable : &m_vdencMeKernelBindingTable;
5958 uint32_t meMvBottomFieldOffset = 0;
5959
5960 CODECHAL_SURFACE_CODEC_PARAMS surfaceCodecParams;
5961 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
5962 surfaceCodecParams.bIs2DSurface = true;
5963 surfaceCodecParams.bMediaBlockRW = true;
5964 surfaceCodecParams.psSurface = meMvDataBuffer;
5965 surfaceCodecParams.dwOffset = meMvBottomFieldOffset;
5966 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE].Value;
5967 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_MV_DATA_SURFACE_CM_G12];
5968 surfaceCodecParams.bIsWritable = true;
5969 surfaceCodecParams.bRenderTarget = true;
5970 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5971 m_hwInterface,
5972 cmdBuffer,
5973 &surfaceCodecParams,
5974 kernelState));
5975
5976 if (hmeLevel == HME_LEVEL_16x && m_b32XMeEnabled)
5977 {
5978 // Pass 32x MV to 16x ME operation
5979 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
5980 surfaceCodecParams.bIs2DSurface = true;
5981 surfaceCodecParams.bMediaBlockRW = true;
5982 surfaceCodecParams.psSurface = &m_s32XMeMvDataBuffer;
5983 surfaceCodecParams.dwOffset = 0;
5984 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE].Value;
5985 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_32xME_MV_DATA_SURFACE_CM_G12];
5986 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
5987 m_hwInterface,
5988 cmdBuffer,
5989 &surfaceCodecParams,
5990 kernelState));
5991 }
5992 else if (!(hmeLevel == HME_LEVEL_32x) && m_b16XMeEnabled)
5993 {
5994 // Pass 16x MV to 4x ME operation
5995 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
5996 surfaceCodecParams.bIs2DSurface = true;
5997 surfaceCodecParams.bMediaBlockRW = true;
5998 surfaceCodecParams.psSurface = &m_s16XMeMvDataBuffer;
5999 surfaceCodecParams.dwOffset = 0;
6000 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_MV_DATA_ENCODE].Value;
6001 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_16xME_MV_DATA_SURFACE_CM_G12];
6002 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6003 m_hwInterface,
6004 cmdBuffer,
6005 &surfaceCodecParams,
6006 kernelState));
6007
6008 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6009 surfaceCodecParams.bIs2DSurface = true;
6010 surfaceCodecParams.bMediaBlockRW = true;
6011 surfaceCodecParams.psSurface = &m_s4XMeDistortionBuffer;
6012 surfaceCodecParams.dwOffset = 0;
6013 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_DISTORTION_SURFACE_CM_G12];
6014 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_ME_DISTORTION_ENCODE].Value;
6015 surfaceCodecParams.bIsWritable = true;
6016 surfaceCodecParams.bRenderTarget = true;
6017 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6018 m_hwInterface,
6019 cmdBuffer,
6020 &surfaceCodecParams,
6021 kernelState));
6022 }
6023
6024 PMOS_SURFACE currScaledSurface = (hmeLevel == HME_LEVEL_4x) ? m_trackedBuf->Get4xDsSurface(CODEC_CURR_TRACKED_BUFFER) :
6025 ((hmeLevel == HME_LEVEL_16x) ? m_trackedBuf->Get16xDsSurface(CODEC_CURR_TRACKED_BUFFER) : m_trackedBuf->Get32xDsSurface(CODEC_CURR_TRACKED_BUFFER));
6026 MOS_SURFACE refScaledSurface = *currScaledSurface;
6027 bool currFieldPicture = CodecHal_PictureIsField(m_currOriginalPic) ? true : false;
6028 bool currBottomField = CodecHal_PictureIsBottomField(m_currOriginalPic) ? true : false;
6029
6030 uint8_t currVDirection = (!currFieldPicture) ? CODECHAL_VDIRECTION_FRAME :
6031 ((currBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
6032 uint32_t currScaledBottomFieldOffset = (hmeLevel == HME_LEVEL_4x) ?
6033 (uint32_t)m_scaledBottomFieldOffset : ((hmeLevel == HME_LEVEL_16x) ? (uint32_t)m_scaled16xBottomFieldOffset : (uint32_t)m_scaled32xBottomFieldOffset);
6034
6035 // Setup references 1...n
6036 // LIST 0 references
6037 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l0_active_minus1; refIdx++)
6038 {
6039 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[LIST_0][refIdx];
6040
6041 if (!CodecHal_PictureIsInvalid(refPic))
6042 {
6043 if (refIdx == 0)
6044 {
6045 // Current Picture Y - VME
6046 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6047 surfaceCodecParams.bUseAdvState = true;
6048 surfaceCodecParams.psSurface = currScaledSurface;
6049 surfaceCodecParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
6050 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
6051 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_CURR_FOR_FWD_REF_CM_G12];
6052 surfaceCodecParams.ucVDirection = currVDirection;
6053 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6054 m_hwInterface,
6055 cmdBuffer,
6056 &surfaceCodecParams,
6057 kernelState));
6058 }
6059
6060 bool refFieldPicture = CodecHal_PictureIsField(refPic) ? true : false;
6061 bool refBottomField = CodecHal_PictureIsBottomField(refPic) ? true : false;
6062 uint8_t refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
6063 uint8_t scaledIdx = m_refList[refPicIdx]->ucScalingIdx;
6064 if (hmeLevel == HME_LEVEL_4x)
6065 {
6066 refScaledSurface.OsResource = m_trackedBuf->Get4xDsSurface(scaledIdx)->OsResource;
6067 }
6068 else if (hmeLevel == HME_LEVEL_16x)
6069 {
6070 refScaledSurface.OsResource = m_trackedBuf->Get16xDsSurface(scaledIdx)->OsResource;
6071 }
6072 else
6073 {
6074 refScaledSurface.OsResource = m_trackedBuf->Get32xDsSurface(scaledIdx)->OsResource;
6075 }
6076 uint32_t refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
6077
6078 // L0 Reference Picture Y - VME
6079 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6080 surfaceCodecParams.bUseAdvState = true;
6081 surfaceCodecParams.psSurface = &refScaledSurface;
6082 surfaceCodecParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
6083 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
6084 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_FWD_REF_IDX0_CM_G12 + (refIdx * 2)];
6085 surfaceCodecParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME :
6086 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
6087 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6088 m_hwInterface,
6089 cmdBuffer,
6090 &surfaceCodecParams,
6091 kernelState));
6092
6093 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_RESERVED1_CM_G12 + (refIdx * 2)];
6094 surfaceCodecParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME :
6095 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
6096 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6097 m_hwInterface,
6098 cmdBuffer,
6099 &surfaceCodecParams,
6100 kernelState));
6101 }
6102 }
6103
6104 //List1
6105 for (uint8_t refIdx = 0; refIdx <= m_hevcSliceParams->num_ref_idx_l1_active_minus1; refIdx++)
6106 {
6107 CODEC_PICTURE refPic = m_hevcSliceParams->RefPicList[LIST_1][refIdx];
6108
6109 if (!CodecHal_PictureIsInvalid(refPic))
6110 {
6111 if (refIdx == 0)
6112 {
6113 // Current Picture Y - VME
6114 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6115 surfaceCodecParams.bUseAdvState = true;
6116 surfaceCodecParams.psSurface = currScaledSurface;
6117 surfaceCodecParams.dwOffset = currBottomField ? currScaledBottomFieldOffset : 0;
6118 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_CURR_ENCODE].Value;
6119 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_CURR_FOR_BWD_REF_CM_G12];
6120 surfaceCodecParams.ucVDirection = currVDirection;
6121 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6122 m_hwInterface,
6123 cmdBuffer,
6124 &surfaceCodecParams,
6125 kernelState));
6126 }
6127
6128 bool refFieldPicture = CodecHal_PictureIsField(refPic) ? 1 : 0;
6129 bool refBottomField = CodecHal_PictureIsBottomField(refPic) ? 1 : 0;
6130 auto refPicIdx = m_picIdx[refPic.FrameIdx].ucPicIdx;
6131 uint8_t scaledIdx = m_refList[refPicIdx]->ucScalingIdx;
6132
6133 if (hmeLevel == HME_LEVEL_4x)
6134 {
6135 refScaledSurface.OsResource = m_trackedBuf->Get4xDsSurface(scaledIdx)->OsResource;
6136 }
6137 else if (hmeLevel == HME_LEVEL_16x)
6138 {
6139 refScaledSurface.OsResource = m_trackedBuf->Get16xDsSurface(scaledIdx)->OsResource;
6140 }
6141 else
6142 {
6143 refScaledSurface.OsResource = m_trackedBuf->Get32xDsSurface(scaledIdx)->OsResource;
6144 }
6145 uint32_t refScaledBottomFieldOffset = refBottomField ? currScaledBottomFieldOffset : 0;
6146
6147 // L1 Reference Picture Y - VME
6148 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6149 surfaceCodecParams.bUseAdvState = true;
6150 surfaceCodecParams.psSurface = &refScaledSurface;
6151 surfaceCodecParams.dwOffset = refBottomField ? refScaledBottomFieldOffset : 0;
6152 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_SURFACE_REF_ENCODE].Value;
6153 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_BWD_REF_IDX0_CM_G12 + (refIdx * 2)];
6154 surfaceCodecParams.ucVDirection = !currFieldPicture ? CODECHAL_VDIRECTION_FRAME :
6155 ((refBottomField) ? CODECHAL_VDIRECTION_BOT_FIELD : CODECHAL_VDIRECTION_TOP_FIELD);
6156 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6157 m_hwInterface,
6158 cmdBuffer,
6159 &surfaceCodecParams,
6160 kernelState));
6161
6162 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_RESERVED9_CM_G12 + (refIdx * 2)];
6163 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6164 m_hwInterface,
6165 cmdBuffer,
6166 &surfaceCodecParams,
6167 kernelState));
6168 }
6169 }
6170
6171 if (hmeLevel == HME_LEVEL_4x)
6172 {
6173 CODECHAL_ENCODE_CHK_NULL_RETURN(&m_resVdencStreamInBuffer[m_currRecycledBufIdx]);
6174
6175 auto streamingSize = (MOS_ALIGN_CEIL(m_frameWidth, 64) / 32) * (MOS_ALIGN_CEIL(m_frameHeight, 64) / 32) * CODECHAL_CACHELINE_SIZE;
6176
6177 // Send driver-prepared stream-in surface as input during ROI/ MBQP(LCUQP)/ Dirty-Rect
6178 if (m_hevcPicParams->NumROI || m_encodeParams.bMbQpDataEnabled || (m_hevcPicParams->NumDirtyRects > 0 && (B_TYPE == m_hevcPicParams->CodingType)))
6179 {
6180 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6181 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(streamingSize);
6182 surfaceCodecParams.bIs2DSurface = false;
6183 surfaceCodecParams.presBuffer = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
6184 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
6185 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_VDENC_STREAMIN_INPUT_CM_G12];
6186 surfaceCodecParams.bIsWritable = true;
6187 surfaceCodecParams.bRenderTarget = true;
6188 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6189 m_hwInterface,
6190 cmdBuffer,
6191 &surfaceCodecParams,
6192 kernelState));
6193 }
6194 else // Clear stream-in surface otherwise
6195 {
6196 MOS_LOCK_PARAMS lockFlags;
6197 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
6198 lockFlags.WriteOnly = true;
6199
6200 auto data = m_osInterface->pfnLockResource(
6201 m_osInterface,
6202 &m_resVdencStreamInBuffer[m_currRecycledBufIdx],
6203 &lockFlags);
6204
6205 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
6206
6207 MOS_ZeroMemory(
6208 data,
6209 streamingSize);
6210
6211 m_osInterface->pfnUnlockResource(
6212 m_osInterface,
6213 &m_resVdencStreamInBuffer[m_currRecycledBufIdx]);
6214 }
6215
6216 MOS_ZeroMemory(&surfaceCodecParams, sizeof(surfaceCodecParams));
6217 surfaceCodecParams.dwSize = MOS_BYTES_TO_DWORDS(streamingSize);
6218 surfaceCodecParams.bIs2DSurface = false;
6219 surfaceCodecParams.presBuffer = &m_resVdencStreamInBuffer[m_currRecycledBufIdx];
6220 surfaceCodecParams.dwCacheabilityControl = m_hwInterface->GetCacheabilitySettings()[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
6221 surfaceCodecParams.dwBindingTableOffset = bindingTable->dwBindingTableEntries[CODECHAL_VDENC_HME_VDENC_STREAMIN_OUTPUT_CM_G12];
6222 surfaceCodecParams.bIsWritable = true;
6223 surfaceCodecParams.bRenderTarget = true;
6224 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalSetRcsSurfaceState(
6225 m_hwInterface,
6226 cmdBuffer,
6227 &surfaceCodecParams,
6228 kernelState));
6229 }
6230
6231 return eStatus;
6232 }
6233
6234 MOS_STATUS
6235 CodechalVdencHevcStateG12::GetKernelHeaderAndSize(
6236 void *binary,
6237 EncOperation operation,
6238 uint32_t krnStateIdx,
6239 void *krnHeader,
6240 uint32_t *krnSize)
6241 {
6242 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6243
6244 CODECHAL_ENCODE_FUNCTION_ENTER;
6245
6246 CODECHAL_ENCODE_CHK_NULL_RETURN(binary);
6247 CODECHAL_ENCODE_CHK_NULL_RETURN(krnHeader);
6248 CODECHAL_ENCODE_CHK_NULL_RETURN(krnSize);
6249
6250 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommonKernelHeaderAndSizeG12(binary, operation, krnStateIdx, krnHeader, krnSize));
6251
6252 return eStatus;
6253 }
6254
6255 MOS_STATUS CodechalVdencHevcStateG12::AddVdencWalkerStateCmd(
6256 PMOS_COMMAND_BUFFER cmdBuffer,
6257 PMHW_VDBOX_HEVC_SLICE_STATE params)
6258 {
6259 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6260
6261 CODECHAL_ENCODE_FUNCTION_ENTER;
6262
6263 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
6264 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
6265
6266 MHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G12 vdencWalkerStateParams;
6267 vdencWalkerStateParams.Mode = CODECHAL_ENCODE_MODE_HEVC;
6268 vdencWalkerStateParams.pHevcEncSeqParams = params->pEncodeHevcSeqParams;
6269 vdencWalkerStateParams.pHevcEncPicParams = params->pEncodeHevcPicParams;
6270 vdencWalkerStateParams.pEncodeHevcSliceParams = params->pEncodeHevcSliceParams;
6271 vdencWalkerStateParams.pTileCodingParams = static_cast<PMHW_VDBOX_HEVC_SLICE_STATE_G12>(params)->pTileCodingParams;
6272 vdencWalkerStateParams.dwTileId = static_cast<PMHW_VDBOX_HEVC_SLICE_STATE_G12>(params)->dwTileID;
6273 switch (static_cast<PMHW_VDBOX_HEVC_SLICE_STATE_G12>(params)->dwNumPipe)
6274 {
6275 case 0:
6276 case 1:
6277 vdencWalkerStateParams.dwNumberOfPipes = VDENC_PIPE_SINGLE_PIPE;
6278 break;
6279 case 2:
6280 vdencWalkerStateParams.dwNumberOfPipes = VDENC_PIPE_TWO_PIPE;
6281 break;
6282 case 4:
6283 vdencWalkerStateParams.dwNumberOfPipes = VDENC_PIPE_FOUR_PIPE;
6284 break;
6285 default:
6286 vdencWalkerStateParams.dwNumberOfPipes = VDENC_PIPE_INVALID;
6287 CODECHAL_ENCODE_ASSERT(false);
6288 break;
6289 }
6290
6291 vdencWalkerStateParams.IBCControl =
6292 m_enableLBCOnly ? SCC_IBC_CONTROL_IBC_ONLY_LBC_G12 : SCC_IBC_CONTROL_IBC_ENABLED_TBCLBC_G12;
6293
6294 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencWalkerStateCmd(cmdBuffer, &vdencWalkerStateParams));
6295
6296 return eStatus;
6297 }
6298
6299 MOS_STATUS CodechalVdencHevcStateG12::GetSystemPipeNumberCommon()
6300 {
6301 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6302
6303 CODECHAL_ENCODE_FUNCTION_ENTER;
6304
6305 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
6306 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6307
6308 MOS_STATUS statusKey = MOS_STATUS_SUCCESS;
6309 statusKey = MOS_UserFeature_ReadValue_ID(
6310 nullptr,
6311 __MEDIA_USER_FEATURE_VALUE_ENCODE_DISABLE_SCALABILITY,
6312 &userFeatureData,
6313 m_osInterface->pOsContext);
6314
6315 bool disableScalability = m_hwInterface->IsDisableScalability();
6316 if (statusKey == MOS_STATUS_SUCCESS)
6317 {
6318 disableScalability = userFeatureData.i32Data ? true : false;
6319 }
6320
6321 MEDIA_SYSTEM_INFO *gtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
6322 CODECHAL_ENCODE_CHK_NULL_RETURN(gtSystemInfo);
6323
6324 if (gtSystemInfo && disableScalability == false)
6325 {
6326 // Both VE mode and media solo mode should be able to get the VDBOX number via the same interface
6327 m_numVdbox = (uint8_t)(gtSystemInfo->VDBoxInfo.NumberOfVDBoxEnabled);
6328 }
6329 else
6330 {
6331 m_numVdbox = 1;
6332 }
6333
6334 CODECHAL_ENCODE_VERBOSEMESSAGE("System VDBOX number = %d.", m_numVdbox);
6335
6336 return eStatus;
6337 }
6338
6339 MOS_STATUS CodechalVdencHevcStateG12::Initialize(CodechalSetting * settings)
6340 {
6341 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6342
6343 CODECHAL_ENCODE_FUNCTION_ENTER;
6344
6345 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
6346 // Tile Replay Enable should be passed from DDI, will change later when DDI is ready
6347 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6348 MOS_UserFeature_ReadValue_ID(
6349 nullptr,
6350 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_TILEREPLAY_ENABLE_ID,
6351 &userFeatureData,
6352 m_osInterface->pOsContext);
6353 m_enableTileReplay = userFeatureData.i32Data ? true : false;
6354
6355 m_skipFrameBasedHWCounterRead = m_enableTileReplay;
6356
6357 // RGB Encoding Enable should be passed from DDI, will change later when DDI is ready
6358 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6359 MOS_UserFeature_ReadValue_ID(
6360 nullptr,
6361 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_RGB_ENCODING_ENABLE_ID,
6362 &userFeatureData,
6363 m_osInterface->pOsContext);
6364 m_RGBEncodingEnable = userFeatureData.i32Data ? true : false;
6365
6366 // Capture mode with display Enable should be passed from DDI, will change later
6367 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6368 MOS_UserFeature_ReadValue_ID(
6369 nullptr,
6370 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_CAPTURE_MODE_ENABLE_ID,
6371 &userFeatureData,
6372 m_osInterface->pOsContext);
6373 m_CaptureModeEnable = userFeatureData.i32Data ? true : false;
6374
6375 #if (_DEBUG || _RELEASE_INTERNAL)
6376 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6377 MOS_UserFeature_ReadValue_ID(
6378 nullptr,
6379 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_TCBRC_ARB_DISABLE_ID,
6380 &userFeatureData,
6381 m_osInterface->pOsContext);
6382 m_brcAdaptiveRegionBoostSupported = userFeatureData.i32Data ? false : m_brcAdaptiveRegionBoostSupported;
6383 #endif
6384
6385 // common initilization
6386 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::Initialize(settings));
6387
6388 MEDIA_FEATURE_TABLE *skuTable = m_osInterface->pfnGetSkuTable(m_osInterface);
6389 if (m_osInterface->bSimIsActive && (m_enableTileReplay == true))
6390 {
6391 m_frameTrackingEnabled = false;
6392 }
6393
6394 // To do: current size assumes 8Kx8K max resolution. Needs to be increased based on Gen12, along with m_maxNumNativeROI.
6395 m_deltaQpRoiBufferSize = m_deltaQpBufferSize;
6396 m_brcRoiBufferSize = m_roiStreamInBufferSize;
6397 m_maxTileNumber = CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameWidth, CODECHAL_HEVC_MIN_TILE_SIZE) *
6398 CODECHAL_GET_HEIGHT_IN_BLOCKS(m_frameHeight, CODECHAL_HEVC_MIN_TILE_SIZE);
6399
6400 // we need additional buffer for (1) 1 CL for size info at the beginning of each tile column (max of 4 vdbox in scalability mode)
6401 // (2) CL alignment at end of every tile column
6402 // as a result, increase the height by 1 for allocation purposes
6403 m_numLcu = MOS_ROUNDUP_DIVIDE(m_frameWidth, MAX_LCU_SIZE) * (MOS_ROUNDUP_DIVIDE(m_frameHeight, MAX_LCU_SIZE) + 1);
6404 m_mbCodeSize = MOS_ALIGN_CEIL(2 * sizeof(uint32_t) * (m_numLcu * 5 + m_numLcu * 64 * 8), CODECHAL_PAGE_SIZE);
6405 m_mbCodeSize += m_mvOffset;
6406
6407 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetSystemPipeNumberCommon());
6408
6409 if (MOS_VE_SUPPORTED(m_osInterface))
6410 {
6411 m_scalabilityState = (PCODECHAL_ENCODE_SCALABILITY_STATE)MOS_AllocAndZeroMemory(sizeof(CODECHAL_ENCODE_SCALABILITY_STATE));
6412 CODECHAL_ENCODE_CHK_NULL_RETURN(m_scalabilityState);
6413 //scalability initialize
6414 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalEncodeScalability_InitializeState(m_scalabilityState, m_hwInterface));
6415 }
6416
6417 // Caculate the size for 3nd level batch buffer
6418 // mhw_vdbox_hcp_g12_X::HCP_PIC_STATE_CMD::byteSize
6419 // As this buffer is going to passed to HuC to generate the command, must be page aligned
6420 // To add the HW interface get the buffer size later
6421
6422 m_thirdLBSize = MOS_ALIGN_CEIL(1024, CODECHAL_PAGE_SIZE);
6423
6424 // Caculate the batch buffer size for each tile
6425 // To add the MHW interface later, can be fine tuned
6426 m_tileLevelBatchSize = m_hwInterface->m_vdenc2ndLevelBatchBufferSize;
6427
6428 // Caculate the size for MV temporal buffer
6429 uint32_t mvt_size = MOS_ALIGN_CEIL(((m_frameWidth + 63) >> 6)*((m_frameHeight + 15) >> 4), 2) * CODECHAL_CACHELINE_SIZE;
6430 uint32_t mvtb_size = MOS_ALIGN_CEIL(((m_frameWidth + 31) >> 5)*((m_frameHeight + 31) >> 5), 2) * CODECHAL_CACHELINE_SIZE;
6431 m_sizeOfMvTemporalBuffer = MOS_MAX(mvt_size, mvtb_size);
6432
6433 m_sizeOfHcpPakFrameStats = 9 * CODECHAL_CACHELINE_SIZE;
6434
6435 #ifdef _MEDIA_RESERVED
6436 InitReserveState(settings);
6437 #endif
6438 m_enableSCC = settings->isSCCEnabled;
6439
6440 #if (_DEBUG || _RELEASE_INTERNAL)
6441 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6442 // LBC only Enable should be passed from DDI, will change later when DDI is ready
6443 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6444 MOS_UserFeature_ReadValue_ID(
6445 nullptr,
6446 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_LBCONLY_ENABLE_ID,
6447 &userFeatureData,
6448 m_osInterface->pOsContext);
6449 m_enableLBCOnly = userFeatureData.i32Data ? true : false;
6450 #endif
6451
6452 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6453 MOS_UserFeature_ReadValue_ID(
6454 nullptr,
6455 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ENABLE_HW_STITCH,
6456 &userFeatureData,
6457 m_osInterface->pOsContext);
6458 m_enableTileStitchByHW = userFeatureData.i32Data ? true : false;
6459
6460 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6461 MOS_UserFeature_ReadValue_ID(
6462 nullptr,
6463 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ENABLE_HW_SEMAPHORE,
6464 &userFeatureData,
6465 m_osInterface->pOsContext);
6466 m_enableHWSemaphore = userFeatureData.i32Data ? true : false;
6467
6468 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6469 MOS_UserFeature_ReadValue_ID(
6470 nullptr,
6471 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ENABLE_VDBOX_HW_SEMAPHORE,
6472 &userFeatureData,
6473 m_osInterface->pOsContext);
6474 m_enableVdBoxHWSemaphore = userFeatureData.i32Data ? true : false;
6475
6476 // ACQP is now supported on Gen12 for TU1 / TU4
6477 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6478 MOS_UserFeature_ReadValue_ID(
6479 nullptr,
6480 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_ACQP_ENABLE_ID,
6481 &userFeatureData,
6482 m_osInterface->pOsContext);
6483 m_hevcVdencAcqpEnabled = userFeatureData.i32Data ? true : false;
6484
6485 m_numDelay = 15;
6486
6487 #if (_DEBUG || _RELEASE_INTERNAL)
6488 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6489 MOS_UserFeature_ReadValue_ID(
6490 nullptr,
6491 __MEDIA_USER_FEATURE_VALUE_HEVC_ENCODE_ENABLE_VE_DEBUG_OVERRIDE,
6492 &userFeatureData,
6493 m_osInterface->pOsContext);
6494 m_kmdVeOveride.Value = (uint64_t)userFeatureData.i64Data;
6495
6496 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6497 MOS_UserFeature_ReadValue_ID(
6498 nullptr,
6499 __MEDIA_USER_FEATURE_VALUE_HEVC_VDENC_FORCE_SCALABILITY_ID,
6500 &userFeatureData,
6501 m_osInterface->pOsContext);
6502 m_forceScalability = userFeatureData.i32Data ? true : false;
6503 #endif
6504
6505 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
6506 MOS_UserFeature_ReadValue_ID(
6507 nullptr,
6508 __MEDIA_USER_FEATURE_VALUE_HEVC_TCBRC_QUALITY_BOOST_ENABLE_ID,
6509 &userFeatureData,
6510 m_osInterface->pOsContext);
6511 m_tcbrcQualityBoost = (userFeatureData.i32Data) ? true : false;
6512
6513 return eStatus;
6514 }
6515
6516 CodechalVdencHevcStateG12::CodechalVdencHevcStateG12(
6517 CodechalHwInterface* hwInterface,
6518 CodechalDebugInterface* debugInterface,
6519 PCODECHAL_STANDARD_INFO standardInfo)
6520 :CodechalVdencHevcState(hwInterface, debugInterface, standardInfo)
6521 {
6522 CODECHAL_ENCODE_FUNCTION_ENTER;
6523
6524 m_useCommonKernel = true;
6525 pfnGetKernelHeaderAndSize = GetKernelHeaderAndSize;
6526 m_useHwScoreboard = false;
6527 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
6528 m_kernelBase = (uint8_t*)IGCODECKRN_G12;
6529 #endif
6530 m_kuidCommon = IDR_CODEC_HME_DS_SCOREBOARD_KERNEL;
6531 m_scalabilityState = nullptr;
6532 m_brcAdaptiveRegionBoostSupported = true;
6533
6534 MOS_ZeroMemory(&m_resPakcuLevelStreamoutData, sizeof(m_resPakcuLevelStreamoutData));
6535 MOS_ZeroMemory(&m_resPakSliceLevelStreamoutData, sizeof(m_resPakSliceLevelStreamoutData));
6536 MOS_ZeroMemory(m_resTileBasedStatisticsBuffer, sizeof(m_resTileBasedStatisticsBuffer));
6537 MOS_ZeroMemory(&m_resHuCPakAggregatedFrameStatsBuffer, sizeof(m_resHuCPakAggregatedFrameStatsBuffer));
6538 MOS_ZeroMemory(m_tileRecordBuffer, sizeof(m_tileRecordBuffer));
6539 MOS_ZeroMemory(&m_kmdVeOveride, sizeof(m_kmdVeOveride));
6540 MOS_ZeroMemory(&m_resHcpScalabilitySyncBuffer, sizeof(m_resHcpScalabilitySyncBuffer));
6541
6542 MOS_ZeroMemory(m_veBatchBuffer, sizeof(m_veBatchBuffer));
6543 MOS_ZeroMemory(&m_realCmdBuffer, sizeof(m_realCmdBuffer));
6544 MOS_ZeroMemory(&m_resBrcSemaphoreMem, sizeof(m_resBrcSemaphoreMem));
6545 MOS_ZeroMemory(&m_resBrcPakSemaphoreMem, sizeof(m_resBrcPakSemaphoreMem));
6546 MOS_ZeroMemory(m_resVdBoxSemaphoreMem, sizeof(m_resVdBoxSemaphoreMem));
6547 MOS_ZeroMemory(&m_resPipeStartSemaMem, sizeof(m_resPipeStartSemaMem));
6548
6549 MOS_ZeroMemory(&m_vdencTileRowStoreBuffer, sizeof(m_vdencTileRowStoreBuffer));
6550 MOS_ZeroMemory(&m_thirdLevelBatchBuffer, sizeof(MHW_BATCH_BUFFER));
6551 MOS_ZeroMemory(&m_vdencSAORowStoreBuffer, sizeof(m_vdencSAORowStoreBuffer));
6552
6553 CODECHAL_ENCODE_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
6554 for (auto i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
6555 {
6556 MOS_ZeroMemory(&m_tileLevelBatchBuffer[i], sizeof(PMHW_BATCH_BUFFER));
6557 MOS_ZeroMemory(&m_TileRowBRCBatchBuffer[i], sizeof(PMHW_BATCH_BUFFER));
6558 }
6559
6560 for (auto k = 0; k < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; k++)
6561 {
6562 for (auto i = 0; i < CODECHAL_VDENC_BRC_NUM_OF_PASSES; i++)
6563 {
6564 MOS_ZeroMemory(&m_resHucPakStitchDmemBuffer[k][i], sizeof(m_resHucPakStitchDmemBuffer[k][i]));
6565 }
6566 }
6567
6568 MOS_ZeroMemory(&m_resBrcDataBuffer, sizeof(m_resBrcDataBuffer));
6569 MOS_ZeroMemory(&m_resTileRowBRCsyncSemaphore, sizeof(m_resTileRowBRCsyncSemaphore));
6570
6571 m_vdencBrcInitDmemBufferSize = sizeof(CODECHAL_VDENC_HEVC_HUC_BRC_INIT_DMEM_G12);
6572 m_vdencBrcUpdateDmemBufferSize = sizeof(CODECHAL_VDENC_HEVC_HUC_BRC_UPDATE_DMEM_G12);
6573 m_vdencBrcConstDataBufferSize = sizeof(CODECHAL_VDENC_HEVC_HUC_BRC_CONSTANT_DATA_G12);
6574 m_maxNumSlicesSupported = CODECHAL_VDENC_HEVC_MAX_SLICE_NUM;
6575
6576 m_hwInterface->GetStateHeapSettings()->dwNumSyncTags = CODECHAL_ENCODE_HEVC_NUM_SYNC_TAGS;
6577 m_hwInterface->GetStateHeapSettings()->dwDshSize = CODECHAL_INIT_DSH_SIZE_HEVC_ENC;
6578 #if defined(ENABLE_KERNELS) && !defined(_FULL_OPEN_SOURCE)
6579 m_kernelBase = (uint8_t*)IGCODECKRN_G12;
6580 #endif
6581
6582 MOS_STATUS eStatus = CodecHalGetKernelBinaryAndSize(
6583 m_kernelBase,
6584 m_kuidCommon,
6585 &m_kernelBinary,
6586 &m_combinedKernelSize);
6587 CODECHAL_ENCODE_ASSERT(eStatus == MOS_STATUS_SUCCESS);
6588
6589 m_hwInterface->GetStateHeapSettings()->dwIshSize +=
6590 MOS_ALIGN_CEIL(m_combinedKernelSize, (1 << MHW_KERNEL_OFFSET_SHIFT));
6591
6592 m_hwInterface->m_hucCommandBufferSize += 64;
6593
6594 m_osInterface->pfnVirtualEngineSupported(m_osInterface, false, true);
6595 Mos_SetVirtualEngineSupported(m_osInterface, true);
6596
6597 CODECHAL_DEBUG_TOOL(
6598 CODECHAL_ENCODE_CHK_NULL_NO_STATUS_RETURN(m_encodeParState = MOS_New(CodechalDebugEncodeParG12, this));
6599 )
6600 }
6601
6602 MOS_STATUS CodechalVdencHevcStateG12::SetGpuCtxCreatOption()
6603 {
6604 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6605
6606 CODECHAL_ENCODE_FUNCTION_ENTER;
6607
6608 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
6609 {
6610 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::SetGpuCtxCreatOption());
6611 }
6612 else
6613 {
6614 m_gpuCtxCreatOpt = MOS_New(MOS_GPUCTX_CREATOPTIONS_ENHANCED);
6615 CODECHAL_ENCODE_CHK_NULL_RETURN(m_gpuCtxCreatOpt);
6616
6617 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncodeScalability_ConstructParmsForGpuCtxCreation(
6618 m_scalabilityState,
6619 (PMOS_GPUCTX_CREATOPTIONS_ENHANCED)m_gpuCtxCreatOpt));
6620 }
6621
6622 return eStatus;
6623 }
6624
6625 MOS_STATUS CodechalVdencHevcStateG12::SetRegionsHuCPakIntegrate(
6626 PMHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams)
6627 {
6628 CODECHAL_ENCODE_FUNCTION_ENTER;
6629
6630 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6631
6632 int32_t currentPass = GetCurrentPass();
6633
6634 if(m_enableTileStitchByHW)
6635 {
6636 CODECHAL_ENCODE_CHK_STATUS_RETURN(ConfigStitchDataBuffer());
6637 }
6638
6639 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
6640 CODECHAL_ENCODE_CHK_NULL_RETURN(tileParams);
6641
6642 MOS_ZeroMemory(virtualAddrParams, sizeof(MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS));
6643
6644 // Add Virtual addr
6645 virtualAddrParams->regionParams[0].presRegion = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource; // Region 0 - Tile based input statistics from PAK/ VDEnc
6646 virtualAddrParams->regionParams[0].dwOffset = 0;
6647 virtualAddrParams->regionParams[1].presRegion = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Region 1 - HuC Frame statistics output
6648 virtualAddrParams->regionParams[1].isWritable = true;
6649 virtualAddrParams->regionParams[4].presRegion = &m_resBitstreamBuffer; // Region 4 - Last Tile bitstream
6650 virtualAddrParams->regionParams[4].dwOffset = MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
6651 virtualAddrParams->regionParams[5].presRegion = &m_resBitstreamBuffer; // Region 5 - HuC modifies the last tile bitstream before stitch command
6652 virtualAddrParams->regionParams[5].dwOffset = MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
6653 virtualAddrParams->regionParams[5].isWritable = true;
6654 virtualAddrParams->regionParams[6].presRegion = &m_vdencBrcHistoryBuffer; // Region 6 History Buffer (Input/Output)
6655 virtualAddrParams->regionParams[6].isWritable = true;
6656 virtualAddrParams->regionParams[7].presRegion = &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource; // Region 7 - HCP PIC state command
6657 virtualAddrParams->regionParams[9].presRegion = &m_resBrcDataBuffer; // Region 9 HuC outputs BRC data
6658 virtualAddrParams->regionParams[9].isWritable = true;
6659 if (m_enableTileStitchByHW)
6660 {
6661 virtualAddrParams->regionParams[8].presRegion = &m_resHucStitchDataBuffer[m_currRecycledBufIdx][currentPass]; // Region 8 - data buffer read by HUC for stitching cmd generation
6662 virtualAddrParams->regionParams[10].presRegion = &m_HucStitchCmdBatchBuffer.OsResource; // Region 10 - SLB for stitching cmd output from Huc
6663 virtualAddrParams->regionParams[10].isWritable = true;
6664 }
6665 virtualAddrParams->regionParams[15].presRegion = &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource; // Region 15 [In/Out] - Tile Record Buffer
6666 virtualAddrParams->regionParams[15].dwOffset = 0;
6667
6668 return eStatus;
6669 }
6670
6671 MOS_STATUS CodechalVdencHevcStateG12::ConfigStitchDataBuffer()
6672 {
6673 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6674 CODECHAL_ENCODE_FUNCTION_ENTER;
6675 int32_t currentPass = GetCurrentPass();
6676 if (currentPass < 0 ||
6677 (currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES && m_brcEnabled))
6678 {
6679 eStatus = MOS_STATUS_INVALID_PARAMETER;
6680 return eStatus;
6681 }
6682
6683 MOS_LOCK_PARAMS lockFlagsWriteOnly;
6684 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
6685 lockFlagsWriteOnly.WriteOnly = 1;
6686
6687 HucCommandDataVdencG12 *hucStitchDataBuf = (HucCommandDataVdencG12 *)m_osInterface->pfnLockResource(m_osInterface, &m_resHucStitchDataBuffer[m_currRecycledBufIdx][currentPass], &lockFlagsWriteOnly);
6688
6689 MOS_ZeroMemory(hucStitchDataBuf, sizeof(HucCommandDataVdencG12));
6690 hucStitchDataBuf->TotalCommands = 1;
6691 hucStitchDataBuf->InputCOM[0].SizeOfData = 0xF;
6692
6693 HucInputCmdVdencG12 hucInputCmd;
6694 MOS_ZeroMemory(&hucInputCmd, sizeof(HucInputCmdVdencG12));
6695
6696 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
6697 hucInputCmd.SelectionForIndData = m_osInterface->osCpInterface->IsCpEnabled() ? 4 : 0;
6698 hucInputCmd.CmdMode = HUC_CMD_LIST_MODE;
6699 hucInputCmd.LengthOfTable = (uint8_t)(m_numTiles);
6700 hucInputCmd.CopySize = m_hwInterface->m_tileRecordSize;
6701
6702 PMOS_RESOURCE presSrc = &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource;
6703
6704 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnRegisterResource(
6705 m_osInterface,
6706 presSrc,
6707 false,
6708 false));
6709 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnRegisterResource(
6710 m_osInterface,
6711 &m_resBitstreamBuffer,
6712 true,
6713 true));
6714
6715 uint64_t srcAddr = m_osInterface->pfnGetResourceGfxAddress(m_osInterface, presSrc);
6716 uint64_t destAddr = m_osInterface->pfnGetResourceGfxAddress(m_osInterface, &m_resBitstreamBuffer);
6717 hucInputCmd.SrcAddrBottom = (uint32_t)(srcAddr & 0x00000000FFFFFFFF);
6718 hucInputCmd.SrcAddrTop = (uint32_t)((srcAddr & 0xFFFFFFFF00000000) >> 32);
6719
6720 hucInputCmd.DestAddrBottom = (uint32_t)(destAddr & 0x00000000FFFFFFFF);
6721 hucInputCmd.DestAddrTop = (uint32_t)((destAddr & 0xFFFFFFFF00000000) >> 32);
6722
6723 MOS_SecureMemcpy(hucStitchDataBuf->InputCOM[0].data, sizeof(HucInputCmdVdencG12), &hucInputCmd, sizeof(HucInputCmdVdencG12));
6724
6725 m_osInterface->pfnUnlockResource(m_osInterface, &m_resHucStitchDataBuffer[m_currRecycledBufIdx][currentPass]);
6726
6727 return eStatus;
6728 }
6729
6730 MOS_STATUS CodechalVdencHevcStateG12::SetRegionsHuCPakIntegrateStitch(
6731 PMHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams)
6732 {
6733 CODECHAL_ENCODE_FUNCTION_ENTER;
6734
6735 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6736
6737 int32_t currentPass = GetCurrentPass();
6738
6739 MOS_ZeroMemory(virtualAddrParams, sizeof(MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS));
6740
6741 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
6742 CODECHAL_ENCODE_CHK_NULL_RETURN(tileParams);
6743
6744 CODECHAL_ENCODE_CHK_STATUS_RETURN(ConfigStitchDataBuffer());
6745
6746 // Add Virtual addr
6747 virtualAddrParams->regionParams[0].presRegion = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource; // Region 0 - Tile based input statistics from PAK/ VDEnc
6748 virtualAddrParams->regionParams[0].dwOffset = 0;
6749 virtualAddrParams->regionParams[1].presRegion = &m_resHuCPakAggregatedFrameStatsBuffer.sResource; // Region 1 - HuC Frame statistics output
6750 virtualAddrParams->regionParams[1].isWritable = true;
6751 virtualAddrParams->regionParams[4].presRegion = &m_resBitstreamBuffer; // Region 4 - Last Tile bitstream
6752 virtualAddrParams->regionParams[4].dwOffset = MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
6753 virtualAddrParams->regionParams[5].presRegion = &m_resBitstreamBuffer; // Region 5 - HuC modifies the last tile bitstream before stitch command
6754 virtualAddrParams->regionParams[5].dwOffset = MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
6755 virtualAddrParams->regionParams[5].isWritable = true;
6756 virtualAddrParams->regionParams[6].presRegion = &m_vdencBrcHistoryBuffer; // Region 6 History Buffer (Input/Output)
6757 virtualAddrParams->regionParams[6].isWritable = true;
6758 virtualAddrParams->regionParams[7].presRegion = &m_thirdLevelBatchBuffer.OsResource; //&m_resHucPakStitchReadBatchBuffer; // Region 7 - HCP PIC state command
6759 virtualAddrParams->regionParams[8].presRegion = &m_resHucStitchDataBuffer[m_currRecycledBufIdx][currentPass]; // Region 8 - data buffer read by HUC for stitching cmd generation
6760 virtualAddrParams->regionParams[9].presRegion = &m_resBrcDataBuffer; // Region 9 HuC outputs BRC data
6761 virtualAddrParams->regionParams[9].isWritable = true;
6762 virtualAddrParams->regionParams[10].presRegion = &m_HucStitchCmdBatchBuffer.OsResource; // Region 10 - SLB for stitching cmd output from Huc
6763 virtualAddrParams->regionParams[10].isWritable = true;
6764 virtualAddrParams->regionParams[15].presRegion = &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource; // Region 15 [In/Out] - Tile Record Buffer
6765 virtualAddrParams->regionParams[15].dwOffset = 0;
6766 return eStatus;
6767 }
6768
6769 MOS_STATUS CodechalVdencHevcStateG12::SetDmemHuCPakIntegrateStitch(
6770 PMHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams)
6771 {
6772 CODECHAL_ENCODE_FUNCTION_ENTER;
6773
6774 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6775
6776 MOS_LOCK_PARAMS lockFlagsWriteOnly;
6777 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
6778 lockFlagsWriteOnly.WriteOnly = true;
6779
6780 int32_t currentPass = GetCurrentPass();
6781
6782 HucPakStitchDmemVdencG12 *hucPakStitchDmem = (HucPakStitchDmemVdencG12 *)m_osInterface->pfnLockResource(
6783 m_osInterface, &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]), &lockFlagsWriteOnly);
6784 CODECHAL_ENCODE_CHK_NULL_RETURN(hucPakStitchDmem);
6785
6786 MOS_ZeroMemory(hucPakStitchDmem, sizeof(HucPakStitchDmemVdencG12));
6787
6788 // reset all the offsets to -1
6789 uint32_t TotalOffsetSize = sizeof(hucPakStitchDmem->TileSizeRecord_offset) +
6790 sizeof(hucPakStitchDmem->VDENCSTAT_offset) +
6791 sizeof(hucPakStitchDmem->HEVC_PAKSTAT_offset) +
6792 sizeof(hucPakStitchDmem->HEVC_Streamout_offset) +
6793 sizeof(hucPakStitchDmem->VP9_PAK_STAT_offset) +
6794 sizeof(hucPakStitchDmem->Vp9CounterBuffer_offset);
6795 MOS_FillMemory(hucPakStitchDmem, TotalOffsetSize, 0xFF);
6796
6797 uint16_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
6798 uint16_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
6799 CODECHAL_ENCODE_ASSERT(numTileColumns > 0 && numTileColumns % 2 == 0); //numTileColumns is nonzero and even number; 2 or 4
6800 CODECHAL_ENCODE_ASSERT(m_numPipe > 0 && m_numPipe % 2 == 0 && numTileColumns <= m_numPipe); //ucNumPipe is nonzero and even number; 2 or 4
6801 uint16_t numTiles = numTileRows * numTileColumns;
6802 uint16_t numTilesPerPipe = m_numTiles / m_numPipe;
6803 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
6804 CODECHAL_ENCODE_CHK_NULL_RETURN(tileParams);
6805
6806 hucPakStitchDmem->PicWidthInPixel = (uint16_t)m_frameWidth;
6807 hucPakStitchDmem->PicHeightInPixel = (uint16_t)m_frameHeight;
6808 hucPakStitchDmem->TotalNumberOfPAKs = 0;
6809 hucPakStitchDmem->Codec = 2; //HEVC DP CQP
6810 hucPakStitchDmem->MAXPass = 1;
6811 hucPakStitchDmem->CurrentPass = 1;
6812 hucPakStitchDmem->MinCUSize = m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3;
6813 hucPakStitchDmem->CabacZeroWordFlag = false;
6814 hucPakStitchDmem->bitdepth_luma = m_hevcSeqParams->bit_depth_luma_minus8 + 8; // default: 8
6815 hucPakStitchDmem->bitdepth_chroma = m_hevcSeqParams->bit_depth_chroma_minus8 + 8; // default: 8
6816 hucPakStitchDmem->ChromaFormatIdc = m_hevcSeqParams->chroma_format_idc;
6817 hucPakStitchDmem->TotalSizeInCommandBuffer = m_numTiles * CODECHAL_CACHELINE_SIZE;
6818 // Last tile length may get modified by HuC. Obtain last Tile Record, Add an offset of 8bytes to skip address field in Tile Record
6819 hucPakStitchDmem->OffsetInCommandBuffer = tileParams[m_numTiles - 1].TileSizeStreamoutOffset * CODECHAL_CACHELINE_SIZE + 8;
6820 hucPakStitchDmem->LastTileBS_StartInBytes = (tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE) & (CODECHAL_PAGE_SIZE - 1);
6821
6822 hucPakStitchDmem->StitchEnable = true;
6823 hucPakStitchDmem->StitchCommandOffset = 0;
6824 hucPakStitchDmem->BBEndforStitch = HUC_BATCH_BUFFER_END;
6825
6826 //Set the kernel output offsets
6827 hucPakStitchDmem->TileSizeRecord_offset[0] = m_hevcFrameStatsOffset.uiTileSizeRecord;
6828 hucPakStitchDmem->HEVC_PAKSTAT_offset[0] = 0xFFFFFFFF;
6829 hucPakStitchDmem->HEVC_Streamout_offset[0] = 0xFFFFFFFF;
6830 hucPakStitchDmem->VDENCSTAT_offset[0] = 0xFFFFFFFF;
6831
6832 for (auto i = 0; i < m_numPipe; i++)
6833 {
6834 hucPakStitchDmem->NumTiles[i] = numTilesPerPipe;
6835
6836 // Statistics are dumped out at a tile level. Driver shares with kernel starting offset of each pipe statistic.
6837 // Offset is calculated by adding size of statistics/pipe to the offset in combined statistics region.
6838 hucPakStitchDmem->TileSizeRecord_offset[i + 1] = (i * numTilesPerPipe * m_hevcStatsSize.uiTileSizeRecord) +
6839 m_hevcTileStatsOffset.uiTileSizeRecord;
6840 }
6841
6842 m_osInterface->pfnUnlockResource(m_osInterface, &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]));
6843
6844 MOS_ZeroMemory(dmemParams, sizeof(MHW_VDBOX_HUC_DMEM_STATE_PARAMS));
6845 dmemParams->presHucDataSource = &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]);
6846 dmemParams->dwDataLength = MOS_ALIGN_CEIL(sizeof(HucPakStitchDmemVdencG12), CODECHAL_CACHELINE_SIZE);
6847 dmemParams->dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
6848
6849 return eStatus;
6850 }
6851
6852 MOS_STATUS CodechalVdencHevcStateG12::SetDmemHuCPakIntegrate(
6853 PMHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams)
6854 {
6855 CODECHAL_ENCODE_FUNCTION_ENTER;
6856
6857 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
6858
6859 MOS_LOCK_PARAMS lockFlagsWriteOnly;
6860 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
6861 lockFlagsWriteOnly.WriteOnly = true;
6862
6863 int32_t currentPass = GetCurrentPass();
6864 if (currentPass < 0 || currentPass >= CODECHAL_VDENC_BRC_NUM_OF_PASSES)
6865 {
6866 eStatus = MOS_STATUS_INVALID_PARAMETER;
6867 return eStatus;
6868 }
6869
6870 HucPakStitchDmemVdencG12* hucPakStitchDmem = (HucPakStitchDmemVdencG12*)m_osInterface->pfnLockResource(
6871 m_osInterface, &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]), &lockFlagsWriteOnly);
6872 CODECHAL_ENCODE_CHK_NULL_RETURN(hucPakStitchDmem);
6873 MOS_ZeroMemory(hucPakStitchDmem, sizeof(HucPakStitchDmemVdencG12));
6874
6875 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
6876 CODECHAL_ENCODE_CHK_NULL_RETURN(tileParams);
6877
6878 // Reset all the offsets to be shared in the huc dmem (6*5 DW's)
6879 MOS_FillMemory(hucPakStitchDmem, 120, 0xFF);
6880
6881 uint16_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
6882 uint16_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
6883 uint16_t numTiles = numTileRows * numTileColumns;
6884 uint16_t numTilesPerPipe = m_numTiles / m_numPipe;
6885
6886 hucPakStitchDmem->TotalSizeInCommandBuffer = m_numTiles * CODECHAL_CACHELINE_SIZE;
6887 // Last tile length may get modified by HuC. Obtain last Tile Record, Add an offset of 8bytes to skip address field in Tile Record
6888 hucPakStitchDmem->OffsetInCommandBuffer = (m_numTiles - 1) * CODECHAL_CACHELINE_SIZE + 8;
6889 hucPakStitchDmem->PicWidthInPixel = (uint16_t)m_frameWidth;
6890 hucPakStitchDmem->PicHeightInPixel = (uint16_t)m_frameHeight;
6891 hucPakStitchDmem->TotalNumberOfPAKs = m_numPipe;
6892 hucPakStitchDmem->Codec = 2; // 1: HEVC DP; 2: HEVC VDEnc; 3: VP9 VDEnc
6893 hucPakStitchDmem->MAXPass = m_brcEnabled ? CODECHAL_VDENC_BRC_NUM_OF_PASSES : 1;
6894 hucPakStitchDmem->CurrentPass = (uint8_t) currentPass + 1; // Current BRC pass [1..MAXPass]
6895 hucPakStitchDmem->MinCUSize = m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3;
6896 hucPakStitchDmem->CabacZeroWordFlag = false;
6897 hucPakStitchDmem->bitdepth_luma = m_hevcSeqParams->bit_depth_luma_minus8 + 8; // default: 8
6898 hucPakStitchDmem->bitdepth_chroma = m_hevcSeqParams->bit_depth_chroma_minus8 + 8; // default: 8
6899 hucPakStitchDmem->ChromaFormatIdc = m_hevcSeqParams->chroma_format_idc;
6900 hucPakStitchDmem->LastTileBS_StartInBytes = (tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE) & (CODECHAL_PAGE_SIZE - 1);
6901 hucPakStitchDmem->PIC_STATE_StartInBytes = (uint16_t)m_picStateCmdStartInBytes;
6902 CODECHAL_ENCODE_VERBOSEMESSAGE("last tile offset = 0x%x, LastTileBS_StartInBytes =0x%x, (tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE), hucPakStitchDmem->LastTileBS_StartInBytes");
6903 if(m_enableTileStitchByHW)
6904 {
6905 hucPakStitchDmem->StitchEnable = true;
6906 hucPakStitchDmem->StitchCommandOffset = 0;
6907 hucPakStitchDmem->BBEndforStitch = HUC_BATCH_BUFFER_END;
6908 }
6909
6910 if (m_numPipe > 1)
6911 {
6912 //Set the kernel output offsets
6913 hucPakStitchDmem->HEVC_PAKSTAT_offset[0] = m_hevcFrameStatsOffset.uiHevcPakStatistics;
6914 hucPakStitchDmem->HEVC_Streamout_offset[0] = m_hevcFrameStatsOffset.uiHevcSliceStreamout;
6915 hucPakStitchDmem->TileSizeRecord_offset[0] = m_hevcFrameStatsOffset.uiTileSizeRecord;
6916 hucPakStitchDmem->VDENCSTAT_offset[0] = m_hevcFrameStatsOffset.uiVdencStatistics;
6917
6918 // Calculate number of slices that execute on a single pipe
6919 for (auto tileRow = 0; tileRow < numTileRows; tileRow++)
6920 {
6921 for (auto tileCol = 0; tileCol < numTileColumns; tileCol++)
6922 {
6923 PCODEC_ENCODER_SLCDATA slcData = m_slcData;
6924 uint16_t slcCount, idx, sliceNumInTile = 0;
6925
6926 idx = tileRow * numTileColumns + tileCol;
6927 for (slcCount = 0; slcCount < m_numSlices; slcCount++)
6928 {
6929 bool lastSliceInTile = false, sliceInTile = false;
6930
6931 CODECHAL_ENCODE_CHK_STATUS_RETURN(IsSliceInTile(slcCount,
6932 &tileParams[idx],
6933 &sliceInTile,
6934 &lastSliceInTile));
6935
6936 if (!sliceInTile)
6937 {
6938 continue;
6939 }
6940
6941 sliceNumInTile++;
6942 } // end of slice
6943 if (0 == sliceNumInTile)
6944 {
6945 // One tile must have at least one slice
6946 CODECHAL_ENCODE_ASSERT(false);
6947 eStatus = MOS_STATUS_INVALID_PARAMETER;
6948 break;
6949 }
6950
6951 if (sliceNumInTile > 1 && (numTileColumns > 1 || numTileRows > 1))
6952 {
6953 CODECHAL_ENCODE_ASSERTMESSAGE("Multi-slices in a tile is not supported!");
6954 return MOS_STATUS_INVALID_PARAMETER;
6955 }
6956 // Set the number of slices per pipe in the Dmem structure
6957 hucPakStitchDmem->NumSlices[tileCol] += sliceNumInTile;
6958 }
6959 }
6960
6961 for (auto i = 0; i < m_numPipe; i++)
6962 {
6963 hucPakStitchDmem->NumTiles[i] = numTilesPerPipe;
6964 hucPakStitchDmem->NumSlices[i] = numTilesPerPipe; // Assuming 1 slice/ tile. To do: change this later.
6965
6966 // Statistics are dumped out at a tile level. Driver shares with kernel starting offset of each pipe statistic.
6967 // Offset is calculated by adding size of statistics/pipe to the offset in combined statistics region.
6968 hucPakStitchDmem->TileSizeRecord_offset[i + 1] = (i * numTilesPerPipe * m_hevcStatsSize.uiTileSizeRecord) + m_hevcTileStatsOffset.uiTileSizeRecord;
6969 hucPakStitchDmem->HEVC_PAKSTAT_offset[i + 1] = (i * numTilesPerPipe * m_hevcStatsSize.uiHevcPakStatistics) + m_hevcTileStatsOffset.uiHevcPakStatistics;
6970 hucPakStitchDmem->VDENCSTAT_offset[i + 1] = (i * numTilesPerPipe * m_hevcStatsSize.uiVdencStatistics) + m_hevcTileStatsOffset.uiVdencStatistics;
6971 hucPakStitchDmem->HEVC_Streamout_offset[i + 1] = (i * hucPakStitchDmem->NumSlices[i] * CODECHAL_CACHELINE_SIZE) + m_hevcTileStatsOffset.uiHevcSliceStreamout;
6972 }
6973 }
6974 else
6975 {
6976 hucPakStitchDmem->NumTiles[0] = numTiles;
6977 hucPakStitchDmem->TotalNumberOfPAKs = m_numPipe;
6978
6979 // non-scalable mode, only VDEnc statistics need to be aggregated
6980 hucPakStitchDmem->VDENCSTAT_offset[0] = m_hevcFrameStatsOffset.uiVdencStatistics;
6981 hucPakStitchDmem->VDENCSTAT_offset[1] = m_hevcTileStatsOffset.uiVdencStatistics;
6982 }
6983
6984 m_osInterface->pfnUnlockResource(m_osInterface, &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]));
6985
6986 MOS_ZeroMemory(dmemParams, sizeof(MHW_VDBOX_HUC_DMEM_STATE_PARAMS));
6987 dmemParams->presHucDataSource = &(m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass]);
6988 dmemParams->dwDataLength = MOS_ALIGN_CEIL(sizeof(HucPakStitchDmemVdencG12), CODECHAL_CACHELINE_SIZE);
6989 dmemParams->dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
6990
6991 return eStatus;
6992 }
6993
6994 MOS_STATUS CodechalVdencHevcStateG12::HucPakIntegrate(
6995 PMOS_COMMAND_BUFFER cmdBuffer)
6996 {
6997 CODECHAL_ENCODE_FUNCTION_ENTER;
6998
6999 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7000
7001 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7002
7003 CODECHAL_ENCODE_CHK_COND_RETURN(
7004 (m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()),
7005 "ERROR - vdbox index exceed the maximum");
7006
7007 auto mmioRegisters = m_hwInterface->GetHucInterface()->GetMmioRegisters(m_vdboxIndex);
7008
7009 // load kernel from WOPCM into L2 storage RAM
7010 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
7011 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
7012 imemParams.dwKernelDescriptor = VDBOX_HUC_PAK_INTEGRATION_KERNEL_DESCRIPTOR;
7013
7014 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucImemStateCmd(cmdBuffer, &imemParams));
7015
7016 // pipe mode select
7017 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
7018 pipeModeSelectParams.Mode = m_mode;
7019 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
7020
7021 // DMEM set
7022 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
7023 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCPakIntegrate(&dmemParams));
7024 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucDmemStateCmd(cmdBuffer, &dmemParams));
7025
7026 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
7027 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRegionsHuCPakIntegrate(&virtualAddrParams));
7028 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucVirtualAddrStateCmd(cmdBuffer, &virtualAddrParams));
7029
7030 // Write HUC_STATUS2 mask - bit 6 - valid IMEM loaded
7031 MHW_MI_STORE_DATA_PARAMS storeDataParams;
7032 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
7033 storeDataParams.pOsResource = &m_resHucStatus2Buffer;
7034 storeDataParams.dwResourceOffset = 0;
7035 storeDataParams.dwValue = m_hwInterface->GetHucInterface()->GetHucStatus2ImemLoadedMask();
7036 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
7037
7038 // Store HUC_STATUS2 register
7039 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
7040 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
7041 storeRegParams.presStoreBuffer = &m_resHucStatus2Buffer;
7042 storeRegParams.dwOffset = sizeof(uint32_t);
7043 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
7044 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &storeRegParams));
7045
7046 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(cmdBuffer));
7047
7048 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucStartCmd(cmdBuffer, true));
7049
7050 // wait Huc completion (use HEVC bit for now)
7051 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
7052 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
7053 vdPipeFlushParams.Flags.bFlushHEVC = 1;
7054 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
7055 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetVdencInterface()->AddVdPipelineFlushCmd(cmdBuffer, &vdPipeFlushParams));
7056
7057 // Flush the engine to ensure memory written out
7058 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
7059 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
7060 flushDwParams.bVideoPipelineCacheInvalidate = true;
7061 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
7062
7063 EncodeStatusBuffer encodeStatusBuf = m_encodeStatusBuf;
7064
7065 uint32_t baseOffset =
7066 (encodeStatusBuf.wCurrIndex * encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
7067
7068 // Write HUC_STATUS mask
7069 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
7070 storeDataParams.pOsResource = &encodeStatusBuf.resStatusBuffer;
7071 storeDataParams.dwResourceOffset = baseOffset + encodeStatusBuf.dwHuCStatusMaskOffset;
7072 storeDataParams.dwValue = m_hwInterface->GetHucInterface()->GetHucStatusReEncodeMask();
7073 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
7074 cmdBuffer,
7075 &storeDataParams));
7076
7077 // store HUC_STATUS register
7078 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
7079 storeRegParams.presStoreBuffer = &encodeStatusBuf.resStatusBuffer;
7080 storeRegParams.dwOffset = baseOffset + encodeStatusBuf.dwHuCStatusRegOffset;
7081 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
7082 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
7083 cmdBuffer,
7084 &storeRegParams));
7085
7086 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHucErrorStatus(mmioRegisters, cmdBuffer, false));
7087 CODECHAL_ENCODE_CHK_STATUS_RETURN(InsertConditionalBBEndWithHucErrorStatus(cmdBuffer));
7088
7089 return eStatus;
7090 }
7091
7092 MOS_STATUS CodechalVdencHevcStateG12::HucPakIntegrateStitch(
7093 PMOS_COMMAND_BUFFER cmdBuffer)
7094 {
7095 CODECHAL_ENCODE_FUNCTION_ENTER;
7096
7097 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7098
7099 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7100
7101 CODECHAL_ENCODE_CHK_COND_RETURN(
7102 (m_vdboxIndex > m_hwInterface->GetMfxInterface()->GetMaxVdboxIndex()),
7103 "ERROR - vdbox index exceed the maximum");
7104
7105 auto mmioRegisters = m_hwInterface->GetHucInterface()->GetMmioRegisters(m_vdboxIndex);
7106
7107 // load kernel from WOPCM into L2 storage RAM
7108 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
7109 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
7110 imemParams.dwKernelDescriptor = VDBOX_HUC_PAK_INTEGRATION_KERNEL_DESCRIPTOR;
7111
7112 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucImemStateCmd(cmdBuffer, &imemParams));
7113
7114 // pipe mode select
7115 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
7116 pipeModeSelectParams.Mode = m_mode;
7117 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucPipeModeSelectCmd(cmdBuffer, &pipeModeSelectParams));
7118
7119 // DMEM set
7120 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
7121 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCPakIntegrateStitch(&dmemParams));
7122 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucDmemStateCmd(cmdBuffer, &dmemParams));
7123
7124 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
7125 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRegionsHuCPakIntegrateStitch(&virtualAddrParams));
7126 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucVirtualAddrStateCmd(cmdBuffer, &virtualAddrParams));
7127
7128 // Write HUC_STATUS2 mask - bit 6 - valid IMEM loaded
7129 MHW_MI_STORE_DATA_PARAMS storeDataParams;
7130 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
7131 storeDataParams.pOsResource = &m_resHucStatus2Buffer;
7132 storeDataParams.dwResourceOffset = 0;
7133 storeDataParams.dwValue = m_hwInterface->GetHucInterface()->GetHucStatus2ImemLoadedMask();
7134 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(cmdBuffer, &storeDataParams));
7135
7136 // Store HUC_STATUS2 register
7137 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
7138 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
7139 storeRegParams.presStoreBuffer = &m_resHucStatus2Buffer;
7140 storeRegParams.dwOffset = sizeof(uint32_t);
7141 storeRegParams.dwRegister = mmioRegisters->hucStatus2RegOffset;
7142 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(cmdBuffer, &storeRegParams));
7143
7144 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(cmdBuffer));
7145
7146 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetHucInterface()->AddHucStartCmd(cmdBuffer, true));
7147
7148 // wait Huc completion (use HEVC bit for now)
7149 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
7150 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
7151 vdPipeFlushParams.Flags.bFlushHEVC = 1;
7152 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
7153 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetVdencInterface()->AddVdPipelineFlushCmd(cmdBuffer, &vdPipeFlushParams));
7154
7155 // Flush the engine to ensure memory written out
7156 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
7157 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
7158 flushDwParams.bVideoPipelineCacheInvalidate = true;
7159 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(cmdBuffer, &flushDwParams));
7160
7161 EncodeStatusBuffer encodeStatusBuf = m_encodeStatusBuf;
7162
7163 uint32_t baseOffset =
7164 (encodeStatusBuf.wCurrIndex * encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
7165
7166 // Write HUC_STATUS mask
7167 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
7168 storeDataParams.pOsResource = &encodeStatusBuf.resStatusBuffer;
7169 storeDataParams.dwResourceOffset = baseOffset + encodeStatusBuf.dwHuCStatusMaskOffset;
7170 storeDataParams.dwValue = m_hwInterface->GetHucInterface()->GetHucStatusReEncodeMask();
7171 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(
7172 cmdBuffer,
7173 &storeDataParams));
7174
7175 // store HUC_STATUS register
7176 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
7177 storeRegParams.presStoreBuffer = &encodeStatusBuf.resStatusBuffer;
7178 storeRegParams.dwOffset = baseOffset + encodeStatusBuf.dwHuCStatusRegOffset;
7179 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
7180 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(
7181 cmdBuffer,
7182 &storeRegParams));
7183
7184 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHucErrorStatus(mmioRegisters, cmdBuffer, false));
7185 CODECHAL_ENCODE_CHK_STATUS_RETURN(InsertConditionalBBEndWithHucErrorStatus(cmdBuffer));
7186
7187 return eStatus;
7188 }
7189
7190 void CodechalVdencHevcStateG12::CreateMhwParams()
7191 {
7192 m_sliceStateParams = MOS_New(MHW_VDBOX_HEVC_SLICE_STATE_G12);
7193 m_pipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12);
7194 m_pipeBufAddrParams = MOS_New(MHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12);
7195 }
7196
7197 MOS_STATUS CodechalVdencHevcStateG12::CalculatePictureStateCommandSize()
7198 {
7199 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7200
7201 CODECHAL_ENCODE_FUNCTION_ENTER;
7202
7203 MHW_VDBOX_STATE_CMDSIZE_PARAMS_G12 stateCmdSizeParams;
7204 CODECHAL_ENCODE_CHK_STATUS_RETURN(
7205 m_hwInterface->GetHxxStateCommandSize(
7206 CODECHAL_ENCODE_MODE_HEVC,
7207 &m_defaultPictureStatesSize,
7208 &m_defaultPicturePatchListSize,
7209 &stateCmdSizeParams));
7210
7211 return eStatus;
7212 }
7213
7214 MOS_STATUS CodechalVdencHevcStateG12::AddHcpPipeBufAddrCmd(
7215 PMOS_COMMAND_BUFFER cmdBuffer)
7216 {
7217 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7218
7219 CODECHAL_ENCODE_FUNCTION_ENTER;
7220
7221 m_mmcState->SetPipeBufAddr(m_pipeBufAddrParams);
7222 // Recon P010v MMC state set from RC for compression write
7223 // Reference P010v MMC state set from MC for compression read
7224 if (m_reconSurface.Format == Format_P010 && m_pipeBufAddrParams && MmcEnable(m_pipeBufAddrParams->PreDeblockSurfMmcState))
7225 {
7226 auto paramsG12 = dynamic_cast<PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS_G12>(m_pipeBufAddrParams);
7227 MHW_CHK_NULL_RETURN(paramsG12);
7228 paramsG12->bSpecificReferencedMmcRequired = true;
7229 paramsG12->ReferencesMmcState = m_pipeBufAddrParams->PreDeblockSurfMmcState;
7230
7231 m_pipeBufAddrParams->PreDeblockSurfMmcState = MOS_MEMCOMP_RC;
7232 }
7233
7234 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hcpInterface->AddHcpPipeBufAddrCmd(cmdBuffer, m_pipeBufAddrParams));
7235
7236 return eStatus;
7237 }
7238
7239 MOS_STATUS CodechalVdencHevcStateG12::SetTileData(
7240 MHW_VDBOX_HCP_TILE_CODING_PARAMS_G12* tileCodingParams)
7241 {
7242 CODECHAL_ENCODE_FUNCTION_ENTER;
7243
7244 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7245
7246 if (!m_hevcPicParams->tiles_enabled_flag)
7247 {
7248 return eStatus;
7249 }
7250
7251 uint32_t colBd[100] = { 0 };
7252 uint32_t numTileColumns = m_hevcPicParams->num_tile_columns_minus1 + 1;
7253 for (uint32_t i = 0; i < numTileColumns; i++)
7254 {
7255 colBd[i + 1] = colBd[i] + m_hevcPicParams->tile_column_width[i];
7256 }
7257
7258 uint32_t rowBd[100] = { 0 };
7259 uint32_t numTileRows = m_hevcPicParams->num_tile_rows_minus1 + 1;
7260 for (uint32_t i = 0; i < numTileRows; i++)
7261 {
7262 rowBd[i + 1] = rowBd[i] + m_hevcPicParams->tile_row_height[i];
7263 }
7264
7265 m_numTiles = numTileRows * numTileColumns;
7266 if (m_numTiles > CODECHAL_GET_WIDTH_IN_BLOCKS(m_frameWidth, CODECHAL_HEVC_VDENC_MIN_TILE_WIDTH_SIZE) *
7267 CODECHAL_GET_HEIGHT_IN_BLOCKS(m_frameHeight, CODECHAL_HEVC_VDENC_MIN_TILE_HEIGHT_SIZE))
7268 {
7269 return MOS_STATUS_INVALID_PARAMETER;
7270 }
7271 m_numTileRows = numTileRows;
7272
7273 uint32_t const numCuRecordTab[] = { 1, 4, 16, 64 }; //LCU: 8x8->1, 16x16->4, 32x32->16, 64x64->64
7274 uint32_t numCuRecord = numCuRecordTab[MOS_MIN(3, m_hevcSeqParams->log2_max_coding_block_size_minus3)];
7275 uint32_t maxBytePerLCU = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
7276 maxBytePerLCU = maxBytePerLCU * maxBytePerLCU; // number of pixels per LCU
7277 maxBytePerLCU = maxBytePerLCU * 3 / (m_is10BitHevc ? 1 : 2); //assume 4:2:0 format
7278 uint32_t bitstreamByteOffset = 0, saoRowstoreOffset = 0, cuLevelStreamoutOffset = 0, sseRowstoreOffset = 0;
7279 int32_t frameWidthInMinCb = m_hevcSeqParams->wFrameWidthInMinCbMinus1 + 1;
7280 int32_t frameHeightInMinCb = m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1;
7281 int32_t shift = m_hevcSeqParams->log2_max_coding_block_size_minus3 - m_hevcSeqParams->log2_min_coding_block_size_minus3;
7282 uint32_t ctbSize = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
7283 uint32_t streamInWidthinLCU = MOS_ROUNDUP_DIVIDE((frameWidthInMinCb << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
7284 uint32_t numLcuInPic = 0;
7285 uint32_t tileStartLCUAddr = 0;
7286
7287 for (uint32_t numLcusInTiles = 0, i = 0; i < numTileRows; i++)
7288 {
7289 for (uint32_t j = 0; j < numTileColumns; j++)
7290 {
7291 numLcuInPic += m_hevcPicParams->tile_row_height[i] * m_hevcPicParams->tile_column_width[j];
7292 }
7293 }
7294
7295 uint32_t numSliceInTile = 0;
7296 uint64_t activeBitstreamSize = (uint64_t)m_encodeParams.dwBitstreamSize;
7297 // There would be padding at the end of last tile in CBR, reserve dedicated part in the BS buf
7298 if (m_hevcSeqParams->RateControlMethod == RATECONTROL_CBR)
7299 {
7300 // Assume max padding num < target frame size derived from target bit rate and frame rate
7301 uint32_t actualFrameRate = m_hevcSeqParams->FrameRate.Numerator / m_hevcSeqParams->FrameRate.Denominator;
7302 uint64_t reservedPart = (uint64_t)m_hevcSeqParams->TargetBitRate / 8 / (uint64_t)actualFrameRate * 1024;
7303
7304 if (reservedPart > activeBitstreamSize)
7305 {
7306 CODECHAL_ENCODE_ASSERTMESSAGE("Frame size cal from target Bit rate is larger than BS buf! Issues in CBR paras!");
7307 return MOS_STATUS_INVALID_PARAMETER;
7308 }
7309
7310 // Capping the reserved part to 1/10 of bs buf size
7311 if (reservedPart > activeBitstreamSize / 10)
7312 {
7313 reservedPart = activeBitstreamSize / 10;
7314 }
7315
7316 activeBitstreamSize -= reservedPart;
7317 }
7318
7319 for (uint32_t numLcusInTiles = 0, i = 0; i < numTileRows; i++)
7320 {
7321 for (uint32_t j = 0; j < numTileColumns; j++)
7322 {
7323 uint32_t idx = i * numTileColumns + j;
7324 uint32_t numLcuInTile = m_hevcPicParams->tile_row_height[i] * m_hevcPicParams->tile_column_width[j];
7325
7326 tileCodingParams[idx].TileStartLCUX = colBd[j];
7327 tileCodingParams[idx].TileStartLCUY = rowBd[i];
7328
7329 tileCodingParams[idx].TileColumnStoreSelect = j % 2;
7330 tileCodingParams[idx].TileRowStoreSelect = i % 2;
7331
7332 if (j != numTileColumns - 1)
7333 {
7334 tileCodingParams[idx].TileWidthInMinCbMinus1 = (m_hevcPicParams->tile_column_width[j] << shift) - 1;
7335 tileCodingParams[idx].IsLastTileofRow = false;
7336 }
7337 else
7338 {
7339 tileCodingParams[idx].TileWidthInMinCbMinus1 = (frameWidthInMinCb - (colBd[j] << shift)) - 1;
7340 tileCodingParams[idx].IsLastTileofRow = true;
7341
7342 }
7343
7344 if (i != numTileRows - 1)
7345 {
7346 tileCodingParams[idx].IsLastTileofColumn = false;
7347 tileCodingParams[idx].TileHeightInMinCbMinus1 = (m_hevcPicParams->tile_row_height[i] << shift) - 1;
7348 }
7349 else
7350 {
7351 tileCodingParams[idx].TileHeightInMinCbMinus1 = (frameHeightInMinCb - (rowBd[i] << shift)) - 1;
7352 tileCodingParams[idx].IsLastTileofColumn = true;
7353 }
7354
7355 tileCodingParams[idx].NumOfTilesInFrame = m_numTiles;
7356 tileCodingParams[idx].NumOfTileColumnsInFrame = numTileColumns;
7357 tileCodingParams[idx].CuRecordOffset = MOS_ALIGN_CEIL(((numCuRecord * numLcusInTiles) * m_hcpInterface->GetHevcEncCuRecordSize()),
7358 CODECHAL_CACHELINE_SIZE) / CODECHAL_CACHELINE_SIZE;
7359 tileCodingParams[idx].NumberOfActiveBePipes = (m_numPipe > 1) ? m_numPipe : 1;
7360
7361 tileCodingParams[idx].PakTileStatisticsOffset = 9 * idx;
7362 tileCodingParams[idx].TileSizeStreamoutOffset = idx;
7363 tileCodingParams[idx].Vp9ProbabilityCounterStreamoutOffset = 0;
7364 tileCodingParams[idx].presHcpSyncBuffer = &m_resHcpScalabilitySyncBuffer.sResource;
7365 tileCodingParams[idx].CuLevelStreamoutOffset = cuLevelStreamoutOffset;
7366 tileCodingParams[idx].SliceSizeStreamoutOffset = numSliceInTile;
7367 tileCodingParams[idx].SseRowstoreOffset = sseRowstoreOffset;
7368 tileCodingParams[idx].BitstreamByteOffset = bitstreamByteOffset;
7369 tileCodingParams[idx].SaoRowstoreOffset = saoRowstoreOffset;
7370
7371 uint32_t tileHeightInLCU = MOS_ROUNDUP_DIVIDE(((tileCodingParams[idx].TileHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
7372 uint32_t tileWidthInLCU = MOS_ROUNDUP_DIVIDE(((tileCodingParams[idx].TileWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
7373
7374 //StreamIn data is 4 Cachelines per LCU
7375 tileCodingParams[idx].TileStreaminOffset = 4 * (tileCodingParams[idx].TileStartLCUY * streamInWidthinLCU + tileCodingParams[idx].TileStartLCUX * tileHeightInLCU);
7376 tileCodingParams[idx].SliceSizeStreamoutOffset = tileStartLCUAddr;
7377 tileStartLCUAddr += (tileWidthInLCU * tileHeightInLCU);
7378
7379 cuLevelStreamoutOffset += (tileCodingParams[idx].TileWidthInMinCbMinus1 + 1) * (tileCodingParams[idx].TileHeightInMinCbMinus1 + 1) * 16 / CODECHAL_CACHELINE_SIZE;
7380 sseRowstoreOffset += ((m_hevcPicParams->tile_column_width[j] + 3) * m_sizeOfSseSrcPixelRowStoreBufferPerLcu) / CODECHAL_CACHELINE_SIZE;
7381 saoRowstoreOffset += (MOS_ALIGN_CEIL(m_hevcPicParams->tile_column_width[j], 4) * CODECHAL_HEVC_SAO_STRMOUT_SIZE_PERLCU) / CODECHAL_CACHELINE_SIZE;
7382
7383 uint64_t totalSizeTemp = (uint64_t)activeBitstreamSize * (uint64_t)numLcuInTile;
7384 uint32_t bitStreamSizePerTile = (uint32_t)(totalSizeTemp / (uint64_t)numLcuInPic) + ((totalSizeTemp % (uint64_t)numLcuInPic) ? 1 : 0);
7385 bitstreamByteOffset += MOS_ALIGN_CEIL(bitStreamSizePerTile, CODECHAL_CACHELINE_SIZE) / CODECHAL_CACHELINE_SIZE;
7386
7387 numLcusInTiles += numLcuInTile;
7388
7389 for (uint32_t slcCount = 0; slcCount < m_numSlices; slcCount++)
7390 {
7391 bool lastSliceInTile = false, sliceInTile = false;
7392 CODECHAL_ENCODE_CHK_STATUS_RETURN(IsSliceInTile(slcCount,
7393 &tileCodingParams[idx],
7394 &sliceInTile,
7395 &lastSliceInTile));
7396 numSliceInTile += (sliceInTile ? 1 : 0);
7397 }
7398 }
7399
7400 // same row store buffer for different tile rows.
7401 saoRowstoreOffset = 0;
7402 sseRowstoreOffset = 0;
7403 }
7404
7405 return eStatus;
7406 }
7407
7408 MOS_STATUS CodechalVdencHevcStateG12::IsSliceInTile(
7409 uint32_t sliceNumber,
7410 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 currentTile,
7411 bool *sliceInTile,
7412 bool *lastSliceInTile)
7413 {
7414 CODECHAL_ENCODE_FUNCTION_ENTER;
7415
7416 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7417
7418 CODECHAL_ENCODE_CHK_NULL_RETURN(currentTile);
7419 CODECHAL_ENCODE_CHK_NULL_RETURN(sliceInTile);
7420 CODECHAL_ENCODE_CHK_NULL_RETURN(lastSliceInTile);
7421
7422 uint32_t shift = m_hevcSeqParams->log2_max_coding_block_size_minus3 - m_hevcSeqParams->log2_min_coding_block_size_minus3;
7423 uint32_t residual = (1 << shift) - 1;
7424 uint32_t frameWidthInLCU = (m_hevcSeqParams->wFrameWidthInMinCbMinus1 + 1 + residual) >> shift;
7425 uint32_t frameHeightInLCU = (m_hevcSeqParams->wFrameHeightInMinCbMinus1 + 1 + residual) >> shift;
7426
7427 PCODEC_HEVC_ENCODE_SLICE_PARAMS hevcSlcParams = &m_hevcSliceParams[sliceNumber];
7428 uint32_t sliceStartLCU = hevcSlcParams->slice_segment_address;
7429 uint32_t sliceLCUx = sliceStartLCU % frameWidthInLCU;
7430 uint32_t sliceLCUy = sliceStartLCU / frameWidthInLCU;
7431
7432 uint32_t tileColumnWidth = (currentTile->TileWidthInMinCbMinus1 + 1 + residual) >> shift;
7433 uint32_t tileRowHeight = (currentTile->TileHeightInMinCbMinus1 + 1 + residual) >> shift;
7434 if (sliceLCUx < currentTile->TileStartLCUX ||
7435 sliceLCUy < currentTile->TileStartLCUY ||
7436 sliceLCUx >= currentTile->TileStartLCUX + tileColumnWidth ||
7437 sliceLCUy >= currentTile->TileStartLCUY + tileRowHeight
7438 )
7439 {
7440 // slice start is not in the tile boundary
7441 *lastSliceInTile = *sliceInTile = false;
7442 return eStatus;
7443 }
7444
7445 sliceLCUx += (hevcSlcParams->NumLCUsInSlice - 1) % tileColumnWidth;
7446 sliceLCUy += (hevcSlcParams->NumLCUsInSlice - 1) / tileColumnWidth;
7447
7448 if (sliceLCUx >= currentTile->TileStartLCUX + tileColumnWidth)
7449 {
7450 sliceLCUx -= tileColumnWidth;
7451 sliceLCUy++;
7452 }
7453
7454 if (sliceLCUx < currentTile->TileStartLCUX ||
7455 sliceLCUy < currentTile->TileStartLCUY ||
7456 sliceLCUx >= currentTile->TileStartLCUX + tileColumnWidth ||
7457 sliceLCUy >= currentTile->TileStartLCUY + tileRowHeight
7458 )
7459 {
7460 // last LCU of the slice is out of the tile boundary
7461 *lastSliceInTile = *sliceInTile = false;
7462 return eStatus;
7463 }
7464
7465 *sliceInTile = true;
7466
7467 sliceLCUx++;
7468 sliceLCUy++;
7469
7470 // the end of slice is at the boundary of tile
7471 *lastSliceInTile = (
7472 sliceLCUx == currentTile->TileStartLCUX + tileColumnWidth &&
7473 sliceLCUy == currentTile->TileStartLCUY + tileRowHeight);
7474
7475 return eStatus;
7476 }
7477
7478 MOS_STATUS CodechalVdencHevcStateG12::InitMmcState()
7479 {
7480 CODECHAL_ENCODE_FUNCTION_ENTER;
7481
7482 m_mmcState = MOS_New(CodechalMmcEncodeHevcG12, m_hwInterface, this);
7483 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
7484
7485 return MOS_STATUS_SUCCESS;
7486 }
7487
7488 #ifdef _MEDIA_RESERVED
7489 MOS_STATUS CodechalVdencHevcStateG12::InitReserveState(CodechalSetting * settings)
7490 {
7491 CODECHAL_ENCODE_FUNCTION_ENTER;
7492
7493 m_rsvdState = MOS_New(CodechalVdencHevcG12Rsvd, m_hwInterface, this);
7494 return MOS_STATUS_SUCCESS;
7495 }
7496 #endif
7497
7498 uint32_t CodechalVdencHevcStateG12::CalculateCommandBufferSize()
7499 {
7500 CODECHAL_ENCODE_FUNCTION_ENTER;
7501
7502 // To be refined later, differentiate BRC and CQP
7503 uint32_t commandBufferSize =
7504 m_pictureStatesSize +
7505 m_extraPictureStatesSize +
7506 (m_sliceStatesSize * m_numSlices) +
7507 m_hucCommandsSize * 5;
7508
7509 if (m_singleTaskPhaseSupported)
7510 {
7511 commandBufferSize *= (m_numPasses + 1);
7512 }
7513
7514 if (m_osInterface->bUsesPatchList && m_hevcPicParams->tiles_enabled_flag)
7515 {
7516 commandBufferSize += (m_tileLevelBatchSize * m_numTiles * CODECHAL_VDENC_BRC_NUM_OF_PASSES);
7517 }
7518
7519 // 4K align since allocation is in chunks of 4K bytes.
7520 commandBufferSize = MOS_ALIGN_CEIL(commandBufferSize, 0x1000);
7521
7522 return commandBufferSize;
7523 }
7524
7525 MOS_STATUS CodechalVdencHevcStateG12::VerifyCommandBufferSize()
7526 {
7527 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7528
7529 CODECHAL_ENCODE_FUNCTION_ENTER;
7530
7531 if (UseRenderCommandBuffer() || m_numPipe == 1)
7532 {
7533 // legacy mode & resize CommandBuffer Size for every BRC pass
7534 if (!m_singleTaskPhaseSupported)
7535 {
7536 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
7537 }
7538 return eStatus;
7539 }
7540
7541 // virtual engine
7542 uint32_t requestedSize =
7543 m_pictureStatesSize +
7544 m_extraPictureStatesSize +
7545 (m_sliceStatesSize * m_numSlices);
7546
7547 requestedSize += (requestedSize * m_numPassesInOnePipe + m_hucCommandsSize);
7548
7549 // Running in the multiple VDBOX mode
7550 int currentPipe = GetCurrentPipe();
7551 if (currentPipe < 0 || currentPipe >= m_numPipe)
7552 {
7553 eStatus = MOS_STATUS_INVALID_PARAMETER;
7554 return eStatus;
7555 }
7556 int currentPass = GetCurrentPass();
7557 if (currentPass < 0 || currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES)
7558 {
7559 eStatus = MOS_STATUS_INVALID_PARAMETER;
7560 return eStatus;
7561 }
7562
7563 if (IsFirstPipe() && m_osInterface->bUsesPatchList)
7564 {
7565 CODECHAL_ENCODE_CHK_STATUS_RETURN(VerifySpaceAvailable());
7566 }
7567
7568 PMOS_COMMAND_BUFFER pCmdBuffer;
7569 if (m_osInterface->phasedSubmission)
7570 {
7571 m_osInterface->pfnVerifyCommandBufferSize(m_osInterface, requestedSize, 0);
7572 return eStatus;
7573 }
7574 else
7575 {
7576 pCmdBuffer = m_singleTaskPhaseSupported ? &m_veBatchBuffer[m_virtualEngineBbIndex][currentPipe][0] : &m_veBatchBuffer[m_virtualEngineBbIndex][currentPipe][currentPass];
7577 }
7578
7579 if (Mos_ResourceIsNull(&pCmdBuffer->OsResource) ||
7580 m_sizeOfVeBatchBuffer < requestedSize)
7581 {
7582 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
7583
7584 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
7585 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
7586 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
7587 allocParamsForBufferLinear.Format = Format_Buffer;
7588 allocParamsForBufferLinear.dwBytes = requestedSize;
7589 allocParamsForBufferLinear.pBufName = "Batch buffer for each VDBOX";
7590
7591 if (!Mos_ResourceIsNull(&pCmdBuffer->OsResource))
7592 {
7593 if (pCmdBuffer->pCmdBase)
7594 {
7595 m_osInterface->pfnUnlockResource(m_osInterface, &pCmdBuffer->OsResource);
7596 }
7597 m_osInterface->pfnFreeResource(m_osInterface, &pCmdBuffer->OsResource);
7598 }
7599
7600 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
7601 m_osInterface,
7602 &allocParamsForBufferLinear,
7603 &pCmdBuffer->OsResource));
7604
7605 m_sizeOfVeBatchBuffer = requestedSize;
7606 }
7607
7608 if (pCmdBuffer->pCmdBase == nullptr)
7609 {
7610 MOS_LOCK_PARAMS lockParams;
7611 MOS_ZeroMemory(&lockParams, sizeof(lockParams));
7612 lockParams.WriteOnly = true;
7613 pCmdBuffer->pCmdPtr = pCmdBuffer->pCmdBase = (uint32_t *)m_osInterface->pfnLockResource(m_osInterface, &pCmdBuffer->OsResource, &lockParams);
7614 pCmdBuffer->iRemaining = m_sizeOfVeBatchBuffer;
7615 pCmdBuffer->iOffset = 0;
7616 pCmdBuffer->is1stLvlBB = true;
7617
7618 if (pCmdBuffer->pCmdBase == nullptr)
7619 {
7620 eStatus = MOS_STATUS_NULL_POINTER;
7621 return eStatus;
7622 }
7623 }
7624
7625 return eStatus;
7626 }
7627
7628 MOS_STATUS CodechalVdencHevcStateG12::GetCommandBuffer(PMOS_COMMAND_BUFFER cmdBuffer)
7629 {
7630 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7631
7632 CODECHAL_ENCODE_FUNCTION_ENTER;
7633
7634 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7635 CODECHAL_ENCODE_CHK_NULL_RETURN(m_osInterface->osCpInterface);
7636
7637 if (UseRenderCommandBuffer() || m_numPipe == 1)
7638 {
7639 // legacy mode
7640 m_realCmdBuffer.pCmdBase = m_realCmdBuffer.pCmdPtr = nullptr;
7641 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, cmdBuffer, 0));
7642 return eStatus;
7643 }
7644
7645 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, &m_realCmdBuffer, 0));
7646
7647 int currentPipe = GetCurrentPipe();
7648 if (currentPipe < 0 || currentPipe >= m_numPipe)
7649 {
7650 eStatus = MOS_STATUS_INVALID_PARAMETER;
7651 return eStatus;
7652 }
7653 int currentPass = GetCurrentPass();
7654 if (currentPass < 0 || currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES)
7655 {
7656 eStatus = MOS_STATUS_INVALID_PARAMETER;
7657 return eStatus;
7658 }
7659
7660 if (m_osInterface->phasedSubmission)
7661 {
7662 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnGetCommandBuffer(m_osInterface, cmdBuffer, currentPipe + 1));
7663
7664 CodecHalEncodeScalability_EncodePhaseToSubmissionType(IsFirstPipe(), cmdBuffer);
7665 if (IsLastPipe())
7666 {
7667 cmdBuffer->iSubmissionType |= SUBMISSION_TYPE_MULTI_PIPE_FLAGS_LAST_PIPE;
7668 }
7669 }
7670 else
7671 {
7672 *cmdBuffer = m_singleTaskPhaseSupported ? m_veBatchBuffer[m_virtualEngineBbIndex][currentPipe][0] : m_veBatchBuffer[m_virtualEngineBbIndex][currentPipe][currentPass];
7673 }
7674
7675 if (m_osInterface->osCpInterface->IsCpEnabled() && cmdBuffer->iOffset == 0)
7676 {
7677 // Insert CP Prolog
7678 CODECHAL_ENCODE_NORMALMESSAGE("Adding cp prolog for secure scalable encode");
7679 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hwInterface->GetCpInterface()->AddProlog(m_osInterface, cmdBuffer));
7680 }
7681 return eStatus;
7682 }
7683
7684 MOS_STATUS CodechalVdencHevcStateG12::ReturnCommandBuffer(PMOS_COMMAND_BUFFER cmdBuffer)
7685 {
7686 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7687
7688 CODECHAL_ENCODE_FUNCTION_ENTER;
7689
7690 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7691
7692 if (UseRenderCommandBuffer() || m_numPipe == 1)
7693 {
7694 // legacy mode
7695 m_osInterface->pfnReturnCommandBuffer(m_osInterface, cmdBuffer, 0);
7696 return eStatus;
7697 }
7698
7699 int currentPipe = GetCurrentPipe();
7700 if (currentPipe < 0 || currentPipe >= m_numPipe)
7701 {
7702 eStatus = MOS_STATUS_INVALID_PARAMETER;
7703 return eStatus;
7704 }
7705 int currentPass = GetCurrentPass();
7706 if (currentPass < 0 || currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES)
7707 {
7708 eStatus = MOS_STATUS_INVALID_PARAMETER;
7709 return eStatus;
7710 }
7711
7712 if (m_osInterface->phasedSubmission)
7713 {
7714 m_osInterface->pfnReturnCommandBuffer(m_osInterface, cmdBuffer, currentPipe + 1);
7715 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &m_realCmdBuffer, 0);
7716 }
7717 else
7718 {
7719 uint8_t passIndex = m_singleTaskPhaseSupported ? 0 : currentPass;
7720 m_veBatchBuffer[m_virtualEngineBbIndex][currentPipe][passIndex] = *cmdBuffer;
7721 m_osInterface->pfnReturnCommandBuffer(m_osInterface, &m_realCmdBuffer, 0);
7722 }
7723
7724 return eStatus;
7725 }
7726
7727 MOS_STATUS CodechalVdencHevcStateG12::SubmitCommandBuffer(
7728 PMOS_COMMAND_BUFFER cmdBuffer,
7729 bool bNullRendering)
7730 {
7731 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7732
7733 CODECHAL_ENCODE_FUNCTION_ENTER;
7734
7735 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7736
7737 if (IsLastPass())
7738 {
7739 HalOcaInterface::On1stLevelBBEnd(*cmdBuffer, *m_osInterface);
7740 }
7741
7742 if (UseRenderCommandBuffer() || m_numPipe == 1)
7743 {
7744 // legacy mode
7745 if (!UseRenderCommandBuffer()) // Set VE Hints for video contexts only
7746 {
7747 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(cmdBuffer));
7748 }
7749 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, cmdBuffer, bNullRendering));
7750 return eStatus;
7751 }
7752
7753 bool cmdBufferReadyForSubmit = IsLastPipe();
7754
7755 // In STF, Hold the command buffer submission till last pass
7756 if (m_singleTaskPhaseSupported)
7757 {
7758 cmdBufferReadyForSubmit = cmdBufferReadyForSubmit && IsLastPass();
7759 }
7760
7761 if(!cmdBufferReadyForSubmit)
7762 {
7763 return eStatus;
7764 }
7765
7766 int currentPass = GetCurrentPass();
7767 if (currentPass < 0 || currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES)
7768 {
7769 eStatus = MOS_STATUS_INVALID_PARAMETER;
7770 return eStatus;
7771 }
7772
7773 if (m_osInterface->phasedSubmission)
7774 {
7775 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &m_realCmdBuffer, bNullRendering));
7776 }
7777 else
7778 {
7779 uint8_t passIndex = m_singleTaskPhaseSupported ? 0 : currentPass;
7780
7781 for (uint32_t i = 0; i < m_numPipe; i++)
7782 {
7783 PMOS_COMMAND_BUFFER cmdBuffer = &m_veBatchBuffer[m_virtualEngineBbIndex][i][passIndex];
7784
7785 if(cmdBuffer->pCmdBase)
7786 {
7787 m_osInterface->pfnUnlockResource(m_osInterface, &cmdBuffer->OsResource);
7788 }
7789
7790 cmdBuffer->pCmdBase = 0;
7791 cmdBuffer->iOffset = cmdBuffer->iRemaining = 0;
7792 }
7793 m_sizeOfVeBatchBuffer = 0;
7794
7795 if(eStatus == MOS_STATUS_SUCCESS)
7796 {
7797 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetAndPopulateVEHintParams(&m_realCmdBuffer));
7798 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnSubmitCommandBuffer(m_osInterface, &m_realCmdBuffer, bNullRendering));
7799 }
7800 }
7801
7802 return eStatus;
7803 }
7804
7805 MOS_STATUS CodechalVdencHevcStateG12::SendPrologWithFrameTracking(
7806 PMOS_COMMAND_BUFFER cmdBuffer,
7807 bool frameTrackingRequested,
7808 MHW_MI_MMIOREGISTERS *mmioRegister)
7809 {
7810 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7811
7812 CODECHAL_ENCODE_FUNCTION_ENTER;
7813
7814 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
7815
7816 CODECHAL_ENCODE_CHK_NULL_RETURN(m_hevcSeqParams);
7817
7818 // Set flag bIsMdfLoad in remote gaming scenario to boost GPU frequency for low latency
7819 cmdBuffer->Attributes.bFrequencyBoost = (m_hevcSeqParams->ScenarioInfo == ESCENARIO_REMOTEGAMING);
7820
7821 MOS_GPU_CONTEXT gpuContext = m_osInterface->pfnGetGpuContext(m_osInterface);
7822
7823 if (UseRenderCommandBuffer())
7824 {
7825 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalEncoderState::SendPrologWithFrameTracking(cmdBuffer, frameTrackingRequested, mmioRegister));
7826 return eStatus;
7827 }
7828
7829 CODECHAL_ENCODE_CHK_NULL_RETURN(m_mmcState);
7830 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_mmcState->SendPrologCmd(m_miInterface, cmdBuffer, gpuContext));
7831
7832 if (!IsLastPipe())
7833 {
7834 return eStatus;
7835 }
7836
7837 PMOS_COMMAND_BUFFER commandBufferInUse;
7838 if (m_realCmdBuffer.pCmdBase)
7839 {
7840 commandBufferInUse = &m_realCmdBuffer;
7841 }
7842 else
7843 if (cmdBuffer && cmdBuffer->pCmdBase)
7844 {
7845 commandBufferInUse = cmdBuffer;
7846 }
7847 else
7848 {
7849 eStatus = MOS_STATUS_INVALID_PARAMETER;
7850 return eStatus;
7851 }
7852
7853 // initialize command buffer attributes
7854 commandBufferInUse->Attributes.bTurboMode = m_hwInterface->m_turboMode;
7855 commandBufferInUse->Attributes.dwNumRequestedEUSlices = m_hwInterface->m_numRequestedEuSlices;
7856 commandBufferInUse->Attributes.dwNumRequestedSubSlices = m_hwInterface->m_numRequestedSubSlices;
7857 commandBufferInUse->Attributes.dwNumRequestedEUs = m_hwInterface->m_numRequestedEus;
7858 commandBufferInUse->Attributes.bValidPowerGatingRequest = true;
7859
7860 if (frameTrackingRequested && m_frameTrackingEnabled)
7861 {
7862 commandBufferInUse->Attributes.bEnableMediaFrameTracking = true;
7863 commandBufferInUse->Attributes.resMediaFrameTrackingSurface =
7864 &m_encodeStatusBuf.resStatusBuffer;
7865 commandBufferInUse->Attributes.dwMediaFrameTrackingTag = m_storeData;
7866 // Set media frame tracking address offset(the offset from the encoder status buffer page)
7867 commandBufferInUse->Attributes.dwMediaFrameTrackingAddrOffset = 0;
7868 }
7869
7870 MHW_GENERIC_PROLOG_PARAMS genericPrologParams;
7871 MOS_ZeroMemory(&genericPrologParams, sizeof(genericPrologParams));
7872 genericPrologParams.pOsInterface = m_hwInterface->GetOsInterface();
7873 genericPrologParams.pvMiInterface = m_hwInterface->GetMiInterface();
7874 genericPrologParams.bMmcEnabled = m_mmcState ? m_mmcState->IsMmcEnabled() : false;
7875 genericPrologParams.dwStoreDataValue = m_storeData - 1;
7876
7877 CODECHAL_ENCODE_CHK_STATUS_RETURN(Mhw_SendGenericPrologCmd(commandBufferInUse, &genericPrologParams));
7878
7879 return eStatus;
7880 }
7881
7882 MOS_STATUS CodechalVdencHevcStateG12::SetSliceStructs()
7883 {
7884 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7885 eStatus = CodechalEncodeHevcBase::SetSliceStructs();
7886 CODECHAL_ENCODE_CHK_COND_RETURN((m_lookaheadPass && !m_lowDelay), "RA B frame is not expected in lookahead pass.");
7887 m_numPassesInOnePipe = m_numPasses;
7888 m_numPasses = (m_numPasses + 1) * m_numPipe - 1;
7889 return eStatus;
7890 }
7891
7892 MOS_STATUS CodechalVdencHevcStateG12::AllocateTileStatistics()
7893 {
7894 CODECHAL_ENCODE_FUNCTION_ENTER;
7895
7896 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
7897
7898 if (!m_hevcPicParams->tiles_enabled_flag)
7899 {
7900 return eStatus;
7901 }
7902
7903 auto num_tile_rows = m_hevcPicParams->num_tile_rows_minus1 + 1;
7904 auto num_tile_columns = m_hevcPicParams->num_tile_columns_minus1 + 1;
7905 auto num_tiles = num_tile_rows * num_tile_columns;
7906
7907 MOS_ZeroMemory(&m_hevcFrameStatsOffset, sizeof(HEVC_TILE_STATS_INFO));
7908 MOS_ZeroMemory(&m_hevcTileStatsOffset, sizeof(HEVC_TILE_STATS_INFO));
7909 MOS_ZeroMemory(&m_hevcStatsSize, sizeof(HEVC_TILE_STATS_INFO));
7910
7911 MOS_LOCK_PARAMS lockFlagsWriteOnly;
7912 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
7913 lockFlagsWriteOnly.WriteOnly = true;
7914
7915 // Set the maximum size based on frame level statistics.
7916 m_hevcStatsSize.uiTileSizeRecord = CODECHAL_CACHELINE_SIZE;
7917 m_hevcStatsSize.uiHevcPakStatistics = m_sizeOfHcpPakFrameStats;
7918 m_hevcStatsSize.uiVdencStatistics = CODECHAL_HEVC_VDENC_STATS_SIZE;
7919 m_hevcStatsSize.uiHevcSliceStreamout = CODECHAL_CACHELINE_SIZE;
7920
7921 // Maintain the offsets to use for patching addresses in to the HuC Pak Integration kernel Aggregated Frame Statistics Output Buffer
7922 // Each offset needs to be page aligned as the combined region is fed into different page aligned HuC regions
7923 m_hevcFrameStatsOffset.uiTileSizeRecord = 0; // Tile Size Record is not present in resHuCPakAggregatedFrameStatsBuffer
7924 m_hevcFrameStatsOffset.uiHevcPakStatistics = 0;
7925 m_hevcFrameStatsOffset.uiVdencStatistics = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.uiHevcPakStatistics + m_hevcStatsSize.uiHevcPakStatistics, CODECHAL_PAGE_SIZE);
7926 m_hevcFrameStatsOffset.uiHevcSliceStreamout = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.uiVdencStatistics + m_hevcStatsSize.uiVdencStatistics, CODECHAL_PAGE_SIZE);
7927
7928 // Frame level statistics
7929 m_hwInterface->m_pakIntAggregatedFrameStatsSize = MOS_ALIGN_CEIL(m_hevcFrameStatsOffset.uiHevcSliceStreamout + (m_hevcStatsSize.uiHevcSliceStreamout * m_numLcu), CODECHAL_PAGE_SIZE);
7930
7931 // HEVC Frame Statistics Buffer - Output from HuC PAK Integration kernel
7932 if (Mos_ResourceIsNull(&m_resHuCPakAggregatedFrameStatsBuffer.sResource))
7933 {
7934 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
7935 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
7936 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
7937 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
7938 allocParamsForBufferLinear.Format = Format_Buffer;
7939 allocParamsForBufferLinear.dwBytes = m_hwInterface->m_pakIntAggregatedFrameStatsSize;
7940 allocParamsForBufferLinear.pBufName = "GEN12 HCP Aggregated Frame Statistics Streamout Buffer";
7941
7942 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
7943 m_osInterface,
7944 &allocParamsForBufferLinear,
7945 &m_resHuCPakAggregatedFrameStatsBuffer.sResource));
7946 m_resHuCPakAggregatedFrameStatsBuffer.dwSize = m_hwInterface->m_pakIntAggregatedFrameStatsSize;
7947
7948 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(
7949 m_osInterface,
7950 &m_resHuCPakAggregatedFrameStatsBuffer.sResource,
7951 &lockFlagsWriteOnly);
7952
7953 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
7954 MOS_ZeroMemory(data, allocParamsForBufferLinear.dwBytes);
7955 m_osInterface->pfnUnlockResource(m_osInterface, &m_resHuCPakAggregatedFrameStatsBuffer.sResource);
7956 }
7957
7958 // Maintain the offsets to use for patching addresses in to the Tile Based Statistics Buffer
7959 // Each offset needs to be page aligned as the combined region is fed into different page aligned HuC regions
7960 m_hevcTileStatsOffset.uiTileSizeRecord = 0; // TileReord is in a separated resource
7961 m_hevcTileStatsOffset.uiHevcPakStatistics = 0; // PakStaticstics is head of m_resTileBasedStatisticsBuffer;
7962 m_hevcTileStatsOffset.uiVdencStatistics = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.uiHevcPakStatistics + (m_hevcStatsSize.uiHevcPakStatistics * num_tiles), CODECHAL_PAGE_SIZE);
7963 m_hevcTileStatsOffset.uiHevcSliceStreamout = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.uiVdencStatistics + (m_hevcStatsSize.uiVdencStatistics * num_tiles), CODECHAL_PAGE_SIZE);
7964 // Combined statistics size for all tiles
7965 m_hwInterface->m_pakIntTileStatsSize = MOS_ALIGN_CEIL(m_hevcTileStatsOffset.uiHevcSliceStreamout + m_hevcStatsSize.uiHevcSliceStreamout * m_numLcu, CODECHAL_PAGE_SIZE);
7966
7967 // Tile size record size for all tiles
7968 m_hwInterface->m_tileRecordSize = m_hevcStatsSize.uiTileSizeRecord * num_tiles;
7969
7970 if (Mos_ResourceIsNull(&m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource) || m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].dwSize < m_hwInterface->m_pakIntTileStatsSize)
7971 {
7972 if (!Mos_ResourceIsNull(&m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource))
7973 {
7974 m_osInterface->pfnFreeResource(m_osInterface, &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource);
7975 }
7976 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
7977 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
7978 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
7979 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
7980 allocParamsForBufferLinear.Format = Format_Buffer;
7981 allocParamsForBufferLinear.dwBytes = m_hwInterface->m_pakIntTileStatsSize;
7982 allocParamsForBufferLinear.pBufName = "GEN12 HCP Tile Level Statistics Streamout Buffer";
7983
7984 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_osInterface->pfnAllocateResource(
7985 m_osInterface,
7986 &allocParamsForBufferLinear,
7987 &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource));
7988 m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].dwSize = m_hwInterface->m_pakIntTileStatsSize;
7989
7990 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(
7991 m_osInterface,
7992 &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource,
7993 &lockFlagsWriteOnly);
7994 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
7995
7996 MOS_ZeroMemory(data, allocParamsForBufferLinear.dwBytes);
7997 m_osInterface->pfnUnlockResource(m_osInterface, &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource);
7998 }
7999
8000 // Allocate the updated tile size buffer for PAK integration kernel
8001 if (Mos_ResourceIsNull(&m_tileRecordBuffer[m_virtualEngineBbIndex].sResource) || m_tileRecordBuffer[m_virtualEngineBbIndex].dwSize < m_hwInterface->m_tileRecordSize)
8002 {
8003 if (!Mos_ResourceIsNull(&m_tileRecordBuffer[m_virtualEngineBbIndex].sResource))
8004 {
8005 m_osInterface->pfnFreeResource(m_osInterface, &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource);
8006 }
8007 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
8008 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
8009 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
8010 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
8011 allocParamsForBufferLinear.Format = Format_Buffer;
8012 allocParamsForBufferLinear.dwBytes = m_hwInterface->m_tileRecordSize;
8013 allocParamsForBufferLinear.pBufName = "Tile Record buffer";
8014
8015 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(m_osInterface->pfnAllocateResource(
8016 m_osInterface,
8017 &allocParamsForBufferLinear,
8018 &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource),
8019 "Failed to create GEN12 Tile Record buffer");
8020
8021 m_tileRecordBuffer[m_virtualEngineBbIndex].dwSize = allocParamsForBufferLinear.dwBytes;
8022 }
8023
8024 // Only needed when tile & BRC is enabled, but the size is not changing at frame level
8025 // Move to more properiate place later
8026 if (Mos_ResourceIsNull(&m_resBrcDataBuffer))
8027 {
8028 uint8_t* data;
8029 MOS_ALLOC_GFXRES_PARAMS allocParamsForBufferLinear;
8030
8031 // Pak stitch DMEM
8032 MOS_ZeroMemory(&allocParamsForBufferLinear, sizeof(MOS_ALLOC_GFXRES_PARAMS));
8033 allocParamsForBufferLinear.Type = MOS_GFXRES_BUFFER;
8034 allocParamsForBufferLinear.TileType = MOS_TILE_LINEAR;
8035 allocParamsForBufferLinear.Format = Format_Buffer;
8036 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(sizeof(HucPakStitchDmemVdencG12), CODECHAL_CACHELINE_SIZE);
8037 allocParamsForBufferLinear.pBufName = "PAK Stitch Dmem Buffer";
8038 auto numOfPasses = CODECHAL_VDENC_BRC_NUM_OF_PASSES;
8039
8040 for (auto k = 0; k < CODECHAL_ENCODE_RECYCLED_BUFFER_NUM; k++)
8041 {
8042 for (auto i = 0; i < numOfPasses; i++)
8043 {
8044 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(
8045 m_osInterface->pfnAllocateResource(
8046 m_osInterface,
8047 &allocParamsForBufferLinear,
8048 &m_resHucPakStitchDmemBuffer[k][i]),
8049 "Failed to allocate PAK Stitch Dmem Buffer.");
8050
8051 MOS_LOCK_PARAMS lockFlagsWriteOnly;
8052 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
8053 lockFlagsWriteOnly.WriteOnly = 1;
8054
8055 data = (uint8_t*)m_osInterface->pfnLockResource(
8056 m_osInterface,
8057 &m_resHucPakStitchDmemBuffer[k][i],
8058 &lockFlagsWriteOnly);
8059
8060 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
8061
8062 MOS_ZeroMemory(
8063 data,
8064 allocParamsForBufferLinear.dwBytes);
8065
8066 m_osInterface->pfnUnlockResource(m_osInterface, &m_resHucPakStitchDmemBuffer[k][i]);
8067 }
8068 }
8069
8070 // BRC Data Buffer
8071 allocParamsForBufferLinear.dwBytes = MOS_ALIGN_CEIL(m_numTiles * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
8072 allocParamsForBufferLinear.pBufName = "BRC Data Buffer";
8073
8074 CODECHAL_ENCODE_CHK_STATUS_MESSAGE_RETURN(
8075 m_osInterface->pfnAllocateResource(
8076 m_osInterface,
8077 &allocParamsForBufferLinear,
8078 &m_resBrcDataBuffer),
8079 "Failed to allocate BRC Data Buffer Buffer.");
8080
8081 MOS_LOCK_PARAMS lockFlags;
8082 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
8083 lockFlags.WriteOnly = 1;
8084
8085 data = (uint8_t*)m_osInterface->pfnLockResource(
8086 m_osInterface,
8087 &m_resBrcDataBuffer,
8088 &lockFlags);
8089
8090 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
8091
8092 MOS_ZeroMemory(
8093 data,
8094 allocParamsForBufferLinear.dwBytes);
8095
8096 m_osInterface->pfnUnlockResource(m_osInterface, &m_resBrcDataBuffer);
8097 }
8098
8099 return eStatus;
8100 }
8101
8102 MOS_STATUS CodechalVdencHevcStateG12::ReadSseStatistics(PMOS_COMMAND_BUFFER cmdBuffer)
8103 {
8104 CODECHAL_ENCODE_FUNCTION_ENTER;
8105
8106 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8107
8108 // encodeStatus is offset by 2 DWs in the resource
8109 uint32_t sseOffsetinBytes = (m_encodeStatusBuf.wCurrIndex * m_encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2 + m_encodeStatusBuf.dwSumSquareErrorOffset;
8110 for (auto i = 0; i < 6; i++) // 64 bit SSE values for luma/ chroma channels need to be copied
8111 {
8112 MHW_MI_COPY_MEM_MEM_PARAMS miCpyMemMemParams;
8113 MOS_ZeroMemory(&miCpyMemMemParams, sizeof(miCpyMemMemParams));
8114 miCpyMemMemParams.presSrc = m_hevcPicParams->tiles_enabled_flag && (m_numPipe > 1) ? &m_resHuCPakAggregatedFrameStatsBuffer.sResource : &m_resFrameStatStreamOutBuffer;
8115 miCpyMemMemParams.dwSrcOffset = (HEVC_PAK_STATISTICS_SSE_OFFSET + i) * sizeof(uint32_t); // SSE luma offset is located at DW32 in Frame statistics, followed by chroma
8116 miCpyMemMemParams.presDst = &m_encodeStatusBuf.resStatusBuffer;
8117 miCpyMemMemParams.dwDstOffset = sseOffsetinBytes + i * sizeof(uint32_t);
8118 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(cmdBuffer, &miCpyMemMemParams));
8119 }
8120 return eStatus;
8121 }
8122
8123 void CodechalVdencHevcStateG12::SetHcpIndObjBaseAddrParams(MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS& indObjBaseAddrParams)
8124 {
8125 PCODECHAL_ENCODE_BUFFER tileRecordBuffer = &m_tileRecordBuffer[m_virtualEngineBbIndex];
8126 bool useTileRecordBuffer = !Mos_ResourceIsNull(&tileRecordBuffer->sResource);
8127
8128 MOS_ZeroMemory(&indObjBaseAddrParams, sizeof(indObjBaseAddrParams));
8129 indObjBaseAddrParams.Mode = CODECHAL_ENCODE_MODE_HEVC;
8130 indObjBaseAddrParams.presMvObjectBuffer = &m_resMbCodeSurface;
8131 indObjBaseAddrParams.dwMvObjectOffset = m_mvOffset;
8132 indObjBaseAddrParams.dwMvObjectSize = m_mbCodeSize - m_mvOffset;
8133 indObjBaseAddrParams.presPakBaseObjectBuffer = &m_resBitstreamBuffer;
8134 indObjBaseAddrParams.dwPakBaseObjectSize = m_bitstreamUpperBound;
8135 indObjBaseAddrParams.presPakTileSizeStasBuffer = useTileRecordBuffer ? &tileRecordBuffer->sResource : nullptr;
8136 indObjBaseAddrParams.dwPakTileSizeStasBufferSize = useTileRecordBuffer ? m_hwInterface->m_tileRecordSize : 0;
8137 indObjBaseAddrParams.dwPakTileSizeRecordOffset = useTileRecordBuffer ? m_hevcTileStatsOffset.uiTileSizeRecord : 0;
8138 }
8139
8140 MOS_STATUS CodechalVdencHevcStateG12::HuCLookaheadInit()
8141 {
8142 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8143
8144 CODECHAL_ENCODE_FUNCTION_ENTER;
8145
8146 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
8147 m_lastTaskInPhase = !m_singleTaskPhaseSupported;
8148
8149 // set DMEM
8150 uint32_t initVbvFullness = MOS_MIN(m_hevcSeqParams->InitVBVBufferFullnessInBit, m_hevcSeqParams->VBVBufferSizeInBit);
8151 MOS_LOCK_PARAMS lockFlagsWriteOnly;
8152 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
8153 lockFlagsWriteOnly.WriteOnly = true;
8154
8155 auto dmem = (PCodechalVdencHevcLaDmem)m_osInterface->pfnLockResource(
8156 m_osInterface, &m_vdencLaInitDmemBuffer, &lockFlagsWriteOnly);
8157 CODECHAL_ENCODE_CHK_NULL_RETURN(dmem);
8158 MOS_ZeroMemory(dmem, sizeof(CodechalVdencHevcLaDmem));
8159
8160 uint8_t downscaleRatioIndicator = 2; // 4x downscaling
8161 if (m_hevcPicParams->DownScaleRatio.fields.X16Minus1_X == 15 && m_hevcPicParams->DownScaleRatio.fields.X16Minus1_Y == 15)
8162 {
8163 downscaleRatioIndicator = 0; // no downscaling
8164 }
8165
8166 dmem->lookAheadFunc = 0;
8167 dmem->lengthAhead = m_lookaheadDepth;
8168 dmem->vbvBufferSize = m_hevcSeqParams->VBVBufferSizeInBit / m_averageFrameSize;
8169 dmem->vbvInitialFullness = initVbvFullness / m_averageFrameSize;
8170 dmem->statsRecords = m_numLaDataEntry;
8171 dmem->avgFrameSizeInByte = m_averageFrameSize >> 3;
8172 dmem->downscaleRatio = downscaleRatioIndicator;
8173 dmem->enc_frame_width = m_frameWidth;
8174 dmem->enc_frame_height = m_frameHeight;
8175 dmem->codec_type = 2;
8176 dmem->mbr_ratio = (m_hevcSeqParams->TargetBitRate > 0 && m_hevcSeqParams->MaxBitRate >= m_hevcSeqParams->TargetBitRate) ?
8177 m_hevcSeqParams->MaxBitRate * 100 / m_hevcSeqParams->TargetBitRate : 100;
8178
8179 if (m_hevcSeqParams->bLookAheadPhase)
8180 {
8181 if (m_hevcSeqParams->GopRefDist == 1)
8182 {
8183 dmem->PGop = 4;
8184 }
8185 else
8186 {
8187 dmem->BGop = m_hevcSeqParams->GopRefDist;
8188 dmem->maxGop = m_hevcSeqParams->GopPicSize;
8189 }
8190
8191 dmem->GopOpt = m_hevcSeqParams->GopFlags.fields.StrictGop ? 2 : m_hevcSeqParams->GopFlags.fields.ClosedGop;
8192 dmem->AGop = m_hevcSeqParams->GopFlags.fields.AdaptiveGop;
8193 if (m_hevcSeqParams->GopFlags.fields.AdaptiveGop)
8194 {
8195 dmem->AGop_Threshold = 30;
8196 }
8197
8198 dmem->maxGop = m_hevcSeqParams->MaxAdaptiveGopPicSize;
8199 dmem->minGop = m_hevcSeqParams->MinAdaptiveGopPicSize;
8200 dmem->adaptiveIDR = (uint8_t)m_lookaheadAdaptiveI;
8201 }
8202
8203 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencLaInitDmemBuffer);
8204
8205 // set HuC regions
8206 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
8207 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
8208 virtualAddrParams.regionParams[0].presRegion = &m_vdencLaHistoryBuffer;
8209 virtualAddrParams.regionParams[0].isWritable = true;
8210
8211 #if USE_CODECHAL_DEBUG_TOOL && _MEDIA_RESERVED
8212 if (m_swLaMode)
8213 {
8214 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgCallSwLookaheadImpl(
8215 m_debugInterface,
8216 m_swLaMode,
8217 CODECHAL_MEDIA_STATE_BRC_INIT_RESET,
8218 &m_vdencLaInitDmemBuffer,
8219 nullptr,
8220 &virtualAddrParams));
8221
8222 return eStatus;
8223 }
8224 #endif
8225
8226 MOS_COMMAND_BUFFER cmdBuffer;
8227 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
8228
8229 if (!m_singleTaskPhaseSupported || m_firstTaskInPhase)
8230 {
8231 // Send command buffer header at the beginning (OS dependent)
8232 bool requestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : 0;
8233 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
8234 }
8235
8236 // load kernel from WOPCM into L2 storage RAM
8237 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
8238 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
8239 imemParams.dwKernelDescriptor = m_vdboxHucHevcLaAnalysisKernelDescriptor;
8240
8241 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
8242
8243 // pipe mode select
8244 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
8245 pipeModeSelectParams.Mode = m_mode;
8246 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
8247
8248 // set HuC DMEM param
8249 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
8250 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
8251 dmemParams.presHucDataSource = &m_vdencLaInitDmemBuffer;
8252 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencLaInitDmemBufferSize, CODECHAL_CACHELINE_SIZE);
8253 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
8254 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
8255 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &virtualAddrParams));
8256 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
8257 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
8258
8259 // wait Huc completion (use HEVC bit for now)
8260 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
8261 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
8262 vdPipeFlushParams.Flags.bFlushHEVC = 1;
8263 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
8264 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipeFlushParams));
8265
8266 // Flush the engine to ensure memory written out
8267 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8268 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8269 flushDwParams.bVideoPipelineCacheInvalidate = true;
8270 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
8271
8272 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
8273 {
8274 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
8275 }
8276
8277 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
8278
8279 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
8280 {
8281 bool renderingFlags = m_videoContextUsesNullHw;
8282
8283 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, renderingFlags));
8284 }
8285
8286 return eStatus;
8287 }
8288
8289 MOS_STATUS CodechalVdencHevcStateG12::HuCLookaheadUpdate()
8290 {
8291 uint8_t currentPass = (uint8_t)GetCurrentPass();
8292 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8293
8294 CODECHAL_ENCODE_FUNCTION_ENTER;
8295
8296 m_firstTaskInPhase = !m_singleTaskPhaseSupported;
8297 m_lastTaskInPhase = (currentPass == m_numPasses);
8298
8299 // set DMEM
8300 MOS_LOCK_PARAMS lockFlagsWriteOnly;
8301 MOS_ZeroMemory(&lockFlagsWriteOnly, sizeof(MOS_LOCK_PARAMS));
8302 lockFlagsWriteOnly.WriteOnly = true;
8303
8304 auto dmem = (PCodechalVdencHevcLaDmem)m_osInterface->pfnLockResource(
8305 m_osInterface, &m_vdencLaUpdateDmemBuffer[m_currRecycledBufIdx][currentPass], &lockFlagsWriteOnly);
8306 CODECHAL_ENCODE_CHK_NULL_RETURN(dmem);
8307 MOS_ZeroMemory(dmem, sizeof(CodechalVdencHevcLaDmem));
8308
8309 dmem->lookAheadFunc = 1;
8310 dmem->validStatsRecords = m_numValidLaRecords;
8311 dmem->offset = (m_numLaDataEntry + m_currLaDataIdx + 1 - m_numValidLaRecords) % m_numLaDataEntry;
8312 dmem->cqmQpThreshold = m_cqmQpThreshold;
8313 dmem->currentPass = currentPass;
8314
8315 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencLaUpdateDmemBuffer[m_currRecycledBufIdx][currentPass]);
8316
8317 // set HuC regions
8318 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
8319 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
8320 virtualAddrParams.regionParams[0].presRegion = &m_vdencLaHistoryBuffer;
8321 virtualAddrParams.regionParams[0].isWritable = true;
8322 virtualAddrParams.regionParams[1].presRegion = &m_vdencLaStatsBuffer;
8323 virtualAddrParams.regionParams[2].presRegion = &m_vdencLaDataBuffer;
8324 virtualAddrParams.regionParams[2].isWritable = true;
8325
8326 #if USE_CODECHAL_DEBUG_TOOL && _MEDIA_RESERVED
8327 if (m_swLaMode)
8328 {
8329 bool isLaAnalysisRequired = true;
8330 MOS_LOCK_PARAMS lockFlags;
8331 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
8332 lockFlags.ReadOnly = true;
8333
8334 if (!IsFirstPass())
8335 {
8336 uint32_t *data = (uint32_t *)m_osInterface->pfnLockResource(m_osInterface, &m_resPakMmioBuffer, &lockFlags);
8337 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
8338 isLaAnalysisRequired = (*data == CODECHAL_VDENC_HEVC_BRC_HUC_STATUS_REENCODE_MASK);
8339 m_osInterface->pfnUnlockResource(m_osInterface, &m_resPakMmioBuffer);
8340 }
8341
8342 if (isLaAnalysisRequired)
8343 {
8344 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgCallSwLookaheadImpl(
8345 m_debugInterface,
8346 m_swLaMode,
8347 CODECHAL_MEDIA_STATE_BRC_UPDATE,
8348 &m_vdencLaUpdateDmemBuffer[m_currRecycledBufIdx][currentPass],
8349 &m_resPakMmioBuffer,
8350 &virtualAddrParams));
8351
8352 EncodeStatusBuffer encodeStatusBuf = m_encodeStatusBuf;
8353 uint32_t baseOffset = (encodeStatusBuf.wCurrIndex * encodeStatusBuf.dwReportSize);
8354
8355 CodechalVdencHevcLaData *data = (CodechalVdencHevcLaData *)m_osInterface->pfnLockResource(m_osInterface, &m_vdencLaDataBuffer, &lockFlags);
8356 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
8357
8358 LookaheadReport *lookaheadStatus = (LookaheadReport *)(encodeStatusBuf.pEncodeStatus + baseOffset + encodeStatusBuf.dwLookaheadStatusOffset);
8359 lookaheadStatus->targetFrameSize = data[dmem->offset].targetFrameSize;
8360 lookaheadStatus->targetBufferFulness = data[dmem->offset].targetBufferFulness;
8361 lookaheadStatus->encodeHints = data[dmem->offset].encodeHints;
8362 lookaheadStatus->pyramidDeltaQP = data[dmem->offset].pyramidDeltaQP;
8363
8364 m_osInterface->pfnUnlockResource(m_osInterface, &m_vdencLaDataBuffer);
8365 }
8366
8367 return eStatus;
8368 }
8369 #endif
8370
8371 MOS_COMMAND_BUFFER cmdBuffer;
8372 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
8373
8374 if (!m_singleTaskPhaseSupported || m_firstTaskInPhase)
8375 {
8376 // Send command buffer header at the beginning (OS dependent)
8377 bool requestFrameTracking = m_singleTaskPhaseSupported ? m_firstTaskInPhase : m_lastTaskInPhase;
8378 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
8379 }
8380
8381 if (!IsFirstPass() && m_firstTaskInPhase)
8382 {
8383 // VDENC uses HuC FW generated semaphore for conditional 2nd pass
8384 MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS miConditionalBatchBufferEndParams;
8385 MOS_ZeroMemory(
8386 &miConditionalBatchBufferEndParams,
8387 sizeof(MHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
8388 miConditionalBatchBufferEndParams.presSemaphoreBuffer =
8389 &m_resPakMmioBuffer;
8390 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
8391 &cmdBuffer,
8392 &miConditionalBatchBufferEndParams));
8393 }
8394
8395 CODECHAL_ENCODE_CHK_STATUS_RETURN(StartStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
8396
8397 // load kernel from WOPCM into L2 storage RAM
8398 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
8399 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
8400 imemParams.dwKernelDescriptor = m_vdboxHucHevcLaAnalysisKernelDescriptor;
8401
8402 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
8403
8404 // pipe mode select
8405 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
8406 pipeModeSelectParams.Mode = m_mode;
8407 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
8408
8409 // set HuC DMEM param
8410 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
8411 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
8412 dmemParams.presHucDataSource = &m_vdencLaUpdateDmemBuffer[m_currRecycledBufIdx][currentPass];
8413 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencLaUpdateDmemBufferSize, CODECHAL_CACHELINE_SIZE);
8414 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
8415 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
8416 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &virtualAddrParams));
8417 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
8418 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
8419
8420 // wait Huc completion (use HEVC bit for now)
8421 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
8422 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
8423 vdPipeFlushParams.Flags.bFlushHEVC = 1;
8424 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
8425 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipeFlushParams));
8426
8427 // Flush the engine to ensure memory written out
8428 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8429 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8430 flushDwParams.bVideoPipelineCacheInvalidate = true;
8431 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
8432
8433 if (IsFirstPass())
8434 {
8435 // Write HUC_STATUS mask: DW1 (mask value)
8436 MHW_MI_STORE_DATA_PARAMS storeDataParams;
8437 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8438 storeDataParams.pOsResource = &m_resPakMmioBuffer;
8439 storeDataParams.dwResourceOffset = sizeof(uint32_t);
8440 storeDataParams.dwValue = CODECHAL_VDENC_HEVC_BRC_HUC_STATUS_REENCODE_MASK;
8441 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &storeDataParams));
8442
8443 // store HUC_STATUS register: DW0 (actual value)
8444 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8445 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
8446 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
8447 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
8448 storeRegParams.presStoreBuffer = &m_resPakMmioBuffer;
8449 storeRegParams.dwOffset = 0;
8450 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
8451 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&cmdBuffer, &storeRegParams));
8452 }
8453
8454 // Write lookahead status to encode status buffer
8455 MHW_MI_COPY_MEM_MEM_PARAMS miCpyMemMemParams;
8456 EncodeStatusBuffer encodeStatusBuf = m_encodeStatusBuf;
8457 uint32_t baseOffset =
8458 (encodeStatusBuf.wCurrIndex * encodeStatusBuf.dwReportSize) + sizeof(uint32_t) * 2; // pEncodeStatus is offset by 2 DWs in the resource
8459 MOS_ZeroMemory(&miCpyMemMemParams, sizeof(MHW_MI_COPY_MEM_MEM_PARAMS));
8460 miCpyMemMemParams.presSrc = &m_vdencLaDataBuffer;
8461 miCpyMemMemParams.dwSrcOffset = dmem->offset * sizeof(CodechalVdencHevcLaData) + CODECHAL_OFFSETOF(CodechalVdencHevcLaData, encodeHints);
8462 miCpyMemMemParams.presDst = &encodeStatusBuf.resStatusBuffer;
8463 miCpyMemMemParams.dwDstOffset = baseOffset + encodeStatusBuf.dwLookaheadStatusOffset + CODECHAL_OFFSETOF(LookaheadReport, encodeHints);
8464 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(&cmdBuffer, &miCpyMemMemParams));
8465 miCpyMemMemParams.dwSrcOffset = dmem->offset * sizeof(CodechalVdencHevcLaData) + CODECHAL_OFFSETOF(CodechalVdencHevcLaData, targetFrameSize);
8466 miCpyMemMemParams.dwDstOffset = baseOffset + encodeStatusBuf.dwLookaheadStatusOffset + CODECHAL_OFFSETOF(LookaheadReport, targetFrameSize);
8467 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(&cmdBuffer, &miCpyMemMemParams));
8468 miCpyMemMemParams.dwSrcOffset = dmem->offset * sizeof(CodechalVdencHevcLaData) + CODECHAL_OFFSETOF(CodechalVdencHevcLaData, targetBufferFulness);
8469 miCpyMemMemParams.dwDstOffset = baseOffset + encodeStatusBuf.dwLookaheadStatusOffset + CODECHAL_OFFSETOF(LookaheadReport, targetBufferFulness);
8470 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(&cmdBuffer, &miCpyMemMemParams));
8471 miCpyMemMemParams.dwSrcOffset = dmem->offset * sizeof(CodechalVdencHevcLaData) + CODECHAL_OFFSETOF(CodechalVdencHevcLaData, pyramidDeltaQP);
8472 miCpyMemMemParams.dwDstOffset = baseOffset + encodeStatusBuf.dwLookaheadStatusOffset + CODECHAL_OFFSETOF(LookaheadReport, pyramidDeltaQP);
8473 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiCopyMemMemCmd(&cmdBuffer, &miCpyMemMemParams));
8474
8475 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8476 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
8477
8478 CODECHAL_ENCODE_CHK_STATUS_RETURN(EndStatusReport(&cmdBuffer, CODECHAL_NUM_MEDIA_STATES));
8479
8480 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
8481 {
8482 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
8483 }
8484
8485 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
8486
8487 if (!m_singleTaskPhaseSupported || m_lastTaskInPhase)
8488 {
8489 bool renderingFlags = m_videoContextUsesNullHw;
8490 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, renderingFlags));
8491 }
8492
8493 return eStatus;
8494 }
8495
8496 MOS_STATUS CodechalVdencHevcStateG12::AnalyzeLookaheadStats()
8497 {
8498 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8499
8500 CODECHAL_ENCODE_FUNCTION_ENTER;
8501
8502 if(IsFirstPass())
8503 {
8504 m_numValidLaRecords++;
8505 }
8506
8507 if (m_lookaheadInit)
8508 {
8509 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCLookaheadInit());
8510 m_lookaheadInit = false;
8511 }
8512
8513 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCLookaheadUpdate());
8514 if (IsLastPass() && (m_numValidLaRecords >= m_lookaheadDepth))
8515 {
8516 m_numValidLaRecords--;
8517 m_lookaheadReport = true;
8518 }
8519
8520 int32_t currentPass = GetCurrentPass();
8521 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
8522 &m_vdencLaUpdateDmemBuffer[m_currRecycledBufIdx][currentPass],
8523 CodechalDbgAttr::attrVdencOutput,
8524 "_LookaheadDmem",
8525 sizeof(CodechalVdencHevcLaDmem),
8526 0,
8527 CODECHAL_NUM_MEDIA_STATES)));
8528
8529 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
8530 &m_vdencLaDataBuffer,
8531 CodechalDbgAttr::attrVdencOutput,
8532 "_LookaheadData",
8533 m_brcLooaheadDataBufferSize,
8534 0,
8535 CODECHAL_NUM_MEDIA_STATES)));
8536
8537 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
8538 &m_vdencLaHistoryBuffer,
8539 CodechalDbgAttr::attrVdencOutput,
8540 "_LookaheadHistory",
8541 m_LaHistoryBufSize,
8542 0,
8543 CODECHAL_NUM_MEDIA_STATES)));
8544
8545 if (m_hevcPicParams->bLastPicInStream)
8546 {
8547 // Flush the last frames
8548 while (m_numValidLaRecords > 0)
8549 {
8550 CODECHAL_ENCODE_CHK_STATUS_RETURN(HuCLookaheadUpdate());
8551 m_numValidLaRecords--;
8552 }
8553 }
8554
8555 return eStatus;
8556 }
8557
8558 MOS_STATUS CodechalVdencHevcStateG12::HuCBrcInitReset()
8559 {
8560 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8561
8562 CODECHAL_ENCODE_FUNCTION_ENTER;
8563
8564 #if (_DEBUG || _RELEASE_INTERNAL) && _MEDIA_RESERVED
8565 if (m_swBrcMode != nullptr && !m_enableTileReplay && !m_hevcVdencWeightedPredEnabled)
8566 {
8567 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcInitReset());
8568
8569 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
8570 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
8571 virtualAddrParams.regionParams[0].presRegion = &m_vdencBrcHistoryBuffer;
8572 virtualAddrParams.regionParams[0].isWritable = true;
8573
8574 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgCallHevcVdencSwBrcImpl(
8575 m_debugInterface,
8576 m_swBrcMode,
8577 CODECHAL_MEDIA_STATE_BRC_INIT_RESET,
8578 !m_brcInit,
8579 &m_vdencBrcInitDmemBuffer[m_currRecycledBufIdx],
8580 &m_resPakMmioBuffer,
8581 &virtualAddrParams));
8582
8583 CODECHAL_DEBUG_TOOL(DumpHucBrcInit());
8584
8585 return eStatus;
8586 }
8587 #endif
8588
8589 MOS_COMMAND_BUFFER cmdBuffer;
8590 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
8591
8592 if ((!m_singleTaskPhaseSupported || m_firstTaskInPhase) && (m_numPipe == 1))
8593 {
8594 // Send command buffer header at the beginning (OS dependent)
8595 bool requestFrameTracking = m_singleTaskPhaseSupported ?
8596 m_firstTaskInPhase : 0;
8597 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
8598 }
8599
8600 // load kernel from WOPCM into L2 storage RAM
8601 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
8602 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
8603 imemParams.dwKernelDescriptor = m_vdboxHucHevcBrcInitKernelDescriptor;
8604
8605 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
8606
8607 // pipe mode select
8608 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
8609 pipeModeSelectParams.Mode = m_mode;
8610 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
8611
8612 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcInitReset());
8613
8614 // set HuC DMEM param
8615 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
8616 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
8617 dmemParams.presHucDataSource = &m_vdencBrcInitDmemBuffer[m_currRecycledBufIdx];
8618 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencBrcInitDmemBufferSize, CODECHAL_CACHELINE_SIZE);
8619 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
8620 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
8621
8622 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
8623 MOS_ZeroMemory(&virtualAddrParams, sizeof(virtualAddrParams));
8624 virtualAddrParams.regionParams[0].presRegion = &m_vdencBrcHistoryBuffer;
8625 virtualAddrParams.regionParams[0].isWritable = true;
8626 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &virtualAddrParams));
8627
8628 // Store HUC_STATUS2 register bit 6 before HUC_Start command
8629 // BitField: VALID IMEM LOADED - This bit will be cleared by HW at the end of a HUC workload
8630 // (HUC_Start command with last start bit set).
8631 CODECHAL_DEBUG_TOOL(
8632 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Register(&cmdBuffer));
8633 )
8634
8635 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
8636
8637 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
8638
8639 // wait Huc completion (use HEVC bit for now)
8640 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
8641 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
8642 vdPipeFlushParams.Flags.bFlushHEVC = 1;
8643 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
8644 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipeFlushParams));
8645
8646 // Flush the engine to ensure memory written out
8647 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8648 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8649 flushDwParams.bVideoPipelineCacheInvalidate = true;
8650 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
8651
8652 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8653 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
8654 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHucErrorStatus(mmioRegisters, &cmdBuffer, true));
8655 CODECHAL_ENCODE_CHK_STATUS_RETURN(InsertConditionalBBEndWithHucErrorStatus(&cmdBuffer));
8656
8657 if (!m_singleTaskPhaseSupported && (m_osInterface->bNoParsingAssistanceInKmd) && (m_numPipe == 1))
8658 {
8659 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
8660 }
8661
8662 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
8663
8664 if (!m_singleTaskPhaseSupported)
8665 {
8666 bool renderingFlags = m_videoContextUsesNullHw;
8667
8668 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
8669 &cmdBuffer,
8670 CODECHAL_MEDIA_STATE_BRC_INIT_RESET,
8671 nullptr)));
8672 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, renderingFlags));
8673 }
8674
8675 CODECHAL_DEBUG_TOOL(DumpHucBrcInit());
8676 return eStatus;
8677 }
8678
8679 MOS_STATUS CodechalVdencHevcStateG12::HuCBrcUpdate()
8680 {
8681 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8682
8683 CODECHAL_ENCODE_FUNCTION_ENTER;
8684
8685 *m_pipeBufAddrParams = {};
8686 if (m_pictureCodingType != I_TYPE)
8687 {
8688 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME_HEVC; i++)
8689 {
8690 if (!m_picIdx[i].bValid || !m_currUsedRefPic[i])
8691 {
8692 continue;
8693 }
8694
8695 uint8_t idx = m_picIdx[i].ucPicIdx;
8696 CodecHalGetResourceInfo(m_osInterface, &(m_refList[idx]->sRefReconBuffer));
8697
8698 uint8_t frameStoreId = (uint8_t)m_refIdxMapping[i];
8699 m_pipeBufAddrParams->presReferences[frameStoreId] = &(m_refList[idx]->sRefReconBuffer.OsResource);
8700 }
8701 }
8702
8703 if (m_enableSCC && m_hevcPicParams->pps_curr_pic_ref_enabled_flag)
8704 {
8705 // I frame is much simpler
8706 if (m_pictureCodingType == I_TYPE)
8707 {
8708 m_slotForRecNotFiltered = 0;
8709 }
8710 // LDB
8711 else
8712 {
8713 unsigned int i;
8714
8715 // Find one available slot
8716 for (i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
8717 {
8718 if (m_pipeBufAddrParams->presReferences[i] == nullptr)
8719 {
8720 break;
8721 }
8722 }
8723
8724 CODECHAL_ENCODE_ASSERT(i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC);
8725
8726 //record the slot for HCP_REF_IDX_STATE
8727 m_slotForRecNotFiltered = (unsigned char)i;
8728 }
8729 }
8730
8731 int32_t currentPass = GetCurrentPass();
8732 if (currentPass < 0)
8733 {
8734 eStatus = MOS_STATUS_INVALID_PARAMETER;
8735 return eStatus;
8736 }
8737
8738 CODECHAL_ENCODE_CHK_STATUS_RETURN(ConstructBatchBufferHuCBRC(&m_vdencReadBatchBuffer[m_currRecycledBufIdx][currentPass]));
8739
8740 #if (_DEBUG || _RELEASE_INTERNAL) && _MEDIA_RESERVED
8741 if (m_swBrcMode != nullptr && !m_enableTileReplay && !m_hevcVdencWeightedPredEnabled)
8742 {
8743 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcUpdate());
8744 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetConstDataHuCBrcUpdate());
8745 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRegionsHuCBrcUpdate(&m_virtualAddrParams));
8746
8747 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(true));
8748
8749 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHal_DbgCallHevcVdencSwBrcImpl(
8750 m_debugInterface,
8751 m_swBrcMode,
8752 CODECHAL_MEDIA_STATE_BRC_UPDATE,
8753 (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW),
8754 &m_vdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][m_currPass],
8755 &m_resPakMmioBuffer,
8756 &m_virtualAddrParams));
8757
8758 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(false));
8759
8760 return eStatus;
8761 }
8762 #endif
8763
8764 MOS_COMMAND_BUFFER cmdBuffer;
8765 CODECHAL_ENCODE_CHK_STATUS_RETURN(GetCommandBuffer(&cmdBuffer));
8766
8767 if (((!m_singleTaskPhaseSupported) || ((m_firstTaskInPhase) && (!m_brcInit))) && (m_numPipe == 1))
8768 {
8769 // Send command buffer header at the beginning (OS dependent)
8770 bool requestFrameTracking = m_singleTaskPhaseSupported ?
8771 m_firstTaskInPhase : 0;
8772 CODECHAL_ENCODE_CHK_STATUS_RETURN(SendPrologWithFrameTracking(&cmdBuffer, requestFrameTracking));
8773 }
8774
8775 // load kernel from WOPCM into L2 storage RAM
8776 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
8777 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
8778
8779 if (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay BRC
8780 {
8781 imemParams.dwKernelDescriptor = m_vdboxHucHevcBrcLowdelayKernelDescriptor;
8782 }
8783 else
8784 {
8785 imemParams.dwKernelDescriptor = m_vdboxHucHevcBrcUpdateKernelDescriptor;
8786 }
8787
8788 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&cmdBuffer, &imemParams));
8789
8790 // pipe mode select
8791 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
8792 pipeModeSelectParams.Mode = m_mode;
8793 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(&cmdBuffer, &pipeModeSelectParams));
8794
8795 // DMEM set
8796 m_CurrentPassForOverAll = 0;
8797 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcUpdate());
8798
8799 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
8800 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
8801 dmemParams.presHucDataSource = &(m_vdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][currentPass]);
8802 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencBrcUpdateDmemBufferSize, CODECHAL_CACHELINE_SIZE);
8803 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
8804
8805 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&cmdBuffer, &dmemParams));
8806
8807 // Set Const Data buffer
8808 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetConstDataHuCBrcUpdate());
8809
8810 // Add Virtual addr
8811 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRegionsHuCBrcUpdate(&m_virtualAddrParams));
8812 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&cmdBuffer, &m_virtualAddrParams));
8813
8814 // Store HUC_STATUS2 register bit 6 before HUC_Start command
8815 // BitField: VALID IMEM LOADED - This bit will be cleared by HW at the end of a HUC workload
8816 // (HUC_Start command with last start bit set).
8817 CODECHAL_DEBUG_TOOL(
8818 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Register(&cmdBuffer));
8819 )
8820
8821 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(&cmdBuffer));
8822
8823 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&cmdBuffer, true));
8824
8825 // wait Huc completion (use HEVC bit for now)
8826 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
8827 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
8828 vdPipeFlushParams.Flags.bFlushHEVC = 1;
8829 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
8830 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&cmdBuffer, &vdPipeFlushParams));
8831
8832 // Flush the engine to ensure memory written out
8833 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8834 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8835 flushDwParams.bVideoPipelineCacheInvalidate = true;
8836 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&cmdBuffer, &flushDwParams));
8837
8838 // Write HUC_STATUS mask: DW1 (mask value)
8839 MHW_MI_STORE_DATA_PARAMS storeDataParams;
8840 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8841 storeDataParams.pOsResource = &m_resPakMmioBuffer;
8842 storeDataParams.dwResourceOffset = sizeof(uint32_t);
8843 storeDataParams.dwValue = CODECHAL_VDENC_HEVC_BRC_HUC_STATUS_REENCODE_MASK;
8844 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&cmdBuffer, &storeDataParams));
8845
8846 // store HUC_STATUS register: DW0 (actual value)
8847 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8848 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
8849 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
8850 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
8851 storeRegParams.presStoreBuffer = &m_resPakMmioBuffer;
8852 storeRegParams.dwOffset = 0;
8853 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
8854 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&cmdBuffer, &storeRegParams));
8855
8856 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHucErrorStatus(mmioRegisters, &cmdBuffer, true));
8857 CODECHAL_ENCODE_CHK_STATUS_RETURN(InsertConditionalBBEndWithHucErrorStatus(&cmdBuffer));
8858
8859 // DW0 & DW1 will considered together for conditional batch buffer end cmd later
8860 if ((!m_singleTaskPhaseSupported) && (m_osInterface->bNoParsingAssistanceInKmd) && (m_numPipe == 1))
8861 {
8862 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(&cmdBuffer, nullptr));
8863 }
8864
8865 // HuC Input
8866 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(true));
8867
8868 CODECHAL_ENCODE_CHK_STATUS_RETURN(ReturnCommandBuffer(&cmdBuffer));
8869
8870 if (!m_singleTaskPhaseSupported)
8871 {
8872 bool renderingFlags = m_videoContextUsesNullHw;
8873
8874 CODECHAL_DEBUG_TOOL(CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpCmdBuffer(
8875 &cmdBuffer,
8876 CODECHAL_MEDIA_STATE_BRC_UPDATE,
8877 nullptr)));
8878 CODECHAL_ENCODE_CHK_STATUS_RETURN(SubmitCommandBuffer(&cmdBuffer, renderingFlags));
8879 }
8880
8881 // HuC Output
8882 CODECHAL_DEBUG_TOOL(DumpHucBrcUpdate(false));
8883
8884 return eStatus;
8885 }
8886
8887 MOS_STATUS CodechalVdencHevcStateG12::HuCBrcTileRowUpdate(PMOS_COMMAND_BUFFER cmdBuffer)
8888 {
8889 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
8890
8891 CODECHAL_ENCODE_FUNCTION_ENTER;
8892
8893 MOS_LOCK_PARAMS lockFlags;
8894 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
8895 lockFlags.WriteOnly = true;
8896
8897 uint8_t *data = (uint8_t *)m_osInterface->pfnLockResource(m_osInterface, &(m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow].OsResource), &lockFlags);
8898 CODECHAL_ENCODE_CHK_NULL_RETURN(data);
8899
8900 MOS_COMMAND_BUFFER tileRowBRCBatchBuf;
8901 MOS_ZeroMemory(&tileRowBRCBatchBuf, sizeof(tileRowBRCBatchBuf));
8902 tileRowBRCBatchBuf.pCmdBase = tileRowBRCBatchBuf.pCmdPtr = (uint32_t *)data;
8903 tileRowBRCBatchBuf.iRemaining = m_hwInterface->m_hucCommandBufferSize;
8904
8905 // Add batch buffer start for tile row BRC batch
8906 HalOcaInterface::OnSubLevelBBStart(*cmdBuffer, (MOS_CONTEXT_HANDLE)m_osInterface->pOsContext, &m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow].OsResource, 0, true, 0);
8907 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferStartCmd(cmdBuffer, &m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow]));
8908
8909 // load kernel from WOPCM into L2 storage RAM
8910 MHW_VDBOX_HUC_IMEM_STATE_PARAMS imemParams;
8911 MOS_ZeroMemory(&imemParams, sizeof(imemParams));
8912
8913 if (m_hevcSeqParams->FrameSizeTolerance == EFRAMESIZETOL_EXTREMELY_LOW) // Low Delay BRC
8914 {
8915 imemParams.dwKernelDescriptor = m_vdboxHucHevcBrcLowdelayKernelDescriptor;
8916 }
8917 else
8918 {
8919 imemParams.dwKernelDescriptor = m_vdboxHucHevcBrcUpdateKernelDescriptor;
8920 }
8921
8922 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucImemStateCmd(&tileRowBRCBatchBuf, &imemParams));
8923
8924 // pipe mode select
8925 MHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams;
8926 pipeModeSelectParams.Mode = m_mode;
8927 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucPipeModeSelectCmd(&tileRowBRCBatchBuf, &pipeModeSelectParams));
8928
8929 // DMEM set
8930 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetDmemHuCBrcUpdate());
8931
8932 MHW_VDBOX_HUC_DMEM_STATE_PARAMS dmemParams;
8933 MOS_ZeroMemory(&dmemParams, sizeof(dmemParams));
8934 dmemParams.presHucDataSource = &(m_vdencBrcUpdateDmemBuffer[m_currRecycledBufIdx][m_CurrentPassForOverAll]);
8935 dmemParams.dwDataLength = MOS_ALIGN_CEIL(m_vdencBrcUpdateDmemBufferSize, CODECHAL_CACHELINE_SIZE);
8936 dmemParams.dwDmemOffset = HUC_DMEM_OFFSET_RTOS_GEMS;
8937
8938 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucDmemStateCmd(&tileRowBRCBatchBuf, &dmemParams));
8939
8940 // Set Const Data buffer
8941 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetConstDataHuCBrcUpdate());
8942
8943 // Add Virtual addr
8944 MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS virtualAddrParams;
8945 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetRegionsHuCTileRowBrcUpdate(&virtualAddrParams));
8946 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucVirtualAddrStateCmd(&tileRowBRCBatchBuf, &virtualAddrParams));
8947
8948 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHuCStatus2Report(cmdBuffer));
8949
8950 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_hucInterface->AddHucStartCmd(&tileRowBRCBatchBuf, true));
8951
8952 // wait Huc completion (use HEVC bit for now)
8953 MHW_VDBOX_VD_PIPE_FLUSH_PARAMS vdPipeFlushParams;
8954 MOS_ZeroMemory(&vdPipeFlushParams, sizeof(vdPipeFlushParams));
8955 vdPipeFlushParams.Flags.bFlushHEVC = 1;
8956 vdPipeFlushParams.Flags.bWaitDoneHEVC = 1;
8957 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdPipelineFlushCmd(&tileRowBRCBatchBuf, &vdPipeFlushParams));
8958
8959 // Flush the engine to ensure memory written out
8960 MHW_MI_FLUSH_DW_PARAMS flushDwParams;
8961 MOS_ZeroMemory(&flushDwParams, sizeof(flushDwParams));
8962 flushDwParams.bVideoPipelineCacheInvalidate = true;
8963 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiFlushDwCmd(&tileRowBRCBatchBuf, &flushDwParams));
8964
8965 // Write HUC_STATUS mask: DW1 (mask value)
8966 MHW_MI_STORE_DATA_PARAMS storeDataParams;
8967 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8968 storeDataParams.pOsResource = &m_resPakMmioBuffer;
8969 storeDataParams.dwResourceOffset = sizeof(uint32_t);
8970 storeDataParams.dwValue = CODECHAL_VDENC_HEVC_BRC_HUC_STATUS_REENCODE_MASK;
8971 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&tileRowBRCBatchBuf, &storeDataParams));
8972
8973 // store HUC_STATUS register: DW0 (actual value)
8974 CODECHAL_ENCODE_CHK_COND_RETURN((m_vdboxIndex > m_mfxInterface->GetMaxVdboxIndex()), "ERROR - vdbox index exceed the maximum");
8975 auto mmioRegisters = m_hucInterface->GetMmioRegisters(m_vdboxIndex);
8976 MHW_MI_STORE_REGISTER_MEM_PARAMS storeRegParams;
8977 MOS_ZeroMemory(&storeRegParams, sizeof(storeRegParams));
8978 storeRegParams.presStoreBuffer = &m_resPakMmioBuffer;
8979 storeRegParams.dwOffset = 0;
8980 storeRegParams.dwRegister = mmioRegisters->hucStatusRegOffset;
8981 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreRegisterMemCmd(&tileRowBRCBatchBuf, &storeRegParams));
8982
8983 CODECHAL_ENCODE_CHK_STATUS_RETURN(StoreHucErrorStatus(mmioRegisters, &tileRowBRCBatchBuf, true));
8984 CODECHAL_ENCODE_CHK_STATUS_RETURN(InsertConditionalBBEndWithHucErrorStatus(&tileRowBRCBatchBuf));
8985
8986 // Set the tile row BRC update sync semaphore
8987 MOS_ZeroMemory(&storeDataParams, sizeof(storeDataParams));
8988 storeDataParams.pOsResource = &m_resTileRowBRCsyncSemaphore;
8989 storeDataParams.dwValue = 0xFF;
8990 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiStoreDataImmCmd(&tileRowBRCBatchBuf, &storeDataParams));
8991
8992 (&m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow])->iCurrent = tileRowBRCBatchBuf.iOffset;
8993 (&m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow])->iRemaining = tileRowBRCBatchBuf.iRemaining;
8994 (&m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow])->pData = data;
8995 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiBatchBufferEnd(nullptr, &m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow]));
8996
8997 if (data)
8998 {
8999 m_osInterface->pfnUnlockResource(m_osInterface, &(m_TileRowBRCBatchBuffer[m_CurrentPassForTileReplay][m_CurrentTileRow].OsResource));
9000 }
9001
9002 return eStatus;
9003 }
9004
9005 MOS_STATUS CodechalVdencHevcStateG12::UpdateCmdBufAttribute(
9006 PMOS_COMMAND_BUFFER cmdBuffer,
9007 bool renderEngineInUse)
9008 {
9009 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
9010
9011 // should not be there. Will remove it in the next change
9012 CODECHAL_ENCODE_FUNCTION_ENTER;
9013 if (MOS_VE_SUPPORTED(m_osInterface) && cmdBuffer->Attributes.pAttriVe)
9014 {
9015 PMOS_CMD_BUF_ATTRI_VE attriExt =
9016 (PMOS_CMD_BUF_ATTRI_VE)(cmdBuffer->Attributes.pAttriVe);
9017
9018 memset(attriExt, 0, sizeof(MOS_CMD_BUF_ATTRI_VE));
9019 attriExt->bUseVirtualEngineHint =
9020 attriExt->VEngineHintParams.NeedSyncWithPrevious = !renderEngineInUse;
9021 }
9022
9023 return eStatus;
9024 }
9025
9026 MOS_STATUS CodechalVdencHevcStateG12::AddMediaVfeCmd(
9027 PMOS_COMMAND_BUFFER cmdBuffer,
9028 SendKernelCmdsParams *params)
9029 {
9030 CODECHAL_ENCODE_CHK_NULL_RETURN(params);
9031
9032 MHW_VFE_PARAMS_G12 vfeParams = {};
9033 vfeParams.pKernelState = params->pKernelState;
9034 vfeParams.eVfeSliceDisable = MHW_VFE_SLICE_ALL;
9035 vfeParams.dwMaximumNumberofThreads = m_encodeVfeMaxThreads;
9036 vfeParams.bFusedEuDispatch = false; // legacy mode
9037
9038 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_renderEngineInterface->AddMediaVfeCmd(cmdBuffer, &vfeParams));
9039
9040 return MOS_STATUS_SUCCESS;
9041 }
9042
9043 void CodechalVdencHevcStateG12::SetStreaminDataPerLcu(
9044 PMHW_VDBOX_VDENC_STREAMIN_STATE_PARAMS streaminParams,
9045 void* streaminData)
9046 {
9047 CODECHAL_ENCODE_FUNCTION_ENTER;
9048 PCODECHAL_VDENC_HEVC_STREAMIN_STATE_G12 data = (PCODECHAL_VDENC_HEVC_STREAMIN_STATE_G12)streaminData;
9049 if (streaminParams->setQpRoiCtrl)
9050 {
9051 if (m_vdencNativeROIEnabled || m_brcAdaptiveRegionBoostEnable)
9052 {
9053 data->DW0.RoiCtrl = streaminParams->roiCtrl;
9054 }
9055 else
9056 {
9057 data->DW7.QpEnable = 0xf;
9058 data->DW14.ForceQp_0 = streaminParams->forceQp[0];
9059 data->DW14.ForceQp_1 = streaminParams->forceQp[1];
9060 data->DW14.ForceQp_2 = streaminParams->forceQp[2];
9061 data->DW14.ForceQp_3 = streaminParams->forceQp[3];
9062 }
9063 }
9064 else
9065 {
9066 data->DW0.MaxTuSize = streaminParams->maxTuSize;
9067 data->DW0.MaxCuSize = streaminParams->maxCuSize;
9068 data->DW0.NumImePredictors = streaminParams->numImePredictors;
9069 data->DW0.PuTypeCtrl = streaminParams->puTypeCtrl;
9070 data->DW6.NumMergeCandidateCu64x64 = streaminParams->numMergeCandidateCu64x64;
9071 data->DW6.NumMergeCandidateCu32x32 = streaminParams->numMergeCandidateCu32x32;
9072 data->DW6.NumMergeCandidateCu16x16 = streaminParams->numMergeCandidateCu16x16;
9073 data->DW6.NumMergeCandidateCu8x8 = streaminParams->numMergeCandidateCu8x8;
9074 }
9075 }
9076
9077 void CodechalVdencHevcStateG12::GetTileInfo(
9078 uint32_t xPosition,
9079 uint32_t yPosition,
9080 uint32_t* tileId,
9081 uint32_t* tileEndLCUX,
9082 uint32_t* tileEndLCUY)
9083 {
9084 *tileId = 0;
9085 uint32_t ctbSize = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
9086 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
9087
9088 for (uint8_t i = 0; i < m_numTiles; i++)
9089 {
9090 uint32_t tileWidthInLCU = MOS_ROUNDUP_DIVIDE(((tileParams[i].TileWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
9091 uint32_t tileHeightInLCU = MOS_ROUNDUP_DIVIDE(((tileParams[i].TileHeightInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
9092 *tileEndLCUX = tileParams[i].TileStartLCUX + tileWidthInLCU;
9093 *tileEndLCUY = tileParams[i].TileStartLCUY + tileHeightInLCU;
9094
9095 if (xPosition >= (tileParams[i].TileStartLCUX * 2) &&
9096 yPosition >= (tileParams[i].TileStartLCUY * 2) &&
9097 xPosition < (*tileEndLCUX * 2) &&
9098 yPosition < (*tileEndLCUY * 2))
9099 {
9100 *tileId = i;
9101 break;
9102 }
9103 }
9104 }
9105
9106 MOS_STATUS CodechalVdencHevcStateG12::PrepareVDEncStreamInData()
9107 {
9108 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
9109
9110 CODECHAL_ENCODE_FUNCTION_ENTER;
9111
9112 if (m_lookaheadPass && m_firstFrame)
9113 {
9114 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetupForceIntraStreamIn(&m_resVdencStreamInBuffer[0]));
9115 }
9116
9117 if (m_hevcPicParams->tiles_enabled_flag)
9118 {
9119 CODECHAL_ENCODE_CHK_STATUS_RETURN(SetTileData(m_tileParams[m_virtualEngineBbIndex]));
9120 }
9121 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::PrepareVDEncStreamInData());
9122
9123 return eStatus;
9124 }
9125
9126 void CodechalVdencHevcStateG12::SetStreaminDataPerRegion(
9127 uint32_t streamInWidth,
9128 uint32_t top,
9129 uint32_t bottom,
9130 uint32_t left,
9131 uint32_t right,
9132 PMHW_VDBOX_VDENC_STREAMIN_STATE_PARAMS streaminParams,
9133 void* streaminData)
9134 {
9135 CODECHAL_ENCODE_FUNCTION_ENTER;
9136
9137 if (!m_hevcPicParams->tiles_enabled_flag)
9138 {
9139 CodechalVdencHevcState::SetStreaminDataPerRegion(streamInWidth, top, bottom, left, right, streaminParams, streaminData);
9140 return;
9141 }
9142
9143 uint8_t* data = (uint8_t*)streaminData;
9144 uint32_t tileId = 0, tileEndLCUX = 0, tileEndLCUY = 0;
9145 uint32_t ctbSize = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
9146 GetTileInfo(left, top, &tileId, &tileEndLCUX, &tileEndLCUY);
9147
9148 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
9149
9150 for (auto y = top; y < bottom; y++)
9151 {
9152 for (auto x = left; x < right; x++)
9153 {
9154 uint32_t streamInBaseOffset = 0, offset = 0, xyOffset = 0;
9155
9156 if (x < (tileParams[tileId].TileStartLCUX * 2) ||
9157 y < (tileParams[tileId].TileStartLCUY * 2) ||
9158 x >= (tileEndLCUX * 2) ||
9159 y >= (tileEndLCUY * 2))
9160 {
9161 GetTileInfo(x, y, &tileId, &tileEndLCUX, &tileEndLCUY);
9162 }
9163 streamInBaseOffset = tileParams[tileId].TileStreaminOffset;
9164
9165 auto xPositionInTile = x - (tileParams[tileId].TileStartLCUX * 2);
9166 auto yPositionInTile = y - (tileParams[tileId].TileStartLCUY * 2);
9167 auto tileWidthInLCU = MOS_ROUNDUP_DIVIDE(((tileParams[tileId].TileWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
9168
9169 StreaminZigZagToLinearMap(tileWidthInLCU * 2, xPositionInTile, yPositionInTile, &offset, &xyOffset);
9170
9171 SetStreaminDataPerLcu(streaminParams, data + (streamInBaseOffset + offset + xyOffset) * 64);
9172 }
9173 }
9174 }
9175
9176 void CodechalVdencHevcStateG12::SetBrcRoiDeltaQpMap(
9177 uint32_t streamInWidth,
9178 uint32_t top,
9179 uint32_t bottom,
9180 uint32_t left,
9181 uint32_t right,
9182 uint8_t regionId,
9183 PDeltaQpForROI deltaQpMap)
9184 {
9185
9186 CODECHAL_ENCODE_FUNCTION_ENTER;
9187
9188 if (!m_hevcPicParams->tiles_enabled_flag)
9189 {
9190 CodechalVdencHevcState::SetBrcRoiDeltaQpMap(streamInWidth, top, bottom, left, right, regionId, deltaQpMap);
9191 return;
9192 }
9193
9194 uint32_t tileId = 0, tileEndLCUX = 0, tileEndLCUY = 0;
9195 uint32_t ctbSize = 1 << (m_hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
9196 GetTileInfo(left, top, &tileId, &tileEndLCUX, &tileEndLCUY);
9197
9198 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
9199
9200 for (auto y = top; y < bottom; y++)
9201 {
9202 for (auto x = left; x < right; x++)
9203 {
9204 uint32_t streamInBaseOffset = 0, offset = 0, xyOffset = 0;
9205
9206 if (x < (tileParams[tileId].TileStartLCUX * 2) ||
9207 y < (tileParams[tileId].TileStartLCUY * 2) ||
9208 x >= (tileEndLCUX * 2) ||
9209 y >= (tileEndLCUY * 2))
9210 {
9211 GetTileInfo(x, y, &tileId, &tileEndLCUX, &tileEndLCUY);
9212 }
9213 streamInBaseOffset = tileParams[tileId].TileStreaminOffset;
9214
9215 auto xPositionInTile = x - (tileParams[tileId].TileStartLCUX * 2);
9216 auto yPositionInTile = y - (tileParams[tileId].TileStartLCUY * 2);
9217 auto tileWidthInLCU = MOS_ROUNDUP_DIVIDE(((tileParams[tileId].TileWidthInMinCbMinus1 + 1) << (m_hevcSeqParams->log2_min_coding_block_size_minus3 + 3)), ctbSize);
9218
9219 StreaminZigZagToLinearMap(tileWidthInLCU * 2, xPositionInTile, yPositionInTile, &offset, &xyOffset);
9220
9221 (deltaQpMap + (streamInBaseOffset + offset + xyOffset))->iDeltaQp = m_hevcPicParams->ROI[regionId].PriorityLevelOrDQp;
9222 }
9223 }
9224 }
9225
9226 MOS_STATUS CodechalVdencHevcStateG12::SetAndPopulateVEHintParams(
9227 PMOS_COMMAND_BUFFER cmdBuffer)
9228 {
9229 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
9230
9231 CODECHAL_ENCODE_FUNCTION_ENTER;
9232
9233 if (!MOS_VE_SUPPORTED(m_osInterface))
9234 {
9235 return eStatus;
9236 }
9237
9238 CODECHAL_ENCODE_SCALABILITY_SETHINT_PARMS scalSetParms;
9239 MOS_ZeroMemory(&scalSetParms, sizeof(CODECHAL_ENCODE_SCALABILITY_SETHINT_PARMS));
9240
9241 if (!MOS_VE_CTXBASEDSCHEDULING_SUPPORTED(m_osInterface))
9242 {
9243 scalSetParms.bNeedSyncWithPrevious = true;
9244 }
9245
9246 int32_t currentPass = GetCurrentPass();
9247 if (currentPass < 0 || currentPass >= CODECHAL_HEVC_MAX_NUM_BRC_PASSES)
9248 {
9249 eStatus = MOS_STATUS_INVALID_PARAMETER;
9250 return eStatus;
9251 }
9252 uint8_t passIndex = m_singleTaskPhaseSupported ? 0 : currentPass;
9253 if (m_numPipe >= 2)
9254 {
9255 for (auto i = 0; i < m_numPipe; i++)
9256 {
9257 scalSetParms.veBatchBuffer[i] = m_veBatchBuffer[m_virtualEngineBbIndex][i][passIndex].OsResource;
9258 }
9259 }
9260
9261 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalEncodeScalability_SetHintParams(this, m_scalabilityState, &scalSetParms));
9262 CODECHAL_ENCODE_CHK_NULL_RETURN(cmdBuffer);
9263 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodecHalEncodeScalability_PopulateHintParams(m_scalabilityState, cmdBuffer));
9264
9265 return eStatus;
9266 }
9267
9268 #if USE_CODECHAL_DEBUG_TOOL
9269 MOS_STATUS CodechalVdencHevcStateG12::DumpVdencOutputs()
9270 {
9271 CODECHAL_ENCODE_FUNCTION_ENTER;
9272
9273 CODECHAL_ENCODE_CHK_STATUS_RETURN(CodechalVdencHevcState::DumpVdencOutputs());
9274
9275 if (m_hevcPicParams->tiles_enabled_flag)
9276 {
9277 PMOS_RESOURCE presVdencTileStatisticsBuffer = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource;
9278 auto num_tiles = (m_hevcPicParams->num_tile_rows_minus1 + 1) * (m_hevcPicParams->num_tile_columns_minus1 + 1);
9279 auto vdencStatsSizeAllTiles = num_tiles * m_vdencBrcStatsBufferSize;
9280 auto vdencStatsOffset = m_hevcTileStatsOffset.uiVdencStatistics;
9281 auto pakStatsSizeAllTiles = num_tiles * 9 * CODECHAL_CACHELINE_SIZE;
9282 auto pakStatsOffset = m_hevcTileStatsOffset.uiHevcPakStatistics;
9283
9284 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
9285 presVdencTileStatisticsBuffer,
9286 CodechalDbgAttr::attrVdencOutput,
9287 "_TileVDEncStats",
9288 vdencStatsSizeAllTiles,
9289 vdencStatsOffset,
9290 CODECHAL_NUM_MEDIA_STATES));
9291
9292 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
9293 presVdencTileStatisticsBuffer,
9294 CodechalDbgAttr::attrPakOutput,
9295 "_TilePAKStats",
9296 pakStatsSizeAllTiles,
9297 pakStatsOffset,
9298 CODECHAL_NUM_MEDIA_STATES));
9299
9300 // Slice Size Conformance
9301 if (m_hevcSeqParams->SliceSizeControl)
9302 {
9303 PMOS_RESOURCE presLcuBaseAddressBuffer = &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource;
9304 auto sliceStreamoutOffset = m_hevcTileStatsOffset.uiHevcSliceStreamout;
9305 uint32_t size = m_numLcu * CODECHAL_CACHELINE_SIZE;
9306 // Slice Size StreamOut Surface
9307 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpBuffer(
9308 presLcuBaseAddressBuffer,
9309 CodechalDbgAttr::attrVdencOutput,
9310 "_SliceSize",
9311 size,
9312 sliceStreamoutOffset,
9313 CODECHAL_NUM_MEDIA_STATES));
9314 }
9315 }
9316
9317 return MOS_STATUS_SUCCESS;
9318 }
9319
9320 MOS_STATUS CodechalVdencHevcStateG12::DumpHucDebugOutputBuffers()
9321 {
9322 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
9323
9324 // Virtual Engine does only one submit per pass. Dump all HuC debug outputs
9325 bool dumpDebugBuffers = IsLastPipe() && (m_numPipe > 1);
9326 if (m_singleTaskPhaseSupported)
9327 {
9328 dumpDebugBuffers = dumpDebugBuffers && IsLastPass();
9329 }
9330
9331 if (dumpDebugBuffers)
9332 {
9333 CODECHAL_DEBUG_TOOL(
9334 DumpHucPakIntegrate();
9335 DumpHucCqp();
9336 )
9337 }
9338
9339 return eStatus;
9340 }
9341
9342 MOS_STATUS CodechalVdencHevcStateG12::DumpHucPakIntegrate()
9343 {
9344 int32_t currentPass = GetCurrentPass();
9345 // HuC Input
9346 // HuC DMEM
9347 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucDmem(
9348 &m_resHucPakStitchDmemBuffer[m_currRecycledBufIdx][currentPass],
9349 MOS_ALIGN_CEIL(sizeof(HucPakStitchDmemVdencG12), CODECHAL_CACHELINE_SIZE),
9350 currentPass,
9351 hucRegionDumpPakIntegrate));
9352
9353 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9354 &m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].sResource,
9355 0,
9356 m_resTileBasedStatisticsBuffer[m_virtualEngineBbIndex].dwSize,
9357 0,
9358 "",
9359 true,
9360 currentPass,
9361 hucRegionDumpPakIntegrate));
9362
9363 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9364 &m_resHuCPakAggregatedFrameStatsBuffer.sResource,
9365 0,
9366 m_resHuCPakAggregatedFrameStatsBuffer.dwSize,
9367 1,
9368 "",
9369 false,
9370 currentPass,
9371 hucRegionDumpPakIntegrate));
9372
9373 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G12 tileParams = m_tileParams[m_virtualEngineBbIndex];
9374 CODECHAL_ENCODE_CHK_NULL_RETURN(tileParams);
9375
9376 auto bitStreamSize = m_encodeParams.dwBitstreamSize -
9377 MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE);
9378
9379 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9380 &m_resBitstreamBuffer,
9381 MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE),
9382 bitStreamSize,
9383 4,
9384 "",
9385 true,
9386 currentPass,
9387 hucRegionDumpPakIntegrate));
9388
9389 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9390 &m_resBitstreamBuffer,
9391 MOS_ALIGN_FLOOR(tileParams[m_numTiles - 1].BitstreamByteOffset * CODECHAL_CACHELINE_SIZE, CODECHAL_PAGE_SIZE),
9392 bitStreamSize,
9393 5,
9394 "",
9395 false,
9396 currentPass,
9397 hucRegionDumpPakIntegrate));
9398
9399 // Region 6 - BRC History buffer
9400 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9401 &m_vdencBrcHistoryBuffer,
9402 0,
9403 CODECHAL_VDENC_HEVC_BRC_HISTORY_BUF_SIZE,
9404 6,
9405 "",
9406 false,
9407 currentPass,
9408 hucRegionDumpPakIntegrate));
9409
9410 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9411 &m_thirdLevelBatchBuffer.OsResource,
9412 0,
9413 m_thirdLBSize,
9414 7,
9415 "",
9416 true,
9417 currentPass,
9418 hucRegionDumpPakIntegrate));
9419
9420 // Region 8
9421 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9422 &m_resHucStitchDataBuffer[m_currRecycledBufIdx][currentPass],
9423 0,
9424 MOS_ALIGN_CEIL(sizeof(HucCommandDataVdencG12), CODECHAL_PAGE_SIZE),
9425 8,
9426 "",
9427 true,
9428 currentPass,
9429 hucRegionDumpPakIntegrate));
9430
9431 // Region 9 - HCP BRC Data Output
9432 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9433 &m_resBrcDataBuffer,
9434 0,
9435 CODECHAL_CACHELINE_SIZE,
9436 9,
9437 "",
9438 false,
9439 currentPass,
9440 hucRegionDumpPakIntegrate));
9441
9442 // Region 10
9443 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9444 &m_HucStitchCmdBatchBuffer.OsResource,
9445 0,
9446 m_hwInterface->m_HucStitchCmdBatchBufferSize,
9447 10,
9448 "",
9449 false,
9450 currentPass,
9451 hucRegionDumpPakIntegrate));
9452
9453 CODECHAL_DEBUG_CHK_STATUS(m_debugInterface->DumpHucRegion(
9454 &m_tileRecordBuffer[m_virtualEngineBbIndex].sResource,
9455 0,
9456 m_tileRecordBuffer[m_virtualEngineBbIndex].dwSize,
9457 15,
9458 "",
9459 true,
9460 currentPass,
9461 hucRegionDumpPakIntegrate));
9462
9463 return MOS_STATUS_SUCCESS;
9464 }
9465
9466 MOS_STATUS CodechalVdencHevcStateG12::DumpHucCqp()
9467 {
9468 CODECHAL_ENCODE_FUNCTION_ENTER;
9469 int32_t currentPass = GetCurrentPass();
9470
9471 // Region 5 - Output SLB Buffer
9472 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_debugInterface->DumpHucRegion(
9473 &m_vdenc2ndLevelBatchBuffer[m_currRecycledBufIdx].OsResource,
9474 0,
9475 m_hwInterface->m_vdenc2ndLevelBatchBufferSize,
9476 5,
9477 "_Out_Slb",
9478 false,
9479 currentPass,
9480 hucRegionDumpUpdate));
9481
9482 return MOS_STATUS_SUCCESS;
9483 }
9484 #endif
9485
9486 MOS_STATUS CodechalVdencHevcStateG12::SetRoundingValues()
9487 {
9488 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
9489
9490 CODECHAL_ENCODE_FUNCTION_ENTER;
9491
9492 if (m_hevcPicParams->CustomRoundingOffsetsParams.fields.EnableCustomRoudingIntra)
9493 {
9494 m_roundIntraValue = m_hevcPicParams->CustomRoundingOffsetsParams.fields.RoundingOffsetIntra;
9495 }
9496 else
9497 {
9498 if (m_hevcPicParams->CodingType == I_TYPE)
9499 {
9500 m_roundIntraValue = 10;
9501 }
9502 else if (m_hevcSeqParams->HierarchicalFlag && m_hevcPicParams->HierarchLevelPlus1 > 0)
9503 {
9504 if (m_hevcPicParams->HierarchLevelPlus1 == 1)
9505 {
9506 m_roundIntraValue = 10;
9507 }
9508 else if (m_hevcPicParams->HierarchLevelPlus1 == 2)
9509 {
9510 m_roundIntraValue = 9;
9511 }
9512 else
9513 {
9514 m_roundIntraValue = 8;
9515 }
9516 }
9517 else
9518 {
9519 m_roundIntraValue = 10;
9520 }
9521 }
9522
9523 if (m_hevcPicParams->CustomRoundingOffsetsParams.fields.EnableCustomRoudingInter)
9524 {
9525 m_roundInterValue = m_hevcPicParams->CustomRoundingOffsetsParams.fields.RoundingOffsetInter;
9526 }
9527 else
9528 {
9529 if (m_hevcPicParams->CodingType == I_TYPE)
9530 {
9531 m_roundInterValue = 4;
9532 }
9533 else if (m_hevcSeqParams->HierarchicalFlag && m_hevcPicParams->HierarchLevelPlus1 > 0)
9534 {
9535 if (m_hevcPicParams->HierarchLevelPlus1 == 1)
9536 {
9537 m_roundInterValue = 4;
9538 }
9539 else if (m_hevcPicParams->HierarchLevelPlus1 == 2)
9540 {
9541 m_roundInterValue = 3;
9542 }
9543 else
9544 {
9545 m_roundInterValue = 2;
9546 }
9547 }
9548 else
9549 {
9550 m_roundInterValue = 4;
9551 }
9552 }
9553
9554 return eStatus;
9555 }
9556
9557 MOS_STATUS CodechalVdencHevcStateG12::SetAddCommands(uint32_t commandType, PMOS_COMMAND_BUFFER cmdBuffer, bool addToBatchBufferHuCBRC, uint32_t roundInterValue, uint32_t roundIntraValue, bool isLowDelayB, int8_t * pRefIdxMapping, int8_t recNotFilteredID)
9558 {
9559 #ifdef _HEVC_ENCODE_VDENC_SUPPORTED
9560 void *pCmdParams = nullptr;
9561
9562 if (commandType == CODECHAL_CMD1)
9563 {
9564 // Send CMD1 command
9565 MHW_VDBOX_VDENC_CMD1_PARAMS cmd1Params;
9566 MOS_ZeroMemory(&cmd1Params, sizeof(cmd1Params));
9567 cmd1Params.Mode = CODECHAL_ENCODE_MODE_HEVC;
9568 cmd1Params.pHevcEncPicParams = m_hevcPicParams;
9569 cmd1Params.pHevcEncSlcParams = m_hevcSliceParams;
9570 cmd1Params.pInputParams = pCmdParams;
9571 cmd1Params.bHevcVisualQualityImprovement = m_hevcVisualQualityImprovement;
9572 //down cast?
9573 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencCmd1Cmd(cmdBuffer, nullptr, &cmd1Params));
9574 }
9575 else if (commandType == CODECHAL_CMD2)
9576 {
9577 PMHW_VDBOX_VDENC_CMD2_STATE cmd2Params(new MHW_VDBOX_VDENC_CMD2_STATE);
9578 CODECHAL_ENCODE_CHK_NULL_RETURN(cmd2Params);
9579
9580 // set CMD2 command
9581 cmd2Params->Mode = CODECHAL_ENCODE_MODE_HEVC;
9582 cmd2Params->pHevcEncSeqParams = m_hevcSeqParams;
9583 cmd2Params->pHevcEncPicParams = m_hevcPicParams;
9584 cmd2Params->pHevcEncSlcParams = m_hevcSliceParams;
9585 cmd2Params->bRoundingEnabled = m_hevcVdencRoundingEnabled;
9586 cmd2Params->bPakOnlyMultipassEnable = m_pakOnlyPass;
9587 cmd2Params->bUseDefaultQpDeltas = (m_hevcVdencAcqpEnabled && cmd2Params->pHevcEncSeqParams->QpAdjustment) ||
9588 (m_brcEnabled && cmd2Params->pHevcEncSeqParams->MBBRC != mbBrcDisabled);
9589 cmd2Params->bPanicEnabled = (m_brcEnabled) && (m_panicEnable) && (IsLastPass()) && !m_pakOnlyPass;
9590 cmd2Params->bStreamInEnabled = m_vdencStreamInEnabled;
9591 cmd2Params->bROIStreamInEnabled = m_vdencNativeROIEnabled;
9592 cmd2Params->bTileReplayEnable = m_enableTileReplay;
9593 cmd2Params->bIsLowDelayB = isLowDelayB;
9594 cmd2Params->bCaptureModeEnable = m_CaptureModeEnable;
9595 cmd2Params->m_WirelessSessionID = 0;
9596 cmd2Params->pRefIdxMapping = pRefIdxMapping;
9597 cmd2Params->recNotFilteredID = recNotFilteredID;
9598 cmd2Params->pInputParams = pCmdParams;
9599 cmd2Params->ucNumRefIdxL0ActiveMinus1 = cmd2Params->pHevcEncSlcParams->num_ref_idx_l0_active_minus1;
9600 cmd2Params->bHevcVisualQualityImprovement = m_hevcVisualQualityImprovement;
9601 cmd2Params->roundInterValue = roundInterValue;
9602 cmd2Params->roundIntraValue = roundIntraValue;
9603 cmd2Params->bROIStreamInEnabled = m_brcAdaptiveRegionBoostEnable ? true : cmd2Params->bROIStreamInEnabled;
9604 cmd2Params->bEnableSubPelMode = m_encodeParams.bEnableSubPelMode;
9605 cmd2Params->SubPelMode = m_encodeParams.SubPelMode;
9606
9607 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_vdencInterface->AddVdencCmd2Cmd(cmdBuffer, nullptr, cmd2Params));
9608 }
9609 #endif
9610 return MOS_STATUS_SUCCESS;
9611 }
9612
9613 MOS_STATUS CodechalVdencHevcStateG12::InsertConditionalBBEndWithHucErrorStatus(PMOS_COMMAND_BUFFER cmdBuffer)
9614 {
9615 MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS miEnhancedConditionalBatchBufferEndParams;
9616
9617 MOS_ZeroMemory(
9618 &miEnhancedConditionalBatchBufferEndParams,
9619 sizeof(MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS));
9620
9621 miEnhancedConditionalBatchBufferEndParams.presSemaphoreBuffer = &m_resHucErrorStatusBuffer;
9622
9623 miEnhancedConditionalBatchBufferEndParams.dwParamsType = MHW_MI_ENHANCED_CONDITIONAL_BATCH_BUFFER_END_PARAMS::ENHANCED_PARAMS;
9624 miEnhancedConditionalBatchBufferEndParams.enableEndCurrentBatchBuffLevel = false;
9625 miEnhancedConditionalBatchBufferEndParams.compareOperation = MAD_EQUAL_IDD;
9626
9627 CODECHAL_ENCODE_CHK_STATUS_RETURN(m_miInterface->AddMiConditionalBatchBufferEndCmd(
9628 cmdBuffer,
9629 (PMHW_MI_CONDITIONAL_BATCH_BUFFER_END_PARAMS)(&miEnhancedConditionalBatchBufferEndParams)));
9630
9631 return MOS_STATUS_SUCCESS;
9632 }
9633