Debian Codegraph @

media_driver/agnostic/gen9_kbl/hw/vdbox/mhw_vdbox_hcp_g9_kbl.cpp

raw
1 /*
2 * Copyright (c) 2017-2018, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vdbox_hcp_g9_kbl.cpp
24 //! \brief Defines functions for constructing Vdbox HCP commands on G9 KBL
25 //!
26
27 #include "mhw_vdbox_hcp_g9_kbl.h"
28 #include "mhw_mi_hwcmd_g9_X.h"
29 #include "mhw_vdbox_vdenc_hwcmd_g9_kbl.h"
30 #include "mos_os_cp_interface_specific.h"
31
32 void MhwVdboxHcpInterfaceG9Kbl::InitRowstoreUserFeatureSettings()
33 {
34 MhwVdboxHcpInterfaceG9::InitRowstoreUserFeatureSettings(m_osInterface->pOsContext);
35
36 if (m_rowstoreCachingSupported && m_decodeInUse)
37 {
38 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
39
40 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
41 #if (_DEBUG || _RELEASE_INTERNAL)
42 MOS_UserFeature_ReadValue_ID(
43 nullptr,
44 __MEDIA_USER_FEATURE_VALUE_VP9_HVDROWSTORECACHE_DISABLE_ID,
45 &userFeatureData,
46 m_osInterface->pOsContext);
47 #endif // _DEBUG || _RELEASE_INTERNAL
48 m_vp9HvdRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
49
50 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
51 #if (_DEBUG || _RELEASE_INTERNAL)
52 MOS_UserFeature_ReadValue_ID(
53 nullptr,
54 __MEDIA_USER_FEATURE_VALUE_VP9_DFROWSTORECACHE_DISABLE_ID,
55 &userFeatureData,
56 m_osInterface->pOsContext);
57 #endif // _DEBUG || _RELEASE_INTERNAL
58 m_vp9DfRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
59
60 }
61 }
62
63 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::GetHcpStateCommandSize(
64 uint32_t mode,
65 uint32_t *commandsSize,
66 uint32_t *patchListSize,
67 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
68 {
69 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
70
71 MHW_FUNCTION_ENTER;
72
73 uint32_t maxSize = 0;
74 uint32_t patchListMaxSize = 0;
75 uint32_t standard = CodecHal_GetStandardFromMode(mode);
76
77 if (standard == CODECHAL_HEVC)
78 {
79 maxSize =
80 mhw_vdbox_vdenc_g9_kbl::VD_PIPELINE_FLUSH_CMD::byteSize +
81 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
82 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_MODE_SELECT_CMD::byteSize +
83 mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD::byteSize +
84 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
85 mhw_vdbox_hcp_g9_kbl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize;
86
87 patchListMaxSize =
88 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
89 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
90 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) +
91 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
92 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD);
93
94 if (mode == CODECHAL_ENCODE_MODE_HEVC)
95 {
96 /* 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.
97 HCP_FQP_STATE_CMD may be issued up to 8 times: 4 scaling list per intra and inter. */
98 maxSize +=
99 20 * mhw_vdbox_hcp_g9_kbl::HCP_QM_STATE_CMD::byteSize +
100 8 * mhw_vdbox_hcp_g9_kbl::HCP_FQM_STATE_CMD::byteSize +
101 mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD::byteSize;
102
103 patchListMaxSize +=
104 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
105 8 * PATCH_LIST_COMMAND(HCP_FQM_STATE_CMD);
106 }
107 else
108 {
109 maxSize +=
110 20 * mhw_vdbox_hcp_g9_kbl::HCP_QM_STATE_CMD::byteSize +
111 mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD::byteSize +
112 mhw_vdbox_hcp_g9_kbl::HCP_TILE_STATE_CMD::byteSize;
113
114 patchListMaxSize +=
115 20 * PATCH_LIST_COMMAND(HCP_QM_STATE_CMD) +
116 PATCH_LIST_COMMAND(HCP_PIC_STATE_CMD) +
117 PATCH_LIST_COMMAND(HCP_TILE_STATE_CMD);
118 }
119 }
120 else if (standard == CODECHAL_VP9)
121 {
122 if (mode == CODECHAL_ENCODE_MODE_VP9)
123 {
124 maxSize =
125 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize * 2 +
126 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_MODE_SELECT_CMD::byteSize +
127 mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD::byteSize * 5 +
128 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
129 mhw_vdbox_hcp_g9_kbl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
130 mhw_vdbox_hcp_g9_kbl::HCP_VP9_SEGMENT_STATE_CMD::byteSize * 8 +
131 mhw_vdbox_hcp_g9_kbl::HCP_VP9_PIC_STATE_CMD::byteSize +
132 mhw_mi_g9_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize +
133 mhw_vdbox_hcp_g9_kbl::HCP_PAK_INSERT_OBJECT_CMD::byteSize +
134 mhw_mi_g9_X::MI_BATCH_BUFFER_START_CMD::byteSize * 2 +
135 mhw_vdbox_vdenc_g9_kbl::VD_PIPELINE_FLUSH_CMD::byteSize;
136
137 patchListMaxSize =
138 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2 +
139 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
140 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) * 5 +
141 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
142 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD) +
143 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
144 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
145 PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD) +
146 PATCH_LIST_COMMAND(HCP_PAK_INSERT_OBJECT_CMD) +
147 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD) * 2 +
148 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD);
149 }
150 else // VP9 Clear Decode
151 {
152 maxSize =
153 mhw_vdbox_vdenc_g9_kbl::VD_PIPELINE_FLUSH_CMD::byteSize +
154 mhw_mi_g9_X::MI_FLUSH_DW_CMD::byteSize +
155 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_MODE_SELECT_CMD::byteSize +
156 mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD::byteSize * 4 +
157 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
158 mhw_vdbox_hcp_g9_kbl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
159 mhw_vdbox_hcp_g9_kbl::HCP_VP9_SEGMENT_STATE_CMD::byteSize * 8 +
160 mhw_vdbox_hcp_g9_kbl::HCP_VP9_PIC_STATE_CMD::byteSize +
161 mhw_vdbox_hcp_g9_kbl::HCP_BSD_OBJECT_CMD::byteSize;
162
163 patchListMaxSize =
164 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
165 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
166 PATCH_LIST_COMMAND(HCP_PIPE_MODE_SELECT_CMD) +
167 PATCH_LIST_COMMAND(HCP_SURFACE_STATE_CMD) * 4 +
168 PATCH_LIST_COMMAND(HCP_PIPE_BUF_ADDR_STATE_CMD) +
169 PATCH_LIST_COMMAND(HCP_IND_OBJ_BASE_ADDR_STATE_CMD) +
170 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
171 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
172 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
173 }
174 }
175 else
176 {
177 MHW_ASSERTMESSAGE("Unsupported standard.");
178 eStatus = MOS_STATUS_UNKNOWN;
179 }
180
181 *commandsSize = maxSize;
182 *patchListSize = patchListMaxSize;
183
184 return eStatus;
185 }
186
187 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::GetHcpPrimitiveCommandSize(
188 uint32_t mode,
189 uint32_t *commandsSize,
190 uint32_t *patchListSize,
191 bool modeSpecific)
192 {
193 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
194
195 MHW_FUNCTION_ENTER;
196
197 uint32_t standard = CodecHal_GetStandardFromMode(mode);
198 uint32_t maxSize = 0;
199 uint32_t patchListMaxSize = 0;
200
201 if (standard == CODECHAL_HEVC)
202 {
203 if (mode == CODECHAL_ENCODE_MODE_HEVC)
204 {
205 maxSize =
206 2 * mhw_vdbox_hcp_g9_kbl::HCP_REF_IDX_STATE_CMD::byteSize +
207 2 * mhw_vdbox_hcp_g9_kbl::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
208 mhw_vdbox_hcp_g9_kbl::HCP_SLICE_STATE_CMD::byteSize +
209 mhw_vdbox_hcp_g9_kbl::HCP_PAK_INSERT_OBJECT_CMD::byteSize +
210 mhw_mi_g9_X::MI_BATCH_BUFFER_START_CMD::byteSize;
211
212 patchListMaxSize =
213 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
214 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
215 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
216 PATCH_LIST_COMMAND(HCP_PAK_INSERT_OBJECT_CMD) +
217 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
218
219 }
220 else
221 {
222 maxSize =
223 2 * mhw_vdbox_hcp_g9_kbl::HCP_REF_IDX_STATE_CMD::byteSize +
224 2 * mhw_vdbox_hcp_g9_kbl::HCP_WEIGHTOFFSET_STATE_CMD::byteSize +
225 mhw_vdbox_hcp_g9_kbl::HCP_SLICE_STATE_CMD::byteSize +
226 mhw_vdbox_hcp_g9_kbl::HCP_BSD_OBJECT_CMD::byteSize +
227 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
228
229 patchListMaxSize =
230 2 * PATCH_LIST_COMMAND(HCP_REF_IDX_STATE_CMD) +
231 2 * PATCH_LIST_COMMAND(HCP_WEIGHTOFFSET_STATE_CMD) +
232 PATCH_LIST_COMMAND(HCP_SLICE_STATE_CMD) +
233 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
234 }
235 }
236 else if (standard == CODECHAL_VP9) // VP9 Clear decode does not require primitive level commands. VP9 DRM does.
237 {
238 if (modeSpecific) // VP9 DRM
239 {
240 maxSize +=
241 mhw_vdbox_hcp_g9_kbl::HCP_VP9_SEGMENT_STATE_CMD::byteSize * 8 +
242 mhw_vdbox_hcp_g9_kbl::HCP_VP9_PIC_STATE_CMD::byteSize +
243 mhw_vdbox_hcp_g9_kbl::HCP_BSD_OBJECT_CMD::byteSize +
244 mhw_mi_g9_X::MI_BATCH_BUFFER_END_CMD::byteSize;
245
246 patchListMaxSize =
247 PATCH_LIST_COMMAND(HCP_VP9_SEGMENT_STATE_CMD) * 8 +
248 PATCH_LIST_COMMAND(HCP_VP9_PIC_STATE_CMD) +
249 PATCH_LIST_COMMAND(HCP_BSD_OBJECT_CMD);
250 }
251 }
252 else
253 {
254 MHW_ASSERTMESSAGE("Unsupported standard.");
255 eStatus = MOS_STATUS_UNKNOWN;
256 }
257
258 *commandsSize = maxSize;
259 *patchListSize = patchListMaxSize;
260
261 return eStatus;
262 }
263
264 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpPipeModeSelectCmd(
265 PMOS_COMMAND_BUFFER cmdBuffer,
266 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
267 {
268 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
269
270 MHW_FUNCTION_ENTER;
271
272 MHW_MI_CHK_NULL(params);
273
274 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_MODE_SELECT_CMD *cmd =
275 (mhw_vdbox_hcp_g9_kbl::HCP_PIPE_MODE_SELECT_CMD*)cmdBuffer->pCmdPtr;
276
277 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceG9<mhw_vdbox_hcp_g9_kbl>::AddHcpPipeModeSelectCmd(cmdBuffer, params));
278
279 m_cpInterface->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)cmd);
280
281 // Without having the HprVp9ModeSwitchEco disabled, the gen9 devices
282 // cause gpu to hang while decoding tiled 4k vp9 streams
283 cmd->DW4.HprVp9ModeSwitchEcoDisable = 1;
284
285 cmd->DW1.PakPipelineStreamoutEnable = params->bStreamOutEnabled;
286 cmd->DW1.AdvancedRateControlEnable = params->bAdvancedRateControlEnable;
287
288 return eStatus;
289 }
290
291 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpDecodeSurfaceStateCmd(
292 PMOS_COMMAND_BUFFER cmdBuffer,
293 PMHW_VDBOX_SURFACE_PARAMS params)
294 {
295 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
296
297 MHW_MI_CHK_NULL(params);
298
299 mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD *cmd =
300 (mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
301
302 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_kbl>::AddHcpDecodeSurfaceStateCmd(cmdBuffer, params));
303
304 if (params->ucBitDepthLumaMinus8 == 0 && params->ucBitDepthChromaMinus8 == 0)
305 {
306 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_PLANAR_420_8;
307 }
308 else
309 {
310 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_P010;
311 }
312
313 return eStatus;
314 }
315
316 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpEncodeSurfaceStateCmd(
317 PMOS_COMMAND_BUFFER cmdBuffer,
318 PMHW_VDBOX_SURFACE_PARAMS params)
319 {
320 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
321
322 MHW_MI_CHK_NULL(params);
323
324 mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD *cmd =
325 (mhw_vdbox_hcp_g9_kbl::HCP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
326
327 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_kbl>::AddHcpDecodeSurfaceStateCmd(cmdBuffer, params));
328
329 cmd->DW2.YOffsetForUCbInPixel = params->psSurface->UPlaneOffset.iYOffset;
330 if (params->ucBitDepthLumaMinus8 == 0 && params->ucBitDepthChromaMinus8 == 0)
331 {
332 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_PLANAR_420_8;
333 }
334 else
335 {
336 cmd->DW2.SurfaceFormat = HCP_SURFACE_FORMAT_P010;
337 }
338
339 return eStatus;
340 }
341
342 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpPipeBufAddrCmd(
343 PMOS_COMMAND_BUFFER cmdBuffer,
344 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
345 {
346 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
347
348 MHW_FUNCTION_ENTER;
349
350 MHW_MI_CHK_NULL(m_osInterface);
351 MHW_MI_CHK_NULL(cmdBuffer);
352 MHW_MI_CHK_NULL(params);
353
354 MHW_RESOURCE_PARAMS resourceParams;
355 MOS_SURFACE details;
356 mhw_vdbox_hcp_g9_kbl::HCP_PIPE_BUF_ADDR_STATE_CMD cmd;
357
358 #if (_DEBUG || _RELEASE_INTERNAL)
359 MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
360 UserFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED_ID;
361 if (m_hevcDatRowStoreCache.bEnabled ||
362 m_hevcDfRowStoreCache.bEnabled ||
363 m_hevcSaoRowStoreCache.bEnabled ||
364 m_vp9HvdRowStoreCache.bEnabled ||
365 m_vp9DfRowStoreCache.bEnabled)
366 {
367 UserFeatureWriteData.Value.i32Data = 1;
368 }
369 MOS_UserFeature_WriteValues_ID(nullptr, &UserFeatureWriteData, 1, m_osInterface->pOsContext);
370 #endif
371
372 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
373 resourceParams.dwLsbNum = MHW_VDBOX_HCP_DECODED_BUFFER_SHIFT;
374 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
375
376 // Decoded Picture
377 // Caching policy change if any of below modes are true
378 // Note for future dev: probably a good idea to add a macro for the below check
379 if (m_osInterface->osCpInterface->IsHMEnabled() ||
380 m_osInterface->osCpInterface->IsIDMEnabled() ||
381 m_osInterface->osCpInterface->IsSMEnabled())
382 {
383 cmd.DecodedPictureMemoryAddressAttributes.DW0.Value |=
384 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC_PARTIALENCSURFACE].Value;
385 }
386 else
387 {
388 cmd.DecodedPictureMemoryAddressAttributes.DW0.Value |=
389 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
390 }
391
392 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable =
393 (params->PreDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ? MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
394 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionMode =
395 (params->PreDeblockSurfMmcState == MOS_MEMCOMP_HORIZONTAL) ? MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
396
397 cmd.DecodedPictureMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType);
398
399 // For HEVC 8bit/10bit mixed case, register App's RenderTarget for specific use case
400 if (params->presP010RTSurface != nullptr)
401 {
402 resourceParams.presResource = &(params->presP010RTSurface->OsResource);
403 resourceParams.dwOffset = params->presP010RTSurface->dwOffset;
404 resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value);
405 resourceParams.dwLocationInCmd = 1;
406 resourceParams.bIsWritable = true;
407
408 if (m_osInterface->bAllowExtraPatchToSameLoc)
409 {
410 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
411 m_osInterface,
412 cmdBuffer,
413 &resourceParams));
414 }
415 else //if not allowed to patch another OsResource to same location in cmd, just register resource here
416 {
417 MHW_MI_CHK_STATUS(m_osInterface->pfnRegisterResource(
418 m_osInterface,
419 resourceParams.presResource,
420 resourceParams.bIsWritable,
421 resourceParams.bIsWritable));
422 }
423 }
424
425 resourceParams.presResource = &(params->psPreDeblockSurface->OsResource);
426 resourceParams.dwOffset = params->psPreDeblockSurface->dwOffset;
427 resourceParams.pdwCmd = (cmd.DecodedPicture.DW0_1.Value);
428 resourceParams.dwLocationInCmd = 1;
429 resourceParams.bIsWritable = true;
430
431 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
432 m_osInterface,
433 cmdBuffer,
434 &resourceParams));
435
436 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
437 MHW_MI_CHK_STATUS(m_osInterface->pfnSetMemoryCompressionMode(m_osInterface, resourceParams.presResource, params->PreDeblockSurfMmcState));
438
439 // Deblocking Filter Line Buffer
440 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.Value |=
441 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
442
443 cmd.DeblockingFilterLineBuffer.DW0_1.Graphicsaddress476 = 0;
444 if (m_hevcDfRowStoreCache.bEnabled)
445 {
446 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
447 cmd.DeblockingFilterLineBuffer.DW0_1.Graphicsaddress476 = m_hevcDfRowStoreCache.dwAddress;
448 }
449 else if (m_vp9DfRowStoreCache.bEnabled)
450 {
451 cmd.DeblockingFilterLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockingFilterLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
452 cmd.DeblockingFilterLineBuffer.DW0_1.Graphicsaddress476 = m_vp9DfRowStoreCache.dwAddress;
453 }
454 else if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
455 {
456 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
457 resourceParams.dwOffset = 0;
458 resourceParams.pdwCmd = (cmd.DeblockingFilterLineBuffer.DW0_1.Value);
459 resourceParams.dwLocationInCmd = 4;
460 resourceParams.bIsWritable = true;
461
462 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
463 m_osInterface,
464 cmdBuffer,
465 &resourceParams));
466 }
467
468 // Deblocking Filter Tile Line Buffer
469 cmd.DeblockingFilterTileLineBufferMemoryAddressAttributes.DW0.Value |=
470 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
471
472 if (params->presDeblockingFilterTileRowStoreScratchBuffer != nullptr)
473 {
474 resourceParams.presResource = params->presDeblockingFilterTileRowStoreScratchBuffer;
475 resourceParams.dwOffset = 0;
476 resourceParams.pdwCmd = (cmd.DeblockingFilterTileLineBuffer.DW0_1.Value);
477 resourceParams.dwLocationInCmd = 7;
478 resourceParams.bIsWritable = true;
479
480 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
481 m_osInterface,
482 cmdBuffer,
483 &resourceParams));
484 }
485
486 // Deblocking Filter Tile Column Buffer
487 cmd.DeblockingFilterTileColumnBufferMemoryAddressAttributes.DW0.Value |=
488 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
489
490 if (params->presDeblockingFilterColumnRowStoreScratchBuffer != nullptr)
491 {
492 resourceParams.presResource = params->presDeblockingFilterColumnRowStoreScratchBuffer;
493 resourceParams.dwOffset = 0;
494 resourceParams.pdwCmd = (cmd.DeblockingFilterTileColumnBuffer.DW0_1.Value);
495 resourceParams.dwLocationInCmd = 10;
496 resourceParams.bIsWritable = true;
497
498 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
499 m_osInterface,
500 cmdBuffer,
501 &resourceParams));
502 }
503
504 // Metadata Line Buffer
505 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.Value |=
506 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
507
508 if (m_hevcDatRowStoreCache.bEnabled)
509 {
510 cmd.MetadataLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.MetadataLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
511 cmd.MetadataLineBuffer.DW0_1.Graphicsaddress476 = m_hevcDatRowStoreCache.dwAddress;
512 }
513 else if (params->presMetadataLineBuffer != nullptr)
514 {
515 resourceParams.presResource = params->presMetadataLineBuffer;
516 resourceParams.dwOffset = 0;
517 resourceParams.pdwCmd = (cmd.MetadataLineBuffer.DW0_1.Value);
518 resourceParams.dwLocationInCmd = 13;
519 resourceParams.bIsWritable = true;
520
521 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
522 m_osInterface,
523 cmdBuffer,
524 &resourceParams));
525 }
526
527 // Metadata Tile Line Buffer
528 cmd.MetadataTileLineBufferMemoryAddressAttributes.DW0.Value |=
529 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
530
531 if (params->presMetadataTileLineBuffer != nullptr)
532 {
533 resourceParams.presResource = params->presMetadataTileLineBuffer;
534 resourceParams.dwOffset = 0;
535 resourceParams.pdwCmd = (cmd.MetadataTileLineBuffer.DW0_1.Value);
536 resourceParams.dwLocationInCmd = 16;
537 resourceParams.bIsWritable = true;
538
539 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
540 m_osInterface,
541 cmdBuffer,
542 &resourceParams));
543 }
544
545 // Metadata Tile Column Buffer
546 cmd.MetadataTileColumnBufferMemoryAddressAttributes.DW0.Value |=
547 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MD_CODEC].Value;
548
549 if (params->presMetadataTileColumnBuffer != nullptr)
550 {
551 resourceParams.presResource = params->presMetadataTileColumnBuffer;
552 resourceParams.dwOffset = 0;
553 resourceParams.pdwCmd = (cmd.MetadataTileColumnBuffer.DW0_1.Value);
554 resourceParams.dwLocationInCmd = 19;
555 resourceParams.bIsWritable = true;
556
557 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
558 m_osInterface,
559 cmdBuffer,
560 &resourceParams));
561 }
562
563 // SAO Line Buffer
564 cmd.SaoLineBufferMemoryAddressAttributes.DW0.Value |=
565 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
566
567 if (m_hevcSaoRowStoreCache.bEnabled)
568 {
569 cmd.SaoLineBufferMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SaoLineBufferMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
570 cmd.SaoLineBuffer.DW0_1.Graphicsaddress476 = m_hevcSaoRowStoreCache.dwAddress;
571 }
572 else if (params->presSaoLineBuffer != nullptr)
573 {
574 resourceParams.presResource = params->presSaoLineBuffer;
575 resourceParams.dwOffset = 0;
576 resourceParams.pdwCmd = (cmd.SaoLineBuffer.DW0_1.Value);
577 resourceParams.dwLocationInCmd = 22;
578 resourceParams.bIsWritable = true;
579
580 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
581 m_osInterface,
582 cmdBuffer,
583 &resourceParams));
584 }
585
586 // SAO Tile Line Buffer
587 cmd.SaoTileLineBufferMemoryAddressAttributes.DW0.Value |=
588 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
589
590 if (params->presSaoTileLineBuffer != nullptr)
591 {
592 resourceParams.presResource = params->presSaoTileLineBuffer;
593 resourceParams.dwOffset = 0;
594 resourceParams.pdwCmd = (cmd.SaoTileLineBuffer.DW0_1.Value);
595 resourceParams.dwLocationInCmd = 25;
596 resourceParams.bIsWritable = true;
597
598 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
599 m_osInterface,
600 cmdBuffer,
601 &resourceParams));
602 }
603
604 // SAO Tile Column Buffer
605 cmd.SaoTileColumnBufferMemoryAddressAttributes.DW0.Value |=
606 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_SAO_CODEC].Value;
607
608 if (params->presSaoTileColumnBuffer != nullptr)
609 {
610 resourceParams.presResource = params->presSaoTileColumnBuffer;
611 resourceParams.dwOffset = 0;
612 resourceParams.pdwCmd = (cmd.SaoTileColumnBuffer.DW0_1.Value);
613 resourceParams.dwLocationInCmd = 28;
614 resourceParams.bIsWritable = true;
615
616 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
617 m_osInterface,
618 cmdBuffer,
619 &resourceParams));
620 }
621
622 // Current Motion Vector Temporal Buffer
623 cmd.CurrentMotionVectorTemporalBufferMemoryAddressAttributes.DW0.Value |=
624 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MV_CODEC].Value;
625
626 if (params->presCurMvTempBuffer != nullptr)
627 {
628 resourceParams.presResource = params->presCurMvTempBuffer;
629 resourceParams.dwOffset = 0;
630 resourceParams.pdwCmd = (cmd.CurrentMotionVectorTemporalBuffer.DW0_1.Value);
631 resourceParams.dwLocationInCmd = 31;
632 resourceParams.bIsWritable = true;
633
634 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
635 m_osInterface,
636 cmdBuffer,
637 &resourceParams));
638 }
639
640 // Reference Picture Buffer
641 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.Value |=
642 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
643
644 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
645 bool firstRefPic = true;
646
647 // NOTE: for both HEVC and VP9, set all the 8 ref pic addresses in HCP_PIPE_BUF_ADDR_STATE command to valid addresses for error concealment purpose
648 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
649 {
650 if (params->presReferences[i] != nullptr)
651 {
652 MOS_ZeroMemory(&details, sizeof(details));
653 details.Format = Format_Invalid;
654 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, params->presReferences[i], &details));
655
656 if (firstRefPic)
657 {
658 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, params->presReferences[i], &mmcMode));
659
660 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
661 firstRefPic = false;
662 }
663
664 resourceParams.presResource = params->presReferences[i];
665 resourceParams.pdwCmd = (cmd.ReferencePictureBaseAddressRefaddr07[i].DW0_1.Value);
666 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
667 resourceParams.dwLocationInCmd = (i * 2) + 37; // * 2 to account for QW rather than DW
668 resourceParams.bIsWritable = false;
669
670 resourceParams.dwSharedMocsOffset = 53 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW53
671
672 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
673 m_osInterface,
674 cmdBuffer,
675 &resourceParams));
676 }
677 }
678
679 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable =
680 (mmcMode != MOS_MEMCOMP_DISABLED) ? MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
681 cmd.ReferencePictureBaseAddressMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionMode =
682 (mmcMode == MOS_MEMCOMP_HORIZONTAL) ? MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
683
684 // Reset dwSharedMocsOffset
685 resourceParams.dwSharedMocsOffset = MOS_MFX_PIPE_BUF_ADDR;
686
687 // Original Uncompressed Picture Source, Encoder only
688 if (params->psRawSurface != nullptr)
689 {
690 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(m_osInterface, &params->psRawSurface->OsResource, &mmcMode));
691
692 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.Value |=
693 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
694 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = (mmcMode != MOS_MEMCOMP_DISABLED) ?
695 MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
696 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionMode = (mmcMode == MOS_MEMCOMP_HORIZONTAL) ?
697 MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
698
699 cmd.OriginalUncompressedPictureSourceMemoryAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
700
701 resourceParams.presResource = &params->psRawSurface->OsResource;
702 resourceParams.dwOffset = params->psRawSurface->dwOffset;
703 resourceParams.pdwCmd = (cmd.OriginalUncompressedPictureSource.DW0_1.Value);
704 resourceParams.dwLocationInCmd = 54;
705 resourceParams.bIsWritable = false;
706
707 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
708 m_osInterface,
709 cmdBuffer,
710 &resourceParams));
711 }
712
713 // StreamOut Data Destination, Decoder only
714 if (params->presStreamOutBuffer != nullptr)
715 {
716 cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.Value |=
717 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
718 cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionEnable =
719 (params->StreamOutBufMmcState != MOS_MEMCOMP_DISABLED) ? MHW_MEDIA_MEMCOMP_ENABLED : MHW_MEDIA_MEMCOMP_DISABLED;
720 cmd.StreamoutDataDestinationMemoryAddressAttributes.DW0.BaseAddressMemoryCompressionMode =
721 (params->StreamOutBufMmcState == MOS_MEMCOMP_HORIZONTAL) ? MHW_MEDIA_MEMCOMP_MODE_HORIZONTAL : MHW_MEDIA_MEMCOMP_MODE_VERTICAL;
722
723 resourceParams.presResource = params->presStreamOutBuffer;
724 resourceParams.dwOffset = 0;
725 resourceParams.pdwCmd = (cmd.StreamoutDataDestination.DW0_1.Value);
726 resourceParams.dwLocationInCmd = 57;
727 resourceParams.bIsWritable = true;
728
729 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
730 m_osInterface,
731 cmdBuffer,
732 &resourceParams));
733 }
734
735 // Decoded Picture Status / Error Buffer Base Address
736 if (params->presLcuBaseAddressBuffer != nullptr)
737 {
738 cmd.DecodedPictureStatusErrorBufferBaseAddressMemoryAddressAttributes.DW0.Value |=
739 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_STATUS_ERROR_CODEC].Value;
740
741 resourceParams.presResource = params->presLcuBaseAddressBuffer;
742 resourceParams.dwOffset = 0;
743 resourceParams.pdwCmd = (cmd.DecodedPictureStatusErrorBufferBaseAddressOrEncodedSliceSizeStreamoutBaseAddress.DW0_1.Value);
744 resourceParams.dwLocationInCmd = 60;
745 resourceParams.bIsWritable = true;
746
747 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
748 m_osInterface,
749 cmdBuffer,
750 &resourceParams));
751 }
752
753 // LCU ILDB StreamOut Buffer
754 if (params->presLcuILDBStreamOutBuffer != nullptr)
755 {
756 cmd.LcuIldbStreamoutBufferMemoryAddressAttributes.DW0.Value |=
757 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_LCU_ILDB_STREAMOUT_CODEC].Value;
758
759 resourceParams.presResource = params->presLcuILDBStreamOutBuffer;
760 resourceParams.dwOffset = 0;
761 resourceParams.pdwCmd = (cmd.LcuIldbStreamoutBuffer.DW0_1.Value);
762 resourceParams.dwLocationInCmd = 63;
763 resourceParams.bIsWritable = true;
764
765 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
766 m_osInterface,
767 cmdBuffer,
768 &resourceParams));
769 }
770
771 // Collocated Motion vector Temporal Buffer
772 cmd.CollocatedMotionVectorTemporalBuffer07MemoryAddressAttributes.DW0.Value |=
773 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HCP_MV_CODEC].Value;
774
775 for (uint32_t i = 0; i < CODECHAL_MAX_CUR_NUM_REF_FRAME_HEVC; i++)
776 {
777 if (params->presColMvTempBuffer[i] != nullptr)
778 {
779 resourceParams.presResource = params->presColMvTempBuffer[i];
780 resourceParams.dwOffset = 0;
781 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBuffer07[i].DW0_1.Value);
782 resourceParams.dwLocationInCmd = (i * 2) + 66;
783 resourceParams.bIsWritable = false;
784
785 resourceParams.dwSharedMocsOffset = 82 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW82
786
787 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
788 m_osInterface,
789 cmdBuffer,
790 &resourceParams));
791 }
792 }
793
794 // Reset dwSharedMocsOffset
795 resourceParams.dwSharedMocsOffset = MOS_MFX_PIPE_BUF_ADDR;
796
797 // VP9 Probability Buffer
798 if (params->presVp9ProbBuffer != nullptr)
799 {
800 cmd.Vp9ProbabilityBufferReadWriteMemoryAddressAttributes.DW0.Value |=
801 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_PROBABILITY_BUFFER_CODEC].Value;
802
803 resourceParams.presResource = params->presVp9ProbBuffer;
804 resourceParams.dwOffset = 0;
805 resourceParams.pdwCmd = (cmd.Vp9ProbabilityBufferReadWrite.DW0_1.Value);
806 resourceParams.dwLocationInCmd = 83;
807 resourceParams.bIsWritable = true;
808
809 resourceParams.dwSharedMocsOffset = 85 - resourceParams.dwLocationInCmd;
810
811 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
812 m_osInterface,
813 cmdBuffer,
814 &resourceParams));
815 }
816
817 // VP9 Segment Id Buffer
818 if (params->presVp9SegmentIdBuffer != nullptr)
819 {
820 cmd.Vp9SegmentIdBufferReadWriteMemoryAddressAttributes.DW0.Value |=
821 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_SEGMENT_ID_BUFFER_CODEC].Value;
822
823 resourceParams.presResource = params->presVp9SegmentIdBuffer;
824 resourceParams.dwOffset = 0;
825 resourceParams.pdwCmd = (cmd.DW86_87.Value);
826 resourceParams.dwLocationInCmd = 86;
827 resourceParams.bIsWritable = true;
828
829 resourceParams.dwSharedMocsOffset = 88 - resourceParams.dwLocationInCmd;
830
831 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
832 m_osInterface,
833 cmdBuffer,
834 &resourceParams));
835 }
836
837 // HVD Line Row Store Buffer
838 if (m_vp9HvdRowStoreCache.bEnabled)
839 {
840 cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
841 cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Graphicsaddress476 = m_vp9HvdRowStoreCache.dwAddress;
842 }
843 else if (params->presHvdLineRowStoreBuffer != nullptr)
844 {
845 cmd.Vp9HvdLineRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value |=
846 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC].Value;
847
848 resourceParams.presResource = params->presHvdLineRowStoreBuffer;
849 resourceParams.dwOffset = 0;
850 resourceParams.pdwCmd = (cmd.Vp9HvdLineRowstoreBufferReadWrite.DW0_1.Value);
851 resourceParams.dwLocationInCmd = 89;
852 resourceParams.bIsWritable = true;
853
854 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
855 m_osInterface,
856 cmdBuffer,
857 &resourceParams));
858 }
859
860 // HVD Tile Row Store Buffer
861 if (params->presHvdTileRowStoreBuffer != nullptr)
862 {
863 cmd.Vp9HvdTileRowstoreBufferReadWriteMemoryAddressAttributes.DW0.Value |=
864 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VP9_HVD_ROWSTORE_BUFFER_CODEC].Value;
865
866 resourceParams.presResource = params->presHvdTileRowStoreBuffer;
867 resourceParams.dwOffset = 0;
868 resourceParams.pdwCmd = (cmd.Vp9HvdTileRowstoreBufferReadWrite.DW0_1.Value);
869 resourceParams.dwLocationInCmd = 92;
870 resourceParams.bIsWritable = true;
871
872 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
873 m_osInterface,
874 cmdBuffer,
875 &resourceParams));
876 }
877
878 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
879
880 return eStatus;
881 }
882
883 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpIndObjBaseAddrCmd(
884 PMOS_COMMAND_BUFFER cmdBuffer,
885 PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params)
886 {
887 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;;
888
889 MHW_FUNCTION_ENTER;
890
891 MHW_MI_CHK_NULL(m_osInterface);
892 MHW_MI_CHK_NULL(params);
893
894 MHW_RESOURCE_PARAMS resourceParams;
895 mhw_vdbox_hcp_g9_kbl::HCP_IND_OBJ_BASE_ADDR_STATE_CMD cmd;
896
897 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
898 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
899 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
900
901 // mode specific settings
902 if (CodecHalIsDecodeModeVLD(params->Mode))
903 {
904 MHW_MI_CHK_NULL(params->presDataBuffer);
905
906 cmd.HcpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value |=
907 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Value;
908
909 resourceParams.presResource = params->presDataBuffer;
910 resourceParams.dwOffset = params->dwDataOffset;
911 resourceParams.pdwCmd = (cmd.HcpIndirectBitstreamObjectBaseAddress.DW0_1.Value);
912 resourceParams.dwLocationInCmd = 1;
913 resourceParams.dwSize = params->dwDataSize;
914 resourceParams.bIsWritable = false;
915
916 // upper bound of the allocated resource will be set at 3 DW apart from address location
917 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
918
919 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
920 m_osInterface,
921 cmdBuffer,
922 &resourceParams));
923
924 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
925 }
926
927 // following is for encoder
928 if (!m_decodeInUse)
929 {
930 if (params->presMvObjectBuffer)
931 {
932 cmd.HcpIndirectCuObjectObjectMemoryAddressAttributes.DW0.Value |=
933 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC].Value;
934
935 resourceParams.presResource = params->presMvObjectBuffer;
936 resourceParams.dwOffset = params->dwMvObjectOffset;
937 resourceParams.pdwCmd = (cmd.DW6_7.Value);
938 resourceParams.dwLocationInCmd = 6;
939 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwMvObjectSize, 0x1000);
940 resourceParams.bIsWritable = false;
941
942 // no upper bound for indirect CU object
943 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
944
945 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
946 m_osInterface,
947 cmdBuffer,
948 &resourceParams));
949 }
950
951 if (params->presPakBaseObjectBuffer)
952 {
953 cmd.HcpPakBseObjectAddressMemoryAddressAttributes.DW0.Value |=
954 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
955
956 resourceParams.presResource = params->presPakBaseObjectBuffer;
957 resourceParams.dwOffset = 0;
958 resourceParams.pdwCmd = (cmd.DW9_10.Value);
959 resourceParams.dwLocationInCmd = 9;
960 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwPakBaseObjectSize, 0x1000);
961 resourceParams.bIsWritable = true;
962
963 // upper bound of the allocated resource will be set at 3 DW apart from address location
964 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
965
966 MHW_MI_CHK_STATUS(pfnAddResourceToCmd(
967 m_osInterface,
968 cmdBuffer,
969 &resourceParams));
970 }
971 }
972
973 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
974
975 return eStatus;
976 }
977
978 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpDecodePicStateCmd(
979 PMOS_COMMAND_BUFFER cmdBuffer,
980 PMHW_VDBOX_HEVC_PIC_STATE params)
981 {
982 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
983
984 MHW_FUNCTION_ENTER;
985
986 MHW_MI_CHK_NULL(params);
987 MHW_MI_CHK_NULL(params->pHevcPicParams);
988
989 mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD *cmd =
990 (mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD*)cmdBuffer->pCmdPtr;
991
992 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_kbl>::AddHcpDecodePicStateCmd(cmdBuffer, params));
993
994 auto hevcPicParams = params->pHevcPicParams;
995
996 cmd->DW5.BitDepthChromaMinus8 = hevcPicParams->bit_depth_chroma_minus8;
997 cmd->DW5.BitDepthLumaMinus8 = hevcPicParams->bit_depth_luma_minus8;
998
999 return eStatus;
1000 }
1001
1002 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpEncodePicStateCmd(
1003 PMOS_COMMAND_BUFFER cmdBuffer,
1004 PMHW_VDBOX_HEVC_PIC_STATE params)
1005 {
1006 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1007
1008 MHW_FUNCTION_ENTER;
1009
1010 MHW_MI_CHK_NULL(m_osInterface);
1011 MHW_MI_CHK_NULL(params);
1012 MHW_MI_CHK_NULL(params->pHevcEncSeqParams);
1013 MHW_MI_CHK_NULL(params->pHevcEncPicParams);
1014
1015 mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD cmd;
1016
1017 auto hevcSeqParams = params->pHevcEncSeqParams;
1018 auto hevcPicParams = params->pHevcEncPicParams;
1019
1020 cmd.DW1.Framewidthinmincbminus1 = hevcSeqParams->wFrameWidthInMinCbMinus1;
1021
1022 /* These two bits should reflect the same value to assigning together across DWORDs should reflect same value*/
1023 cmd.DW1.PakTransformSkipEnable =
1024 cmd.DW4.TransformSkipEnabledFlag = hevcPicParams->transform_skip_enabled_flag;
1025
1026
1027 cmd.DW1.Frameheightinmincbminus1 = hevcSeqParams->wFrameHeightInMinCbMinus1;
1028
1029 cmd.DW2.Mincusize = hevcSeqParams->log2_min_coding_block_size_minus3;
1030 cmd.DW2.CtbsizeLcusize = hevcSeqParams->log2_max_coding_block_size_minus3;
1031 cmd.DW2.Maxtusize = hevcSeqParams->log2_max_transform_block_size_minus2;
1032 cmd.DW2.Mintusize = hevcSeqParams->log2_min_transform_block_size_minus2;
1033 cmd.DW2.Minpcmsize = hevcSeqParams->log2_min_PCM_cb_size_minus3;
1034 cmd.DW2.Maxpcmsize = hevcSeqParams->log2_max_PCM_cb_size_minus3;
1035
1036 cmd.DW3.Colpicisi = 0;
1037 cmd.DW3.Curpicisi = 0;
1038
1039 cmd.DW4.SampleAdaptiveOffsetEnabledFlag = params->bSAOEnable; // HW restriction, does not support SAO filtering for LCU size 16x16
1040 cmd.DW4.PcmEnabledFlag = hevcSeqParams->pcm_enabled_flag;
1041 cmd.DW4.CuQpDeltaEnabledFlag = hevcPicParams->cu_qp_delta_enabled_flag;
1042 cmd.DW4.DiffCuQpDeltaDepthOrNamedAsMaxDqpDepth = hevcPicParams->diff_cu_qp_delta_depth;
1043 cmd.DW4.PcmLoopFilterDisableFlag = hevcSeqParams->pcm_loop_filter_disable_flag;
1044 cmd.DW4.ConstrainedIntraPredFlag = 0;
1045 cmd.DW4.Log2ParallelMergeLevelMinus2 = 0;
1046 cmd.DW4.SignDataHidingFlag = 0; // currently not supported in encoder
1047 cmd.DW4.EntropyCodingSyncEnabledFlag = 0; // not supported as per Dimas notes. PAK restriction
1048 cmd.DW4.TilesEnabledFlag = 0; // not supported in encoder
1049 cmd.DW4.WeightedPredFlag = hevcPicParams->weighted_pred_flag;
1050 cmd.DW4.WeightedBipredFlag = hevcPicParams->weighted_bipred_flag;
1051 cmd.DW4.Fieldpic = 0;
1052 cmd.DW4.Bottomfield = 0;
1053 cmd.DW4.AmpEnabledFlag = hevcSeqParams->amp_enabled_flag;
1054 cmd.DW4.TransquantBypassEnableFlag = hevcPicParams->transquant_bypass_enabled_flag;
1055 cmd.DW4.StrongIntraSmoothingEnableFlag = hevcSeqParams->strong_intra_smoothing_enable_flag;
1056 cmd.DW4.CuPacketStructure = 1 ; // 0 output from HW VME, 1/2 CL per CU, 1 NON-HwVME, Ext interface , 1 CL per CU
1057
1058 cmd.DW5.PicCbQpOffset = hevcPicParams->pps_cb_qp_offset & 0x1f;
1059 cmd.DW5.PicCrQpOffset = hevcPicParams->pps_cr_qp_offset & 0x1f;
1060 cmd.DW5.MaxTransformHierarchyDepthIntraOrNamedAsTuMaxDepthIntra = hevcSeqParams->max_transform_hierarchy_depth_intra;
1061 cmd.DW5.MaxTransformHierarchyDepthInterOrNamedAsTuMaxDepthInter = hevcSeqParams->max_transform_hierarchy_depth_inter;
1062 cmd.DW5.PcmSampleBitDepthChromaMinus1 = hevcSeqParams->pcm_sample_bit_depth_chroma_minus1;
1063 cmd.DW5.PcmSampleBitDepthLumaMinus1 = hevcSeqParams->pcm_sample_bit_depth_luma_minus1;
1064 cmd.DW5.BitDepthChromaMinus8 = hevcSeqParams->bit_depth_chroma_minus8;
1065 cmd.DW5.BitDepthLumaMinus8 = hevcSeqParams->bit_depth_luma_minus8;
1066
1067 cmd.DW6.LcuMaxBitsizeAllowed = hevcPicParams->LcuMaxBitsizeAllowed;
1068 cmd.DW6.Nonfirstpassflag = params->bNotFirstPass;
1069 cmd.DW6.LcumaxbitstatusenLcumaxsizereportmask = 0;
1070 cmd.DW6.FrameszoverstatusenFramebitratemaxreportmask = 0;
1071 cmd.DW6.FrameszunderstatusenFramebitrateminreportmask = 0;
1072 cmd.DW6.LoadSlicePointerFlag = 0; // must be set to 0 for encoder
1073
1074 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1075
1076 return eStatus;
1077 }
1078
1079 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpDecodeSliceStateCmd(
1080 PMOS_COMMAND_BUFFER cmdBuffer,
1081 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1082 {
1083 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1084
1085 MHW_FUNCTION_ENTER;
1086
1087 MHW_MI_CHK_NULL(hevcSliceState);
1088 MHW_MI_CHK_NULL(hevcSliceState->pHevcPicParams);
1089 MHW_MI_CHK_NULL(hevcSliceState->pHevcSliceParams);
1090
1091 auto hevcPicParams = hevcSliceState->pHevcPicParams;
1092 auto hevcSliceParams = hevcSliceState->pHevcSliceParams;
1093
1094 mhw_vdbox_hcp_g9_kbl::HCP_SLICE_STATE_CMD *cmd =
1095 (mhw_vdbox_hcp_g9_kbl::HCP_SLICE_STATE_CMD*)cmdBuffer->pCmdPtr;
1096
1097 MHW_MI_CHK_STATUS(MhwVdboxHcpInterfaceGeneric<mhw_vdbox_hcp_g9_kbl>::AddHcpDecodeSliceStateCmd(cmdBuffer, hevcSliceState));
1098
1099 int32_t sliceQP = hevcSliceParams->slice_qp_delta + hevcPicParams->init_qp_minus26 + 26;
1100 cmd->DW3.SliceqpSignFlag = (sliceQP >= 0) ? 0 : 1;
1101 cmd->DW3.Sliceqp = ABS(sliceQP);
1102
1103 return eStatus;
1104 }
1105
1106 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpEncodeSliceStateCmd(
1107 PMOS_COMMAND_BUFFER cmdBuffer,
1108 PMHW_VDBOX_HEVC_SLICE_STATE hevcSliceState)
1109 {
1110 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1111
1112 MHW_FUNCTION_ENTER;
1113
1114 MHW_MI_CHK_NULL(hevcSliceState);
1115 MHW_MI_CHK_NULL(hevcSliceState->pEncodeHevcSliceParams);
1116 MHW_MI_CHK_NULL(hevcSliceState->pEncodeHevcPicParams);
1117 MHW_MI_CHK_NULL(hevcSliceState->pEncodeHevcSeqParams);
1118
1119 mhw_vdbox_hcp_g9_kbl::HCP_SLICE_STATE_CMD cmd;
1120
1121 auto hevcSliceParams = hevcSliceState->pEncodeHevcSliceParams;
1122 auto hevcPicParams = hevcSliceState->pEncodeHevcPicParams;
1123 auto hevcSeqParams = hevcSliceState->pEncodeHevcSeqParams;
1124
1125 uint32_t ctbSize = 1 << (hevcSeqParams->log2_max_coding_block_size_minus3 + 3);
1126 uint32_t widthInPix = (1 << (hevcSeqParams->log2_min_coding_block_size_minus3 + 3)) *
1127 (hevcSeqParams->wFrameWidthInMinCbMinus1 + 1);
1128 uint32_t widthInCtb = (widthInPix / ctbSize) +
1129 ((widthInPix % ctbSize) ? 1 : 0); // round up
1130
1131 uint32_t ctbAddr = hevcSliceParams->slice_segment_address;
1132 cmd.DW1.SlicestartctbxOrSliceStartLcuXEncoder = ctbAddr % widthInCtb;
1133 cmd.DW1.SlicestartctbyOrSliceStartLcuYEncoder = ctbAddr / widthInCtb;
1134
1135
1136 ctbAddr = hevcSliceParams->slice_segment_address + hevcSliceParams->NumLCUsInSlice;
1137 cmd.DW2.NextslicestartctbxOrNextSliceStartLcuXEncoder = ctbAddr % widthInCtb;
1138 cmd.DW2.NextslicestartctbyOrNextSliceStartLcuYEncoder = ctbAddr / widthInCtb;
1139
1140
1141 cmd.DW3.SliceType = hevcSliceParams->slice_type;
1142 cmd.DW3.Lastsliceofpic = hevcSliceState->bLastSlice;
1143 cmd.DW3.SliceqpSignFlag = ((hevcSliceParams->slice_qp_delta + hevcPicParams->QpY) >= 0)
1144 ? 0 : 1; //8 bit will have 0 as sign bit adn 10 bit might have 1 as sign bit depending on Qp
1145
1146 cmd.DW3.DependentSliceFlag = 0; // Not supported on encoder
1147 cmd.DW3.SliceTemporalMvpEnableFlag = hevcSliceParams->slice_temporal_mvp_enable_flag;
1148 cmd.DW3.Sliceqp = hevcSliceParams->slice_qp_delta + hevcPicParams->QpY;
1149 cmd.DW3.SliceCbQpOffset = hevcSliceParams->slice_cb_qp_offset;
1150 cmd.DW3.SliceCrQpOffset = hevcSliceParams->slice_cr_qp_offset;
1151
1152 cmd.DW4.SliceHeaderDisableDeblockingFilterFlag = hevcSliceParams->slice_deblocking_filter_disable_flag;
1153 cmd.DW4.SliceTcOffsetDiv2OrFinalTcOffsetDiv2Encoder = hevcSliceParams->tc_offset_div2;
1154 cmd.DW4.SliceBetaOffsetDiv2OrFinalBetaOffsetDiv2Encoder = hevcSliceParams->beta_offset_div2;
1155 cmd.DW4.SliceLoopFilterAcrossSlicesEnabledFlag = 0;
1156 cmd.DW4.SliceSaoChromaFlag = hevcSliceParams->slice_sao_chroma_flag;
1157 cmd.DW4.SliceSaoLumaFlag = hevcSliceParams->slice_sao_luma_flag;
1158 cmd.DW4.MvdL1ZeroFlag = 0; // Decoder only - set to 0 for encoder
1159 cmd.DW4.Islowdelay = hevcSliceState->bIsLowDelay;
1160 cmd.DW4.CollocatedFromL0Flag = hevcSliceParams->collocated_from_l0_flag;
1161 cmd.DW4.Chromalog2Weightdenom = hevcSliceParams->luma_log2_weight_denom + hevcSliceParams->delta_chroma_log2_weight_denom;
1162 cmd.DW4.LumaLog2WeightDenom = hevcSliceParams->luma_log2_weight_denom;
1163 cmd.DW4.CabacInitFlag = hevcSliceParams->cabac_init_flag;
1164 cmd.DW4.Maxmergeidx = hevcSliceParams->MaxNumMergeCand - 1;
1165
1166 if (cmd.DW3.SliceTemporalMvpEnableFlag)
1167 {
1168 if (cmd.DW3.SliceType == hevcSliceI)
1169 {
1170 cmd.DW4.Collocatedrefidx = 0;
1171 }
1172 else
1173 {
1174 // need to check with Ce for DDI issues
1175 uint8_t collocatedFromL0Flag = cmd.DW4.CollocatedFromL0Flag;
1176
1177 uint8_t collocatedRefIndex = hevcPicParams->CollocatedRefPicIndex;
1178 MHW_ASSERT(collocatedRefIndex < CODEC_MAX_NUM_REF_FRAME_HEVC);
1179
1180 uint8_t collocatedFrameIdx = hevcSliceState->pRefIdxMapping[collocatedRefIndex];
1181 MHW_ASSERT(collocatedRefIndex < CODEC_MAX_NUM_REF_FRAME_HEVC);
1182
1183 cmd.DW4.Collocatedrefidx = collocatedFrameIdx;
1184 }
1185 }
1186 else
1187 {
1188 cmd.DW4.Collocatedrefidx = 0;
1189 }
1190
1191 cmd.DW5.Sliceheaderlength = 0; // Decoder only, setting to 0 for Encoder
1192
1193 if (!hevcPicParams->bUsedAsRef && hevcPicParams->CodingType != I_TYPE)
1194 {
1195 // non reference B frame
1196 cmd.DW6.Roundinter = 0;
1197 cmd.DW6.Roundintra = 8;
1198 }
1199 else
1200 {
1201 //Other frames
1202 cmd.DW6.Roundinter = 5;
1203 cmd.DW6.Roundintra = 11;
1204 }
1205
1206 cmd.DW7.Cabaczerowordinsertionenable
1207 = 1;
1208 cmd.DW7.Emulationbytesliceinsertenable
1209 = 1;
1210 cmd.DW7.TailInsertionEnable = (hevcPicParams->bLastPicInSeq || hevcPicParams->bLastPicInStream) && hevcSliceState->bLastSlice;
1211 cmd.DW7.SlicedataEnable = 1;
1212 cmd.DW7.HeaderInsertionEnable = 1;
1213
1214 cmd.DW8.IndirectPakBseDataStartOffsetWrite
1215 = hevcSliceState->dwHeaderBytesInserted;
1216
1217 // Transform skip related parameters
1218 if (hevcPicParams->transform_skip_enabled_flag)
1219 {
1220 cmd.DW9.TransformskipLambda = hevcSliceState->EncodeHevcTransformSkipParams.Transformskip_lambda;
1221 cmd.DW10.TransformskipNumzerocoeffsFactor0 = hevcSliceState->EncodeHevcTransformSkipParams.Transformskip_Numzerocoeffs_Factor0;
1222 cmd.DW10.TransformskipNumnonzerocoeffsFactor0 = hevcSliceState->EncodeHevcTransformSkipParams.Transformskip_Numnonzerocoeffs_Factor0;
1223 cmd.DW10.TransformskipNumzerocoeffsFactor1 = hevcSliceState->EncodeHevcTransformSkipParams.Transformskip_Numzerocoeffs_Factor1;
1224 cmd.DW10.TransformskipNumnonzerocoeffsFactor1 = hevcSliceState->EncodeHevcTransformSkipParams.Transformskip_Numnonzerocoeffs_Factor1;
1225 }
1226
1227 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, hevcSliceState->pBatchBufferForPakSlices, &cmd, cmd.byteSize));
1228
1229 return eStatus;
1230 }
1231
1232 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpVp9PicStateCmd(
1233 PMOS_COMMAND_BUFFER cmdBuffer,
1234 PMHW_BATCH_BUFFER batchBuffer,
1235 PMHW_VDBOX_VP9_PIC_STATE params)
1236 {
1237 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1238
1239 MHW_MI_CHK_NULL(params);
1240 MHW_MI_CHK_NULL(params->pVp9PicParams);
1241
1242 mhw_vdbox_hcp_g9_kbl::HCP_VP9_PIC_STATE_CMD cmd;
1243 auto vp9PicParams = params->pVp9PicParams;
1244 auto vp9RefList = params->ppVp9RefList;
1245
1246 cmd.DW0.DwordLength = mhw_vdbox_hcp_g9_kbl::GetOpLength(12); //VP9_PIC_STATE command is common for both Decoder and Encoder. Decoder uses only 12 DWORDS of the generated 33 DWORDS
1247
1248 uint32_t curFrameWidth = vp9PicParams->FrameWidthMinus1 + 1;
1249 uint32_t curFrameHeight = vp9PicParams->FrameHeightMinus1 + 1;
1250 bool isScaling = (curFrameWidth == params->dwPrevFrmWidth) && (curFrameHeight == params->dwPrevFrmHeight) ? false : true;
1251
1252 cmd.DW1.FrameWidthInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameWidth, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
1253 cmd.DW1.FrameHeightInPixelsMinus1 = MOS_ALIGN_CEIL(curFrameHeight, CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
1254
1255 cmd.DW2.FrameType = vp9PicParams->PicFlags.fields.frame_type;
1256 cmd.DW2.AdaptProbabilitiesFlag = !vp9PicParams->PicFlags.fields.error_resilient_mode && !vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
1257 cmd.DW2.IntraonlyFlag = vp9PicParams->PicFlags.fields.intra_only;
1258 cmd.DW2.RefreshFrameContext = vp9PicParams->PicFlags.fields.refresh_frame_context;
1259 cmd.DW2.ErrorResilientMode = vp9PicParams->PicFlags.fields.error_resilient_mode;
1260 cmd.DW2.FrameParallelDecodingMode = vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
1261 cmd.DW2.FilterLevel = vp9PicParams->filter_level;
1262 cmd.DW2.SharpnessLevel = vp9PicParams->sharpness_level;
1263 cmd.DW2.SegmentationEnabled = vp9PicParams->PicFlags.fields.segmentation_enabled;
1264 cmd.DW2.SegmentationUpdateMap = cmd.DW2.SegmentationEnabled && vp9PicParams->PicFlags.fields.segmentation_update_map;
1265 cmd.DW2.LosslessMode = vp9PicParams->PicFlags.fields.LosslessFlag;
1266 cmd.DW2.SegmentIdStreamoutEnable = cmd.DW2.SegmentationUpdateMap;
1267
1268 uint8_t segmentIDStreaminEnable = 0;
1269 if (vp9PicParams->PicFlags.fields.intra_only ||
1270 (vp9PicParams->PicFlags.fields.frame_type == CODEC_VP9_KEY_FRAME)) {
1271 segmentIDStreaminEnable = 1;
1272 } else if (vp9PicParams->PicFlags.fields.segmentation_enabled) {
1273 if (!vp9PicParams->PicFlags.fields.segmentation_update_map)
1274 segmentIDStreaminEnable = 1;
1275 else if (vp9PicParams->PicFlags.fields.segmentation_temporal_update)
1276 segmentIDStreaminEnable = 1;
1277 }
1278 if (vp9PicParams->PicFlags.fields.error_resilient_mode) {
1279 segmentIDStreaminEnable = 1;
1280 }
1281 // Resolution change will reset the segment ID buffer
1282 if (isScaling)
1283 {
1284 segmentIDStreaminEnable = 1;
1285 }
1286
1287 cmd.DW2.SegmentIdStreaminEnable = segmentIDStreaminEnable;
1288
1289 cmd.DW3.Log2TileRow = vp9PicParams->log2_tile_rows; // No need to minus 1 here.
1290 cmd.DW3.Log2TileColumn = vp9PicParams->log2_tile_columns; // No need to minus 1 here.
1291 if (vp9PicParams->subsampling_x == 1 && vp9PicParams->subsampling_y == 1)
1292 {
1293 //4:2:0
1294 cmd.DW3.ChromaSamplingFormat = 0;
1295 }
1296 else if (vp9PicParams->subsampling_x == 1 && vp9PicParams->subsampling_y == 0)
1297 {
1298 //4:2:2
1299 cmd.DW3.ChromaSamplingFormat = 1;
1300 }
1301 else if (vp9PicParams->subsampling_x == 0 && vp9PicParams->subsampling_y == 0)
1302 {
1303 //4:4:4
1304 cmd.DW3.ChromaSamplingFormat = 2;
1305 }
1306 cmd.DW3.Bitdepthminus8 = vp9PicParams->BitDepthMinus8;
1307 cmd.DW3.ProfileLevel = vp9PicParams->profile;
1308
1309 cmd.DW10.UncompressedHeaderLengthInBytes70 = vp9PicParams->UncompressedHeaderLengthInBytes;
1310 cmd.DW10.FirstPartitionSizeInBytes150 = vp9PicParams->FirstPartitionSize;
1311
1312 if (vp9PicParams->PicFlags.fields.frame_type && !vp9PicParams->PicFlags.fields.intra_only)
1313 {
1314 PCODEC_PICTURE refFrameList = &(vp9PicParams->RefFrameList[0]);
1315
1316 uint8_t lastRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.LastRefIdx].FrameIdx;
1317 uint32_t lastRefFrameWidth = vp9RefList[lastRefPicIndex]->dwFrameWidth;
1318 uint32_t lastRefFrameHeight = vp9RefList[lastRefPicIndex]->dwFrameHeight;
1319
1320 uint8_t goldenRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.GoldenRefIdx].FrameIdx;
1321 uint32_t goldenRefFrameWidth = vp9RefList[goldenRefPicIndex]->dwFrameWidth;
1322 uint32_t goldenRefFrameHeight = vp9RefList[goldenRefPicIndex]->dwFrameHeight;
1323
1324 uint8_t altRefPicIndex = refFrameList[vp9PicParams->PicFlags.fields.AltRefIdx].FrameIdx;
1325 uint32_t altRefFrameWidth = vp9RefList[altRefPicIndex]->dwFrameWidth;
1326 uint32_t altRefFrameHeight = vp9RefList[altRefPicIndex]->dwFrameHeight;
1327
1328 cmd.DW2.AllowHiPrecisionMv = vp9PicParams->PicFlags.fields.allow_high_precision_mv;
1329 cmd.DW2.McompFilterType = vp9PicParams->PicFlags.fields.mcomp_filter_type;
1330 cmd.DW2.SegmentationTemporalUpdate = cmd.DW2.SegmentationUpdateMap && vp9PicParams->PicFlags.fields.segmentation_temporal_update;
1331
1332 cmd.DW2.RefFrameSignBias02 = vp9PicParams->PicFlags.fields.LastRefSignBias |
1333 (vp9PicParams->PicFlags.fields.GoldenRefSignBias << 1) |
1334 (vp9PicParams->PicFlags.fields.AltRefSignBias << 2);
1335
1336 cmd.DW2.LastFrameType = !params->PrevFrameParams.fields.KeyFrame;
1337
1338 // Reset UsePrevInFindMvReferences to zero if last picture has a different size,
1339 // Current picture is error-resilient mode, Last picture was intra_only or keyframe,
1340 // Last picture was not a displayed picture.
1341 cmd.DW2.UsePrevInFindMvReferences =
1342 !(vp9PicParams->PicFlags.fields.error_resilient_mode ||
1343 params->PrevFrameParams.fields.KeyFrame ||
1344 params->PrevFrameParams.fields.IntraOnly ||
1345 !params->PrevFrameParams.fields.Display);
1346 // Reset UsePrevInFindMvReferences in case of resolution change on inter frames
1347 if (isScaling) {
1348 cmd.DW2.UsePrevInFindMvReferences = 0;
1349 }
1350
1351 cmd.DW4.HorizontalScaleFactorForLast = (lastRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1352 cmd.DW4.VerticalScaleFactorForLast = (lastRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1353
1354 cmd.DW5.HorizontalScaleFactorForGolden = (goldenRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1355 cmd.DW5.VerticalScaleFactorForGolden = (goldenRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1356
1357 cmd.DW6.HorizontalScaleFactorForAltref = (altRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1358 cmd.DW6.VerticalScaleFactorForAltref = (altRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1359
1360 cmd.DW7.LastFrameWidthInPixelsMinus1 = lastRefFrameWidth - 1;
1361 cmd.DW7.LastFrameHieghtInPixelsMinus1 = lastRefFrameHeight - 1;
1362
1363 cmd.DW8.GoldenFrameWidthInPixelsMinus1 = goldenRefFrameWidth - 1;
1364 cmd.DW8.GoldenFrameHieghtInPixelsMinus1 = goldenRefFrameHeight - 1;
1365
1366 cmd.DW9.AltrefFrameWidthInPixelsMinus1 = altRefFrameWidth - 1;
1367 cmd.DW9.AltrefFrameHieghtInPixelsMinus1 = altRefFrameHeight - 1;
1368 }
1369
1370 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, cmd.byteSize));
1371
1372 return eStatus;
1373 }
1374
1375 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpVp9PicStateEncCmd(
1376 PMOS_COMMAND_BUFFER cmdBuffer,
1377 PMHW_BATCH_BUFFER batchBuffer,
1378 PMHW_VDBOX_VP9_ENCODE_PIC_STATE params)
1379 {
1380 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1381
1382 MHW_FUNCTION_ENTER;
1383
1384 MHW_MI_CHK_NULL(params);
1385 MHW_MI_CHK_NULL(params->pVp9PicParams);
1386 MHW_MI_CHK_NULL(params->ppVp9RefList);
1387
1388 mhw_vdbox_hcp_g9_kbl::HCP_VP9_PIC_STATE_CMD cmd;
1389
1390 auto vp9PicParams = params->pVp9PicParams;
1391 auto vp9RefList = params->ppVp9RefList;
1392
1393 cmd.DW1.FrameWidthInPixelsMinus1 = vp9PicParams->SrcFrameWidthMinus1;
1394 cmd.DW1.FrameHeightInPixelsMinus1 = vp9PicParams->SrcFrameHeightMinus1;
1395
1396 cmd.DW2.FrameType = vp9PicParams->PicFlags.fields.frame_type;
1397 cmd.DW2.AdaptProbabilitiesFlag = !vp9PicParams->PicFlags.fields.error_resilient_mode && !vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
1398 cmd.DW2.IntraonlyFlag = vp9PicParams->PicFlags.fields.intra_only;
1399 cmd.DW2.AllowHiPrecisionMv = vp9PicParams->PicFlags.fields.allow_high_precision_mv;
1400 cmd.DW2.McompFilterType = vp9PicParams->PicFlags.fields.mcomp_filter_type;
1401
1402 cmd.DW2.RefFrameSignBias02 = vp9PicParams->RefFlags.fields.LastRefSignBias |
1403 (vp9PicParams->RefFlags.fields.GoldenRefSignBias << 1) |
1404 (vp9PicParams->RefFlags.fields.AltRefSignBias << 2);
1405
1406 cmd.DW2.HybridPredictionMode = vp9PicParams->PicFlags.fields.comp_prediction_mode == 2;
1407 cmd.DW2.SelectableTxMode = params->ucTxMode == 4;
1408 cmd.DW2.RefreshFrameContext = vp9PicParams->PicFlags.fields.refresh_frame_context;
1409 cmd.DW2.ErrorResilientMode = vp9PicParams->PicFlags.fields.error_resilient_mode;
1410 cmd.DW2.FrameParallelDecodingMode = vp9PicParams->PicFlags.fields.frame_parallel_decoding_mode;
1411 cmd.DW2.FilterLevel = vp9PicParams->filter_level;
1412 cmd.DW2.SharpnessLevel = vp9PicParams->sharpness_level;
1413 cmd.DW2.SegmentationEnabled = vp9PicParams->PicFlags.fields.segmentation_enabled;
1414 cmd.DW2.SegmentationUpdateMap = vp9PicParams->PicFlags.fields.segmentation_update_map;
1415 cmd.DW2.SegmentationTemporalUpdate = vp9PicParams->PicFlags.fields.segmentation_temporal_update;
1416 cmd.DW2.LosslessMode = vp9PicParams->PicFlags.fields.LosslessFlag;
1417
1418 cmd.DW3.Log2TileColumn = vp9PicParams->log2_tile_columns;
1419 cmd.DW3.Log2TileRow = vp9PicParams->log2_tile_rows;
1420
1421 if (vp9PicParams->PicFlags.fields.frame_type && !vp9PicParams->PicFlags.fields.intra_only)
1422 {
1423 uint32_t curFrameWidth = vp9PicParams->SrcFrameWidthMinus1 + 1;
1424 uint32_t curFrameHeight = vp9PicParams->SrcFrameHeightMinus1 + 1;
1425
1426 PCODEC_PICTURE refFrameList = &(vp9PicParams->RefFrameList[0]);
1427
1428 cmd.DW2.LastFrameType = !params->PrevFrameParams.fields.KeyFrame;
1429
1430 cmd.DW2.UsePrevInFindMvReferences = vp9PicParams->PicFlags.fields.error_resilient_mode ||
1431 params->PrevFrameParams.fields.KeyFrame ||
1432 params->PrevFrameParams.fields.IntraOnly ||
1433 !params->PrevFrameParams.fields.Display ||
1434 (curFrameWidth != params->dwPrevFrmWidth) ||
1435 (curFrameHeight != params->dwPrevFrmHeight) ? 0 : 1;
1436
1437 if ((vp9PicParams->RefFlags.fields.ref_frame_ctrl_l0 & 0x01) || (vp9PicParams->RefFlags.fields.ref_frame_ctrl_l1 & 0x01))
1438 {
1439 MHW_ASSERT(!CodecHal_PictureIsInvalid(refFrameList[vp9PicParams->RefFlags.fields.LastRefIdx]));
1440
1441 uint8_t lastRefPicIndex = refFrameList[vp9PicParams->RefFlags.fields.LastRefIdx].FrameIdx;
1442 uint32_t lastRefFrameWidth = vp9RefList[lastRefPicIndex]->dwFrameWidth;
1443 uint32_t lastRefFrameHeight = vp9RefList[lastRefPicIndex]->dwFrameHeight;
1444
1445 cmd.DW4.HorizontalScaleFactorForLast = (lastRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1446 cmd.DW4.VerticalScaleFactorForLast = (lastRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1447
1448 cmd.DW7.LastFrameWidthInPixelsMinus1 = lastRefFrameWidth - 1;
1449 cmd.DW7.LastFrameHieghtInPixelsMinus1 = lastRefFrameHeight - 1;
1450 }
1451
1452 if ((vp9PicParams->RefFlags.fields.ref_frame_ctrl_l0 & 0x02) || (vp9PicParams->RefFlags.fields.ref_frame_ctrl_l1 & 0x02))
1453 {
1454 MHW_ASSERT(!CodecHal_PictureIsInvalid(refFrameList[vp9PicParams->RefFlags.fields.GoldenRefIdx]));
1455
1456 uint8_t goldenRefPicIndex = refFrameList[vp9PicParams->RefFlags.fields.GoldenRefIdx].FrameIdx;
1457 uint32_t goldenRefFrameWidth = vp9RefList[goldenRefPicIndex]->dwFrameWidth;
1458 uint32_t goldenRefFrameHeight = vp9RefList[goldenRefPicIndex]->dwFrameHeight;
1459
1460 cmd.DW5.HorizontalScaleFactorForGolden = (goldenRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1461 cmd.DW5.VerticalScaleFactorForGolden = (goldenRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1462
1463 cmd.DW8.GoldenFrameWidthInPixelsMinus1 = goldenRefFrameWidth - 1;
1464 cmd.DW8.GoldenFrameHieghtInPixelsMinus1 = goldenRefFrameHeight - 1;
1465 }
1466
1467 if ((vp9PicParams->RefFlags.fields.ref_frame_ctrl_l0 & 0x04) || (vp9PicParams->RefFlags.fields.ref_frame_ctrl_l1 & 0x04))
1468 {
1469 MHW_ASSERT(!CodecHal_PictureIsInvalid(refFrameList[vp9PicParams->RefFlags.fields.AltRefIdx]));
1470
1471 uint8_t altRefPicIndex = refFrameList[vp9PicParams->RefFlags.fields.AltRefIdx].FrameIdx;
1472 uint32_t altRefFrameWidth = vp9RefList[altRefPicIndex]->dwFrameWidth;
1473 uint32_t altRefFrameHeight = vp9RefList[altRefPicIndex]->dwFrameHeight;
1474
1475 cmd.DW6.HorizontalScaleFactorForAltref = (altRefFrameWidth * m_vp9ScalingFactor) / curFrameWidth;
1476 cmd.DW6.VerticalScaleFactorForAltref = (altRefFrameHeight * m_vp9ScalingFactor) / curFrameHeight;
1477
1478 cmd.DW9.AltrefFrameWidthInPixelsMinus1 = altRefFrameWidth - 1;
1479 cmd.DW9.AltrefFrameHieghtInPixelsMinus1 = altRefFrameHeight - 1;
1480 }
1481 }
1482
1483 cmd.DW13.BaseQIndexSameAsLumaAc = vp9PicParams->LumaACQIndex;
1484
1485 cmd.DW14.ChromaacQindexdelta = Convert2SignMagnitude(vp9PicParams->ChromaACQIndexDelta, 5);
1486 cmd.DW14.ChromadcQindexdelta = Convert2SignMagnitude(vp9PicParams->ChromaDCQIndexDelta, 5);
1487 cmd.DW14.LumaDcQIndexDelta = Convert2SignMagnitude(vp9PicParams->LumaDCQIndexDelta, 5);
1488
1489 cmd.DW15.LfRefDelta0 = Convert2SignMagnitude(vp9PicParams->LFRefDelta[0], 7);
1490 cmd.DW15.LfRefDelta1 = Convert2SignMagnitude(vp9PicParams->LFRefDelta[1], 7);
1491 cmd.DW15.LfRefDelta2 = Convert2SignMagnitude(vp9PicParams->LFRefDelta[2], 7);
1492 cmd.DW15.LfRefDelta3 = Convert2SignMagnitude(vp9PicParams->LFRefDelta[3], 7);
1493
1494 cmd.DW16.LfModeDelta0 = Convert2SignMagnitude(vp9PicParams->LFModeDelta[0], 7);
1495 cmd.DW16.LfModeDelta0 = Convert2SignMagnitude(vp9PicParams->LFModeDelta[1], 7);
1496
1497 cmd.DW17.Bitoffsetforlfrefdelta = vp9PicParams->BitOffsetForLFRefDelta;
1498 cmd.DW17.Bitoffsetforlfmodedelta = vp9PicParams->BitOffsetForLFModeDelta;
1499
1500 cmd.DW18.Bitoffsetforlflevel = vp9PicParams->BitOffsetForLFLevel;
1501 cmd.DW18.Bitoffsetforqindex = vp9PicParams->BitOffsetForQIndex;
1502
1503 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, cmd.byteSize));
1504
1505 return eStatus;
1506 }
1507
1508 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpVp9SegmentStateCmd(
1509 PMOS_COMMAND_BUFFER cmdBuffer,
1510 PMHW_BATCH_BUFFER batchBuffer,
1511 PMHW_VDBOX_VP9_SEGMENT_STATE params)
1512 {
1513 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1514
1515 MHW_MI_CHK_NULL(params);
1516
1517 typename mhw_vdbox_hcp_g9_kbl::HCP_VP9_SEGMENT_STATE_CMD cmd;
1518 void* segData = nullptr;
1519
1520 cmd.DW1.SegmentId = params->ucCurrentSegmentId;
1521
1522 if (!this->m_decodeInUse)
1523 {
1524 CODEC_VP9_ENCODE_SEG_PARAMS vp9SegData;
1525
1526 vp9SegData = params->pVp9EncodeSegmentParams->SegData[params->ucCurrentSegmentId];
1527
1528 if (params->pbSegStateBufferPtr) // Use the seg data from this buffer (output of BRC)
1529 {
1530 segData = params->pbSegStateBufferPtr;
1531 }
1532 else // Prepare the seg data
1533 {
1534 cmd.DW2.SegmentSkipped = vp9SegData.SegmentFlags.fields.SegmentSkipped;
1535 cmd.DW2.SegmentReference = vp9SegData.SegmentFlags.fields.SegmentReference;
1536 cmd.DW2.SegmentReferenceEnabled = vp9SegData.SegmentFlags.fields.SegmentReferenceEnabled;
1537
1538 segData = &cmd;
1539 }
1540 }
1541 else
1542 {
1543 CODEC_VP9_SEG_PARAMS vp9SegData;
1544 vp9SegData = params->pVp9SegmentParams->SegData[params->ucCurrentSegmentId];
1545
1546 cmd.DW2.SegmentSkipped = vp9SegData.SegmentFlags.fields.SegmentReferenceSkipped;
1547 cmd.DW2.SegmentReference = vp9SegData.SegmentFlags.fields.SegmentReference;
1548 cmd.DW2.SegmentReferenceEnabled = vp9SegData.SegmentFlags.fields.SegmentReferenceEnabled;
1549
1550 cmd.DW3.Filterlevelref0Mode0 = vp9SegData.FilterLevel[0][0];
1551 cmd.DW3.Filterlevelref0Mode1 = vp9SegData.FilterLevel[0][1];
1552 cmd.DW3.Filterlevelref1Mode0 = vp9SegData.FilterLevel[1][0];
1553 cmd.DW3.Filterlevelref1Mode1 = vp9SegData.FilterLevel[1][1];
1554
1555 cmd.DW4.Filterlevelref2Mode0 = vp9SegData.FilterLevel[2][0];
1556 cmd.DW4.Filterlevelref2Mode1 = vp9SegData.FilterLevel[2][1];
1557 cmd.DW4.Filterlevelref3Mode0 = vp9SegData.FilterLevel[3][0];
1558 cmd.DW4.Filterlevelref3Mode1 = vp9SegData.FilterLevel[3][1];
1559
1560 cmd.DW5.LumaDcQuantScaleDecodeModeOnly = vp9SegData.LumaDCQuantScale;
1561 cmd.DW5.LumaAcQuantScaleDecodeModeOnly = vp9SegData.LumaACQuantScale;
1562
1563 cmd.DW6.ChromaDcQuantScaleDecodeModeOnly = vp9SegData.ChromaDCQuantScale;
1564 cmd.DW6.ChromaAcQuantScaleDecodeModeOnly = vp9SegData.ChromaACQuantScale;
1565
1566 segData = &cmd;
1567 }
1568
1569 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, segData, cmd.byteSize));
1570
1571 return eStatus;
1572 }
1573
1574 MOS_STATUS MhwVdboxHcpInterfaceG9Kbl::AddHcpHevcPicBrcBuffer(
1575 PMOS_RESOURCE hcpImgStates,
1576 PMHW_VDBOX_HEVC_PIC_STATE hevcSliceState)
1577 {
1578 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1579
1580 MHW_FUNCTION_ENTER;
1581
1582 MHW_MI_CHK_NULL(hcpImgStates);
1583
1584 MOS_COMMAND_BUFFER constructedCmdBuf;
1585 mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD cmd;
1586 uint32_t* insertion = nullptr;
1587 MOS_LOCK_PARAMS lockFlags;
1588 m_brcNumPakPasses = hevcSliceState->brcNumPakPasses;
1589
1590 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
1591 lockFlags.WriteOnly = 1;
1592 uint8_t* data = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, hcpImgStates, &lockFlags);
1593 MHW_MI_CHK_NULL(data);
1594
1595 constructedCmdBuf.pCmdBase = (uint32_t *)data;
1596 constructedCmdBuf.pCmdPtr = (uint32_t *)data;
1597 constructedCmdBuf.iOffset = 0;
1598 constructedCmdBuf.iRemaining = BRC_IMG_STATE_SIZE_PER_PASS * (m_brcNumPakPasses);
1599
1600 MHW_MI_CHK_STATUS(AddHcpPicStateCmd(&constructedCmdBuf, hevcSliceState));
1601
1602 cmd = *(mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD *)data;
1603
1604 for (uint32_t i = 0; i < m_brcNumPakPasses; i++)
1605 {
1606 if (i == 0)
1607 {
1608 cmd.DW6.Nonfirstpassflag = false;
1609 }
1610 else
1611 {
1612 cmd.DW6.Nonfirstpassflag = true;
1613 }
1614
1615 cmd.DW6.FrameszoverstatusenFramebitratemaxreportmask = true;
1616 cmd.DW6.FrameszunderstatusenFramebitrateminreportmask = true;
1617 cmd.DW6.LcumaxbitstatusenLcumaxsizereportmask = false; // BRC update kernel does not consider if there is any LCU whose size is too big
1618
1619 *(mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD *)data = cmd;
1620
1621 /* add batch buffer end insertion flag */
1622 insertion = (uint32_t*)(data + mhw_vdbox_hcp_g9_kbl::HCP_PIC_STATE_CMD::byteSize);
1623 *insertion = 0x05000000;
1624
1625 data += BRC_IMG_STATE_SIZE_PER_PASS;
1626 }
1627
1628 m_osInterface->pfnUnlockResource(m_osInterface, hcpImgStates);
1629
1630 return eStatus;
1631 }