Debian Codegraph @

media_driver/agnostic/gen9/hw/vdbox/mhw_vdbox_mfx_g9_X.h

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