Debian Codegraph @

media_softlet/agnostic/common/hw/vdbox/mhw_vdbox_vdenc_impl.h

raw
1 /*
2 * Copyright (c) 2020-2021, 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_vdenc_impl.h
24 //! \brief MHW VDBOX VDENC interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_VDENC_IMPL_H__
29 #define __MHW_VDBOX_VDENC_IMPL_H__
30
31 #include "mhw_vdbox_vdenc_itf.h"
32 #include "mhw_impl.h"
33 #include "mhw_mi_impl.h"
34
35 #ifdef _MEDIA_RESERVED
36 #include "mhw_vdbox_vdenc_impl_ext.h"
37 #include "mhw_vdbox_vdenc_hwcmd_ext.h"
38 #endif
39
40 namespace mhw
41 {
42 namespace vdbox
43 {
44 namespace vdenc
45 {
46 inline SurfaceFormat MosFormatToVdencSurfaceRawFormat(MOS_FORMAT format)
47 {
48 switch (format)
49 {
50 case Format_A8R8G8B8:
51 case Format_X8R8G8B8:
52 case Format_A8B8G8R8:
53 return SurfaceFormat::rgba4444;
54 case Format_NV12:
55 case Format_NV11:
56 case Format_P208:
57 case Format_IMC1:
58 case Format_IMC2:
59 case Format_IMC3:
60 case Format_IMC4:
61 return SurfaceFormat::planar4208;
62 case Format_400P:
63 case Format_P8:
64 return SurfaceFormat::y8Unorm;
65 case Format_UYVY:
66 return SurfaceFormat::yCrCbSwapY422;
67 case Format_YVYU:
68 return SurfaceFormat::yCrCbSwapUv422;
69 case Format_VYUY:
70 return SurfaceFormat::yCrCbSwapUvy422;
71 case Format_444P:
72 case Format_AYUV:
73 return SurfaceFormat::yuv444;
74 case Format_YUY2:
75 case Format_YUYV:
76 return SurfaceFormat::yuv422;
77 case Format_P010:
78 return SurfaceFormat::p010;
79 case Format_R10G10B10A2:
80 case Format_B10G10R10A2:
81 return SurfaceFormat::r10g10b10a2;
82 // Only Y210 supported now, allocated as Y216 format by 3D driver
83 case Format_Y210:
84 case Format_Y216:
85 return SurfaceFormat::y216;
86 case Format_Y410:
87 return SurfaceFormat::y410;
88 case Format_NV21:
89 return SurfaceFormat::nv21;
90 default:
91 return SurfaceFormat::planar4208;
92 }
93 }
94
95 inline SurfaceFormat MosFormatToVdencSurfaceReconFormat(MOS_FORMAT format)
96 {
97 switch (format)
98 {
99 case Format_A8R8G8B8:
100 case Format_X8R8G8B8:
101 case Format_A8B8G8R8:
102 return SurfaceFormat::rgba4444;
103 case Format_NV12:
104 case Format_IMC1:
105 case Format_IMC2:
106 case Format_IMC3:
107 case Format_IMC4:
108 return SurfaceFormat::planar4208;
109 case Format_400P:
110 case Format_P8:
111 return SurfaceFormat::y8Unorm;
112 case Format_UYVY:
113 return SurfaceFormat::yCrCbSwapY422;
114 case Format_YVYU:
115 return SurfaceFormat::yCrCbSwapUv422;
116 case Format_VYUY:
117 return SurfaceFormat::yCrCbSwapUvy422;
118 case Format_444P:
119 case Format_AYUV:
120 return SurfaceFormat::ayuvVariant;
121 case Format_YUY2:
122 case Format_YUYV:
123 return SurfaceFormat::yuyvVariant;
124 case Format_P010:
125 return SurfaceFormat::p010Variant;
126 case Format_R10G10B10A2:
127 return SurfaceFormat::r10g10b10a2;
128 case Format_Y210:
129 case Format_Y216:
130 return SurfaceFormat::y216Variant;
131 case Format_Y410:
132 return SurfaceFormat::y416Variant;
133 case Format_NV21:
134 return SurfaceFormat::nv21;
135 default:
136 return SurfaceFormat::planar4208;
137 }
138 }
139
140 template <typename cmd_t>
141 class Impl : public Itf, public mhw::Impl
142 {
143 _VDENC_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
144 MmioRegistersVdbox m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< Mfx mmio registers
145
146 public:
147 MOS_STATUS SetRowstoreCachingOffsets(const RowStorePar &par) override
148 {
149 MHW_FUNCTION_ENTER;
150
151 switch (par.mode)
152 {
153 case RowStorePar::AVC:
154 {
155 if (this->m_rowStoreCache.vdenc.supported)
156 {
157 this->m_rowStoreCache.vdenc.enabled = true;
158 this->m_rowStoreCache.vdenc.dwAddress = !par.isField ? 1280 : 1536;
159 }
160 if (this->m_rowStoreCache.ipdl.supported)
161 {
162 this->m_rowStoreCache.ipdl.enabled = true;
163 this->m_rowStoreCache.ipdl.dwAddress = 512;
164 }
165
166 break;
167 }
168 case RowStorePar::HEVC:
169 {
170 constexpr bool enable[16][5] =
171 {
172 {1, 1, 1, 0, 1}, {1, 1, 1, 1, 1}, {1, 1, 0, 0, 0}, {1, 1, 0, 1, 0},
173 {1, 1, 1, 1, 1}, {1, 1, 0, 0, 1}, {1, 1, 1, 0, 0}, {1, 0, 1, 0, 1},
174 {1, 1, 1, 0, 0}, {1, 0, 1, 0, 1}, {1, 1, 1, 1, 1}, {1, 1, 0, 1, 1},
175 {1, 1, 1, 1, 1}, {1, 0, 1, 1, 1}, {1, 1, 1, 1, 1}, {1, 0, 1, 1, 1}
176 };
177
178 constexpr uint32_t address[16][5] =
179 {
180 {0, 256, 1280, 0, 2048}, {0, 256, 1280, 1824, 1792}, {0, 512, 0, 0, 0}, {0, 256, 0, 2304, 0},
181 {0, 256, 1024, 0, 1792}, {0, 512, 0, 0, 2048}, {0, 256, 1792, 0, 0}, {0, 0, 512, 0, 2048},
182 {0, 256, 1792, 0, 0}, {0, 0, 256, 0, 1792}, {0, 256, 1024, 1568, 1536}, {0, 512, 0, 2112, 2048},
183 {0, 256, 1792, 2336, 2304}, {0, 0, 512, 1600, 1536}, {0, 128, 1664, 2336, 2304}, {0, 0, 256, 1600, 1536}
184 };
185
186 bool isLcu32or64 = par.lcuSize == RowStorePar::SIZE_32 || par.lcuSize == RowStorePar::SIZE_64;
187 bool isGt4k = par.frameWidth > 4096;
188 bool isGt8k = par.frameWidth > 8192;
189 uint32_t index = 0;
190
191 if (par.format != RowStorePar::YUV444)
192 {
193 index = 2 * isGt4k + isLcu32or64;
194 }
195 else
196 {
197 uint32_t subidx = par.bitDepth == RowStorePar::DEPTH_12 ? 2 : (par.bitDepth == RowStorePar::DEPTH_10 ? 1 : 0);
198 index = 4 + 6 * isLcu32or64 + 2 * subidx + isGt4k;
199 }
200
201 if (!isGt8k && this->m_rowStoreCache.vdenc.supported)
202 {
203 this->m_rowStoreCache.vdenc.enabled = enable[index][3];
204 if (this->m_rowStoreCache.vdenc.enabled)
205 {
206 this->m_rowStoreCache.vdenc.dwAddress = address[index][3];
207 }
208 }
209
210 break;
211 }
212 case RowStorePar::AV1:
213 {
214 if (this->m_rowStoreCache.vdenc.supported)
215 {
216 this->m_rowStoreCache.vdenc.enabled = true;
217 this->m_rowStoreCache.vdenc.dwAddress = 2370;
218 }
219 if (this->m_rowStoreCache.ipdl.supported)
220 {
221 this->m_rowStoreCache.ipdl.enabled = true;
222 this->m_rowStoreCache.ipdl.dwAddress = 384;
223 }
224
225 break;
226 }
227 case RowStorePar::VP9:
228 {
229 // HVD, Meta/MV, DeBlock, VDEnc
230 const bool enableVP9[13][4] =
231 {
232 { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 1, 0, 1, 1 }, { 1, 1, 0, 1 },
233 { 1, 1, 1, 1 }, { 0, 0, 1, 1 }, { 0, 0, 1, 0 }, { 1, 1, 0, 1 },
234 { 1, 1, 1, 1 }, { 1, 1, 0, 1 }, { 1, 1, 1, 1 }, { 1, 1, 0, 1 },
235 { 1, 1, 0, 1 }
236 };
237
238 const uint32_t addressVP9[13][4] =
239 {
240 { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 64, 2368, }, { 0, 128, 0, 768, },
241 { 0, 64, 384, 1536, }, { 0, 0, 0, 2304, }, { 0, 0, 0, 0, }, { 0, 128, 0, 768, },
242 { 0, 64, 384, 2112, }, { 0, 128, 0, 768, }, { 0, 32, 192, 1920, }, { 0, 128, 0, 768, },
243 { 0, 128, 0, 768, }
244 };
245
246 if(this->m_rowStoreCache.vdenc.supported)
247 {
248 bool is8bit = par.bitDepth == RowStorePar::DEPTH_8;
249 bool isGt2k = par.frameWidth > 2048;
250 bool isGt4k = par.frameWidth > 4096;
251 bool isGt8k = par.frameWidth > 8192;
252 uint32_t index = 0;
253
254 if((par.format >= RowStorePar::YUV420) && (par.format <= RowStorePar::YUV444))
255 {
256 index = 4 * (par.format - RowStorePar::YUV420) + 2 * (!is8bit) + isGt4k;
257 }
258 else
259 {
260 return MOS_STATUS_SUCCESS;
261 }
262
263 if(par.format == RowStorePar::YUV444 && !is8bit)
264 {
265 index += isGt2k;
266 }
267
268 if(!isGt8k)
269 {
270 this->m_rowStoreCache.vdenc.enabled = enableVP9[index][3];
271 if(this->m_rowStoreCache.vdenc.enabled)
272 {
273 this->m_rowStoreCache.vdenc.dwAddress = addressVP9[index][3];
274 }
275 }
276 }
277 }
278 default:
279 {
280 break;
281 }
282 }
283
284 return MOS_STATUS_SUCCESS;
285 }
286
287 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
288 {
289 MHW_FUNCTION_ENTER;
290
291 MHW_CHK_NULL_RETURN(settings);
292
293 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
294
295 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
296 }
297
298 bool IsPerfModeSupported() override
299 {
300 return m_perfModeSupported;
301 }
302
303 bool IsRhoDomainStatsEnabled() override
304 {
305 return m_rhoDomainStatsEnabled;
306 }
307
308 MmioRegistersVdbox *GetMmioRegisters(MHW_VDBOX_NODE_IND index) override
309 {
310 MHW_FUNCTION_ENTER;
311 if (index < MHW_VDBOX_NODE_MAX)
312 {
313 return &m_mmioRegisters[index];
314 }
315 else
316 {
317 MHW_ASSERT("index is out of range!");
318 return &m_mmioRegisters[MHW_VDBOX_NODE_1];
319 }
320 }
321 private:
322 //VDBOX register offsets
323 static constexpr uint32_t MFC_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT = 0x1C08B4;
324 static constexpr uint32_t MFC_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT = 0x1C08B8;
325 static constexpr uint32_t MFC_AVC_NUM_SLICES_REG_OFFSET_NODE_1_INIT = 0x1C0954;
326 static constexpr uint32_t MFC_QP_STATUS_COUNT_OFFSET_NODE_1_INIT = 0x1C08BC;
327 static constexpr uint32_t MFX_ERROR_FLAG_REG_OFFSET_NODE_1_INIT = 0x1C0800;
328 static constexpr uint32_t MFX_FRAME_CRC_REG_OFFSET_NODE_1_INIT = 0x1C0850;
329 static constexpr uint32_t MFX_MB_COUNT_REG_OFFSET_NODE_1_INIT = 0x1C0868;
330 static constexpr uint32_t MFC_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT = 0x1C08A0;
331 static constexpr uint32_t MFC_BITSTREAM_SE_BITCOUNT_FRAME_REG_OFFSET_NODE_1_INIT = 0x1C08A4;
332 static constexpr uint32_t MFC_BITSTREAM_BYTECOUNT_SLICE_REG_OFFSET_NODE_1_INIT = 0x1C08D0;
333 //VDBOX register initial value
334 static constexpr uint32_t MFX_LRA0_REG_OFFSET_NODE_1_INIT = 0;
335 static constexpr uint32_t MFX_LRA1_REG_OFFSET_NODE_1_INIT = 0;
336 static constexpr uint32_t MFX_LRA2_REG_OFFSET_NODE_1_INIT = 0;
337
338 void InitMmioRegisters()
339 {
340 MHW_FUNCTION_ENTER;
341 MmioRegistersVdbox *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1];
342
343 mmioRegisters->generalPurposeRegister0LoOffset = mhw::mi::GENERAL_PURPOSE_REGISTER0_LO_OFFSET_NODE_1_INIT;
344 mmioRegisters->generalPurposeRegister0HiOffset = mhw::mi::GENERAL_PURPOSE_REGISTER0_HI_OFFSET_NODE_1_INIT;
345 mmioRegisters->generalPurposeRegister4LoOffset = mhw::mi::GENERAL_PURPOSE_REGISTER4_LO_OFFSET_NODE_1_INIT;
346 mmioRegisters->generalPurposeRegister4HiOffset = mhw::mi::GENERAL_PURPOSE_REGISTER4_HI_OFFSET_NODE_1_INIT;
347 mmioRegisters->generalPurposeRegister11LoOffset = mhw::mi::GENERAL_PURPOSE_REGISTER11_LO_OFFSET_NODE_1_INIT;
348 mmioRegisters->generalPurposeRegister11HiOffset = mhw::mi::GENERAL_PURPOSE_REGISTER11_HI_OFFSET_NODE_1_INIT;
349 mmioRegisters->generalPurposeRegister12LoOffset = mhw::mi::GENERAL_PURPOSE_REGISTER12_LO_OFFSET_NODE_1_INIT;
350 mmioRegisters->generalPurposeRegister12HiOffset = mhw::mi::GENERAL_PURPOSE_REGISTER12_HI_OFFSET_NODE_1_INIT;
351 mmioRegisters->mfcImageStatusMaskRegOffset = MFC_IMAGE_STATUS_MASK_REG_OFFSET_NODE_1_INIT;
352 mmioRegisters->mfcImageStatusCtrlRegOffset = MFC_IMAGE_STATUS_CTRL_REG_OFFSET_NODE_1_INIT;
353 mmioRegisters->mfcAvcNumSlicesRegOffset = MFC_AVC_NUM_SLICES_REG_OFFSET_NODE_1_INIT;
354 mmioRegisters->mfcQPStatusCountOffset = MFC_QP_STATUS_COUNT_OFFSET_NODE_1_INIT;
355 mmioRegisters->mfxErrorFlagsRegOffset = MFX_ERROR_FLAG_REG_OFFSET_NODE_1_INIT;
356 mmioRegisters->mfxFrameCrcRegOffset = MFX_FRAME_CRC_REG_OFFSET_NODE_1_INIT;
357 mmioRegisters->mfxMBCountRegOffset = MFX_MB_COUNT_REG_OFFSET_NODE_1_INIT;
358 mmioRegisters->mfcBitstreamBytecountFrameRegOffset = MFC_BITSTREAM_BYTECOUNT_FRAME_REG_OFFSET_NODE_1_INIT;
359 mmioRegisters->mfcBitstreamSeBitcountFrameRegOffset = MFC_BITSTREAM_SE_BITCOUNT_FRAME_REG_OFFSET_NODE_1_INIT;
360 mmioRegisters->mfcBitstreamBytecountSliceRegOffset = MFC_BITSTREAM_BYTECOUNT_SLICE_REG_OFFSET_NODE_1_INIT;
361 mmioRegisters->mfxLra0RegOffset = MFX_LRA0_REG_OFFSET_NODE_1_INIT;
362 mmioRegisters->mfxLra1RegOffset = MFX_LRA1_REG_OFFSET_NODE_1_INIT;
363 mmioRegisters->mfxLra2RegOffset = MFX_LRA2_REG_OFFSET_NODE_1_INIT;
364
365 m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1];
366 }
367 protected:
368 using base_t = Itf;
369
370 struct
371 {
372 RowStoreCache vdenc;
373 RowStoreCache ipdl;
374 } m_rowStoreCache = {};
375 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
376
377 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
378 {
379 MHW_FUNCTION_ENTER;
380
381 InitMmioRegisters();
382 InitRowstoreUserFeatureSettings();
383 }
384
385 virtual MOS_STATUS InitRowstoreUserFeatureSettings()
386 {
387 MHW_FUNCTION_ENTER;
388
389 bool rowstoreCachingDisableDefaultValue = false;
390 if (this->m_osItf->bSimIsActive)
391 {
392 // Disable RowStore Cache on simulation by default
393 rowstoreCachingDisableDefaultValue = true;
394 }
395 else
396 {
397 rowstoreCachingDisableDefaultValue = false;
398 }
399 bool rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue;
400 #if (_DEBUG || _RELEASE_INTERNAL)
401 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf);
402 {
403 MediaUserSetting::Value outValue;
404 ReadUserSettingForDebug(userSettingPtr,
405 outValue,
406 "Disable RowStore Cache",
407 MediaUserSetting::Group::Device,
408 rowstoreCachingDisableDefaultValue,
409 true);
410 rowstoreCachingSupported = !(outValue.Get<bool>());
411 }
412 #endif // _DEBUG || _RELEASE_INTERNAL
413
414 if (!rowstoreCachingSupported)
415 {
416 return MOS_STATUS_SUCCESS;
417 }
418
419 m_rowStoreCache.vdenc.supported = true;
420 #if (_DEBUG || _RELEASE_INTERNAL)
421 {
422 MediaUserSetting::Value outValue;
423 ReadUserSettingForDebug(userSettingPtr,
424 outValue,
425 "DisableVDEncRowStoreCache",
426 MediaUserSetting::Group::Device);
427 m_rowStoreCache.vdenc.supported = !(outValue.Get<bool>());
428 }
429 #endif // _DEBUG || _RELEASE_INTERNAL
430
431 m_rowStoreCache.ipdl.supported = true;
432 #if (_DEBUG || _RELEASE_INTERNAL)
433 {
434 MediaUserSetting::Value outValue;
435 ReadUserSettingForDebug(userSettingPtr,
436 outValue,
437 "DisableIntraRowStoreCache",
438 MediaUserSetting::Group::Device);
439 m_rowStoreCache.ipdl.supported = !(outValue.Get<bool>());
440 }
441 #endif // _DEBUG || _RELEASE_INTERNAL
442
443 return MOS_STATUS_SUCCESS;
444 }
445
446 _MHW_SETCMD_OVERRIDE_DECL(VDENC_CONTROL_STATE)
447 {
448 _MHW_SETCMD_CALLBASE(VDENC_CONTROL_STATE);
449
450 #define DO_FIELDS() \
451 DO_FIELD(DW1, VdencInitialization, params.vdencInitialization)
452
453 #include "mhw_hwcmd_process_cmdfields.h"
454 }
455
456 _MHW_SETCMD_OVERRIDE_DECL(VDENC_PIPE_MODE_SELECT)
457 {
458 _MHW_SETCMD_CALLBASE(VDENC_PIPE_MODE_SELECT);
459
460 #define DO_FIELDS() \
461 DO_FIELD(DW1, StandardSelect, params.standardSelect); \
462 DO_FIELD(DW1, ScalabilityMode, params.scalabilityMode); \
463 DO_FIELD(DW1, FrameStatisticsStreamOutEnable, params.frameStatisticsStreamOut); \
464 DO_FIELD(DW1, VdencPakObjCmdStreamOutEnable, params.pakObjCmdStreamOut); \
465 DO_FIELD(DW1, TlbPrefetchEnable, params.tlbPrefetch); \
466 DO_FIELD(DW1, PakThresholdCheckEnable, params.dynamicSlice); \
467 DO_FIELD(DW1, VdencStreamInEnable, params.streamIn); \
468 DO_FIELD(DW1, BitDepth, params.bitDepthMinus8); \
469 DO_FIELD(DW1, PakChromaSubSamplingType, params.chromaType); \
470 DO_FIELD(DW1, OutputRangeControlAfterColorSpaceConversion, params.outputRangeControlCsc); \
471 DO_FIELD(DW1, TileReplayEnable, params.tileBasedReplayMode); \
472 DO_FIELD(DW1, IsRandomAccess, params.randomAccess); \
473 DO_FIELD(DW1, RgbEncodingEnable, params.rgbEncodingMode); \
474 DO_FIELD(DW1, StreamingBufferConfig, params.streamingBufferConfig); \
475 \
476 DO_FIELD(DW2, HmeRegionPreFetchenable, params.hmeRegionPrefetch); \
477 DO_FIELD(DW2, Topprefetchenablemode, params.topPrefetchEnableMode); \
478 DO_FIELD(DW2, LeftpreFetchatwraparound, params.leftPrefetchAtWrapAround); \
479 DO_FIELD(DW2, Verticalshift32Minus1, params.verticalShift32Minus1); \
480 DO_FIELD(DW2, Hzshift32Minus1, params.hzShift32Minus1); \
481 DO_FIELD(DW2, NumVerticalReqMinus1, params.numVerticalReqMinus1); \
482 DO_FIELD(DW2, Numhzreqminus1, params.numHzReqMinus1); \
483 DO_FIELD(DW2, PreFetchOffsetForReferenceIn16PixelIncrement, params.prefetchOffset); \
484 \
485 DO_FIELD(DW5, CaptureMode, params.captureMode); \
486 DO_FIELD(DW5, ParallelCaptureAndEncodeSessionId, params.wirelessSessionId); \
487 DO_FIELD(DW5, TailPointerReadFrequency, params.tailPointerReadFrequency); \
488 DO_FIELD(DW5, VDENC_PIPE_MODE_SELECT_DW5_BIT17, params.VdencPipeModeSelectPar0); \
489 DO_FIELD(DW5, VDENC_PIPE_MODE_SELECT_DW5_BIT8, params.VdencPipeModeSelectPar1);
490
491 #include "mhw_hwcmd_process_cmdfields.h"
492 }
493
494 _MHW_SETCMD_OVERRIDE_DECL(VDENC_SRC_SURFACE_STATE)
495 {
496 _MHW_SETCMD_CALLBASE(VDENC_SRC_SURFACE_STATE);
497
498 #define DO_FIELDS() \
499 DO_FIELD(Dwords25.DW0, Width, params.width - 1); \
500 DO_FIELD(Dwords25.DW0, Height, params.height - 1); \
501 DO_FIELD(Dwords25.DW0, ColorSpaceSelection, params.colorSpaceSelection); \
502 DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirection); \
503 DO_FIELD(Dwords25.DW0, SurfaceFormatByteSwizzle, params.displayFormatSwizzle); \
504 \
505 DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileType, params.tileModeGmm, params.gmmTileEn)); \
506 DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceRawFormat(params.format))); \
507 DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitch - 1); \
508 DO_FIELD(Dwords25.DW1, ChromaDownsampleFilterControl, params.chromaDownsampleFilterControl); \
509 \
510 DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffset); \
511 DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffset)
512
513 #include "mhw_hwcmd_process_cmdfields.h"
514 }
515
516 _MHW_SETCMD_OVERRIDE_DECL(VDENC_REF_SURFACE_STATE)
517 {
518 _MHW_SETCMD_CALLBASE(VDENC_REF_SURFACE_STATE);
519
520 #define DO_FIELDS() \
521 DO_FIELD(Dwords25.DW0, Width, params.width - 1); \
522 DO_FIELD(Dwords25.DW0, Height, params.height - 1); \
523 DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirection); \
524 \
525 DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileType, params.tileModeGmm, params.gmmTileEn)); \
526 DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitch - 1); \
527 DO_FIELD(Dwords25.DW1, SurfaceFormat, static_cast<uint32_t>(MosFormatToVdencSurfaceReconFormat(params.format))); \
528 \
529 DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffset); \
530 DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffset)
531
532 #include "mhw_hwcmd_process_cmdfields.h"
533 }
534
535 _MHW_SETCMD_OVERRIDE_DECL(VDENC_DS_REF_SURFACE_STATE)
536 {
537 _MHW_SETCMD_CALLBASE(VDENC_DS_REF_SURFACE_STATE);
538
539 const bool stage2 = params.widthStage2 && params.heightStage2 && params.pitchStage2;
540
541 #define DO_FIELDS() \
542 DO_FIELD(Dwords25.DW0, Width, params.widthStage1 - 1); \
543 DO_FIELD(Dwords25.DW0, Height, params.heightStage1 - 1); \
544 DO_FIELD(Dwords25.DW0, CrVCbUPixelOffsetVDirection, params.vDirectionStage1); \
545 \
546 DO_FIELD(Dwords25.DW1, TileMode, GetHwTileType(params.tileTypeStage1, params.tileModeGmmStage1, params.gmmTileEnStage1)); \
547 DO_FIELD(Dwords25.DW1, SurfaceFormat, cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8); \
548 DO_FIELD(Dwords25.DW1, SurfacePitch, params.pitchStage1 - 1); \
549 \
550 DO_FIELD(Dwords25.DW2, YOffsetForUCb, params.uOffsetStage1); \
551 \
552 DO_FIELD(Dwords25.DW3, YOffsetForVCr, params.vOffsetStage1); \
553 \
554 DO_FIELD(Dwords69.DW0, Width, stage2 ? params.widthStage2 - 1 : 0); \
555 DO_FIELD(Dwords69.DW0, Height, stage2 ? params.heightStage2 - 1 : 0); \
556 DO_FIELD(Dwords69.DW0, CrVCbUPixelOffsetVDirection, stage2 ? params.vDirectionStage2 : 0); \
557 \
558 DO_FIELD(Dwords69.DW1, TileMode, stage2 ? GetHwTileType(params.tileTypeStage2, params.tileModeGmmStage2, params.gmmTileEnStage2) : 0); \
559 DO_FIELD(Dwords69.DW1, SurfaceFormat, stage2 ? cmd_t::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8 : 0); \
560 DO_FIELD(Dwords69.DW1, SurfacePitch, stage2 ? params.pitchStage2 - 1 : 0); \
561 \
562 DO_FIELD(Dwords69.DW2, YOffsetForUCb, stage2 ? params.uOffsetStage2 : 0); \
563 \
564 DO_FIELD(Dwords69.DW3, YOffsetForVCr, stage2 ? params.vOffsetStage2 : 0)
565
566 #include "mhw_hwcmd_process_cmdfields.h"
567 }
568
569 _MHW_SETCMD_OVERRIDE_DECL(VDENC_PIPE_BUF_ADDR_STATE)
570 {
571 _MHW_SETCMD_CALLBASE(VDENC_PIPE_BUF_ADDR_STATE);
572
573 MHW_RESOURCE_PARAMS resourceParams = {};
574
575 if (params.surfaceRaw)
576 {
577 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(params.mmcStateRaw);
578 cmd.OriginalUncompressedPicture.PictureFields.DW0.CompressionType = MmcRcEnabled(params.mmcStateRaw);
579 cmd.OriginalUncompressedPicture.PictureFields.DW0.CompressionFormat = params.compressionFormatRaw;
580
581 resourceParams = {};
582 resourceParams.presResource = &params.surfaceRaw->OsResource;
583 resourceParams.dwOffset = params.surfaceRaw->dwOffset;
584 resourceParams.pdwCmd = (uint32_t *)&(cmd.OriginalUncompressedPicture.LowerAddress);
585 //resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(OriginalUncompressedPicture.LowerAddress);
586 resourceParams.dwLocationInCmd = 10;
587 resourceParams.bIsWritable = false;
588 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
589
590 InitMocsParams(resourceParams, &cmd.OriginalUncompressedPicture.PictureFields.DW0.Value, 1, 6);
591
592 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
593 this->m_osItf,
594 this->m_currentCmdBuf,
595 &resourceParams));
596 }
597
598 if (this->m_rowStoreCache.vdenc.enabled)
599 {
600 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
601 cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_rowStoreCache.vdenc.dwAddress << 6;
602 }
603 else if (!Mos_ResourceIsNull(params.intraRowStoreScratchBuffer))
604 {
605 resourceParams.presResource = params.intraRowStoreScratchBuffer;
606 resourceParams.dwOffset = 0;
607 resourceParams.pdwCmd = (uint32_t *)&(cmd.RowStoreScratchBuffer.LowerAddress);
608 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(RowStoreScratchBuffer.LowerAddress);
609 resourceParams.bIsWritable = true;
610 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
611
612 InitMocsParams(resourceParams, &cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.Value, 1, 6);
613
614 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
615 this->m_osItf,
616 this->m_currentCmdBuf,
617 &resourceParams));
618 }
619
620 if (!Mos_ResourceIsNull(params.streamOutBuffer))
621 {
622 resourceParams.presResource = params.streamOutBuffer;
623 resourceParams.dwOffset = params.streamOutOffset;
624 resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencStatisticsStreamout.LowerAddress);
625 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencStatisticsStreamout.LowerAddress);
626 resourceParams.bIsWritable = true;
627 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
628
629 InitMocsParams(resourceParams, &cmd.VdencStatisticsStreamout.PictureFields.DW0.Value, 1, 6);
630
631 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
632 this->m_osItf,
633 this->m_currentCmdBuf,
634 &resourceParams));
635 }
636
637 if (!Mos_ResourceIsNull(params.streamInBuffer))
638 {
639 resourceParams.presResource = params.streamInBuffer;
640 resourceParams.dwOffset = params.streamInBuffer->dwResourceOffset;
641 resourceParams.pdwCmd = (uint32_t *)&(cmd.StreaminDataPicture.LowerAddress);
642 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(StreaminDataPicture.LowerAddress);
643 resourceParams.bIsWritable = false;
644 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
645
646 InitMocsParams(resourceParams, &cmd.StreaminDataPicture.PictureFields.DW0.Value, 1, 6);
647
648 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
649 this->m_osItf,
650 this->m_currentCmdBuf,
651 &resourceParams));
652 }
653
654 // SCC will use BwdRef0 as extra slot to store IBC if max fwd ref num is 3.
655 typename cmd_t::VDENC_Reference_Picture_CMD *fwdRefs[] =
656 {&cmd.FwdRef0, &cmd.FwdRef1, &cmd.FwdRef2, &cmd.BwdRef0};
657 uint32_t fwdRefsDwLoaction[] =
658 {_MHW_CMD_DW_LOCATION(FwdRef0), _MHW_CMD_DW_LOCATION(FwdRef1), _MHW_CMD_DW_LOCATION(FwdRef2), _MHW_CMD_DW_LOCATION(BwdRef0)};
659
660 typename cmd_t::VDENC_Down_Scaled_Reference_Picture_CMD *fwdRefsDsStage1[] =
661 {&cmd.DsFwdRef0, &cmd.DsFwdRef1};
662 uint32_t fwdRefsDsStage1DwLoaction[] =
663 {_MHW_CMD_DW_LOCATION(DsFwdRef0), _MHW_CMD_DW_LOCATION(DsFwdRef1)};
664
665 typename cmd_t::VDENC_Down_Scaled_Reference_Picture_CMD *fwdRefsDsStage2[] =
666 {&cmd.DsFwdRef04X, &cmd.DsFwdRef14X, &cmd.Additional4xDsFwdRef};
667 uint32_t fwdRefsDsStage2DwLoaction[] =
668 {_MHW_CMD_DW_LOCATION(DsFwdRef04X), _MHW_CMD_DW_LOCATION(DsFwdRef14X), _MHW_CMD_DW_LOCATION(Additional4xDsFwdRef)};
669
670 uint8_t refIdx;
671 for (refIdx = 0; refIdx < params.numActiveRefL0; refIdx++)
672 {
673 if (!Mos_ResourceIsNull(params.refs[refIdx]) && refIdx < sizeof(fwdRefs) / sizeof(fwdRefs[0]))
674 {
675 MOS_SURFACE details = {};
676 details.Format = Format_Invalid;
677 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refs[refIdx], &details));
678
679 resourceParams.presResource = params.refs[refIdx];
680 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
681 resourceParams.dwLocationInCmd = fwdRefsDwLoaction[refIdx];
682 resourceParams.bIsWritable = false;
683 resourceParams.pdwCmd = (uint32_t *)&fwdRefs[refIdx]->LowerAddress;
684 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
685
686 uint8_t mmcSkip = (params.mmcSkipMask) & (1 << refIdx);
687 auto mmcMode = MOS_MEMCOMP_DISABLED;
688 uint32_t mmcFormat = 0;
689 if (params.mmcEnabled)
690 {
691 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetMemoryCompressionMode(
692 this->m_osItf, params.refs[refIdx], &mmcMode));
693 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetMemoryCompressionFormat(
694 this->m_osItf, params.refs[refIdx], &mmcFormat));
695 }
696
697 fwdRefs[refIdx]->PictureFields.DW0.MemoryCompressionEnable = mmcSkip ? 0 : MmcEnabled(mmcMode);
698 fwdRefs[refIdx]->PictureFields.DW0.CompressionType = mmcSkip ? MOS_MEMCOMP_DISABLED : MmcRcEnabled(mmcMode);
699 fwdRefs[refIdx]->PictureFields.DW0.CompressionFormat = mmcFormat;
700
701 InitMocsParams(resourceParams, &fwdRefs[refIdx]->PictureFields.DW0.Value, 1, 6);
702
703 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
704 this->m_osItf,
705 this->m_currentCmdBuf,
706 &resourceParams));
707 }
708
709 if (!Mos_ResourceIsNull(params.refsDsStage1[refIdx]) && refIdx < sizeof(fwdRefsDsStage1) / sizeof(fwdRefsDsStage1[0]))
710 {
711 MOS_SURFACE details = {};
712 details.Format = Format_Invalid;
713 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage1[refIdx], &details));
714
715 resourceParams.presResource = params.refsDsStage1[refIdx];
716 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
717 resourceParams.dwLocationInCmd = fwdRefsDsStage1DwLoaction[refIdx];
718 resourceParams.bIsWritable = false;
719 resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage1[refIdx]->LowerAddress);
720 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
721
722 auto mmcMode = params.mmcStateDsStage1;
723
724 fwdRefsDsStage1[refIdx]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
725 fwdRefsDsStage1[refIdx]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
726
727 InitMocsParams(resourceParams, &fwdRefsDsStage1[refIdx]->PictureFields.DW0.Value, 1, 6);
728
729 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
730 this->m_osItf,
731 this->m_currentCmdBuf,
732 &resourceParams));
733 }
734
735 if (!Mos_ResourceIsNull(params.refsDsStage2[refIdx]) && refIdx < sizeof(fwdRefsDsStage2) / sizeof(fwdRefsDsStage2[0]))
736 {
737 MOS_SURFACE details = {};
738 details.Format = Format_Invalid;
739 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage2[refIdx], &details));
740
741 resourceParams.presResource = params.refsDsStage2[refIdx];
742 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
743 resourceParams.dwLocationInCmd = fwdRefsDsStage2DwLoaction[refIdx];
744 resourceParams.bIsWritable = false;
745 resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage2[refIdx]->LowerAddress);
746 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
747
748 auto mmcMode = params.mmcStateDsStage2;
749
750 fwdRefsDsStage2[refIdx]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
751 fwdRefsDsStage2[refIdx]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
752
753 InitMocsParams(resourceParams, &fwdRefsDsStage2[refIdx]->PictureFields.DW0.Value, 1, 6);
754
755 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
756 this->m_osItf,
757 this->m_currentCmdBuf,
758 &resourceParams));
759
760 if (params.numActiveRefL0 == 2 && params.numActiveRefL1 == 1 && refIdx == 1)
761 {
762 resourceParams.dwLocationInCmd = fwdRefsDsStage2DwLoaction[refIdx + 1];
763 resourceParams.pdwCmd = (uint32_t *)&(fwdRefsDsStage2[refIdx + 1]->LowerAddress);
764 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
765
766 fwdRefsDsStage2[refIdx + 1]->PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
767 fwdRefsDsStage2[refIdx + 1]->PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
768
769 InitMocsParams(resourceParams, &fwdRefsDsStage2[refIdx + 1]->PictureFields.DW0.Value, 1, 6);
770
771 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
772 this->m_osItf,
773 this->m_currentCmdBuf,
774 &resourceParams));
775 }
776 }
777 }
778
779 if ((!params.lowDelayB && params.numActiveRefL1) || params.isPFrame) //HW request HEVC PFrame to set address in BwdRef0 to be same as FwdRef0
780 {
781 if (!Mos_ResourceIsNull(params.refs[refIdx]))
782 {
783 MOS_SURFACE details = {};
784 details.Format = Format_Invalid;
785 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refs[refIdx], &details));
786
787 resourceParams.presResource = params.refs[refIdx];
788 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
789 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(BwdRef0);
790 resourceParams.bIsWritable = false;
791 resourceParams.pdwCmd = (uint32_t *)&(cmd.BwdRef0.LowerAddress);
792 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
793
794 auto mmcMode = MOS_MEMCOMP_DISABLED;
795 uint32_t mmcFormat = 0;
796 if (params.mmcEnabled)
797 {
798 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetMemoryCompressionMode(
799 this->m_osItf, params.refs[refIdx], &mmcMode));
800 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetMemoryCompressionFormat(
801 this->m_osItf, params.refs[refIdx], &mmcFormat));
802 }
803
804 cmd.BwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
805 cmd.BwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
806 cmd.BwdRef0.PictureFields.DW0.CompressionFormat = mmcFormat;
807
808 InitMocsParams(resourceParams, &cmd.BwdRef0.PictureFields.DW0.Value, 1, 6);
809
810 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
811 this->m_osItf,
812 this->m_currentCmdBuf,
813 &resourceParams));
814 }
815
816 if (!Mos_ResourceIsNull(params.refsDsStage1[refIdx]))
817 {
818 MOS_SURFACE details = {};
819 details.Format = Format_Invalid;
820 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage1[refIdx], &details));
821
822 resourceParams.presResource = params.refsDsStage1[refIdx];
823 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
824 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DsBwdRef0);
825 resourceParams.bIsWritable = false;
826 resourceParams.pdwCmd = (uint32_t *)&(cmd.DsBwdRef0.LowerAddress);
827 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
828
829 auto mmcMode = params.mmcStateDsStage1;
830
831 cmd.DsBwdRef0.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
832 cmd.DsBwdRef0.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
833
834 InitMocsParams(resourceParams, &cmd.DsBwdRef0.PictureFields.DW0.Value, 1, 6);
835
836 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
837 this->m_osItf,
838 this->m_currentCmdBuf,
839 &resourceParams));
840 }
841
842 if (!Mos_ResourceIsNull(params.refsDsStage2[refIdx]))
843 {
844 MOS_SURFACE details = {};
845 details.Format = Format_Invalid;
846 MHW_CHK_STATUS_RETURN(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refsDsStage2[refIdx], &details));
847
848 resourceParams.presResource = params.refsDsStage2[refIdx];
849 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
850 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DsBwdRef04X);
851 resourceParams.bIsWritable = false;
852 resourceParams.pdwCmd = (uint32_t *)&(cmd.DsBwdRef04X.LowerAddress);
853 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
854
855 auto mmcMode = params.mmcStateDsStage2;
856
857 cmd.DsBwdRef04X.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
858 cmd.DsBwdRef04X.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
859
860 InitMocsParams(resourceParams, &cmd.DsBwdRef04X.PictureFields.DW0.Value, 1, 6);
861
862 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
863 this->m_osItf,
864 this->m_currentCmdBuf,
865 &resourceParams));
866 }
867 }
868
869 if (!Mos_ResourceIsNull(params.colocatedMvReadBuffer))
870 {
871 resourceParams.presResource = params.colocatedMvReadBuffer;
872 resourceParams.dwOffset = 0;
873 resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMv.LowerAddress);
874 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMv.LowerAddress);
875 resourceParams.bIsWritable = false;
876 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
877
878 cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
879 cmd.ColocatedMv.PictureFields.DW0.CompressionType = 0;
880
881 InitMocsParams(resourceParams, &cmd.ColocatedMv.PictureFields.DW0.Value, 1, 6);
882
883 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
884 this->m_osItf,
885 this->m_currentCmdBuf,
886 &resourceParams));
887 }
888
889 if (!Mos_ResourceIsNull(params.colMvTempBuffer[0]))
890 {
891 resourceParams.presResource = params.colMvTempBuffer[0];
892 resourceParams.dwOffset = 0;
893 resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMv.LowerAddress);
894 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMv.LowerAddress);
895 resourceParams.bIsWritable = true;
896 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
897
898 cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable = 0;
899 cmd.ColocatedMv.PictureFields.DW0.CompressionType = 0;
900
901 InitMocsParams(resourceParams, &cmd.ColocatedMv.PictureFields.DW0.Value, 1, 6);
902
903 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
904 this->m_osItf,
905 this->m_currentCmdBuf,
906 &resourceParams));
907 }
908
909 if (params.surfaceDsStage1)
910 {
911 resourceParams.presResource = &params.surfaceDsStage1->OsResource;
912 resourceParams.dwOffset = params.surfaceDsStage1->dwOffset;
913 resourceParams.pdwCmd = (uint32_t *)&(cmd.ScaledReferenceSurfaceStage1.LowerAddress);
914 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ScaledReferenceSurfaceStage1.LowerAddress);
915 resourceParams.bIsWritable = true;
916 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
917
918 auto mmcMode = params.mmcStateDsStage1;
919
920 cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
921 cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
922
923 InitMocsParams(resourceParams, &cmd.ScaledReferenceSurfaceStage1.PictureFields.DW0.Value, 1, 6);
924
925 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
926 this->m_osItf,
927 this->m_currentCmdBuf,
928 &resourceParams));
929 }
930
931 if (params.surfaceDsStage2)
932 {
933 resourceParams.presResource = &params.surfaceDsStage2->OsResource;
934 resourceParams.dwOffset = params.surfaceDsStage2->dwOffset;
935 resourceParams.pdwCmd = (uint32_t *)&(cmd.ScaledReferenceSurfaceStage2.LowerAddress);
936 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ScaledReferenceSurfaceStage2.LowerAddress);
937 resourceParams.bIsWritable = true;
938 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
939
940 auto mmcMode = params.mmcStateDsStage2;
941
942 cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.MemoryCompressionEnable = MmcEnabled(mmcMode);
943 cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.CompressionType = MmcRcEnabled(mmcMode);
944
945 InitMocsParams(resourceParams, &cmd.ScaledReferenceSurfaceStage2.PictureFields.DW0.Value, 1, 6);
946
947 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
948 this->m_osItf,
949 this->m_currentCmdBuf,
950 &resourceParams));
951 }
952
953 if (!Mos_ResourceIsNull(params.pakObjCmdStreamOutBuffer))
954 {
955 resourceParams.presResource = params.pakObjCmdStreamOutBuffer;
956 resourceParams.dwOffset = 0;
957 resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencLcuPakObjCmdBuffer.LowerAddress);
958 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencLcuPakObjCmdBuffer.LowerAddress);
959 resourceParams.bIsWritable = true;
960 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
961
962 cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
963 cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.CompressionType = 0;
964
965 InitMocsParams(resourceParams, &cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.Value, 1, 6);
966
967 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
968 this->m_osItf,
969 this->m_currentCmdBuf,
970 &resourceParams));
971 }
972
973 if (!Mos_ResourceIsNull(params.segmentMapStreamInBuffer))
974 {
975 resourceParams.presResource = params.segmentMapStreamInBuffer;
976 resourceParams.dwOffset = 0;
977 resourceParams.pdwCmd = (uint32_t *)&(cmd.Vp9SegmentationMapStreaminBuffer.LowerAddress);
978 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9SegmentationMapStreaminBuffer.LowerAddress);
979 resourceParams.bIsWritable = true;
980 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
981
982 InitMocsParams(resourceParams, &cmd.Vp9SegmentationMapStreaminBuffer.PictureFields.DW0.Value, 1, 6);
983
984 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
985 this->m_osItf,
986 this->m_currentCmdBuf,
987 &resourceParams));
988 }
989
990 if (!Mos_ResourceIsNull(params.segmentMapStreamOutBuffer))
991 {
992 resourceParams.presResource = params.segmentMapStreamOutBuffer;
993 resourceParams.dwOffset = 0;
994 resourceParams.pdwCmd = (uint32_t *)&(cmd.Vp9SegmentationMapStreamoutBuffer.LowerAddress);
995 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Vp9SegmentationMapStreamoutBuffer.LowerAddress);
996 resourceParams.bIsWritable = true;
997 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
998
999 InitMocsParams(resourceParams, &cmd.Vp9SegmentationMapStreamoutBuffer.PictureFields.DW0.Value, 1, 6);
1000
1001 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
1002 this->m_osItf,
1003 this->m_currentCmdBuf,
1004 &resourceParams));
1005 }
1006
1007 cmd.DW61.WeightsHistogramStreamoutOffset = 3 * MHW_CACHELINE_SIZE;
1008
1009 if (!Mos_ResourceIsNull(params.tileRowStoreBuffer))
1010 {
1011 resourceParams.presResource = params.tileRowStoreBuffer;
1012 resourceParams.dwOffset = 0;
1013 resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencTileRowStoreBuffer.LowerAddress);
1014 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencTileRowStoreBuffer.LowerAddress);
1015 resourceParams.bIsWritable = true;
1016 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
1017
1018 InitMocsParams(resourceParams, &cmd.VdencTileRowStoreBuffer.BufferPictureFields.DW0.Value, 1, 6);
1019
1020 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
1021 this->m_osItf,
1022 this->m_currentCmdBuf,
1023 &resourceParams));
1024 }
1025
1026 if (this->m_rowStoreCache.ipdl.enabled)
1027 {
1028 cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.CacheSelect = cmd_t::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
1029 cmd.IntraPredictionRowstoreBaseAddress.LowerAddress.DW0.Value = this->m_rowStoreCache.ipdl.dwAddress << 6;
1030 }
1031 else if (!Mos_ResourceIsNull(params.mfdIntraRowStoreScratchBuffer))
1032 {
1033 resourceParams.presResource = params.mfdIntraRowStoreScratchBuffer;
1034 resourceParams.dwOffset = 0;
1035 resourceParams.pdwCmd = (uint32_t *)&(cmd.IntraPredictionRowstoreBaseAddress);
1036 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionRowstoreBaseAddress);
1037 resourceParams.bIsWritable = true;
1038 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
1039
1040 cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.MemoryCompressionEnable = 0;
1041
1042 InitMocsParams(resourceParams, &cmd.IntraPredictionRowstoreBaseAddress.BufferPictureFields.DW0.Value, 1, 6);
1043
1044 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
1045 this->m_osItf,
1046 this->m_currentCmdBuf,
1047 &resourceParams));
1048 }
1049
1050 if (!Mos_ResourceIsNull(params.cumulativeCuCountStreamOutBuffer))
1051 {
1052 resourceParams.presResource = params.cumulativeCuCountStreamOutBuffer;
1053 resourceParams.dwOffset = 0;
1054 resourceParams.pdwCmd = (uint32_t *)&(cmd.VdencCumulativeCuCountStreamoutSurface.LowerAddress);
1055 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(VdencCumulativeCuCountStreamoutSurface.LowerAddress);
1056 resourceParams.bIsWritable = true;
1057 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
1058
1059 InitMocsParams(resourceParams, &cmd.VdencCumulativeCuCountStreamoutSurface.PictureFields.DW0.Value, 1, 6);
1060
1061 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
1062 this->m_osItf,
1063 this->m_currentCmdBuf,
1064 &resourceParams));
1065 }
1066
1067 if (!Mos_ResourceIsNull(params.colocatedMvWriteBuffer))
1068 {
1069 resourceParams.presResource = params.colocatedMvWriteBuffer;
1070 resourceParams.dwOffset = 0;
1071 resourceParams.pdwCmd = (uint32_t *)&(cmd.ColocatedMvAvcWriteBuffer.LowerAddress);
1072 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ColocatedMvAvcWriteBuffer.LowerAddress);
1073 resourceParams.bIsWritable = true;
1074 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
1075
1076 cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.MemoryCompressionEnable = 0;
1077 cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.CompressionType = 0;
1078
1079 InitMocsParams(resourceParams, &cmd.ColocatedMvAvcWriteBuffer.PictureFields.DW0.Value, 1, 6);
1080
1081 MHW_CHK_STATUS_RETURN(this->AddResourceToCmd(
1082 this->m_osItf,
1083 this->m_currentCmdBuf,
1084 &resourceParams));
1085 }
1086
1087 return MOS_STATUS_SUCCESS;
1088 }
1089
1090 _MHW_SETCMD_OVERRIDE_DECL(VDENC_WEIGHTSOFFSETS_STATE)
1091 {
1092 _MHW_SETCMD_CALLBASE(VDENC_WEIGHTSOFFSETS_STATE);
1093
1094 #define DO_FIELDS() \
1095 DO_FIELD(DW1, WeightsForwardReference0, Clip3(-128, 127, params.weightsLuma[0][0] + params.denomLuma)); \
1096 DO_FIELD(DW1, OffsetForwardReference0, params.offsetsLuma[0][0]); \
1097 DO_FIELD(DW1, WeightsForwardReference1, Clip3(-128, 127, params.weightsLuma[0][1] + params.denomLuma)); \
1098 DO_FIELD(DW1, OffsetForwardReference1, params.offsetsLuma[0][1]); \
1099 \
1100 DO_FIELD(DW2, WeightsForwardReference2, Clip3(-128, 127, params.weightsLuma[0][2] + params.denomLuma)); \
1101 DO_FIELD(DW2, OffsetForwardReference2, params.offsetsLuma[0][2]); \
1102 DO_FIELD(DW2, WeightsBackwardReference0, Clip3(-128, 127, params.weightsLuma[1][0] + params.denomLuma)); \
1103 DO_FIELD(DW2, OffsetBackwardReference0, params.offsetsLuma[1][0]); \
1104 \
1105 DO_FIELD(DW3, CbWeightsForwardReference0, Clip3(-128, 127, params.weightsChroma[0][0][0] + params.denomChroma)); \
1106 DO_FIELD(DW3, CbOffsetForwardReference0, params.offsetsChroma[0][0][0]); \
1107 DO_FIELD(DW3, CbWeightsForwardReference1, Clip3(-128, 127, params.weightsChroma[0][1][0] + params.denomChroma)); \
1108 DO_FIELD(DW3, CbOffsetForwardReference1, params.offsetsChroma[0][1][0]); \
1109 \
1110 DO_FIELD(DW4, CbWeightsForwardReference2, Clip3(-128, 127, params.weightsChroma[0][2][0] + params.denomChroma)); \
1111 DO_FIELD(DW4, CbOffsetForwardReference2, params.offsetsChroma[0][2][0]); \
1112 DO_FIELD(DW4, CbWeightsBackwardReference0, Clip3(-128, 127, params.weightsChroma[1][0][0] + params.denomChroma)); \
1113 DO_FIELD(DW4, CbOffsetBackwardReference0, params.offsetsChroma[1][0][0]); \
1114 \
1115 DO_FIELD(DW5, CrWeightsForwardReference0, Clip3(-128, 127, params.weightsChroma[0][0][1] + params.denomChroma)); \
1116 DO_FIELD(DW5, CrOffsetForwardReference0, params.offsetsChroma[0][0][1]); \
1117 DO_FIELD(DW5, CrWeightsForwardReference1, Clip3(-128, 127, params.weightsChroma[0][1][1] + params.denomChroma)); \
1118 DO_FIELD(DW5, CrOffsetForwardReference1, params.offsetsChroma[0][1][1]); \
1119 \
1120 DO_FIELD(DW6, CrWeightsForwardReference2, Clip3(-128, 127, params.weightsChroma[0][2][1] + params.denomChroma)); \
1121 DO_FIELD(DW6, CrOffsetForwardReference2, params.offsetsChroma[0][2][1]); \
1122 DO_FIELD(DW6, CrWeightsBackwardReference0, Clip3(-128, 127, params.weightsChroma[1][0][1] + params.denomChroma)); \
1123 DO_FIELD(DW6, CrOffsetBackwardReference0, params.offsetsChroma[1][0][1])
1124
1125 #include "mhw_hwcmd_process_cmdfields.h"
1126 }
1127
1128 _MHW_SETCMD_OVERRIDE_DECL(VDENC_HEVC_VP9_TILE_SLICE_STATE)
1129 {
1130 _MHW_SETCMD_CALLBASE(VDENC_HEVC_VP9_TILE_SLICE_STATE);
1131
1132 #define DO_FIELDS() \
1133 DO_FIELD(DW3, NumParEngine, params.numPipe); \
1134 DO_FIELD(DW3, TileNumber, params.tileId); \
1135 DO_FIELD(DW3, TileRowStoreSelect, params.tileRowStoreSelect); \
1136 DO_FIELD(DW3, Log2WeightDenomLuma, params.log2WeightDenomLuma); \
1137 DO_FIELD(DW3, HevcVp9Log2WeightDenomLuma, params.hevcVp9Log2WeightDenomLuma); \
1138 DO_FIELD(DW3, Log2WeightDenomChroma, params.log2WeightDenomChroma); \
1139 \
1140 DO_FIELD(DW4, TileStartCtbX, params.tileStartLCUX *params.ctbSize); \
1141 DO_FIELD(DW4, TileStartCtbY, params.tileStartLCUY *params.ctbSize); \
1142 \
1143 DO_FIELD(DW5, TileWidth, (params.tileWidth >= 256 ? MOS_ALIGN_CEIL(params.tileWidth, 8) : params.tileWidth) - 1); \
1144 DO_FIELD(DW5, TileHeight, (params.tileHeight >= 128 ? MOS_ALIGN_CEIL(params.tileHeight, 8) : params.tileHeight) - 1); \
1145 \
1146 DO_FIELD(DW6, StreaminOffsetEnable, params.tileEnable); \
1147 DO_FIELD(DW6, TileStreaminOffset, params.tileStreamInOffset); \
1148 \
1149 DO_FIELD(DW7, RowStoreOffsetEnable, cmd.DW4.TileStartCtbY == 0 ? params.tileEnable : 0); \
1150 DO_FIELD(DW7, TileRowstoreOffset, params.tileRowstoreOffset); \
1151 \
1152 DO_FIELD(DW8, TileStreamoutOffsetEnable, params.tileEnable); \
1153 DO_FIELD(DW8, TileStreamoutOffset, params.tileId * 19); \
1154 \
1155 DO_FIELD(DW9, LcuStreamOutOffsetEnable, params.tileEnable); \
1156 DO_FIELD(DW9, TileLcuStreamOutOffset, params.tileLCUStreamOutOffset); \
1157 \
1158 DO_FIELD(DW11, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW11_BIT8, params.VdencHEVCVP9TileSlicePar0); \
1159 \
1160 DO_FIELD(DW12, IbcControl, params.ibcControl); \
1161 DO_FIELD(DW12, PaletteModeEnable, params.paletteModeEnable); \
1162 DO_FIELD(DW12, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW12_BIT24, params.VdencHEVCVP9TileSlicePar1); \
1163 DO_FIELD(DW12, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW12_BIT0, params.VdencHEVCVP9TileSlicePar5); \
1164 DO_FIELD(DW12, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW12_BIT18, params.VdencHEVCVP9TileSlicePar2); \
1165 DO_FIELD(DW12, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW12_BIT16, params.VdencHEVCVP9TileSlicePar3); \
1166 DO_FIELD(DW12, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW12_BIT8, params.VdencHEVCVP9TileSlicePar4); \
1167 \
1168 DO_FIELD(DW13, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW13_BIT16, params.VdencHEVCVP9TileSlicePar6); \
1169 DO_FIELD(DW13, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW13_BIT0, params.VdencHEVCVP9TileSlicePar7); \
1170 \
1171 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT8, params.VdencHEVCVP9TileSlicePar8); \
1172 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT0, params.VdencHEVCVP9TileSlicePar9); \
1173 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT16, params.VdencHEVCVP9TileSlicePar10); \
1174 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT31, params.VdencHEVCVP9TileSlicePar11); \
1175 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT24, params.VdencHEVCVP9TileSlicePar12); \
1176 DO_FIELD(DW14, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW14_BIT21, params.VdencHEVCVP9TileSlicePar13); \
1177 \
1178 DO_FIELD(DW15, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW15_BIT0, params.VdencHEVCVP9TileSlicePar15); \
1179 DO_FIELD(DW15, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW15_BIT16, params.VdencHEVCVP9TileSlicePar14); \
1180 \
1181 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT31, params.VdencHEVCVP9TileSlicePar16[2]); \
1182 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT30, params.VdencHEVCVP9TileSlicePar16[1]); \
1183 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT29, params.VdencHEVCVP9TileSlicePar16[0]); \
1184 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT24, params.VdencHEVCVP9TileSlicePar23); \
1185 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT16, params.VdencHEVCVP9TileSlicePar17[2]); \
1186 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT8, params.VdencHEVCVP9TileSlicePar17[1]); \
1187 DO_FIELD(DW16, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW16_BIT0, params.VdencHEVCVP9TileSlicePar17[0]); \
1188 \
1189 DO_FIELD(DW17, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW17_BIT0, params.VdencHEVCVP9TileSlicePar18); \
1190 DO_FIELD(DW17, VDENC_HEVC_VP9_TILE_SLICE_STATE_DW17_BIT6, params.VdencHEVCVP9TileSlicePar19);
1191
1192 #include "mhw_hwcmd_process_cmdfields.h"
1193 }
1194
1195 _MHW_SETCMD_OVERRIDE_DECL(VDENC_WALKER_STATE)
1196 {
1197 _MHW_SETCMD_CALLBASE(VDENC_WALKER_STATE);
1198
1199 #define DO_FIELDS() \
1200 DO_FIELD(DW1, FirstSuperSlice, params.firstSuperSlice); \
1201 DO_FIELD(DW1, MbLcuStartXPosition, params.tileSliceStartLcuMbX); \
1202 DO_FIELD(DW1, MbLcuStartYPosition, params.tileSliceStartLcuMbY); \
1203 \
1204 DO_FIELD(DW2, NextsliceMbLcuStartXPosition, params.nextTileSliceStartLcuMbX); \
1205 DO_FIELD(DW2, NextsliceMbStartYPosition, params.nextTileSliceStartLcuMbY)
1206
1207 #include "mhw_hwcmd_process_cmdfields.h"
1208 }
1209
1210 _MHW_SETCMD_OVERRIDE_DECL(VD_PIPELINE_FLUSH)
1211 {
1212 _MHW_SETCMD_CALLBASE(VD_PIPELINE_FLUSH);
1213
1214 #define DO_FIELDS() \
1215 DO_FIELD(DW1, HevcPipelineDone, params.waitDoneHEVC); \
1216 DO_FIELD(DW1, VdencPipelineDone, params.waitDoneVDENC); \
1217 DO_FIELD(DW1, MflPipelineDone, params.waitDoneMFL); \
1218 DO_FIELD(DW1, MfxPipelineDone, params.waitDoneMFX); \
1219 DO_FIELD(DW1, VdCommandMessageParserDone, params.waitDoneVDCmdMsgParser); \
1220 DO_FIELD(DW1, HevcPipelineCommandFlush, params.flushHEVC); \
1221 DO_FIELD(DW1, VdencPipelineCommandFlush, params.flushVDENC); \
1222 DO_FIELD(DW1, MflPipelineCommandFlush, params.flushMFL); \
1223 DO_FIELD(DW1, MfxPipelineCommandFlush, params.flushMFX)
1224
1225 #define DO_FIELDS_EXT() \
1226 __MHW_VDBOX_VDENC_WRAPPER_EXT(VD_PIPELINE_FLUSH_IMPL_EXT)
1227
1228 #include "mhw_hwcmd_process_cmdfields.h"
1229 }
1230
1231 _MHW_SETCMD_OVERRIDE_DECL(VDENC_AVC_SLICE_STATE)
1232 {
1233 _MHW_SETCMD_CALLBASE(VDENC_AVC_SLICE_STATE);
1234
1235 #define DO_FIELDS() \
1236 DO_FIELD(DW1, RoundIntra, params.roundIntra); \
1237 DO_FIELD(DW1, RoundIntraEnable, params.roundIntraEnable); \
1238 DO_FIELD(DW1, RoundInter, params.roundInter); \
1239 DO_FIELD(DW1, RoundInterEnable, params.roundInterEnable); \
1240 \
1241 DO_FIELD(DW3, Log2WeightDenomLuma, params.log2WeightDenomLuma)
1242 #include "mhw_hwcmd_process_cmdfields.h"
1243 }
1244
1245 _MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD1)
1246 {
1247 _MHW_SETCMD_CALLBASE(VDENC_CMD1);
1248
1249 #define DO_FIELDS() \
1250 DO_FIELD(DW1, VDENC_CMD1_DW1_BIT0, params.vdencCmd1Par2[0]); \
1251 DO_FIELD(DW1, VDENC_CMD1_DW1_BIT8, params.vdencCmd1Par2[1]); \
1252 DO_FIELD(DW1, VDENC_CMD1_DW1_BIT16, params.vdencCmd1Par2[2]); \
1253 DO_FIELD(DW1, VDENC_CMD1_DW1_BIT24, params.vdencCmd1Par2[3]); \
1254 \
1255 DO_FIELD(DW2, VDENC_CMD1_DW2_BIT0, params.vdencCmd1Par2[4]); \
1256 DO_FIELD(DW2, VDENC_CMD1_DW2_BIT8, params.vdencCmd1Par2[5]); \
1257 DO_FIELD(DW2, VDENC_CMD1_DW2_BIT16, params.vdencCmd1Par2[6]); \
1258 DO_FIELD(DW2, VDENC_CMD1_DW2_BIT24, params.vdencCmd1Par2[7]); \
1259 \
1260 DO_FIELD(DW3, VDENC_CMD1_DW3_BIT0, params.vdencCmd1Par3[0]); \
1261 DO_FIELD(DW3, VDENC_CMD1_DW3_BIT8, params.vdencCmd1Par3[1]); \
1262 DO_FIELD(DW3, VDENC_CMD1_DW3_BIT16, params.vdencCmd1Par3[2]); \
1263 DO_FIELD(DW3, VDENC_CMD1_DW3_BIT24, params.vdencCmd1Par3[3]); \
1264 \
1265 DO_FIELD(DW4, VDENC_CMD1_DW4_BIT0, params.vdencCmd1Par3[4]); \
1266 DO_FIELD(DW4, VDENC_CMD1_DW4_BIT8, params.vdencCmd1Par3[5]); \
1267 DO_FIELD(DW4, VDENC_CMD1_DW4_BIT16, params.vdencCmd1Par3[6]); \
1268 DO_FIELD(DW4, VDENC_CMD1_DW4_BIT24, params.vdencCmd1Par3[7]); \
1269 \
1270 DO_FIELD(DW5, VDENC_CMD1_DW5_BIT0, params.vdencCmd1Par3[8]); \
1271 DO_FIELD(DW5, VDENC_CMD1_DW5_BIT8, params.vdencCmd1Par3[9]); \
1272 DO_FIELD(DW5, VDENC_CMD1_DW5_BIT16, params.vdencCmd1Par3[10]); \
1273 DO_FIELD(DW5, VDENC_CMD1_DW5_BIT24, params.vdencCmd1Par3[11]); \
1274 \
1275 DO_FIELD(DW6, VDENC_CMD1_DW6_BIT0, params.vdencCmd1Par4[0]); \
1276 DO_FIELD(DW6, VDENC_CMD1_DW6_BIT8, params.vdencCmd1Par4[1]); \
1277 DO_FIELD(DW6, VDENC_CMD1_DW6_BIT16, params.vdencCmd1Par4[2]); \
1278 DO_FIELD(DW6, VDENC_CMD1_DW6_BIT24, params.vdencCmd1Par4[3]); \
1279 \
1280 DO_FIELD(DW7, VDENC_CMD1_DW7_BIT0, params.vdencCmd1Par4[4]); \
1281 DO_FIELD(DW7, VDENC_CMD1_DW7_BIT8, params.vdencCmd1Par4[5]); \
1282 DO_FIELD(DW7, VDENC_CMD1_DW7_BIT16, params.vdencCmd1Par4[6]); \
1283 DO_FIELD(DW7, VDENC_CMD1_DW7_BIT24, params.vdencCmd1Par4[7]); \
1284 \
1285 DO_FIELD(DW8, VDENC_CMD1_DW8_BIT0, params.vdencCmd1Par4[8]); \
1286 DO_FIELD(DW8, VDENC_CMD1_DW8_BIT8, params.vdencCmd1Par4[9]); \
1287 DO_FIELD(DW8, VDENC_CMD1_DW8_BIT16, params.vdencCmd1Par4[10]); \
1288 DO_FIELD(DW8, VDENC_CMD1_DW8_BIT24, params.vdencCmd1Par4[11]); \
1289 \
1290 DO_FIELD(DW9, VDENC_CMD1_DW9_BIT0, params.vdencCmd1Par5); \
1291 DO_FIELD(DW9, VDENC_CMD1_DW9_BIT8, params.vdencCmd1Par6); \
1292 DO_FIELD(DW9, VDENC_CMD1_DW9_BIT16, params.vdencCmd1Par7); \
1293 \
1294 DO_FIELD(DW10, VDENC_CMD1_DW10_BIT0, params.vdencCmd1Par8[0]); \
1295 DO_FIELD(DW10, VDENC_CMD1_DW10_BIT8, params.vdencCmd1Par12[0]); \
1296 DO_FIELD(DW10, VDENC_CMD1_DW10_BIT16, params.vdencCmd1Par9[0]); \
1297 DO_FIELD(DW10, VDENC_CMD1_DW10_BIT24, params.vdencCmd1Par13[0]); \
1298 \
1299 DO_FIELD(DW11, VDENC_CMD1_DW11_BIT0, params.vdencCmd1Par10[0]); \
1300 DO_FIELD(DW11, VDENC_CMD1_DW11_BIT8, params.vdencCmd1Par14[0]); \
1301 DO_FIELD(DW11, VDENC_CMD1_DW11_BIT16, params.vdencCmd1Par11[0]); \
1302 DO_FIELD(DW11, VDENC_CMD1_DW11_BIT24, params.vdencCmd1Par15[0]); \
1303 \
1304 DO_FIELD(DW12, VDENC_CMD1_DW12_BIT0, params.vdencCmd1Par16); \
1305 DO_FIELD(DW12, VDENC_CMD1_DW12_BIT8, params.vdencCmd1Par17); \
1306 DO_FIELD(DW12, VDENC_CMD1_DW12_BIT16, params.vdencCmd1Par18); \
1307 DO_FIELD(DW12, VDENC_CMD1_DW12_BIT24, params.vdencCmd1Par19); \
1308 \
1309 DO_FIELD(DW13, VDENC_CMD1_DW13_BIT0, params.vdencCmd1Par20); \
1310 DO_FIELD(DW13, VDENC_CMD1_DW13_BIT8, params.vdencCmd1Par21); \
1311 DO_FIELD(DW13, VDENC_CMD1_DW13_BIT16, params.vdencCmd1Par22); \
1312 DO_FIELD(DW13, VDENC_CMD1_DW13_BIT24, params.vdencCmd1Par23); \
1313 \
1314 DO_FIELD(DW14, VDENC_CMD1_DW14_BIT0, params.vdencCmd1Par24); \
1315 DO_FIELD(DW14, VDENC_CMD1_DW14_BIT8, params.vdencCmd1Par25); \
1316 DO_FIELD(DW14, VDENC_CMD1_DW14_BIT16, params.vdencCmd1Par26); \
1317 DO_FIELD(DW14, VDENC_CMD1_DW14_BIT24, params.vdencCmd1Par27); \
1318 \
1319 DO_FIELD(DW15, VDENC_CMD1_DW15_BIT0, params.vdencCmd1Par28); \
1320 DO_FIELD(DW15, VDENC_CMD1_DW15_BIT8, params.vdencCmd1Par29); \
1321 DO_FIELD(DW15, VDENC_CMD1_DW15_BIT16, params.vdencCmd1Par30); \
1322 DO_FIELD(DW15, VDENC_CMD1_DW15_BIT24, params.vdencCmd1Par31); \
1323 \
1324 DO_FIELD(DW16, VDENC_CMD1_DW16_BIT0, params.vdencCmd1Par32); \
1325 DO_FIELD(DW16, VDENC_CMD1_DW16_BIT8, params.vdencCmd1Par33); \
1326 DO_FIELD(DW16, VDENC_CMD1_DW16_BIT16, params.vdencCmd1Par34); \
1327 DO_FIELD(DW16, VDENC_CMD1_DW16_BIT24, params.vdencCmd1Par35); \
1328 \
1329 DO_FIELD(DW17, VDENC_CMD1_DW17_BIT0, params.vdencCmd1Par36); \
1330 DO_FIELD(DW17, VDENC_CMD1_DW17_BIT8, params.vdencCmd1Par37); \
1331 DO_FIELD(DW17, VDENC_CMD1_DW17_BIT16, params.vdencCmd1Par38); \
1332 DO_FIELD(DW17, VDENC_CMD1_DW17_BIT24, params.vdencCmd1Par39); \
1333 \
1334 DO_FIELD(DW18, VDENC_CMD1_DW18_BIT0, params.vdencCmd1Par40); \
1335 DO_FIELD(DW18, VDENC_CMD1_DW18_BIT8, params.vdencCmd1Par41); \
1336 DO_FIELD(DW18, VDENC_CMD1_DW18_BIT16, params.vdencCmd1Par42); \
1337 DO_FIELD(DW18, VDENC_CMD1_DW18_BIT24, params.vdencCmd1Par43); \
1338 \
1339 DO_FIELD(DW19, VDENC_CMD1_DW19_BIT8, params.vdencCmd1Par44); \
1340 DO_FIELD(DW19, VDENC_CMD1_DW19_BIT16, params.vdencCmd1Par45); \
1341 DO_FIELD(DW19, VDENC_CMD1_DW19_BIT24, params.vdencCmd1Par46); \
1342 \
1343 DO_FIELD(DW20, VDENC_CMD1_DW20_BIT0, params.vdencCmd1Par47); \
1344 DO_FIELD(DW20, VDENC_CMD1_DW20_BIT8, params.vdencCmd1Par48); \
1345 DO_FIELD(DW20, VDENC_CMD1_DW20_BIT16, params.vdencCmd1Par49); \
1346 DO_FIELD(DW20, VDENC_CMD1_DW20_BIT24, params.vdencCmd1Par50); \
1347 \
1348 DO_FIELD(DW21, VDENC_CMD1_DW21_BIT0, params.vdencCmd1Par51); \
1349 DO_FIELD(DW21, VDENC_CMD1_DW21_BIT8, params.vdencCmd1Par52); \
1350 DO_FIELD(DW21, VDENC_CMD1_DW21_BIT16, params.vdencCmd1Par53); \
1351 DO_FIELD(DW21, VDENC_CMD1_DW21_BIT24, params.vdencCmd1Par54); \
1352 \
1353 DO_FIELD(DW22, VDENC_CMD1_DW22_BIT0, params.vdencCmd1Par0); \
1354 DO_FIELD(DW22, VDENC_CMD1_DW22_BIT16, params.vdencCmd1Par1); \
1355 \
1356 DO_FIELD(DW23, VDENC_CMD1_DW23_BIT0, params.vdencCmd1Par55); \
1357 DO_FIELD(DW23, VDENC_CMD1_DW23_BIT8, params.vdencCmd1Par56); \
1358 DO_FIELD(DW23, VDENC_CMD1_DW23_BIT16, params.vdencCmd1Par57); \
1359 DO_FIELD(DW23, VDENC_CMD1_DW23_BIT24, params.vdencCmd1Par58); \
1360 \
1361 DO_FIELD(DW24, VDENC_CMD1_DW24_BIT0, params.vdencCmd1Par59); \
1362 DO_FIELD(DW24, VDENC_CMD1_DW24_BIT8, params.vdencCmd1Par60); \
1363 DO_FIELD(DW24, VDENC_CMD1_DW24_BIT16, params.vdencCmd1Par61); \
1364 DO_FIELD(DW24, VDENC_CMD1_DW24_BIT24, params.vdencCmd1Par62); \
1365 \
1366 DO_FIELD(DW25, VDENC_CMD1_DW25_BIT0, params.vdencCmd1Par63); \
1367 DO_FIELD(DW25, VDENC_CMD1_DW25_BIT8, params.vdencCmd1Par64); \
1368 DO_FIELD(DW25, VDENC_CMD1_DW25_BIT16, params.vdencCmd1Par65); \
1369 DO_FIELD(DW25, VDENC_CMD1_DW25_BIT24, params.vdencCmd1Par66); \
1370 \
1371 DO_FIELD(DW26, VDENC_CMD1_DW26_BIT0, params.vdencCmd1Par67); \
1372 DO_FIELD(DW26, VDENC_CMD1_DW26_BIT8, params.vdencCmd1Par68); \
1373 DO_FIELD(DW26, VDENC_CMD1_DW26_BIT16, params.vdencCmd1Par69); \
1374 DO_FIELD(DW26, VDENC_CMD1_DW26_BIT24, params.vdencCmd1Par70); \
1375 \
1376 DO_FIELD(DW27, VDENC_CMD1_DW27_BIT0, params.vdencCmd1Par71); \
1377 DO_FIELD(DW27, VDENC_CMD1_DW27_BIT8, params.vdencCmd1Par72); \
1378 DO_FIELD(DW27, VDENC_CMD1_DW27_BIT16, params.vdencCmd1Par73); \
1379 DO_FIELD(DW27, VDENC_CMD1_DW27_BIT24, params.vdencCmd1Par74); \
1380 \
1381 DO_FIELD(DW28, VDENC_CMD1_DW28_BIT0, params.vdencCmd1Par75); \
1382 DO_FIELD(DW28, VDENC_CMD1_DW28_BIT8, params.vdencCmd1Par76); \
1383 DO_FIELD(DW28, VDENC_CMD1_DW28_BIT16, params.vdencCmd1Par77); \
1384 DO_FIELD(DW28, VDENC_CMD1_DW28_BIT24, params.vdencCmd1Par78); \
1385 \
1386 DO_FIELD(DW29, VDENC_CMD1_DW29_BIT0, params.vdencCmd1Par79); \
1387 DO_FIELD(DW29, VDENC_CMD1_DW29_BIT8, params.vdencCmd1Par80); \
1388 DO_FIELD(DW29, VDENC_CMD1_DW29_BIT16, params.vdencCmd1Par81); \
1389 DO_FIELD(DW29, VDENC_CMD1_DW29_BIT24, params.vdencCmd1Par82); \
1390 \
1391 DO_FIELD(DW30, VDENC_CMD1_DW30_BIT0, params.vdencCmd1Par83); \
1392 DO_FIELD(DW30, VDENC_CMD1_DW30_BIT8, params.vdencCmd1Par84); \
1393 DO_FIELD(DW30, VDENC_CMD1_DW30_BIT16, params.vdencCmd1Par85); \
1394 DO_FIELD(DW30, VDENC_CMD1_DW30_BIT24, params.vdencCmd1Par86); \
1395 \
1396 DO_FIELD(DW31, VDENC_CMD1_DW31_BIT0, params.vdencCmd1Par87); \
1397 DO_FIELD(DW31, VDENC_CMD1_DW31_BIT8, params.vdencCmd1Par88); \
1398 DO_FIELD(DW31, VDENC_CMD1_DW31_BIT16, params.vdencCmd1Par89); \
1399 \
1400 DO_FIELD(DW32, VDENC_CMD1_DW32_BIT0, params.vdencCmd1Par90); \
1401 DO_FIELD(DW32, VDENC_CMD1_DW32_BIT8, params.vdencCmd1Par91); \
1402 DO_FIELD(DW32, VDENC_CMD1_DW32_BIT16, params.vdencCmd1Par92)
1403
1404 #include "mhw_hwcmd_process_cmdfields.h"
1405 }
1406
1407 _MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD2)
1408 {
1409 _MHW_SETCMD_CALLBASE(VDENC_CMD2);
1410
1411 #define DO_FIELDS() \
1412 DO_FIELD(DW1, FrameWidthInPixelsMinusOne, MOS_ALIGN_CEIL(params.width, 8) - 1); \
1413 DO_FIELD(DW1, FrameHeightInPixelsMinusOne, MOS_ALIGN_CEIL(params.height, 8) - 1); \
1414 \
1415 DO_FIELD(DW2, PictureType, params.pictureType); \
1416 DO_FIELD(DW2, TemporalMvpEnableFlag, params.temporalMvp); \
1417 DO_FIELD(DW2, Collocatedfroml0Flag, params.collocatedFromL0); \
1418 DO_FIELD(DW2, LongTermReferenceFlagsL0, params.longTermReferenceFlagsL0); \
1419 DO_FIELD(DW2, LongTermReferenceFlagsL1, params.longTermReferenceFlagsL1); \
1420 DO_FIELD(DW2, TransformSkip, params.transformSkip); \
1421 DO_FIELD(DW2, ConstrainedIntraPredFlag, params.constrainedIntraPred); \
1422 \
1423 DO_FIELD(DW3, FwdPocNumberForRefid0InL0, params.pocL0Ref0); \
1424 DO_FIELD(DW3, BwdPocNumberForRefid0InL1, params.pocL1Ref0); \
1425 DO_FIELD(DW3, PocNumberForRefid1InL0, params.pocL0Ref1); \
1426 DO_FIELD(DW3, PocNumberForRefid1InL1, params.pocL1Ref1); \
1427 \
1428 DO_FIELD(DW4, PocNumberForRefid2InL0, params.pocL0Ref2); \
1429 DO_FIELD(DW4, PocNumberForRefid2InL1, params.pocL1Ref2); \
1430 DO_FIELD(DW4, PocNumberForRefid3InL0, params.pocL0Ref3); \
1431 DO_FIELD(DW4, PocNumberForRefid3InL1, params.pocL1Ref3); \
1432 \
1433 DO_FIELD(DW5, StreaminRoiEnable, params.roiStreamIn); \
1434 DO_FIELD(DW5, NumRefIdxL0Minus1, params.numRefL0 > 0 ? params.numRefL0 - 1 : 0); \
1435 DO_FIELD(DW5, NumRefIdxL1Minus1, params.numRefL1 > 0 ? params.numRefL1 - 1 : 0); \
1436 DO_FIELD(DW5, SubPelMode, params.subPelMode); \
1437 \
1438 DO_FIELD(DW7, SegmentationEnable, params.segmentation); \
1439 DO_FIELD(DW7, SegmentationMapTemporalPredictionEnable, params.segmentationTemporal); \
1440 DO_FIELD(DW7, TilingEnable, params.tiling); \
1441 DO_FIELD(DW7, VdencStreamInEnable, params.vdencStreamIn); \
1442 DO_FIELD(DW7, PakOnlyMultiPassEnable, params.pakOnlyMultiPass); \
1443 \
1444 DO_FIELD(DW11, FwdRef0RefPic, params.frameIdxL0Ref0); \
1445 DO_FIELD(DW11, FwdRef1RefPic, params.frameIdxL0Ref1); \
1446 DO_FIELD(DW11, FwdRef2RefPic, params.frameIdxL0Ref2); \
1447 DO_FIELD(DW11, BwdRef0RefPic, params.frameIdxL1Ref0); \
1448 \
1449 DO_FIELD(DW16, MinQp, params.minQp); \
1450 DO_FIELD(DW16, MaxQp, params.maxQp); \
1451 \
1452 DO_FIELD(DW17, TemporalMVEnableForIntegerSearch, params.temporalMvEnableForIntegerSearch); \
1453 \
1454 DO_FIELD(DW21, IntraRefreshPos, params.intraRefreshPos); \
1455 DO_FIELD(DW21, IntraRefreshMBSizeMinusOne, params.intraRefreshMbSizeMinus1); \
1456 DO_FIELD(DW21, IntraRefreshMode, params.intraRefreshMode); \
1457 DO_FIELD(DW21, IntraRefreshEnable, params.intraRefresh); \
1458 DO_FIELD(DW21, QpAdjustmentForRollingI, params.qpAdjustmentForRollingI); \
1459 \
1460 DO_FIELD(DW24, QpForSeg0, params.qpForSegs[0]); \
1461 DO_FIELD(DW24, QpForSeg1, params.qpForSegs[1]); \
1462 DO_FIELD(DW24, QpForSeg2, params.qpForSegs[2]); \
1463 DO_FIELD(DW24, QpForSeg3, params.qpForSegs[3]); \
1464 \
1465 DO_FIELD(DW25, QpForSeg4, params.qpForSegs[4]); \
1466 DO_FIELD(DW25, QpForSeg5, params.qpForSegs[5]); \
1467 DO_FIELD(DW25, QpForSeg6, params.qpForSegs[6]); \
1468 DO_FIELD(DW25, QpForSeg7, params.qpForSegs[7]); \
1469 \
1470 DO_FIELD(DW26, Vp9DynamicSliceEnable, params.vp9DynamicSlice); \
1471 \
1472 DO_FIELD(DW27, QpPrimeYDc, params.qpPrimeYDc); \
1473 DO_FIELD(DW27, QpPrimeYAc, params.qpPrimeYAc); \
1474 \
1475 DO_FIELD(DW36, IntraRefreshBoundaryRef0, params.intraRefreshBoundary[0]); \
1476 DO_FIELD(DW36, IntraRefreshBoundaryRef1, params.intraRefreshBoundary[1]); \
1477 DO_FIELD(DW36, IntraRefreshBoundaryRef2, params.intraRefreshBoundary[2]); \
1478 \
1479 DO_FIELD(DW61, Av1L0RefID0, params.av1RefId[0][0]); \
1480 DO_FIELD(DW61, Av1L1RefID0, params.av1RefId[1][0]); \
1481 DO_FIELD(DW61, Av1L0RefID1, params.av1RefId[0][1]); \
1482 DO_FIELD(DW61, Av1L1RefID1, params.av1RefId[1][1]); \
1483 DO_FIELD(DW61, Av1L0RefID2, params.av1RefId[0][2]); \
1484 DO_FIELD(DW61, Av1L1RefID2, params.av1RefId[1][2]); \
1485 DO_FIELD(DW61, Av1L0RefID3, params.av1RefId[0][3]); \
1486 DO_FIELD(DW61, Av1L1RefID3, params.av1RefId[1][3])
1487
1488 #define DO_FIELDS_EXT() \
1489 __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_CMD2_IMPL_EXT)
1490
1491 #include "mhw_hwcmd_process_cmdfields.h"
1492 }
1493
1494 _MHW_SETCMD_OVERRIDE_DECL(VDENC_CMD3)
1495 {
1496 _MHW_SETCMD_CALLBASE(VDENC_CMD3);
1497
1498 cmd.DW1_2.VDENC_CMD3_DW1_BIT0 = params.vdencCmd3Par0[0];
1499 cmd.DW1_2.VDENC_CMD3_DW1_BIT8 = params.vdencCmd3Par0[1];
1500 cmd.DW1_2.VDENC_CMD3_DW1_BIT16 = params.vdencCmd3Par0[2];
1501 cmd.DW1_2.VDENC_CMD3_DW1_BIT24 = params.vdencCmd3Par0[3];
1502 cmd.DW1_2.VDENC_CMD3_DW2_BIT0 = params.vdencCmd3Par0[4];
1503 cmd.DW1_2.VDENC_CMD3_DW2_BIT8 = params.vdencCmd3Par0[5];
1504 cmd.DW1_2.VDENC_CMD3_DW2_BIT16 = params.vdencCmd3Par0[6];
1505 cmd.DW1_2.VDENC_CMD3_DW2_BIT24 = params.vdencCmd3Par0[7];
1506
1507 for (auto i = 0; i < 12; i++)
1508 {
1509 cmd.VDENC_CMD3_DW3_5[i] = params.vdencCmd3Par1[i];
1510 cmd.VDENC_CMD3_DW6_8[i] = params.vdencCmd3Par2[i];
1511 }
1512
1513 #define DO_FIELDS() \
1514 DO_FIELD(DW10, VDENC_CMD3_DW10_BIT16, params.vdencCmd3Par3); \
1515 DO_FIELD(DW10, VDENC_CMD3_DW10_BIT24, params.vdencCmd3Par4); \
1516 \
1517 DO_FIELD(DW12, VDENC_CMD3_DW12_BIT0, params.vdencCmd3Par5); \
1518 DO_FIELD(DW12, VDENC_CMD3_DW12_BIT8, params.vdencCmd3Par6); \
1519 DO_FIELD(DW12, VDENC_CMD3_DW12_BIT16, params.vdencCmd3Par7); \
1520 DO_FIELD(DW12, VDENC_CMD3_DW12_BIT24, params.vdencCmd3Par8); \
1521 \
1522 DO_FIELD(DW13, VDENC_CMD3_DW13_BIT0, params.vdencCmd3Par9); \
1523 DO_FIELD(DW13, VDENC_CMD3_DW13_BIT8, params.vdencCmd3Par10); \
1524 DO_FIELD(DW13, VDENC_CMD3_DW13_BIT16, params.vdencCmd3Par11); \
1525 DO_FIELD(DW13, VDENC_CMD3_DW13_BIT24, params.vdencCmd3Par12); \
1526 \
1527 DO_FIELD(DW14, VDENC_CMD3_DW14_BIT8, params.vdencCmd3Par13); \
1528 DO_FIELD(DW14, VDENC_CMD3_DW14_BIT16, params.vdencCmd3Par14); \
1529 DO_FIELD(DW14, VDENC_CMD3_DW14_BIT24, params.vdencCmd3Par15); \
1530 \
1531 DO_FIELD(DW15, VDENC_CMD3_DW15_BIT8, params.vdencCmd3Par16); \
1532 DO_FIELD(DW15, VDENC_CMD3_DW15_BIT16, params.vdencCmd3Par17); \
1533 DO_FIELD(DW15, VDENC_CMD3_DW15_BIT24, params.vdencCmd3Par18); \
1534 \
1535 DO_FIELD(DW16, VDENC_CMD3_DW16_BIT16, params.vdencCmd3Par19); \
1536 \
1537 DO_FIELD(DW17, VDENC_CMD3_DW17_BIT0, params.vdencCmd3Par20); \
1538 DO_FIELD(DW17, VDENC_CMD3_DW17_BIT8, params.vdencCmd3Par23); \
1539 DO_FIELD(DW17, VDENC_CMD3_DW17_BIT16, params.vdencCmd3Par21); \
1540 DO_FIELD(DW17, VDENC_CMD3_DW17_BIT24, params.vdencCmd3Par22); \
1541 \
1542 DO_FIELD(DW19, VDENC_CMD3_DW19_BIT8, params.vdencCmd3Par24); \
1543 DO_FIELD(DW19, VDENC_CMD3_DW19_BIT16, params.vdencCmd3Par25); \
1544 DO_FIELD(DW19, VDENC_CMD3_DW19_BIT24, params.vdencCmd3Par26); \
1545 \
1546 DO_FIELD(DW20, VDENC_CMD3_DW20_BIT0, params.vdencCmd3Par27); \
1547 DO_FIELD(DW20, VDENC_CMD3_DW20_BIT8, params.vdencCmd3Par28); \
1548 \
1549 DO_FIELD(DW21, VDENC_CMD3_DW21_BIT0, params.vdencCmd3Par29); \
1550 DO_FIELD(DW21, VDENC_CMD3_DW21_BIT8, params.vdencCmd3Par30); \
1551 \
1552 DO_FIELD(DW22, VDENC_CMD3_DW22_BIT0, params.vdencCmd3Par31); \
1553 DO_FIELD(DW22, VDENC_CMD3_DW22_BIT16, params.vdencCmd3Par32)
1554
1555 #include "mhw_hwcmd_process_cmdfields.h"
1556 }
1557
1558 _MHW_SETCMD_OVERRIDE_DECL(VDENC_AVC_IMG_STATE)
1559 {
1560 _MHW_SETCMD_CALLBASE(VDENC_AVC_IMG_STATE);
1561
1562 #define DO_FIELDS() \
1563 DO_FIELD(DW1, PictureType, params.pictureType); \
1564 DO_FIELD(DW1, Transform8X8Flag, params.transform8X8Flag); \
1565 DO_FIELD(DW1, colloc_mv_wr_en, params.colMVWriteEnable); \
1566 DO_FIELD(DW1, SubpelMode, params.subpelMode); \
1567 \
1568 DO_FIELD(DW2, colloc_mv_rd_en, params.colMVReadEnable); \
1569 DO_FIELD(DW2, BidirectionalWeight, params.bidirectionalWeight); \
1570 \
1571 DO_FIELD(DW3, PictureHeightMinusOne, params.pictureHeightMinusOne); \
1572 DO_FIELD(DW3, PictureWidth, params.pictureWidth); \
1573 \
1574 DO_FIELD(DW5, FwdRefIdx0ReferencePicture, params.fwdRefIdx0ReferencePicture); \
1575 DO_FIELD(DW5, BwdRefIdx0ReferencePicture, params.bwdRefIdx0ReferencePicture); \
1576 DO_FIELD(DW5, FwdRefIdx1ReferencePicture, params.fwdRefIdx1ReferencePicture); \
1577 DO_FIELD(DW5, FwdRefIdx2ReferencePicture, params.fwdRefIdx2ReferencePicture); \
1578 DO_FIELD(DW5, NumberOfL0ReferencesMinusOne, params.numberOfL0ReferencesMinusOne); \
1579 DO_FIELD(DW5, NumberOfL1ReferencesMinusOne, params.numberOfL1ReferencesMinusOne); \
1580 \
1581 DO_FIELD(DW6, IntraRefreshMbPos, params.intraRefreshMbPos); \
1582 DO_FIELD(DW6, IntraRefreshMbSizeMinusOne, params.intraRefreshMbSizeMinusOne); \
1583 DO_FIELD(DW6, IntraRefreshEnableRollingIEnable, params.intraRefreshEnableRollingIEnable); \
1584 DO_FIELD(DW6, IntraRefreshMode, params.intraRefreshMode); \
1585 DO_FIELD(DW6, QpAdjustmentForRollingI, params.qpAdjustmentForRollingI); \
1586 \
1587 DO_FIELD(DW9, RoiQpAdjustmentForZone0, params.roiQpAdjustmentForZone0); \
1588 DO_FIELD(DW9, RoiQpAdjustmentForZone1, params.roiQpAdjustmentForZone1); \
1589 DO_FIELD(DW9, RoiQpAdjustmentForZone2, params.roiQpAdjustmentForZone2); \
1590 DO_FIELD(DW9, RoiQpAdjustmentForZone3, params.roiQpAdjustmentForZone3); \
1591 \
1592 DO_FIELD(DW12, MinQp, params.minQp); \
1593 DO_FIELD(DW12, MaxQp, params.maxQp); \
1594 \
1595 DO_FIELD(DW13, RoiEnable, params.roiEnable); \
1596 DO_FIELD(DW13, MbLevelQpEnable, params.mbLevelQpEnable); \
1597 DO_FIELD(DW13, MbLevelDeltaQpEnable, params.mbLevelDeltaQpEnable); \
1598 DO_FIELD(DW13, LongtermReferenceFrameBwdRef0Indicator, params.longtermReferenceFrameBwdRef0Indicator); \
1599 \
1600 DO_FIELD(DW14, QpPrimeY, params.qpPrimeY); \
1601 DO_FIELD(DW14, TrellisQuantEn, params.trellisQuantEn); \
1602 \
1603 DO_FIELD(DW15, PocNumberForCurrentPicture, params.pocNumberForCurrentPicture); \
1604 DO_FIELD(DW16, PocNumberForFwdRef0, params.pocNumberForFwdRef0); \
1605 DO_FIELD(DW17, PocNumberForFwdRef1, params.pocNumberForFwdRef1); \
1606 DO_FIELD(DW18, PocNumberForFwdRef2, params.pocNumberForFwdRef2); \
1607 DO_FIELD(DW19, PocNumberForBwdRef0, params.pocNumberForBwdRef0)
1608
1609 #define DO_FIELDS_EXT() \
1610 __MHW_VDBOX_VDENC_WRAPPER_EXT(VDENC_AVC_IMG_STATE_IMPL_EXT)
1611
1612 #include "mhw_hwcmd_process_cmdfields.h"
1613 }
1614 MEDIA_CLASS_DEFINE_END(mhw__vdbox__vdenc__Impl)
1615 };
1616 } // namespace vdenc
1617 } // namespace vdbox
1618 } // namespace mhw
1619
1620 #endif // __MHW_VDBOX_VDENC_IMPL_H__