Debian Codegraph @

media_driver/agnostic/gen12/hw/vdbox/mhw_vdbox_mfx_g12_X.cpp

raw
1 /*
2 * Copyright (c) 2017-2023, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vdbox_mfx_g12_X.cpp
24 //! \brief Constructs VdBox MFX commands on Gen12-based platforms
25
26 #include "mhw_vdbox_mfx_g12_X.h"
27 #include "mhw_mi_hwcmd_g12_X.h"
28 #include "mos_os.h"
29 #include "mhw_mmio_g12.h"
30 #include "hal_oca_interface.h"
31
32 #define GEN12_AVC_MPR_ROWSTORE_BASEADDRESS 256
33 #define GEN12_AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF 512
34 #define GEN12_AVC_IP_ROWSTORE_BASEADDRESS 512
35 #define GEN12_AVC_IP_ROWSTORE_BASEADDRESS_MBAFF 1024
36 #define GEN12_AVC_VLF_ROWSTORE_BASEADDRESS 768
37 #define GEN12_VP8_IP_ROWSTORE_BASEADDRESS 256
38 #define GEN12_VP8_VLF_ROWSTORE_BASEADDRESS 512
39
40 MhwVdboxMfxInterfaceG12::~MhwVdboxMfxInterfaceG12()
41 {
42 MHW_FUNCTION_ENTER;
43
44 #if (_DEBUG || _RELEASE_INTERNAL)
45 MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
46 UserFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED_ID;
47 if (m_intraRowstoreCache.bEnabled ||
48 m_deblockingFilterRowstoreCache.bEnabled ||
49 m_bsdMpcRowstoreCache.bEnabled ||
50 m_mprRowstoreCache.bEnabled)
51 {
52 UserFeatureWriteData.Value.i32Data = 1;
53 }
54 MOS_UserFeature_WriteValues_ID(nullptr, &UserFeatureWriteData, 1, m_osInterface->pOsContext);
55 #endif
56
57 }
58
59 void MhwVdboxMfxInterfaceG12::InitMmioRegisters()
60 {
61 MmioRegistersMfx *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1];
62
63 mmioRegisters->generalPurposeRegister0LoOffset = GENERAL_PURPOSE_REGISTER0_LO_OFFSET_NODE_1_INIT_G12;
64 mmioRegisters->generalPurposeRegister0HiOffset = GENERAL_PURPOSE_REGISTER0_HI_OFFSET_NODE_1_INIT_G12;
65 mmioRegisters->generalPurposeRegister4LoOffset = GENERAL_PURPOSE_REGISTER4_LO_OFFSET_NODE_1_INIT_G12;
66 mmioRegisters->generalPurposeRegister4HiOffset = GENERAL_PURPOSE_REGISTER4_HI_OFFSET_NODE_1_INIT_G12;
67 mmioRegisters->generalPurposeRegister11LoOffset = GENERAL_PURPOSE_REGISTER11_LO_OFFSET_NODE_1_INIT_G12;
68 mmioRegisters->generalPurposeRegister11HiOffset = GENERAL_PURPOSE_REGISTER11_HI_OFFSET_NODE_1_INIT_G12;
69 mmioRegisters->generalPurposeRegister12LoOffset = GENERAL_PURPOSE_REGISTER12_LO_OFFSET_NODE_1_INIT_G12;
70 mmioRegisters->generalPurposeRegister12HiOffset = GENERAL_PURPOSE_REGISTER12_HI_OFFSET_NODE_1_INIT_G12;
71 mmioRegisters->mfcImageStatusMaskRegOffset = MFC_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT_G12;
72 mmioRegisters->mfcImageStatusCtrlRegOffset = MFC_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT_G12;
73 mmioRegisters->mfcAvcNumSlicesRegOffset = MFC_AVC_NUM_SLICES_REG_OFFSET_NODE_1_INIT_G12;
74 mmioRegisters->mfcQPStatusCountOffset = MFC_QP_STATUS_COUNT_OFFSET_NODE_1_INIT_G12;
75 mmioRegisters->mfxErrorFlagsRegOffset = MFX_ERROR_FLAG_REG_OFFSET_NODE_1_INIT_G12;
76 mmioRegisters->mfxFrameCrcRegOffset = MFX_FRAME_CRC_REG_OFFSET_NODE_1_INIT_G12;
77 mmioRegisters->mfxMBCountRegOffset = MFX_MB_COUNT_REG_OFFSET_NODE_1_INIT_G12;
78 mmioRegisters->mfcBitstreamBytecountFrameRegOffset = MFC_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G12;
79 mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset = MFC_BITSTREAM_SE_BITCOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G12;
80 mmioRegisters->mfcBitstreamBytecountSliceRegOffset = MFC_BITSTREAM_BYTECOUNT_SLICE_REG_OFFSET_NODE_1_INIT_G12;
81 mmioRegisters->mfcVP8BitstreamBytecountFrameRegOffset = MFC_VP8_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G12;
82 mmioRegisters->mfcVP8ImageStatusMaskRegOffset = MFC_VP8_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT_G12;
83 mmioRegisters->mfcVP8ImageStatusCtrlRegOffset = MFC_VP8_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT_G12;
84 mmioRegisters->mfxVP8BrcDQIndexRegOffset = MFX_VP8_BRC_DQ_INDEX_REG_OFFSET_NODE_1_INIT_G12;
85 mmioRegisters->mfxVP8BrcDLoopFilterRegOffset = MFX_VP8_BRC_LOOP_FILTER_REG_OFFSET_NODE_1_INIT_G12;
86 mmioRegisters->mfxVP8BrcCumulativeDQIndex01RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX01_REG_OFFSET_NODE_1_INIT_G12;
87 mmioRegisters->mfxVP8BrcCumulativeDQIndex23RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX23_REG_OFFSET_NODE_1_INIT_G12;
88 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter01RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER01_REG_OFFSET_NODE_1_INIT_G12;
89 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter23RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER23_REG_OFFSET_NODE_1_INIT_G12;
90 mmioRegisters->mfxVP8BrcConvergenceStatusRegOffset = MFX_VP8_BRC_CONVERGENCE_STATUS_REG_OFFSET_NODE_1_INIT_G12;
91 mmioRegisters->mfxLra0RegOffset = MFX_LRA0_REG_OFFSET_NODE_1_INIT_G12;
92 mmioRegisters->mfxLra1RegOffset = MFX_LRA1_REG_OFFSET_NODE_1_INIT_G12;
93 mmioRegisters->mfxLra2RegOffset = MFX_LRA2_REG_OFFSET_NODE_1_INIT_G12;
94
95 m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1];
96 }
97
98 void MhwVdboxMfxInterfaceG12::InitRowstoreUserFeatureSettings()
99 {
100 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
101
102 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
103 if (m_osInterface->bSimIsActive)
104 {
105 // GEN12 can support row store cache
106 userFeatureData.u32Data = 1;
107 }
108 else
109 {
110 userFeatureData.u32Data = 0;
111 }
112
113 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
114 #if (_DEBUG || _RELEASE_INTERNAL)
115 MOS_UserFeature_ReadValue_ID(
116 nullptr,
117 __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
118 &userFeatureData,
119 m_osInterface->pOsContext);
120 #endif // _DEBUG || _RELEASE_INTERNAL
121 m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;
122
123 if (m_rowstoreCachingSupported)
124 {
125 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
126 #if (_DEBUG || _RELEASE_INTERNAL)
127 MOS_UserFeature_ReadValue_ID(
128 nullptr,
129 __MEDIA_USER_FEATURE_VALUE_INTRAROWSTORECACHE_DISABLE_ID,
130 &userFeatureData,
131 m_osInterface->pOsContext);
132 #endif // _DEBUG || _RELEASE_INTERNAL
133 m_intraRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
134
135 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
136 #if (_DEBUG || _RELEASE_INTERNAL)
137 MOS_UserFeature_ReadValue_ID(
138 nullptr,
139 __MEDIA_USER_FEATURE_VALUE_DEBLOCKINGFILTERROWSTORECACHE_DISABLE_ID,
140 &userFeatureData,
141 m_osInterface->pOsContext);
142 #endif // _DEBUG || _RELEASE_INTERNAL
143 m_deblockingFilterRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
144
145 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
146 #if (_DEBUG || _RELEASE_INTERNAL)
147 MOS_UserFeature_ReadValue_ID(
148 nullptr,
149 __MEDIA_USER_FEATURE_VALUE_BSDMPCROWSTORECACHE_DISABLE_ID,
150 &userFeatureData,
151 m_osInterface->pOsContext);
152 #endif // _DEBUG || _RELEASE_INTERNAL
153 m_bsdMpcRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
154
155 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
156 #if (_DEBUG || _RELEASE_INTERNAL)
157 MOS_UserFeature_ReadValue_ID(
158 nullptr,
159 __MEDIA_USER_FEATURE_VALUE_MPRROWSTORECACHE_DISABLE_ID,
160 &userFeatureData,
161 m_osInterface->pOsContext);
162 #endif // _DEBUG || _RELEASE_INTERNAL
163 m_mprRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
164 }
165 }
166
167 MOS_STATUS MhwVdboxMfxInterfaceG12::GetRowstoreCachingAddrs(
168 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
169 {
170 MHW_FUNCTION_ENTER;
171
172 MHW_MI_CHK_NULL(rowstoreParams);
173
174 bool avc = rowstoreParams->Mode == CODECHAL_DECODE_MODE_AVCVLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC;
175 bool vp8 = rowstoreParams->Mode == CODECHAL_DECODE_MODE_VP8VLD || rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP8;
176 bool widthLE4K = rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_4K;
177 bool mbaffOrField = rowstoreParams->bMbaff || !rowstoreParams->bIsFrame;
178
179 //BSD row store cache
180 m_bsdMpcRowstoreCache.bEnabled = m_bsdMpcRowstoreCache.bSupported && widthLE4K && (avc || vp8);
181 m_bsdMpcRowstoreCache.dwAddress = m_bsdMpcRowstoreCache.bEnabled ? BSDMPCROWSTORE_BASEADDRESS : 0;
182
183 //MPR row store cache
184 m_mprRowstoreCache.bEnabled = m_mprRowstoreCache.bSupported && widthLE4K && avc;
185 m_mprRowstoreCache.dwAddress = m_mprRowstoreCache.bEnabled ? (mbaffOrField ? GEN12_AVC_MPR_ROWSTORE_BASEADDRESS_MBAFF :
186 GEN12_AVC_MPR_ROWSTORE_BASEADDRESS) : 0;
187
188 //IP row store cache
189 m_intraRowstoreCache.bEnabled = m_intraRowstoreCache.bSupported && widthLE4K && (avc || vp8);
190 m_intraRowstoreCache.dwAddress = avc ? (mbaffOrField ? GEN12_AVC_IP_ROWSTORE_BASEADDRESS_MBAFF
191 : GEN12_AVC_IP_ROWSTORE_BASEADDRESS) : GEN12_VP8_IP_ROWSTORE_BASEADDRESS;
192 m_intraRowstoreCache.dwAddress = m_intraRowstoreCache.bEnabled ? m_intraRowstoreCache.dwAddress : 0;
193
194 //VLF row store cache
195 m_deblockingFilterRowstoreCache.bEnabled = m_deblockingFilterRowstoreCache.bSupported && widthLE4K && ((avc && !mbaffOrField) || vp8);
196 m_deblockingFilterRowstoreCache.dwAddress = m_deblockingFilterRowstoreCache.bEnabled ?
197 (avc ? GEN12_AVC_VLF_ROWSTORE_BASEADDRESS : GEN12_VP8_VLF_ROWSTORE_BASEADDRESS) : 0;
198
199 return MOS_STATUS_SUCCESS;
200 }
201
202 #if (_DEBUG || _RELEASE_INTERNAL)
203 MOS_STATUS MhwVdboxMfxInterfaceG12::CheckScalabilityOverrideValidity()
204 {
205 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
206
207 MEDIA_SYSTEM_INFO *gtSystemInfo;
208 uint32_t forceVdbox;
209 bool scalableDecMode;
210 bool useVD1, useVD2, useVD3, useVD4;
211
212 MHW_MI_CHK_NULL(m_osInterface);
213 scalableDecMode = m_osInterface->bHcpDecScalabilityMode ? true : false;
214 forceVdbox = m_osInterface->eForceVdbox;
215 gtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
216 MHW_MI_CHK_NULL(gtSystemInfo);
217
218 if (forceVdbox != MOS_FORCE_VDBOX_NONE &&
219 forceVdbox != MOS_FORCE_VDBOX_1 &&
220 forceVdbox != MOS_FORCE_VDBOX_2 &&
221 // 2 pipes, VDBOX1-BE1, VDBOX2-BE2
222 forceVdbox != MOS_FORCE_VDBOX_1_1_2 &&
223 forceVdbox != MOS_FORCE_VDBOX_2_1_2)
224 {
225 eStatus = MOS_STATUS_INVALID_PARAMETER;
226 MHW_ASSERTMESSAGE("user feature forceVdbox value is invalid.");
227 return eStatus;
228 }
229
230 if (!scalableDecMode &&
231 (forceVdbox == MOS_FORCE_VDBOX_1_1_2 ||
232 forceVdbox == MOS_FORCE_VDBOX_2_1_2))
233 {
234 eStatus = MOS_STATUS_INVALID_PARAMETER;
235 MHW_ASSERTMESSAGE("user feature forceVdbox valude does not consistent with regkey scalability mode.");
236 return eStatus;
237 }
238
239 if (scalableDecMode && !m_scalabilitySupported)
240 {
241 eStatus = MOS_STATUS_INVALID_PARAMETER;
242 MHW_ASSERTMESSAGE("user feature scalability mode is not allowed on current platform!");
243 return eStatus;
244 }
245
246 useVD1 = useVD2 = false;
247 if (forceVdbox == 0)
248 {
249 useVD1 = true;
250 }
251 else
252 {
253 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_1,
254 MOS_FORCEVDBOX_VDBOXID_BITSNUM,
255 MOS_FORCEVDBOX_MASK,
256 useVD1);
257 MHW_VDBOX_IS_VDBOX_SPECIFIED(forceVdbox, MOS_FORCE_VDBOX_2,
258 MOS_FORCEVDBOX_VDBOXID_BITSNUM,
259 MOS_FORCEVDBOX_MASK,
260 useVD2);
261 }
262
263 if (!gtSystemInfo->VDBoxInfo.IsValid ||
264 (useVD1 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox0Enabled) ||
265 (useVD2 && !gtSystemInfo->VDBoxInfo.Instances.Bits.VDBox1Enabled))
266 {
267 eStatus = MOS_STATUS_INVALID_PARAMETER;
268 MHW_ASSERTMESSAGE("the forced VDBOX is not enabled in current platform.");
269 return eStatus;
270 }
271
272 return eStatus;
273 }
274 #endif
275
276 MOS_STATUS MhwVdboxMfxInterfaceG12::FindGpuNodeToUse(
277 PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit)
278 {
279 bool setVideoNode = false;
280 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
281
282 MOS_GPU_NODE videoGpuNode = MOS_GPU_NODE_VIDEO;
283
284 if (MOS_VE_MULTINODESCALING_SUPPORTED(m_osInterface))
285 {
286 if (GetNumVdbox() == 1)
287 {
288 videoGpuNode = MOS_GPU_NODE_VIDEO;
289 }
290 else
291 {
292 MHW_MI_CHK_STATUS(m_osInterface->pfnCreateVideoNodeAssociation(
293 m_osInterface,
294 setVideoNode,
295 &videoGpuNode));
296 }
297 }
298
299 #if (_DEBUG || _RELEASE_INTERNAL)
300 if (m_osInterface != nullptr && m_osInterface->bEnableDbgOvrdInVE &&
301 (!m_osInterface->bSupportVirtualEngine || !m_scalabilitySupported))
302 {
303 eStatus = MOS_STATUS_INVALID_PARAMETER;
304 MHW_ASSERTMESSAGE("not support DebugOverrid on current OS or Platform.");
305 return eStatus;
306 }
307
308 if (m_osInterface != nullptr && m_osInterface->bEnableDbgOvrdInVE)
309 {
310 MHW_MI_CHK_STATUS(CheckScalabilityOverrideValidity());
311 }
312 #endif
313
314 gpuNodeLimit->dwGpuNodeToUse = videoGpuNode;
315
316 return eStatus;
317 }
318
319 MOS_STATUS MhwVdboxMfxInterfaceG12::GetMfxStateCommandsDataSize(
320 uint32_t mode,
321 uint32_t *commandsSize,
322 uint32_t *patchListSize,
323 bool isShortFormat)
324 {
325 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
326
327 MHW_FUNCTION_ENTER;
328
329 MHW_MI_CHK_NULL(commandsSize);
330 MHW_MI_CHK_NULL(patchListSize);
331
332 uint32_t maxSize =
333 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize +
334 mhw_vdbox_mfx_g12_X::MFX_PIPE_MODE_SELECT_CMD::byteSize +
335 mhw_vdbox_mfx_g12_X::MFX_SURFACE_STATE_CMD::byteSize +
336 mhw_vdbox_mfx_g12_X::MFX_PIPE_BUF_ADDR_STATE_CMD::byteSize +
337 mhw_vdbox_mfx_g12_X::MFX_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
338 2 * mhw_mi_g12_X::MI_STORE_DATA_IMM_CMD::byteSize +
339 2 * mhw_mi_g12_X::MI_STORE_REGISTER_MEM_CMD::byteSize +
340 8 * mhw_mi_g12_X::MI_LOAD_REGISTER_REG_CMD::byteSize;
341
342 uint32_t patchListMaxSize =
343 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
344 PATCH_LIST_COMMAND(MFX_PIPE_MODE_SELECT_CMD) +
345 PATCH_LIST_COMMAND(MFX_SURFACE_STATE_CMD) +
346 PATCH_LIST_COMMAND(MFX_PIPE_BUF_ADDR_STATE_CMD) +
347 PATCH_LIST_COMMAND(MFX_IND_OBJ_BASE_ADDR_STATE_CMD) +
348 (2 * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD)) +
349 (2 * PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD));
350
351 uint32_t standard = CodecHal_GetStandardFromMode(mode);
352 if (standard == CODECHAL_AVC)
353 {
354 maxSize +=
355 mhw_vdbox_mfx_g12_X::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
356 mhw_vdbox_mfx_g12_X::MFD_AVC_PICID_STATE_CMD::byteSize +
357 mhw_vdbox_mfx_g12_X::MFX_AVC_DIRECTMODE_STATE_CMD::byteSize +
358 mhw_vdbox_mfx_g12_X::MFX_AVC_IMG_STATE_CMD::byteSize +
359 mhw_vdbox_mfx_g12_X::MFX_QM_STATE_CMD::byteSize * 4; // QM_State sent 4 times
360
361 patchListMaxSize +=
362 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
363 PATCH_LIST_COMMAND(MFD_AVC_PICID_STATE_CMD) +
364 PATCH_LIST_COMMAND(MFX_AVC_DIRECTMODE_STATE_CMD) +
365 PATCH_LIST_COMMAND(MFX_AVC_IMG_STATE_CMD) +
366 PATCH_LIST_COMMAND(MFX_QM_STATE_CMD) * 4;
367
368 if (mode == CODECHAL_ENCODE_MODE_AVC)
369 {
370 maxSize +=
371 mhw_mi_g12_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize +
372 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize * 3 + // 3 extra MI_FLUSH_DWs for encode
373 mhw_vdbox_mfx_g12_X::MFX_FQM_STATE_CMD::byteSize * 4 + // FQM_State sent 4 times
374 mhw_mi_g12_X::MI_STORE_REGISTER_MEM_CMD::byteSize * 8 + // 5 extra register queries for encode, 3 extra slice level commands for BrcPakStatistics
375 mhw_mi_g12_X::MI_STORE_DATA_IMM_CMD::byteSize * 3 + // slice level commands for StatusReport, BrcPakStatistics
376 MHW_VDBOX_PAK_BITSTREAM_OVERFLOW_SIZE + // accounting for the max DW payload for PAK_INSERT_OBJECT, for frame header payload
377 mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD::byteSize * 4; // for inserting AU, SPS, PSP, SEI headers before first slice header
378
379 patchListMaxSize +=
380 PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD) +
381 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 3 + // 3 extra MI_FLUSH_DWs for encode
382 PATCH_LIST_COMMAND(MFX_FQM_STATE_CMD) * 4 + // FQM_State sent 4 times
383 PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD) * 8 + // 5 extra register queries for encode, 3 extra slice level commands for BrcPakStatistics
384 PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD) * 3; // slice level commands for StatusReport, BrcPakStatistics
385 PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD) * 4; // for inserting AU, SPS, PSP, SEI headers before first slice header
386 }
387 }
388 else if (standard == CODECHAL_VC1)
389 {
390 maxSize +=
391 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize +
392 mhw_vdbox_mfx_g12_X::MFD_VC1_LONG_PIC_STATE_CMD::byteSize +
393 mhw_vdbox_mfx_g12_X::MFX_VC1_PRED_PIPE_STATE_CMD::byteSize;
394
395 patchListMaxSize +=
396 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
397 PATCH_LIST_COMMAND(MFD_VC1_LONG_PIC_STATE_CMD) +
398 PATCH_LIST_COMMAND(MFX_VC1_PRED_PIPE_STATE_CMD);
399
400 if (mode == CODECHAL_DECODE_MODE_VC1VLD)
401 {
402 maxSize +=
403 mhw_vdbox_mfx_g12_X::MFX_VC1_DIRECTMODE_STATE_CMD::byteSize +
404 mhw_vdbox_mfx_g12_X::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize;
405
406 patchListMaxSize +=
407 PATCH_LIST_COMMAND(MFX_VC1_DIRECTMODE_STATE_CMD) +
408 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD);
409 }
410 else if (mode == CODECHAL_DECODE_MODE_VC1IT)
411 {
412 maxSize +=
413 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize * 2;
414
415 patchListMaxSize +=
416 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2;
417 }
418 }
419 else if (standard == CODECHAL_MPEG2)
420 {
421 maxSize += mhw_vdbox_mfx_g12_X::MFX_MPEG2_PIC_STATE_CMD::byteSize;
422 patchListMaxSize += PATCH_LIST_COMMAND(MFX_MPEG2_PIC_STATE_CMD);
423
424 if (mode == CODECHAL_DECODE_MODE_MPEG2VLD)
425 {
426 maxSize +=
427 mhw_vdbox_mfx_g12_X::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
428 ((mhw_vdbox_mfx_g12_X::MFX_QM_STATE_CMD::byteSize + (m_mpeg2WeightScaleSize * sizeof(uint32_t))) * 2);
429
430 patchListMaxSize +=
431 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
432 PATCH_LIST_COMMAND(MFX_QM_STATE_CMD) * 2;
433 }
434 else if (mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
435 {
436 maxSize +=
437 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize * 2;
438
439 patchListMaxSize +=
440 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2;
441 }
442 }
443 else if (standard == CODECHAL_VP8)
444 {
445 maxSize +=
446 mhw_vdbox_mfx_g12_X::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
447 mhw_vdbox_mfx_g12_X::MFX_VP8_PIC_STATE_CMD::byteSize;
448
449 patchListMaxSize +=
450 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
451 PATCH_LIST_COMMAND(MFX_VP8_PIC_STATE_CMD);
452 }
453 else if (standard == CODECHAL_JPEG)
454 {
455 // Added to prevent error for JPEG
456 }
457 else
458 {
459 MHW_ASSERTMESSAGE("Unsupported decode mode.");
460 maxSize = 0;
461 patchListMaxSize = 0;
462 eStatus = MOS_STATUS_UNKNOWN;
463 }
464
465 *commandsSize = maxSize;
466 *patchListSize = patchListMaxSize;
467
468 return eStatus;
469 }
470
471 MOS_STATUS MhwVdboxMfxInterfaceG12::GetMfxPrimitiveCommandsDataSize(
472 uint32_t mode,
473 uint32_t *commandsSize,
474 uint32_t *patchListSize,
475 bool isModeSpecific)
476 {
477 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
478
479 MHW_FUNCTION_ENTER;
480
481 MHW_MI_CHK_NULL(commandsSize);
482 MHW_MI_CHK_NULL(patchListSize);
483
484 uint32_t maxSize = 0, patchListMaxSize = 0;
485 uint32_t standard = CodecHal_GetStandardFromMode(mode);
486
487 if (standard == CODECHAL_AVC)
488 {
489 if (mode == CODECHAL_DECODE_MODE_AVCVLD)
490 {
491 maxSize =
492 mhw_vdbox_mfx_g12_X::MFX_AVC_SLICE_STATE_CMD::byteSize +
493 mhw_vdbox_mfx_g12_X::MFD_AVC_BSD_OBJECT_CMD::byteSize +
494 mhw_vdbox_mfx_g12_X::MFD_AVC_DPB_STATE_CMD::byteSize +
495 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize;
496
497 patchListMaxSize =
498 PATCH_LIST_COMMAND(MFX_AVC_SLICE_STATE_CMD) +
499 PATCH_LIST_COMMAND(MFD_AVC_BSD_OBJECT_CMD) +
500 PATCH_LIST_COMMAND(MFD_AVC_DPB_STATE_CMD) +
501 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
502
503 if (isModeSpecific)
504 {
505 // isModeSpecific = bShortFormat for AVC decode
506 maxSize +=
507 mhw_vdbox_mfx_g12_X::MFD_AVC_DPB_STATE_CMD::byteSize +
508 mhw_vdbox_mfx_g12_X::MFD_AVC_SLICEADDR_CMD::byteSize;
509
510 patchListMaxSize +=
511 PATCH_LIST_COMMAND(MFD_AVC_DPB_STATE_CMD) +
512 PATCH_LIST_COMMAND(MFD_AVC_SLICEADDR_CMD);
513 }
514 else
515 {
516 maxSize +=
517 (2 * mhw_vdbox_mfx_g12_X::MFX_AVC_REF_IDX_STATE_CMD::byteSize) +
518 (2 * mhw_vdbox_mfx_g12_X::MFX_AVC_WEIGHTOFFSET_STATE_CMD::byteSize);
519
520 patchListMaxSize +=
521 (2 * PATCH_LIST_COMMAND(MFX_AVC_REF_IDX_STATE_CMD)) +
522 (2 * PATCH_LIST_COMMAND(MFX_AVC_WEIGHTOFFSET_STATE_CMD));
523 }
524 }
525 else // CODECHAL_ENCODE_MODE_AVC
526 {
527 // 1 PAK_INSERT_OBJECT inserted for every end of frame/stream with 1 DW payload
528 maxSize = mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD::byteSize + sizeof(uint32_t);
529 patchListMaxSize = PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD);
530
531 if (isModeSpecific)
532 {
533 // isModeSpecific = bSingleTaskPhaseSupported for AVC encode
534 maxSize += (2 * mhw_mi_g12_X::MI_BATCH_BUFFER_START_CMD::byteSize);
535 patchListMaxSize += (2 * PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD));
536 }
537 else
538 {
539 maxSize +=
540 (2 * mhw_vdbox_mfx_g12_X::MFX_AVC_REF_IDX_STATE_CMD::byteSize) +
541 (2 * mhw_vdbox_mfx_g12_X::MFX_AVC_WEIGHTOFFSET_STATE_CMD::byteSize) +
542 mhw_vdbox_mfx_g12_X::MFX_AVC_SLICE_STATE_CMD::byteSize +
543 MHW_VDBOX_PAK_SLICE_HEADER_OVERFLOW_SIZE + // slice header payload
544 (2 * mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD::byteSize) +
545 mhw_mi_g12_X::MI_BATCH_BUFFER_START_CMD::byteSize +
546 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize;
547
548 patchListMaxSize +=
549 (2 * PATCH_LIST_COMMAND(MFX_AVC_REF_IDX_STATE_CMD)) +
550 (2 * PATCH_LIST_COMMAND(MFX_AVC_WEIGHTOFFSET_STATE_CMD)) +
551 PATCH_LIST_COMMAND(MFX_AVC_SLICE_STATE_CMD) +
552 (2 * PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD)) +
553 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD) +
554 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
555 }
556 }
557 }
558 else if (standard == CODECHAL_VC1)
559 {
560 if (mode == CODECHAL_DECODE_MODE_VC1VLD)
561 {
562 maxSize =
563 mhw_vdbox_mfx_g12_X::MFD_VC1_BSD_OBJECT_CMD::byteSize;
564
565 patchListMaxSize =
566 PATCH_LIST_COMMAND(MFD_VC1_BSD_OBJECT_CMD);
567 }
568 else if (mode == CODECHAL_DECODE_MODE_VC1IT)
569 {
570 maxSize =
571 sizeof(MFD_VC1_IT_OBJECT_CMD);
572
573 patchListMaxSize =
574 PATCH_LIST_COMMAND(MFD_VC1_IT_OBJECT_CMD);
575 }
576 }
577 else if (standard == CODECHAL_MPEG2)
578 {
579 if (mode == CODECHAL_DECODE_MODE_MPEG2VLD)
580 {
581 maxSize =
582 mhw_vdbox_mfx_g12_X::MFD_MPEG2_BSD_OBJECT_CMD::byteSize ;
583
584 patchListMaxSize =
585 PATCH_LIST_COMMAND(MFD_MPEG2_BSD_OBJECT_CMD);
586 }
587 else if (mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
588 {
589 maxSize =
590 sizeof(MFD_MPEG2_IT_OBJECT_CMD);
591
592 patchListMaxSize =
593 PATCH_LIST_COMMAND(MFD_MPEG2_IT_OBJECT_CMD);
594 }
595 }
596 else if (standard == CODECHAL_VP8)
597 {
598 maxSize =
599 mhw_vdbox_mfx_g12_X::MFD_VP8_BSD_OBJECT_CMD::byteSize;
600
601 patchListMaxSize +=
602 PATCH_LIST_COMMAND(MFD_VP8_BSD_OBJECT_CMD);
603 }
604 else if (standard == CODECHAL_JPEG)
605 {
606 maxSize +=
607 mhw_vdbox_mfx_g12_X::MFX_FQM_STATE_CMD::byteSize * 3 +
608 mhw_vdbox_mfx_g12_X::MFC_JPEG_HUFF_TABLE_STATE_CMD::byteSize * 2 +
609 mhw_vdbox_mfx_g12_X::MFC_JPEG_SCAN_OBJECT_CMD::byteSize +
610 mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD::byteSize * 10;
611 }
612 else
613 {
614 MHW_ASSERTMESSAGE("Unsupported decode mode.");
615 eStatus = MOS_STATUS_UNKNOWN;
616 }
617
618 *commandsSize = maxSize;
619 *patchListSize = patchListMaxSize;
620
621 return eStatus;
622 }
623
624 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxPipeModeSelectCmd(
625 PMOS_COMMAND_BUFFER cmdBuffer,
626 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
627 {
628 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
629
630 MHW_FUNCTION_ENTER;
631
632 MHW_MI_CHK_NULL(m_osInterface);
633 MHW_MI_CHK_NULL(cmdBuffer);
634 MHW_MI_CHK_NULL(params);
635
636 //for gen 12, we need to add MFX wait for both KIN and VRT before and after MFX Pipemode select...
637 MHW_MI_CHK_STATUS(m_MiInterface->AddMfxWaitCmd(cmdBuffer, nullptr, true));
638
639 mhw_vdbox_mfx_g12_X::MFX_PIPE_MODE_SELECT_CMD cmd;
640
641 MHW_MI_CHK_STATUS(m_cpInterface->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)&cmd));
642
643 cmd.DW1.StreamOutEnable = params->bStreamOutEnabled;
644 cmd.DW1.DeblockerStreamOutEnable = params->bDeblockerStreamOutEnable;
645
646 if (m_decodeInUse)
647 {
648 cmd.DW1.PreDeblockingOutputEnablePredeblockoutenable = params->bPreDeblockOutEnable;
649 cmd.DW1.PostDeblockingOutputEnablePostdeblockoutenable = params->bPostDeblockOutEnable;
650 cmd.DW1.CodecSelect = decoderCodec;
651 cmd.DW1.DecoderShortFormatMode = !params->bShortFormatInUse;
652 cmd.DW2.Vlf720IOddHeightInVc1Mode = params->bVC1OddFrameHeight;
653
654 if (CodecHalIsDecodeModeVLD(params->Mode))
655 {
656 cmd.DW1.DecoderModeSelect = mfxDecoderModeVld;
657 }
658 else if (CodecHalIsDecodeModeIT(params->Mode))
659 {
660 cmd.DW1.DecoderModeSelect = mfxDecoderModeIt;
661 }
662
663 cmd.DW4.MediaSoftResetCounterPer1000Clocks = cmd.MEDIA_SOFT_RESET_COUNTER_PER_1000_CLOCKS_DISABLE;
664 #if (_DEBUG || _RELEASE_INTERNAL)
665 if (m_osInterface)
666 {
667 if (m_osInterface->bSoftReset)
668 {
669 cmd.DW4.MediaSoftResetCounterPer1000Clocks = cmd.MEDIA_SOFT_RESET_COUNTER_PER_1000_CLOCKS_ENABLE;
670 }
671 else
672 {
673 cmd.DW4.MediaSoftResetCounterPer1000Clocks = cmd.MEDIA_SOFT_RESET_COUNTER_PER_1000_CLOCKS_DISABLE;
674 }
675 }
676 #endif
677 }
678 else
679 {
680 cmd.DW1.DeblockerStreamOutEnable = params->bDeblockerStreamOutEnable;
681 cmd.DW1.PostDeblockingOutputEnablePostdeblockoutenable = params->bPostDeblockOutEnable;
682 cmd.DW1.PreDeblockingOutputEnablePredeblockoutenable = params->bPreDeblockOutEnable;
683 cmd.DW1.CodecSelect = encoderCodec;
684 cmd.DW1.DecoderShortFormatMode = !params->bShortFormatInUse; // This bit is set to be long format in order for HW to not change next slice X and Y position in encoder mode
685 }
686
687 cmd.DW1.StandardSelect = CodecHal_GetStandardFromMode(params->Mode);
688
689 if (params->bVdencEnabled)
690 {
691 cmd.DW1.VdencMode = 1;
692 // Enable 4xDS in PAK for VDENC HME
693 cmd.DW1.ScaledSurfaceEnable = 1;
694 // Disable PAK streamout from previous PAK pass, as VDEnc does not support standalone PAK
695 cmd.DW1.StreamOutEnable = 0;
696 // Enable PAK statistics streamout
697 cmd.DW1.FrameStatisticsStreamoutEnable = 1;
698 }
699
700 if (params->bStreamOutEnabledExtEnabled)
701 {
702 // Enable PerMB streamOut PAK Statistics
703 cmd.DW1.StreamOutEnable = 1;
704 cmd.DW1.ExtendedStreamOutEnable = true;
705 }
706 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
707
708 //for gen 12, we need to add MFX wait for both KIN and VRT before and after MFX Pipemode select...
709 MHW_MI_CHK_STATUS(m_MiInterface->AddMfxWaitCmd(cmdBuffer, nullptr, true));
710
711 return eStatus;
712 }
713
714 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxSurfaceCmd(
715 PMOS_COMMAND_BUFFER cmdBuffer,
716 PMHW_VDBOX_SURFACE_PARAMS params)
717 {
718 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
719
720 MHW_FUNCTION_ENTER;
721
722 MHW_MI_CHK_NULL(m_osInterface);
723 MHW_MI_CHK_NULL(cmdBuffer);
724 MHW_MI_CHK_NULL(params);
725
726 uint32_t uvPlaneAlignment;
727 if (params->ucSurfaceStateId == CODECHAL_MFX_SRC_SURFACE_ID)
728 {
729 uvPlaneAlignment = MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9;
730 }
731 else if ((params->ucSurfaceStateId == CODECHAL_MFX_REF_SURFACE_ID) || params->ucSurfaceStateId == CODECHAL_MFX_DSRECON_SURFACE_ID)
732 {
733 uvPlaneAlignment = params->dwUVPlaneAlignment ? params->dwUVPlaneAlignment : MHW_VDBOX_MFX_RECON_UV_PLANE_ALIGNMENT;
734 }
735 else
736 {
737 uvPlaneAlignment = MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY;
738 }
739
740 mhw_vdbox_mfx_g12_X::MFX_SURFACE_STATE_CMD cmd;
741 cmd.DW1.SurfaceId = params->ucSurfaceStateId;
742
743 // Take actual height/width from SPS in case of AVC encode and source surface
744 if (params->Mode == CODECHAL_ENCODE_MODE_AVC && params->ucSurfaceStateId == CODECHAL_MFX_SRC_SURFACE_ID)
745 {
746 cmd.DW2.Height = params->dwActualHeight - 1;
747 cmd.DW2.Width = params->dwActualWidth - 1;
748 }
749 else
750 {
751 cmd.DW2.Height = params->psSurface->dwHeight - 1;
752 cmd.DW2.Width = params->psSurface->dwWidth - 1;
753 }
754
755 cmd.DW3.TileWalk = mhw_vdbox_mfx_g12_X::MFX_SURFACE_STATE_CMD::TILE_WALK_YMAJOR;
756 cmd.DW3.TiledSurface = 1;
757 cmd.DW3.InterleaveChroma = 1;
758 cmd.DW3.SurfacePitch = params->psSurface->dwPitch - 1;
759 cmd.DW3.SurfaceFormat = MosToMediaStateFormat(params->psSurface->Format);
760 cmd.DW3.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
761
762 if (cmd.DW3.TiledSurface)
763 {
764 cmd.DW3.TileWalk = (params->psSurface->TileType);
765 }
766
767 if (params->psSurface->Format == Format_P8) // monochrome format
768 {
769 cmd.DW3.InterleaveChroma = 0;
770 }
771
772 if (params->Mode == CODECHAL_DECODE_MODE_JPEG)
773 {
774 // this parameter must always be 0 for JPEG regardless of the YUV format
775 cmd.DW3.InterleaveChroma = 0;
776
777 // Separate function for JPEG decode because this surface format should match with that programmed
778 // in JPEG Picture State
779 cmd.DW3.SurfaceFormat = GetJpegDecodeFormat(params->psSurface->Format);
780
781 }
782
783 cmd.DW4.YOffsetForUCb = cmd.DW5.YOffsetForVCr =
784 MOS_ALIGN_CEIL((params->psSurface->UPlaneOffset.iSurfaceOffset -params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.U.YOffset, uvPlaneAlignment);
785
786 if (IsVPlanePresent(params->psSurface->Format))
787 {
788 cmd.DW5.YOffsetForVCr =
789 MOS_ALIGN_CEIL((params->psSurface->VPlaneOffset.iSurfaceOffset -params->psSurface->dwOffset)/params->psSurface->dwPitch + params->psSurface->RenderOffset.YUV.V.YOffset, uvPlaneAlignment);
790 }
791
792 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
793
794 return eStatus;
795 }
796
797 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxPipeBufAddrCmd(
798 PMOS_COMMAND_BUFFER cmdBuffer,
799 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
800 {
801 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
802
803 MHW_FUNCTION_ENTER;
804
805 MHW_MI_CHK_NULL(m_osInterface);
806 MHW_MI_CHK_NULL(cmdBuffer);
807 MHW_MI_CHK_NULL(params);
808
809 MHW_RESOURCE_PARAMS resourceParams;
810 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
811 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
812 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
813
814 mhw_vdbox_mfx_g12_X::MFX_PIPE_BUF_ADDR_STATE_CMD cmd;
815
816 // Encoding uses both surfaces regardless of deblocking status
817 if (params->psPreDeblockSurface != nullptr)
818 {
819 cmd.DW3.MemoryObjectControlState =
820 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Value;
821 cmd.DW3.PreDeblockingMemoryCompressionEnable =
822 (params->PreDeblockSurfMmcState == MOS_MEMCOMP_RC || params->PreDeblockSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0;
823 cmd.DW3.PreDeblockingMemoryCompressionType = (params->PreDeblockSurfMmcState == MOS_MEMCOMP_RC) ? 1 : 0;
824
825 cmd.DW3.PreDeblockingTiledResourceMode = Mhw_ConvertToTRMode(params->psPreDeblockSurface->TileType);
826
827 resourceParams.presResource = &(params->psPreDeblockSurface->OsResource);
828 resourceParams.dwOffset = params->psPreDeblockSurface->dwOffset;
829 resourceParams.pdwCmd = &(cmd.DW1.Value);
830 resourceParams.dwLocationInCmd = 1;
831 resourceParams.bIsWritable = true;
832
833 MHW_MI_CHK_STATUS(AddResourceToCmd(
834 m_osInterface,
835 cmdBuffer,
836 &resourceParams));
837 }
838
839 if (params->psPostDeblockSurface != nullptr)
840 {
841 cmd.DW6.MemoryObjectControlState =
842 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_POST_DEBLOCKING_CODEC].Value;
843 cmd.DW6.PostDeblockingMemoryCompressionEnable =
844 (params->PostDeblockSurfMmcState == MOS_MEMCOMP_RC || params->PostDeblockSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0;
845 cmd.DW6.PostDeblockingMemoryCompressionType = (params->PostDeblockSurfMmcState == MOS_MEMCOMP_RC) ? 1 : 0;
846
847 cmd.DW6.PostDeblockingTiledResourceMode = Mhw_ConvertToTRMode(params->psPostDeblockSurface->TileType);
848
849 resourceParams.presResource = &(params->psPostDeblockSurface->OsResource);
850 resourceParams.dwOffset = params->psPostDeblockSurface->dwOffset;
851 resourceParams.pdwCmd = &(cmd.DW4.Value);
852 resourceParams.dwLocationInCmd = 4;
853 resourceParams.bIsWritable = true;
854
855 MHW_MI_CHK_STATUS(AddResourceToCmd(
856 m_osInterface,
857 cmdBuffer,
858 &resourceParams));
859 }
860
861 if (params->psRawSurface != nullptr)
862 {
863 if (!m_decodeInUse)
864 {
865 cmd.DW9.MemoryObjectControlState =
866 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
867 cmd.DW9.OriginalUncompressedPictureMemoryCompressionEnable =
868 (params->RawSurfMmcState == MOS_MEMCOMP_RC || params->RawSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0;
869 cmd.DW9.OriginalUncompressedPictureMemoryCompressionType = (params->RawSurfMmcState == MOS_MEMCOMP_RC) ? 1 : 0;
870 }
871 else
872 {
873 cmd.DW9.MemoryObjectControlState =
874 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_DECODE].Value;
875 }
876
877 cmd.DW9.OriginalUncompressedPictureTiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
878
879 resourceParams.presResource = &params->psRawSurface->OsResource;
880 resourceParams.dwOffset = params->psRawSurface->dwOffset;
881 resourceParams.pdwCmd = &(cmd.DW7.Value);
882 resourceParams.dwLocationInCmd = 7;
883 resourceParams.bIsWritable = false;
884
885 MHW_MI_CHK_STATUS(AddResourceToCmd(
886 m_osInterface,
887 cmdBuffer,
888 &resourceParams));
889 }
890
891 if (params->presStreamOutBuffer != nullptr)
892 {
893 cmd.DW12.MemoryObjectControlState =
894 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
895
896 resourceParams.presResource = params->presStreamOutBuffer;
897 resourceParams.dwOffset = 0;
898 resourceParams.pdwCmd = &(cmd.DW10.Value);
899 resourceParams.dwLocationInCmd = 10;
900 resourceParams.bIsWritable = true;
901
902 MHW_MI_CHK_STATUS(AddResourceToCmd(
903 m_osInterface,
904 cmdBuffer,
905 &resourceParams));
906
907 if (!m_decodeInUse)
908 {
909 cmd.DW54.MemoryObjectControlState =
910 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
911
912 resourceParams.presResource = params->presStreamOutBuffer;
913 resourceParams.dwOffset = 0;
914 resourceParams.pdwCmd = &(cmd.DW52.Value);
915 resourceParams.dwLocationInCmd = 52;
916 resourceParams.bIsWritable = true;
917
918 MHW_MI_CHK_STATUS(AddResourceToCmd(
919 m_osInterface,
920 cmdBuffer,
921 &resourceParams));
922 }
923 }
924
925 if (m_intraRowstoreCache.bEnabled)
926 {
927 cmd.DW15.IntraRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
928 cmd.DW13.IntraRowStoreScratchBufferBaseAddress = m_intraRowstoreCache.dwAddress;
929 }
930 else if (params->presMfdIntraRowStoreScratchBuffer != nullptr)
931 {
932 cmd.DW15.MemoryObjectControlState =
933 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_INTRA_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
934
935 cmd.DW15.IntraRowStoreScratchBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
936
937 resourceParams.presResource = params->presMfdIntraRowStoreScratchBuffer;
938 resourceParams.dwOffset = 0;
939 resourceParams.pdwCmd = &(cmd.DW13.Value);
940 resourceParams.dwLocationInCmd = 13;
941 resourceParams.bIsWritable = true;
942
943 MHW_MI_CHK_STATUS(AddResourceToCmd(
944 m_osInterface,
945 cmdBuffer,
946 &resourceParams));
947 }
948
949 if (m_deblockingFilterRowstoreCache.bEnabled)
950 {
951 cmd.DW18.DeblockingFilterRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
952 cmd.DW16.DeblockingFilterRowStoreScratchBaseAddress =
953 m_deblockingFilterRowstoreCache.dwAddress;
954 }
955 else if (params->presMfdDeblockingFilterRowStoreScratchBuffer != nullptr)
956 {
957 cmd.DW18.MemoryObjectControlState =
958 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
959 cmd.DW18.DeblockingFilterRowStoreScratchMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
960
961 resourceParams.presResource = params->presMfdDeblockingFilterRowStoreScratchBuffer;
962 resourceParams.dwOffset = 0;
963 resourceParams.pdwCmd = &(cmd.DW16.Value);
964 resourceParams.dwLocationInCmd = 16;
965 resourceParams.bIsWritable = true;
966
967 MHW_MI_CHK_STATUS(AddResourceToCmd(
968 m_osInterface,
969 cmdBuffer,
970 &resourceParams));
971 }
972
973 PMOS_RESOURCE *references = params->presReferences;
974 uint32_t numRefIdx = CODEC_MAX_NUM_REF_FRAME;
975 uint32_t step = 1;
976
977 // When one on one ref idx mapping is enabled, add active vdenc references into cmd
978 // instead of full ref list in picture paramters
979 if (params->oneOnOneMapping)
980 {
981 references = params->presVdencReferences;
982 step = 2;
983 }
984
985 bool firstRefPic = true;
986 for (uint32_t i = 0; i < numRefIdx; i++)
987 {
988 if (references[i] != nullptr && references[i]->pGmmResInfo != nullptr)
989 {
990 MOS_SURFACE details;
991 MOS_ZeroMemory(&details, sizeof(details));
992 details.Format = Format_Invalid;
993 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, references[i], &details));
994
995
996 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
997
998 if (params->bMmcEnabled && m_decodeInUse)
999 {
1000 MHW_MI_CHK_STATUS(m_osInterface->pfnGetMemoryCompressionMode(
1001 m_osInterface, references[i], &mmcMode));
1002 }
1003 else
1004 {
1005 mmcMode = (params->PostDeblockSurfMmcState != MOS_MEMCOMP_DISABLED) ?
1006 params->PostDeblockSurfMmcState : params->PreDeblockSurfMmcState;
1007 }
1008
1009 if (mmcMode == MOS_MEMCOMP_RC || mmcMode == MOS_MEMCOMP_MC)
1010 {
1011 cmd.DW61.Value |= (MHW_MEDIA_MEMCOMP_ENABLED << (i * 2 * step)) | ((mmcMode == MOS_MEMCOMP_RC) << (i * 2 * step + 1));
1012 }
1013
1014 if (firstRefPic)
1015 {
1016 cmd.DW51.ReferencePictureTiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
1017 firstRefPic = false;
1018 }
1019
1020 resourceParams.presResource = references[i];
1021 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
1022 resourceParams.pdwCmd = &(cmd.Refpicbaseaddr[i * step].DW0_1.Value[0]);
1023 resourceParams.dwLocationInCmd = (i * 2 * step) + 19; // * 2 to account for QW rather than DW
1024 resourceParams.bIsWritable = false;
1025
1026 resourceParams.dwSharedMocsOffset = 51 - resourceParams.dwLocationInCmd;
1027
1028 MHW_MI_CHK_STATUS(AddResourceToCmd(
1029 m_osInterface,
1030 cmdBuffer,
1031 &resourceParams));
1032 }
1033 }
1034
1035 // There is only one control DW51 for all references
1036 cmd.DW51.MemoryObjectControlState =
1037 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
1038
1039 // Reset dwSharedMocsOffset
1040 resourceParams.dwSharedMocsOffset = 0;
1041
1042 if (params->presMacroblockIldbStreamOutBuffer1 != nullptr)
1043 {
1044 cmd.DW57.MacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
1045 cmd.DW57.MemoryObjectControlState =
1046 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
1047
1048 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer1;
1049 resourceParams.dwOffset = 0;
1050 resourceParams.pdwCmd = &(cmd.DW55.Value);
1051 resourceParams.dwLocationInCmd = 55;
1052 resourceParams.bIsWritable = true;
1053
1054 MHW_MI_CHK_STATUS(AddResourceToCmd(
1055 m_osInterface,
1056 cmdBuffer,
1057 &resourceParams));
1058 }
1059
1060 if (params->presMacroblockIldbStreamOutBuffer2 != nullptr)
1061 {
1062 cmd.DW60.SecondMacroblockIldbStreamoutBufferMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
1063 cmd.DW60.MemoryObjectControlState =
1064 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MACROBLOCK_ILDB_STREAM_OUT_BUFFER_CODEC].Value;
1065
1066 resourceParams.presResource = params->presMacroblockIldbStreamOutBuffer2;
1067 resourceParams.dwOffset = 0;
1068 resourceParams.pdwCmd = &(cmd.DW58.Value);
1069 resourceParams.dwLocationInCmd = 58;
1070 resourceParams.bIsWritable = true;
1071
1072 MHW_MI_CHK_STATUS(AddResourceToCmd(
1073 m_osInterface,
1074 cmdBuffer,
1075 &resourceParams));
1076 }
1077
1078 // Add 4xDS surface for VDENC
1079 if (params->bVdencEnabled && params->ps4xDsSurface != nullptr)
1080 {
1081 resourceParams.presResource = &params->ps4xDsSurface->OsResource;
1082 resourceParams.dwOffset = params->ps4xDsSurface->dwOffset;
1083 resourceParams.pdwCmd = &(cmd.DW62.Value);
1084 resourceParams.dwLocationInCmd = 62;
1085 resourceParams.bIsWritable = true;
1086
1087 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionEnable =
1088 (params->Ps4xDsSurfMmcState == MOS_MEMCOMP_RC || params->Ps4xDsSurfMmcState == MOS_MEMCOMP_MC) ? 1 : 0;
1089 cmd.DW64.ScaledReferenceSurfaceMemoryCompressionType =
1090 (params->Ps4xDsSurfMmcState == MOS_MEMCOMP_RC) ? 1 : 0;
1091
1092 cmd.DW64.ScaledReferenceSurfaceTiledResourceMode = Mhw_ConvertToTRMode(params->ps4xDsSurface->TileType);
1093
1094 cmd.DW64.ScaledReferenceSurfaceIndexToMemoryObjectControlStateMocsTables = GetScaledReferenceSurfaceCachePolicy();
1095
1096 MHW_MI_CHK_STATUS(AddResourceToCmd(
1097 m_osInterface,
1098 cmdBuffer,
1099 &resourceParams));
1100 }
1101
1102 if (params->presSliceSizeStreamOutBuffer != nullptr)
1103 {
1104 cmd.DW67.SlicesizeStreamoutDataDestinationIndexToMemoryObjectControlStateMocsTables =
1105 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
1106 cmd.DW67.SlicesizeStreamoutDataDestinationMemoryCompressionEnable = MHW_MEDIA_MEMCOMP_DISABLED;
1107
1108 resourceParams.presResource = params->presSliceSizeStreamOutBuffer;
1109 resourceParams.dwOffset = 0;
1110 resourceParams.pdwCmd = &(cmd.DW65.Value);
1111 resourceParams.dwLocationInCmd = 65;
1112 resourceParams.bIsWritable = true;
1113
1114 MHW_MI_CHK_STATUS(AddResourceToCmd(
1115 m_osInterface,
1116 cmdBuffer,
1117 &resourceParams));
1118 }
1119
1120 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1121
1122 return eStatus;
1123 }
1124
1125 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxIndObjBaseAddrCmd(
1126 PMOS_COMMAND_BUFFER cmdBuffer,
1127 PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params)
1128 {
1129 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1130
1131 MHW_FUNCTION_ENTER;
1132
1133 MHW_MI_CHK_NULL(m_osInterface);
1134 MHW_MI_CHK_NULL(cmdBuffer);
1135 MHW_MI_CHK_NULL(params);
1136
1137 PMOS_CONTEXT pOsContext = m_osInterface->pOsContext;
1138 MHW_MI_CHK_NULL(pOsContext);
1139
1140 MHW_RESOURCE_PARAMS resourceParams;
1141 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1142 resourceParams.dwLsbNum = MHW_VDBOX_MFX_UPPER_BOUND_STATE_SHIFT;
1143 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
1144
1145 mhw_vdbox_mfx_g12_X::MFX_IND_OBJ_BASE_ADDR_STATE_CMD cmd;
1146
1147 // mode specific settings
1148 if (CodecHalIsDecodeModeVLD(params->Mode) || (params->Mode == CODECHAL_ENCODE_MODE_VP8))
1149 {
1150 MHW_MI_CHK_NULL(params->presDataBuffer);
1151
1152 cmd.DW3.MemoryObjectControlState =
1153 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Value;
1154
1155 resourceParams.presResource = params->presDataBuffer;
1156 resourceParams.dwOffset = params->dwDataOffset;
1157 resourceParams.pdwCmd = &(cmd.DW1.Value);
1158 resourceParams.dwLocationInCmd = 1;
1159 resourceParams.dwSize = params->dwDataSize;
1160 resourceParams.bIsWritable = false;
1161
1162 // upper bound of the allocated resource will be set at 3 DW apart from address location
1163 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1164
1165 MHW_MI_CHK_STATUS(AddResourceToCmd(
1166 m_osInterface,
1167 cmdBuffer,
1168 &resourceParams));
1169
1170 if(HalOcaInterface::IsLargeResouceDumpSupported())
1171 {
1172 HalOcaInterface::OnIndirectState(*cmdBuffer, (MOS_CONTEXT_HANDLE)pOsContext, resourceParams.presResource, 0, true, 0);
1173 }
1174
1175 }
1176 else if (CodecHalIsDecodeModeIT(params->Mode))
1177 {
1178 MHW_MI_CHK_NULL(params->presDataBuffer);
1179
1180 cmd.DW13.MemoryObjectControlState =
1181 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE].Value;
1182
1183 resourceParams.presResource = params->presDataBuffer;
1184 resourceParams.dwOffset = params->dwDataOffset;
1185 resourceParams.pdwCmd = &(cmd.DW11.Value);
1186 resourceParams.dwLocationInCmd = 11;
1187 resourceParams.dwSize = params->dwDataSize;
1188 resourceParams.bIsWritable = false;
1189
1190 // upper bound of the allocated resource will be set at 3 DW apart from address location
1191 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1192
1193 MHW_MI_CHK_STATUS(AddResourceToCmd(
1194 m_osInterface,
1195 cmdBuffer,
1196 &resourceParams));
1197 }
1198
1199 if (params->presMvObjectBuffer)
1200 {
1201 cmd.DW8.MemoryObjectControlState =
1202 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC].Value;
1203
1204 resourceParams.presResource = params->presMvObjectBuffer;
1205 resourceParams.dwOffset = params->dwMvObjectOffset;
1206 resourceParams.pdwCmd = &(cmd.DW6.Value);
1207 resourceParams.dwLocationInCmd = 6;
1208 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwMvObjectSize, 0x1000);
1209 resourceParams.bIsWritable = false;
1210
1211 // upper bound of the allocated resource will be set at 3 DW apart from address location
1212 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1213
1214 MHW_MI_CHK_STATUS(AddResourceToCmd(
1215 m_osInterface,
1216 cmdBuffer,
1217 &resourceParams));
1218 }
1219
1220 if (params->presPakBaseObjectBuffer)
1221 {
1222 cmd.DW23.MemoryObjectControlState =
1223 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
1224
1225 resourceParams.presResource = params->presPakBaseObjectBuffer;
1226 resourceParams.dwOffset = params->presPakBaseObjectBuffer->dwResourceOffset;
1227 resourceParams.pdwCmd = &(cmd.DW21.Value);
1228 resourceParams.dwLocationInCmd = 21;
1229 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwPakBaseObjectSize, 0x1000);
1230 resourceParams.bIsWritable = true;
1231
1232 // upper bound of the allocated resource will be set at 3 DW apart from address location
1233 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1234
1235 MHW_MI_CHK_STATUS(AddResourceToCmd(
1236 m_osInterface,
1237 cmdBuffer,
1238 &resourceParams));
1239 }
1240
1241 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1242
1243 return eStatus;
1244 }
1245
1246 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxBspBufBaseAddrCmd(
1247 PMOS_COMMAND_BUFFER cmdBuffer,
1248 PMHW_VDBOX_BSP_BUF_BASE_ADDR_PARAMS params)
1249 {
1250 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1251
1252 MHW_FUNCTION_ENTER;
1253
1254 MHW_MI_CHK_NULL(m_osInterface);
1255 MHW_MI_CHK_NULL(cmdBuffer);
1256 MHW_MI_CHK_NULL(params);
1257
1258 MHW_RESOURCE_PARAMS resourceParams;
1259 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1260 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
1261 resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR;
1262
1263 mhw_vdbox_mfx_g12_X::MFX_BSP_BUF_BASE_ADDR_STATE_CMD cmd;
1264
1265 if (m_bsdMpcRowstoreCache.bEnabled) // mbaff and non mbaff mode for all resolutions
1266 {
1267 cmd.DW3.BsdMpcRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
1268 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = m_bsdMpcRowstoreCache.dwAddress;
1269 }
1270 else if (params->presBsdMpcRowStoreScratchBuffer)
1271 {
1272 cmd.DW3.MemoryObjectControlState =
1273 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
1274 cmd.DW1.BsdMpcRowStoreScratchBufferBaseAddressReadWrite = 0;
1275
1276 resourceParams.presResource = params->presBsdMpcRowStoreScratchBuffer;
1277 resourceParams.dwOffset = 0;
1278 resourceParams.pdwCmd = &(cmd.DW1.Value);
1279 resourceParams.dwLocationInCmd = 1;
1280 resourceParams.bIsWritable = true;
1281
1282 MHW_MI_CHK_STATUS(AddResourceToCmd(
1283 m_osInterface,
1284 cmdBuffer,
1285 &resourceParams));
1286 }
1287
1288 if (m_mprRowstoreCache.bEnabled)
1289 {
1290 cmd.DW6.MprRowStoreScratchBufferCacheSelect = BUFFER_TO_INTERNALMEDIASTORAGE;
1291 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = m_mprRowstoreCache.dwAddress;
1292 }
1293 else if (params->presMprRowStoreScratchBuffer)
1294 {
1295 cmd.DW6.MemoryObjectControlState =
1296 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MPR_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
1297 cmd.DW4.MprRowStoreScratchBufferBaseAddressReadWriteDecoderOnly = 0;
1298
1299 resourceParams.presResource = params->presMprRowStoreScratchBuffer;
1300 resourceParams.dwOffset = 0;
1301 resourceParams.pdwCmd = &(cmd.DW4.Value);
1302 resourceParams.dwLocationInCmd = 4;
1303 resourceParams.bIsWritable = true;
1304
1305 MHW_MI_CHK_STATUS(AddResourceToCmd(
1306 m_osInterface,
1307 cmdBuffer,
1308 &resourceParams));
1309 }
1310
1311 if (params->presBitplaneBuffer)
1312 {
1313 cmd.DW9.MemoryObjectControlState =
1314 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_BITPLANE_READ_CODEC].Value;
1315
1316 resourceParams.presResource = params->presBitplaneBuffer;
1317 resourceParams.dwOffset = 0;
1318 resourceParams.pdwCmd = &(cmd.DW7.Value);
1319 resourceParams.dwLocationInCmd = 7;
1320 resourceParams.bIsWritable = false;
1321
1322 MHW_MI_CHK_STATUS(AddResourceToCmd(
1323 m_osInterface,
1324 cmdBuffer,
1325 &resourceParams));
1326 }
1327
1328 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1329
1330 return eStatus;
1331 }
1332
1333 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxDecodeAvcImgCmd(
1334 PMOS_COMMAND_BUFFER cmdBuffer,
1335 PMHW_BATCH_BUFFER batchBuffer,
1336 PMHW_VDBOX_AVC_IMG_PARAMS params)
1337 {
1338 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1339
1340 MHW_FUNCTION_ENTER;
1341
1342 MOS_UNUSED(batchBuffer);
1343
1344 MHW_MI_CHK_NULL(m_osInterface);
1345 MHW_MI_CHK_NULL(cmdBuffer);
1346 MHW_MI_CHK_NULL(params);
1347 MHW_MI_CHK_NULL(params->pAvcPicParams);
1348
1349 auto avcPicParams = params->pAvcPicParams;
1350
1351 mhw_vdbox_mfx_g12_X::MFX_AVC_IMG_STATE_CMD cmd;
1352
1353 uint32_t numMBs =
1354 (avcPicParams->pic_height_in_mbs_minus1 + 1) *
1355 (avcPicParams->pic_width_in_mbs_minus1 + 1);
1356
1357 cmd.DW1.FrameSize = numMBs;
1358 cmd.DW2.FrameHeight = avcPicParams->pic_height_in_mbs_minus1;
1359 cmd.DW2.FrameWidth = avcPicParams->pic_width_in_mbs_minus1;
1360 cmd.DW3.SecondChromaQpOffset = avcPicParams->second_chroma_qp_index_offset;
1361 cmd.DW3.FirstChromaQpOffset = avcPicParams->chroma_qp_index_offset;
1362 cmd.DW3.WeightedPredFlag = avcPicParams->pic_fields.weighted_pred_flag;
1363 cmd.DW3.WeightedBipredIdc = avcPicParams->pic_fields.weighted_bipred_idc;
1364 cmd.DW3.ImgstructImageStructureImgStructure10 =
1365 ((avcPicParams->CurrPic.PicFlags == PICTURE_FRAME) ?
1366 avcFrame : (CodecHal_PictureIsTopField(avcPicParams->CurrPic) ?
1367 avcTopField : avcBottomField));
1368 cmd.DW4.Chromaformatidc = avcPicParams->seq_fields.chroma_format_idc;
1369 cmd.DW4.Entropycodingflag = avcPicParams->pic_fields.entropy_coding_mode_flag;
1370 cmd.DW4.Imgdisposableflag = !avcPicParams->pic_fields.reference_pic_flag;
1371 cmd.DW4.Constrainedipredflag = avcPicParams->pic_fields.constrained_intra_pred_flag;
1372 cmd.DW4.Direct8X8Infflag = avcPicParams->seq_fields.direct_8x8_inference_flag;
1373 cmd.DW4.Transform8X8Flag = avcPicParams->pic_fields.transform_8x8_mode_flag;
1374 cmd.DW4.Framembonlyflag = avcPicParams->seq_fields.frame_mbs_only_flag;
1375 cmd.DW4.Mbaffflameflag =
1376 avcPicParams->seq_fields.mb_adaptive_frame_field_flag && !avcPicParams->pic_fields.field_pic_flag;
1377 cmd.DW4.Fieldpicflag = avcPicParams->pic_fields.field_pic_flag;
1378
1379 cmd.DW5.TrellisQuantizationChromaDisableTqchromadisable = true;
1380 cmd.DW5.TrellisQuantizationRoundingTqr = 0;
1381
1382 cmd.DW13.CurrentPictureHasPerformedMmco5 = 0;
1383 cmd.DW13.NumberOfReferenceFrames = params->ucActiveFrameCnt;
1384 // These fields should be NumRefIdx(L0 or L1) Active - 1 at picture level
1385 // But hardware expects the data without the minus 1 to keep this field consistent with
1386 // NumRefIdxL0 and NumRefIdxL1 which appears at slice level. Thus the addition of 1
1387 cmd.DW13.NumberOfActiveReferencePicturesFromL0 = avcPicParams->num_ref_idx_l0_active_minus1 + 1;
1388 cmd.DW13.NumberOfActiveReferencePicturesFromL1 = avcPicParams->num_ref_idx_l1_active_minus1 + 1;
1389
1390 cmd.DW13.InitialQpValue = avcPicParams->pic_init_qp_minus26;
1391
1392 cmd.DW14.Log2MaxFrameNumMinus4 = avcPicParams->seq_fields.log2_max_frame_num_minus4;
1393 cmd.DW14.Log2MaxPicOrderCntLsbMinus4 = avcPicParams->seq_fields.log2_max_pic_order_cnt_lsb_minus4;
1394 cmd.DW14.DeblockingFilterControlPresentFlag = avcPicParams->pic_fields.deblocking_filter_control_present_flag;
1395 cmd.DW14.NumSliceGroupsMinus1 = avcPicParams->num_slice_groups_minus1;
1396 cmd.DW14.RedundantPicCntPresentFlag = avcPicParams->pic_fields.redundant_pic_cnt_present_flag;
1397 cmd.DW14.PicOrderPresentFlag = avcPicParams->pic_fields.pic_order_present_flag;
1398 cmd.DW14.SliceGroupMapType = avcPicParams->slice_group_map_type;
1399 cmd.DW14.PicOrderCntType = avcPicParams->seq_fields.pic_order_cnt_type;
1400 cmd.DW14.DeltaPicOrderAlwaysZeroFlag = avcPicParams->seq_fields.delta_pic_order_always_zero_flag;
1401 cmd.DW15.CurrPicFrameNum = avcPicParams->frame_num;
1402 cmd.DW15.SliceGroupChangeRate = avcPicParams->slice_group_change_rate_minus1;
1403
1404 auto mvcExtPicParams = params->pMvcExtPicParams;
1405 if (mvcExtPicParams)
1406 {
1407 cmd.DW16.CurrentFrameViewId = mvcExtPicParams->CurrViewID;
1408 cmd.DW16.MaxViewIdxl0 = mvcExtPicParams->NumInterViewRefsL0;
1409 cmd.DW16.MaxViewIdxl1 = mvcExtPicParams->NumInterViewRefsL1;
1410 cmd.DW16.InterViewOrderDisable = 0;
1411 }
1412
1413 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1414
1415 return eStatus;
1416 }
1417
1418 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxEncodeAvcImgCmd(
1419 PMOS_COMMAND_BUFFER cmdBuffer,
1420 PMHW_BATCH_BUFFER batchBuffer,
1421 PMHW_VDBOX_AVC_IMG_PARAMS params)
1422 {
1423 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1424
1425 MHW_FUNCTION_ENTER;
1426
1427 MHW_MI_CHK_NULL(params);
1428 MHW_MI_CHK_NULL(params->pEncodeAvcSeqParams);
1429 MHW_MI_CHK_NULL(params->pEncodeAvcPicParams);
1430
1431 if (cmdBuffer == nullptr && batchBuffer == nullptr)
1432 {
1433 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
1434 return MOS_STATUS_INVALID_PARAMETER;
1435 }
1436
1437 auto avcSeqParams = params->pEncodeAvcSeqParams;
1438 auto avcPicParams = params->pEncodeAvcPicParams;
1439
1440 mhw_vdbox_mfx_g12_X::MFX_AVC_IMG_STATE_CMD cmd;
1441
1442 uint32_t numMBs = params->wPicWidthInMb * params->wPicHeightInMb;
1443 cmd.DW1.FrameSize = (numMBs > 0xFFFF) ? 0xFFFF : numMBs;
1444
1445 cmd.DW2.FrameHeight = params->wPicHeightInMb - 1;
1446 cmd.DW2.FrameWidth = params->wPicWidthInMb - 1;
1447
1448 cmd.DW3.ImgstructImageStructureImgStructure10 =
1449 (CodecHal_PictureIsFrame(avcPicParams->CurrOriginalPic) ?
1450 avcFrame : (CodecHal_PictureIsTopField(avcPicParams->CurrOriginalPic) ?
1451 avcTopField : avcBottomField));
1452
1453 cmd.DW3.WeightedBipredIdc = avcPicParams->weighted_bipred_idc;
1454 cmd.DW3.WeightedPredFlag = avcPicParams->weighted_pred_flag;
1455
1456 cmd.DW3.FirstChromaQpOffset = avcPicParams->chroma_qp_index_offset;
1457 cmd.DW3.SecondChromaQpOffset = avcPicParams->second_chroma_qp_index_offset;
1458
1459 // Enable RhoDomain RC in PAK statistics
1460 cmd.DW3.RhodomainRateControlEnable = params->bVdencEnabled;
1461
1462 cmd.DW4.Fieldpicflag =
1463 CodecHal_PictureIsField(avcPicParams->CurrOriginalPic);
1464 cmd.DW4.Mbaffflameflag = avcSeqParams->mb_adaptive_frame_field_flag;
1465 cmd.DW4.Framembonlyflag = avcSeqParams->frame_mbs_only_flag;
1466 cmd.DW4.Transform8X8Flag = avcPicParams->transform_8x8_mode_flag;
1467 cmd.DW4.Direct8X8Infflag = avcSeqParams->direct_8x8_inference_flag;
1468 cmd.DW4.Constrainedipredflag = avcPicParams->constrained_intra_pred_flag;
1469 cmd.DW4.Entropycodingflag = avcPicParams->entropy_coding_mode_flag;
1470 cmd.DW4.Chromaformatidc = avcSeqParams->chroma_format_idc;
1471 cmd.DW4.Mbmvformatflag = 1;
1472 cmd.DW4.Mvunpackedflag = 1;
1473
1474 cmd.DW4.Loadslicepointerflag = 0;
1475 cmd.DW4.Mbstatenabled = 0; // Disable for the first pass
1476 if ((params->dwMaxFrameSize > 0) && params->currPass && params->pDeltaQp)
1477 {
1478 cmd.DW4.Mbstatenabled = 1;
1479 }
1480 cmd.DW4.Minframewsize = 0;
1481
1482 cmd.DW5.IntrambmaxbitflagIntrambmaxsizereportmask = 1;
1483 cmd.DW5.IntermbmaxbitflagIntermbmaxsizereportmask = 1;
1484 cmd.DW5.FrameszoverflagFramebitratemaxreportmask = 1;
1485 cmd.DW5.FrameszunderflagFramebitrateminreportmask = 1;
1486 cmd.DW5.IntraIntermbipcmflagForceipcmcontrolmask = 1;
1487 cmd.DW5.MbratectrlflagMbLevelRateControlEnablingFlag = 0;
1488 cmd.DW5.Nonfirstpassflag = 0;
1489 cmd.DW5.TrellisQuantizationChromaDisableTqchromadisable = true;
1490
1491 if (params->dwMaxFrameSize && params->currPass)
1492 {
1493 cmd.DW5.Nonfirstpassflag = 1;
1494 }
1495
1496 if (params->dwTqEnabled &&
1497 cmd.DW4.Entropycodingflag)
1498 {
1499 cmd.DW5.TrellisQuantizationEnabledTqenb = params->dwTqEnabled;
1500 cmd.DW5.TrellisQuantizationRoundingTqr = params->dwTqRounding;
1501 }
1502 else
1503 {
1504 cmd.DW5.TrellisQuantizationEnabledTqenb = cmd.DW5.TrellisQuantizationRoundingTqr = 0;
1505 }
1506
1507 //DW6
1508 cmd.DW6.Intrambmaxsz = m_avcIntraMbMaxSize;
1509 cmd.DW6.Intermbmaxsz = m_avcInterMbMaxSize;
1510 //DW8
1511 cmd.DW8.Slicedeltaqppmax0 =
1512 cmd.DW8.Slicedeltaqpmax1 =
1513 cmd.DW8.Slicedeltaqpmax2 =
1514 cmd.DW8.Slicedeltaqpmax3 = 0;
1515 //DW9
1516 cmd.DW9.Slicedeltaqpmin0 =
1517 cmd.DW9.Slicedeltaqpmin1 =
1518 cmd.DW9.Slicedeltaqpmin2 =
1519 cmd.DW9.Slicedeltaqpmin3 = 0;
1520
1521 //DW10
1522 MHW_VDBOX_AVC_IMG_BITRATE_PARAMS bitrateParams;
1523 CalcAvcImgStateMinMaxBitrate(bitrateParams);
1524 cmd.DW10.Framebitratemin = bitrateParams.frameBitRateMin;
1525 cmd.DW10.Framebitrateminunit = bitrateParams.frameBitRateMinUnit;
1526 cmd.DW10.Framebitrateminunitmode = bitrateParams.frameBitRateMinUnitMode;
1527 cmd.DW10.Framebitratemax = bitrateParams.frameBitRateMax;
1528 cmd.DW10.Framebitratemaxunit = bitrateParams.frameBitRateMaxUnit;
1529 cmd.DW10.Framebitratemaxunitmode = bitrateParams.frameBitRateMaxUnitMode;
1530
1531 //DW11
1532 cmd.DW11.Framebitratemindelta = bitrateParams.frameBitRateMinDelta;
1533 cmd.DW11.Framebitratemaxdelta = bitrateParams.frameBitRateMaxDelta;
1534 cmd.DW11.SliceStatsStreamoutEnable = params->bSliceSizeStreamOutEnabled;
1535
1536 //add for multiple pass
1537 if (params->dwMaxFrameSize > 0 && params->pDeltaQp && (!params->bIPCMPass))
1538 {
1539 cmd.DW8.Slicedeltaqppmax0 =
1540 cmd.DW8.Slicedeltaqpmax1 =
1541 cmd.DW8.Slicedeltaqpmax2 =
1542 cmd.DW8.Slicedeltaqpmax3 = params->pDeltaQp[params->currPass];
1543 cmd.DW10.Framebitratemaxunit = 0;
1544 cmd.DW10.Framebitratemaxunitmode = 0;
1545 //when FrameBitrateMaxUnit & FrameBitrateMaxUnitMode both are 0, the frame size unit is 128bytes.
1546 cmd.DW10.Framebitratemax = params->dwMaxFrameSize >> 7;
1547 cmd.DW11.Framebitratemaxdelta = params->dwMaxFrameSize >> 8;
1548
1549 // In compatibility mode (DW10.FrameBitrateMaxUnitMode = 0), only 12 bits is used.
1550 // If the calulated value of max frame size exceeded 12 bits, need change unit from 128 bytes to 16K bytes.
1551 if (params->dwMaxFrameSize >= (0x1 << 12) * 128)
1552 {
1553 // use 16K bytes unit mode in compatibility mode.
1554 cmd.DW10.Framebitratemaxunit = 1;
1555 cmd.DW10.Framebitratemaxunitmode = 0;
1556 cmd.DW10.Framebitratemax = params->dwMaxFrameSize >> 14;
1557 cmd.DW11.Framebitratemaxdelta = params->dwMaxFrameSize >> 15;
1558 }
1559 }
1560
1561 if (params->bIPCMPass)
1562 {
1563 // InterMbConfFlag, IntraMbConfFlag: not being used in HW
1564 cmd.DW4.Mbstatenabled = true;
1565 cmd.DW5.IntraIntermbipcmflagForceipcmcontrolmask = true;
1566 }
1567
1568 cmd.DW17.ExtendedRhodomainStatisticsEnable = m_rhoDomainStatsEnabled;
1569
1570 if (avcSeqParams->EnableSliceLevelRateCtrl)
1571 {
1572 cmd.DW19.ThresholdSizeInBytes = avcPicParams->SliceSizeInBytes - MOS_MIN(avcPicParams->SliceSizeInBytes, params->dwVdencSliceMinusBytes);
1573 cmd.DW20.TargetSliceSizeInBytes = avcPicParams->SliceSizeInBytes;
1574 }
1575
1576 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1577
1578 return eStatus;
1579 }
1580
1581 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxAvcDirectmodeCmd(
1582 PMOS_COMMAND_BUFFER cmdBuffer,
1583 PMHW_VDBOX_AVC_DIRECTMODE_PARAMS params)
1584 {
1585 MHW_FUNCTION_ENTER;
1586
1587 MHW_MI_CHK_NULL(m_osInterface);
1588 MHW_MI_CHK_NULL(cmdBuffer);
1589 MHW_MI_CHK_NULL(params);
1590
1591 MHW_RESOURCE_PARAMS resourceParams;
1592 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1593 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
1594 resourceParams.HwCommandType = MOS_MFX_AVC_DIRECT_MODE;
1595
1596 mhw_vdbox_mfx_g12_X::MFX_AVC_DIRECTMODE_STATE_CMD cmd;
1597
1598 if (!params->bDisableDmvBuffers)
1599 {
1600 MHW_MI_CHK_NULL(params->presAvcDmvBuffers);
1601
1602 cmd.DW36.MemoryObjectControlState =
1603 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC].Value;
1604
1605 // current picture
1606 resourceParams.presResource = &params->presAvcDmvBuffers[params->ucAvcDmvIdx];
1607 resourceParams.dwOffset = 0;
1608 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddressForWrite[0].DW0_1.Value[0]);
1609 resourceParams.dwLocationInCmd = 34;
1610 resourceParams.bIsWritable = true;
1611
1612 MHW_MI_CHK_STATUS(AddResourceToCmd(
1613 m_osInterface,
1614 cmdBuffer,
1615 &resourceParams));
1616 }
1617
1618 CODEC_REF_LIST** refList;
1619 MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST**)params->avcRefList);
1620
1621 if (CodecHal_PictureIsBottomField(params->CurrPic))
1622 {
1623 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = 0;
1624 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1625 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[1];
1626 }
1627 else
1628 {
1629 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1630 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[0];
1631 if (CodecHal_PictureIsFrame(params->CurrPic))
1632 {
1633 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1634 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[1];
1635 }
1636 }
1637
1638 if (!params->bDisableDmvBuffers)
1639 {
1640 // there is only one control DW33 for all references
1641 cmd.DW33.MemoryObjectControlState =
1642 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC].Value;
1643 }
1644
1645 bool dmvPresent[CODEC_AVC_NUM_REF_DMV_BUFFERS] = { false };
1646 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1647 {
1648 if (params->pAvcPicIdx[i].bValid)
1649 {
1650 uint8_t idx = params->pAvcPicIdx[i].ucPicIdx;
1651 uint8_t picID = params->bPicIdRemappingInUse ? i : refList[idx]->ucFrameId;
1652 uint8_t mvIdx = refList[idx]->ucDMVIdx[0];
1653
1654 uint8_t validRef = ((params->uiUsedForReferenceFlags >> (i * 2)) >> 0) & 1;
1655 uint8_t frameID = picID << 1;
1656 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1657 {
1658 if (!params->bDisableDmvBuffers)
1659 {
1660 dmvPresent[picID] = true;
1661
1662 resourceParams.presResource = &params->presAvcDmvBuffers[mvIdx];
1663 resourceParams.dwOffset = 0;
1664 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[picID].DW0_1.Value[0]);
1665 resourceParams.dwLocationInCmd = picID * 2 + 1;
1666 resourceParams.bIsWritable = false;
1667
1668 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd;
1669
1670 MHW_MI_CHK_STATUS(AddResourceToCmd(
1671 m_osInterface,
1672 cmdBuffer,
1673 &resourceParams));
1674 }
1675
1676 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[0] * validRef;
1677 }
1678 else
1679 {
1680 return MOS_STATUS_UNKNOWN;
1681 }
1682
1683 validRef = ((params->uiUsedForReferenceFlags >> (i * 2)) >> 1) & 1;
1684 frameID = (picID << 1) + 1;
1685 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1686 {
1687 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[1] * validRef;
1688 }
1689 else
1690 {
1691 return MOS_STATUS_UNKNOWN;
1692 }
1693 }
1694 }
1695
1696 if (!params->bDisableDmvBuffers)
1697 {
1698 // Use a valid address for remaining DMV buffers
1699 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1700 {
1701 if (dmvPresent[i] == false)
1702 {
1703 //Give default buffer to the MV
1704 resourceParams.presResource = &params->presAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS];
1705 resourceParams.dwOffset = 0;
1706 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[i].DW0_1.Value[0]);
1707 resourceParams.dwLocationInCmd = i * 2 + 1;
1708 resourceParams.bIsWritable = false;
1709
1710 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd;
1711
1712 MHW_MI_CHK_STATUS(AddResourceToCmd(
1713 m_osInterface,
1714 cmdBuffer,
1715 &resourceParams));
1716 }
1717 }
1718 }
1719
1720 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1721
1722 return MOS_STATUS_SUCCESS;
1723 }
1724
1725 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfdAvcSliceAddrCmd(
1726 PMOS_COMMAND_BUFFER cmdBuffer,
1727 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState)
1728 {
1729 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1730
1731 MHW_FUNCTION_ENTER;
1732
1733 MHW_MI_CHK_NULL(m_osInterface);
1734 MHW_MI_CHK_NULL(cmdBuffer);
1735 MHW_MI_CHK_NULL(avcSliceState);
1736
1737 mhw_vdbox_mfx_g12_X::MFD_AVC_SLICEADDR_CMD cmd;
1738
1739 if (avcSliceState->bFullFrameData)
1740 {
1741 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwNextLength;
1742 cmd.DW2.IndirectBsdDataStartAddress = avcSliceState->dwNextOffset;
1743 }
1744 else
1745 {
1746 cmd.DW1.IndirectBsdDataLength = (avcSliceState->dwNextLength + 1 - m_osInterface->dwNumNalUnitBytesIncluded);
1747 cmd.DW2.IndirectBsdDataStartAddress = (avcSliceState->dwNextOffset - 1 + m_osInterface->dwNumNalUnitBytesIncluded);
1748 }
1749
1750 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1751 sliceInfoParam.presDataBuffer = avcSliceState->presDataBuffer;
1752 sliceInfoParam.dwSliceIndex = avcSliceState->dwSliceIndex;
1753 sliceInfoParam.dwTotalBytesConsumed = avcSliceState->dwTotalBytesConsumed;
1754 sliceInfoParam.dwDataStartOffset[0] = cmd.DW2.IndirectBsdDataStartAddress;
1755 sliceInfoParam.dwDataStartOffset[1] = avcSliceState->pAvcSliceParams->slice_data_offset;
1756
1757 MHW_MI_CHK_STATUS(m_cpInterface->SetMfxProtectionState(
1758 m_decodeInUse,
1759 cmdBuffer,
1760 nullptr,
1761 &sliceInfoParam));
1762
1763 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1764
1765 return eStatus;
1766 }
1767
1768 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfdAvcBsdObjectCmd(
1769 PMOS_COMMAND_BUFFER cmdBuffer,
1770 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState)
1771 {
1772 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1773
1774 MHW_FUNCTION_ENTER;
1775
1776 MHW_MI_CHK_NULL(m_osInterface);
1777 MHW_MI_CHK_NULL(cmdBuffer);
1778 MHW_MI_CHK_NULL(avcSliceState);
1779 MHW_MI_CHK_NULL(avcSliceState->pAvcSliceParams);
1780
1781 mhw_vdbox_mfx_g12_X::MFD_AVC_BSD_OBJECT_CMD cmd;
1782 auto sliceParams = avcSliceState->pAvcSliceParams;
1783
1784 cmd.DW4.LastsliceFlag = avcSliceState->bLastSlice;
1785
1786 cmd.DW3.IntraPredmode4X48X8LumaErrorControlBit = 1;
1787 cmd.DW5.IntraPredictionErrorControlBitAppliedToIntra16X16Intra8X8Intra4X4LumaAndChroma = 1;
1788 cmd.DW5.Intra8X84X4PredictionErrorConcealmentControlBit = 1;
1789 cmd.DW5.ISliceConcealmentMode = 1;
1790
1791 if (avcSliceState->bShortFormatInUse)
1792 {
1793 if (avcSliceState->bFullFrameData)
1794 {
1795 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength;
1796 cmd.DW2.IndirectBsdDataStartAddress = sliceParams->slice_data_offset;
1797 }
1798 else
1799 {
1800 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength + 1 - m_osInterface->dwNumNalUnitBytesIncluded;
1801 cmd.DW2.IndirectBsdDataStartAddress =
1802 sliceParams->slice_data_offset - 1 + m_osInterface->dwNumNalUnitBytesIncluded;
1803 }
1804 cmd.DW4.FirstMbByteOffsetOfSliceDataOrSliceHeader = 0;
1805 }
1806 else
1807 {
1808 // Long format
1809 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength;
1810 cmd.DW2.IndirectBsdDataStartAddress = sliceParams->slice_data_offset + avcSliceState->dwOffset;
1811 cmd.DW4.FirstMacroblockMbBitOffset = sliceParams->slice_data_bit_offset;
1812
1813 if (!avcSliceState->bIntelEntrypointInUse)
1814 {
1815 // NAL Header Unit must be passed to HW in the compressed bitstream buffer
1816 avcSliceState->dwOffset -= (m_osInterface->dwNumNalUnitBytesIncluded - 1);
1817 cmd.DW1.IndirectBsdDataLength += avcSliceState->dwOffset;
1818 cmd.DW2.IndirectBsdDataStartAddress -= avcSliceState->dwOffset;
1819 cmd.DW4.FirstMbByteOffsetOfSliceDataOrSliceHeader = avcSliceState->dwOffset;
1820 }
1821 }
1822
1823 cmd.DW4.FixPrevMbSkipped = 1;
1824
1825 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1826 sliceInfoParam.presDataBuffer = avcSliceState->presDataBuffer;
1827 sliceInfoParam.dwSliceIndex = avcSliceState->dwSliceIndex;
1828 sliceInfoParam.dwTotalBytesConsumed = avcSliceState->dwTotalBytesConsumed;
1829 sliceInfoParam.dwDataStartOffset[0] = cmd.DW2.IndirectBsdDataStartAddress;
1830 sliceInfoParam.dwDataStartOffset[1] = sliceParams->slice_data_offset;
1831 sliceInfoParam.dwDataLength[1] = sliceParams->slice_data_size;
1832
1833 MHW_MI_CHK_STATUS(m_cpInterface->SetMfxProtectionState(
1834 m_decodeInUse,
1835 cmdBuffer,
1836 nullptr,
1837 &sliceInfoParam));
1838
1839 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1840
1841 return eStatus;
1842 }
1843
1844 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxPakInsertObject(
1845 PMOS_COMMAND_BUFFER cmdBuffer,
1846 PMHW_BATCH_BUFFER batchBuffer,
1847 PMHW_VDBOX_PAK_INSERT_PARAMS params)
1848 {
1849 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1850
1851 MHW_FUNCTION_ENTER;
1852
1853 MHW_MI_CHK_NULL(params);
1854
1855 if (cmdBuffer == nullptr && batchBuffer == nullptr)
1856 {
1857 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
1858 return MOS_STATUS_INVALID_PARAMETER;
1859 }
1860
1861 mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD cmd;
1862 uint32_t dwordsUsed = mhw_vdbox_mfx_g12_X::MFX_PAK_INSERT_OBJECT_CMD::dwSize;
1863
1864 cmd.DW1.SliceHeaderIndicator = params->bSliceHeaderIndicator;
1865
1866 if (params->bLastPicInSeq || params->bLastPicInStream) // used by AVC, MPEG2
1867 {
1868 dwordsUsed += params->bLastPicInSeq + params->bLastPicInStream;
1869
1870 cmd.DW0.DwordLength = mhw_vdbox_mfx_g12_X::GetOpLength(dwordsUsed);
1871 cmd.DW1.BitstreamstartresetResetbitstreamstartingpos = 0;
1872 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = 1;
1873 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = 1;
1874 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = 0;
1875 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = 0;
1876 // use dwBitSize to pass SrcDataEndingBitInclusion
1877 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = params->dwBitSize;
1878 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1879 cmd.DW1.Headerlengthexcludefrmsize = cmd.DW1.EmulationflagEmulationbytebitsinsertenable ? false : params->bHeaderLengthExcludeFrmSize; // Cannot be set to true if emulation byte bit insertion is enabled
1880
1881 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1882
1883 if (params->bLastPicInSeq) // only used by AVC, not used by MPEG2
1884 {
1885 uint32_t lastPicInSeqData = params->dwLastPicInSeqData;
1886
1887 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
1888 m_osInterface,
1889 cmdBuffer,
1890 batchBuffer,
1891 &lastPicInSeqData,
1892 sizeof(lastPicInSeqData)));
1893 }
1894
1895 if (params->bLastPicInStream) // used by AVC, MPEG2
1896 {
1897 uint32_t lastPicInStreamData = params->dwLastPicInStreamData;
1898
1899 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
1900 m_osInterface,
1901 cmdBuffer,
1902 batchBuffer,
1903 &lastPicInStreamData,
1904 sizeof(lastPicInStreamData)));
1905 }
1906 }
1907 else // used by AVC, MPEG2, JPEG
1908 {
1909 uint32_t byteSize = (params->dwBitSize + 7) >> 3;
1910 uint32_t dataBitsInLastDw = params->dwBitSize % 32;
1911
1912 if (dataBitsInLastDw == 0)
1913 {
1914 dataBitsInLastDw = 32;
1915 }
1916
1917 dwordsUsed += ((byteSize + 3) >> 2);
1918 cmd.DW0.DwordLength = mhw_vdbox_mfx_g12_X::GetOpLength(dwordsUsed);
1919 cmd.DW1.BitstreamstartresetResetbitstreamstartingpos = params->bResetBitstreamStartingPos;
1920 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = params->bEndOfSlice;
1921 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = params->bLastHeader;
1922 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = params->bEmulationByteBitsInsert;
1923 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = params->uiSkipEmulationCheckCount;
1924 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1925 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1926 cmd.DW1.Headerlengthexcludefrmsize = cmd.DW1.EmulationflagEmulationbytebitsinsertenable ? false :
1927 params->bHeaderLengthExcludeFrmSize; // Cannot be set to true if emulation byte bit insertion is enabled
1928 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1929
1930 // Add actual data
1931 uint8_t* data = (uint8_t*)(params->pBsBuffer->pBase + params->dwOffset);
1932 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, data, byteSize));
1933 }
1934
1935 return eStatus;
1936 }
1937
1938 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxJpegPicCmd(
1939 PMOS_COMMAND_BUFFER cmdBuffer,
1940 PMHW_VDBOX_JPEG_PIC_STATE params)
1941 {
1942 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1943
1944 MHW_FUNCTION_ENTER;
1945
1946 MHW_MI_CHK_NULL(m_osInterface);
1947 MHW_MI_CHK_NULL(cmdBuffer);
1948 MHW_MI_CHK_NULL(params);
1949 MHW_MI_CHK_NULL(params->pJpegPicParams);
1950
1951 mhw_vdbox_mfx_g12_X::MFX_JPEG_PIC_STATE_CMD cmd;
1952 auto picParams = params->pJpegPicParams;
1953
1954 if (picParams->m_chromaType == jpegRGB || picParams->m_chromaType == jpegBGR)
1955 {
1956 cmd.DW1.Obj1.InputFormatYuv = jpegYUV444;
1957 }
1958 else
1959 {
1960 cmd.DW1.Obj1.InputFormatYuv = picParams->m_chromaType;
1961 }
1962 cmd.DW1.Obj1.Rotation = picParams->m_rotation;
1963 cmd.DW1.Obj1.OutputFormatYuv = GetJpegDecodeFormat((MOS_FORMAT)params->dwOutputFormat);
1964
1965 if (params->dwOutputFormat == Format_NV12)
1966 {
1967 if (picParams->m_chromaType == jpegYUV422H2Y ||
1968 picParams->m_chromaType == jpegYUV422H4Y)
1969 {
1970 cmd.DW1.Obj1.VerticalDownSamplingEnable = 1;
1971 }
1972 else if (picParams->m_chromaType == jpegYUV422V2Y ||
1973 picParams->m_chromaType == jpegYUV422V4Y)
1974 {
1975 cmd.DW1.Obj1.HorizontalDownSamplingEnable = 1;
1976 }
1977 }
1978 else if (params->dwOutputFormat == Format_UYVY ||
1979 params->dwOutputFormat == Format_YUY2)
1980 {
1981 if (picParams->m_chromaType == jpegYUV420)
1982 {
1983 cmd.DW1.Obj1.VerticalUpSamplingEnable = 1;
1984 }
1985 }
1986
1987 cmd.DW2.Obj0.FrameWidthInBlocksMinus1 = params->dwWidthInBlocks;
1988 cmd.DW2.Obj0.FrameHeightInBlocksMinus1 = params->dwHeightInBlocks;
1989
1990 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1991
1992 return eStatus;
1993 }
1994
1995 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxJpegEncodePicStateCmd(
1996 PMOS_COMMAND_BUFFER cmdBuffer,
1997 MhwVdboxJpegEncodePicState *params)
1998 {
1999 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2000
2001 MHW_FUNCTION_ENTER;
2002
2003 MHW_MI_CHK_NULL(m_osInterface);
2004 MHW_MI_CHK_NULL(cmdBuffer);
2005 MHW_MI_CHK_NULL(params);
2006 MHW_MI_CHK_NULL(params->pJpegEncodePicParams);
2007
2008 mhw_vdbox_mfx_g12_X::MFX_JPEG_PIC_STATE_CMD cmd;
2009 auto picParams = params->pJpegEncodePicParams;
2010
2011 cmd.DW1.Obj0.InputSurfaceFormatYuv = picParams->m_inputSurfaceFormat;
2012
2013 if (picParams->m_inputSurfaceFormat == codechalJpegY8)
2014 {
2015 cmd.DW1.Obj0.OutputMcuStructure = jpegYUV400;
2016 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = picParams->m_picWidth % 8;
2017 cmd.DW1.Obj0.PixelsInVerticalLastMcu = picParams->m_picHeight % 8;
2018 }
2019 else if (picParams->m_inputSurfaceFormat == codechalJpegNV12)
2020 {
2021 cmd.DW1.Obj0.OutputMcuStructure = jpegYUV420;
2022
2023 if (picParams->m_picWidth % 2 == 0)
2024 {
2025 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = picParams->m_picWidth % 16;
2026 }
2027 else
2028 {
2029 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = ((picParams->m_picWidth % 16) + 1) % 16;
2030 }
2031
2032 if (picParams->m_picHeight % 2 == 0)
2033 {
2034 cmd.DW1.Obj0.PixelsInVerticalLastMcu = picParams->m_picHeight % 16;
2035 }
2036 else
2037 {
2038 cmd.DW1.Obj0.PixelsInVerticalLastMcu = ((picParams->m_picHeight % 16) + 1) % 16;
2039 }
2040 }
2041 else if (picParams->m_inputSurfaceFormat == codechalJpegYUY2 ||
2042 picParams->m_inputSurfaceFormat == codechalJpegUYVY)
2043 {
2044 cmd.DW1.Obj0.OutputMcuStructure = jpegYUV422H2Y;
2045
2046 if (picParams->m_picWidth % 2 == 0)
2047 {
2048 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = picParams->m_picWidth % 16;
2049 }
2050 else
2051 {
2052 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = ((picParams->m_picWidth % 16) + 1) % 16;
2053 }
2054
2055 cmd.DW1.Obj0.PixelsInVerticalLastMcu = picParams->m_picHeight % 8;
2056 }
2057 else if (picParams->m_inputSurfaceFormat == codechalJpegRGB)
2058 {
2059 cmd.DW1.Obj0.OutputMcuStructure = jpegYUV444;
2060 cmd.DW1.Obj0.PixelsInHorizontalLastMcu = picParams->m_picWidth % 8;
2061 cmd.DW1.Obj0.PixelsInVerticalLastMcu = picParams->m_picHeight % 8;
2062 }
2063
2064 uint32_t horizontalSamplingFactor = GetJpegHorizontalSamplingFactorForY((CodecEncodeJpegInputSurfaceFormat)picParams->m_inputSurfaceFormat);
2065 uint32_t verticalSamplingFactor = GetJpegVerticalSamplingFactorForY((CodecEncodeJpegInputSurfaceFormat)picParams->m_inputSurfaceFormat);
2066 cmd.DW2.Obj0.FrameWidthInBlocksMinus1 = (((picParams->m_picWidth + (horizontalSamplingFactor * 8 - 1)) / (horizontalSamplingFactor * 8)) * horizontalSamplingFactor) - 1;
2067 cmd.DW2.Obj0.FrameHeightInBlocksMinus1 = (((picParams->m_picHeight + (verticalSamplingFactor * 8 - 1)) / (verticalSamplingFactor * 8)) * verticalSamplingFactor) - 1;
2068
2069 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2070
2071 return eStatus;
2072 }
2073
2074 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxJpegFqmCmd(
2075 PMOS_COMMAND_BUFFER cmdBuffer,
2076 PMHW_VDBOX_QM_PARAMS params,
2077 uint32_t numQuantTables)
2078 {
2079 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2080
2081 MHW_FUNCTION_ENTER;
2082
2083 MHW_MI_CHK_NULL(m_osInterface);
2084 MHW_MI_CHK_NULL(cmdBuffer);
2085 MHW_MI_CHK_NULL(params);
2086
2087 mhw_vdbox_mfx_g12_X::MFX_FQM_STATE_CMD cmd;
2088
2089 for (uint32_t i = 0; i < numQuantTables; i++)
2090 {
2091 cmd.DW1.Obj0.Avc = i;
2092
2093 MOS_ZeroMemory(&cmd.ForwardQuantizerMatrix, sizeof(cmd.ForwardQuantizerMatrix));
2094
2095 auto j = 0;
2096 // Copy over 32 uint32_t worth of values - Each uint32_t will contain 2 16 bit quantizer values
2097 // where for the DWordx Bits [15: 0] = 1/QM[0][x] Bits[32:16] = 1/QM[1][x]
2098 for (auto k = 0; k < 8; k++)
2099 {
2100 for (auto l = k; l < 64; l += 16)
2101 {
2102 cmd.ForwardQuantizerMatrix[j] = (((GetReciprocalScalingValue(params->pJpegQuantMatrix->m_quantMatrix[i][l + 8]) & 0xFFFF) << 16)
2103 | (GetReciprocalScalingValue(params->pJpegQuantMatrix->m_quantMatrix[i][l]) & 0xFFFF));
2104 j++;
2105 }
2106 }
2107
2108 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2109 }
2110
2111 return eStatus;
2112 }
2113
2114 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfcJpegHuffTableStateCmd(
2115 PMOS_COMMAND_BUFFER cmdBuffer,
2116 PMHW_VDBOX_ENCODE_HUFF_TABLE_PARAMS params)
2117 {
2118 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2119
2120 MHW_FUNCTION_ENTER;
2121
2122 MHW_MI_CHK_NULL(m_osInterface);
2123 MHW_MI_CHK_NULL(cmdBuffer);
2124 MHW_MI_CHK_NULL(params);
2125
2126 mhw_vdbox_mfx_g12_X::MFC_JPEG_HUFF_TABLE_STATE_CMD cmd;
2127
2128 cmd.DW1.HuffTableId = params->HuffTableID;
2129
2130 // cmd DWORDS 2:13 for DC Table
2131 // Format- 3Bytes: Byte0 for Code length, Byte1 and Byte2 for Code word, and Byte3 for dummy
2132 for (auto j = 0; j < JPEG_NUM_HUFF_TABLE_DC_HUFFVAL; j++)
2133 {
2134 cmd.DcTable[j] = 0;
2135 cmd.DcTable[j] = (params->pDCCodeLength[j] & 0xFF) | ((params->pDCCodeValues[j] & 0xFFFF) << 8);
2136 }
2137
2138 // cmd DWORDS 14:175 for AC table
2139 // Format- 3Bytes: Byte0 for Code length, Byte1 and Byte2 for Code word, and Byte3 for dummy
2140 for (auto j = 0; j < JPEG_NUM_HUFF_TABLE_AC_HUFFVAL; j++)
2141 {
2142 cmd.AcTable[j] = 0;
2143 cmd.AcTable[j] = (params->pACCodeLength[j] & 0xFF)
2144 | ((params->pACCodeValues[j] & 0xFFFF) << 8);
2145 }
2146
2147 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2148
2149 return eStatus;
2150 }
2151
2152 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfcJpegScanObjCmd(
2153 PMOS_COMMAND_BUFFER cmdBuffer,
2154 MhwVdboxJpegScanParams *params)
2155 {
2156 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2157
2158 MHW_FUNCTION_ENTER;
2159
2160 MHW_MI_CHK_NULL(m_osInterface);
2161 MHW_MI_CHK_NULL(cmdBuffer);
2162 MHW_MI_CHK_NULL(params);
2163 MHW_MI_CHK_NULL(params->pJpegEncodeScanParams);
2164
2165 mhw_vdbox_mfx_g12_X::MFC_JPEG_SCAN_OBJECT_CMD cmd;
2166
2167 uint32_t horizontalSamplingFactor = GetJpegHorizontalSamplingFactorForY(params->inputSurfaceFormat);
2168 uint32_t verticalSamplingFactor = GetJpegVerticalSamplingFactorForY(params->inputSurfaceFormat);
2169 cmd.DW1.McuCount = ((params->dwPicWidth + (horizontalSamplingFactor * 8 - 1)) / (horizontalSamplingFactor * 8))
2170 * ((params->dwPicHeight + (verticalSamplingFactor * 8 - 1)) / (verticalSamplingFactor * 8));
2171 cmd.DW2.RestartInterval = params->pJpegEncodeScanParams->m_restartInterval;
2172 cmd.DW2.IsLastScan = 1; // Always 1 since there is only 1 scan in the JPEG frame
2173 cmd.DW2.HeadPresentFlag = 1; // There will always be MFC_JPEG_PAK_INSERT_OBJECT commands sent
2174
2175 for (auto i = 0; i < jpegNumComponent; i++)
2176 {
2177 cmd.DW2.HuffmanDcTable |= (params->pJpegEncodeScanParams->m_dcCodingTblSelector[i]) << i;
2178 cmd.DW2.HuffmanAcTable |= (params->pJpegEncodeScanParams->m_acCodingTblSelector[i]) << i;
2179 }
2180
2181 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2182
2183 return eStatus;
2184 }
2185
2186 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxDecodeVp8PicCmd(
2187 PMOS_COMMAND_BUFFER cmdBuffer,
2188 PMHW_VDBOX_VP8_PIC_STATE params)
2189 {
2190 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2191
2192 MHW_FUNCTION_ENTER;
2193
2194 MHW_MI_CHK_NULL(m_osInterface);
2195 MHW_MI_CHK_NULL(cmdBuffer);
2196 MHW_MI_CHK_NULL(params);
2197
2198 mhw_vdbox_mfx_g12_X::MFX_VP8_PIC_STATE_CMD cmd;
2199 auto vp8PicParams = params->pVp8PicParams;
2200 auto vp8IqMatrixParams = params->pVp8IqMatrixParams;
2201
2202 cmd.DW1.FrameWidthMinus1 = vp8PicParams->wFrameWidthInMbsMinus1;
2203 cmd.DW1.FrameHeightMinus1 = vp8PicParams->wFrameHeightInMbsMinus1;
2204 cmd.DW2.McFilterSelect = (vp8PicParams->version != 0);
2205 cmd.DW2.ChromaFullPixelMcFilterMode = (vp8PicParams->version == 3);
2206 cmd.DW2.Dblkfiltertype = vp8PicParams->filter_type;
2207 cmd.DW2.Skeyframeflag = vp8PicParams->key_frame;
2208 cmd.DW2.SegmentationIdStreamoutEnable =
2209 (vp8PicParams->segmentation_enabled) && (vp8PicParams->update_mb_segmentation_map);
2210 cmd.DW2.SegmentationIdStreaminEnable =
2211 (vp8PicParams->segmentation_enabled) && !(vp8PicParams->update_mb_segmentation_map);
2212 cmd.DW2.SegmentEnableFlag = vp8PicParams->segmentation_enabled;
2213 cmd.DW2.UpdateMbsegmentMapFlag =
2214 (vp8PicParams->segmentation_enabled) ? vp8PicParams->update_mb_segmentation_map : 0;
2215 cmd.DW2.MbNocoeffSkipflag = vp8PicParams->mb_no_coeff_skip;
2216 cmd.DW2.ModeReferenceLoopFilterDeltaEnabled = vp8PicParams->loop_filter_adj_enable;
2217 cmd.DW2.GoldenRefPictureMvSignbiasFlag = vp8PicParams->sign_bias_golden;
2218 cmd.DW2.AlternateRefPicMvSignbiasFlag = vp8PicParams->sign_bias_alternate;
2219 cmd.DW2.DeblockSharpnessLevel = vp8PicParams->ucSharpnessLevel;
2220 cmd.DW3.DblkfilterlevelForSegment3 = vp8PicParams->ucLoopFilterLevel[3];
2221 cmd.DW3.DblkfilterlevelForSegment2 = vp8PicParams->ucLoopFilterLevel[2];
2222 cmd.DW3.DblkfilterlevelForSegment1 = vp8PicParams->ucLoopFilterLevel[1];
2223 cmd.DW3.DblkfilterlevelForSegment0 = vp8PicParams->ucLoopFilterLevel[0];
2224
2225 uint32_t i = 0;
2226 uint32_t j = 0;
2227 cmd.DW4.dec.QuantizerValue0Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
2228 cmd.DW4.dec.QuantizerValue0Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2229
2230 i = 0;
2231 j = 2;
2232 cmd.DW5.dec.QuantizerValue0Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
2233 cmd.DW5.dec.QuantizerValue0Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
2234
2235 i = 0;
2236 j = 4;
2237 cmd.DW6.dec.QuantizerValue0Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
2238 cmd.DW6.dec.QuantizerValue0Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2239
2240 i = 1;
2241 j = 0;
2242 cmd.DW7.dec.QuantizerValue1Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
2243 cmd.DW7.dec.QuantizerValue1Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2244
2245 i = 1;
2246 j = 2;
2247 cmd.DW8.QuantizerValue1Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
2248 cmd.DW8.QuantizerValue1Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
2249
2250 i = 1;
2251 j = 4;
2252 cmd.DW9.QuantizerValue1Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
2253 cmd.DW9.QuantizerValue1Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2254
2255 i = 2;
2256 j = 0;
2257 cmd.DW10.QuantizerValue2Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
2258 cmd.DW10.QuantizerValue2Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2259
2260 i = 2;
2261 j = 2;
2262 cmd.DW11.QuantizerValue2Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
2263 cmd.DW11.QuantizerValue2Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
2264
2265 i = 2;
2266 j = 4;
2267 cmd.DW12.QuantizerValue2Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
2268 cmd.DW12.QuantizerValue2Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2269
2270 i = 3;
2271 j = 0;
2272 cmd.DW13.QuantizerValue3Blocktype0Y1Dc = vp8IqMatrixParams->quantization_values[i][j];
2273 cmd.DW13.QuantizerValue3Blocktype1Y1Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2274
2275 i = 3;
2276 j = 2;
2277 cmd.DW14.QuantizerValue3Blocktype2Uvdc = vp8IqMatrixParams->quantization_values[i][j];
2278 cmd.DW14.QuantizerValue3Blocktype3Uvac = vp8IqMatrixParams->quantization_values[i][j + 1];
2279
2280 i = 3;
2281 j = 4;
2282 cmd.DW15.QuantizerValue3Blocktype4Y2Dc = vp8IqMatrixParams->quantization_values[i][j];
2283 cmd.DW15.QuantizerValue3Blocktype5Y2Ac = vp8IqMatrixParams->quantization_values[i][j + 1];
2284
2285 cmd.DW19.Mbsegmentidtreeprobs2 = vp8PicParams->cMbSegmentTreeProbs[2];
2286 cmd.DW19.Mbsegmentidtreeprobs1 = vp8PicParams->cMbSegmentTreeProbs[1];
2287 cmd.DW19.Mbsegmentidtreeprobs0 = vp8PicParams->cMbSegmentTreeProbs[0];
2288 cmd.DW20.Mbnocoeffskipfalseprob = vp8PicParams->ucProbSkipFalse;
2289 cmd.DW20.Intrambprob = vp8PicParams->ucProbIntra;
2290 cmd.DW20.Interpredfromlastrefprob = vp8PicParams->ucProbLast;
2291 cmd.DW20.Interpredfromgrefrefprob = vp8PicParams->ucProbGolden;
2292 cmd.DW21.Ymodeprob3 = vp8PicParams->ucYModeProbs[3];
2293 cmd.DW21.Ymodeprob2 = vp8PicParams->ucYModeProbs[2];
2294 cmd.DW21.Ymodeprob1 = vp8PicParams->ucYModeProbs[1];
2295 cmd.DW21.Ymodeprob0 = vp8PicParams->ucYModeProbs[0];
2296 cmd.DW22.Uvmodeprob2 = vp8PicParams->ucUvModeProbs[2];
2297 cmd.DW22.Uvmodeprob1 = vp8PicParams->ucUvModeProbs[1];
2298 cmd.DW22.Uvmodeprob0 = vp8PicParams->ucUvModeProbs[0];
2299
2300 i = 0;
2301 j = 0;
2302 cmd.DW23.Mvupdateprobs00 = vp8PicParams->ucMvUpdateProb[i][j];
2303 cmd.DW23.Mvupdateprobs01 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2304 cmd.DW23.Mvupdateprobs02 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2305 cmd.DW23.Mvupdateprobs03 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2306
2307 i = 0;
2308 j = 4;
2309 cmd.DW24.Mvupdateprobs04 = vp8PicParams->ucMvUpdateProb[i][j];
2310 cmd.DW24.Mvupdateprobs05 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2311 cmd.DW24.Mvupdateprobs06 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2312 cmd.DW24.Mvupdateprobs07 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2313
2314 i = 0;
2315 j = 8;
2316 cmd.DW25.Mvupdateprobs08 = vp8PicParams->ucMvUpdateProb[i][j];
2317 cmd.DW25.Mvupdateprobs09 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2318 cmd.DW25.Mvupdateprobs010 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2319 cmd.DW25.Mvupdateprobs011 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2320
2321 i = 0;
2322 j = 12;
2323 cmd.DW26.Mvupdateprobs012 = vp8PicParams->ucMvUpdateProb[i][j];
2324 cmd.DW26.Mvupdateprobs013 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2325 cmd.DW26.Mvupdateprobs014 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2326 cmd.DW26.Mvupdateprobs015 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2327
2328 i = 0;
2329 j = 16;
2330 cmd.DW27.Mvupdateprobs016 = vp8PicParams->ucMvUpdateProb[i][j];
2331 cmd.DW27.Mvupdateprobs017 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2332 cmd.DW27.Mvupdateprobs018 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2333
2334 i = 1;
2335 j = 0;
2336 cmd.DW28.Mvupdateprobs10 = vp8PicParams->ucMvUpdateProb[i][j];
2337 cmd.DW28.Mvupdateprobs11 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2338 cmd.DW28.Mvupdateprobs12 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2339 cmd.DW28.Mvupdateprobs13 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2340
2341 i = 1;
2342 j = 4;
2343 cmd.DW29.Mvupdateprobs14 = vp8PicParams->ucMvUpdateProb[i][j];
2344 cmd.DW29.Mvupdateprobs15 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2345 cmd.DW29.Mvupdateprobs16 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2346 cmd.DW29.Mvupdateprobs17 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2347
2348 i = 1;
2349 j = 8;
2350 cmd.DW30.Mvupdateprobs18 = vp8PicParams->ucMvUpdateProb[i][j];
2351 cmd.DW30.Mvupdateprobs19 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2352 cmd.DW30.Mvupdateprobs110 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2353 cmd.DW30.Mvupdateprobs111 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2354
2355 i = 1;
2356 j = 12;
2357 cmd.DW31.Mvupdateprobs112 = vp8PicParams->ucMvUpdateProb[i][j];
2358 cmd.DW31.Mvupdateprobs113 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2359 cmd.DW31.Mvupdateprobs114 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2360 cmd.DW31.Mvupdateprobs115 = vp8PicParams->ucMvUpdateProb[i][j + 3];
2361
2362 i = 1;
2363 j = 16;
2364 cmd.DW32.Mvupdateprobs116 = vp8PicParams->ucMvUpdateProb[i][j];
2365 cmd.DW32.Mvupdateprobs117 = vp8PicParams->ucMvUpdateProb[i][j + 1];
2366 cmd.DW32.Mvupdateprobs118 = vp8PicParams->ucMvUpdateProb[i][j + 2];
2367
2368 cmd.DW33.Reflfdelta0ForIntraFrame = vp8PicParams->cRefLfDelta[0];
2369 cmd.DW33.Reflfdelta1ForLastFrame = vp8PicParams->cRefLfDelta[1];
2370 cmd.DW33.Reflfdelta2ForGoldenFrame = vp8PicParams->cRefLfDelta[2];
2371 cmd.DW33.Reflfdelta3ForAltrefFrame = vp8PicParams->cRefLfDelta[3];
2372 cmd.DW34.Modelfdelta0ForBPredMode = vp8PicParams->cModeLfDelta[0];
2373 cmd.DW34.Modelfdelta1ForZeromvMode = vp8PicParams->cModeLfDelta[1];
2374 cmd.DW34.Modelfdelta2ForNearestNearAndNewMode = vp8PicParams->cModeLfDelta[2];
2375 cmd.DW34.Modelfdelta3ForSplitmvMode = vp8PicParams->cModeLfDelta[3];
2376
2377 MHW_RESOURCE_PARAMS resourceParams;
2378 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
2379 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
2380 resourceParams.HwCommandType = MOS_MFX_VP8_PIC;
2381
2382 resourceParams.presResource = params->presCoefProbBuffer;
2383 resourceParams.dwOffset = params->dwCoefProbTableOffset;
2384 resourceParams.pdwCmd = &(cmd.DW16.Value);
2385 resourceParams.dwLocationInCmd = 16;
2386 resourceParams.bIsWritable = false;
2387
2388 MHW_MI_CHK_STATUS(AddResourceToCmd(
2389 m_osInterface,
2390 cmdBuffer,
2391 &resourceParams));
2392
2393 if (vp8PicParams->segmentation_enabled)
2394 {
2395 resourceParams.presResource = params->presSegmentationIdStreamBuffer;
2396 resourceParams.dwOffset = 0;
2397 resourceParams.pdwCmd = &(cmd.DW35.Value);
2398 resourceParams.dwLocationInCmd = 35;
2399 resourceParams.bIsWritable = true;
2400
2401 MHW_MI_CHK_STATUS(AddResourceToCmd(
2402 m_osInterface,
2403 cmdBuffer,
2404 &resourceParams));
2405 }
2406
2407 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2408
2409 return eStatus;
2410 }
2411
2412 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxEncodeVp8PicCmd(
2413 PMOS_COMMAND_BUFFER cmdBuffer,
2414 PMHW_VDBOX_VP8_PIC_STATE params)
2415 {
2416 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2417
2418 MHW_FUNCTION_ENTER;
2419
2420 MHW_MI_CHK_NULL(m_osInterface);
2421 MHW_MI_CHK_NULL(cmdBuffer);
2422 MHW_MI_CHK_NULL(params);
2423 MHW_MI_CHK_NULL(params->pEncodeVP8SeqParams);
2424 MHW_MI_CHK_NULL(params->pEncodeVP8PicParams);
2425 MHW_MI_CHK_NULL(params->pEncodeVP8QuantData);
2426
2427 mhw_vdbox_mfx_g12_X::MFX_VP8_PIC_STATE_CMD cmd;
2428 auto vp8SeqParams = params->pEncodeVP8SeqParams;
2429 auto vp8PicParams = params->pEncodeVP8PicParams;
2430 auto vp8QuantData = params->pEncodeVP8QuantData;
2431
2432 cmd.DW1.FrameWidthMinus1 = params->wPicWidthInMb - 1;
2433 cmd.DW1.FrameHeightMinus1 = params->wPicHeightInMb - 1;
2434
2435 cmd.DW2.McFilterSelect = (vp8PicParams->version != 0);
2436 cmd.DW2.ChromaFullPixelMcFilterMode = (vp8PicParams->version == 3);
2437 cmd.DW2.Dblkfiltertype = vp8PicParams->filter_type;
2438 cmd.DW2.Skeyframeflag = !vp8PicParams->frame_type;
2439 cmd.DW2.SegmentEnableFlag = vp8PicParams->segmentation_enabled;
2440 cmd.DW2.UpdateMbsegmentMapFlag =
2441 (vp8PicParams->segmentation_enabled) ? vp8PicParams->update_mb_segmentation_map : 0;
2442 cmd.DW2.MbNocoeffSkipflag = vp8PicParams->mb_no_coeff_skip;
2443 cmd.DW2.ModeReferenceLoopFilterDeltaEnabled = vp8PicParams->loop_filter_adj_enable;
2444 cmd.DW2.GoldenRefPictureMvSignbiasFlag = vp8PicParams->sign_bias_golden;
2445 cmd.DW2.AlternateRefPicMvSignbiasFlag = vp8PicParams->sign_bias_alternate;
2446 cmd.DW2.DeblockSharpnessLevel = vp8PicParams->sharpness_level;
2447 cmd.DW2.Log2NumOfPartition = vp8PicParams->CodedCoeffTokenPartition;
2448
2449 cmd.DW3.DblkfilterlevelForSegment3 = vp8PicParams->loop_filter_level[3];
2450 cmd.DW3.DblkfilterlevelForSegment2 = vp8PicParams->loop_filter_level[2];
2451 cmd.DW3.DblkfilterlevelForSegment1 = vp8PicParams->loop_filter_level[1];
2452 cmd.DW3.DblkfilterlevelForSegment0 = vp8PicParams->loop_filter_level[0];
2453
2454 //Y1 AC is the reference.
2455 cmd.DW4.enc.Seg0Qindex = vp8QuantData->QIndex[0];
2456 cmd.DW4.enc.Seg1Qindex = vp8QuantData->QIndex[1];
2457 cmd.DW4.enc.Seg2Qindex = vp8QuantData->QIndex[2];
2458 cmd.DW4.enc.Seg3Qindex = vp8QuantData->QIndex[3];
2459
2460 cmd.DW5.enc.Y2DcQindexDelta = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_DC];
2461 cmd.DW5.enc.Y2AcQindexDeltaSign = (vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_DC] < 0) ? 1 : 0;
2462 cmd.DW5.enc.Y2AcQindexDelta = vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_AC];
2463 cmd.DW5.enc.Y2AcQindexSign = (vp8QuantData->QIndexDelta[VP8_QINDEX_Y2_AC] < 0) ? 1 : 0;
2464 cmd.DW5.enc.UvdcQindexDelta = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC];
2465 cmd.DW5.enc.UvdcQindexDeltaSign = (vp8QuantData->QIndexDelta[VP8_QINDEX_UV_DC] < 0) ? 1 : 0;
2466 cmd.DW5.enc.UvacQindexdelta = vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC];
2467 cmd.DW5.enc.UvacQindexDeltaSign = (vp8QuantData->QIndexDelta[VP8_QINDEX_UV_AC] < 0) ? 1 : 0;
2468
2469 cmd.DW6.enc.Y1DcQindexDelta = vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC];
2470 cmd.DW6.enc.Y1DcQindexDeltaSign = (vp8QuantData->QIndexDelta[VP8_QINDEX_Y1_DC] < 0) ? 1 : 0;
2471
2472 cmd.DW7.enc.ClampQindexLow = vp8PicParams->ClampQindexLow;
2473 cmd.DW7.enc.ClampQindexHigh = vp8PicParams->ClampQindexHigh;
2474
2475 MHW_RESOURCE_PARAMS resourceParams;
2476 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
2477 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
2478 resourceParams.HwCommandType = MOS_MFX_VP8_PIC;
2479
2480 cmd.DW19.Mbsegmentidtreeprobs2 = SegTreeProbs[2];
2481 cmd.DW19.Mbsegmentidtreeprobs1 = SegTreeProbs[1];
2482 cmd.DW19.Mbsegmentidtreeprobs0 = SegTreeProbs[0];
2483
2484 //The following probs need to be updated by the kernel when ready.
2485 cmd.DW20.Mbnocoeffskipfalseprob = 224;
2486 cmd.DW20.Intrambprob = 63;
2487 cmd.DW20.Interpredfromlastrefprob = 255;
2488 cmd.DW20.Interpredfromgrefrefprob = 128;
2489
2490 cmd.DW21.Ymodeprob3 = YModeProb[3];
2491 cmd.DW21.Ymodeprob2 = YModeProb[2];
2492 cmd.DW21.Ymodeprob1 = YModeProb[1];
2493 cmd.DW21.Ymodeprob0 = YModeProb[0];
2494
2495 cmd.DW22.Uvmodeprob2 = UVModeProb[2];
2496 cmd.DW22.Uvmodeprob1 = UVModeProb[1];
2497 cmd.DW22.Uvmodeprob0 = UVModeProb[0];
2498
2499 uint32_t i = 0;
2500 uint32_t j = 0;
2501 cmd.DW23.Mvupdateprobs00 = DefaultMvContext[i][j];
2502 cmd.DW23.Mvupdateprobs01 = DefaultMvContext[i][j + 1];
2503 cmd.DW23.Mvupdateprobs02 = DefaultMvContext[i][j + 2];
2504 cmd.DW23.Mvupdateprobs03 = DefaultMvContext[i][j + 3];
2505
2506 i = 0;
2507 j = 4;
2508 cmd.DW24.Mvupdateprobs04 = DefaultMvContext[i][j];
2509 cmd.DW24.Mvupdateprobs05 = DefaultMvContext[i][j + 1];
2510 cmd.DW24.Mvupdateprobs06 = DefaultMvContext[i][j + 2];
2511 cmd.DW24.Mvupdateprobs07 = DefaultMvContext[i][j + 3];
2512
2513 i = 0;
2514 j = 8;
2515 cmd.DW25.Mvupdateprobs08 = DefaultMvContext[i][j];
2516 cmd.DW25.Mvupdateprobs09 = DefaultMvContext[i][j + 1];
2517 cmd.DW25.Mvupdateprobs010 = DefaultMvContext[i][j + 2];
2518 cmd.DW25.Mvupdateprobs011 = DefaultMvContext[i][j + 3];
2519
2520 i = 0;
2521 j = 12;
2522 cmd.DW26.Mvupdateprobs012 = DefaultMvContext[i][j];
2523 cmd.DW26.Mvupdateprobs013 = DefaultMvContext[i][j + 1];
2524 cmd.DW26.Mvupdateprobs014 = DefaultMvContext[i][j + 2];
2525 cmd.DW26.Mvupdateprobs015 = DefaultMvContext[i][j + 3];
2526
2527 i = 0;
2528 j = 16;
2529 cmd.DW27.Mvupdateprobs016 = DefaultMvContext[i][j];
2530 cmd.DW27.Mvupdateprobs017 = DefaultMvContext[i][j + 1];
2531 cmd.DW27.Mvupdateprobs018 = DefaultMvContext[i][j + 2];
2532
2533 i = 1;
2534 j = 0;
2535 cmd.DW28.Mvupdateprobs10 = DefaultMvContext[i][j];
2536 cmd.DW28.Mvupdateprobs11 = DefaultMvContext[i][j + 1];
2537 cmd.DW28.Mvupdateprobs12 = DefaultMvContext[i][j + 2];
2538 cmd.DW28.Mvupdateprobs13 = DefaultMvContext[i][j + 3];
2539
2540 i = 1;
2541 j = 4;
2542 cmd.DW29.Mvupdateprobs14 = DefaultMvContext[i][j];
2543 cmd.DW29.Mvupdateprobs15 = DefaultMvContext[i][j + 1];
2544 cmd.DW29.Mvupdateprobs16 = DefaultMvContext[i][j + 2];
2545 cmd.DW29.Mvupdateprobs17 = DefaultMvContext[i][j + 3];
2546
2547 i = 1;
2548 j = 8;
2549 cmd.DW30.Mvupdateprobs18 = DefaultMvContext[i][j];
2550 cmd.DW30.Mvupdateprobs19 = DefaultMvContext[i][j + 1];
2551 cmd.DW30.Mvupdateprobs110 = DefaultMvContext[i][j + 2];
2552 cmd.DW30.Mvupdateprobs111 = DefaultMvContext[i][j + 3];
2553
2554 i = 1;
2555 j = 12;
2556 cmd.DW31.Mvupdateprobs112 = DefaultMvContext[i][j];
2557 cmd.DW31.Mvupdateprobs113 = DefaultMvContext[i][j + 1];
2558 cmd.DW31.Mvupdateprobs114 = DefaultMvContext[i][j + 2];
2559 cmd.DW31.Mvupdateprobs115 = DefaultMvContext[i][j + 3];
2560
2561 i = 1;
2562 j = 16;
2563 cmd.DW32.Mvupdateprobs116 = DefaultMvContext[i][j];
2564 cmd.DW32.Mvupdateprobs117 = DefaultMvContext[i][j + 1];
2565 cmd.DW32.Mvupdateprobs118 = DefaultMvContext[i][j + 2];
2566
2567 cmd.DW33.Reflfdelta0ForIntraFrame = vp8PicParams->ref_lf_delta[0];
2568 cmd.DW33.Reflfdelta1ForLastFrame = vp8PicParams->ref_lf_delta[1];
2569 cmd.DW33.Reflfdelta2ForGoldenFrame = vp8PicParams->ref_lf_delta[2];
2570 cmd.DW33.Reflfdelta3ForAltrefFrame = vp8PicParams->ref_lf_delta[3];
2571
2572 cmd.DW34.Modelfdelta0ForBPredMode = vp8PicParams->mode_lf_delta[0];
2573 cmd.DW34.Modelfdelta1ForZeromvMode = vp8PicParams->mode_lf_delta[1];
2574 cmd.DW34.Modelfdelta2ForNearestNearAndNewMode = vp8PicParams->mode_lf_delta[2];
2575 cmd.DW34.Modelfdelta3ForSplitmvMode = vp8PicParams->mode_lf_delta[3];
2576
2577 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2578
2579 return eStatus;
2580 }
2581
2582 MOS_STATUS MhwVdboxMfxInterfaceG12::InitMfxVp8EncoderCfgCmd(
2583 PMOS_RESOURCE cfgCmdBuffer,
2584 PMHW_VDBOX_VP8_ENCODER_CFG_PARAMS params)
2585 {
2586 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2587
2588 MHW_FUNCTION_ENTER;
2589
2590 MHW_MI_CHK_NULL(cfgCmdBuffer);
2591 MHW_MI_CHK_NULL(params);
2592 MHW_MI_CHK_NULL(params->pEncodeVP8PicParams);
2593 MHW_MI_CHK_NULL(params->pEncodeVP8SeqParams);
2594 MHW_MI_CHK_NULL(params->pEncodeVP8QuantData);
2595
2596 auto picParams = params->pEncodeVP8PicParams;
2597 auto seqParams = params->pEncodeVP8SeqParams;
2598 auto quantData = params->pEncodeVP8QuantData;
2599
2600 MOS_LOCK_PARAMS lockFlags;
2601 MOS_ZeroMemory(&lockFlags, sizeof(MOS_LOCK_PARAMS));
2602 lockFlags.WriteOnly = 1;
2603 uint8_t *data = (uint8_t*)m_osInterface->pfnLockResource(m_osInterface, cfgCmdBuffer, &lockFlags);
2604 MHW_MI_CHK_NULL(data);
2605 data += params->dwCfgCmdOffset;
2606
2607 MOS_ZeroMemory(data, params->dwCfgBufferSize);
2608
2609 mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD *cmd = (mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD *)data;
2610
2611 cmd->DW0.DwordLength = mhw_vdbox_mfx_g12_X::GetOpLength(mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::dwSize);
2612 cmd->DW0.SubOpcodeB = mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::SUB_OPCODE_B_MFXVP8ENCODERCFG;
2613 cmd->DW0.SubOpcodeA = mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::SUB_OPCODE_A_VP8COMMON;
2614 cmd->DW0.MediaCommandOpcode = mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::MEDIA_COMMAND_OPCODE_VP8;
2615 cmd->DW0.Pipeline = mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::PIPELINE_VIDEOCODEC;
2616 cmd->DW0.CommandType = mhw_vdbox_mfx_g12_X::MFX_VP8_Encoder_CFG_CMD::COMMAND_TYPE_PARALLELVIDEOPIPE;
2617
2618 cmd->DW1.Value = 0;
2619 cmd->DW2.Value = 0;
2620 cmd->DW3.Value = 0;
2621 cmd->DW4.Value = 0;
2622 cmd->DW5.Value = 0;
2623 cmd->DW6.Value = 0;
2624 cmd->DW7.Value = 0;
2625 cmd->DW8.Value = 0;
2626 cmd->DW9.Value = 0;
2627 cmd->DW10.Value = 0;
2628 cmd->DW11.Value = 0;
2629 cmd->DW12.Value = 0;
2630 cmd->DW13.Value = 0;
2631 cmd->DW14.Value = 0;
2632 cmd->DW15.Value = 0;
2633 cmd->DW16.Value = 0;
2634 cmd->DW17.Value = 0;
2635 cmd->DW18.Value = 0;
2636 cmd->DW19.Value = 0;
2637 cmd->DW20.Value = 0;
2638 cmd->DW22.Value = 0;
2639 cmd->DW23.Value = 0;
2640 cmd->DW24.Value = 0;
2641 cmd->DW25.Value = 0;
2642 cmd->DW26.Value = 0;
2643 cmd->DW27.Value = 0;
2644 cmd->DW28.Value = 0;
2645 cmd->DW29.Value = 0;
2646
2647 cmd->DW1.RateControlInitialPass = params->bFirstPass ? 1 : 0;
2648 cmd->DW1.PerSegmentDeltaQindexLoopfilterDisable = (params->bFirstPass || !params->bBRCEnabled);
2649 cmd->DW1.TokenStatisticsOutputEnable = 1;
2650
2651 if (picParams->segmentation_enabled)
2652 {
2653 cmd->DW1.UpdateSegmentFeatureDataFlag = 1;
2654 }
2655
2656 if (params->bBRCEnabled)
2657 {
2658 //Add BRC init below
2659 cmd->DW2.MaxFrameBitCountRateControlEnableMask = 1;
2660 cmd->DW2.MinFrameBitCountRateControlEnableMask = 1;
2661 }
2662
2663 cmd->DW22.ShowFrame = picParams->show_frame;
2664 cmd->DW22.BitstreamFormatVersion = picParams->version;
2665
2666 cmd->DW23.HorizontalSizeCode = ((seqParams->FrameWidthScale << 14) | seqParams->FrameWidth);
2667 cmd->DW23.VerticalSizeCode = ((seqParams->FrameHeightScale << 14) | seqParams->FrameHeight);
2668
2669 //Add batch buffer end command
2670 data += sizeof(*cmd);
2671
2672 mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD *miBatchBufferEndCmd = (mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD *)data;
2673 *miBatchBufferEndCmd = mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD();
2674
2675 MHW_MI_CHK_STATUS(m_osInterface->pfnUnlockResource(
2676 m_osInterface,
2677 cfgCmdBuffer));
2678
2679 return eStatus;
2680 }
2681
2682 MOS_STATUS MhwVdboxMfxInterfaceG12::AddMfxVp8BspBufBaseAddrCmd(
2683 PMOS_COMMAND_BUFFER cmdBuffer,
2684 PMHW_VDBOX_VP8_BSP_BUF_BASE_ADDR_PARAMS params)
2685 {
2686 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2687
2688 MHW_FUNCTION_ENTER;
2689
2690 MHW_MI_CHK_NULL(m_osInterface);
2691 MHW_MI_CHK_NULL(cmdBuffer);
2692 MHW_MI_CHK_NULL(params);
2693
2694 if (params->dwPartitions == 0 || params->dwPartitions >= m_vp8MaxNumPartitions)
2695 {
2696 MHW_ASSERTMESSAGE("Invalid Partitions.");
2697 eStatus = MOS_STATUS_INVALID_PARAMETER;
2698 return eStatus;
2699 }
2700
2701 mhw_vdbox_mfx_g12_X::MFX_VP8_BSP_BUF_BASE_ADDR_STATE_CMD cmd;
2702
2703 MHW_RESOURCE_PARAMS resourceParams;
2704 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
2705 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
2706 resourceParams.HwCommandType = MOS_MFX_BSP_BUF_BASE_ADDR;
2707
2708 if (params->presFrameHeaderBuffer)
2709 {
2710 cmd.DW3.Value =
2711 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
2712
2713 resourceParams.presResource = params->presFrameHeaderBuffer;
2714 resourceParams.dwOffset = 0;
2715 resourceParams.pdwCmd = &(cmd.DW1.Value);
2716 resourceParams.dwLocationInCmd = 1;
2717 resourceParams.bIsWritable = true;
2718
2719 MHW_MI_CHK_STATUS(AddResourceToCmd(
2720 m_osInterface,
2721 cmdBuffer,
2722 &resourceParams));
2723 }
2724
2725 if (params->presPakIntermediateBuffer)
2726 {
2727 cmd.DW6.Value =
2728 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
2729
2730 resourceParams.presResource = params->presPakIntermediateBuffer;
2731 resourceParams.dwOffset = 0;
2732 resourceParams.pdwCmd = &(cmd.DW4.Value);
2733 resourceParams.dwLocationInCmd = 4;
2734 resourceParams.bIsWritable = true;
2735
2736 MHW_MI_CHK_STATUS(AddResourceToCmd(
2737 m_osInterface,
2738 cmdBuffer,
2739 &resourceParams));
2740
2741 uint32_t partitionSize = (params->dwPakIntermediateTokenSize / params->dwPartitions);
2742 cmd.DW7.IntermediateBufferPartition1Offset = MOS_ALIGN_CEIL(params->dwPakIntermediatePartition0Size, 64);
2743 cmd.DW8.IntermediateBufferPartition2Offset = MOS_ALIGN_CEIL(cmd.DW7.IntermediateBufferPartition1Offset + partitionSize, 64);
2744 cmd.DW9.IntermediateBufferPartition3Offset = MOS_ALIGN_CEIL(cmd.DW8.IntermediateBufferPartition2Offset + partitionSize, 64);
2745 cmd.DW10.IntermediateBufferPartition4Offset = MOS_ALIGN_CEIL(cmd.DW9.IntermediateBufferPartition3Offset + partitionSize, 64);
2746 cmd.DW11.IntermediateBufferPartition5Offset = MOS_ALIGN_CEIL(cmd.DW10.IntermediateBufferPartition4Offset + partitionSize, 64);
2747 cmd.DW12.IntermediateBufferPartition6Offset = MOS_ALIGN_CEIL(cmd.DW11.IntermediateBufferPartition5Offset + partitionSize, 64);
2748 cmd.DW13.IntermediateBufferPartition7Offset = MOS_ALIGN_CEIL(cmd.DW12.IntermediateBufferPartition6Offset + partitionSize, 64);
2749 cmd.DW14.IntermediateBufferPartition8Offset = MOS_ALIGN_CEIL(cmd.DW13.IntermediateBufferPartition7Offset + partitionSize, 64);
2750
2751 cmd.DW15.IntermediateBufferMaxSize = params->dwPakIntermediateTokenSize + params->dwPakIntermediatePartition0Size;
2752 }
2753
2754 if (params->presPakFinalFrameBuffer)
2755 {
2756 cmd.DW18.Value =
2757 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
2758
2759 resourceParams.presResource = params->presPakFinalFrameBuffer;
2760 resourceParams.dwOffset = 0;
2761 resourceParams.pdwCmd = &(cmd.DW16.Value);
2762 resourceParams.dwLocationInCmd = 16;
2763 resourceParams.bIsWritable = true;
2764
2765 MHW_MI_CHK_STATUS(AddResourceToCmd(
2766 m_osInterface,
2767 cmdBuffer,
2768 &resourceParams));
2769 }
2770
2771 if (params->presCoeffProbsBuffer)
2772 {
2773 cmd.DW25.Value =
2774 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
2775
2776 resourceParams.presResource = params->presCoeffProbsBuffer;
2777 resourceParams.dwOffset = 0;
2778 resourceParams.pdwCmd = &(cmd.DW23.Value);
2779 resourceParams.dwLocationInCmd = 23;
2780 resourceParams.bIsWritable = true;
2781
2782 MHW_MI_CHK_STATUS(AddResourceToCmd(
2783 m_osInterface,
2784 cmdBuffer,
2785 &resourceParams));
2786 }
2787
2788 if (params->presTokenStatisticsBuffer)
2789 {
2790 cmd.DW28.Value =
2791 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_MV_DATA_ENCODE].Value;
2792
2793 resourceParams.presResource = params->presTokenStatisticsBuffer;
2794 resourceParams.dwOffset = 0;
2795 resourceParams.pdwCmd = &(cmd.DW26.Value);
2796 resourceParams.dwLocationInCmd = 26;
2797 resourceParams.bIsWritable = true;
2798
2799 MHW_MI_CHK_STATUS(AddResourceToCmd(
2800 m_osInterface,
2801 cmdBuffer,
2802 &resourceParams));
2803 }
2804
2805 if (params->presBsdMpcRowStoreScratchBuffer)
2806 {
2807 cmd.DW31.Value =
2808 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_BSDMPC_ROWSTORE_SCRATCH_BUFFER_CODEC].Value;
2809
2810 resourceParams.presResource = params->presBsdMpcRowStoreScratchBuffer;
2811 resourceParams.dwOffset = 0;
2812 resourceParams.pdwCmd = &(cmd.DW29_30.Value[0]);
2813 resourceParams.dwLocationInCmd = 29;
2814 resourceParams.bIsWritable = true;
2815
2816 MHW_MI_CHK_STATUS(AddResourceToCmd(
2817 m_osInterface,
2818 cmdBuffer,
2819 &resourceParams));
2820 }
2821
2822 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
2823
2824 return eStatus;
2825 }
2826