Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2020-2023, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_vdbox_avp_impl.h
24 //! \brief MHW VDBOX AVP interface common base
25 //! \details
26 //!
27
28 #ifndef __MHW_VDBOX_AVP_IMPL_H__
29 #define __MHW_VDBOX_AVP_IMPL_H__
30
31 #include "mhw_vdbox_avp_itf.h"
32 #include "mhw_impl.h"
33 #include "mos_interface.h"
34
35 namespace mhw
36 {
37 namespace vdbox
38 {
39 namespace avp
40 {
41 static constexpr uint32_t AVP_AVP_BITSTREAM_BYTECOUNT_TILE_WITH_HEADER_AWM_REG0 = 0x1C2B48;
42 static constexpr uint32_t AVP_ENC_BITSTREAM_BYTE_COUNT_TILE_NO_HEADER_REG_OFFSET_INIT = 0x1C2B4C;
43 static constexpr uint32_t AVP_ENC_CABAC_BIN_COUNT_TILE_REG_OFFSET_INIT = 0x1C2B50;
44 static constexpr uint32_t AVP_ENC_CABAC_INSERTION_COUNT_REG_OFFSET_INIT = 0x1C2B54;
45 static constexpr uint32_t AVP_ENC_MIN_SIZE_PADDING_COUNT_REG_OFFSET_INIT = 0x1C2B58;
46 static constexpr uint32_t AVP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT = 0x1C2B5C;
47 static constexpr uint32_t AVP_ENC_IMAGE_STATUS_CONTROL_REG_OFFSET_INIT = 0x1C2B60;
48 static constexpr uint32_t AVP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT = 0x1C2B64;
49 static constexpr uint32_t AVP_DEC_ERROR_STATUS_ADDR_REG_OFFSET_INIT = 0x1C2B08;
50
51 static constexpr uint32_t MEMORY_ADDRESS_ATTRIBUTES_MOCS_CLEAN_MASK = 0xFFFFFF81;
52
53 template <typename cmd_t>
54 class Impl : public Itf, public mhw::Impl
55 {
56 _AVP_CMD_DEF(_MHW_CMD_ALL_DEF_FOR_IMPL);
57
58 public:
59 MOS_STATUS SetCacheabilitySettings(MHW_MEMORY_OBJECT_CONTROL_PARAMS settings[MOS_CODEC_RESOURCE_USAGE_END_CODEC]) override
60 {
61 MHW_FUNCTION_ENTER;
62
63 MHW_CHK_NULL_RETURN(settings);
64
65 size_t size = MOS_CODEC_RESOURCE_USAGE_END_CODEC * sizeof(MHW_MEMORY_OBJECT_CONTROL_PARAMS);
66
67 return MOS_SecureMemcpy(m_cacheabilitySettings, size, settings, size);
68 }
69
70 MOS_STATUS GetAvpBufSize(AvpBufferType bufferType, AvpBufferSizePar *avpBufSizeParam) override
71 {
72 MHW_FUNCTION_ENTER;
73
74 MHW_MI_CHK_NULL(avpBufSizeParam);
75 MHW_ASSERT(avpBufSizeParam->bitDepthIdc == 0 || avpBufSizeParam->bitDepthIdc == 1);
76
77 uint32_t bufferSize = 0;
78
79 MHW_MI_CHK_STATUS(CalculateBufferSize(bufferType, avpBufSizeParam, avpBufferSize, avpBufferSizeExt, bufferSize));
80
81 avpBufSizeParam->bufferSize = bufferSize * MHW_CACHELINE_SIZE;
82
83 return MOS_STATUS_SUCCESS;
84 }
85
86 MOS_STATUS CalculateBufferSize(AvpBufferType bufferType,
87 AvpBufferSizePar *avpBufSizeParam,
88 const uint8_t avpBufferSizeTbl[][2][2],
89 const uint8_t avpBufferSizeExtTbl[][2][2],
90 uint32_t &bufferSize)
91 {
92 MHW_FUNCTION_ENTER;
93
94 uint32_t sbPerFrmWid = avpBufSizeParam->width;
95 uint32_t sbPerFrmHgt = avpBufSizeParam->height;
96 uint32_t sbPerTileWid = avpBufSizeParam->tileWidth;
97 uint32_t totalSbPerFrame = sbPerFrmWid * sbPerFrmHgt;
98 uint32_t index = (uint32_t)bufferType;
99 uint32_t maxCuPerSB = avpBufSizeParam->isSb128x128 ? 256 : 64;
100
101 switch (bufferType)
102 {
103 //Rowstore buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_tile_width)
104 case bsdLineBuffer:
105 case spatialMvLineBuffer:
106 case intraPredLineBuffer:
107 case deblockLineYBuffer:
108 case deblockLineUBuffer:
109 case deblockLineVBuffer:
110 bufferSize = sbPerTileWid * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
111 break;
112 case cdefLineBuffer:
113 bufferSize = sbPerTileWid * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128]
114 + avpBufferSizeExtTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
115 break;
116 //Tile storage - tile line buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_row) = (#CLs_per_SB * num_of_SB_per_frame_width)
117 case bsdTileLineBuffer:
118 case spatialMvTileLineBuffer:
119 case intraPredTileLineBuffer:
120 case deblockTileLineYBuffer:
121 case deblockTileLineUBuffer:
122 case deblockTileLineVBuffer:
123 bufferSize = sbPerFrmWid * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
124 break;
125 //Tile storage - tile column buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_column) = (#CLs_per_SB * num_of_SB_per_frame_height)
126 case deblockTileColYBuffer:
127 case deblockTileColUBuffer:
128 case deblockTileColVBuffer:
129 bufferSize = sbPerFrmHgt * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
130 break;
131 // Tile storage, per tile number
132 case cdefTopLeftCornerBuffer:
133 bufferSize = avpBufSizeParam->curFrameTileNum * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
134 break;
135 case cdefMetaTileLineBuffer:
136 bufferSize = avpBufSizeParam->numTileCol;
137 break;
138 case lrTileLineYBuffer:
139 bufferSize = avpBufSizeParam->numTileCol * 7;
140 break;
141 case lrTileLineUBuffer:
142 case lrTileLineVBuffer:
143 bufferSize = avpBufSizeParam->numTileCol * 5;
144 break;
145 // Tile storage, - tile line buffers, with extra size
146 case cdefTileLineBuffer:
147 bufferSize = sbPerFrmWid * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128]
148 + avpBufferSizeExtTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
149 break;
150 // Tile storage, - tile column buffers, with extra size
151 case cdefTileColBuffer:
152 case cdefMetaTileColBuffer:
153 case superResTileColYBuffer:
154 case superResTileColUBuffer:
155 case superResTileColVBuffer:
156 case lrTileColYBuffer:
157 case lrTileColUBuffer:
158 case lrTileColVBuffer:
159 case lrMetaTileColBuffer:
160 bufferSize = sbPerFrmHgt * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128]
161 + avpBufferSizeExtTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
162 break;
163 //frame buffer
164 case segmentIdBuffer:
165 bufferSize = ((avpBufSizeParam->isSb128x128)? 8 : 2) * totalSbPerFrame;
166 break;
167 case mvTemporalBuffer:
168 bufferSize = ((avpBufSizeParam->isSb128x128) ? 16 : 4) * totalSbPerFrame;
169 break;
170 case frameStatusErrBuffer:
171 case dbdStreamoutBuffer:
172 bufferSize = 1;
173 break;
174 case tileSzStreamOutBuffer:
175 bufferSize = avpBufSizeParam->numTileCol * avpBufSizeParam->numTileCol * MHW_CACHELINE_SIZE;
176 break;
177 case tileStatStreamOutBuffer:
178 bufferSize = 512;
179 break;
180 case cuStreamoutBuffer:
181 bufferSize = MOS_ALIGN_CEIL(totalSbPerFrame * maxCuPerSB * 8, MHW_CACHELINE_SIZE); // Each CU streams out 8 bytes
182 break;
183 case sseLineBuffer:
184 case sseTileLineBuffer:
185 if (avpBufSizeParam->numOfActivePipes > 1)
186 {
187 // To be added for scalability case
188 }
189 else
190 {
191 bufferSize = (sbPerFrmWid + 3) * MHW_CACHELINE_SIZE * (8 + 8) << 1; // 8 for Luma, 8 for Chroma
192 }
193 break;
194 case lrTileColAlignBuffer:
195 case fgTileColBuffer:
196 bufferSize = sbPerFrmHgt * avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128]
197 + avpBufferSizeExtTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
198 break;
199 case fgSampleTmpBuffer:
200 bufferSize = avpBufferSizeTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128]
201 + avpBufferSizeExtTbl[index][avpBufSizeParam->bitDepthIdc][avpBufSizeParam->isSb128x128];
202 break;
203 default:
204 return MOS_STATUS_INVALID_PARAMETER;
205 }
206
207 return MOS_STATUS_SUCCESS;
208 }
209
210 bool IsRowStoreCachingSupported() override
211 {
212 return m_rowstoreCachingSupported;
213 }
214
215 bool IsBufferRowstoreCacheEnabled(AvpBufferType bufferType) override
216 {
217 MHW_FUNCTION_ENTER;
218
219 bool rowstoreCacheEnabled = false;
220 switch (bufferType)
221 {
222 case bsdLineBuffer:
223 rowstoreCacheEnabled = m_btdlRowstoreCache.enabled ? true : false;
224 break;
225 case spatialMvLineBuffer:
226 rowstoreCacheEnabled = m_smvlRowstoreCache.enabled ? true : false;
227 break;
228 case intraPredLineBuffer:
229 rowstoreCacheEnabled = m_ipdlRowstoreCache.enabled ? true : false;
230 break;
231 case deblockLineYBuffer:
232 rowstoreCacheEnabled = m_dflyRowstoreCache.enabled ? true : false;
233 break;
234 case deblockLineUBuffer:
235 rowstoreCacheEnabled = m_dfluRowstoreCache.enabled ? true : false;
236 break;
237 case deblockLineVBuffer:
238 rowstoreCacheEnabled = m_dflvRowstoreCache.enabled ? true : false;
239 break;
240 case cdefLineBuffer:
241 rowstoreCacheEnabled = m_cdefRowstoreCache.enabled ? true : false;
242 break;
243 default:
244 return false;
245 }
246
247 return rowstoreCacheEnabled;
248 }
249
250 MOS_STATUS GetAvpStateCmdSize(uint32_t* commandsSize, uint32_t* patchListSize, PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) override
251 {
252 // Just return success here, please implement logic in platform sepecific impl class.
253 return MOS_STATUS_SUCCESS;
254 }
255
256 MOS_STATUS GetAvpPrimitiveCmdSize(uint32_t* commandsSize, uint32_t* patchListSize, PMHW_VDBOX_STATE_CMDSIZE_PARAMS params) override
257 {
258 // Just return success here, please implement logic in platform sepecific impl class.
259 return MOS_STATUS_SUCCESS;
260 }
261
262 AvpMmioRegisters* GetMmioRegisters(MHW_VDBOX_NODE_IND index) override
263 {
264 MHW_FUNCTION_ENTER;
265
266 if (index < MHW_VDBOX_NODE_MAX)
267 {
268 return (&m_mmioRegisters[index]);
269 }
270 else
271 {
272 MHW_ASSERT("index is out of range!");
273 return (&m_mmioRegisters[MHW_VDBOX_NODE_1]);
274 }
275 }
276
277 private:
278 bool m_rowstoreCachingSupported = false;
279 AvpMmioRegisters m_mmioRegisters[MHW_VDBOX_NODE_MAX] = {}; //!< AVP mmio registers
280
281 void InitMmioRegisters()
282 {
283 MHW_FUNCTION_ENTER;
284
285 AvpMmioRegisters *mmioRegisters = &m_mmioRegisters[MHW_VDBOX_NODE_1];
286
287 mmioRegisters->avpAv1BitstreamByteCountTileRegOffset = AVP_AVP_BITSTREAM_BYTECOUNT_TILE_WITH_HEADER_AWM_REG0;
288 mmioRegisters->avpAv1BitstreamByteCountTileNoHeaderRegOffset = AVP_ENC_BITSTREAM_BYTE_COUNT_TILE_NO_HEADER_REG_OFFSET_INIT;
289 mmioRegisters->avpAv1CabacBinCountTileRegOffset = AVP_ENC_CABAC_BIN_COUNT_TILE_REG_OFFSET_INIT;
290 mmioRegisters->avpAv1CabacInsertionCountRegOffset = AVP_ENC_CABAC_INSERTION_COUNT_REG_OFFSET_INIT;
291 mmioRegisters->avpAv1MinSizePaddingCountRegOffset = AVP_ENC_MIN_SIZE_PADDING_COUNT_REG_OFFSET_INIT;
292 mmioRegisters->avpAv1ImageStatusMaskRegOffset = AVP_ENC_IMAGE_STATUS_MASK_REG_OFFSET_INIT;
293 mmioRegisters->avpAv1ImageStatusControlRegOffset = AVP_ENC_IMAGE_STATUS_CONTROL_REG_OFFSET_INIT;
294 mmioRegisters->avpAv1QpStatusCountRegOffset = AVP_ENC_QP_STATUS_COUNT_REG_OFFSET_INIT;
295 mmioRegisters->avpAv1DecErrorStatusAddrRegOffset = AVP_DEC_ERROR_STATUS_ADDR_REG_OFFSET_INIT;
296
297 m_mmioRegisters[MHW_VDBOX_NODE_2] = m_mmioRegisters[MHW_VDBOX_NODE_1];
298 }
299
300 MOS_STATUS InitRowstoreUserFeatureSettings()
301 {
302 MHW_FUNCTION_ENTER;
303
304 bool rowstoreCachingDisableDefaultValue = false;
305 if (m_osItf->bSimIsActive)
306 {
307 // Disable RowStore Cache on simulation by default
308 rowstoreCachingDisableDefaultValue = true;
309 }
310 else
311 {
312 rowstoreCachingDisableDefaultValue = false;
313 }
314 m_rowstoreCachingSupported = !rowstoreCachingDisableDefaultValue;
315 #if (_DEBUG || _RELEASE_INTERNAL)
316 auto userSettingPtr = m_osItf->pfnGetUserSettingInstance(m_osItf);
317 {
318 MediaUserSetting::Value outValue;
319 ReadUserSettingForDebug(userSettingPtr,
320 outValue,
321 "Disable RowStore Cache",
322 MediaUserSetting::Group::Device,
323 rowstoreCachingDisableDefaultValue,
324 true);
325 m_rowstoreCachingSupported = !(outValue.Get<bool>());
326 }
327 #endif // _DEBUG || _RELEASE_INTERNAL
328
329 if (m_rowstoreCachingSupported)
330 {
331 m_btdlRowstoreCache.supported = true;
332 #if (_DEBUG || _RELEASE_INTERNAL)
333 {
334 MediaUserSetting::Value outValue;
335 ReadUserSettingForDebug(userSettingPtr,
336 outValue,
337 "DisableAv1BtdlRowstoreCache",
338 MediaUserSetting::Group::Device);
339 m_btdlRowstoreCache.supported = !(outValue.Get<bool>());
340 }
341 #endif // _DEBUG || _RELEASE_INTERNAL
342
343 m_smvlRowstoreCache.supported = true;
344 #if (_DEBUG || _RELEASE_INTERNAL)
345 {
346 MediaUserSetting::Value outValue;
347 ReadUserSettingForDebug(userSettingPtr,
348 outValue,
349 "DisableAv1SmvlRowstoreCache",
350 MediaUserSetting::Group::Device);
351 m_smvlRowstoreCache.supported = !(outValue.Get<bool>());
352 }
353 #endif // _DEBUG || _RELEASE_INTERNAL
354
355 m_ipdlRowstoreCache.supported = true;
356 #if (_DEBUG || _RELEASE_INTERNAL)
357 {
358 MediaUserSetting::Value outValue;
359 ReadUserSettingForDebug(userSettingPtr,
360 outValue,
361 "DisableAv1IpdlRowstoreCache",
362 MediaUserSetting::Group::Device);
363 m_ipdlRowstoreCache.supported = !(outValue.Get<bool>());
364 }
365 #endif // _DEBUG || _RELEASE_INTERNAL
366
367 m_dflyRowstoreCache.supported = true;
368 #if (_DEBUG || _RELEASE_INTERNAL)
369 {
370 MediaUserSetting::Value outValue;
371 ReadUserSettingForDebug(userSettingPtr,
372 outValue,
373 "DisableAv1DflyRowstoreCache",
374 MediaUserSetting::Group::Device);
375 m_dflyRowstoreCache.supported = !(outValue.Get<bool>());
376 }
377 #endif // _DEBUG || _RELEASE_INTERNAL
378
379 m_dfluRowstoreCache.supported = true;
380 #if (_DEBUG || _RELEASE_INTERNAL)
381 {
382 MediaUserSetting::Value outValue;
383 ReadUserSettingForDebug(userSettingPtr,
384 outValue,
385 "DisableAv1DfluRowstoreCache",
386 MediaUserSetting::Group::Device);
387 m_dfluRowstoreCache.supported = !(outValue.Get<bool>());
388 }
389 #endif // _DEBUG || _RELEASE_INTERNAL
390
391 m_dflvRowstoreCache.supported = true;
392 #if (_DEBUG || _RELEASE_INTERNAL)
393 {
394 MediaUserSetting::Value outValue;
395 ReadUserSettingForDebug(userSettingPtr,
396 outValue,
397 "DisableAv1DflvRowstoreCache",
398 MediaUserSetting::Group::Device);
399 m_dflvRowstoreCache.supported = !(outValue.Get<bool>());
400 }
401 #endif // _DEBUG || _RELEASE_INTERNAL
402
403 m_cdefRowstoreCache.supported = true;
404 #if (_DEBUG || _RELEASE_INTERNAL)
405 {
406 MediaUserSetting::Value outValue;
407 ReadUserSettingForDebug(userSettingPtr,
408 outValue,
409 "DisableAv1CdefRowstoreCache",
410 MediaUserSetting::Group::Device);
411 m_cdefRowstoreCache.supported = !(outValue.Get<bool>());
412 }
413 #endif // _DEBUG || _RELEASE_INTERNAL
414 }
415
416 return MOS_STATUS_SUCCESS;
417 }
418
419 //AVP internal buffer size table [buffer_index][bitdepthIdc][IsSb128x128]
420 const uint8_t avpBufferSize[avpInternalBufferMax][2][2] =
421 {
422 { 2 , 8 , 2 , 8 }, //segmentIdBuffer,
423 { 4 , 16 , 4 , 16 }, //mvTemporalBuffer,
424 { 2 , 4 , 2 , 4 }, //bsdLineBuffer,
425 { 2 , 4 , 2 , 4 }, //bsdTileLineBuffer,
426 { 2 , 4 , 4 , 8 }, //intraPredLineBuffer,
427 { 2 , 4 , 4 , 8 }, //intraPredTileLineBuffer,
428 { 4 , 8 , 4 , 8 }, //spatialMvLineBuffer,
429 { 4 , 8 , 4 , 8 }, //spatialMvTileLineBuffer,
430 { 1 , 1 , 1 , 1 }, //lrMetaTileColBuffer,
431 { 7 , 7 , 7 , 7 }, //lrTileLineYBuffer,
432 { 5 , 5 , 5 , 5 }, //lrTileLineUBuffer,
433 { 5 , 5 , 5 , 5 }, //lrTileLineVBuffer,
434 { 9 , 17 , 11 , 21 }, //deblockLineYBuffer,
435 { 3 , 4 , 3 , 5 }, //deblockLineUBuffer,
436 { 3 , 4 , 3 , 5 }, //deblockLineVBuffer,
437 { 9 , 17 , 11 , 21 }, //deblockTileLineYBuffer,
438 { 3 , 4 , 3 , 5 }, //deblockTileLineVBuffer,
439 { 3 , 4 , 3 , 5 }, //deblockTileLineUBuffer,
440 { 8 , 16 , 10 , 20 }, //deblockTileColYBuffer,
441 { 2 , 4 , 3 , 5 }, //deblockTileColUBuffer,
442 { 2 , 4 , 3 , 5 }, //deblockTileColVBuffer,
443 { 8 , 16 , 10 , 20 }, //cdefLineBufferBuffer,
444 { 8 , 16 , 10 , 20 }, //cdefTileLineBufBuffer,
445 { 8 , 16 , 10 , 20 }, //cdefTileColBufBuffer,
446 { 1 , 1 , 1 , 1 }, //cdefMetaTileLineBuffer,
447 { 1 , 1 , 1 , 1 }, //cdefMetaTileColBuffer,
448 { 1 , 1 , 1 , 1 }, //cdefTopLeftCornerBuffer,
449 { 22, 44 , 29 , 58 }, //superResTileColYBuffer,
450 { 8 , 16 , 10 , 20 }, //superResTileColUBuffer,
451 { 8 , 16 , 10 , 20 }, //superResTileColVBuffer,
452 { 9 , 17 , 11 , 22 }, //lrTileColYBuffer,
453 { 5 , 9 , 6 , 12 }, //lrTileColUBuffer,
454 { 5 , 9 , 6 , 12 }, //lrTileColVBuffer,
455 { 0 , 0 , 0 , 0 }, //frameStatusErrBuffer,
456 { 0 , 0 , 0 , 0 }, //dbdStreamoutBuffer,
457 { 2 , 4 , 3 , 5 }, //fgTileColBuffer
458 { 96, 96 , 192 , 192 },//fgSampleTmpBuffer
459 { 4, 8 , 5 , 10 }, //lrTileColAlignBuffer
460 };
461
462 const uint8_t avpBufferSizeExt[avpInternalBufferMax][2][2] =
463 {
464 { 0 , 0 , 0 , 0 }, //segmentIdBuffer,
465 { 0 , 0 , 0 , 0 }, //mvTemporalBuffer,
466 { 0 , 0 , 0 , 0 }, //bsdLineBuffer,
467 { 0 , 0 , 0 , 0 }, //bsdTileLineBuffer,
468 { 0 , 0 , 0 , 0 }, //intraPredLineBuffer,
469 { 0 , 0 , 0 , 0 }, //intraPredTileLineBuffer,
470 { 0 , 0 , 0 , 0 }, //spatialMvLineBuffer,
471 { 0 , 0 , 0 , 0 }, //spatialMvTileLineBuffer,
472 { 1 , 1 , 1 , 1 }, //lrMetaTileColBuffer,
473 { 0 , 0 , 0 , 0 }, //lrTileLineYBuffer,
474 { 0 , 0 , 0 , 0 }, //lrTileLineUBuffer,
475 { 0 , 0 , 0 , 0 }, //lrTileLineVBuffer,
476 { 0 , 0 , 0 , 0 }, //deblockLineYBuffer,
477 { 0 , 0 , 0 , 0 }, //deblockLineUBuffer,
478 { 0 , 0 , 0 , 0 }, //deblockLineVBuffer,
479 { 0 , 0 , 0 , 0 }, //deblockTileLineYBuffer,
480 { 0 , 0 , 0 , 0 }, //deblockTileLineVBuffer,
481 { 0 , 0 , 0 , 0 }, //deblockTileLineUBuffer,
482 { 0 , 0 , 0 , 0 }, //deblockTileColYBuffer,
483 { 0 , 0 , 0 , 0 }, //deblockTileColUBuffer,
484 { 0 , 0 , 0 , 0 }, //deblockTileColVBuffer,
485 { 1 , 1 , 2 , 2 }, //cdefLineBuffer,
486 { 1 , 1 , 2 , 2 }, //cdefTileLineBuffer,
487 { 1 , 1 , 2 , 2 }, //cdefTileColBuffer,
488 { 0 , 0 , 0 , 0 }, //cdefMetaTileLineBuffer,
489 { 1 , 1 , 1 , 1 }, //cdefMetaTileColBuffer,
490 { 0 , 0 , 0 , 0 }, //cdefTopLeftCornerBuffer,
491 { 22, 44 , 29 , 58 }, //superResTileColYBuffer,
492 { 8 , 16 , 10 , 20 }, //superResTileColUBuffer,
493 { 8 , 16 , 10 , 20 }, //superResTileColVBuffer,
494 { 2 , 2 , 2 , 2 }, //lrTileColYBuffer,
495 { 1 , 1 , 1 , 1 }, //lrTileColUBuffer,
496 { 1 , 1 , 1 , 1 }, //lrTileColVBuffer,
497 { 0 , 0 , 0 , 0 }, //frameStatusErrBuffer,
498 { 0 , 0 , 0 , 0 }, //dbdStreamoutBuffer,
499 { 1 , 1 , 1 , 1 }, //fgTileColBuffer,
500 { 0 , 0 , 0 , 0 }, //fgSampleTmpBuffer,
501 { 1 , 1 , 1 , 1 }, //lrTileColAlignBuffer,
502 };
503
504 protected:
505 using base_t = Itf;
506
507 MHW_MEMORY_OBJECT_CONTROL_PARAMS m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_END_CODEC] = {};
508
509 vdbox::RowStoreCache m_btdlRowstoreCache = {}; //! Bitstream Decoder/Encode Line Rowstore (BTDL)
510 vdbox::RowStoreCache m_smvlRowstoreCache = {}; //! Spatial Motion Vector Line Rowstore (SMVL)
511 vdbox::RowStoreCache m_ipdlRowstoreCache = {}; //! Intra Prediction Line Rowstore (IPDL)
512 vdbox::RowStoreCache m_dflyRowstoreCache = {}; //! Deblocker Filter Line Y Buffer (DFLY)
513 vdbox::RowStoreCache m_dfluRowstoreCache = {}; //! Deblocker Filter Line U Buffe (DFLU)
514 vdbox::RowStoreCache m_dflvRowstoreCache = {}; //! Deblocker Filter Line V Buffe (DFLV)
515 vdbox::RowStoreCache m_cdefRowstoreCache = {}; //! CDEF Filter Line Buffer (CDEF)
516
517 Impl(PMOS_INTERFACE osItf) : mhw::Impl(osItf)
518 {
519 MHW_FUNCTION_ENTER;
520
521 InitRowstoreUserFeatureSettings();
522 InitMmioRegisters();
523 }
524
525 virtual ~Impl()
526 {
527 MHW_FUNCTION_ENTER;
528
529 #if (_DEBUG || _RELEASE_INTERNAL)
530 if (m_btdlRowstoreCache.enabled ||
531 m_smvlRowstoreCache.enabled ||
532 m_ipdlRowstoreCache.enabled ||
533 m_dflyRowstoreCache.enabled ||
534 m_dfluRowstoreCache.enabled ||
535 m_dflvRowstoreCache.enabled ||
536 m_cdefRowstoreCache.enabled)
537 {
538 // Report rowstore cache usage status to regkey
539 ReportUserSettingForDebug(
540 m_userSettingPtr,
541 __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED,
542 1,
543 MediaUserSetting::Group::Device);
544 }
545 #endif
546
547 }
548
549 MOS_STATUS GetRowstoreCachingAddrs(mhw::vdbox::avp::AvpVdboxRowStorePar rowstoreParams) override
550 {
551 //BTDL
552 if (m_btdlRowstoreCache.supported)
553 {
554 m_btdlRowstoreCache.enabled = true;
555 m_btdlRowstoreCache.dwAddress = 0;
556 }
557
558 //SMVL
559 if (m_smvlRowstoreCache.supported)
560 {
561 m_smvlRowstoreCache.enabled = true;
562 m_smvlRowstoreCache.dwAddress = 128;
563 }
564
565 //IPDL
566 if (m_ipdlRowstoreCache.supported)
567 {
568 m_ipdlRowstoreCache.enabled = true;
569 m_ipdlRowstoreCache.dwAddress = 384;
570 }
571
572 //DFLY
573 if (m_dflyRowstoreCache.supported)
574 {
575 m_dflyRowstoreCache.enabled = true;
576 m_dflyRowstoreCache.dwAddress = 640;
577 }
578
579 //DFLU
580 if (m_dfluRowstoreCache.supported)
581 {
582 m_dfluRowstoreCache.enabled = true;
583 m_dfluRowstoreCache.dwAddress = 1344;
584 }
585
586 //DFLV
587 if (m_dflvRowstoreCache.supported)
588 {
589 m_dflvRowstoreCache.enabled = true;
590 m_dflvRowstoreCache.dwAddress = 1536;
591 }
592
593 //CDEF
594 if (m_cdefRowstoreCache.supported)
595 {
596 m_cdefRowstoreCache.enabled = true;
597 m_cdefRowstoreCache.dwAddress = 1728;
598 }
599
600 return MOS_STATUS_SUCCESS;
601 }
602
603 // Programming Note: CodecHAL layer must add MFX wait command
604 // for both KIN and VRT before and after AVP_PIPE_MODE_SELECT
605
606 _MHW_SETCMD_OVERRIDE_DECL(AVP_PIPE_MODE_SELECT)
607 {
608 _MHW_SETCMD_CALLBASE(AVP_PIPE_MODE_SELECT);
609
610 #define DO_FIELDS() \
611 DO_FIELD(DW1, CodecSelect, params.codecSelect); \
612 DO_FIELD(DW1, PicStatusErrorReportEnable, params.picStatusErrorReportEnable ? 1 : 0); \
613 DO_FIELD(DW1, CodecStandardSelect, params.codecStandardSelect); \
614 DO_FIELD(DW1, MultiEngineMode, params.multiEngineMode); \
615 DO_FIELD(DW1, PipeWorkingMode, params.pipeWorkingMode); \
616 DO_FIELD(DW1, TileBasedEngine, params.tileBasedReplayMode ? 1 : 0); \
617 DO_FIELD(DW3, PicStatusErrorReportId, params.picStatusErrorReportEnable ? 1 : 0); \
618 DO_FIELD(DW5, PhaseIndicator, params.phaseIndicator); \
619 \
620 DO_FIELD(DW1, FrameReconstructionDisable, params.frameReconDisable); \
621 DO_FIELD(DW1, VdencMode, params.vdencMode); \
622 DO_FIELD(DW1, MotionCompMemTrackerCounterEnable, params.motionCompMemTrackerCounterEnable ? 1 : 0)
623
624 #include "mhw_hwcmd_process_cmdfields.h"
625 }
626
627 _MHW_SETCMD_OVERRIDE_DECL(AVP_PIC_STATE)
628 {
629 _MHW_SETCMD_CALLBASE(AVP_PIC_STATE);
630
631 //DW9..DW29
632 //It specifies the Warp Parameter set for each of the 7reference frames [LAST_FRAME .. ALTREF_FRAME]
633 MOS_SecureMemcpy(cmd.WarpParametersArrayReference1To7Projectioncoeff0To5,
634 sizeof(params.warpParamsArrayProjection),
635 params.warpParamsArrayProjection,
636 sizeof(params.warpParamsArrayProjection)
637 );
638
639 #define DO_FIELDS() \
640 DO_FIELD(DW1, FrameWidthInPixelMinus1, params.frameWidthMinus1); \
641 DO_FIELD(DW1, FrameHeightInPixelMinus1, params.frameHeightMinus1); \
642 \
643 DO_FIELD(DW2, SequenceChromaSubsamplingFormat, params.chromaFormat); \
644 DO_FIELD(DW2, SequencePixelBitDepthIdc, params.bitDepthIdc); \
645 DO_FIELD(DW2, SequenceSuperblockSizeUsed, params.superblockSizeUsed); \
646 DO_FIELD(DW2, SequenceEnableOrderHintFlag, params.enableOrderHint ? 1 : 0); \
647 DO_FIELD(DW2, SequenceOrderHintBitsMinus1, params.orderHintBitsMinus1); \
648 DO_FIELD(DW2, SequenceEnableFilterIntraFlag, params.enableFilterIntra ? 1 : 0); \
649 DO_FIELD(DW2, SequenceEnableIntraEdgeFilterFlag, params.enableIntraEdgeFilter ? 1 : 0); \
650 DO_FIELD(DW2, SequenceEnableDualFilterFlag, params.enableDualFilter ? 1 : 0); \
651 DO_FIELD(DW2, SequenceEnableInterIntraCompoundFlag, params.enableInterIntraCompound ? 1 : 0); \
652 DO_FIELD(DW2, SequenceEnableMaskedCompoundFlag, params.enableMaskedCompound ? 1 : 0); \
653 DO_FIELD(DW2, SequenceEnableJointCompoundFlag, params.enableJointCompound ? 1 : 0); \
654 DO_FIELD(DW2, HeaderPresentFlag, params.headerPresent ? 1 : 0); \
655 DO_FIELD(DW2, EnableBistreamStitchingInHardware, params.autoBistreamStitchingInHardware); \
656 \
657 DO_FIELD(DW3, AllowScreenContentToolsFlag, params.allowScreenContentTools ? 1 : 0); \
658 DO_FIELD(DW3, ForceIntegerMvFlag, params.forceIntegerMv ? 1 : 0); \
659 DO_FIELD(DW3, AllowWarpedMotionFlag, params.allowWarpedMotion ? 1: 0); \
660 DO_FIELD(DW3, UseCdefFilterFlag, params.enableCDEF ? 1 : 0); \
661 DO_FIELD(DW3, UseSuperResFlag, params.enableSuperres ? 1 : 0); \
662 DO_FIELD(DW3, FrameLevelLoopRestorationFilterEnableFlag, params.enableRestoration ? 1 : 0); \
663 DO_FIELD(DW3, LargeScaleTileEnableFlag, params.enableLargeScaleTile ? 1 : 0); \
664 DO_FIELD(DW3, PostCdefFilteredReconPixelsWriteoutEn, params.postCdefReconPixelStreamoutEn ? 1 : 0); \
665 DO_FIELD(DW3, FrameType, params.frameType); \
666 DO_FIELD(DW3, IntraonlyFlag, (params.frameType == keyFrame || params.frameType == intraOnlyFrame)); \
667 DO_FIELD(DW3, ErrorResilientModeFlag, params.errorResilientMode); \
668 DO_FIELD(DW3, AllowIntrabcFlag, params.allowIntraBC ? 1 : 0); \
669 DO_FIELD(DW3, PrimaryReferenceFrameIdx, params.primaryRefFrame); \
670 DO_FIELD(DW3, ApplyFilmGrainFlag, params.applyFilmGrainFlag); \
671 \
672 DO_FIELD(DW4, SegmentationEnableFlag, params.segmentParams.m_enabled); \
673 DO_FIELD(DW4, SegmentationUpdateMapFlag, params.segmentParams.m_updateMap); \
674 DO_FIELD(DW4, SegmentationTemporalUpdateFlag, params.segmentParams.m_temporalUpdate); \
675 DO_FIELD(DW4, LastActiveSegmentId, params.segmentParams.m_lastActiveSegmentId); \
676 DO_FIELD(DW4, PreSkipSegmentIdFlag, params.segmentParams.m_preSkipSegmentIdFlag); \
677 DO_FIELD(DW4, DeltaQPresentFlag, params.deltaQPresentFlag ? 1 : 0); \
678 DO_FIELD(DW4, DeltaQRes, params.log2DeltaQRes); \
679 DO_FIELD(DW4, FrameCodedLosslessMode, params.codedLossless); \
680 DO_FIELD(DW4, SegmentMapIsZeroFlag, params.segmentParams.m_segmentMapIsZeroFlag); \
681 DO_FIELD(DW4, SegmentIdBufferStreamInEnableFlag, params.segmentParams.m_segIdBufStreamInEnable); \
682 DO_FIELD(DW4, SegmentIdBufferStreamOutEnableFlag, params.segmentParams.m_segIdBufStreamOutEnable); \
683 DO_FIELD(DW4, BaseQindex, params.baseQindex); \
684 DO_FIELD(DW4, YDcDeltaQ, params.yDcDeltaQ); \
685 \
686 DO_FIELD(DW5, UDcDeltaQ, params.uDcDeltaQ); \
687 DO_FIELD(DW5, UAcDeltaQ, params.uAcDeltaQ); \
688 DO_FIELD(DW5, VDcDeltaQ, params.vDcDeltaQ); \
689 DO_FIELD(DW5, VAcDeltaQ, params.vAcDeltaQ); \
690 \
691 DO_FIELD(DW6, AllowHighPrecisionMv, params.allowHighPrecisionMV); \
692 DO_FIELD(DW6, FrameLevelReferenceModeSelect, params.referenceSelect ? 1 : 0); \
693 DO_FIELD(DW6, McompFilterType, params.interpFilter); \
694 DO_FIELD(DW6, MotionModeSwitchableFlag, params.motionModeSwitchable); \
695 DO_FIELD(DW6, UseReferenceFrameMvSetFlag, params.useReferenceFrameMvSet); \
696 DO_FIELD(DW6, ReferenceFrameSignBiasI0To7, params.refFrameBiasFlag); \
697 DO_FIELD(DW6, CurrentFrameOrderHint, params.currentOrderHint); \
698 \
699 DO_FIELD(DW7, ReducedTxSetUsed, params.reducedTxSetUsed ? 1 : 0); \
700 DO_FIELD(DW7, FrameTransformMode, params.txMode); \
701 DO_FIELD(DW7, SkipModePresentFlag, params.skipModePresent ? 1 : 0); \
702 DO_FIELD(DW7, SkipModeFrame0, params.skipModeFrame[0]); \
703 DO_FIELD(DW7, SkipModeFrame1, params.skipModeFrame[1]); \
704 DO_FIELD(DW7, ReferenceFrameSideI0To7, params.refFrameSide); \
705 \
706 DO_FIELD(DW8, GlobalMotionType1, params.globalMotionType[0]); \
707 DO_FIELD(DW8, GlobalMotionType2, params.globalMotionType[1]); \
708 DO_FIELD(DW8, GlobalMotionType3, params.globalMotionType[2]); \
709 DO_FIELD(DW8, GlobalMotionType4, params.globalMotionType[3]); \
710 DO_FIELD(DW8, GlobalMotionType5, params.globalMotionType[4]); \
711 DO_FIELD(DW8, GlobalMotionType6, params.globalMotionType[5]); \
712 DO_FIELD(DW8, GlobalMotionType7, params.globalMotionType[6]); \
713 DO_FIELD(DW8, FrameLevelGlobalMotionInvalidFlags, params.frameLevelGlobalMotionInvalidFlags); \
714 \
715 DO_FIELD(DW30, ReferenceFrameIdx0, params.refFrameIdx[intraFrame]); \
716 DO_FIELD(DW30, ReferenceFrameIdx1, params.refFrameIdx[lastFrame]); \
717 DO_FIELD(DW30, ReferenceFrameIdx2, params.refFrameIdx[last2Frame]); \
718 DO_FIELD(DW30, ReferenceFrameIdx3, params.refFrameIdx[last3Frame]); \
719 DO_FIELD(DW30, ReferenceFrameIdx4, params.refFrameIdx[goldenFrame]); \
720 DO_FIELD(DW30, ReferenceFrameIdx5, params.refFrameIdx[bwdRefFrame]); \
721 DO_FIELD(DW30, ReferenceFrameIdx6, params.refFrameIdx[altRef2Frame]); \
722 DO_FIELD(DW30, ReferenceFrameIdx7, params.refFrameIdx[altRefFrame]); \
723 \
724 DO_FIELD(DW31, Value, params.refFrameRes[intraFrame]); \
725 \
726 DO_FIELD(DW32, Value, params.refFrameRes[lastFrame]); \
727 \
728 DO_FIELD(DW33, Value, params.refFrameRes[last2Frame]); \
729 \
730 DO_FIELD(DW34, Value, params.refFrameRes[last3Frame]); \
731 \
732 DO_FIELD(DW35, Value, params.refFrameRes[goldenFrame]); \
733 \
734 DO_FIELD(DW36, Value, params.refFrameRes[bwdRefFrame]); \
735 \
736 DO_FIELD(DW37, Value, params.refFrameRes[altRef2Frame]); \
737 \
738 DO_FIELD(DW38, Value, params.refFrameRes[altRefFrame]); \
739 \
740 DO_FIELD(DW39, Value, params.refScaleFactor[intraFrame]); \
741 \
742 DO_FIELD(DW40, Value, params.refScaleFactor[lastFrame]); \
743 \
744 DO_FIELD(DW41, Value, params.refScaleFactor[last2Frame]); \
745 \
746 DO_FIELD(DW42, Value, params.refScaleFactor[last3Frame]); \
747 \
748 DO_FIELD(DW43, Value, params.refScaleFactor[goldenFrame]); \
749 \
750 DO_FIELD(DW44, Value, params.refScaleFactor[bwdRefFrame]); \
751 \
752 DO_FIELD(DW45, Value, params.refScaleFactor[altRef2Frame]); \
753 \
754 DO_FIELD(DW46, Value, params.refScaleFactor[altRefFrame]); \
755 \
756 DO_FIELD(DW47, ReferenceFrameOrderHint0ForIntraFrame, params.refOrderHints[intraFrame]); \
757 DO_FIELD(DW47, ReferenceFrameOrderHint1ForLastFrame, params.refOrderHints[lastFrame]); \
758 DO_FIELD(DW47, ReferenceFrameOrderHint2ForLast2Frame, params.refOrderHints[last2Frame]); \
759 DO_FIELD(DW47, ReferenceFrameOrderHint3ForLast3Frame, params.refOrderHints[last3Frame]); \
760 \
761 DO_FIELD(DW48, ReferenceFrameOrderHint4ForGoldenFrame, params.refOrderHints[goldenFrame]); \
762 DO_FIELD(DW48, ReferenceFrameOrderHint5ForBwdrefFrame, params.refOrderHints[bwdRefFrame]); \
763 DO_FIELD(DW48, ReferenceFrameOrderHint6ForAltref2Frame, params.refOrderHints[altRef2Frame]); \
764 DO_FIELD(DW48, ReferenceFrameOrderHint7ForAltrefFrame, params.refOrderHints[altRefFrame]); \
765 \
766 DO_FIELD(DW51, Nonfirstpassflag, params.notFirstPass ? 1 : 0); \
767 DO_FIELD(DW51, VdencPakOnlyPass, params.vdencPackOnlyPass ? 1 : 0); \
768 DO_FIELD(DW51, FrameszoverstatusenFramebitratemaxreportmask, params.frameBitRateMaxReportMask ? 1 : 0); \
769 DO_FIELD(DW51, FrameszunderstatusenFramebitrateminreportmask, params.frameBitRateMinReportMask ? 1 : 0); \
770 \
771 DO_FIELD(DW52, Framebitratemax, params.frameBitRateMax); \
772 DO_FIELD(DW52, Framebitratemaxunit, params.frameBitRateMaxUnit); \
773 \
774 DO_FIELD(DW53, Framebitratemin, params.frameBitRateMin); \
775 DO_FIELD(DW53, Framebitrateminunit, params.frameBitRateMinUnit); \
776 \
777 DO_FIELD(DW54_55, Value[0], params.frameDeltaQindexMax[0]); \
778 DO_FIELD(DW54_55, Value[1], params.frameDeltaQindexMax[1]); \
779 \
780 DO_FIELD(DW56, Framedeltaqindexmin, params.frameDeltaQindexMin); \
781 \
782 DO_FIELD(DW57_58, Value[0], params.frameDeltaLFMax[0]); \
783 DO_FIELD(DW57_58, Value[1], params.frameDeltaLFMax[1]); \
784 \
785 DO_FIELD(DW59, Framedeltalfmin, params.frameDeltaLFMin); \
786 \
787 DO_FIELD(DW60_61, Value[0], params.frameDeltaQindexLFMaxRange[0]); \
788 DO_FIELD(DW60_61, Value[1], params.frameDeltaQindexLFMaxRange[1]); \
789 \
790 DO_FIELD(DW62, Framedeltaqindexlfminrange, params.frameDeltaQindexLFMinRange); \
791 \
792 DO_FIELD(DW63, Minframsize, params.minFramSize); \
793 DO_FIELD(DW63, Minframesizeunits, params.minFramSizeUnits); \
794 \
795 DO_FIELD(DW65, Class0SseThreshold0, params.class0_SSE_Threshold0); \
796 DO_FIELD(DW65, Class0SseThreshold1, params.class0_SSE_Threshold1); \
797 \
798 DO_FIELD(DW74, Rdmult, params.rdmult);
799
800 #include "mhw_hwcmd_process_cmdfields.h"
801 }
802
803 _MHW_SETCMD_OVERRIDE_DECL(AVP_INLOOP_FILTER_STATE)
804 {
805 _MHW_SETCMD_CALLBASE(AVP_INLOOP_FILTER_STATE);
806
807 #define DO_FIELDS() \
808 DO_FIELD(DW1, LumaYDeblockerFilterLevelVertical, params.loopFilterLevel[0]); \
809 DO_FIELD(DW1, LumaYDeblockerFilterLevelHorizontal, params.loopFilterLevel[1]); \
810 DO_FIELD(DW1, ChromaUDeblockerFilterLevel, params.loopFilterLevel[2]); \
811 DO_FIELD(DW1, ChromaVDeblockerFilterLevel, params.loopFilterLevel[3]); \
812 DO_FIELD(DW1, DeblockerFilterSharpnessLevel, params.loopFilterSharpness); \
813 DO_FIELD(DW1, DeblockerFilterModeRefDeltaEnableFlag, params.loopFilterDeltaEnabled); \
814 DO_FIELD(DW1, DeblockerDeltaLfResolution, params.deltaLfRes); \
815 DO_FIELD(DW1, DeblockerFilterDeltaLfMultiFlag, params.deltaLfMulti); \
816 DO_FIELD(DW1, DeblockerFilterDeltaLfPresentFlag, params.loopFilterDeltaUpdate); \
817 \
818 DO_FIELD(DW2, DeblockerFilterRefDeltas0, params.loopFilterRefDeltas[0]); \
819 DO_FIELD(DW2, DeblockerFilterRefDeltas1, params.loopFilterRefDeltas[1]); \
820 DO_FIELD(DW2, DeblockerFilterRefDeltas2, params.loopFilterRefDeltas[2]); \
821 DO_FIELD(DW2, DeblockerFilterRefDeltas3, params.loopFilterRefDeltas[3]); \
822 \
823 DO_FIELD(DW3, DeblockerFilterRefDeltas4, params.loopFilterRefDeltas[4]); \
824 DO_FIELD(DW3, DeblockerFilterRefDeltas5, params.loopFilterRefDeltas[5]); \
825 DO_FIELD(DW3, DeblockerFilterRefDeltas6, params.loopFilterRefDeltas[6]); \
826 DO_FIELD(DW3, DeblockerFilterRefDeltas7, params.loopFilterRefDeltas[7]); \
827 \
828 DO_FIELD(DW4, DeblockerFilterModeDeltas0, params.loopFilterModeDeltas[0]); \
829 DO_FIELD(DW4, DeblockerFilterModeDeltas1, params.loopFilterModeDeltas[1]); \
830 \
831 DO_FIELD(DW5, CdefYStrength0, params.cdefYStrength[0]); \
832 DO_FIELD(DW5, CdefYStrength1, params.cdefYStrength[1]); \
833 DO_FIELD(DW5, CdefYStrength2, params.cdefYStrength[2]); \
834 DO_FIELD(DW5, CdefYStrength3, params.cdefYStrength[3]); \
835 DO_FIELD(DW5, CdefBits, params.cdefBits); \
836 DO_FIELD(DW5, CdefFilterDampingFactorMinus3, params.cdefDampingMinus3); \
837 \
838 DO_FIELD(DW6, CdefYStrength4, params.cdefYStrength[4]); \
839 DO_FIELD(DW6, CdefYStrength5, params.cdefYStrength[5]); \
840 DO_FIELD(DW6, CdefYStrength6, params.cdefYStrength[6]); \
841 DO_FIELD(DW6, CdefYStrength7, params.cdefYStrength[7]); \
842 \
843 DO_FIELD(DW7, CdefUvStrength0, params.cdefUVStrength[0]); \
844 DO_FIELD(DW7, CdefUvStrength1, params.cdefUVStrength[1]); \
845 DO_FIELD(DW7, CdefUvStrength2, params.cdefUVStrength[2]); \
846 DO_FIELD(DW7, CdefUvStrength3, params.cdefUVStrength[3]); \
847 \
848 DO_FIELD(DW8, CdefUvStrength4, params.cdefUVStrength[4]); \
849 DO_FIELD(DW8, CdefUvStrength5, params.cdefUVStrength[5]); \
850 DO_FIELD(DW8, CdefUvStrength6, params.cdefUVStrength[6]); \
851 DO_FIELD(DW8, CdefUvStrength7, params.cdefUVStrength[7]); \
852 \
853 DO_FIELD(DW9, SuperResUpscaledFrameWidthMinus1, params.superresUpscaledWidthMinus1); \
854 DO_FIELD(DW9, SuperResDenom, params.superresDenom); \
855 \
856 DO_FIELD(DW10, FrameLoopRestorationFilterTypeForLumaY, params.LoopRestorationType[0]); \
857 DO_FIELD(DW10, FrameLoopRestorationFilterTypeForChromaU, params.LoopRestorationType[1]); \
858 DO_FIELD(DW10, FrameLoopRestorationFilterTypeForChromaV, params.LoopRestorationType[2]); \
859 DO_FIELD(DW10, LoopRestorationUnitSizeForLumaY, params.LoopRestorationSizeLuma); \
860 DO_FIELD(DW10, UseSameLoopRestorationUnitSizeForChromasUvFlag, params.UseSameLoopRestorationSizeForChroma); \
861 \
862 DO_FIELD(DW11, LumaPlaneXStepQn, params.lumaPlaneXStepQn); \
863 \
864 DO_FIELD(DW12, LumaPlaneX0Qn, params.lumaPlaneX0Qn); \
865 \
866 DO_FIELD(DW13, ChromaPlaneXStepQn, params.chromaPlaneXStepQn); \
867 \
868 DO_FIELD(DW14, ChromaPlaneX0Qn, params.chromaPlaneX0Qn)
869
870 #include "mhw_hwcmd_process_cmdfields.h"
871 }
872
873 _MHW_SETCMD_OVERRIDE_DECL(AVP_TILE_CODING)
874 {
875 _MHW_SETCMD_CALLBASE(AVP_TILE_CODING);
876
877 #define DO_FIELDS() \
878 DO_FIELD(DW1, FrameTileId, params.tileId); \
879 DO_FIELD(DW1, TgTileNum, params.tgTileNum); \
880 DO_FIELD(DW1, TileGroupId, params.tileGroupId); \
881 \
882 DO_FIELD(DW2, TileColumnPositionInSbUnit, params.tileColPositionInSb); \
883 DO_FIELD(DW2, TileRowPositionInSbUnit, params.tileRowPositionInSb); \
884 \
885 DO_FIELD(DW3, TileWidthInSuperblockUnitMinus1, params.tileWidthInSbMinus1); \
886 DO_FIELD(DW3, TileHeightInSuperblockUnitMinus1, params.tileHeightInSbMinus1); \
887 \
888 DO_FIELD(DW4, FirstTileInAFrame, params.firstTileInAFrame ? 1 : 0); \
889 DO_FIELD(DW4, IslasttileofcolumnFlag, params.lastTileOfColumn ? 1 : 0); \
890 DO_FIELD(DW4, IslasttileofrowFlag, params.lastTileOfRow ? 1 : 0); \
891 DO_FIELD(DW4, IsstarttileoftilegroupFlag, params.firstTileOfTileGroup ? 1 : 0); \
892 DO_FIELD(DW4, IsendtileoftilegroupFlag, params.lastTileOfTileGroup ? 1 : 0); \
893 DO_FIELD(DW4, IslasttileofframeFlag, params.lastTileOfFrame ? 1 : 0); \
894 DO_FIELD(DW4, DisableCdfUpdateFlag, params.disableCdfUpdateFlag ? 1 : 0); \
895 DO_FIELD(DW4, DisableFrameContextUpdateFlag, params.disableFrameContextUpdateFlag ? 1 : 0); \
896 \
897 DO_FIELD(DW5, NumberOfActiveBePipes, params.numOfActiveBePipes); \
898 DO_FIELD(DW5, NumOfTileColumnsMinus1InAFrame, params.numOfTileColumnsInFrame - 1); \
899 DO_FIELD(DW5, NumOfTileRowsMinus1InAFrame, params.numOfTileRowsInFrame - 1); \
900 \
901 DO_FIELD(DW6, OutputDecodedTileColumnPositionInSbUnit, params.outputDecodedTileColPos); \
902 DO_FIELD(DW6, OutputDecodedTileRowPositionInSbUnit, params.outputDecodedTileRowPos)
903
904 #include "mhw_hwcmd_process_cmdfields.h"
905 }
906
907 template<typename TCmd>
908 MOS_STATUS SetAvpPipeBufAddrStateSpecific(TCmd& cmd)
909 {
910 MHW_FUNCTION_ENTER;
911
912 const auto &params = this->__MHW_CMDINFO_M(AVP_PIPE_BUF_ADDR_STATE)->first;
913
914 MHW_RESOURCE_PARAMS resourceParams = {};
915 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
916 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
917
918 // Film Grain Output Surface
919 if (!Mos_ResourceIsNull(params.filmGrainOutputSurface))
920 {
921 MOS_SURFACE details = {};
922 details.Format = Format_Invalid;
923 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.filmGrainOutputSurface, &details));
924
925 cmd.FilmGrainInjectedOutputFrameBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0;
926 cmd.FilmGrainInjectedOutputFrameBufferAddressAttributes.DW0.TileMode = this->GetHwTileType(params.filmGrainOutputSurface->TileType,
927 params.filmGrainOutputSurface->TileModeGMM,
928 params.filmGrainOutputSurface->bGMMTileEnabled);
929
930 MOS_MEMCOMP_STATE mmcState = MOS_MEMCOMP_DISABLED;
931 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetMemoryCompressionMode(this->m_osItf,
932 params.filmGrainOutputSurface,
933 &mmcState));
934 cmd.FilmGrainInjectedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = this->MmcEnabled(mmcState);
935 cmd.FilmGrainInjectedOutputFrameBufferAddressAttributes.DW0.CompressionType = this->MmcRcEnabled(mmcState);
936
937 resourceParams.presResource = params.filmGrainOutputSurface;
938 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
939 resourceParams.pdwCmd = (cmd.FilmGrainInjectedOutputFrameBufferAddress.DW0_1.Value);
940 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(FilmGrainInjectedOutputFrameBufferAddress);
941 resourceParams.bIsWritable = true;
942
943 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
944 this->m_osItf,
945 this->m_currentCmdBuf,
946 &resourceParams));
947 }
948
949 // Film Grain Sample Template Buffer
950 if (!Mos_ResourceIsNull(params.filmGrainSampleTemplateBuffer))
951 {
952 cmd.FilmGrainSampleTemplateAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0;
953
954 resourceParams.presResource = params.filmGrainSampleTemplateBuffer;
955 resourceParams.dwOffset = 0;
956 resourceParams.pdwCmd = (cmd.FilmGrainSampleTemplateAddress.DW0_1.Value);
957 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(FilmGrainSampleTemplateAddress);
958 resourceParams.bIsWritable = true;
959
960 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
961 this->m_osItf,
962 this->m_currentCmdBuf,
963 &resourceParams));
964 }
965
966 // Loop Restoration Tile Column Alignment Buffer
967 if (!Mos_ResourceIsNull(params.lrTileColumnAlignBuffer))
968 {
969 cmd.LoopRestorationFilterTileColumnAlignmentReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0;
970
971 resourceParams.presResource = params.lrTileColumnAlignBuffer;
972 resourceParams.dwOffset = 0;
973 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnAlignmentReadWriteBufferAddress.DW0_1.Value);
974 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileColumnAlignmentReadWriteBufferAddress);
975 resourceParams.bIsWritable = true;
976
977 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
978 this->m_osItf,
979 this->m_currentCmdBuf,
980 &resourceParams));
981 }
982
983 // Film Grain Tile Column Data Buffer
984 if (!Mos_ResourceIsNull(params.filmGrainTileColumnDataBuffer))
985 {
986 cmd.FilmGrainTileColumnDataReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = 0;
987
988 resourceParams.presResource = params.filmGrainTileColumnDataBuffer;
989 resourceParams.dwOffset = 0;
990 resourceParams.pdwCmd = (cmd.FilmGrainTileColumnDataReadWriteBufferAddress.DW0_1.Value);
991 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(FilmGrainTileColumnDataReadWriteBufferAddress);
992 resourceParams.bIsWritable = true;
993
994 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
995 this->m_osItf,
996 this->m_currentCmdBuf,
997 &resourceParams));
998 }
999
1000 return MOS_STATUS_SUCCESS;
1001 }
1002
1003 _MHW_SETCMD_OVERRIDE_DECL(AVP_SEGMENT_STATE)
1004 {
1005 _MHW_SETCMD_CALLBASE(AVP_SEGMENT_STATE);
1006
1007 const uint8_t seg = params.currentSegmentId;
1008
1009 #define DO_FIELDS() \
1010 DO_FIELD(DW1, SegmentId, seg); \
1011 \
1012 DO_FIELD(DW2, SegmentFeatureMask, params.av1SegmentParams.m_featureMask[seg]); \
1013 DO_FIELD(DW2, SegmentDeltaQindex, params.av1SegmentParams.m_featureData[seg][segLvlAltQ]); \
1014 DO_FIELD(DW2, SegmentBlockSkipFlag, params.av1SegmentParams.m_featureData[seg][segLvlSkip]); \
1015 DO_FIELD(DW2, SegmentBlockGlobalmvFlag, params.av1SegmentParams.m_featureData[seg][segLvlGlobalMv]); \
1016 DO_FIELD(DW2, SegmentLosslessFlag, params.av1SegmentParams.m_losslessFlag[seg]); \
1017 DO_FIELD(DW2, SegmentLumaYQmLevel, params.av1SegmentParams.m_qmLevelY[seg]); \
1018 DO_FIELD(DW2, SegmentChromaUQmLevel, params.av1SegmentParams.m_qmLevelU[seg]); \
1019 DO_FIELD(DW2, SegmentChromaVQmLevel, params.av1SegmentParams.m_qmLevelV[seg]); \
1020 \
1021 DO_FIELD(DW3, SegmentDeltaLoopFilterLevelLumaVertical, params.av1SegmentParams.m_featureData[seg][segLvlAltLfYv]); \
1022 DO_FIELD(DW3, SegmentDeltaLoopFilterLevelLumaHorizontal, params.av1SegmentParams.m_featureData[seg][segLvlAltLfYh]); \
1023 DO_FIELD(DW3, SegmentDeltaLoopFilterLevelChromaU, params.av1SegmentParams.m_featureData[seg][segLvlAltLfU]); \
1024 DO_FIELD(DW3, SegmentDeltaLoopFilterLevelChromaV, params.av1SegmentParams.m_featureData[seg][segLvlAltLfV]); \
1025 DO_FIELD(DW3, SegmentReferenceFrame, params.av1SegmentParams.m_featureData[seg][segLvlRefFrame])
1026
1027 #include "mhw_hwcmd_process_cmdfields.h"
1028 }
1029
1030 _MHW_SETCMD_OVERRIDE_DECL(AVP_PIPE_BUF_ADDR_STATE)
1031 {
1032 _MHW_SETCMD_CALLBASE(AVP_PIPE_BUF_ADDR_STATE);
1033
1034 MHW_RESOURCE_PARAMS resourceParams = {};
1035
1036 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
1037 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
1038
1039 // Reference Picture Base Address. Only one control DW17 for all references
1040
1041 bool firstRefPic = true;
1042
1043 // m_references[8] follows the order INTRA_FRAME->LAST_FRAME->LAST2_FRAME->LAST3_FRAME->GOLDEN_FRAME->
1044 // BWDREF_FRAME-.ALTREF2_FRAME->ALTREF_FRAME.
1045 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++)
1046 {
1047 // Reference Picture Buffer
1048 if (!Mos_ResourceIsNull(params.refs[i]))
1049 {
1050 MOS_SURFACE details = {};
1051 MOS_ZeroMemory(&details, sizeof(details));
1052 details.Format = Format_Invalid;
1053 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.refs[i], &details));
1054
1055 if (firstRefPic)
1056 {
1057 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStatePreDeblock);
1058 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStatePreDeblock);
1059 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
1060 firstRefPic = false;
1061 }
1062
1063 resourceParams.presResource = params.refs[i];
1064 resourceParams.pdwCmd = (cmd.ReferenceFrameBufferBaseAddressRefaddr07[i].DW0_1.Value);
1065 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
1066 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(ReferenceFrameBufferBaseAddressRefaddr07[i]);
1067 resourceParams.bIsWritable = false;
1068 resourceParams.dwSharedMocsOffset = 17 - resourceParams.dwLocationInCmd;
1069
1070 InitMocsParams(resourceParams, &cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.Value, 1, 6);
1071
1072 MHW_MI_CHK_STATUS(AddResourceToCmd(
1073 this->m_osItf,
1074 this->m_currentCmdBuf,
1075 &resourceParams));
1076 }
1077 }
1078
1079 //Decoded Output Frame Buffer
1080 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStatePreDeblock);
1081 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStatePreDeblock);
1082 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.TileMode = GetHwTileType(params.decodedPic->TileType, params.decodedPic->TileModeGMM, params.decodedPic->bGMMTileEnabled);
1083
1084 resourceParams.presResource = &(params.decodedPic->OsResource);
1085 resourceParams.dwOffset = params.decodedPic->dwOffset;
1086 resourceParams.pdwCmd = (cmd.DecodedOutputFrameBufferAddress.DW0_1.Value);
1087 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedOutputFrameBufferAddress);
1088 resourceParams.bIsWritable = true;
1089
1090 InitMocsParams(resourceParams, &cmd.DecodedOutputFrameBufferAddressAttributes.DW0.Value, 1, 6);
1091
1092 MHW_MI_CHK_STATUS(AddResourceToCmd(
1093 this->m_osItf,
1094 this->m_currentCmdBuf,
1095 &resourceParams));
1096
1097 //IntraBC Decoded Output Frame buffer
1098 if (!Mos_ResourceIsNull(params.intrabcDecodedOutputFrameBuffer))
1099 {
1100 resourceParams.presResource = params.intrabcDecodedOutputFrameBuffer;
1101 resourceParams.dwOffset = 0;
1102 resourceParams.pdwCmd = (cmd.IntrabcDecodedOutputFrameBufferAddress.DW0_1.Value);
1103 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntrabcDecodedOutputFrameBufferAddress);
1104 resourceParams.bIsWritable = true;
1105
1106 InitMocsParams(resourceParams, &cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.Value, 1, 6);
1107
1108 MHW_MI_CHK_STATUS(AddResourceToCmd(
1109 this->m_osItf,
1110 this->m_currentCmdBuf,
1111 &resourceParams));
1112
1113 //This surface should not have memory compression turned on
1114 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = 0;
1115 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.CompressionType = 0;
1116 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.TileMode = GetHwTileType(params.intrabcDecodedOutputFrameBuffer->TileType, params.intrabcDecodedOutputFrameBuffer->TileModeGMM, params.intrabcDecodedOutputFrameBuffer->bGMMTileEnabled);
1117 }
1118
1119 // CDF Table Initialization Buffer
1120 if (!Mos_ResourceIsNull(params.cdfTableInitBuffer))
1121 {
1122 resourceParams.presResource = params.cdfTableInitBuffer;
1123 resourceParams.dwOffset = params.cdfTableInitBufferOffset;
1124 resourceParams.pdwCmd = (cmd.CdfTablesInitializationBufferAddress.DW0_1.Value);
1125 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdfTablesInitializationBufferAddress);
1126 resourceParams.bIsWritable = false;
1127
1128 InitMocsParams(resourceParams, &cmd.CdfTablesInitializationBufferAddressAttributes.DW0.Value, 1, 6);
1129
1130 MHW_MI_CHK_STATUS(AddResourceToCmd(
1131 this->m_osItf,
1132 this->m_currentCmdBuf,
1133 &resourceParams));
1134 }
1135
1136 if (!Mos_ResourceIsNull(params.cdfTableBwdAdaptBuffer))
1137 {
1138 resourceParams.presResource = params.cdfTableBwdAdaptBuffer;
1139 resourceParams.dwOffset = 0;
1140 resourceParams.pdwCmd = (cmd.CdfTablesBackwardAdaptationBufferAddress.DW0_1.Value);
1141 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdfTablesBackwardAdaptationBufferAddress);
1142 resourceParams.bIsWritable = true;
1143
1144 InitMocsParams(resourceParams, &cmd.CdfTablesBackwardAdaptationBufferAddressAttributes.DW0.Value, 1, 6);
1145
1146 MHW_MI_CHK_STATUS(AddResourceToCmd(
1147 this->m_osItf,
1148 this->m_currentCmdBuf,
1149 &resourceParams));
1150 }
1151
1152 // Reset dwSharedMocsOffset
1153 //resourceParams.dwSharedMocsOffset = 0;
1154
1155 if (!Mos_ResourceIsNull(params.segmentIdReadBuffer))
1156 {
1157 resourceParams.presResource = params.segmentIdReadBuffer;
1158 resourceParams.dwOffset = 0;
1159 resourceParams.pdwCmd = (cmd.Av1SegmentIdReadBufferAddress.DW0_1.Value);
1160 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Av1SegmentIdReadBufferAddress);
1161 resourceParams.bIsWritable = true;
1162
1163 resourceParams.dwSharedMocsOffset = 35 - resourceParams.dwLocationInCmd;
1164
1165 InitMocsParams(resourceParams, &cmd.Av1SegmentIdReadBufferAddressAttributes.DW0.Value, 1, 6);
1166
1167 MHW_MI_CHK_STATUS(AddResourceToCmd(
1168 this->m_osItf,
1169 this->m_currentCmdBuf,
1170 &resourceParams));
1171 }
1172
1173 // AV1 Segment Id Write Buffer
1174 if (!Mos_ResourceIsNull(params.segmentIdWriteBuffer))
1175 {
1176 resourceParams.presResource = params.segmentIdWriteBuffer;
1177 resourceParams.dwOffset = 0;
1178 resourceParams.pdwCmd = (cmd.Av1SegmentIdWriteBufferAddress.DW0_1.Value);
1179 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(Av1SegmentIdWriteBufferAddress);
1180 resourceParams.bIsWritable = true;
1181
1182 resourceParams.dwSharedMocsOffset = 38 - resourceParams.dwLocationInCmd;
1183
1184 InitMocsParams(resourceParams, &cmd.Av1SegmentIdWriteBufferAddressAttributes.DW0.Value, 1, 6);
1185
1186 MHW_MI_CHK_STATUS(AddResourceToCmd(
1187 this->m_osItf,
1188 this->m_currentCmdBuf,
1189 &resourceParams));
1190 }
1191
1192 //Collocated MV Temporal buffers
1193 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++)
1194 {
1195 if (!Mos_ResourceIsNull(params.colMvTempBuffer[i]))
1196 {
1197 resourceParams.presResource = params.colMvTempBuffer[i];
1198 resourceParams.dwOffset = 0;
1199 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBufferBaseAddressTmvaddr07[i].DW0_1.Value);
1200 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CollocatedMotionVectorTemporalBufferBaseAddressTmvaddr07[i]);
1201 resourceParams.bIsWritable = true;
1202 resourceParams.dwSharedMocsOffset = 55 - resourceParams.dwLocationInCmd;
1203
1204 InitMocsParams(resourceParams, &cmd.CollocatedMotionVectorTemporalBufferBaseAddressAttributes.DW0.Value, 1, 6);
1205
1206 MHW_MI_CHK_STATUS(AddResourceToCmd(
1207 this->m_osItf,
1208 this->m_currentCmdBuf,
1209 &resourceParams));
1210 }
1211 }
1212
1213 // Current Motion Vector Temporal Buffer
1214 if (!Mos_ResourceIsNull(params.curMvTempBuffer))
1215 {
1216 resourceParams.presResource = params.curMvTempBuffer;
1217 resourceParams.dwOffset = 0;
1218 resourceParams.pdwCmd = (cmd.CurrentFrameMotionVectorWriteBufferAddress.DW0_1.Value);
1219 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CurrentFrameMotionVectorWriteBufferAddress);
1220 resourceParams.bIsWritable = true;
1221
1222 InitMocsParams(resourceParams, &cmd.CurrentFrameMotionVectorWriteBufferAddressAttributes.DW0.Value, 1, 6);
1223
1224 MHW_MI_CHK_STATUS(AddResourceToCmd(
1225 this->m_osItf,
1226 this->m_currentCmdBuf,
1227 &resourceParams));
1228 }
1229
1230 // Reset dwSharedMocsOffset
1231 resourceParams.dwSharedMocsOffset = 0;
1232 // Bitstream Decode Line Rowstore Buffer
1233 if (m_btdlRowstoreCache.enabled)
1234 {
1235 cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1236 cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddress.DW0_1.BaseAddress = m_btdlRowstoreCache.dwAddress;
1237 }
1238 else if (!Mos_ResourceIsNull(params.bsLineRowstoreBuffer))
1239 {
1240 resourceParams.presResource = params.bsLineRowstoreBuffer;
1241 resourceParams.dwOffset = 0;
1242 resourceParams.pdwCmd = (cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddress.DW0_1.Value);
1243 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddress);
1244 resourceParams.bIsWritable = true;
1245
1246 InitMocsParams(resourceParams, &cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1247
1248 MHW_MI_CHK_STATUS(AddResourceToCmd(
1249 this->m_osItf,
1250 this->m_currentCmdBuf,
1251 &resourceParams));
1252 }
1253
1254 // Bitstream Decode Tile Line Rowstore Buffer
1255 if (!Mos_ResourceIsNull(params.bsTileLineRowstoreBuffer))
1256 {
1257 resourceParams.presResource = params.bsTileLineRowstoreBuffer;
1258 resourceParams.dwOffset = 0;
1259 resourceParams.pdwCmd = (cmd.BitstreamDecoderEncoderTileLineRowstoreReadWriteBufferAddress.DW0_1.Value);
1260 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(BitstreamDecoderEncoderTileLineRowstoreReadWriteBufferAddress);
1261 resourceParams.bIsWritable = true;
1262
1263 InitMocsParams(resourceParams, &cmd.BitstreamDecoderEncoderTileLineRowstoreReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1264
1265 MHW_MI_CHK_STATUS(AddResourceToCmd(
1266 this->m_osItf,
1267 this->m_currentCmdBuf,
1268 &resourceParams));
1269 }
1270
1271 // Reset dwSharedMocsOffset
1272 resourceParams.dwSharedMocsOffset = 0;
1273 // Intra Prediction Line Rowstore Read/Write Buffer
1274 if (m_ipdlRowstoreCache.enabled)
1275 {
1276 cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1277 cmd.IntraPredictionLineRowstoreReadWriteBufferAddress.DW0_1.BaseAddress = m_ipdlRowstoreCache.dwAddress;
1278 }
1279 else if (!Mos_ResourceIsNull(params.intraPredLineRowstoreBuffer))
1280 {
1281 resourceParams.presResource = params.intraPredLineRowstoreBuffer;
1282 resourceParams.dwOffset = 0;
1283 resourceParams.pdwCmd = (cmd.IntraPredictionLineRowstoreReadWriteBufferAddress.DW0_1.Value);
1284 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionLineRowstoreReadWriteBufferAddress);
1285 resourceParams.bIsWritable = true;
1286
1287 InitMocsParams(resourceParams, &cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1288
1289 MHW_MI_CHK_STATUS(AddResourceToCmd(
1290 this->m_osItf,
1291 this->m_currentCmdBuf,
1292 &resourceParams));
1293 }
1294
1295 if (!Mos_ResourceIsNull(params.intraPredTileLineRowstoreBuffer))
1296 {
1297 resourceParams.presResource = params.intraPredTileLineRowstoreBuffer;
1298 resourceParams.dwOffset = 0;
1299 resourceParams.pdwCmd = (cmd.IntraPredictionTileLineRowstoreReadWriteBufferAddress.DW0_1.Value);
1300 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(IntraPredictionTileLineRowstoreReadWriteBufferAddress);
1301 resourceParams.bIsWritable = true;
1302
1303 InitMocsParams(resourceParams, &cmd.IntraPredictionTileLineRowstoreReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1304
1305 MHW_MI_CHK_STATUS(AddResourceToCmd(
1306 this->m_osItf,
1307 this->m_currentCmdBuf,
1308 &resourceParams));
1309 }
1310
1311 // Spatial Motion Vector Line Buffer
1312 if (m_smvlRowstoreCache.enabled)
1313 {
1314 cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1315 cmd.SpatialMotionVectorLineReadWriteBufferAddress.DW0_1.BaseAddress = m_smvlRowstoreCache.dwAddress;
1316 }
1317 else if (!Mos_ResourceIsNull(params.spatialMVLineBuffer))
1318 {
1319 resourceParams.presResource = params.spatialMVLineBuffer;
1320 resourceParams.dwOffset = 0;
1321 resourceParams.pdwCmd = (cmd.SpatialMotionVectorLineReadWriteBufferAddress.DW0_1.Value);
1322 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SpatialMotionVectorLineReadWriteBufferAddress);
1323 resourceParams.bIsWritable = true;
1324
1325 InitMocsParams(resourceParams, &cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1326
1327 MHW_MI_CHK_STATUS(AddResourceToCmd(
1328 this->m_osItf,
1329 this->m_currentCmdBuf,
1330 &resourceParams));
1331 }
1332
1333 // Spatial Motion Vector Tile Line Buffer
1334 if (!Mos_ResourceIsNull(params.spatialMVCodingTileLineBuffer))
1335 {
1336 resourceParams.presResource = params.spatialMVCodingTileLineBuffer;
1337 resourceParams.dwOffset = 0;
1338 resourceParams.pdwCmd = (cmd.SpatialMotionVectorCodingTileLineReadWriteBufferAddress.DW0_1.Value);
1339 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SpatialMotionVectorCodingTileLineReadWriteBufferAddress);
1340 resourceParams.bIsWritable = true;
1341
1342 InitMocsParams(resourceParams, &cmd.SpatialMotionVectorTileLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1343
1344 MHW_MI_CHK_STATUS(AddResourceToCmd(
1345 this->m_osItf,
1346 this->m_currentCmdBuf,
1347 &resourceParams));
1348 }
1349
1350 //Loop Restoration Meta Tile Column Read/Write Buffer
1351 if (!Mos_ResourceIsNull(params.lrMetaTileColumnBuffer))
1352 {
1353 resourceParams.presResource = params.lrMetaTileColumnBuffer;
1354 resourceParams.dwOffset = 0;
1355 resourceParams.pdwCmd = (cmd.LoopRestorationMetaTileColumnReadWriteBufferAddress.DW0_1.Value);
1356 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationMetaTileColumnReadWriteBufferAddress);
1357 resourceParams.bIsWritable = true;
1358
1359 InitMocsParams(resourceParams, &cmd.LoopRestorationMetaTileColumnReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1360
1361 MHW_MI_CHK_STATUS(AddResourceToCmd(
1362 this->m_osItf,
1363 this->m_currentCmdBuf,
1364 &resourceParams));
1365 }
1366
1367 //Deblocker Filter Control Parameters Line Read Write Buffer
1368 if (!Mos_ResourceIsNull(params.lrTileLineYBuffer))
1369 {
1370 resourceParams.presResource = params.lrTileLineYBuffer;
1371 resourceParams.dwOffset = 0;
1372 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineYBufferAddress.DW0_1.Value);
1373 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileReadWriteLineYBufferAddress);
1374 resourceParams.bIsWritable = true;
1375
1376 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileReadWriteLineYBufferAddressAttributes.DW0.Value, 1, 6);
1377
1378 MHW_MI_CHK_STATUS(AddResourceToCmd(
1379 this->m_osItf,
1380 this->m_currentCmdBuf,
1381 &resourceParams));
1382 }
1383
1384 //Deblocker Filter Control Parameters Tile Line Read Write Buffer
1385 if (!Mos_ResourceIsNull(params.lrTileLineUBuffer))
1386 {
1387 resourceParams.presResource = params.lrTileLineUBuffer;
1388 resourceParams.dwOffset = 0;
1389 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineUBufferAddress.DW0_1.Value);
1390 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileReadWriteLineUBufferAddress);
1391 resourceParams.bIsWritable = true;
1392
1393 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileReadWriteLineUBufferAddressAttributes.DW0.Value, 1, 6);
1394
1395 MHW_MI_CHK_STATUS(AddResourceToCmd(
1396 this->m_osItf,
1397 this->m_currentCmdBuf,
1398 &resourceParams));
1399 }
1400
1401 //Deblocker Filter Control Parameters Tile Column Read Write Buffer
1402 if (!Mos_ResourceIsNull(params.lrTileLineVBuffer))
1403 {
1404 resourceParams.presResource = params.lrTileLineVBuffer;
1405 resourceParams.dwOffset = 0;
1406 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineVBufferAddress.DW0_1.Value);
1407 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileReadWriteLineVBufferAddress);
1408 resourceParams.bIsWritable = true;
1409
1410 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileReadWriteLineVBufferAddressAttributes.DW0.Value, 1, 6);
1411
1412 MHW_MI_CHK_STATUS(AddResourceToCmd(
1413 this->m_osItf,
1414 this->m_currentCmdBuf,
1415 &resourceParams));
1416 }
1417
1418 // Deblocker Filter Line Read Write Y Buffer
1419 if (m_dflyRowstoreCache.enabled)
1420 {
1421 cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1422 cmd.DeblockerFilterLineReadWriteYBufferAddress.DW0_1.BaseAddress = m_dflyRowstoreCache.dwAddress;
1423 }
1424 else if (!Mos_ResourceIsNull(params.deblockLineYBuffer))
1425 {
1426 resourceParams.presResource = params.deblockLineYBuffer;
1427 resourceParams.dwOffset = 0;
1428 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteYBufferAddress.DW0_1.Value);
1429 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterLineReadWriteYBufferAddress);
1430 resourceParams.bIsWritable = true;
1431
1432 InitMocsParams(resourceParams, &cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.DW0.Value, 1, 6);
1433
1434 MHW_MI_CHK_STATUS(AddResourceToCmd(
1435 this->m_osItf,
1436 this->m_currentCmdBuf,
1437 &resourceParams));
1438 }
1439
1440 // Deblocker Filter Line Read Write U Buffer
1441 if (m_dfluRowstoreCache.enabled)
1442 {
1443 cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1444 cmd.DeblockerFilterLineReadWriteUBufferAddress.DW0_1.BaseAddress = m_dfluRowstoreCache.dwAddress;
1445 }
1446 else if(!Mos_ResourceIsNull(params.deblockLineUBuffer))
1447 {
1448 resourceParams.presResource = params.deblockLineUBuffer;
1449 resourceParams.dwOffset = 0;
1450 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteUBufferAddress.DW0_1.Value);
1451 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterLineReadWriteUBufferAddress);
1452 resourceParams.bIsWritable = true;
1453
1454 InitMocsParams(resourceParams, &cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.DW0.Value, 1, 6);
1455
1456 MHW_MI_CHK_STATUS(AddResourceToCmd(
1457 this->m_osItf,
1458 this->m_currentCmdBuf,
1459 &resourceParams));
1460 }
1461 // Deblocker Filter Line Read Write V Buffer
1462 if (m_dflvRowstoreCache.enabled)
1463 {
1464 cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1465 cmd.DeblockerFilterLineReadWriteVBufferAddress.DW0_1.BaseAddress = m_dflvRowstoreCache.dwAddress;
1466 }
1467 else if (!Mos_ResourceIsNull(params.deblockLineVBuffer))
1468 {
1469 resourceParams.presResource = params.deblockLineVBuffer;
1470 resourceParams.dwOffset = 0;
1471 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteVBufferAddress.DW0_1.Value);
1472 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterLineReadWriteVBufferAddress);
1473 resourceParams.bIsWritable = true;
1474
1475 InitMocsParams(resourceParams, &cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.DW0.Value, 1, 6);
1476
1477 MHW_MI_CHK_STATUS(AddResourceToCmd(
1478 this->m_osItf,
1479 this->m_currentCmdBuf,
1480 &resourceParams));
1481 }
1482
1483 // Deblocker Filter Tile Line Read Write Y Buffer
1484 if (!Mos_ResourceIsNull(params.deblockTileLineYBuffer))
1485 {
1486 resourceParams.presResource = params.deblockTileLineYBuffer;
1487 resourceParams.dwOffset = 0;
1488 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteYBufferAddress.DW0_1.Value);
1489 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileLineReadWriteYBufferAddress);
1490 resourceParams.bIsWritable = true;
1491
1492 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileLineReadWriteYBufferAddressAttributes.DW0.Value, 1, 6);
1493
1494 MHW_MI_CHK_STATUS(AddResourceToCmd(
1495 this->m_osItf,
1496 this->m_currentCmdBuf,
1497 &resourceParams));
1498 }
1499
1500 // Deblocker Filter Tile Line Read Write V Buffer
1501 if (!Mos_ResourceIsNull(params.deblockTileLineVBuffer))
1502 {
1503 resourceParams.presResource = params.deblockTileLineVBuffer;
1504 resourceParams.dwOffset = 0;
1505 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteVBufferAddress.DW0_1.Value);
1506 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileLineReadWriteVBufferAddress);
1507 resourceParams.bIsWritable = true;
1508
1509 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileLineReadWriteVBufferAddressAttributes.DW0.Value, 1, 6);
1510
1511 MHW_MI_CHK_STATUS(AddResourceToCmd(
1512 this->m_osItf,
1513 this->m_currentCmdBuf,
1514 &resourceParams));
1515 }
1516
1517 // Deblocker Filter Tile Line Read Write U Buffer
1518 if (!Mos_ResourceIsNull(params.deblockTileLineUBuffer))
1519 {
1520 resourceParams.presResource = params.deblockTileLineUBuffer;
1521 resourceParams.dwOffset = 0;
1522 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteUBufferAddress.DW0_1.Value);
1523 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileLineReadWriteUBufferAddress);
1524 resourceParams.bIsWritable = true;
1525
1526 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileLineReadWriteUBufferAddressAttributes.DW0.Value, 1, 6);
1527
1528 MHW_MI_CHK_STATUS(AddResourceToCmd(
1529 this->m_osItf,
1530 this->m_currentCmdBuf,
1531 &resourceParams));
1532 }
1533
1534 // Deblocker Filter Tile Column Read Write Y Buffer
1535 if (!Mos_ResourceIsNull(params.deblockTileColumnYBuffer))
1536 {
1537 resourceParams.presResource = params.deblockTileColumnYBuffer;
1538 resourceParams.dwOffset = 0;
1539 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteYBufferAddress.DW0_1.Value);
1540 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileColumnReadWriteYBufferAddress);
1541 resourceParams.bIsWritable = true;
1542
1543 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileColumnReadWriteYBufferAddressAttributes.DW0.Value, 1, 6);
1544
1545 MHW_MI_CHK_STATUS(AddResourceToCmd(
1546 this->m_osItf,
1547 this->m_currentCmdBuf,
1548 &resourceParams));
1549 }
1550
1551 // Deblocker Filter Tile Column Read Write U Buffer
1552 if (!Mos_ResourceIsNull(params.deblockTileColumnUBuffer))
1553 {
1554 resourceParams.presResource = params.deblockTileColumnUBuffer;
1555 resourceParams.dwOffset = 0;
1556 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteUBufferAddress.DW0_1.Value);
1557 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileColumnReadWriteUBufferAddress);
1558 resourceParams.bIsWritable = true;
1559
1560 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileColumnReadWriteUBufferAddressAttributes.DW0.Value, 1, 6);
1561
1562 MHW_MI_CHK_STATUS(AddResourceToCmd(
1563 this->m_osItf,
1564 this->m_currentCmdBuf,
1565 &resourceParams));
1566 }
1567
1568 // Deblocker Filter Tile Column Read Write V Buffer
1569 if (!Mos_ResourceIsNull(params.deblockTileColumnVBuffer))
1570 {
1571 resourceParams.presResource = params.deblockTileColumnVBuffer;
1572 resourceParams.dwOffset = 0;
1573 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteVBufferAddress.DW0_1.Value);
1574 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DeblockerFilterTileColumnReadWriteVBufferAddress);
1575 resourceParams.bIsWritable = true;
1576
1577 InitMocsParams(resourceParams, &cmd.DeblockerFilterTileColumnReadWriteVBufferAddressAttributes.DW0.Value, 1, 6);
1578
1579 MHW_MI_CHK_STATUS(AddResourceToCmd(
1580 this->m_osItf,
1581 this->m_currentCmdBuf,
1582 &resourceParams));
1583 }
1584
1585 // Cdef Filter Line Read Write Y Buffer
1586 if (m_cdefRowstoreCache.enabled)
1587 {
1588 cmd.CdefFilterLineReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.CdefFilterLineReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1589 cmd.CdefFilterLineReadWriteBufferAddress.DW0_1.BaseAddress = m_cdefRowstoreCache.dwAddress;
1590 }
1591 else if (!Mos_ResourceIsNull(params.cdefLineBuffer))
1592 {
1593 resourceParams.presResource = params.cdefLineBuffer;
1594 resourceParams.dwOffset = 0;
1595 resourceParams.pdwCmd = (cmd.CdefFilterLineReadWriteBufferAddress.DW0_1.Value);
1596 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterLineReadWriteBufferAddress);
1597 resourceParams.bIsWritable = true;
1598
1599 InitMocsParams(resourceParams, &cmd.CdefFilterLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1600
1601 MHW_MI_CHK_STATUS(AddResourceToCmd(
1602 this->m_osItf,
1603 this->m_currentCmdBuf,
1604 &resourceParams));
1605 }
1606
1607 // Cdef Filter Tile Line Read Write Y Buffer
1608 if (!Mos_ResourceIsNull(params.cdefTileLineBuffer))
1609 {
1610 resourceParams.presResource = params.cdefTileLineBuffer;
1611 resourceParams.dwOffset = 0;
1612 resourceParams.pdwCmd = (cmd.CdefFilterTileLineReadWriteBufferAddress.DW0_1.Value);
1613 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterTileLineReadWriteBufferAddress);
1614 resourceParams.bIsWritable = true;
1615
1616 InitMocsParams(resourceParams, &cmd.CdefFilterTileLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1617
1618 MHW_MI_CHK_STATUS(AddResourceToCmd(
1619 this->m_osItf,
1620 this->m_currentCmdBuf,
1621 &resourceParams));
1622 }
1623
1624 // Cdef Filter Tile Line Read Write U Buffer
1625 if (!Mos_ResourceIsNull(params.cdefTileColumnBuffer))
1626 {
1627 resourceParams.presResource = params.cdefTileColumnBuffer;
1628 resourceParams.dwOffset = 0;
1629 resourceParams.pdwCmd = (cmd.CdefFilterTileColumnReadWriteBufferAddress.DW0_1.Value);
1630 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterTileColumnReadWriteBufferAddress);
1631 resourceParams.bIsWritable = true;
1632
1633 InitMocsParams(resourceParams, &cmd.CdefFilterTileColumnReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1634
1635 MHW_MI_CHK_STATUS(AddResourceToCmd(
1636 this->m_osItf,
1637 this->m_currentCmdBuf,
1638 &resourceParams));
1639 }
1640
1641 // Cdef Filter Tile Line Read Write V Buffer
1642 if (!Mos_ResourceIsNull(params.cdefMetaTileLineBuffer))
1643 {
1644 resourceParams.presResource = params.cdefMetaTileLineBuffer;
1645 resourceParams.dwOffset = 0;
1646 resourceParams.pdwCmd = (cmd.CdefFilterMetaTileLineReadWriteBufferAddress.DW0_1.Value);
1647 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterMetaTileLineReadWriteBufferAddress);
1648 resourceParams.bIsWritable = true;
1649
1650 InitMocsParams(resourceParams, &cmd.CdefFilterMetaTileLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1651
1652 MHW_MI_CHK_STATUS(AddResourceToCmd(
1653 this->m_osItf,
1654 this->m_currentCmdBuf,
1655 &resourceParams));
1656 }
1657
1658 // Cdef Filter Tile Column Read Write Y Buffer
1659 if (!Mos_ResourceIsNull(params.cdefMetaTileColumnBuffer))
1660 {
1661 resourceParams.presResource = params.cdefMetaTileColumnBuffer;
1662 resourceParams.dwOffset = 0;
1663 resourceParams.pdwCmd = (cmd.CdefFilterMetaTileColumnReadWriteBufferAddress.DW0_1.Value);
1664 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterMetaTileColumnReadWriteBufferAddress);
1665 resourceParams.bIsWritable = true;
1666
1667 InitMocsParams(resourceParams, &cmd.CdefFilterMetaTileColumnReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1668
1669 MHW_MI_CHK_STATUS(AddResourceToCmd(
1670 this->m_osItf,
1671 this->m_currentCmdBuf,
1672 &resourceParams));
1673 }
1674
1675 // Cdef Filter Top Left Corner Read Write Buffer
1676 if (!Mos_ResourceIsNull(params.cdefTopLeftCornerBuffer))
1677 {
1678 resourceParams.presResource = params.cdefTopLeftCornerBuffer;
1679 resourceParams.dwOffset = 0;
1680 resourceParams.pdwCmd = (cmd.CdefFilterTopLeftCornerReadWriteBufferAddress.DW0_1.Value);
1681 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CdefFilterTopLeftCornerReadWriteBufferAddress);
1682 resourceParams.bIsWritable = true;
1683
1684 InitMocsParams(resourceParams, &cmd.CdefFilterTopLeftCornerReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1685
1686 MHW_MI_CHK_STATUS(AddResourceToCmd(
1687 this->m_osItf,
1688 this->m_currentCmdBuf,
1689 &resourceParams));
1690 }
1691
1692 // Super-Res Tile Column Read Write Y Buffer
1693 if (!Mos_ResourceIsNull(params.superResTileColumnYBuffer))
1694 {
1695 resourceParams.presResource = params.superResTileColumnYBuffer;
1696 resourceParams.dwOffset = 0;
1697 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteYBufferAddress.DW0_1.Value);
1698 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SuperResTileColumnReadWriteYBufferAddress);
1699 resourceParams.bIsWritable = true;
1700
1701 InitMocsParams(resourceParams, &cmd.SuperResTileColumnReadWriteYBufferAddressAttributes.DW0.Value, 1, 6);
1702
1703 MHW_MI_CHK_STATUS(AddResourceToCmd(
1704 this->m_osItf,
1705 this->m_currentCmdBuf,
1706 &resourceParams));
1707 }
1708
1709 // Super-Res Tile Column Read Write U Buffer
1710 if (!Mos_ResourceIsNull(params.superResTileColumnUBuffer))
1711 {
1712 resourceParams.presResource = params.superResTileColumnUBuffer;
1713 resourceParams.dwOffset = 0;
1714 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteUBufferAddress.DW0_1.Value);
1715 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SuperResTileColumnReadWriteUBufferAddress);
1716 resourceParams.bIsWritable = true;
1717
1718 InitMocsParams(resourceParams, &cmd.SuperResTileColumnReadWriteUBufferAddressAttributes.DW0.Value, 1, 6);
1719
1720 MHW_MI_CHK_STATUS(AddResourceToCmd(
1721 this->m_osItf,
1722 this->m_currentCmdBuf,
1723 &resourceParams));
1724 }
1725
1726 // Super-Res Tile Column Read Write V Buffer
1727 if (!Mos_ResourceIsNull(params.superResTileColumnVBuffer))
1728 {
1729 resourceParams.presResource = params.superResTileColumnVBuffer;
1730 resourceParams.dwOffset = 0;
1731 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteVBufferAddress.DW0_1.Value);
1732 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SuperResTileColumnReadWriteVBufferAddress);
1733 resourceParams.bIsWritable = true;
1734
1735 InitMocsParams(resourceParams, &cmd.SuperResTileColumnReadWriteVBufferAddressAttributes.DW0.Value, 1, 6);
1736
1737 MHW_MI_CHK_STATUS(AddResourceToCmd(
1738 this->m_osItf,
1739 this->m_currentCmdBuf,
1740 &resourceParams));
1741 }
1742
1743 // Loop Restoration Filter Tile Column Read Write Y Buffer
1744 if (!Mos_ResourceIsNull(params.lrTileColumnYBuffer))
1745 {
1746 resourceParams.presResource = params.lrTileColumnYBuffer;
1747 resourceParams.dwOffset = 0;
1748 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteYBufferAddress.DW0_1.Value);
1749 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileColumnReadWriteYBufferAddress);
1750 resourceParams.bIsWritable = true;
1751
1752 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileColumnReadWriteYBufferAddressAttributes.DW0.Value, 1, 6);
1753
1754 MHW_MI_CHK_STATUS(AddResourceToCmd(
1755 this->m_osItf,
1756 this->m_currentCmdBuf,
1757 &resourceParams));
1758 }
1759
1760 // Loop Restoration Filter Tile Column Read Write U Buffer
1761 if (!Mos_ResourceIsNull(params.lrTileColumnUBuffer))
1762 {
1763 resourceParams.presResource = params.lrTileColumnUBuffer;
1764 resourceParams.dwOffset = 0;
1765 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteUBufferAddress.DW0_1.Value);
1766 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileColumnReadWriteUBufferAddress);
1767 resourceParams.bIsWritable = true;
1768
1769 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileColumnReadWriteUBufferAddressAttributes.DW0.Value, 1, 6);
1770
1771 MHW_MI_CHK_STATUS(AddResourceToCmd(
1772 this->m_osItf,
1773 this->m_currentCmdBuf,
1774 &resourceParams));
1775 }
1776
1777 // Loop Restoration Filter Tile Column Read Write V Buffer
1778 if (!Mos_ResourceIsNull(params.lrTileColumnVBuffer))
1779 {
1780 resourceParams.presResource = params.lrTileColumnVBuffer;
1781 resourceParams.dwOffset = 0;
1782 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteVBufferAddress.DW0_1.Value);
1783 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(LoopRestorationFilterTileColumnReadWriteVBufferAddress);
1784 resourceParams.bIsWritable = true;
1785
1786 InitMocsParams(resourceParams, &cmd.LoopRestorationFilterTileColumnReadWriteVBufferAddressAttributes.DW0.Value, 1, 6);
1787
1788 MHW_MI_CHK_STATUS(AddResourceToCmd(
1789 this->m_osItf,
1790 this->m_currentCmdBuf,
1791 &resourceParams));
1792 }
1793
1794 // Decoded Frame Status Error Buffer
1795 if (!Mos_ResourceIsNull(params.decodedFrameStatusErrorBuffer))
1796 {
1797 resourceParams.presResource = params.decodedFrameStatusErrorBuffer;
1798 resourceParams.dwOffset = 0;
1799 resourceParams.pdwCmd = (cmd.DecodedFrameStatusErrorBufferBaseAddress.DW0_1.Value);
1800 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedFrameStatusErrorBufferBaseAddress);
1801 resourceParams.bIsWritable = true;
1802
1803 InitMocsParams(resourceParams, &cmd.DecodedFrameStatusErrorBufferBaseAddressAttributes.DW0.Value, 1, 6);
1804
1805 MHW_MI_CHK_STATUS(AddResourceToCmd(
1806 this->m_osItf,
1807 this->m_currentCmdBuf,
1808 &resourceParams));
1809 }
1810
1811 // Decoded Block Data Streamout Buffer
1812 if (!Mos_ResourceIsNull(params.decodedBlockDataStreamoutBuffer))
1813 {
1814 resourceParams.presResource = params.decodedBlockDataStreamoutBuffer;
1815 resourceParams.dwOffset = 0;
1816 resourceParams.pdwCmd = (cmd.DecodedBlockDataStreamoutBufferAddress.DW0_1.Value);
1817 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DecodedBlockDataStreamoutBufferAddress);
1818 resourceParams.bIsWritable = true;
1819
1820 InitMocsParams(resourceParams, &cmd.DecodedBlockDataStreamoutBufferAddressAttributes.DW0.Value, 1, 6);
1821
1822 MHW_MI_CHK_STATUS(AddResourceToCmd(
1823 this->m_osItf,
1824 this->m_currentCmdBuf,
1825 &resourceParams));
1826 }
1827
1828 // below is encode part
1829
1830 // Original Uncompressed Picture Source Buffer
1831 if (!Mos_ResourceIsNull(params.originalPicSourceBuffer))
1832 {
1833 MOS_SURFACE details = {};
1834 MOS_ZeroMemory(&details, sizeof(details));
1835 details.Format = Format_Invalid;
1836 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.originalPicSourceBuffer, &details));
1837
1838 cmd.OriginalUncompressedPictureSourceBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStateRawSurf);
1839 cmd.OriginalUncompressedPictureSourceBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStateRawSurf);
1840 cmd.OriginalUncompressedPictureSourceBufferAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
1841
1842 resourceParams.presResource = params.originalPicSourceBuffer;
1843 resourceParams.dwOffset = 0;
1844 resourceParams.pdwCmd = (cmd.OriginalUncompressedPictureSourceBufferAddress.DW0_1.Value);
1845 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(OriginalUncompressedPictureSourceBufferAddress);
1846 resourceParams.bIsWritable = false;
1847
1848 InitMocsParams(resourceParams, &cmd.OriginalUncompressedPictureSourceBufferAddressAttributes.DW0.Value, 1, 6);
1849
1850 MHW_MI_CHK_STATUS(AddResourceToCmd(
1851 this->m_osItf,
1852 this->m_currentCmdBuf,
1853 &resourceParams));
1854 }
1855
1856 // Downscaled Uncompressed Picture Source Buffer
1857 if (!Mos_ResourceIsNull(params.dsPictureSourceBuffer))
1858 {
1859 MOS_SURFACE details = {};
1860 MOS_ZeroMemory(&details, sizeof(details));
1861 details.Format = Format_Invalid;
1862 MHW_MI_CHK_STATUS(this->m_osItf->pfnGetResourceInfo(this->m_osItf, params.dsPictureSourceBuffer, &details));
1863
1864 cmd.DownscaledUncompressedPictureSourceBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.mmcStateRawSurf);
1865 cmd.DownscaledUncompressedPictureSourceBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.mmcStateRawSurf);
1866 cmd.DownscaledUncompressedPictureSourceBufferAddressAttributes.DW0.TileMode = GetHwTileType(details.TileType, details.TileModeGMM, details.bGMMTileEnabled);
1867
1868 resourceParams.presResource = params.dsPictureSourceBuffer;
1869 resourceParams.dwOffset = 0;
1870 resourceParams.pdwCmd = (cmd.DownscaledUncompressedPictureSourceBufferAddress.DW0_1.Value);
1871 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(DownscaledUncompressedPictureSourceBufferAddress);
1872 resourceParams.bIsWritable = false;
1873
1874 InitMocsParams(resourceParams, &cmd.DownscaledUncompressedPictureSourceBufferAddressAttributes.DW0.Value, 1, 6);
1875
1876 MHW_MI_CHK_STATUS(AddResourceToCmd(
1877 this->m_osItf,
1878 this->m_currentCmdBuf,
1879 &resourceParams));
1880 }
1881
1882 // Tile Size Streamout Buffer
1883
1884 if (!Mos_ResourceIsNull(params.tileSizeStreamoutBuffer))
1885 {
1886 resourceParams.presResource = params.tileSizeStreamoutBuffer;
1887 resourceParams.dwOffset = params.tileSizeStreamoutBufferOffset;
1888 resourceParams.pdwCmd = (cmd.TileSizeStreamoutBufferAddress.DW0_1.Value);
1889 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(TileSizeStreamoutBufferAddress);
1890 resourceParams.bIsWritable = true;
1891
1892 InitMocsParams(resourceParams, &cmd.TileSizeStreamoutBufferAddressAttributes.DW0.Value, 1, 6);
1893
1894 MHW_MI_CHK_STATUS(AddResourceToCmd(
1895 this->m_osItf,
1896 this->m_currentCmdBuf,
1897 &resourceParams));
1898 }
1899
1900 // Tile Statistics Streamout Buffer
1901 if (!Mos_ResourceIsNull(params.tileStatisticsPakStreamoutBuffer))
1902 {
1903 resourceParams.presResource = params.tileStatisticsPakStreamoutBuffer;
1904 resourceParams.dwOffset = 0;
1905 resourceParams.pdwCmd = (cmd.TileStatisticsStreamoutBufferAddress.DW0_1.Value);
1906 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(TileStatisticsStreamoutBufferAddress);
1907 resourceParams.bIsWritable = true;
1908
1909 InitMocsParams(resourceParams, &cmd.TileStatisticsStreamoutBufferAddressAttributes.DW0.Value, 1, 6);
1910
1911 MHW_MI_CHK_STATUS(AddResourceToCmd(
1912 this->m_osItf,
1913 this->m_currentCmdBuf,
1914 &resourceParams));
1915 }
1916
1917 // CU Streamout Buffer
1918 if (!Mos_ResourceIsNull(params.cuStreamoutBuffer))
1919 {
1920 resourceParams.presResource = params.cuStreamoutBuffer;
1921 resourceParams.dwOffset = 0;
1922 resourceParams.pdwCmd = (cmd.CUStreamoutBufferAddress.DW0_1.Value);
1923 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(CUStreamoutBufferAddress);
1924 resourceParams.bIsWritable = true;
1925
1926 InitMocsParams(resourceParams, &cmd.CUStreamoutBufferAddressAttributes.DW0.Value, 1, 6);
1927
1928 MHW_MI_CHK_STATUS(AddResourceToCmd(
1929 this->m_osItf,
1930 this->m_currentCmdBuf,
1931 &resourceParams));
1932 }
1933
1934 // SSE Line Read / Write Buffer
1935 if (!Mos_ResourceIsNull(params.sseLineBuffer))
1936 {
1937 resourceParams.presResource = params.sseLineBuffer;
1938 resourceParams.dwOffset = 0;
1939 resourceParams.pdwCmd = (cmd.SSELineReadWriteBufferAddress.DW0_1.Value);
1940 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SSELineReadWriteBufferAddress);
1941 resourceParams.bIsWritable = true;
1942
1943 InitMocsParams(resourceParams, &cmd.SSELineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1944
1945 MHW_MI_CHK_STATUS(AddResourceToCmd(
1946 this->m_osItf,
1947 this->m_currentCmdBuf,
1948 &resourceParams));
1949 }
1950
1951 // SSE Tile Line Read/Write Buffer
1952 if (!Mos_ResourceIsNull(params.sseTileLineBuffer))
1953 {
1954 resourceParams.presResource = params.sseTileLineBuffer;
1955 resourceParams.dwOffset = 0;
1956 resourceParams.pdwCmd = (cmd.SSETileLineReadWriteBufferAddress.DW0_1.Value);
1957 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(SSETileLineReadWriteBufferAddress);
1958 resourceParams.bIsWritable = true;
1959
1960 InitMocsParams(resourceParams, &cmd.SSETileLineReadWriteBufferAddressAttributes.DW0.Value, 1, 6);
1961
1962 MHW_MI_CHK_STATUS(AddResourceToCmd(
1963 this->m_osItf,
1964 this->m_currentCmdBuf,
1965 &resourceParams));
1966 }
1967
1968 // PostCDEF pixels Buffer
1969 if (params.postCDEFpixelsBuffer != nullptr)
1970 {
1971 cmd.PostCDEFpixelsBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnabled(params.postCdefSurfMmcState);
1972 cmd.PostCDEFpixelsBufferAddressAttributes.DW0.CompressionType = MmcRcEnabled(params.postCdefSurfMmcState);
1973 cmd.PostCDEFpixelsBufferAddressAttributes.DW0.TileMode = GetHwTileType(params.postCDEFpixelsBuffer->TileType,
1974 params.postCDEFpixelsBuffer->TileModeGMM,
1975 params.postCDEFpixelsBuffer->bGMMTileEnabled);
1976
1977 resourceParams.presResource = &params.postCDEFpixelsBuffer->OsResource;
1978 resourceParams.dwOffset = 0;
1979 resourceParams.pdwCmd = (cmd.PostCDEFpixelsBufferAddress.DW0_1.Value);
1980 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(PostCDEFpixelsBufferAddress);
1981 resourceParams.bIsWritable = true;
1982
1983 InitMocsParams(resourceParams, &cmd.PostCDEFpixelsBufferAddressAttributes.DW0.Value, 1, 6);
1984
1985 MHW_MI_CHK_STATUS(AddResourceToCmd(
1986 this->m_osItf,
1987 this->m_currentCmdBuf,
1988 &resourceParams));
1989 }
1990
1991 return MOS_STATUS_SUCCESS;
1992 }
1993
1994 _MHW_SETCMD_OVERRIDE_DECL(AVP_INTER_PRED_STATE)
1995 {
1996 _MHW_SETCMD_CALLBASE(AVP_INTER_PRED_STATE);
1997
1998 #define DO_FIELDS() \
1999 DO_FIELD(DW1, SavedOrderHintsForAllReferences00, params.savedRefOrderHints[0][0]); \
2000 DO_FIELD(DW1, SavedOrderHintsForAllReferences01, params.savedRefOrderHints[0][1]); \
2001 DO_FIELD(DW1, SavedOrderHintsForAllReferences02, params.savedRefOrderHints[0][2]); \
2002 DO_FIELD(DW1, SavedOrderHintsForAllReferences03, params.savedRefOrderHints[0][3]); \
2003 \
2004 DO_FIELD(DW2, SavedOrderHintsForAllReferences04, params.savedRefOrderHints[0][4]); \
2005 DO_FIELD(DW2, SavedOrderHintsForAllReferences05, params.savedRefOrderHints[0][5]); \
2006 DO_FIELD(DW2, SavedOrderHintsForAllReferences06, params.savedRefOrderHints[0][6]); \
2007 DO_FIELD(DW2, ActiveReferenceBitmaskForMotionFieldProjection, params.refMaskMfProj); \
2008 \
2009 DO_FIELD(DW3, SavedOrderHintsForAllReferences10, params.savedRefOrderHints[1][0]); \
2010 DO_FIELD(DW3, SavedOrderHintsForAllReferences11, params.savedRefOrderHints[1][1]); \
2011 DO_FIELD(DW3, SavedOrderHintsForAllReferences12, params.savedRefOrderHints[1][2]); \
2012 DO_FIELD(DW3, SavedOrderHintsForAllReferences13, params.savedRefOrderHints[1][3]); \
2013 \
2014 DO_FIELD(DW4, SavedOrderHintsForAllReferences14, params.savedRefOrderHints[1][4]); \
2015 DO_FIELD(DW4, SavedOrderHintsForAllReferences15, params.savedRefOrderHints[1][5]); \
2016 DO_FIELD(DW4, SavedOrderHintsForAllReferences16, params.savedRefOrderHints[1][6]); \
2017 \
2018 DO_FIELD(DW5, SavedOrderHintsForAllReferences20, params.savedRefOrderHints[2][0]); \
2019 DO_FIELD(DW5, SavedOrderHintsForAllReferences21, params.savedRefOrderHints[2][1]); \
2020 DO_FIELD(DW5, SavedOrderHintsForAllReferences22, params.savedRefOrderHints[2][2]); \
2021 DO_FIELD(DW5, SavedOrderHintsForAllReferences23, params.savedRefOrderHints[2][3]); \
2022 \
2023 DO_FIELD(DW6, SavedOrderHintsForAllReferences24, params.savedRefOrderHints[2][4]); \
2024 DO_FIELD(DW6, SavedOrderHintsForAllReferences25, params.savedRefOrderHints[2][5]); \
2025 DO_FIELD(DW6, SavedOrderHintsForAllReferences26, params.savedRefOrderHints[2][6]); \
2026 \
2027 DO_FIELD(DW7, SavedOrderHintsForAllReferences30, params.savedRefOrderHints[3][0]); \
2028 DO_FIELD(DW7, SavedOrderHintsForAllReferences31, params.savedRefOrderHints[3][1]); \
2029 DO_FIELD(DW7, SavedOrderHintsForAllReferences32, params.savedRefOrderHints[3][2]); \
2030 DO_FIELD(DW7, SavedOrderHintsForAllReferences33, params.savedRefOrderHints[3][3]); \
2031 \
2032 DO_FIELD(DW8, SavedOrderHintsForAllReferences34, params.savedRefOrderHints[3][4]); \
2033 DO_FIELD(DW8, SavedOrderHintsForAllReferences35, params.savedRefOrderHints[3][5]); \
2034 DO_FIELD(DW8, SavedOrderHintsForAllReferences36, params.savedRefOrderHints[3][6]); \
2035 \
2036 DO_FIELD(DW9, SavedOrderHintsForAllReferences40, params.savedRefOrderHints[4][0]); \
2037 DO_FIELD(DW9, SavedOrderHintsForAllReferences41, params.savedRefOrderHints[4][1]); \
2038 DO_FIELD(DW9, SavedOrderHintsForAllReferences42, params.savedRefOrderHints[4][2]); \
2039 DO_FIELD(DW9, SavedOrderHintsForAllReferences43, params.savedRefOrderHints[4][3]); \
2040 \
2041 DO_FIELD(DW10, SavedOrderHintsForAllReferences44, params.savedRefOrderHints[4][4]); \
2042 DO_FIELD(DW10, SavedOrderHintsForAllReferences45, params.savedRefOrderHints[4][5]); \
2043 DO_FIELD(DW10, SavedOrderHintsForAllReferences46, params.savedRefOrderHints[4][6]); \
2044 \
2045 DO_FIELD(DW11, SavedOrderHintsForAllReferences50, params.savedRefOrderHints[5][0]); \
2046 DO_FIELD(DW11, SavedOrderHintsForAllReferences51, params.savedRefOrderHints[5][1]); \
2047 DO_FIELD(DW11, SavedOrderHintsForAllReferences52, params.savedRefOrderHints[5][2]); \
2048 DO_FIELD(DW11, SavedOrderHintsForAllReferences53, params.savedRefOrderHints[5][3]); \
2049 \
2050 DO_FIELD(DW12, SavedOrderHintsForAllReferences54, params.savedRefOrderHints[5][4]); \
2051 DO_FIELD(DW12, SavedOrderHintsForAllReferences55, params.savedRefOrderHints[5][5]); \
2052 DO_FIELD(DW12, SavedOrderHintsForAllReferences56, params.savedRefOrderHints[5][6]); \
2053 \
2054 DO_FIELD(DW13, SavedOrderHintsForAllReferences60, params.savedRefOrderHints[6][0]); \
2055 DO_FIELD(DW13, SavedOrderHintsForAllReferences61, params.savedRefOrderHints[6][1]); \
2056 DO_FIELD(DW13, SavedOrderHintsForAllReferences62, params.savedRefOrderHints[6][2]); \
2057 DO_FIELD(DW13, SavedOrderHintsForAllReferences63, params.savedRefOrderHints[6][3]); \
2058 \
2059 DO_FIELD(DW14, SavedOrderHintsForAllReferences64, params.savedRefOrderHints[6][4]); \
2060 DO_FIELD(DW14, SavedOrderHintsForAllReferences65, params.savedRefOrderHints[6][5]); \
2061 DO_FIELD(DW14, SavedOrderHintsForAllReferences66, params.savedRefOrderHints[6][6])
2062
2063 #include "mhw_hwcmd_process_cmdfields.h"
2064 }
2065
2066 _MHW_SETCMD_OVERRIDE_DECL(AVP_IND_OBJ_BASE_ADDR_STATE)
2067 {
2068 _MHW_SETCMD_CALLBASE(AVP_IND_OBJ_BASE_ADDR_STATE);
2069
2070 MHW_RESOURCE_PARAMS resourceParams = {};
2071
2072 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
2073 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
2074
2075 if (!Mos_ResourceIsNull(params.dataBuffer))
2076 {
2077 resourceParams.presResource = params.dataBuffer;
2078 resourceParams.dwOffset = params.dataOffset;
2079 resourceParams.pdwCmd = &(cmd.AvpIndirectBitstreamObjectBaseAddress.DW0_1.Value[0]);
2080 resourceParams.dwLocationInCmd = 1;
2081 resourceParams.dwSize = params.dataSize;
2082 resourceParams.bIsWritable = false;
2083
2084 // upper bound of the allocated resource will be set at 3 DW apart from address location
2085 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
2086
2087 InitMocsParams(resourceParams, &cmd.AvpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value, 1, 6);
2088
2089 MHW_MI_CHK_STATUS(AddResourceToCmd(
2090 this->m_osItf,
2091 this->m_currentCmdBuf,
2092 &resourceParams));
2093
2094 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
2095 }
2096
2097 if (!Mos_ResourceIsNull(params.pakBaseObjectBuffer))
2098 {
2099 resourceParams.presResource = params.pakBaseObjectBuffer;
2100 resourceParams.dwOffset = params.pakBaseObjectOffset;
2101 resourceParams.pdwCmd = &(cmd.AvpIndirectBitstreamObjectBaseAddress.DW0_1.Value[0]);
2102 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AvpIndirectBitstreamObjectBaseAddress);
2103 resourceParams.dwSize = MOS_ALIGN_FLOOR(params.pakBaseObjectSize, PAGE_SIZE);
2104 resourceParams.bIsWritable = true;
2105 // upper bound of the allocated resource will be set at 3 DW apart from address location
2106 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
2107
2108 InitMocsParams(resourceParams, &cmd.AvpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value, 1, 6);
2109
2110 MHW_MI_CHK_STATUS(AddResourceToCmd(
2111 this->m_osItf,
2112 this->m_currentCmdBuf,
2113 &resourceParams));
2114 }
2115
2116 if (!Mos_ResourceIsNull(params.mvObjectBuffer))
2117 {
2118 resourceParams.presResource = params.mvObjectBuffer;
2119 resourceParams.dwOffset = params.mvObjectOffset;
2120 resourceParams.pdwCmd = &(cmd.AvpIndirectCuObjectBaseAddress.DW0_1.Value[0]);
2121 resourceParams.dwLocationInCmd = _MHW_CMD_DW_LOCATION(AvpIndirectCuObjectBaseAddress);
2122 resourceParams.dwSize = MOS_ALIGN_CEIL(params.mvObjectSize, PAGE_SIZE);
2123 resourceParams.bIsWritable = false;
2124
2125 // no upper bound for indirect CU object
2126 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
2127
2128 InitMocsParams(resourceParams, &cmd.AvpIndirectCuObjectMemoryAddressAttributes.DW0.Value, 1, 6);
2129
2130 MHW_MI_CHK_STATUS(AddResourceToCmd(
2131 this->m_osItf,
2132 this->m_currentCmdBuf,
2133 &resourceParams));
2134 }
2135
2136 return MOS_STATUS_SUCCESS;
2137 }
2138
2139 _MHW_SETCMD_OVERRIDE_DECL(AVP_SURFACE_STATE)
2140 {
2141 _MHW_SETCMD_CALLBASE(AVP_SURFACE_STATE);
2142
2143 #define DO_FIELDS() \
2144 DO_FIELD(DW1, SurfaceId, params.surfaceStateId); \
2145 DO_FIELD(DW1, SurfacePitchMinus1, params.pitch - 1); \
2146 \
2147 DO_FIELD(DW2, SurfaceFormat, static_cast<uint32_t>(params.srcFormat)); \
2148 DO_FIELD(DW2, YOffsetForUCbInPixel, params.uOffset); \
2149 DO_FIELD(DW3, YOffsetForVCr, params.vOffset); \
2150 \
2151 DO_FIELD(DW4, CompressionFormat, params.compressionFormat)
2152
2153 #include "mhw_hwcmd_process_cmdfields.h"
2154 }
2155
2156 _MHW_SETCMD_OVERRIDE_DECL(AVP_BSD_OBJECT)
2157 {
2158 _MHW_SETCMD_CALLBASE(AVP_BSD_OBJECT);
2159
2160 #define DO_FIELDS() \
2161 DO_FIELD(DW1, TileIndirectBsdDataLength, params.bsdDataLength); \
2162 DO_FIELD(DW2, TileIndirectDataStartAddress, params.bsdDataStartOffset)
2163
2164 #include "mhw_hwcmd_process_cmdfields.h"
2165 }
2166
2167 _MHW_SETCMD_OVERRIDE_DECL(AVP_PAK_INSERT_OBJECT)
2168 {
2169 _MHW_SETCMD_CALLBASE(AVP_PAK_INSERT_OBJECT);
2170
2171 uint32_t dwordsUsed = cmd.dwSize;
2172
2173 uint32_t byteSize = (params.bitSize + 7) >> 3;
2174 uint32_t dataBitsInLastDw = params.bitSize % 32;
2175 if (dataBitsInLastDw == 0)
2176 {
2177 dataBitsInLastDw = 32;
2178 }
2179
2180 dwordsUsed += (MOS_ALIGN_CEIL(byteSize, sizeof(uint32_t))) / sizeof(uint32_t);
2181
2182 #define DO_FIELDS() \
2183 DO_FIELD(DW0, DwordLength, OP_LENGTH(dwordsUsed)); \
2184 \
2185 DO_FIELD(DW1, EndofsliceflagLastdstdatainsertcommandflag, params.endOfHeaderInsertion ? 1 : 0); \
2186 DO_FIELD(DW1, LastheaderflagLastsrcheaderdatainsertcommandflag, params.lastHeader ? 1 : 0); \
2187 DO_FIELD(DW1, DatabitsinlastdwSrcdataendingbitinclusion50, dataBitsInLastDw); \
2188 DO_FIELD(DW1, DatabyteoffsetSrcdatastartingbyteoffset10, 0); \
2189 DO_FIELD(DW1, IndirectPayloadEnable, 0)
2190
2191 #include "mhw_hwcmd_process_cmdfields.h"
2192 }
2193 MEDIA_CLASS_DEFINE_END(mhw__vdbox__avp__Impl)
2194 };
2195 } // namespace avp
2196 } // namespace vdbox
2197 } // namespace mhw
2198
2199 #endif // __MHW_VDBOX_AVP_IMPL_H__