Debian Codegraph @

media_driver/agnostic/gen9_skl/hw/vdbox/mhw_vdbox_hcp_g9_skl.cpp

raw
1 /*
2 * Copyright (c) 2017, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vdbox_hcp_g9_skl.cpp
24 //! \brief Defines functions for constructing Vdbox HCP commands on G9 SKL
25 //!
26
27 #include "mos_os_cp_interface_specific.h"
28 #include "mhw_vdbox_hcp_g9_skl.h"
29 #include "mhw_mi_hwcmd_g9_X.h"
30 #include "mhw_vdbox_vdenc_hwcmd_g9_skl.h"
31
32 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::GetHcpStateCommandSize(
33 uint32_t mode,
34 uint32_t *commandsSize,
35 uint32_t *patchListSize,
36 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
37 {
38 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
39
40 MHW_FUNCTION_ENTER;
41
42 uint32_t maxSize = 0;
43 uint32_t patchListMaxSize = 0;
44 uint32_t standard = CodecHal_GetStandardFromMode(mode);
45
46 if (standard == CODECHAL_HEVC)
47 {
48 maxSize =
49 mhw_vdbox_vdenc_g9_skl::VD_PIPELINE_FLUSH_CMD::byteSize +
50 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
51 mhw_vdbox_hcp_g9_skl::HCP_PIPE_MODE_SELECT_CMD::byteSize +
52 mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD::byteSize +
53 mhw_vdbox_hcp_g9_skl::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
54 mhw_vdbox_hcp_g9_skl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize;
55
56 patchListMaxSize =
57 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
58 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
59 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
60 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) +
61 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
62 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD);
63
64 if (mode == CODECHAL_ENCODE_MODE_HEVC)
65 {
66 /* HCP_QM_STATE_CMD may be issued up to 20 times: 3x Colour Component plus 2x intra/inter plus 4x SizeID minus 4 for the 32x32 chroma components.
67 HCP_FQP_STATE_CMD may be issued up to 8 times: 4 scaling list per intra and inter. */
68 maxSize +=
69 mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD::byteSize + // encoder needs two surface state commands. One is for raw and another one is for recon surfaces.
70 20 * mhw_vdbox_hcp_g9_skl::HCP_QM_STATE_CMD::byteSize +
71 8 * mhw_vdbox_hcp_g9_skl::HCP_FQM_STATE_CMD::byteSize +
72 mhw_vdbox_hcp_g9_skl::HCP_PIC_STATE_CMD::byteSize +
73 2 * mhw_mi_g9_X::MI_STORE_DATA_IMM_CMD::byteSize + // Slice level commands
74 2 * mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize + // need for Status report, Mfc Status and
75 10 * mhw_mi_g9_X::MI_STORE_REGISTER_MEM_CMD::byteSize + // 8 for BRCStatistics and 2 for RC6 WAs
76 mhw_mi_g9_X::MI_LOAD_REGISTER_MEM_CMD::byteSize + // 1 for RC6
77 2 * mhw_vdbox_hcp_g9_skl::HCP_PAK_INSERT_OBJECT_CMD::byteSize + // Two PAK insert object commands are for headers before the slice header and the header for the end of stream
78 4 * mhw_mi_g9_X::MI_STORE_DATA_IMM_CMD::byteSize + // two (BRC+reference frame) for clean-up HW semaphore memory and another two for signal it
79 17 * mhw_mi_g9_X::MI_SEMAPHORE_WAIT_CMD::byteSize + // Use HW wait command for each reference and one wait for current semaphore object
80 mhw_mi_g9_X::MI_SEMAPHORE_WAIT_CMD::byteSize; // Use HW wait command for each BRC pass
81
82 patchListMaxSize +=
83 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
84 8 * PATCH_LIST_COMMAND(HCP_FQM_STATE_CMD) +
85 PATCH_LIST_COMMAND(HCP_PIC_STATE_CMD) +
86 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD) + // When BRC is on, HCP_PIC_STATE_CMD command is in the BB
87 2 * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD) + // Slice level commands
88 2 * PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) + // need for Status report, Mfc Status and
89 11 * PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD) +// 8 for BRCStatistics and 3 for RC6 WAs
90 22 * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD); // Use HW wait commands plus its memory clean-up and signal (4 + 16 +1 + 1)
91 }
92 else
93 {
94 maxSize +=
95 20 * mhw_vdbox_hcp_g9_skl::HCP_QM_STATE_CMD::byteSize +
96 mhw_vdbox_hcp_g9_skl::HCP_PIC_STATE_CMD::byteSize +
97 mhw_vdbox_hcp_g9_skl::HCP_TILE_STATE_CMD::byteSize;
98
99 patchListMaxSize +=
100 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
101 PATCH_LIST_COMMAND(HCP_PIC_STATE_CMD) +
102 PATCH_LIST_COMMAND(HCP_TILE_STATE_CMD);
103 }
104 }
105 else if (standard == CODECHAL_VP9) // VP9 Clear Decode
106 {
107 maxSize =
108 mhw_vdbox_vdenc_g9_skl::VD_PIPELINE_FLUSH_CMD::byteSize +
109 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
110 mhw_vdbox_hcp_g9_skl::HCP_PIPE_MODE_SELECT_CMD::byteSize +
111 mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD::byteSize * 4 +
112 mhw_vdbox_hcp_g9_skl::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
113 mhw_vdbox_hcp_g9_skl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
114 mhw_vdbox_hcp_g9_skl::HCP_BSD_OBJECT_CMD::byteSize;
115
116 patchListMaxSize =
117 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
118 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
119 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
120 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) * 4 +
121 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
122 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD) +
123 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
124 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
125 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
126 }
127 else
128 {
129 MHW_ASSERTMESSAGE("Unsupported standard.");
130 eStatus = MOS_STATUS_UNKNOWN;
131 }
132
133 *commandsSize = maxSize;
134 *patchListSize = patchListMaxSize;
135
136 return eStatus;
137 }
138
139 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::GetHcpPrimitiveCommandSize(
140 uint32_t mode,
141 uint32_t *commandsSize,
142 uint32_t *patchListSize,
143 bool modeSpecific)
144 {
145 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
146
147 MHW_FUNCTION_ENTER;
148
149 uint32_t standard = CodecHal_GetStandardFromMode(mode);
150 uint32_t maxSize = 0;
151 uint32_t patchListMaxSize = 0;
152
153 if (standard == CODECHAL_HEVC)
154 {
155 if (mode == CODECHAL_ENCODE_MODE_HEVC)
156 {
157 maxSize =
158 2 * mhw_vdbox_hcp_g9_skl::HCP_REF_IDX_STATE_CMD::byteSize +
159 2 * mhw_vdbox_hcp_g9_skl::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
160 mhw_vdbox_hcp_g9_skl::HCP_SLICE_STATE_CMD::byteSize +
161 mhw_vdbox_hcp_g9_skl::HCP_PAK_INSERT_OBJECT_CMD::byteSize +
162 mhw_mi_g9_X::MI_BATCH_BUFFER_START_CMD::byteSize;
163
164 patchListMaxSize =
165 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
166 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
167 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
168 PATCH_LIST_COMMAND(HCP_PAK_INSERT_OBJECT_CMD) +
169 2 * PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD); // One is for the PAK command and another one is for the BB when BRC and single task mode are on
170 }
171 else
172 {
173 maxSize =
174 2 * mhw_vdbox_hcp_g9_skl::HCP_REF_IDX_STATE_CMD::byteSize +
175 2 * mhw_vdbox_hcp_g9_skl::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
176 mhw_vdbox_hcp_g9_skl::HCP_SLICE_STATE_CMD::byteSize +
177 mhw_vdbox_hcp_g9_skl::HCP_BSD_OBJECT_CMD::byteSize +
178 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
179
180 patchListMaxSize =
181 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
182 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
183 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
184 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
185 }
186 }
187 else if (standard == CODECHAL_VP9) // VP9 Clear decode does not require primitive level commands. VP9 DRM does.
188 {
189 if (modeSpecific) // VP9 DRM
190 {
191 maxSize +=
192 mhw_vdbox_hcp_g9_skl::HCP_BSD_OBJECT_CMD::byteSize +
193 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
194
195 patchListMaxSize =
196 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
197 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
198 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
199 }
200 }
201 else
202 {
203 MHW_ASSERTMESSAGE("Unsupported standard.");
204 eStatus = MOS_STATUS_UNKNOWN;
205 }
206
207 *commandsSize = maxSize;
208 *patchListSize = patchListMaxSize;
209
210 return eStatus;
211 }
212
213 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::AddHcpPipeModeSelectCmd(
214 PMOS_COMMAND_BUFFER cmdBuffer,
215 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
216 {
217 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
218
219 MHW_FUNCTION_ENTER;
220
221 MHW_MI_CHK_NULL(params);
222
223 mhw_vdbox_hcp_g9_skl::HCP_PIPE_MODE_SELECT_CMD *cmd =
224 (mhw_vdbox_hcp_g9_skl::HCP_PIPE_MODE_SELECT_CMD*)cmdBuffer->pCmdPtr;
225
226 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceG9<mhw_vdbox_hcp_g9_skl>::AddHcpPipeModeSelectCmd(cmdBuffer, params));
227
228 m_cpInterface->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)cmd);
229
230 return eStatus;
231 }
232
233 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::AddHcpDecodeSurfaceStateCmd(
234 PMOS_COMMAND_BUFFER cmdBuffer,
235 PMHW_VDBOX_SURFACE_PARAMS params)
236 {
237 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
238
239 MHW_MI_CHK_NULL(params);
240
241 mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD *cmd =
242 (mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
243
244 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_skl>::AddHcpDecodeSurfaceStateCmd(cmdBuffer, params));
245
246 MHW_ASSERT(params->psSurface->Format == Format_NV12);
247
248 return eStatus;
249 }
250
251 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::AddHcpEncodeSurfaceStateCmd(
252 PMOS_COMMAND_BUFFER cmdBuffer,
253 PMHW_VDBOX_SURFACE_PARAMS params)
254 {
255 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
256
257 MHW_MI_CHK_NULL(params);
258
259 mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD *cmd =
260 (mhw_vdbox_hcp_g9_skl::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
261
262 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_skl>::AddHcpEncodeSurfaceStateCmd(cmdBuffer, params));
263
264 MHW_ASSERT(params->psSurface->Format == Format_NV12);
265
266 return eStatus;
267 }
268
269 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::AddHcpDecodeSliceStateCmd(
270 PMOS_COMMAND_BUFFER cmdBuffer,
271 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
272 {
273 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
274
275 MHW_FUNCTION_ENTER;
276
277 MHW_MI_CHK_NULL(hevcSliceState);
278 MHW_MI_CHK_NULL(hevcSliceState->pHevcPicParams);
279 MHW_MI_CHK_NULL(hevcSliceState->pHevcSliceParams);
280
281 auto hevcPicParams = hevcSliceState->pHevcPicParams;
282 auto hevcSliceParams = hevcSliceState->pHevcSliceParams;
283
284 mhw_vdbox_hcp_g9_skl::HCP_SLICE_STATE_CMD *cmd =
285 (mhw_vdbox_hcp_g9_skl::HCP_SLICE_STATE_CMD*)cmdBuffer->pCmdPtr;
286
287 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_skl>::AddHcpDecodeSliceStateCmd(cmdBuffer, hevcSliceState));
288
289 cmd->DW3.Sliceqp = hevcSliceParams->slice_qp_delta +
290 hevcPicParams->init_qp_minus26 + 26;
291
292 return eStatus;
293 }
294
295 MOS_STATUS MhwVdboxHcpInterfaceG9Skl::AddHcpVp9SegmentStateCmd(
296 PMOS_COMMAND_BUFFER cmdBuffer,
297 PMHW_BATCH_BUFFER batchBuffer,
298 PMHW_VDBOX_VP9_SEGMENT_STATE params)
299 {
300 return MOS_STATUS_SUCCESS;
301 }