Debian Codegraph @

media_driver/agnostic/gen8/hw/vdbox/mhw_vdbox_mfx_g8_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_g8_X.h
24 //! \brief Defines functions for constructing Vdbox MFX commands on Gen8-based platforms
25 //!
26
27 #ifndef __MHW_VDBOX_MFX_G8_X_H__
28 #define __MHW_VDBOX_MFX_G8_X_H__
29
30 #include "mhw_vdbox_mfx_generic.h"
31 #include "mhw_mi_hwcmd_g8_X.h"
32 #include "mhw_mmio_g8.h"
33
34 //! MHW Vdbox Mfx interface for Gen8
35 /*!
36 This class defines the Mfx command construction functions for Gen8 platforms as template
37 */
38 template <class TMfxCmds>
39 class MhwVdboxMfxInterfaceG8 : public MhwVdboxMfxInterfaceGeneric<TMfxCmds, mhw_mi_g8_X>
40 {
41 protected:
42 // Value found by experiments to allow all MBs to be converted to IPCM
43 // if lower values are used as threshold not all MBs are converted to IPCM.
44 static const uint32_t m_avcInterMbMaxSize = 4095; //! AVC inter macroblock max size
45 static const uint32_t m_avcIntraMbMaxSize = 2700; //! AVC intra macroblock max size
46
47 #define PATCH_LIST_COMMAND(x) (x##_NUMBER_OF_ADDRESSES)
48
49 enum CommandsNumberOfAddresses
50 {
51 // Render Engine Commands
52 PIPE_CONTROL_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
53 PIPELINE_SELECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
54 STATE_BASE_ADDRESS_CMD_NUMBER_OF_ADDRESSES = 5, // 10 DW for 5 address fields
55 MEDIA_VFE_STATE_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
56 MEDIA_CURBE_LOAD_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
57 MEDIA_INTERFACE_DESCRIPTOR_LOAD_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
58 MEDIA_OBJECT_WALKER_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
59 MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
60 MI_STORE_DATA_IMM_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
61 MI_COPY_MEM_MEM_CMD_NUMBER_OF_ADDRESSES = 4, // 4 DW for 2 address fields
62
63 // MFX Engine Commands
64 MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
65 MI_CONDITIONAL_BATCH_BUFFER_END_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
66 MI_STORE_REGISTER_MEM_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
67 MI_ATOMIC_CMD_NUMBER_OF_ADDRESSES = 1, // 2 DW for 1 address field
68 MFX_PIPE_MODE_SELECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
69 MFX_SURFACE_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
70 MFX_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 25, // 50 DW for 25 address fields
71 MFX_IND_OBJ_BASE_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 5, // 10 DW for 5 address fields
72 MFX_WAIT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
73 MFX_BSP_BUF_BASE_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 3, // 2 DW for 3 address fields
74 MFD_AVC_PICID_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
75 MFX_AVC_DIRECTMODE_STATE_CMD_NUMBER_OF_ADDRESSES = 17, // 50 DW for 17 address fields
76 MFX_AVC_IMG_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
77 MFX_QM_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
78
79 MFX_FQM_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
80 MFD_VC1_LONG_PIC_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
81 MFD_VC1_SHORT_PIC_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
82 MFX_VC1_PRED_PIPE_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
83 MFX_VC1_DIRECTMODE_STATE_CMD_NUMBER_OF_ADDRESSES = 2, // 2 DW for 2 address fields
84 MFX_MPEG2_PIC_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
85 MFX_DBK_OBJECT_CMD_NUMBER_OF_ADDRESSES = 4, // 2 DW for 4 address fields
86 MFX_VP8_PIC_STATE_CMD_NUMBER_OF_ADDRESSES = 2, // 2 DW for 2 address fields
87 MFX_AVC_SLICE_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
88 MFD_AVC_BSD_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
89 MFD_AVC_DPB_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
90 MFD_AVC_SLICEADDR_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
91 MFX_AVC_REF_IDX_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
92 MFX_AVC_WEIGHTOFFSET_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
93 MFC_AVC_PAK_INSERT_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
94 MFD_VC1_BSD_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
95 MFD_VC1_IT_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
96 MFD_MPEG2_BSD_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
97 MFD_MPEG2_IT_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
98 MFD_VP8_BSD_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
99
100 MFC_MPEG2_SLICEGROUP_STATE_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
101 MFC_PAK_INSERT_OBJECT_CMD_NUMBER_OF_ADDRESSES = 0, // 0 DW for address fields
102 };
103
104 protected:
105 //!
106 //! \brief Constructor
107 //!
108 MhwVdboxMfxInterfaceG8(
109 PMOS_INTERFACE osInterface,
110 MhwMiInterface *miInterface,
111 MhwCpInterface *cpInterface,
112 bool decodeInUse) :
113 MhwVdboxMfxInterfaceGeneric<TMfxCmds, mhw_mi_g8_X>(osInterface, miInterface, cpInterface, decodeInUse)
114 {
115 MHW_FUNCTION_ENTER;
116
117 InitMmioRegisters();
118 }
119
120 //!
121 //! \brief Destructor
122 //!
123 virtual ~MhwVdboxMfxInterfaceG8() { MHW_FUNCTION_ENTER; }
124
125 //!
126 //! \brief Check whether interview prediction is used for MVC
127 //!
128 //! \param [in] currPic
129 //! Current picture
130 //! \param [in] currPoc
131 //! Current POC
132 //! \param [in] refListIdx
133 //! Reference list index
134 //! \param [in] refList
135 //! Pointer to the reference list
136 //!
137 //! \return bool
138 //! True if interview prediction is used, false otherwise
139 //!
140 bool IsMvcInterviewPred(
141 const CODEC_PICTURE &currPic,
142 int32_t currPoc[CODEC_NUM_FIELDS_PER_FRAME],
143 uint8_t refListIdx,
144 PCODEC_REF_LIST *refList)
145 {
146 return (((refListIdx) != (currPic).FrameIdx) &&
147 (!CodecHal_PictureIsTopField(currPic) && (refList[refListIdx]->iFieldOrderCnt[1] == (currPoc)[1]) ||
148 !CodecHal_PictureIsBottomField(currPic) && (refList[refListIdx]->iFieldOrderCnt[0] == (currPoc)[0])) &&
149 ((currPic).FrameIdx != 0x7f));
150 }
151
152 void InitMmioRegisters()
153 {
154 MmioRegistersMfx *mmioRegisters = &this->m_mmioRegisters[MHW_VDBOX_NODE_1];
155
156 mmioRegisters->generalPurposeRegister0LoOffset = GENERAL_PURPOSE_REGISTER0_LO_OFFSET_NODE_1_INIT_G8;
157 mmioRegisters->generalPurposeRegister0HiOffset = GENERAL_PURPOSE_REGISTER0_HI_OFFSET_NODE_1_INIT_G8;
158 mmioRegisters->generalPurposeRegister4LoOffset = GENERAL_PURPOSE_REGISTER4_LO_OFFSET_NODE_1_INIT_G8;
159 mmioRegisters->generalPurposeRegister4HiOffset = GENERAL_PURPOSE_REGISTER4_HI_OFFSET_NODE_1_INIT_G8;
160 mmioRegisters->generalPurposeRegister11LoOffset = GENERAL_PURPOSE_REGISTER11_LO_OFFSET_NODE_1_INIT_G8;
161 mmioRegisters->generalPurposeRegister11HiOffset = GENERAL_PURPOSE_REGISTER11_HI_OFFSET_NODE_1_INIT_G8;
162 mmioRegisters->generalPurposeRegister12LoOffset = GENERAL_PURPOSE_REGISTER12_LO_OFFSET_NODE_1_INIT_G8;
163 mmioRegisters->generalPurposeRegister12HiOffset = GENERAL_PURPOSE_REGISTER12_HI_OFFSET_NODE_1_INIT_G8;
164 mmioRegisters->mfcImageStatusMaskRegOffset = MFC_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT_G8;
165 mmioRegisters->mfcImageStatusCtrlRegOffset = MFC_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT_G8;
166 mmioRegisters->mfcAvcNumSlicesRegOffset = MFC_AVC_NUM_SLICES_REG_OFFSET_NODE_1_INIT_G8;
167 mmioRegisters->mfcQPStatusCountOffset = MFC_QP_STATUS_COUNT_OFFSET_NODE_1_INIT_G8;
168 mmioRegisters->mfxErrorFlagsRegOffset = MFX_ERROR_FLAG_REG_OFFSET_NODE_1_INIT_G8;
169 mmioRegisters->mfxFrameCrcRegOffset = MFX_FRAME_CRC_REG_OFFSET_NODE_1_INIT_G8;
170 mmioRegisters->mfxMBCountRegOffset = MFX_MB_COUNT_REG_OFFSET_NODE_1_INIT_G8;
171 mmioRegisters->mfcBitstreamBytecountFrameRegOffset = MFC_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G8;
172 mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset = MFC_BITSTREAM_SE_BITCOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G8;
173 mmioRegisters->mfcBitstreamBytecountSliceRegOffset = MFC_BITSTREAM_BYTECOUNT_SLICE_REG_OFFSET_NODE_1_INIT_G8;
174 mmioRegisters->mfcVP8BitstreamBytecountFrameRegOffset = MFC_VP8_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT_G8;
175 mmioRegisters->mfcVP8ImageStatusMaskRegOffset = MFC_VP8_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT_G8;
176 mmioRegisters->mfcVP8ImageStatusCtrlRegOffset = MFC_VP8_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT_G8;
177 mmioRegisters->mfxVP8BrcDQIndexRegOffset = MFX_VP8_BRC_DQ_INDEX_REG_OFFSET_NODE_1_INIT_G8;
178 mmioRegisters->mfxVP8BrcDLoopFilterRegOffset = MFX_VP8_BRC_LOOP_FILTER_REG_OFFSET_NODE_1_INIT_G8;
179 mmioRegisters->mfxVP8BrcCumulativeDQIndex01RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX01_REG_OFFSET_NODE_1_INIT_G8;
180 mmioRegisters->mfxVP8BrcCumulativeDQIndex23RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX23_REG_OFFSET_NODE_1_INIT_G8;
181 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter01RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER01_REG_OFFSET_NODE_1_INIT_G8;
182 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter23RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER23_REG_OFFSET_NODE_1_INIT_G8;
183 mmioRegisters->mfxVP8BrcConvergenceStatusRegOffset = MFX_VP8_BRC_CONVERGENCE_STATUS_REG_OFFSET_NODE_1_INIT_G8;
184 mmioRegisters->mfxLra0RegOffset = MFX_LRA0_REG_OFFSET_NODE_1_INIT_G8;
185 mmioRegisters->mfxLra1RegOffset = MFX_LRA1_REG_OFFSET_NODE_1_INIT_G8;
186 mmioRegisters->mfxLra2RegOffset = MFX_LRA2_REG_OFFSET_NODE_1_INIT_G8;
187
188 mmioRegisters = &this->m_mmioRegisters[MHW_VDBOX_NODE_2];
189
190 mmioRegisters->generalPurposeRegister0LoOffset = GENERAL_PURPOSE_REGISTER0_LO_OFFSET_NODE_2_INIT_G8;
191 mmioRegisters->generalPurposeRegister0HiOffset = GENERAL_PURPOSE_REGISTER0_HI_OFFSET_NODE_2_INIT_G8;
192 mmioRegisters->generalPurposeRegister4LoOffset = GENERAL_PURPOSE_REGISTER4_LO_OFFSET_NODE_2_INIT_G8;
193 mmioRegisters->generalPurposeRegister4HiOffset = GENERAL_PURPOSE_REGISTER4_HI_OFFSET_NODE_2_INIT_G8;
194 mmioRegisters->generalPurposeRegister11LoOffset = GENERAL_PURPOSE_REGISTER11_LO_OFFSET_NODE_2_INIT_G8;
195 mmioRegisters->generalPurposeRegister11HiOffset = GENERAL_PURPOSE_REGISTER11_HI_OFFSET_NODE_2_INIT_G8;
196 mmioRegisters->generalPurposeRegister12LoOffset = GENERAL_PURPOSE_REGISTER12_LO_OFFSET_NODE_2_INIT_G8;
197 mmioRegisters->generalPurposeRegister12HiOffset = GENERAL_PURPOSE_REGISTER12_HI_OFFSET_NODE_2_INIT_G8;
198 mmioRegisters->mfcImageStatusMaskRegOffset = MFC_IMAGE_STATUS_MASK_REG_OFFSET_NODE_2_INIT_G8;
199 mmioRegisters->mfcImageStatusCtrlRegOffset = MFC_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_2_INIT_G8;
200 mmioRegisters->mfcAvcNumSlicesRegOffset = MFC_AVC_NUM_SLICES_REG_OFFSET_NODE_2_INIT_G8;
201 mmioRegisters->mfcQPStatusCountOffset = MFC_QP_STATUS_COUNT_OFFSET_NODE_2_INIT_G8;
202 mmioRegisters->mfxErrorFlagsRegOffset = MFX_ERROR_FLAG_REG_OFFSET_NODE_2_INIT_G8;
203 mmioRegisters->mfxFrameCrcRegOffset = MFX_FRAME_CRC_REG_OFFSET_NODE_2_INIT_G8;
204 mmioRegisters->mfxMBCountRegOffset = MFX_MB_COUNT_REG_OFFSET_NODE_2_INIT_G8;
205 mmioRegisters->mfcBitstreamBytecountFrameRegOffset = MFC_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_2_INIT_G8;
206 mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset = MFC_BITSTREAM_SE_BITCOUNT_FRAME_REG_OFFSET_NODE_2_INIT_G8;
207 mmioRegisters->mfcBitstreamBytecountSliceRegOffset = MFC_BITSTREAM_BYTECOUNT_SLICE_REG_OFFSET_NODE_2_INIT_G8;
208 mmioRegisters->mfcVP8BitstreamBytecountFrameRegOffset = MFC_VP8_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_2_INIT_G8;
209 mmioRegisters->mfcVP8ImageStatusMaskRegOffset = MFC_VP8_IMAGE_STATUS_MASK_REG_OFFSET_NODE_2_INIT_G8;
210 mmioRegisters->mfcVP8ImageStatusCtrlRegOffset = MFC_VP8_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_2_INIT_G8;
211 mmioRegisters->mfxVP8BrcDQIndexRegOffset = MFX_VP8_BRC_DQ_INDEX_REG_OFFSET_NODE_2_INIT_G8;
212 mmioRegisters->mfxVP8BrcDLoopFilterRegOffset = MFX_VP8_BRC_LOOP_FILTER_REG_OFFSET_NODE_2_INIT_G8;
213 mmioRegisters->mfxVP8BrcCumulativeDQIndex01RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX01_REG_OFFSET_NODE_2_INIT_G8;
214 mmioRegisters->mfxVP8BrcCumulativeDQIndex23RegOffset = MFX_VP8_BRC_CUMULATIVE_DQ_INDEX23_REG_OFFSET_NODE_2_INIT_G8;
215 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter01RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER01_REG_OFFSET_NODE_2_INIT_G8;
216 mmioRegisters->mfxVP8BrcCumulativeDLoopFilter23RegOffset = MFX_VP8_BRC_CUMULATIVE_LOOP_FILTER23_REG_OFFSET_NODE_2_INIT_G8;
217 mmioRegisters->mfxVP8BrcConvergenceStatusRegOffset = MFX_VP8_BRC_CONVERGENCE_STATUS_REG_OFFSET_NODE_2_INIT_G8;
218 mmioRegisters->mfxLra0RegOffset = MFX_LRA0_REG_OFFSET_NODE_2_INIT_G8;
219 mmioRegisters->mfxLra1RegOffset = MFX_LRA1_REG_OFFSET_NODE_2_INIT_G8;
220 mmioRegisters->mfxLra2RegOffset = MFX_LRA2_REG_OFFSET_NODE_2_INIT_G8;
221 }
222
223 MOS_STATUS FindGpuNodeToUse(
224 PMHW_VDBOX_GPUNODE_LIMIT gpuNodeLimit)
225 {
226 MOS_GPU_NODE videoGpuNode = MOS_GPU_NODE_VIDEO;
227 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
228
229 if (MEDIA_IS_SKU(this->m_skuTable, FtrVcs2))
230 {
231 // BDW only
232 bool setVideoNode = false;
233
234 //If 2VDBox feature check for Content Protection, default to Master VDBox.
235 if (this->m_osInterface->osCpInterface->IsCpEnabled())
236 {
237 setVideoNode = true;
238 videoGpuNode = MOS_GPU_NODE_VIDEO;
239 }
240
241 MHW_MI_CHK_STATUS(this->m_osInterface->pfnCreateVideoNodeAssociation(
242 this->m_osInterface,
243 setVideoNode,
244 &videoGpuNode));
245 }
246
247 gpuNodeLimit->dwGpuNodeToUse = videoGpuNode;
248
249 return eStatus;
250 }
251
252 MOS_STATUS GetMfxStateCommandsDataSize(
253 uint32_t mode,
254 uint32_t *commandsSize,
255 uint32_t *patchListSize,
256 bool isShortFormat)
257 {
258 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
259
260 MHW_FUNCTION_ENTER;
261
262 MHW_MI_CHK_NULL(commandsSize);
263 MHW_MI_CHK_NULL(patchListSize);
264
265 uint32_t maxSize =
266 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize +
267 TMfxCmds::MFX_PIPE_MODE_SELECT_CMD::byteSize +
268 TMfxCmds::MFX_SURFACE_STATE_CMD::byteSize +
269 TMfxCmds::MFX_PIPE_BUF_ADDR_STATE_CMD::byteSize +
270 TMfxCmds::MFX_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
271 2 * mhw_mi_g8_X::MI_STORE_DATA_IMM_CMD::byteSize +
272 2 * mhw_mi_g8_X::MI_STORE_REGISTER_MEM_CMD::byteSize;
273
274 uint32_t patchListMaxSize =
275 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
276 PATCH_LIST_COMMAND(MFX_PIPE_MODE_SELECT_CMD) +
277 PATCH_LIST_COMMAND(MFX_SURFACE_STATE_CMD) +
278 PATCH_LIST_COMMAND(MFX_PIPE_BUF_ADDR_STATE_CMD) +
279 PATCH_LIST_COMMAND(MFX_IND_OBJ_BASE_ADDR_STATE_CMD) +
280 (2 * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD)) +
281 (2 * PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD));
282
283 uint32_t standard = CodecHal_GetStandardFromMode(mode);
284
285 if (standard == CODECHAL_AVC)
286 {
287 maxSize +=
288 TMfxCmds::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
289 TMfxCmds::MFD_AVC_PICID_STATE_CMD::byteSize +
290 TMfxCmds::MFX_AVC_DIRECTMODE_STATE_CMD::byteSize +
291 TMfxCmds::MFX_AVC_IMG_STATE_CMD::byteSize +
292 TMfxCmds::MFX_QM_STATE_CMD::byteSize * 4 + // QM_State sent 4 times
293 TMfxCmds::MFX_FQM_STATE_CMD::byteSize * 4;
294
295 patchListMaxSize +=
296 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
297 PATCH_LIST_COMMAND(MFD_AVC_PICID_STATE_CMD) +
298 PATCH_LIST_COMMAND(MFX_AVC_DIRECTMODE_STATE_CMD) +
299 PATCH_LIST_COMMAND(MFX_AVC_IMG_STATE_CMD) +
300 (PATCH_LIST_COMMAND(MFX_QM_STATE_CMD) * 4) +
301 (PATCH_LIST_COMMAND(MFX_FQM_STATE_CMD) * 4);
302
303 if (mode == CODECHAL_ENCODE_MODE_AVC)
304 {
305 maxSize +=
306 mhw_mi_g8_X::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize +
307 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize * 3 + // 3 extra MI_FLUSH_DWs for encode
308 TMfxCmds::MFX_FQM_STATE_CMD::byteSize * 4 + // FQM_State sent 4 times
309 mhw_mi_g8_X::MI_STORE_REGISTER_MEM_CMD::byteSize * 8 + // 5 extra register queries for encode, 3 extra slice level commands for BrcPakStatistics
310 mhw_mi_g8_X::MI_STORE_DATA_IMM_CMD::byteSize * 3 + // slice level commands for StatusReport, BrcPakStatistics
311 MHW_VDBOX_PAK_BITSTREAM_OVERFLOW_SIZE + // accounting for the max DW payload for PAK_INSERT_OBJECT, for frame header payload
312 TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD::byteSize * 4; // for inserting AU, SPS, PSP, SEI headers before first slice header
313
314 patchListMaxSize +=
315 PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD) +
316 (PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 3) +
317 (PATCH_LIST_COMMAND(MFX_FQM_STATE_CMD) * 4) +
318 (PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD) * 8) + // 3 extra slice level commands for BrcPakStatistics
319 (PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD) * 3) + // slice level commands for StatusReport, BrcPakStatistics
320 (PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD) * 4);
321 }
322 else
323 {
324 // this must be AVC decode case
325 // add MI_BATCH_BUFFER_START_CMD for special case
326 maxSize +=
327 mhw_mi_g8_X::MI_BATCH_BUFFER_START_CMD::byteSize;
328
329 patchListMaxSize +=
330 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD);
331 }
332 }
333 else if (standard == CODECHAL_VC1)
334 {
335 maxSize +=
336 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize +
337 TMfxCmds::MFX_VC1_PRED_PIPE_STATE_CMD::byteSize;
338
339 patchListMaxSize +=
340 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
341 PATCH_LIST_COMMAND(MFX_VC1_PRED_PIPE_STATE_CMD);
342
343 if (mode == CODECHAL_DECODE_MODE_VC1VLD)
344 {
345 maxSize +=
346 TMfxCmds::MFX_VC1_DIRECTMODE_STATE_CMD::byteSize +
347 TMfxCmds::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize;
348
349 maxSize += isShortFormat ?
350 TMfxCmds::MFD_VC1_SHORT_PIC_STATE_CMD::byteSize :
351 TMfxCmds::MFD_VC1_LONG_PIC_STATE_CMD::byteSize;
352
353 patchListMaxSize +=
354 PATCH_LIST_COMMAND(MFX_VC1_DIRECTMODE_STATE_CMD) +
355 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD);
356
357 patchListMaxSize += isShortFormat ?
358 PATCH_LIST_COMMAND(MFD_VC1_SHORT_PIC_STATE_CMD) :
359 PATCH_LIST_COMMAND(MFD_VC1_LONG_PIC_STATE_CMD);
360 }
361 else if (mode == CODECHAL_DECODE_MODE_VC1IT)
362 {
363 maxSize +=
364 TMfxCmds::MFD_VC1_LONG_PIC_STATE_CMD::byteSize +
365 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize * 2;
366
367 patchListMaxSize +=
368 PATCH_LIST_COMMAND(MFD_VC1_LONG_PIC_STATE_CMD) +
369 (PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2);
370 }
371 }
372 else if (standard == CODECHAL_MPEG2)
373 {
374 maxSize += TMfxCmds::MFX_MPEG2_PIC_STATE_CMD::byteSize;
375 patchListMaxSize += PATCH_LIST_COMMAND(MFX_MPEG2_PIC_STATE_CMD);
376
377 if (mode == CODECHAL_DECODE_MODE_MPEG2VLD)
378 {
379 maxSize +=
380 TMfxCmds::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
381 ((TMfxCmds::MFX_QM_STATE_CMD::byteSize + (MhwVdboxMfxInterface::m_mpeg2WeightScaleSize * sizeof(uint32_t))) * 2);
382
383 patchListMaxSize +=
384 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
385 (PATCH_LIST_COMMAND(MFX_QM_STATE_CMD) * 2);
386 }
387 else if (mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
388 {
389 maxSize +=
390 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize * 2;
391
392 patchListMaxSize +=
393 (PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2);
394 }
395 }
396 else if (standard == CODECHAL_VP8)
397 {
398 maxSize +=
399 TMfxCmds::MFX_BSP_BUF_BASE_ADDR_STATE_CMD::byteSize +
400 TMfxCmds::MFX_VP8_PIC_STATE_CMD::byteSize;
401
402 patchListMaxSize +=
403 PATCH_LIST_COMMAND(MFX_BSP_BUF_BASE_ADDR_STATE_CMD) +
404 PATCH_LIST_COMMAND(MFX_VP8_PIC_STATE_CMD);
405 }
406 else if (standard == CODECHAL_JPEG)
407 {
408 // Adding so that error does not occur for JPEG
409 }
410 else
411 {
412 MHW_ASSERTMESSAGE("Unsupported decode mode.");
413 maxSize = 0;
414 patchListMaxSize = 0;
415 eStatus = MOS_STATUS_UNKNOWN;
416 }
417
418 *commandsSize = maxSize;
419 *patchListSize = patchListMaxSize;
420
421 return eStatus;
422 }
423
424 MOS_STATUS GetMfxPrimitiveCommandsDataSize(
425 uint32_t mode,
426 uint32_t *commandsSize,
427 uint32_t *patchListSize,
428 bool isModeSpecific)
429 {
430 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
431
432 MHW_FUNCTION_ENTER;
433
434 MHW_MI_CHK_NULL(commandsSize);
435 MHW_MI_CHK_NULL(patchListSize);
436
437 uint32_t maxSize = 0, patchListMaxSize = 0;
438 uint32_t standard = CodecHal_GetStandardFromMode(mode);
439
440 if (standard == CODECHAL_AVC)
441 {
442 if (mode == CODECHAL_DECODE_MODE_AVCVLD)
443 {
444 maxSize =
445 TMfxCmds::MFX_AVC_SLICE_STATE_CMD::byteSize +
446 TMfxCmds::MFD_AVC_BSD_OBJECT_CMD::byteSize +
447 TMfxCmds::MFD_AVC_DPB_STATE_CMD::byteSize +
448 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize;
449
450 patchListMaxSize =
451 PATCH_LIST_COMMAND(MFX_AVC_SLICE_STATE_CMD) +
452 PATCH_LIST_COMMAND(MFD_AVC_BSD_OBJECT_CMD) +
453 PATCH_LIST_COMMAND(MFD_AVC_DPB_STATE_CMD) +
454 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
455
456 if (isModeSpecific)
457 {
458 // isModeSpecific = bShortFormat for AVC decode
459 maxSize +=
460 TMfxCmds::MFD_AVC_DPB_STATE_CMD::byteSize +
461 TMfxCmds::MFD_AVC_SLICEADDR_CMD::byteSize;
462
463 patchListMaxSize +=
464 PATCH_LIST_COMMAND(MFD_AVC_DPB_STATE_CMD) +
465 PATCH_LIST_COMMAND(MFD_AVC_SLICEADDR_CMD);
466 }
467 else
468 {
469 maxSize +=
470 (2 * TMfxCmds::MFX_AVC_REF_IDX_STATE_CMD::byteSize) +
471 (2 * TMfxCmds::MFX_AVC_WEIGHTOFFSET_STATE_CMD::byteSize);
472
473 patchListMaxSize +=
474 (2 * PATCH_LIST_COMMAND(MFX_AVC_REF_IDX_STATE_CMD)) +
475 (2 * PATCH_LIST_COMMAND(MFX_AVC_WEIGHTOFFSET_STATE_CMD));
476 }
477 }
478 else // CODECHAL_ENCODE_MODE_AVC
479 {
480 // 1 PAK_INSERT_OBJECT inserted for every end of frame/stream with 1 DW payload
481 maxSize = TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD::byteSize + sizeof(uint32_t);
482 patchListMaxSize = PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD);
483
484 if (isModeSpecific)
485 {
486 // isModeSpecific = bSingleTaskPhaseSupported for AVC encode
487 maxSize += (2 * mhw_mi_g8_X::MI_BATCH_BUFFER_START_CMD::byteSize);
488 patchListMaxSize += (2 * PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD));
489 }
490 else
491 {
492 maxSize +=
493 (2 * TMfxCmds::MFX_AVC_REF_IDX_STATE_CMD::byteSize) +
494 (2 * TMfxCmds::MFX_AVC_WEIGHTOFFSET_STATE_CMD::byteSize) +
495 TMfxCmds::MFX_AVC_SLICE_STATE_CMD::byteSize +
496 MHW_VDBOX_PAK_SLICE_HEADER_OVERFLOW_SIZE + // slice header payload
497 (2 * TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD::byteSize) +
498 mhw_mi_g8_X::MI_BATCH_BUFFER_START_CMD::byteSize +
499 mhw_mi_g8_X::MI_FLUSH_DW_CMD::byteSize;
500
501 patchListMaxSize +=
502 (2 * PATCH_LIST_COMMAND(MFX_AVC_REF_IDX_STATE_CMD)) +
503 (2 * PATCH_LIST_COMMAND(MFX_AVC_WEIGHTOFFSET_STATE_CMD)) +
504 PATCH_LIST_COMMAND(MFX_AVC_SLICE_STATE_CMD) +
505 (2 * PATCH_LIST_COMMAND(MFC_AVC_PAK_INSERT_OBJECT_CMD)) +
506 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD) +
507 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
508 }
509 }
510 }
511 else if (standard == CODECHAL_VC1)
512 {
513 if (mode == CODECHAL_DECODE_MODE_VC1VLD)
514 {
515 maxSize =
516 TMfxCmds::MFD_VC1_BSD_OBJECT_CMD::byteSize;
517
518 patchListMaxSize +=
519 PATCH_LIST_COMMAND(MFD_VC1_BSD_OBJECT_CMD);
520 }
521 else if (mode == CODECHAL_DECODE_MODE_VC1IT)
522 {
523 maxSize = TMfxCmds::MFD_IT_OBJECT_CMD::byteSize +
524 TMfxCmds::MFD_IT_OBJECT_VC1_INLINE_DATA_CMD::byteSize;
525
526 patchListMaxSize +=
527 PATCH_LIST_COMMAND(MFD_VC1_IT_OBJECT_CMD);
528 }
529 }
530 else if (standard == CODECHAL_MPEG2)
531 {
532 if (mode == CODECHAL_DECODE_MODE_MPEG2VLD)
533 {
534 maxSize =
535 TMfxCmds::MFD_MPEG2_BSD_OBJECT_CMD::byteSize;
536
537 patchListMaxSize =
538 PATCH_LIST_COMMAND(MFD_MPEG2_BSD_OBJECT_CMD);
539
540 }
541 else if (mode == CODECHAL_DECODE_MODE_MPEG2IDCT)
542 {
543 maxSize = TMfxCmds::MFD_IT_OBJECT_CMD::byteSize +
544 TMfxCmds::MFD_IT_OBJECT_MPEG2_INLINE_DATA_CMD::byteSize;
545
546 patchListMaxSize =
547 PATCH_LIST_COMMAND(MFD_MPEG2_IT_OBJECT_CMD);
548 }
549 else if (mode == CODECHAL_ENCODE_MODE_MPEG2)
550 {
551 maxSize =
552 TMfxCmds::MFC_MPEG2_SLICEGROUP_STATE_CMD::byteSize +
553 TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD::byteSize +
554 mhw_mi_g8_X::MI_BATCH_BUFFER_START_CMD::byteSize;
555
556 patchListMaxSize =
557 PATCH_LIST_COMMAND(MFC_MPEG2_SLICEGROUP_STATE_CMD) +
558 PATCH_LIST_COMMAND(MFC_PAK_INSERT_OBJECT_CMD) +
559 PATCH_LIST_COMMAND(MI_BATCH_BUFFER_START_CMD);
560 }
561 else
562 {
563 MHW_ASSERTMESSAGE("Unsupported decode/encode mode.");
564 eStatus = MOS_STATUS_UNKNOWN;
565 }
566 }
567 else if (standard == CODECHAL_VP8)
568 {
569 maxSize =
570 TMfxCmds::MFD_VP8_BSD_OBJECT_CMD::byteSize;
571
572 patchListMaxSize =
573 PATCH_LIST_COMMAND(MFD_VP8_BSD_OBJECT_CMD);
574 }
575 else
576 {
577 MHW_ASSERTMESSAGE("Unsupported decode mode.");
578 eStatus = MOS_STATUS_UNKNOWN;
579 }
580
581 *commandsSize = maxSize;
582 *patchListSize = patchListMaxSize;
583
584 return eStatus;
585 }
586
587 MOS_STATUS AddMfxPipeModeSelectCmd(
588 PMOS_COMMAND_BUFFER cmdBuffer,
589 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
590 {
591 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
592
593 MHW_FUNCTION_ENTER;
594
595 MHW_MI_CHK_NULL(this->m_osInterface);
596 MHW_MI_CHK_NULL(cmdBuffer);
597 MHW_MI_CHK_NULL(params);
598
599 typename TMfxCmds::MFX_PIPE_MODE_SELECT_CMD cmd;
600
601 MHW_MI_CHK_STATUS(this->m_cpInterface->SetProtectionSettingsForMfxPipeModeSelect((uint32_t *)&cmd));
602
603 cmd.DW1.StreamOutEnable = params->bStreamOutEnabled;
604 cmd.DW1.DeblockerStreamOutEnable = params->bDeblockerStreamOutEnable;
605
606 if (this->m_decodeInUse)
607 {
608 cmd.DW1.PreDeblockingOutputEnablePredeblockoutenable = params->bPreDeblockOutEnable;
609 cmd.DW1.PostDeblockingOutputEnablePostdeblockoutenable = params->bPostDeblockOutEnable;
610 cmd.DW1.CodecSelect = MhwVdboxMfxInterface::decoderCodec;
611 cmd.DW1.DecoderShortFormatMode = !params->bShortFormatInUse;
612
613 if (CodecHalIsDecodeModeVLD(params->Mode))
614 {
615 cmd.DW1.DecoderModeSelect = MhwVdboxMfxInterface::mfxDecoderModeVld;
616 }
617 else if (CodecHalIsDecodeModeIT(params->Mode))
618 {
619 cmd.DW1.DecoderModeSelect = MhwVdboxMfxInterface::mfxDecoderModeIt;
620 }
621 }
622 else
623 {
624 cmd.DW1.PostDeblockingOutputEnablePostdeblockoutenable = params->bPostDeblockOutEnable;
625 cmd.DW1.PreDeblockingOutputEnablePredeblockoutenable = params->bPreDeblockOutEnable;
626 cmd.DW1.CodecSelect = MhwVdboxMfxInterface::encoderCodec;
627 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
628 }
629
630 cmd.DW1.StandardSelect = CodecHal_GetStandardFromMode(params->Mode);
631
632 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
633
634 return eStatus;
635 }
636
637 MOS_STATUS AddMfxSurfaceCmd(
638 PMOS_COMMAND_BUFFER cmdBuffer,
639 PMHW_VDBOX_SURFACE_PARAMS params)
640 {
641 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
642
643 MHW_FUNCTION_ENTER;
644
645 MHW_MI_CHK_NULL(this->m_osInterface);
646 MHW_MI_CHK_NULL(cmdBuffer);
647 MHW_MI_CHK_NULL(params);
648 MHW_MI_CHK_NULL(params->psSurface);
649 MHW_ASSERT(params->Mode != CODECHAL_UNSUPPORTED_MODE);
650
651 typename TMfxCmds::MFX_SURFACE_STATE_CMD cmd;
652
653 cmd.DW1.SurfaceId = params->ucSurfaceStateId;
654
655 cmd.DW2.Height = params->psSurface->dwHeight - 1;
656 cmd.DW2.Width = params->psSurface->dwWidth - 1;
657
658 cmd.DW3.TileWalk = TMfxCmds::MFX_SURFACE_STATE_CMD::TILE_WALK_YMAJOR;
659 cmd.DW3.TiledSurface = 1;
660 cmd.DW3.InterleaveChroma = 1;
661 cmd.DW3.SurfacePitch = params->psSurface->dwPitch - 1;
662 cmd.DW3.SurfaceFormat = this->MosToMediaStateFormat(params->psSurface->Format);
663
664 cmd.DW4.YOffsetForUCb =
665 MOS_ALIGN_CEIL(params->psSurface->UPlaneOffset.iYOffset, MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY);
666
667 if (params->Mode == CODECHAL_DECODE_MODE_JPEG)
668 {
669 // this parameter must always be 0 for JPEG regardless of the YUV format
670 cmd.DW3.InterleaveChroma = 0;
671
672 // Separate function for JPEG decode because this surface format should match with that programmed
673 // in JPEG Picture State
674 cmd.DW3.SurfaceFormat = this->GetJpegDecodeFormat(params->psSurface->Format);
675 }
676
677 if (this->IsVPlanePresent(params->psSurface->Format))
678 {
679 cmd.DW5.YOffsetForVCr =
680 MOS_ALIGN_CEIL(params->psSurface->VPlaneOffset.iYOffset, MHW_VDBOX_MFX_UV_PLANE_ALIGNMENT_LEGACY);
681 }
682
683 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
684
685 return eStatus;
686 }
687
688 MOS_STATUS AddMfxIndObjBaseAddrCmd(
689 PMOS_COMMAND_BUFFER cmdBuffer,
690 PMHW_VDBOX_IND_OBJ_BASE_ADDR_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 MHW_RESOURCE_PARAMS resourceParams;
701 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
702 resourceParams.dwLsbNum = MHW_VDBOX_MFX_UPPER_BOUND_STATE_SHIFT;
703 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
704
705 typename TMfxCmds::MFX_IND_OBJ_BASE_ADDR_STATE_CMD cmd;
706
707 // mode specific settings
708 if (CodecHalIsDecodeModeVLD(params->Mode) || (params->Mode == CODECHAL_ENCODE_MODE_VP8))
709 {
710 MHW_MI_CHK_NULL(params->presDataBuffer);
711
712 cmd.DW3.MemoryObjectControlState =
713 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Value;
714
715 resourceParams.presResource = params->presDataBuffer;
716 resourceParams.dwOffset = params->dwDataOffset;
717 resourceParams.pdwCmd = &(cmd.DW1.Value);
718 resourceParams.dwLocationInCmd = 1;
719 resourceParams.dwSize = params->dwDataSize;
720 resourceParams.bIsWritable = false;
721
722 // upper bound of the allocated resource will be set at 3 DW apart from address location
723 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
724
725 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
726 this->m_osInterface,
727 cmdBuffer,
728 &resourceParams));
729 }
730 else if (CodecHalIsDecodeModeIT(params->Mode))
731 {
732 MHW_MI_CHK_NULL(params->presDataBuffer);
733
734 cmd.DW13.MemoryObjectControlState =
735 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFD_INDIRECT_IT_COEF_OBJECT_DECODE].Value;
736
737 resourceParams.presResource = params->presDataBuffer;
738 resourceParams.dwOffset = 0;
739 resourceParams.pdwCmd = &(cmd.DW11.Value);
740 resourceParams.dwLocationInCmd = 11;
741 resourceParams.dwSize = params->dwDataSize;
742 resourceParams.bIsWritable = false;
743
744 // upper bound of the allocated resource will be set at 3 DW apart from address location
745 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
746
747 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
748 this->m_osInterface,
749 cmdBuffer,
750 &resourceParams));
751 }
752
753 if (params->presMvObjectBuffer)
754 {
755 cmd.DW8.MemoryObjectControlState =
756 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_MV_OBJECT_CODEC].Value;
757
758 resourceParams.presResource = params->presMvObjectBuffer;
759 resourceParams.dwOffset = params->dwMvObjectOffset;
760 resourceParams.pdwCmd = &(cmd.DW6.Value);
761 resourceParams.dwLocationInCmd = 6;
762 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwMvObjectSize, 0x1000);
763 resourceParams.bIsWritable = false;
764
765 // upper bound of the allocated resource will be set at 3 DW apart from address location
766 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
767
768 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
769 this->m_osInterface,
770 cmdBuffer,
771 &resourceParams));
772 }
773
774 if (params->presPakBaseObjectBuffer)
775 {
776 cmd.DW23.MemoryObjectControlState =
777 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFC_INDIRECT_PAKBASE_OBJECT_CODEC].Value;
778
779 resourceParams.presResource = params->presPakBaseObjectBuffer;
780 resourceParams.dwOffset = 0;
781 resourceParams.pdwCmd = &(cmd.DW21.Value);
782 resourceParams.dwLocationInCmd = 21;
783 resourceParams.dwSize = MOS_ALIGN_CEIL(params->dwPakBaseObjectSize, 0x1000);
784 resourceParams.bIsWritable = true;
785
786 // upper bound of the allocated resource will be set at 3 DW apart from address location
787 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
788
789 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
790 this->m_osInterface,
791 cmdBuffer,
792 &resourceParams));
793 }
794
795 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
796
797 return eStatus;
798 }
799
800 MOS_STATUS AddMfxDecodeAvcImgCmd(
801 PMOS_COMMAND_BUFFER cmdBuffer,
802 PMHW_BATCH_BUFFER batchBuffer,
803 PMHW_VDBOX_AVC_IMG_PARAMS params)
804 {
805 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
806
807 MHW_FUNCTION_ENTER;
808
809 MOS_UNUSED(batchBuffer);
810
811 MHW_MI_CHK_NULL(this->m_osInterface);
812 MHW_MI_CHK_NULL(cmdBuffer);
813 MHW_MI_CHK_NULL(params);
814 MHW_MI_CHK_NULL(params->pAvcPicParams);
815
816 auto avcPicParams = params->pAvcPicParams;
817
818 typename TMfxCmds::MFX_AVC_IMG_STATE_CMD cmd;
819
820 uint32_t numMBs =
821 (avcPicParams->pic_height_in_mbs_minus1 + 1) *
822 (avcPicParams->pic_width_in_mbs_minus1 + 1);
823
824 cmd.DW1.FrameSize = numMBs;
825 cmd.DW2.FrameHeight = avcPicParams->pic_height_in_mbs_minus1;
826 cmd.DW2.FrameWidth = avcPicParams->pic_width_in_mbs_minus1;
827 cmd.DW3.SecondChromaQpOffset = avcPicParams->second_chroma_qp_index_offset;
828 cmd.DW3.FirstChromaQpOffset = avcPicParams->chroma_qp_index_offset;
829 cmd.DW3.WeightedPredFlag = avcPicParams->pic_fields.weighted_pred_flag;
830 cmd.DW3.WeightedBipredIdc = avcPicParams->pic_fields.weighted_bipred_idc;
831 cmd.DW3.ImgstructImageStructureImgStructure10 = ((avcPicParams->CurrPic.PicFlags == PICTURE_FRAME) ?
832 MhwVdboxMfxInterface::avcFrame : (CodecHal_PictureIsTopField(avcPicParams->CurrPic) ?
833 MhwVdboxMfxInterface::avcTopField : MhwVdboxMfxInterface::avcBottomField));
834 cmd.DW4.Chromaformatidc = avcPicParams->seq_fields.chroma_format_idc;
835 cmd.DW4.Entropycodingflag = avcPicParams->pic_fields.entropy_coding_mode_flag;
836 cmd.DW4.Imgdisposableflag = !avcPicParams->pic_fields.reference_pic_flag;
837 cmd.DW4.Constrainedipredflag = avcPicParams->pic_fields.constrained_intra_pred_flag;
838 cmd.DW4.Direct8X8Infflag = avcPicParams->seq_fields.direct_8x8_inference_flag;
839 cmd.DW4.Transform8X8Flag = avcPicParams->pic_fields.transform_8x8_mode_flag;
840 cmd.DW4.Framembonlyflag = avcPicParams->seq_fields.frame_mbs_only_flag;
841 cmd.DW4.Mbaffflameflag =
842 avcPicParams->seq_fields.mb_adaptive_frame_field_flag && !avcPicParams->pic_fields.field_pic_flag;
843 cmd.DW4.Fieldpicflag = avcPicParams->pic_fields.field_pic_flag;
844
845 cmd.DW5.TrellisQuantizationRoundingTqr = 0;
846 cmd.DW5.TrellisQuantizationChromaDisableTqchromadisable = true;
847
848 cmd.DW13.CurrentPictureHasPerformedMmco5 = 0;
849 cmd.DW13.NumberOfReferenceFrames = params->ucActiveFrameCnt;
850 // These fields to be NumRefIdx(L0 or L1) Active - 1 at picture level
851 // But hardware expects the data without the minus 1 to keep this field consistent with
852 // NumRefIdxL0 and NumRefIdxL1 which appears at slice level. Thus the addition of 1
853 cmd.DW13.NumberOfActiveReferencePicturesFromL0 = avcPicParams->num_ref_idx_l0_active_minus1 + 1;
854 cmd.DW13.NumberOfActiveReferencePicturesFromL1 = avcPicParams->num_ref_idx_l1_active_minus1 + 1;
855
856 cmd.DW13.InitialQpValue = avcPicParams->pic_init_qp_minus26;
857 cmd.DW14.Log2MaxFrameNumMinus4 = avcPicParams->seq_fields.log2_max_frame_num_minus4;
858 cmd.DW14.Log2MaxPicOrderCntLsbMinus4 = avcPicParams->seq_fields.log2_max_pic_order_cnt_lsb_minus4;
859 cmd.DW14.DeblockingFilterControlPresentFlag = avcPicParams->pic_fields.deblocking_filter_control_present_flag;
860 cmd.DW14.NumSliceGroupsMinus1 = avcPicParams->num_slice_groups_minus1;
861 cmd.DW14.RedundantPicCntPresentFlag = avcPicParams->pic_fields.redundant_pic_cnt_present_flag;
862 cmd.DW14.PicOrderPresentFlag = avcPicParams->pic_fields.pic_order_present_flag;
863 cmd.DW14.SliceGroupMapType = avcPicParams->slice_group_map_type;
864 cmd.DW14.PicOrderCntType = avcPicParams->seq_fields.pic_order_cnt_type;
865 cmd.DW14.DeltaPicOrderAlwaysZeroFlag = avcPicParams->seq_fields.delta_pic_order_always_zero_flag;
866 cmd.DW15.CurrPicFrameNum = avcPicParams->frame_num;
867 cmd.DW15.SliceGroupChangeRate = avcPicParams->slice_group_change_rate_minus1;
868
869 auto mvcExtPicParams = params->pMvcExtPicParams;
870 if (mvcExtPicParams)
871 {
872 cmd.DW16.CurrentFrameViewId = mvcExtPicParams->CurrViewID;
873 cmd.DW16.MaxViewIdxl0 = mvcExtPicParams->NumInterViewRefsL0;
874 cmd.DW16.MaxViewIdxl1 = mvcExtPicParams->NumInterViewRefsL1;
875 cmd.DW16.InterViewOrderDisable = 0;
876 }
877
878 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
879
880 return eStatus;
881 }
882
883 MOS_STATUS AddMfxEncodeAvcImgCmd(
884 PMOS_COMMAND_BUFFER cmdBuffer,
885 PMHW_BATCH_BUFFER batchBuffer,
886 PMHW_VDBOX_AVC_IMG_PARAMS params)
887 {
888 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
889
890 MHW_FUNCTION_ENTER;
891
892 MHW_MI_CHK_NULL(params);
893 MHW_MI_CHK_NULL(params->pEncodeAvcSeqParams);
894 MHW_MI_CHK_NULL(params->pEncodeAvcPicParams);
895
896 if (cmdBuffer == nullptr && batchBuffer == nullptr)
897 {
898 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
899 return MOS_STATUS_INVALID_PARAMETER;
900 }
901
902 auto avcSeqParams = params->pEncodeAvcSeqParams;
903 auto avcPicParams = params->pEncodeAvcPicParams;
904
905 typename TMfxCmds::MFX_AVC_IMG_STATE_CMD cmd;
906
907 uint32_t numMBs = params->wPicWidthInMb * params->wPicHeightInMb;
908
909 cmd.DW1.FrameSize = (numMBs > 65535) ? 65535 : numMBs;
910
911 cmd.DW2.FrameHeight = params->wPicHeightInMb - 1;
912 cmd.DW2.FrameWidth = params->wPicWidthInMb - 1;
913
914 cmd.DW3.ImgstructImageStructureImgStructure10 = (CodecHal_PictureIsFrame(avcPicParams->CurrOriginalPic) ?
915 MhwVdboxMfxInterface::avcFrame : (CodecHal_PictureIsTopField(avcPicParams->CurrOriginalPic) ?
916 MhwVdboxMfxInterface::avcTopField : MhwVdboxMfxInterface::avcBottomField));
917
918 cmd.DW3.WeightedBipredIdc = avcPicParams->weighted_bipred_idc;
919 cmd.DW3.WeightedPredFlag = avcPicParams->weighted_pred_flag;
920
921 cmd.DW3.FirstChromaQpOffset = avcPicParams->chroma_qp_index_offset;
922 cmd.DW3.SecondChromaQpOffset = avcPicParams->second_chroma_qp_index_offset;
923
924 cmd.DW4.Fieldpicflag = CodecHal_PictureIsField(avcPicParams->CurrOriginalPic);
925 cmd.DW4.Mbaffflameflag = avcSeqParams->mb_adaptive_frame_field_flag;
926 cmd.DW4.Framembonlyflag = avcSeqParams->frame_mbs_only_flag;
927 cmd.DW4.Transform8X8Flag = avcPicParams->transform_8x8_mode_flag;
928 cmd.DW4.Direct8X8Infflag = avcSeqParams->direct_8x8_inference_flag;
929 cmd.DW4.Constrainedipredflag = avcPicParams->constrained_intra_pred_flag;
930 cmd.DW4.Entropycodingflag = avcPicParams->entropy_coding_mode_flag;
931 cmd.DW4.Chromaformatidc = avcSeqParams->chroma_format_idc;
932
933 cmd.DW4.Mbmvformatflag = 1;
934 cmd.DW4.Mvunpackedflag = 1;
935
936 cmd.DW4.Loadslicepointerflag = 0;
937 cmd.DW4.Mbstatenabled = 0; // Disable for the first pass
938 if (params->dwMaxFrameSize > 0 && params->pDeltaQp && params->currPass)
939 {
940 cmd.DW4.Mbstatenabled = 1;
941 }
942 cmd.DW4.Minframewsize = 0;
943
944 cmd.DW5.IntrambmaxbitflagIntrambmaxsizereportmask = 1;
945 cmd.DW5.IntermbmaxbitflagIntermbmaxsizereportmask = 1;
946 cmd.DW5.FrameszoverflagFramebitratemaxreportmask = 1;
947 cmd.DW5.FrameszunderflagFramebitrateminreportmask = 1;
948 cmd.DW5.IntraIntermbipcmflagForceipcmcontrolmask = 1;
949 cmd.DW5.MbratectrlflagMbLevelRateControlEnablingFlag = 0;
950 cmd.DW5.Nonfirstpassflag = 0;
951 cmd.DW5.TrellisQuantizationChromaDisableTqchromadisable = true;
952
953 if (params->dwMaxFrameSize && params->currPass)
954 {
955 cmd.DW5.Nonfirstpassflag = 1;
956 }
957
958 if (params->dwTqEnabled && cmd.DW4.Entropycodingflag)
959 {
960 cmd.DW5.TrellisQuantizationEnabledTqenb = params->dwTqEnabled;
961 cmd.DW5.TrellisQuantizationRoundingTqr = params->dwTqRounding;
962
963 }
964 else
965 {
966 cmd.DW5.TrellisQuantizationEnabledTqenb = cmd.DW5.TrellisQuantizationRoundingTqr = 0;
967 }
968
969 //DW6
970 cmd.DW6.Intrambmaxsz = m_avcIntraMbMaxSize;
971 cmd.DW6.Intermbmaxsz = m_avcInterMbMaxSize;
972
973 //DW8
974 cmd.DW8.Slicedeltaqppmax0 =
975 cmd.DW8.Slicedeltaqpmax1 =
976 cmd.DW8.Slicedeltaqpmax2 =
977 cmd.DW8.Slicedeltaqpmax3 = 0;
978
979 //DW9
980 cmd.DW9.Slicedeltaqpmin0 =
981 cmd.DW9.Slicedeltaqpmin1 =
982 cmd.DW9.Slicedeltaqpmin2 =
983 cmd.DW9.Slicedeltaqpmin3 = 0;
984
985 //DW10
986 MHW_VDBOX_AVC_IMG_BITRATE_PARAMS bitrateParams;
987 this->CalcAvcImgStateMinMaxBitrate(bitrateParams);
988 cmd.DW10.Framebitratemin = bitrateParams.frameBitRateMin;
989 cmd.DW10.Framebitrateminunit = bitrateParams.frameBitRateMinUnit;
990 cmd.DW10.Framebitrateminunitmode = bitrateParams.frameBitRateMinUnitMode;
991 cmd.DW10.Framebitratemax = bitrateParams.frameBitRateMax;
992 cmd.DW10.Framebitratemaxunit = bitrateParams.frameBitRateMaxUnit;
993 cmd.DW10.Framebitratemaxunitmode = bitrateParams.frameBitRateMaxUnitMode;
994
995 //DW11
996 cmd.DW11.Framebitratemindelta = bitrateParams.frameBitRateMinDelta;
997 cmd.DW11.Framebitratemaxdelta = bitrateParams.frameBitRateMaxDelta;
998 //add for multiple pass
999 if (params->dwMaxFrameSize > 0 && params->pDeltaQp && (!params->bIPCMPass))
1000 {
1001 cmd.DW8.Slicedeltaqppmax0 =
1002 cmd.DW8.Slicedeltaqpmax1 =
1003 cmd.DW8.Slicedeltaqpmax2 =
1004 cmd.DW8.Slicedeltaqpmax3 = params->pDeltaQp[params->currPass];
1005 cmd.DW10.Framebitratemaxunit = 0;
1006 cmd.DW10.Framebitratemaxunitmode = 0;
1007 //when FrameBitrateMaxUnit & FrameBitrateMaxUnitMode both are 0, the frame size unit is 128bytes.
1008 cmd.DW10.Framebitratemax = params->dwMaxFrameSize >> 7;
1009 cmd.DW11.Framebitratemaxdelta = params->dwMaxFrameSize >> 8;
1010
1011 // In compatibility mode (DW10.FrameBitrateMaxUnitMode = 0), only 12 bits is used.
1012 // If the calulated value of max frame size exceeded 12 bits, need change unit from 128 bytes to 16K bytes.
1013 if (params->dwMaxFrameSize >= (0x1 << 12) * 128)
1014 {
1015 // use 16K bytes unit mode in compatibility mode.
1016 cmd.DW10.Framebitratemaxunit = 1;
1017 cmd.DW10.Framebitratemaxunitmode = 0;
1018 cmd.DW10.Framebitratemax = params->dwMaxFrameSize >> 14;
1019 cmd.DW11.Framebitratemaxdelta = params->dwMaxFrameSize >> 15;
1020 }
1021 }
1022
1023 if (params->bIPCMPass)
1024 {
1025 // InterMbConfFlag, IntraMbConfFlag: not being used in HW
1026 cmd.DW4.Mbstatenabled = true;
1027 cmd.DW5.IntraIntermbipcmflagForceipcmcontrolmask = true;
1028 }
1029
1030 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1031
1032 return eStatus;
1033 }
1034
1035 MOS_STATUS AddMfxAvcDirectmodeCmd(
1036 PMOS_COMMAND_BUFFER cmdBuffer,
1037 PMHW_VDBOX_AVC_DIRECTMODE_PARAMS params)
1038 {
1039 MHW_FUNCTION_ENTER;
1040
1041 MHW_MI_CHK_NULL(this->m_osInterface);
1042 MHW_MI_CHK_NULL(cmdBuffer);
1043 MHW_MI_CHK_NULL(params);
1044
1045 MHW_RESOURCE_PARAMS resourceParams;
1046 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1047 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
1048 resourceParams.HwCommandType = MOS_MFX_AVC_DIRECT_MODE;
1049
1050 typename TMfxCmds::MFX_AVC_DIRECTMODE_STATE_CMD cmd;
1051
1052 if (!params->bDisableDmvBuffers)
1053 {
1054 MHW_MI_CHK_NULL(params->presAvcDmvBuffers);
1055 MHW_MI_CHK_NULL(params->pAvcDmvList);
1056
1057 cmd.DW36.MemoryObjectControlState =
1058 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC].Value;
1059
1060 // current picture
1061 resourceParams.presResource = &params->presAvcDmvBuffers[params->ucAvcDmvIdx];
1062 resourceParams.dwOffset = 0;
1063 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddressForWrite[0].DW0_1.Value[0]);
1064 resourceParams.dwLocationInCmd = 34;
1065 resourceParams.bIsWritable = true;
1066
1067 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
1068 this->m_osInterface,
1069 cmdBuffer,
1070 &resourceParams));
1071 }
1072
1073 CODEC_REF_LIST** refList;
1074 MHW_MI_CHK_NULL(refList = (CODEC_REF_LIST**)params->avcRefList);
1075
1076 if (CodecHal_PictureIsBottomField(params->CurrPic))
1077 {
1078 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = 0;
1079 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1080 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[1];
1081 }
1082 else
1083 {
1084 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_TOP] = cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1085 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[0];
1086 if (CodecHal_PictureIsFrame(params->CurrPic))
1087 {
1088 cmd.PocList[MHW_VDBOX_AVC_DMV_DEST_BOTTOM] =
1089 refList[params->CurrPic.FrameIdx]->iFieldOrderCnt[1];
1090 }
1091 }
1092
1093 if (!params->bDisableDmvBuffers)
1094 {
1095 cmd.DW33.MemoryObjectControlState =
1096 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DIRECTMV_BUFFER_CODEC].Value;
1097 }
1098
1099 bool dmvPresent[CODEC_MAX_NUM_REF_FRAME] = { false };
1100 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1101 {
1102 if (params->pAvcPicIdx[i].bValid)
1103 {
1104 uint8_t idx = params->pAvcPicIdx[i].ucPicIdx;
1105 uint8_t picID = params->bPicIdRemappingInUse ? i : refList[idx]->ucFrameId;
1106 uint8_t mvIdx = refList[idx]->ucDMVIdx[0];
1107
1108 bool useMvcDummyDmvBuf = 0;
1109 //bool useMvcDummyDmvBuf = IsMvcInterviewPred(params->CurrPic, params->ppAvcRefList[params->CurrPic.FrameIdx]->iFieldOrderCnt, idx, params->ppAvcRefList);
1110
1111 uint8_t validRef = ((params->uiUsedForReferenceFlags >> (i * 2)) >> 0) & 1;
1112 uint8_t frameID = picID << 1;
1113
1114 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1115 {
1116 if (!params->bDisableDmvBuffers)
1117 {
1118 dmvPresent[picID] = true;
1119
1120 resourceParams.presResource = useMvcDummyDmvBuf ?
1121 params->presMvcDummyDmvBuffer : &params->presAvcDmvBuffers[mvIdx];
1122 resourceParams.dwOffset = 0;
1123 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[picID].DW0_1.Value[0]);
1124 resourceParams.dwLocationInCmd = picID * 2 + 1;
1125 resourceParams.bIsWritable = false;
1126
1127 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW33
1128
1129 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
1130 this->m_osInterface,
1131 cmdBuffer,
1132 &resourceParams));
1133 }
1134
1135 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[0] * validRef;
1136 }
1137 else
1138 {
1139 return MOS_STATUS_UNKNOWN;
1140 }
1141
1142 validRef = ((params->uiUsedForReferenceFlags >> (i * 2)) >> 1) & 1;
1143 frameID = (picID << 1) + 1;
1144 if (frameID < CODEC_AVC_NUM_REF_DMV_BUFFERS * 2)
1145 {
1146 cmd.PocList[frameID] = refList[idx]->iFieldOrderCnt[1] * validRef;
1147 }
1148 else
1149 {
1150 return MOS_STATUS_UNKNOWN;
1151 }
1152 }
1153 }
1154
1155 if (!params->bDisableDmvBuffers)
1156 {
1157 // Use a valid address for remaining DMV buffers
1158 for (auto i = 0; i < CODEC_MAX_NUM_REF_FRAME; i++)
1159 {
1160 if (dmvPresent[i] == false)
1161 {
1162 //Give default buffer to the MV
1163 resourceParams.presResource = &params->presAvcDmvBuffers[CODEC_AVC_NUM_REF_DMV_BUFFERS];
1164 resourceParams.dwOffset = 0;
1165 resourceParams.pdwCmd = &(cmd.DirectMvBufferBaseAddress[i].DW0_1.Value[0]);
1166 resourceParams.dwLocationInCmd = i * 2 + 1;
1167 resourceParams.bIsWritable = false;
1168
1169 resourceParams.dwSharedMocsOffset = 33 - resourceParams.dwLocationInCmd; // Common Prodected Data bit is in DW33
1170
1171 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
1172 this->m_osInterface,
1173 cmdBuffer,
1174 &resourceParams));
1175 }
1176 }
1177 }
1178
1179 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1180
1181 return MOS_STATUS_SUCCESS;
1182 }
1183
1184 MOS_STATUS AddMfdAvcSliceAddrCmd(
1185 PMOS_COMMAND_BUFFER cmdBuffer,
1186 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState)
1187 {
1188 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1189
1190 MHW_FUNCTION_ENTER;
1191
1192 MHW_MI_CHK_NULL(this->m_osInterface);
1193 MHW_MI_CHK_NULL(cmdBuffer);
1194 MHW_MI_CHK_NULL(avcSliceState);
1195
1196 typename TMfxCmds::MFD_AVC_SLICEADDR_CMD cmd;
1197
1198 if (avcSliceState->bFullFrameData)
1199 {
1200 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwNextLength;
1201 cmd.DW2.IndirectBsdDataStartAddress = avcSliceState->dwNextOffset;
1202 }
1203 else
1204 {
1205 cmd.DW1.IndirectBsdDataLength = (avcSliceState->dwNextLength + 1 - this->m_osInterface->dwNumNalUnitBytesIncluded);
1206 cmd.DW2.IndirectBsdDataStartAddress = (avcSliceState->dwNextOffset - 1 + this->m_osInterface->dwNumNalUnitBytesIncluded);
1207 }
1208
1209 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1210 sliceInfoParam.presDataBuffer = avcSliceState->presDataBuffer;
1211 sliceInfoParam.dwSliceIndex = avcSliceState->dwSliceIndex;
1212 sliceInfoParam.dwTotalBytesConsumed = avcSliceState->dwTotalBytesConsumed;
1213 sliceInfoParam.dwDataStartOffset[0] = cmd.DW2.IndirectBsdDataStartAddress;
1214 sliceInfoParam.dwDataStartOffset[1] = avcSliceState->pAvcSliceParams->slice_data_offset;
1215
1216 MHW_MI_CHK_STATUS(this->m_cpInterface->SetMfxProtectionState(
1217 this->m_decodeInUse,
1218 cmdBuffer,
1219 nullptr,
1220 &sliceInfoParam));
1221
1222 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1223
1224 return eStatus;
1225 }
1226
1227 MOS_STATUS AddMfdAvcBsdObjectCmd(
1228 PMOS_COMMAND_BUFFER cmdBuffer,
1229 PMHW_VDBOX_AVC_SLICE_STATE avcSliceState)
1230 {
1231 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1232
1233 MHW_FUNCTION_ENTER;
1234
1235 MHW_MI_CHK_NULL(this->m_osInterface);
1236 MHW_MI_CHK_NULL(cmdBuffer);
1237 MHW_MI_CHK_NULL(avcSliceState);
1238 MHW_MI_CHK_NULL(avcSliceState->pAvcSliceParams);
1239
1240 typename TMfxCmds::MFD_AVC_BSD_OBJECT_CMD cmd;
1241 auto sliceParams = avcSliceState->pAvcSliceParams;
1242
1243 cmd.DW4.LastsliceFlag = avcSliceState->bLastSlice;
1244
1245 cmd.DW3.IntraPredmode4X48X8LumaErrorControlBit = 1;
1246 cmd.DW5.IntraPredictionErrorControlBitAppliedToIntra16X16Intra8X8Intra4X4LumaAndChroma = 1;
1247 cmd.DW5.Intra8X84X4PredictionErrorConcealmentControlBit = 1;
1248 cmd.DW5.ISliceConcealmentMode = 1;
1249
1250 if (avcSliceState->bShortFormatInUse)
1251 {
1252 if (avcSliceState->bFullFrameData)
1253 {
1254 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength;
1255 cmd.DW2.IndirectBsdDataStartAddress = sliceParams->slice_data_offset;
1256 }
1257 else
1258 {
1259 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength + 1 - this->m_osInterface->dwNumNalUnitBytesIncluded;
1260 cmd.DW2.IndirectBsdDataStartAddress =
1261 sliceParams->slice_data_offset - 1 + this->m_osInterface->dwNumNalUnitBytesIncluded;
1262 }
1263 cmd.DW4.FirstMbByteOffsetOfSliceDataOrSliceHeader = 0;
1264 }
1265 else
1266 {
1267 // Long format
1268 cmd.DW1.IndirectBsdDataLength = avcSliceState->dwLength;
1269 cmd.DW2.IndirectBsdDataStartAddress = sliceParams->slice_data_offset + avcSliceState->dwOffset;
1270 cmd.DW4.FirstMacroblockMbBitOffset = sliceParams->slice_data_bit_offset;
1271
1272 if (!avcSliceState->bIntelEntrypointInUse)
1273 {
1274 // NAL Header Unit must be passed to HW in the compressed bitstream buffer
1275 avcSliceState->dwOffset -= (this->m_osInterface->dwNumNalUnitBytesIncluded - 1);
1276 cmd.DW1.IndirectBsdDataLength += avcSliceState->dwOffset;
1277 cmd.DW2.IndirectBsdDataStartAddress -= avcSliceState->dwOffset;
1278 cmd.DW4.FirstMbByteOffsetOfSliceDataOrSliceHeader = avcSliceState->dwOffset;
1279 }
1280
1281 }
1282
1283 cmd.DW4.FixPrevMbSkipped = 1;
1284
1285 MHW_CP_SLICE_INFO_PARAMS sliceInfoParam;
1286 sliceInfoParam.presDataBuffer = avcSliceState->presDataBuffer;
1287 sliceInfoParam.dwSliceIndex = avcSliceState->dwSliceIndex;
1288 sliceInfoParam.dwTotalBytesConsumed = avcSliceState->dwTotalBytesConsumed;
1289 sliceInfoParam.dwDataStartOffset[0] = cmd.DW2.IndirectBsdDataStartAddress;
1290 sliceInfoParam.dwDataStartOffset[1] = sliceParams->slice_data_offset;
1291 sliceInfoParam.dwDataLength[1] = sliceParams->slice_data_size;
1292
1293 MHW_MI_CHK_STATUS(this->m_cpInterface->SetMfxProtectionState(
1294 this->m_decodeInUse,
1295 cmdBuffer,
1296 nullptr,
1297 &sliceInfoParam));
1298
1299 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1300
1301 return eStatus;
1302 }
1303
1304 MOS_STATUS AddMfxPakInsertObject(
1305 PMOS_COMMAND_BUFFER cmdBuffer,
1306 PMHW_BATCH_BUFFER batchBuffer,
1307 PMHW_VDBOX_PAK_INSERT_PARAMS params)
1308 {
1309 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1310
1311 MHW_FUNCTION_ENTER;
1312
1313 MHW_MI_CHK_NULL(params);
1314
1315 if (cmdBuffer == nullptr && batchBuffer == nullptr)
1316 {
1317 MHW_ASSERTMESSAGE("No valid buffer to add the command to!");
1318 return MOS_STATUS_INVALID_PARAMETER;
1319 }
1320
1321 typename TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD cmd;
1322 uint32_t dwordsUsed = TMfxCmds::MFX_PAK_INSERT_OBJECT_CMD::dwSize;
1323
1324 cmd.DW1.SliceHeaderIndicator = params->bSliceHeaderIndicator;
1325
1326 if (params->bLastPicInSeq || params->bLastPicInStream) // used by AVC, MPEG2
1327 {
1328 dwordsUsed += params->bLastPicInSeq + params->bLastPicInStream;
1329
1330 cmd.DW0.DwordLength = TMfxCmds::GetOpLength(dwordsUsed);
1331 cmd.DW1.BitstreamstartresetResetbitstreamstartingpos = 0;
1332 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = 1;
1333 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = 1;
1334 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = 0;
1335 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = 0;
1336 // use dwBitSize to pass SrcDataEndingBitInclusion
1337 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = params->dwBitSize;
1338 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1339 cmd.DW1.Headerlengthexcludefrmsize = cmd.DW1.EmulationflagEmulationbytebitsinsertenable ? false
1340 : params->bHeaderLengthExcludeFrmSize; // Cannot be set to true if emulation byte bit insertion is enabled
1341
1342 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1343
1344 if (params->bLastPicInSeq) // only used by AVC, not used by MPEG2
1345 {
1346 uint32_t lastPicInSeqData = params->dwLastPicInSeqData;
1347
1348 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
1349 this->m_osInterface,
1350 cmdBuffer,
1351 batchBuffer,
1352 &lastPicInSeqData,
1353 sizeof(lastPicInSeqData)));
1354 }
1355
1356 if (params->bLastPicInStream) // used by AVC,MPEG2
1357 {
1358 uint32_t lastPicInStreamData = params->dwLastPicInStreamData;
1359
1360 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(
1361 this->m_osInterface,
1362 cmdBuffer,
1363 batchBuffer,
1364 &lastPicInStreamData,
1365 sizeof(lastPicInStreamData)));
1366 }
1367 }
1368 else // used by AVC, MPEG2, JPEG
1369 {
1370 uint32_t byteSize = (params->dwBitSize + 7) >> 3;
1371 uint32_t dataBitsInLastDw = params->dwBitSize % 32;
1372
1373 if (dataBitsInLastDw == 0)
1374 {
1375 dataBitsInLastDw = 32;
1376 }
1377
1378 dwordsUsed += ((byteSize + 3) >> 2);
1379 cmd.DW0.DwordLength = TMfxCmds::GetOpLength(dwordsUsed);
1380 cmd.DW1.BitstreamstartresetResetbitstreamstartingpos = params->bResetBitstreamStartingPos;
1381 cmd.DW1.EndofsliceflagLastdstdatainsertcommandflag = params->bEndOfSlice;
1382 cmd.DW1.LastheaderflagLastsrcheaderdatainsertcommandflag = params->bLastHeader;
1383 cmd.DW1.EmulationflagEmulationbytebitsinsertenable = params->bEmulationByteBitsInsert;
1384 cmd.DW1.SkipemulbytecntSkipEmulationByteCount = params->uiSkipEmulationCheckCount;
1385 cmd.DW1.DatabitsinlastdwSrcdataendingbitinclusion50 = dataBitsInLastDw;
1386 cmd.DW1.DatabyteoffsetSrcdatastartingbyteoffset10 = 0;
1387 cmd.DW1.Headerlengthexcludefrmsize = cmd.DW1.EmulationflagEmulationbytebitsinsertenable ? false
1388 : params->bHeaderLengthExcludeFrmSize; // Cannot be set to true if emulation byte bit insertion is enabled
1389 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1390
1391 // Add actual data
1392 uint8_t* data = (uint8_t*)(params->pBsBuffer->pBase + params->dwOffset);
1393 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, data, byteSize));
1394 }
1395
1396 return eStatus;
1397 }
1398
1399 MOS_STATUS AddMfdVp8BsdObjectCmd(
1400 PMOS_COMMAND_BUFFER cmdBuffer,
1401 PMHW_VDBOX_VP8_BSD_PARAMS params)
1402 {
1403 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1404
1405 MHW_FUNCTION_ENTER;
1406
1407 typename TMfxCmds::MFD_VP8_BSD_OBJECT_CMD cmd;
1408
1409 eStatus = MhwVdboxMfxInterfaceGeneric<TMfxCmds, mhw_mi_g8_X>::AddMfdVp8BsdObjectCmd(cmdBuffer, params);
1410 MHW_MI_CHK_STATUS(eStatus);
1411
1412 return eStatus;
1413 }
1414
1415 };
1416
1417 #endif