Debian Codegraph @

media_driver/agnostic/gen11/hw/vdbox/mhw_vdbox_mfx_g11_X.cpp

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