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_g12_X.cpp
24 //! \brief Constructs VdBox AVP commands on Gen12-based platforms
25
26 #include "mhw_vdbox_avp_g12_X.h"
27 #include "mhw_mi_hwcmd_g12_X.h"
28 #include "mhw_vdbox_vdenc_hwcmd_g12_X.h"
29
~MhwVdboxAvpInterfaceG12()30 MhwVdboxAvpInterfaceG12::~MhwVdboxAvpInterfaceG12()
31 {
32 MHW_FUNCTION_ENTER;
33
34 #if (_DEBUG || _RELEASE_INTERNAL)
35 MOS_USER_FEATURE_VALUE_WRITE_DATA UserFeatureWriteData = __NULL_USER_FEATURE_VALUE_WRITE_DATA__;
36 UserFeatureWriteData.ValueID = __MEDIA_USER_FEATURE_VALUE_IS_CODEC_ROW_STORE_CACHE_ENABLED_ID;
37 if (m_btdlRowstoreCache.bEnabled ||
38 m_smvlRowstoreCache.bEnabled ||
39 m_ipdlRowstoreCache.bEnabled ||
40 m_dflyRowstoreCache.bEnabled ||
41 m_dfluRowstoreCache.bEnabled ||
42 m_dflvRowstoreCache.bEnabled ||
43 m_cdefRowstoreCache.bEnabled)
44 {
45 UserFeatureWriteData.Value.i32Data = 1;
46 }
47 MOS_UserFeature_WriteValues_ID(nullptr, &UserFeatureWriteData, 1, m_osInterface->pOsContext);
48 #endif
49
50 }
51
InitRowstoreUserFeatureSettings()52 void MhwVdboxAvpInterfaceG12::InitRowstoreUserFeatureSettings()
53 {
54 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
55
56 memset(&userFeatureData, 0, sizeof(userFeatureData));
57 if (m_osInterface->bSimIsActive)
58 {
59 userFeatureData.u32Data = 1;
60 }
61 else
62 {
63 userFeatureData.u32Data = 0;
64 }
65
66 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
67 #if (_DEBUG || _RELEASE_INTERNAL)
68 MOS_UserFeature_ReadValue_ID(
69 nullptr,
70 __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
71 &userFeatureData,
72 m_osInterface->pOsContext);
73 #endif // _DEBUG || _RELEASE_INTERNAL
74 m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;
75
76 if (m_rowstoreCachingSupported)
77 {
78 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
79 #if (_DEBUG || _RELEASE_INTERNAL)
80 MOS_UserFeature_ReadValue_ID(
81 nullptr,
82 __MEDIA_USER_FEATURE_VALUE_AV1BTDLROWSTORECACHE_DISABLE_ID,
83 &userFeatureData,
84 m_osInterface->pOsContext);
85 #endif // _DEBUG || _RELEASE_INTERNAL
86 m_btdlRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
87
88 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
89 #if (_DEBUG || _RELEASE_INTERNAL)
90 MOS_UserFeature_ReadValue_ID(
91 nullptr,
92 __MEDIA_USER_FEATURE_VALUE_AV1SMVLROWSTORECACHE_DISABLE_ID,
93 &userFeatureData,
94 m_osInterface->pOsContext);
95 #endif // _DEBUG || _RELEASE_INTERNAL
96 m_smvlRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
97
98 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
99 #if (_DEBUG || _RELEASE_INTERNAL)
100 MOS_UserFeature_ReadValue_ID(
101 nullptr,
102 __MEDIA_USER_FEATURE_VALUE_AV1IPDLROWSTORECACHE_DISABLE_ID,
103 &userFeatureData,
104 m_osInterface->pOsContext);
105 #endif // _DEBUG || _RELEASE_INTERNAL
106 m_ipdlRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
107 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
108 #if (_DEBUG || _RELEASE_INTERNAL)
109 MOS_UserFeature_ReadValue_ID(
110 nullptr,
111 __MEDIA_USER_FEATURE_VALUE_AV1DFLYROWSTORECACHE_DISABLE_ID,
112 &userFeatureData,
113 m_osInterface->pOsContext);
114 #endif // _DEBUG || _RELEASE_INTERNAL
115 m_dflyRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
116
117 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
118 #if (_DEBUG || _RELEASE_INTERNAL)
119 MOS_UserFeature_ReadValue_ID(
120 nullptr,
121 __MEDIA_USER_FEATURE_VALUE_AV1DFLUROWSTORECACHE_DISABLE_ID,
122 &userFeatureData,
123 m_osInterface->pOsContext);
124 #endif // _DEBUG || _RELEASE_INTERNAL
125 m_dfluRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
126
127 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
128 #if (_DEBUG || _RELEASE_INTERNAL)
129 MOS_UserFeature_ReadValue_ID(
130 nullptr,
131 __MEDIA_USER_FEATURE_VALUE_AV1DFLVROWSTORECACHE_DISABLE_ID,
132 &userFeatureData,
133 m_osInterface->pOsContext);
134 #endif // _DEBUG || _RELEASE_INTERNAL
135 m_dflvRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
136
137 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
138 #if (_DEBUG || _RELEASE_INTERNAL)
139 MOS_UserFeature_ReadValue_ID(
140 nullptr,
141 __MEDIA_USER_FEATURE_VALUE_AV1CDEFROWSTORECACHE_DISABLE_ID,
142 &userFeatureData,
143 m_osInterface->pOsContext);
144 #endif // _DEBUG || _RELEASE_INTERNAL
145 m_cdefRowstoreCache.bSupported = userFeatureData.i32Data ? false : true;
146 }
147 }
148
GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)149 MOS_STATUS MhwVdboxAvpInterfaceG12::GetRowstoreCachingAddrs(
150 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
151 {
152 MHW_FUNCTION_ENTER;
153
154 MHW_MI_CHK_NULL(rowstoreParams);
155
156 //BTDL
157 if (m_btdlRowstoreCache.bSupported)
158 {
159 m_btdlRowstoreCache.bEnabled = true;
160 m_btdlRowstoreCache.dwAddress = 0;
161 }
162
163 //SMVL
164 if (m_smvlRowstoreCache.bSupported)
165 {
166 m_smvlRowstoreCache.bEnabled = true;
167 m_smvlRowstoreCache.dwAddress = 128;
168 }
169
170 //IPDL
171 if (m_ipdlRowstoreCache.bSupported)
172 {
173 m_ipdlRowstoreCache.bEnabled = true;
174 m_ipdlRowstoreCache.dwAddress = 384;
175 }
176
177 //DFLY
178 if (m_dflyRowstoreCache.bSupported)
179 {
180 m_dflyRowstoreCache.bEnabled = true;
181 m_dflyRowstoreCache.dwAddress = 640;
182 }
183
184 //DFLU
185 if (m_dfluRowstoreCache.bSupported)
186 {
187 m_dfluRowstoreCache.bEnabled = true;
188 m_dfluRowstoreCache.dwAddress = 1344;
189 }
190
191 //DFLV
192 if (m_dflvRowstoreCache.bSupported)
193 {
194 m_dflvRowstoreCache.bEnabled = true;
195 m_dflvRowstoreCache.dwAddress = 1536;
196 }
197
198 //CDEF
199 if (m_cdefRowstoreCache.bSupported)
200 {
201 m_cdefRowstoreCache.bEnabled = true;
202 m_cdefRowstoreCache.dwAddress = 1728;
203 }
204
205 return MOS_STATUS_SUCCESS;
206 }
207
GetAvpStateCommandSize(uint32_t * commandsSize,uint32_t * patchListSize,PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)208 MOS_STATUS MhwVdboxAvpInterfaceG12::GetAvpStateCommandSize(
209 uint32_t *commandsSize,
210 uint32_t *patchListSize,
211 PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
212 {
213 MHW_FUNCTION_ENTER;
214
215 MHW_MI_CHK_NULL(commandsSize);
216 MHW_MI_CHK_NULL(patchListSize);
217
218 uint32_t maxSize = 0;
219 uint32_t patchListMaxSize = 0;
220
221 maxSize =
222 mhw_vdbox_vdenc_g12_X::VD_PIPELINE_FLUSH_CMD::byteSize +
223 mhw_mi_g12_X::MI_FLUSH_DW_CMD::byteSize +
224 mhw_vdbox_avp_g12_X::AVP_PIPE_MODE_SELECT_CMD::byteSize +
225 mhw_vdbox_avp_g12_X::AVP_SURFACE_STATE_CMD::byteSize * 11 +
226 mhw_vdbox_avp_g12_X::AVP_PIPE_BUF_ADDR_STATE_CMD::byteSize +
227 mhw_vdbox_avp_g12_X::AVP_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
228 mhw_vdbox_avp_g12_X::AVP_SEGMENT_STATE_CMD::byteSize * 8 +
229 mhw_vdbox_avp_g12_X::AVP_INLOOP_FILTER_STATE_CMD::byteSize +
230 mhw_vdbox_avp_g12_X::AVP_INTER_PRED_STATE_CMD::byteSize;
231
232 patchListMaxSize =
233 PATCH_LIST_COMMAND(VD_PIPELINE_FLUSH_CMD) +
234 PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) +
235 PATCH_LIST_COMMAND(AVP_PIPE_MODE_SELECT_CMD) +
236 PATCH_LIST_COMMAND(AVP_SURFACE_STATE_CMD) * 11 +
237 PATCH_LIST_COMMAND(AVP_PIPE_BUF_ADDR_STATE_CMD) +
238 PATCH_LIST_COMMAND(AVP_IND_OBJ_BASE_ADDR_STATE_CMD) +
239 PATCH_LIST_COMMAND(AVP_SEGMENT_STATE_CMD) * 8 +
240 PATCH_LIST_COMMAND(AVP_INTER_PRED_STATE_CMD) +
241 PATCH_LIST_COMMAND(AVP_INLOOP_FILTER_STATE_CMD);
242
243 if(m_decodeInUse)
244 {
245 maxSize +=
246 mhw_vdbox_avp_g12_X::AVP_PIC_STATE_CMD::byteSize +
247 mhw_mi_g12_X::VD_CONTROL_STATE_CMD::byteSize * 2;
248
249 patchListMaxSize += PATCH_LIST_COMMAND(AVP_PIC_STATE_CMD);
250
251 MHW_CHK_NULL_RETURN(params);
252 auto paramsG12 = dynamic_cast<PMHW_VDBOX_STATE_CMDSIZE_PARAMS_G12>(params);
253 MHW_CHK_NULL_RETURN(paramsG12);
254 if (paramsG12->bScalableMode)
255 {
256 // VD_CONTROL_STATE AVP lock and unlock
257 maxSize += 2 * mhw_mi_g12_X::VD_CONTROL_STATE_CMD::byteSize;
258 }
259 }
260
261 *commandsSize = maxSize;
262 *patchListSize = patchListMaxSize;
263
264 return MOS_STATUS_SUCCESS;
265 }
266
GetAvpPrimitiveCommandSize(uint32_t * commandsSize,uint32_t * patchListSize)267 MOS_STATUS MhwVdboxAvpInterfaceG12::GetAvpPrimitiveCommandSize(
268 uint32_t *commandsSize,
269 uint32_t *patchListSize)
270 {
271 MHW_FUNCTION_ENTER;
272
273 MHW_MI_CHK_NULL(commandsSize);
274 MHW_MI_CHK_NULL(patchListSize);
275
276 uint32_t maxSize = 0;
277 uint32_t patchListMaxSize = 0;
278
279 if(m_decodeInUse)
280 {
281 if (MEDIA_IS_SKU(m_osInterface->pfnGetSkuTable(m_osInterface), FtrAV1VLDLSTDecoding) && !m_disableLstCmd)
282 {
283 maxSize =
284 mhw_vdbox_avp_g12_X::AVP_TILE_CODING_CMD_LST::byteSize +
285 mhw_vdbox_avp_g12_X::AVP_BSD_OBJECT_CMD::byteSize +
286 mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
287
288 patchListMaxSize =
289 PATCH_LIST_COMMAND(AVP_TILE_CODING_CMD_LST) +
290 PATCH_LIST_COMMAND(AVP_BSD_OBJECT_CMD);
291 }
292 else
293 {
294 maxSize =
295 mhw_vdbox_avp_g12_X::AVP_TILE_CODING_CMD::byteSize +
296 mhw_vdbox_avp_g12_X::AVP_BSD_OBJECT_CMD::byteSize +
297 mhw_mi_g12_X::MI_BATCH_BUFFER_END_CMD::byteSize;
298
299 patchListMaxSize =
300 PATCH_LIST_COMMAND(AVP_TILE_CODING_CMD) +
301 PATCH_LIST_COMMAND(AVP_BSD_OBJECT_CMD);
302 }
303 }
304
305 *commandsSize = maxSize;
306 *patchListSize = patchListMaxSize;
307
308 return MOS_STATUS_SUCCESS;
309 }
310
GetAv1BufferSize(MhwVdboxAvpInternalBufferType bufferType,MhwVdboxAvpBufferSizeParams * avpBufSizeParam)311 MOS_STATUS MhwVdboxAvpInterfaceG12::GetAv1BufferSize(
312 MhwVdboxAvpInternalBufferType bufferType,
313 MhwVdboxAvpBufferSizeParams *avpBufSizeParam)
314 {
315 MHW_FUNCTION_ENTER;
316
317 MHW_MI_CHK_NULL(avpBufSizeParam);
318
319 uint32_t sbPerFrmWid = avpBufSizeParam->m_picWidth;
320 uint32_t sbPerFrmHgt = avpBufSizeParam->m_picHeight;
321 uint32_t sbPerTileWid = avpBufSizeParam->m_tileWidth;
322 uint32_t bufferSize = 0;
323 uint32_t totalSbPerFrame = sbPerFrmWid * sbPerFrmHgt;
324 uint32_t index = (uint32_t)bufferType;
325 uint32_t maxCuPerSB = avpBufSizeParam->m_isSb128x128 ? 256 : 64;
326
327 MHW_ASSERT(avpBufSizeParam->m_bitDepthIdc == 0 || avpBufSizeParam->m_bitDepthIdc == 1);
328
329 switch (bufferType)
330 {
331 //Rowstore buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_tile_width)
332 case bsdLineBuf:
333 case spatialMvLineBuf:
334 case intraPredLine:
335 case deblockLineYBuf:
336 case deblockLineUBuf:
337 case deblockLineVBuf:
338 bufferSize = sbPerTileWid * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128];
339 break;
340 case cdefLineBuf:
341 bufferSize = sbPerTileWid * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128]
342 + CodecAv1BufferSizeExt[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128];
343 break;
344 //Tile storage - tile line buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_row) = (#CLs_per_SB * num_of_SB_per_frame_width)
345 case bsdTileLineBuf:
346 case spatialMvTileLineBuf:
347 case intraPredTileLine:
348 case deblockTileLineYBuf:
349 case deblockTileLineUBuf:
350 case deblockTileLineVBuf:
351 bufferSize = sbPerFrmWid * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128];
352 break;
353 //Tile storage - tile column buffers, Total CLs = (#CLs_per_SB * num_of_SB_per_column) = (#CLs_per_SB * num_of_SB_per_frame_height)
354 case deblockTileColYBuf:
355 case deblockTileColUBuf:
356 case deblockTileColVBuf:
357 bufferSize = sbPerFrmHgt * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128];
358 break;
359 // Tile storage, per tile number
360 case cdefTopLeftCornerBuf:
361 bufferSize = avpBufSizeParam->m_curFrameTileNum;
362 break;
363 case cdefMetaTileLine:
364 bufferSize = avpBufSizeParam->m_numTileCol;
365 break;
366 case lrTileLineY:
367 bufferSize = avpBufSizeParam->m_numTileCol * 7;
368 break;
369 case lrTileLineU:
370 case lrTileLineV:
371 bufferSize = avpBufSizeParam->m_numTileCol * 5;
372 break;
373 // Tile storage, - tile line buffers, with extra size
374 case cdefTileLineBuf:
375 bufferSize = sbPerFrmWid * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128]
376 + CodecAv1BufferSizeExt[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128];
377 break;
378 // Tile storage, - tile column buffers, with extra size
379 case cdefTileColBuf:
380 case cdefMetaTileCol:
381 case superResTileColYBuf:
382 case superResTileColUBuf:
383 case superResTileColVBuf:
384 case lrTileColYBuf:
385 case lrTileColUBuf:
386 case lrTileColVBuf:
387 case lrMetaTileCol:
388 bufferSize = sbPerFrmHgt * CodecAv1BufferSize[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128]
389 + CodecAv1BufferSizeExt[index][avpBufSizeParam->m_bitDepthIdc][avpBufSizeParam->m_isSb128x128]
390 + MOS_PAGE_SIZE; //Add one page size here to fix page fault issue
391 break;
392 //frame buffer
393 case segmentIdBuf:
394 bufferSize = ((avpBufSizeParam->m_isSb128x128)? 8 : 2) * totalSbPerFrame;
395 break;
396 case mvTemporalBuf:
397 bufferSize = ((avpBufSizeParam->m_isSb128x128) ? 16 : 4) * totalSbPerFrame;
398 break;
399 case frameStatusErrBuf:
400 case dbdStreamoutBuf:
401 bufferSize = 1;
402 break;
403 case tileSzStreamOutBuf:
404 bufferSize = avpBufSizeParam->m_numTileCol * avpBufSizeParam->m_numTileCol * MHW_CACHELINE_SIZE;
405 break;
406 case tileStatStreamOutBuf:
407 bufferSize = 512;
408 break;
409 case cuStreamoutBuf:
410 bufferSize = MOS_ALIGN_CEIL(totalSbPerFrame * maxCuPerSB * 8, MHW_CACHELINE_SIZE); // Each CU streams out 8 bytes
411 break;
412 case sseLineBuf:
413 case sseTileLineBuf:
414 if (avpBufSizeParam->m_numOfActivePipes > 1)
415 {
416 // To be added for scalability case
417 }
418 else
419 {
420 bufferSize = (sbPerFrmWid + 3) * MHW_CACHELINE_SIZE * (8 + 8) << 1; // 8 for Luma, 8 for Chroma
421 }
422 break;
423 default:
424 return MOS_STATUS_INVALID_PARAMETER;
425
426 }
427
428 avpBufSizeParam->m_bufferSize = bufferSize * MHW_CACHELINE_SIZE;
429
430 return MOS_STATUS_SUCCESS;
431 }
432
IsAv1BufferReallocNeeded(MhwVdboxAvpInternalBufferType bufferType,MhwVdboxAvpBufferReallocParams * reallocParam)433 MOS_STATUS MhwVdboxAvpInterfaceG12::IsAv1BufferReallocNeeded(
434 MhwVdboxAvpInternalBufferType bufferType,
435 MhwVdboxAvpBufferReallocParams *reallocParam)
436 {
437 MHW_FUNCTION_ENTER;
438
439 MHW_MI_CHK_NULL(reallocParam);
440
441 uint32_t widthInSb, heightInSb, picWidthInSbAlloced, picHeightInSbAlloced;
442 bool realloc = false;
443
444 MHW_MI_CHK_NULL(reallocParam);
445
446 widthInSb = reallocParam->m_picWidth;
447 heightInSb = reallocParam->m_picHeight;
448 picWidthInSbAlloced = reallocParam->m_picWidthAlloced;
449 picHeightInSbAlloced = reallocParam->m_picHeightAlloced;
450
451 uint32_t sbPerTileWid = reallocParam->m_tileWidth;
452 MHW_ASSERT(reallocParam->m_bitDepthIdc == 0 || reallocParam->m_bitDepthIdc == 1);
453
454 uint32_t index = (uint32_t)bufferType;
455 uint32_t prevSize, curSize;
456 switch (bufferType)
457 {
458 //Rowstore buffers, size per SB
459 case bsdLineBuf:
460 case spatialMvLineBuf:
461 case intraPredLine:
462 case deblockLineYBuf:
463 case deblockLineUBuf:
464 case deblockLineVBuf:
465 case cdefLineBuf:
466 realloc = false;
467 break;
468 //Tile storage - tile line buffer
469 case bsdTileLineBuf:
470 case spatialMvTileLineBuf:
471 case intraPredTileLine:
472 case deblockTileLineYBuf:
473 case deblockTileLineUBuf:
474 case deblockTileLineVBuf:
475 case cdefTileLineBuf:
476 realloc = (widthInSb > picWidthInSbAlloced);
477 break;
478 // Tile storage - tile column buffer
479 case deblockTileColYBuf:
480 case deblockTileColUBuf:
481 case deblockTileColVBuf:
482 case cdefTileColBuf:
483 case cdefMetaTileCol:
484 case superResTileColYBuf:
485 case superResTileColUBuf:
486 case superResTileColVBuf:
487 case lrTileColYBuf:
488 case lrTileColUBuf:
489 case lrTileColVBuf:
490 case lrMetaTileCol:
491 realloc = (heightInSb > picHeightInSbAlloced);
492 break;
493 // Tile storage, per tile number
494 case cdefTopLeftCornerBuf:
495 realloc = (reallocParam->m_curFrameTileNum > reallocParam->m_prevFrameTileNum);
496 break;
497 case cdefMetaTileLine:
498 case lrTileLineY:
499 case lrTileLineU:
500 case lrTileLineV:
501 realloc = reallocParam->m_numTileCol > reallocParam->m_numTileColAllocated;
502 break;
503 //frame buffer
504 case segmentIdBuf:
505 case mvTemporalBuf:
506 realloc = (widthInSb * heightInSb) > reallocParam->m_bufferSizeAlloced;//Note: SB128/SB64 is per sequence info, driver assumes one device supports one sequence only.
507 break;
508 case frameStatusErrBuf:
509 case dbdStreamoutBuf:
510 realloc = 0;
511 break;
512 default:
513 return MOS_STATUS_INVALID_PARAMETER;
514 }
515
516 reallocParam->m_needBiggerSize = realloc;
517
518 return MOS_STATUS_SUCCESS;
519 }
520
AddAvpPipeModeSelectCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)521 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpPipeModeSelectCmd(
522 PMOS_COMMAND_BUFFER cmdBuffer,
523 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
524 {
525 MHW_FUNCTION_ENTER;
526
527 MHW_MI_CHK_NULL(params);
528
529 auto paramsG12 = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G12>(params);
530 MHW_MI_CHK_NULL(paramsG12);
531 mhw_vdbox_avp_g12_X::AVP_PIPE_MODE_SELECT_CMD cmd;
532
533 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after AVP Pipemode select...
534 MHW_MI_CHK_STATUS(m_miInterface->AddMfxWaitCmd(cmdBuffer, nullptr, true));
535
536 if (m_decodeInUse)
537 {
538 cmd.DW1.CodecSelect = cmd.CODEC_SELECT_DECODE;
539 }
540 else
541 {
542 cmd.DW1.CodecSelect = cmd.CODEC_SELECT_ENCODE;
543 }
544
545 cmd.DW1.CdefOutputStreamoutEnableFlag = false;
546 cmd.DW1.LoopRestorationOutputStreamoutEnableFlag = false;
547 cmd.DW1.PicStatusErrorReportEnable = false;
548 cmd.DW1.CodecStandardSelect = 2;
549 cmd.DW1.MultiEngineMode = paramsG12->MultiEngineMode;
550 cmd.DW1.PipeWorkingMode = paramsG12->PipeWorkMode;
551 cmd.DW1.TileBasedEngine = paramsG12->bTileBasedReplayMode;
552 cmd.DW3.PicStatusErrorReportId = false;
553 cmd.DW5.PhaseIndicator = paramsG12->ucPhaseIndicator;
554
555 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, params->pBatchBuffer, &cmd, sizeof(cmd)));
556
557 // for Gen11+, we need to add MFX wait for both KIN and VRT before and after AVP Pipemode select...
558 MHW_MI_CHK_STATUS(m_miInterface->AddMfxWaitCmd(cmdBuffer, nullptr, true));
559
560 return MOS_STATUS_SUCCESS;
561 }
562
AddAvpDecodeSurfaceStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_SURFACE_PARAMS params)563 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpDecodeSurfaceStateCmd(
564 PMOS_COMMAND_BUFFER cmdBuffer,
565 PMHW_VDBOX_SURFACE_PARAMS params)
566 {
567 MHW_MI_CHK_NULL(params);
568
569 mhw_vdbox_avp_g12_X::AVP_SURFACE_STATE_CMD *cmd =
570 (mhw_vdbox_avp_g12_X::AVP_SURFACE_STATE_CMD*)cmdBuffer->pCmdPtr;
571
572 MHW_MI_CHK_STATUS(MhwVdboxAvpInterfaceGeneric<mhw_vdbox_avp_g12_X>::AddAvpDecodeSurfaceStateCmd(cmdBuffer, params));
573
574 if (params->ucBitDepthLumaMinus8 == 0 && params->ucBitDepthChromaMinus8 == 0)
575 {
576 if (params->ChromaType == HCP_CHROMA_FORMAT_YUV420 && params->psSurface->Format == Format_NV12)// 4:2:0 8bit surface
577 {
578 cmd->DW2.SurfaceFormat = cmd->SURFACE_FORMAT_PLANAR4208;
579 }
580 else if (params->ChromaType == HCP_CHROMA_FORMAT_YUV420 && params->psSurface->Format == Format_P010)// 4:2:0 10bit surface
581 {
582 cmd->DW2.SurfaceFormat = cmd->SURFACE_FORMAT_P010;
583 }
584 else
585 {
586 return MOS_STATUS_INVALID_PARAMETER;
587 }
588 }
589 else if ((params->ucBitDepthLumaMinus8 == 2) && (params->ucBitDepthChromaMinus8 == 2))
590 {
591 if (params->ChromaType == HCP_CHROMA_FORMAT_YUV420 && params->psSurface->Format == Format_P010)// 4:2:0 10b
592 {
593 cmd->DW2.SurfaceFormat = cmd->SURFACE_FORMAT_P010;
594 }
595 else
596 {
597 return MOS_STATUS_INVALID_PARAMETER;
598 }
599 }
600 else
601 {
602 return MOS_STATUS_INVALID_PARAMETER;
603 }
604
605 cmd->DW3.DefaultAlphaValue = 0;
606
607 uint32_t DW4 = 0;
608 if(MmcEnable(params->mmcState))
609 {
610 DW4 |= ((~params->mmcSkipMask) & 0xff);
611 }
612 if(MmcIsRc(params->mmcState))
613 {
614 DW4 |= 0xff00;
615 }
616
617 cmd->DW4.Value = (DW4 | params->dwCompressionFormat << 16);
618
619 return MOS_STATUS_SUCCESS;
620 }
621
AddAvpPipeBufAddrCmd(PMOS_COMMAND_BUFFER cmdBuffer,MhwVdboxAvpPipeBufAddrParams * params)622 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpPipeBufAddrCmd(
623 PMOS_COMMAND_BUFFER cmdBuffer,
624 MhwVdboxAvpPipeBufAddrParams *params)
625 {
626 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
627
628 MHW_FUNCTION_ENTER;
629
630 MHW_MI_CHK_NULL(m_osInterface);
631 MHW_MI_CHK_NULL(cmdBuffer);
632 MHW_MI_CHK_NULL(params);
633
634 MHW_RESOURCE_PARAMS resourceParams;
635 MOS_SURFACE details;
636 mhw_vdbox_avp_g12_X::AVP_PIPE_BUF_ADDR_STATE_CMD cmd;
637
638 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
639
640 // 1. MHW_VDBOX_HCP_GENERAL_STATE_SHIFT(6) may not work with DecodedPicture
641 // since it needs to be 4k aligned
642 resourceParams.dwLsbNum = MHW_VDBOX_HCP_GENERAL_STATE_SHIFT;
643 resourceParams.HwCommandType = MOS_MFX_PIPE_BUF_ADDR;
644
645 // Reference Picture Base Address. Only one control DW17 for all references
646 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables =
647 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Gen12.Index;
648
649 bool firstRefPic = true;
650 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
651
652 // NOTE: all the 8 ref pic addresses has been set to valid addresses for error concealment purpose
653 // m_references[8] follows the order LAST_FRAME->LAST2_FRAME->LAST3_FRAME->GOLDEN_FRAME->BWDREF_FRAME->ALTREF2_FRAME->ALTREF_FRAME.
654 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++)
655 {
656 // Reference Picture Buffer
657 if (params->m_references[i] != nullptr)
658 {
659 MOS_ZeroMemory(&details, sizeof(details));
660 details.Format = Format_Invalid;
661 MHW_MI_CHK_STATUS(m_osInterface->pfnGetResourceInfo(m_osInterface, params->m_references[i], &details));
662
663 if (firstRefPic)
664 {
665 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
666 firstRefPic = false;
667 }
668
669 resourceParams.presResource = params->m_references[i];
670 resourceParams.pdwCmd = (cmd.ReferenceFrameBufferBaseAddressRefaddr07[i].DW0_1.Value);
671 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
672 resourceParams.dwLocationInCmd = (i * 2) + 1;
673 resourceParams.bIsWritable = false;
674 resourceParams.dwSharedMocsOffset = 17 - resourceParams.dwLocationInCmd;
675
676 MHW_MI_CHK_STATUS(AddResourceToCmd(
677 m_osInterface,
678 cmdBuffer,
679 &resourceParams));
680 }
681 }
682
683 //Decoded Output Frame Buffer
684 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_PRE_DEBLOCKING_CODEC].Gen12.Index;
685 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = MmcEnable(params->m_preDeblockSurfMmcState) ? 1 : 0;
686 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.CompressionType = MmcIsRc(params->m_preDeblockSurfMmcState) ? 1 : 0;
687
688 cmd.DecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressTiledResourceMode = Mhw_ConvertToTRMode(params->m_decodedPic->TileType);
689
690 //Same MMC status for deblock and reference surfaces
691 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = cmd.DecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable;
692 cmd.ReferenceFrameBufferBaseAddressAttributes.DW0.CompressionType = cmd.DecodedOutputFrameBufferAddressAttributes.DW0.CompressionType;
693
694 resourceParams.presResource = &(params->m_decodedPic->OsResource);
695 resourceParams.dwOffset = params->m_decodedPic->dwOffset;
696 resourceParams.pdwCmd = (cmd.DecodedOutputFrameBufferAddress.DW0_1.Value);
697 resourceParams.dwLocationInCmd = 18;
698 resourceParams.bIsWritable = true;
699
700 MHW_MI_CHK_STATUS(AddResourceToCmd(
701 m_osInterface,
702 cmdBuffer,
703 &resourceParams));
704
705 //IntraBC Decoded Output Frame buffer
706 if (params->m_intrabcDecodedOutputFrameBuffer != nullptr)
707 {
708 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
709
710 resourceParams.presResource = params->m_intrabcDecodedOutputFrameBuffer;
711 resourceParams.dwOffset = 0;
712 resourceParams.pdwCmd = (cmd.IntrabcDecodedOutputFrameBufferAddress.DW0_1.Value);
713 resourceParams.dwLocationInCmd = 24;
714 resourceParams.bIsWritable = true;
715
716 MHW_MI_CHK_STATUS(AddResourceToCmd(
717 m_osInterface,
718 cmdBuffer,
719 &resourceParams));
720
721 //This surface should not have memory compression turned on
722 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.BaseAddressMemoryCompressionEnable = 0;
723 cmd.IntrabcDecodedOutputFrameBufferAddressAttributes.DW0.CompressionType =0;
724 }
725
726 // CDF Table Initialization Buffer
727 if (params->m_cdfTableInitializationBuffer != nullptr)
728 {
729 cmd.CdfTablesInitializationBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
730
731 resourceParams.presResource = params->m_cdfTableInitializationBuffer;
732 resourceParams.dwOffset = 0;
733 resourceParams.pdwCmd = (cmd.CdfTablesInitializationBufferAddress.DW0_1.Value);
734 resourceParams.dwLocationInCmd = 27;
735 resourceParams.bIsWritable = false;
736
737 MHW_MI_CHK_STATUS(AddResourceToCmd(
738 m_osInterface,
739 cmdBuffer,
740 &resourceParams));
741 }
742
743 // CDF Tables Backward Adaptation Buffer
744 if (params->m_cdfTableBwdAdaptationBuffer != nullptr)
745 {
746 cmd.CdfTablesBackwardAdaptationBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
747
748 resourceParams.presResource = params->m_cdfTableBwdAdaptationBuffer;
749 resourceParams.dwOffset = 0;
750 resourceParams.pdwCmd = (cmd.CdfTablesBackwardAdaptationBufferAddress.DW0_1.Value);
751 resourceParams.dwLocationInCmd = 30;
752 resourceParams.bIsWritable = true;
753
754 MHW_MI_CHK_STATUS(AddResourceToCmd(
755 m_osInterface,
756 cmdBuffer,
757 &resourceParams));
758 }
759
760 // Reset dwSharedMocsOffset
761 //resourceParams.dwSharedMocsOffset = 0;
762
763 // AV1 Segment Id Read Buffer
764 if (params->m_segmentIdReadBuffer != nullptr)
765 {
766 cmd.Av1SegmentIdReadBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
767
768 resourceParams.presResource = params->m_segmentIdReadBuffer;
769 resourceParams.dwOffset = 0;
770 resourceParams.pdwCmd = (cmd.Av1SegmentIdReadBufferAddress.DW0_1.Value);
771 resourceParams.dwLocationInCmd = 33;
772 resourceParams.bIsWritable = true;
773
774 resourceParams.dwSharedMocsOffset = 35 - resourceParams.dwLocationInCmd;
775
776 MHW_MI_CHK_STATUS(AddResourceToCmd(
777 m_osInterface,
778 cmdBuffer,
779 &resourceParams));
780 }
781
782 // AV1 Segment Id Write Buffer
783 if (params->m_segmentIdWriteBuffer != nullptr)
784 {
785 cmd.Av1SegmentIdWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
786
787 resourceParams.presResource = params->m_segmentIdWriteBuffer;
788 resourceParams.dwOffset = 0;
789 resourceParams.pdwCmd = (cmd.Av1SegmentIdWriteBufferAddress.DW0_1.Value);
790 resourceParams.dwLocationInCmd = 36;
791 resourceParams.bIsWritable = true;
792
793 resourceParams.dwSharedMocsOffset = 38 - resourceParams.dwLocationInCmd;
794
795 MHW_MI_CHK_STATUS(AddResourceToCmd(
796 m_osInterface,
797 cmdBuffer,
798 &resourceParams));
799 }
800
801 //Collocated MV Temporal buffers
802 cmd.CollocatedMotionVectorTemporalBufferBaseAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
803
804 for (uint32_t i = 0; i < av1TotalRefsPerFrame; i++)
805 {
806 if (params->m_colMvTemporalBuffer[i] != nullptr)
807 {
808 resourceParams.presResource = params->m_colMvTemporalBuffer[i];
809 resourceParams.dwOffset = 0;
810 resourceParams.pdwCmd = (cmd.CollocatedMotionVectorTemporalBufferBaseAddressTmvaddr07[i].DW0_1.Value);
811 resourceParams.dwLocationInCmd = (i * 2) + 39;
812 resourceParams.bIsWritable = true;
813 resourceParams.dwSharedMocsOffset = 55 - resourceParams.dwLocationInCmd;
814
815 MHW_MI_CHK_STATUS(AddResourceToCmd(
816 m_osInterface,
817 cmdBuffer,
818 &resourceParams));
819 }
820 }
821
822 // Current Motion Vector Temporal Buffer
823 if (params->m_curMvTemporalBuffer != nullptr)
824 {
825 cmd.CurrentFrameMotionVectorWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
826
827 resourceParams.presResource = params->m_curMvTemporalBuffer;
828 resourceParams.dwOffset = 0;
829 resourceParams.pdwCmd = (cmd.CurrentFrameMotionVectorWriteBufferAddress.DW0_1.Value);
830 resourceParams.dwLocationInCmd = 56;
831 resourceParams.bIsWritable = true;
832
833 MHW_MI_CHK_STATUS(AddResourceToCmd(
834 m_osInterface,
835 cmdBuffer,
836 &resourceParams));
837 }
838
839 // Reset dwSharedMocsOffset
840 resourceParams.dwSharedMocsOffset = 0;
841 // Bitstream Decode Line Rowstore Buffer
842 if (m_btdlRowstoreCache.bEnabled)
843 {
844 cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
845 cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddress.DW0_1.BaseAddress = m_btdlRowstoreCache.dwAddress;
846 }
847 else if (params->m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer != nullptr)
848 {
849 cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
850
851 resourceParams.presResource = params->m_bitstreamDecoderEncoderLineRowstoreReadWriteBuffer;
852 resourceParams.dwOffset = 0;
853 resourceParams.pdwCmd = (cmd.BitstreamDecoderEncoderLineRowstoreReadWriteBufferAddress.DW0_1.Value);
854 resourceParams.dwLocationInCmd = 62;
855 resourceParams.bIsWritable = true;
856
857 MHW_MI_CHK_STATUS(AddResourceToCmd(
858 m_osInterface,
859 cmdBuffer,
860 &resourceParams));
861 }
862
863 // Bitstream Decode Tile Line Rowstore Buffer
864 if (params->m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer != nullptr)
865 {
866 cmd.BitstreamDecoderEncoderTileLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
867
868 resourceParams.presResource = params->m_bitstreamDecoderEncoderTileLineRowstoreReadWriteBuffer;
869 resourceParams.dwOffset = 0;
870 resourceParams.pdwCmd = (cmd.BitstreamDecoderEncoderTileLineRowstoreReadWriteBufferAddress.DW0_1.Value);
871 resourceParams.dwLocationInCmd = 65;
872 resourceParams.bIsWritable = true;
873
874 MHW_MI_CHK_STATUS(AddResourceToCmd(
875 m_osInterface,
876 cmdBuffer,
877 &resourceParams));
878 }
879
880 // Reset dwSharedMocsOffset
881 resourceParams.dwSharedMocsOffset = 0;
882 // Intra Prediction Line Rowstore Read/Write Buffer
883 if (m_ipdlRowstoreCache.bEnabled)
884 {
885 cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
886 cmd.IntraPredictionLineRowstoreReadWriteBufferAddress.DW0_1.BaseAddress = m_ipdlRowstoreCache.dwAddress;
887 }
888 else if (params->m_intraPredictionLineRowstoreReadWriteBuffer != nullptr)
889 {
890 cmd.IntraPredictionLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
891
892 resourceParams.presResource = params->m_intraPredictionLineRowstoreReadWriteBuffer;
893 resourceParams.dwOffset = 0;
894 resourceParams.pdwCmd = (cmd.IntraPredictionLineRowstoreReadWriteBufferAddress.DW0_1.Value);
895 resourceParams.dwLocationInCmd = 68;
896 resourceParams.bIsWritable = true;
897
898 MHW_MI_CHK_STATUS(AddResourceToCmd(
899 m_osInterface,
900 cmdBuffer,
901 &resourceParams));
902 }
903
904 // Intra Prediction Tile Line Rowstore Buffer
905 if (params->m_intraPredictionTileLineRowstoreReadWriteBuffer != nullptr)
906 {
907 cmd.IntraPredictionTileLineRowstoreReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
908
909 resourceParams.presResource = params->m_intraPredictionTileLineRowstoreReadWriteBuffer;
910 resourceParams.dwOffset = 0;
911 resourceParams.pdwCmd = (cmd.IntraPredictionTileLineRowstoreReadWriteBufferAddress.DW0_1.Value);
912 resourceParams.dwLocationInCmd = 71;
913 resourceParams.bIsWritable = true;
914
915 MHW_MI_CHK_STATUS(AddResourceToCmd(
916 m_osInterface,
917 cmdBuffer,
918 &resourceParams));
919 }
920
921 // Spatial Motion Vector Line Buffer
922 if (m_smvlRowstoreCache.bEnabled)
923 {
924 cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
925 cmd.SpatialMotionVectorLineReadWriteBufferAddress.DW0_1.BaseAddress = m_smvlRowstoreCache.dwAddress;
926 }
927 else if (params->m_spatialMotionVectorLineReadWriteBuffer != nullptr)
928 {
929 cmd.SpatialMotionVectorLineReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
930
931 resourceParams.presResource = params->m_spatialMotionVectorLineReadWriteBuffer;
932 resourceParams.dwOffset = 0;
933 resourceParams.pdwCmd = (cmd.SpatialMotionVectorLineReadWriteBufferAddress.DW0_1.Value);
934 resourceParams.dwLocationInCmd = 74;
935 resourceParams.bIsWritable = true;
936
937 MHW_MI_CHK_STATUS(AddResourceToCmd(
938 m_osInterface,
939 cmdBuffer,
940 &resourceParams));
941 }
942
943 // Spatial Motion Vector Tile Line Buffer
944 if (params->m_spatialMotionVectorCodingTileLineReadWriteBuffer != nullptr)
945 {
946 cmd.SpatialMotionVectorTileLineReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
947
948 resourceParams.presResource = params->m_spatialMotionVectorCodingTileLineReadWriteBuffer;
949 resourceParams.dwOffset = 0;
950 resourceParams.pdwCmd = (cmd.SpatialMotionVectorCodingTileLineReadWriteBufferAddress.DW0_1.Value);
951 resourceParams.dwLocationInCmd = 77;
952 resourceParams.bIsWritable = true;
953
954 MHW_MI_CHK_STATUS(AddResourceToCmd(
955 m_osInterface,
956 cmdBuffer,
957 &resourceParams));
958 }
959
960 //Loop Restoration Meta Tile Column Read/Write Buffer
961 if (params->m_loopRestorationMetaTileColumnReadWriteBuffer != nullptr)
962 {
963 cmd.LoopRestorationMetaTileColumnReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
964
965 resourceParams.presResource = params->m_loopRestorationMetaTileColumnReadWriteBuffer;
966 resourceParams.dwOffset = 0;
967 resourceParams.pdwCmd = (cmd.LoopRestorationMetaTileColumnReadWriteBufferAddress.DW0_1.Value);
968 resourceParams.dwLocationInCmd = 80;
969 resourceParams.bIsWritable = true;
970
971 MHW_MI_CHK_STATUS(AddResourceToCmd(
972 m_osInterface,
973 cmdBuffer,
974 &resourceParams));
975 }
976
977 //Deblocker Filter Control Parameters Line Read Write Buffer
978 if (params->m_loopRestorationFilterTileReadWriteLineYBuffer != nullptr)
979 {
980 cmd.LoopRestorationFilterTileReadWriteLineYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
981
982 resourceParams.presResource = params->m_loopRestorationFilterTileReadWriteLineYBuffer;
983 resourceParams.dwOffset = 0;
984 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineYBufferAddress.DW0_1.Value);
985 resourceParams.dwLocationInCmd = 83;
986 resourceParams.bIsWritable = true;
987
988 MHW_MI_CHK_STATUS(AddResourceToCmd(
989 m_osInterface,
990 cmdBuffer,
991 &resourceParams));
992 }
993
994 //Deblocker Filter Control Parameters Tile Line Read Write Buffer
995 if (params->m_loopRestorationFilterTileReadWriteLineUBuffer != nullptr)
996 {
997 cmd.LoopRestorationFilterTileReadWriteLineUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
998
999 resourceParams.presResource = params->m_loopRestorationFilterTileReadWriteLineUBuffer;
1000 resourceParams.dwOffset = 0;
1001 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineUBufferAddress.DW0_1.Value);
1002 resourceParams.dwLocationInCmd = 86;
1003 resourceParams.bIsWritable = true;
1004
1005 MHW_MI_CHK_STATUS(AddResourceToCmd(
1006 m_osInterface,
1007 cmdBuffer,
1008 &resourceParams));
1009 }
1010
1011 //Deblocker Filter Control Parameters Tile Column Read Write Buffer
1012 if (params->m_loopRestorationFilterTileReadWriteLineVBuffer != nullptr)
1013 {
1014 cmd.LoopRestorationFilterTileReadWriteLineVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1015
1016 resourceParams.presResource = params->m_loopRestorationFilterTileReadWriteLineVBuffer;
1017 resourceParams.dwOffset = 0;
1018 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileReadWriteLineVBufferAddress.DW0_1.Value);
1019 resourceParams.dwLocationInCmd = 89;
1020 resourceParams.bIsWritable = true;
1021
1022 MHW_MI_CHK_STATUS(AddResourceToCmd(
1023 m_osInterface,
1024 cmdBuffer,
1025 &resourceParams));
1026 }
1027
1028 // Deblocker Filter Line Read Write Y Buffer
1029 if (m_dflyRowstoreCache.bEnabled)
1030 {
1031 cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1032 cmd.DeblockerFilterLineReadWriteYBufferAddress.DW0_1.BaseAddress = m_dflyRowstoreCache.dwAddress;
1033 }
1034 else if (params->m_deblockerFilterLineReadWriteYBuffer != nullptr)
1035 {
1036 cmd.DeblockerFilterLineReadWriteYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1037
1038 resourceParams.presResource = params->m_deblockerFilterLineReadWriteYBuffer;
1039 resourceParams.dwOffset = 0;
1040 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteYBufferAddress.DW0_1.Value);
1041 resourceParams.dwLocationInCmd = 92;
1042 resourceParams.bIsWritable = true;
1043
1044 MHW_MI_CHK_STATUS(AddResourceToCmd(
1045 m_osInterface,
1046 cmdBuffer,
1047 &resourceParams));
1048 }
1049
1050 // Deblocker Filter Line Read Write U Buffer
1051 if (m_dfluRowstoreCache.bEnabled)
1052 {
1053 cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1054 cmd.DeblockerFilterLineReadWriteUBufferAddress.DW0_1.BaseAddress = m_dfluRowstoreCache.dwAddress;
1055 }
1056 else if (params->m_deblockerFilterLineReadWriteUBuffer != nullptr)
1057 {
1058 cmd.DeblockerFilterLineReadWriteUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1059
1060 resourceParams.presResource = params->m_deblockerFilterLineReadWriteUBuffer;
1061 resourceParams.dwOffset = 0;
1062 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteUBufferAddress.DW0_1.Value);
1063 resourceParams.dwLocationInCmd = 95;
1064 resourceParams.bIsWritable = true;
1065
1066 MHW_MI_CHK_STATUS(AddResourceToCmd(
1067 m_osInterface,
1068 cmdBuffer,
1069 &resourceParams));
1070 }
1071 // Deblocker Filter Line Read Write V Buffer
1072 if (m_dflvRowstoreCache.bEnabled)
1073 {
1074 cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1075 cmd.DeblockerFilterLineReadWriteVBufferAddress.DW0_1.BaseAddress = m_dflvRowstoreCache.dwAddress;
1076 }
1077 else if (params->m_deblockerFilterLineReadWriteVBuffer != nullptr)
1078 {
1079 cmd.DeblockerFilterLineReadWriteVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1080
1081 resourceParams.presResource = params->m_deblockerFilterLineReadWriteVBuffer;
1082 resourceParams.dwOffset = 0;
1083 resourceParams.pdwCmd = (cmd.DeblockerFilterLineReadWriteVBufferAddress.DW0_1.Value);
1084 resourceParams.dwLocationInCmd = 98;
1085 resourceParams.bIsWritable = true;
1086
1087 MHW_MI_CHK_STATUS(AddResourceToCmd(
1088 m_osInterface,
1089 cmdBuffer,
1090 &resourceParams));
1091 }
1092
1093 // Deblocker Filter Tile Line Read Write Y Buffer
1094 if (params->m_deblockerFilterTileLineReadWriteYBuffer != nullptr)
1095 {
1096 cmd.DeblockerFilterTileLineReadWriteYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1097
1098 resourceParams.presResource = params->m_deblockerFilterTileLineReadWriteYBuffer;
1099 resourceParams.dwOffset = 0;
1100 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteYBufferAddress.DW0_1.Value);
1101 resourceParams.dwLocationInCmd = 101;
1102 resourceParams.bIsWritable = true;
1103
1104 MHW_MI_CHK_STATUS(AddResourceToCmd(
1105 m_osInterface,
1106 cmdBuffer,
1107 &resourceParams));
1108 }
1109
1110 // Deblocker Filter Tile Line Read Write V Buffer
1111 if (params->m_deblockerFilterTileLineReadWriteVBuffer != nullptr)
1112 {
1113 cmd.DeblockerFilterTileLineReadWriteVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1114
1115 resourceParams.presResource = params->m_deblockerFilterTileLineReadWriteVBuffer;
1116 resourceParams.dwOffset = 0;
1117 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteVBufferAddress.DW0_1.Value);
1118 resourceParams.dwLocationInCmd = 104;
1119 resourceParams.bIsWritable = true;
1120
1121 MHW_MI_CHK_STATUS(AddResourceToCmd(
1122 m_osInterface,
1123 cmdBuffer,
1124 &resourceParams));
1125 }
1126
1127 // Deblocker Filter Tile Line Read Write U Buffer
1128 if (params->m_deblockerFilterTileLineReadWriteUBuffer != nullptr)
1129 {
1130 cmd.DeblockerFilterTileLineReadWriteUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1131
1132 resourceParams.presResource = params->m_deblockerFilterTileLineReadWriteUBuffer;
1133 resourceParams.dwOffset = 0;
1134 resourceParams.pdwCmd = (cmd.DeblockerFilterTileLineReadWriteUBufferAddress.DW0_1.Value);
1135 resourceParams.dwLocationInCmd = 107;
1136 resourceParams.bIsWritable = true;
1137
1138 MHW_MI_CHK_STATUS(AddResourceToCmd(
1139 m_osInterface,
1140 cmdBuffer,
1141 &resourceParams));
1142 }
1143
1144 // Deblocker Filter Tile Column Read Write Y Buffer
1145 if (params->m_deblockerFilterTileColumnReadWriteYBuffer != nullptr)
1146 {
1147 cmd.DeblockerFilterTileColumnReadWriteYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1148
1149 resourceParams.presResource = params->m_deblockerFilterTileColumnReadWriteYBuffer;
1150 resourceParams.dwOffset = 0;
1151 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteYBufferAddress.DW0_1.Value);
1152 resourceParams.dwLocationInCmd = 110;
1153 resourceParams.bIsWritable = true;
1154
1155 MHW_MI_CHK_STATUS(AddResourceToCmd(
1156 m_osInterface,
1157 cmdBuffer,
1158 &resourceParams));
1159 }
1160
1161 // Deblocker Filter Tile Column Read Write U Buffer
1162 if (params->m_deblockerFilterTileColumnReadWriteUBuffer != nullptr)
1163 {
1164 cmd.DeblockerFilterTileColumnReadWriteUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1165
1166 resourceParams.presResource = params->m_deblockerFilterTileColumnReadWriteUBuffer;
1167 resourceParams.dwOffset = 0;
1168 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteUBufferAddress.DW0_1.Value);
1169 resourceParams.dwLocationInCmd = 113;
1170 resourceParams.bIsWritable = true;
1171
1172 MHW_MI_CHK_STATUS(AddResourceToCmd(
1173 m_osInterface,
1174 cmdBuffer,
1175 &resourceParams));
1176 }
1177
1178 // Deblocker Filter Tile Column Read Write V Buffer
1179 if (params->m_deblockerFilterTileColumnReadWriteVBuffer != nullptr)
1180 {
1181 cmd.DeblockerFilterTileColumnReadWriteVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_DEBLOCKINGFILTER_ROWSTORE_SCRATCH_BUFFER_CODEC].Gen12.Index;
1182
1183 resourceParams.presResource = params->m_deblockerFilterTileColumnReadWriteVBuffer;
1184 resourceParams.dwOffset = 0;
1185 resourceParams.pdwCmd = (cmd.DeblockerFilterTileColumnReadWriteVBufferAddress.DW0_1.Value);
1186 resourceParams.dwLocationInCmd = 116;
1187 resourceParams.bIsWritable = true;
1188
1189 MHW_MI_CHK_STATUS(AddResourceToCmd(
1190 m_osInterface,
1191 cmdBuffer,
1192 &resourceParams));
1193 }
1194
1195 // Cdef Filter Line Read Write Y Buffer
1196 if (m_cdefRowstoreCache.bEnabled)
1197 {
1198 cmd.CdefFilterLineReadWriteBufferAddressAttributes.DW0.BaseAddressRowStoreScratchBufferCacheSelect = cmd.CdefFilterLineReadWriteBufferAddressAttributes.BASE_ADDRESS_ROW_STORE_SCRATCH_BUFFER_CACHE_SELECT_UNNAMED1;
1199 cmd.CdefFilterLineReadWriteBufferAddress.DW0_1.BaseAddress = m_cdefRowstoreCache.dwAddress;
1200 }
1201 else if (params->m_cdefFilterLineReadWriteBuffer != nullptr)
1202 {
1203 cmd.CdefFilterLineReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1204
1205 resourceParams.presResource = params->m_cdefFilterLineReadWriteBuffer;
1206 resourceParams.dwOffset = 0;
1207 resourceParams.pdwCmd = (cmd.CdefFilterLineReadWriteBufferAddress.DW0_1.Value);
1208 resourceParams.dwLocationInCmd = 119;
1209 resourceParams.bIsWritable = true;
1210
1211 MHW_MI_CHK_STATUS(AddResourceToCmd(
1212 m_osInterface,
1213 cmdBuffer,
1214 &resourceParams));
1215 }
1216
1217 // Cdef Filter Tile Line Read Write Y Buffer
1218 if (params->m_cdefFilterTileLineReadWriteBuffer != nullptr)
1219 {
1220 cmd.CdefFilterTileLineReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1221
1222 resourceParams.presResource = params->m_cdefFilterTileLineReadWriteBuffer;
1223 resourceParams.dwOffset = 0;
1224 resourceParams.pdwCmd = (cmd.CdefFilterTileLineReadWriteBufferAddress.DW0_1.Value);
1225 resourceParams.dwLocationInCmd = 128;
1226 resourceParams.bIsWritable = true;
1227
1228 MHW_MI_CHK_STATUS(AddResourceToCmd(
1229 m_osInterface,
1230 cmdBuffer,
1231 &resourceParams));
1232 }
1233
1234 // Cdef Filter Tile Line Read Write U Buffer
1235 if (params->m_cdefFilterTileColumnReadWriteBuffer != nullptr)
1236 {
1237 cmd.CdefFilterTileColumnReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1238
1239 resourceParams.presResource = params->m_cdefFilterTileColumnReadWriteBuffer;
1240 resourceParams.dwOffset = 0;
1241 resourceParams.pdwCmd = (cmd.CdefFilterTileColumnReadWriteBufferAddress.DW0_1.Value);
1242 resourceParams.dwLocationInCmd = 137;
1243 resourceParams.bIsWritable = true;
1244
1245 MHW_MI_CHK_STATUS(AddResourceToCmd(
1246 m_osInterface,
1247 cmdBuffer,
1248 &resourceParams));
1249 }
1250
1251 // Cdef Filter Tile Line Read Write V Buffer
1252 if (params->m_cdefFilterMetaTileLineReadWriteBuffer != nullptr)
1253 {
1254 cmd.CdefFilterMetaTileLineReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1255
1256 resourceParams.presResource = params->m_cdefFilterMetaTileLineReadWriteBuffer;
1257 resourceParams.dwOffset = 0;
1258 resourceParams.pdwCmd = (cmd.CdefFilterMetaTileLineReadWriteBufferAddress.DW0_1.Value);
1259 resourceParams.dwLocationInCmd = 140;
1260 resourceParams.bIsWritable = true;
1261
1262 MHW_MI_CHK_STATUS(AddResourceToCmd(
1263 m_osInterface,
1264 cmdBuffer,
1265 &resourceParams));
1266 }
1267
1268 // Cdef Filter Tile Column Read Write Y Buffer
1269 if (params->m_cdefFilterMetaTileColumnReadWriteBuffer != nullptr)
1270 {
1271 cmd.CdefFilterMetaTileColumnReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1272
1273 resourceParams.presResource = params->m_cdefFilterMetaTileColumnReadWriteBuffer;
1274 resourceParams.dwOffset = 0;
1275 resourceParams.pdwCmd = (cmd.CdefFilterMetaTileColumnReadWriteBufferAddress.DW0_1.Value);
1276 resourceParams.dwLocationInCmd = 143;
1277 resourceParams.bIsWritable = true;
1278
1279 MHW_MI_CHK_STATUS(AddResourceToCmd(
1280 m_osInterface,
1281 cmdBuffer,
1282 &resourceParams));
1283 }
1284
1285 // Cdef Filter Top Left Corner Read Write Buffer
1286 if (params->m_cdefFilterTopLeftCornerReadWriteBuffer != nullptr)
1287 {
1288 cmd.CdefFilterTopLeftCornerReadWriteBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1289
1290 resourceParams.presResource = params->m_cdefFilterTopLeftCornerReadWriteBuffer;
1291 resourceParams.dwOffset = 0;
1292 resourceParams.pdwCmd = (cmd.CdefFilterTopLeftCornerReadWriteBufferAddress.DW0_1.Value);
1293 resourceParams.dwLocationInCmd = 146;
1294 resourceParams.bIsWritable = true;
1295
1296 MHW_MI_CHK_STATUS(AddResourceToCmd(
1297 m_osInterface,
1298 cmdBuffer,
1299 &resourceParams));
1300 }
1301
1302 // Super-Res Tile Column Read Write Y Buffer
1303 if (params->m_superResTileColumnReadWriteYBuffer != nullptr)
1304 {
1305 cmd.SuperResTileColumnReadWriteYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1306
1307 resourceParams.presResource = params->m_superResTileColumnReadWriteYBuffer;
1308 resourceParams.dwOffset = 0;
1309 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteYBufferAddress.DW0_1.Value);
1310 resourceParams.dwLocationInCmd = 149;
1311 resourceParams.bIsWritable = true;
1312
1313 MHW_MI_CHK_STATUS(AddResourceToCmd(
1314 m_osInterface,
1315 cmdBuffer,
1316 &resourceParams));
1317 }
1318
1319 // Super-Res Tile Column Read Write U Buffer
1320 if (params->m_superResTileColumnReadWriteUBuffer != nullptr)
1321 {
1322 cmd.SuperResTileColumnReadWriteUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1323
1324 resourceParams.presResource = params->m_superResTileColumnReadWriteUBuffer;
1325 resourceParams.dwOffset = 0;
1326 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteUBufferAddress.DW0_1.Value);
1327 resourceParams.dwLocationInCmd = 152;
1328 resourceParams.bIsWritable = true;
1329
1330 MHW_MI_CHK_STATUS(AddResourceToCmd(
1331 m_osInterface,
1332 cmdBuffer,
1333 &resourceParams));
1334 }
1335
1336 // Super-Res Tile Column Read Write V Buffer
1337 if (params->m_superResTileColumnReadWriteVBuffer != nullptr)
1338 {
1339 cmd.SuperResTileColumnReadWriteVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1340
1341 resourceParams.presResource = params->m_superResTileColumnReadWriteVBuffer;
1342 resourceParams.dwOffset = 0;
1343 resourceParams.pdwCmd = (cmd.SuperResTileColumnReadWriteVBufferAddress.DW0_1.Value);
1344 resourceParams.dwLocationInCmd = 155;
1345 resourceParams.bIsWritable = true;
1346
1347 MHW_MI_CHK_STATUS(AddResourceToCmd(
1348 m_osInterface,
1349 cmdBuffer,
1350 &resourceParams));
1351 }
1352
1353 // Loop Restoration Filter Tile Column Read Write Y Buffer
1354 if (params->m_loopRestorationFilterTileColumnReadWriteYBuffer != nullptr)
1355 {
1356 cmd.LoopRestorationFilterTileColumnReadWriteYBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1357
1358 resourceParams.presResource = params->m_loopRestorationFilterTileColumnReadWriteYBuffer;
1359 resourceParams.dwOffset = 0;
1360 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteYBufferAddress.DW0_1.Value);
1361 resourceParams.dwLocationInCmd = 158;
1362 resourceParams.bIsWritable = true;
1363
1364 MHW_MI_CHK_STATUS(AddResourceToCmd(
1365 m_osInterface,
1366 cmdBuffer,
1367 &resourceParams));
1368 }
1369
1370 // Loop Restoration Filter Tile Column Read Write U Buffer
1371 if (params->m_loopRestorationFilterTileColumnReadWriteUBuffer != nullptr)
1372 {
1373 cmd.LoopRestorationFilterTileColumnReadWriteUBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1374
1375 resourceParams.presResource = params->m_loopRestorationFilterTileColumnReadWriteUBuffer;
1376 resourceParams.dwOffset = 0;
1377 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteUBufferAddress.DW0_1.Value);
1378 resourceParams.dwLocationInCmd = 161;
1379 resourceParams.bIsWritable = true;
1380
1381 MHW_MI_CHK_STATUS(AddResourceToCmd(
1382 m_osInterface,
1383 cmdBuffer,
1384 &resourceParams));
1385 }
1386
1387 // Loop Restoration Filter Tile Column Read Write V Buffer
1388 if (params->m_loopRestorationFilterTileColumnReadWriteVBuffer != nullptr)
1389 {
1390 cmd.LoopRestorationFilterTileColumnReadWriteVBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1391
1392 resourceParams.presResource = params->m_loopRestorationFilterTileColumnReadWriteVBuffer;
1393 resourceParams.dwOffset = 0;
1394 resourceParams.pdwCmd = (cmd.LoopRestorationFilterTileColumnReadWriteVBufferAddress.DW0_1.Value);
1395 resourceParams.dwLocationInCmd = 164;
1396 resourceParams.bIsWritable = true;
1397
1398 MHW_MI_CHK_STATUS(AddResourceToCmd(
1399 m_osInterface,
1400 cmdBuffer,
1401 &resourceParams));
1402 }
1403
1404 // Decoded Frame Status Error Buffer
1405 if (params->m_decodedFrameStatusErrorBuffer != nullptr)
1406 {
1407 cmd.DecodedFrameStatusErrorBufferBaseAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1408
1409 resourceParams.presResource = params->m_decodedFrameStatusErrorBuffer;
1410 resourceParams.dwOffset = 0;
1411 resourceParams.pdwCmd = (cmd.DecodedFrameStatusErrorBufferBaseAddress.DW0_1.Value);
1412 resourceParams.dwLocationInCmd = 176;
1413 resourceParams.bIsWritable = true;
1414
1415 MHW_MI_CHK_STATUS(AddResourceToCmd(
1416 m_osInterface,
1417 cmdBuffer,
1418 &resourceParams));
1419 }
1420
1421 // Decoded Block Data Streamout Buffer
1422 if (params->m_decodedBlockDataStreamoutBuffer != nullptr)
1423 {
1424 cmd.DecodedBlockDataStreamoutBufferAddressAttributes.DW0.BaseAddressIndexToMemoryObjectControlStateMocsTables = m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED].Gen12.Index;
1425
1426 resourceParams.presResource = params->m_decodedBlockDataStreamoutBuffer;
1427 resourceParams.dwOffset = 0;
1428 resourceParams.pdwCmd = (cmd.DecodedBlockDataStreamoutBufferAddress.DW0_1.Value);
1429 resourceParams.dwLocationInCmd = 179;
1430 resourceParams.bIsWritable = true;
1431
1432 MHW_MI_CHK_STATUS(AddResourceToCmd(
1433 m_osInterface,
1434 cmdBuffer,
1435 &resourceParams));
1436 }
1437
1438 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1439
1440 return eStatus;
1441 }
1442
AddAvpIndObjBaseAddrCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params)1443 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpIndObjBaseAddrCmd(
1444 PMOS_COMMAND_BUFFER cmdBuffer,
1445 PMHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS params)
1446 {
1447 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1448
1449 MHW_FUNCTION_ENTER;
1450
1451 MHW_MI_CHK_NULL(m_osInterface);
1452 MHW_MI_CHK_NULL(params);
1453
1454 MHW_RESOURCE_PARAMS resourceParams;
1455 mhw_vdbox_avp_g12_X::AVP_IND_OBJ_BASE_ADDR_STATE_CMD cmd;
1456
1457 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
1458 resourceParams.dwLsbNum = MHW_VDBOX_HCP_UPPER_BOUND_STATE_SHIFT;
1459 resourceParams.HwCommandType = MOS_MFX_INDIRECT_OBJ_BASE_ADDR;
1460
1461 // mode specific settings
1462 if(m_decodeInUse)
1463 {
1464 MHW_MI_CHK_NULL(params->presDataBuffer);
1465
1466 cmd.AvpIndirectBitstreamObjectMemoryAddressAttributes.DW0.Value |=
1467 m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_MFX_INDIRECT_BITSTREAM_OBJECT_DECODE].Gen12.Index;
1468
1469 resourceParams.presResource = params->presDataBuffer;
1470 resourceParams.dwOffset = params->dwDataOffset;
1471 resourceParams.pdwCmd = &(cmd.AvpIndirectBitstreamObjectBaseAddress.DW0_1.Value[0]);
1472 resourceParams.dwLocationInCmd = 1;
1473 resourceParams.dwSize = params->dwDataSize;
1474 resourceParams.bIsWritable = false;
1475
1476 // upper bound of the allocated resource will be set at 3 DW apart from address location
1477 resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
1478
1479 MHW_MI_CHK_STATUS(AddResourceToCmd(
1480 m_osInterface,
1481 cmdBuffer,
1482 &resourceParams));
1483
1484 resourceParams.dwUpperBoundLocationOffsetFromCmd = 0;
1485 }
1486
1487 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1488
1489 return eStatus;
1490 }
1491
AddAvpDecodePicStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,MhwVdboxAvpPicStateParams * params)1492 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpDecodePicStateCmd(
1493 PMOS_COMMAND_BUFFER cmdBuffer,
1494 MhwVdboxAvpPicStateParams *params)
1495 {
1496 MHW_FUNCTION_ENTER;
1497
1498 MHW_MI_CHK_NULL(m_osInterface);
1499 MHW_MI_CHK_NULL(params);
1500 MHW_MI_CHK_NULL(params->m_picParams);
1501
1502 mhw_vdbox_avp_g12_X::AVP_PIC_STATE_CMD cmd;
1503 auto picParams = params->m_picParams;
1504
1505 cmd.DW1.FrameWidthInPixelMinus1 = picParams->m_frameWidthMinus1;//down-scaled frame width
1506 cmd.DW1.FrameHeightInPixelMinus1 = picParams->m_frameHeightMinus1;
1507
1508 if (picParams->m_seqInfoFlags.m_fields.m_subsamplingX == 1 && picParams->m_seqInfoFlags.m_fields.m_subsamplingY == 1)
1509 {
1510 if (picParams->m_seqInfoFlags.m_fields.m_monoChrome)
1511 {
1512 //4:0:0
1513 cmd.DW2.SequenceChromaSubsamplingFormat = 0;
1514 }
1515 else
1516 {
1517 //4:2:0
1518 cmd.DW2.SequenceChromaSubsamplingFormat = 1;
1519 }
1520 }
1521 else if (picParams->m_seqInfoFlags.m_fields.m_subsamplingX == 1 && picParams->m_seqInfoFlags.m_fields.m_subsamplingY == 0)
1522 {
1523 //4:2:2
1524 cmd.DW2.SequenceChromaSubsamplingFormat = 2;
1525 }
1526 else if (picParams->m_seqInfoFlags.m_fields.m_subsamplingX == 0 && picParams->m_seqInfoFlags.m_fields.m_subsamplingY == 0)
1527 {
1528 //4:4:4
1529 cmd.DW2.SequenceChromaSubsamplingFormat = 3;
1530 }
1531
1532 cmd.DW2.SequencePixelBitDepthIdc = picParams->m_bitDepthIdx;
1533 cmd.DW2.SequenceSuperblockSizeUsed = picParams->m_seqInfoFlags.m_fields.m_use128x128Superblock;
1534 cmd.DW2.SequenceEnableOrderHintFlag = picParams->m_seqInfoFlags.m_fields.m_enableOrderHint;
1535 cmd.DW2.SequenceOrderHintBitsMinus1 = (picParams->m_seqInfoFlags.m_fields.m_enableOrderHint)? picParams->m_orderHintBitsMinus1 : 0;
1536 cmd.DW2.SequenceEnableFilterIntraFlag = picParams->m_seqInfoFlags.m_fields.m_enableFilterIntra;
1537 cmd.DW2.SequenceEnableIntraEdgeFilterFlag = picParams->m_seqInfoFlags.m_fields.m_enableIntraEdgeFilter;
1538 cmd.DW2.SequenceEnableDualFilterFlag = picParams->m_seqInfoFlags.m_fields.m_enableDualFilter;
1539 cmd.DW2.SequenceEnableInterIntraCompoundFlag = picParams->m_seqInfoFlags.m_fields.m_enableInterintraCompound;
1540 cmd.DW2.SequenceEnableMaskedCompoundFlag = picParams->m_seqInfoFlags.m_fields.m_enableMaskedCompound;
1541 cmd.DW2.SequenceEnableJointCompoundFlag = picParams->m_seqInfoFlags.m_fields.m_enableJntComp;
1542
1543 cmd.DW3.AllowScreenContentToolsFlag = picParams->m_picInfoFlags.m_fields.m_allowScreenContentTools;
1544 cmd.DW3.ForceIntegerMvFlag = picParams->m_picInfoFlags.m_fields.m_forceIntegerMv;
1545 cmd.DW3.AllowWarpedMotionFlag = picParams->m_picInfoFlags.m_fields.m_allowWarpedMotion;
1546 cmd.DW3.UseCdefFilterFlag = !(picParams->m_losslessMode || picParams->m_picInfoFlags.m_fields.m_allowIntrabc || !picParams->m_seqInfoFlags.m_fields.m_enableCdef);//coded lossless is used here
1547 cmd.DW3.UseSuperResFlag = picParams->m_picInfoFlags.m_fields.m_useSuperres;
1548 cmd.DW3.FrameLevelLoopRestorationFilterEnableFlag = params->m_picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType != 0 ||
1549 params->m_picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType != 0 ||
1550 params->m_picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType != 0;
1551
1552 cmd.DW3.LargeScaleTileEnableFlag = picParams->m_picInfoFlags.m_fields.m_largeScaleTile;
1553 cmd.DW3.FrameType = picParams->m_picInfoFlags.m_fields.m_frameType;
1554 cmd.DW3.IntraonlyFlag = (picParams->m_picInfoFlags.m_fields.m_frameType == keyFrame) || (picParams->m_picInfoFlags.m_fields.m_frameType == intraOnlyFrame);
1555 cmd.DW3.ErrorResilientModeFlag = picParams->m_picInfoFlags.m_fields.m_errorResilientMode;
1556 cmd.DW3.AllowIntrabcFlag = picParams->m_picInfoFlags.m_fields.m_allowIntrabc;
1557 cmd.DW3.PrimaryReferenceFrameIdx = picParams->m_primaryRefFrame;
1558
1559 cmd.DW4.SegmentationEnableFlag = picParams->m_av1SegData.m_enabled;
1560 cmd.DW4.SegmentationUpdateMapFlag = picParams->m_av1SegData.m_updateMap;
1561 if (picParams->m_picInfoFlags.m_fields.m_frameType == keyFrame || picParams->m_picInfoFlags.m_fields.m_frameType == intraOnlyFrame)
1562 {
1563 cmd.DW4.SegmentationTemporalUpdateFlag = 0;//override this flag to "0" in KEY_FRAME or INTRA_ONLY frame even if this bit decoded from bitstream is different
1564 }
1565 else
1566 {
1567 cmd.DW4.SegmentationTemporalUpdateFlag = picParams->m_av1SegData.m_temporalUpdate;
1568 }
1569 cmd.DW4.PreSkipSegmentIdFlag = picParams->m_av1SegData.m_preSkipSegmentIdFlag;
1570 cmd.DW4.LastActiveSegmentId = picParams->m_av1SegData.m_lastActiveSegmentId;
1571 cmd.DW4.DeltaQPresentFlag = picParams->m_modeControlFlags.m_fields.m_deltaQPresentFlag;
1572 cmd.DW4.DeltaQRes = picParams->m_modeControlFlags.m_fields.m_log2DeltaQRes;
1573 cmd.DW4.FrameCodedLosslessMode = picParams->m_losslessMode;
1574 cmd.DW4.SegmentIdBufferStreamInEnableFlag = picParams->m_av1SegData.m_segIdBufStreamInEnable;
1575 cmd.DW4.SegmentIdBufferStreamOutEnableFlag = picParams->m_av1SegData.m_segIdBufStreamOutEnable;
1576 cmd.DW4.SegmentMapIsZeroFlag = picParams->m_av1SegData.m_segmentMapIsZeroFlag;
1577 cmd.DW4.BaseQindex = picParams->m_baseQindex;
1578 cmd.DW4.YDcDeltaQ = picParams->m_yDcDeltaQ;
1579
1580 cmd.DW5.UDcDeltaQ = picParams->m_uDcDeltaQ;
1581 cmd.DW5.UAcDeltaQ = picParams->m_uAcDeltaQ;
1582 cmd.DW5.VDcDeltaQ = picParams->m_vDcDeltaQ;
1583 cmd.DW5.VAcDeltaQ = picParams->m_vAcDeltaQ;
1584
1585 cmd.DW6.AllowHighPrecisionMv = picParams->m_picInfoFlags.m_fields.m_allowHighPrecisionMv;
1586 cmd.DW6.FrameLevelReferenceModeSelect = !(picParams->m_modeControlFlags.m_fields.m_referenceMode == singleReference);
1587 cmd.DW6.McompFilterType = picParams->m_interpFilter;
1588 cmd.DW6.MotionModeSwitchableFlag = picParams->m_picInfoFlags.m_fields.m_isMotionModeSwitchable;
1589 cmd.DW6.UseReferenceFrameMvSetFlag = picParams->m_picInfoFlags.m_fields.m_useRefFrameMvs;
1590 cmd.DW6.ReferenceFrameSignBiasI0To7 = (params->m_referenceFrameSignBias[1] << 1) |
1591 (params->m_referenceFrameSignBias[2] << 2) |
1592 (params->m_referenceFrameSignBias[3] << 3) |
1593 (params->m_referenceFrameSignBias[4] << 4) |
1594 (params->m_referenceFrameSignBias[5] << 5) |
1595 (params->m_referenceFrameSignBias[6] << 6) |
1596 (params->m_referenceFrameSignBias[7] << 7);
1597 cmd.DW6.CurrentFrameOrderHint = picParams->m_orderHint;
1598
1599 cmd.DW7.ReducedTxSetUsed = picParams->m_modeControlFlags.m_fields.m_reducedTxSetUsed;
1600 cmd.DW7.FrameTransformMode = picParams->m_modeControlFlags.m_fields.m_txMode;
1601 cmd.DW7.SkipModePresentFlag = picParams->m_modeControlFlags.m_fields.m_skipModePresent;
1602 cmd.DW7.SkipModeFrame0 = params->m_skipModeFrame[0] + lastFrame;
1603 cmd.DW7.SkipModeFrame1 = params->m_skipModeFrame[1] + lastFrame;
1604 cmd.DW7.RefFrameSide = (params->m_picParams->m_refFrameSide[0]) |
1605 (params->m_picParams->m_refFrameSide[1] << 1) |
1606 (params->m_picParams->m_refFrameSide[2] << 2) |
1607 (params->m_picParams->m_refFrameSide[3] << 3) |
1608 (params->m_picParams->m_refFrameSide[4] << 4) |
1609 (params->m_picParams->m_refFrameSide[5] << 5) |
1610 (params->m_picParams->m_refFrameSide[6] << 6) |
1611 (params->m_picParams->m_refFrameSide[7] << 7);
1612
1613 //inter frame uses 1..7 instead of 0..6 for LAST_FRAME->ALTREF_FRAME
1614 cmd.DW8.GlobalMotionType1 = picParams->m_wm[0].m_wmtype;
1615 cmd.DW8.GlobalMotionType2 = picParams->m_wm[1].m_wmtype;
1616 cmd.DW8.GlobalMotionType3 = picParams->m_wm[2].m_wmtype;
1617 cmd.DW8.GlobalMotionType4 = picParams->m_wm[3].m_wmtype;
1618 cmd.DW8.GlobalMotionType5 = picParams->m_wm[4].m_wmtype;
1619 cmd.DW8.GlobalMotionType6 = picParams->m_wm[5].m_wmtype;
1620 cmd.DW8.GlobalMotionType7 = picParams->m_wm[6].m_wmtype;
1621 cmd.DW8.FrameLevelGlobalMotionInvalidFlags = (picParams->m_wm[0].m_invalid << 1) |
1622 (picParams->m_wm[1].m_invalid << 2) |
1623 (picParams->m_wm[2].m_invalid << 3) |
1624 (picParams->m_wm[3].m_invalid << 4) |
1625 (picParams->m_wm[4].m_invalid << 5) |
1626 (picParams->m_wm[5].m_invalid << 6) |
1627 (picParams->m_wm[6].m_invalid << 7);
1628
1629 //DW9..DW29
1630 //It specifies the Warp Parameter set for each of the 7reference frames [LAST_FRAME .. ALTREF_FRAME]
1631 uint8_t idx = 0;
1632 for (uint32_t frame = (uint32_t)lastFrame; frame <= (uint32_t)altRefFrame; frame++)
1633 {
1634 cmd.WarpParametersArrayReference1To7Projectioncoeff0To5[idx++] = CAT2SHORTS(picParams->m_wm[frame - lastFrame].m_wmmat[0], picParams->m_wm[frame - lastFrame].m_wmmat[1]);
1635 cmd.WarpParametersArrayReference1To7Projectioncoeff0To5[idx++] = CAT2SHORTS(picParams->m_wm[frame - lastFrame].m_wmmat[2], picParams->m_wm[frame - lastFrame].m_wmmat[3]);
1636 cmd.WarpParametersArrayReference1To7Projectioncoeff0To5[idx++] = CAT2SHORTS(picParams->m_wm[frame - lastFrame].m_wmmat[4], picParams->m_wm[frame - lastFrame].m_wmmat[5]);
1637 }
1638
1639 cmd.DW30.ReferenceFrameIdx1 = lastFrame;
1640 cmd.DW30.ReferenceFrameIdx2 = last2Frame;
1641 cmd.DW30.ReferenceFrameIdx3 = last3Frame;
1642 cmd.DW30.ReferenceFrameIdx4 = goldenFrame;
1643 cmd.DW30.ReferenceFrameIdx5 = bwdRefFrame;
1644 cmd.DW30.ReferenceFrameIdx6 = altRef2Frame;
1645 cmd.DW30.ReferenceFrameIdx7 = altRefFrame;
1646
1647 //Setup reference frame width/height and scale factors
1648 if (picParams->m_picInfoFlags.m_fields.m_frameType != keyFrame && picParams->m_picInfoFlags.m_fields.m_frameType != intraOnlyFrame)
1649 {
1650 PCODEC_PICTURE refFrameList = &(picParams->m_refFrameMap[0]);
1651 uint32_t refFrameWidth[7], refFrameHeight[7];
1652 uint8_t refPicIndex;
1653 uint32_t av1ScalingFactorMax = (1 << 15); //!< AV1 Scaling factor range [1/16, 2]
1654 uint32_t av1ScalingFactorMin = (1 << 10); //!< AV1 Scaling factor range [1/16, 2]
1655
1656 union
1657 {
1658 struct
1659 {
1660 uint32_t m_verticalScaleFactor : 16; // Vertical Scale Factor
1661 uint32_t m_horizontalScaleFactor : 16; // Horizontal Scale Factor
1662 };
1663 uint32_t m_value;
1664 } refScaleFactor[7];
1665 union
1666 {
1667 struct
1668 {
1669 uint32_t m_widthInPixelMinus1 : 16; // Ref Frame Width In Pixel Minus 1
1670 uint32_t m_heightInPixelMinus1 : 16; // Ref Frame Height In Pixel Minus 1
1671 };
1672 uint32_t m_value;
1673 } refFrameRes[7];
1674
1675 memset(refScaleFactor, 0, sizeof(refScaleFactor));
1676 memset(refFrameRes, 0, sizeof(refFrameRes));
1677
1678 for (auto i = 0; i < 7; i++)//i=0 corresponds to LAST_FRAME
1679 {
1680 refPicIndex = refFrameList[picParams->m_refFrameIdx[i]].FrameIdx;
1681 refFrameWidth[i] = params->m_refList[refPicIndex]->m_frameWidth;
1682 refFrameHeight[i] = params->m_refList[refPicIndex]->m_frameHeight;
1683
1684 uint32_t curFrameWidth = picParams->m_frameWidthMinus1 + 1;
1685 uint32_t curFrameHeight = picParams->m_frameHeightMinus1 + 1;
1686
1687 refScaleFactor[i].m_horizontalScaleFactor = (refFrameWidth[i] * m_av1ScalingFactor + (curFrameWidth >> 1)) / curFrameWidth;
1688 refScaleFactor[i].m_verticalScaleFactor = (refFrameHeight[i] * m_av1ScalingFactor + (curFrameHeight >> 1)) / curFrameHeight;
1689
1690 refFrameRes[i].m_widthInPixelMinus1 = refFrameWidth[i] - 1;
1691 refFrameRes[i].m_heightInPixelMinus1 = refFrameHeight[i] - 1;
1692 MHW_CHK_COND(refScaleFactor[i].m_horizontalScaleFactor > av1ScalingFactorMax, "Invalid parameter");
1693 MHW_CHK_COND(refScaleFactor[i].m_verticalScaleFactor > av1ScalingFactorMax, "Invalid parameter");
1694 MHW_CHK_COND(refScaleFactor[i].m_horizontalScaleFactor < av1ScalingFactorMin, "Invalid parameter");
1695 MHW_CHK_COND(refScaleFactor[i].m_verticalScaleFactor < av1ScalingFactorMin, "Invalid parameter");
1696 }
1697
1698 cmd.DW31.Value = CAT2SHORTS(picParams->m_frameWidthMinus1, picParams->m_frameHeightMinus1);
1699 cmd.DW32.Value = refFrameRes[0].m_value;//LAST
1700 cmd.DW33.Value = refFrameRes[1].m_value;//LAST2
1701 cmd.DW34.Value = refFrameRes[2].m_value;//LAST3
1702 cmd.DW35.Value = refFrameRes[3].m_value;//GOLD
1703 cmd.DW36.Value = refFrameRes[4].m_value;//BWD
1704 cmd.DW37.Value = refFrameRes[5].m_value;//ALT2
1705 cmd.DW38.Value = refFrameRes[6].m_value;//ALT
1706
1707 cmd.DW39.Value = CAT2SHORTS(m_av1ScalingFactor, m_av1ScalingFactor);
1708 cmd.DW40.Value = refScaleFactor[0].m_value;//LAST
1709 cmd.DW41.Value = refScaleFactor[1].m_value;//LAST2
1710 cmd.DW42.Value = refScaleFactor[2].m_value;//LAST3
1711 cmd.DW43.Value = refScaleFactor[3].m_value;//GOLD
1712 cmd.DW44.Value = refScaleFactor[4].m_value;//BWD
1713 cmd.DW45.Value = refScaleFactor[5].m_value;//ALT2
1714 cmd.DW46.Value = refScaleFactor[6].m_value;//ALT
1715 }
1716
1717 cmd.DW47.ReferenceFrameOrderHint0ForIntraFrame = picParams->m_orderHint;
1718 cmd.DW47.ReferenceFrameOrderHint1ForLastFrame = params->m_refOrderHints[0];
1719 cmd.DW47.ReferenceFrameOrderHint2ForLast2Frame = params->m_refOrderHints[1];
1720 cmd.DW47.ReferenceFrameOrderHint3ForLast3Frame = params->m_refOrderHints[2];
1721 cmd.DW48.ReferenceFrameOrderHint4ForGoldenFrame = params->m_refOrderHints[3];
1722 cmd.DW48.ReferenceFrameOrderHint5ForBwdrefFrame = params->m_refOrderHints[4];
1723 cmd.DW48.ReferenceFrameOrderHint6ForAltref2Frame = params->m_refOrderHints[5];
1724 cmd.DW48.ReferenceFrameOrderHint7ForAltrefFrame = params->m_refOrderHints[6];
1725
1726 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1727
1728 return MOS_STATUS_SUCCESS;
1729 }
1730
AddAvpSegmentStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,MhwVdboxAvpSegmentStateParams * params)1731 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpSegmentStateCmd(
1732 PMOS_COMMAND_BUFFER cmdBuffer,
1733 MhwVdboxAvpSegmentStateParams *params)
1734 {
1735 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1736
1737 MHW_MI_CHK_NULL(m_osInterface);
1738 MHW_MI_CHK_NULL(params);
1739 MHW_MI_CHK_NULL(params->m_av1SegmentParams);
1740
1741 mhw_vdbox_avp_g12_X::AVP_SEGMENT_STATE_CMD cmd;
1742 uint8_t seg = params->m_currentSegmentId;
1743 cmd.DW1.SegmentId = seg;
1744
1745 cmd.DW2.SegmentFeatureMask = params->m_av1SegmentParams->m_featureMask[seg];
1746 cmd.DW2.SegmentDeltaQindex = params->m_av1SegmentParams->m_featureData[seg][segLvlAltQ];
1747 cmd.DW2.SegmentBlockSkipFlag = params->m_av1SegmentParams->m_featureData[seg][segLvlSkip];
1748 cmd.DW2.SegmentBlockGlobalmvFlag = params->m_av1SegmentParams->m_featureData[seg][segLvlGlobalMv];
1749 cmd.DW2.SegmentLosslessFlag = params->m_av1SegmentParams->m_losslessFlag[seg];
1750 cmd.DW2.SegmentLumaYQmLevel = params->m_av1SegmentParams->m_qmLevelY[seg];
1751 cmd.DW2.SegmentChromaUQmLevel = params->m_av1SegmentParams->m_qmLevelU[seg];
1752 cmd.DW2.SegmentChromaVQmLevel = params->m_av1SegmentParams->m_qmLevelV[seg];
1753
1754 cmd.DW3.SegmentDeltaLoopFilterLevelLumaVertical = params->m_av1SegmentParams->m_featureData[seg][segLvlAltLfYv];
1755 cmd.DW3.SegmentDeltaLoopFilterLevelLumaHorizontal = params->m_av1SegmentParams->m_featureData[seg][segLvlAltLfYh];
1756 cmd.DW3.SegmentDeltaLoopFilterLevelChromaU = params->m_av1SegmentParams->m_featureData[seg][segLvlAltLfU];
1757 cmd.DW3.SegmentDeltaLoopFilterLevelChromaV = params->m_av1SegmentParams->m_featureData[seg][segLvlAltLfV];
1758 cmd.DW3.SegmentReferenceFrame = params->m_av1SegmentParams->m_featureData[seg][segLvlRefFrame];
1759
1760 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
1761
1762 return eStatus;
1763 }
1764
AddAvpDecodeTileCodingCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,MhwVdboxAvpTileCodingParams * params)1765 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpDecodeTileCodingCmd(
1766 PMOS_COMMAND_BUFFER cmdBuffer,
1767 PMHW_BATCH_BUFFER batchBuffer,
1768 MhwVdboxAvpTileCodingParams *params)
1769 {
1770 MHW_FUNCTION_ENTER;
1771
1772 MHW_MI_CHK_NULL(params);
1773
1774 mhw_vdbox_avp_g12_X::AVP_TILE_CODING_CMD cmd;
1775 MHW_RESOURCE_PARAMS resourceParams;
1776 MEDIA_SYSTEM_INFO *gtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
1777 uint8_t numVdbox = (uint8_t)gtSystemInfo->VDBoxInfo.NumberOfVDBoxEnabled;
1778
1779 cmd.DW1.FrameTileId = params->m_tileId;
1780 cmd.DW1.TgTileNum = params->m_tgTileNum;
1781 cmd.DW1.TileGroupId = params->m_tileGroupId;
1782
1783 cmd.DW2.TileColumnPositionInSbUnit = params->m_tileColPositionInSb;
1784 cmd.DW2.TileRowPositionInSbUnit = params->m_tileRowPositionInSb;
1785
1786 cmd.DW3.TileWidthInSuperblockUnitMinus1 = params->m_tileWidthInSbMinus1;
1787 cmd.DW3.TileHeightInSuperblockUnitMinus1 = params->m_tileHeightInSbMinus1;
1788
1789 cmd.DW4.FilmGrainSampleTemplateWriteReadControl = 0;
1790 cmd.DW4.IslasttileofcolumnFlag = params->m_isLastTileOfColumn;
1791 cmd.DW4.IslasttileofrowFlag = params->m_isLastTileOfRow;
1792 cmd.DW4.IsstarttileoftilegroupFlag = params->m_isFirstTileOfTileGroup;
1793 cmd.DW4.IsendtileoftilegroupFlag = params->m_isLastTileOfTileGroup;
1794 cmd.DW4.IslasttileofframeFlag = params->m_isLastTileOfFrame;
1795 cmd.DW4.DisableCdfUpdateFlag = params->m_disableCdfUpdateFlag;
1796 cmd.DW4.DisableFrameContextUpdateFlag = params->m_disableFrameContextUpdateFlag;
1797
1798 cmd.DW5.NumberOfActiveBePipes = params->m_numOfActiveBePipes;
1799 cmd.DW5.NumOfTileColumnsMinus1InAFrame = params->m_numOfTileColumnsInFrame - 1;
1800 cmd.DW5.NumOfTileRowsMinus1InAFrame = params->m_numOfTileRowsInFrame - 1;
1801
1802 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1803
1804 return MOS_STATUS_SUCCESS;
1805 }
1806
AddAvpDecodeTileCodingCmdLst(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,MhwVdboxAvpTileCodingParams * params)1807 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpDecodeTileCodingCmdLst(
1808 PMOS_COMMAND_BUFFER cmdBuffer,
1809 PMHW_BATCH_BUFFER batchBuffer,
1810 MhwVdboxAvpTileCodingParams *params)
1811 {
1812 MHW_FUNCTION_ENTER;
1813
1814 MHW_MI_CHK_NULL(params);
1815
1816 mhw_vdbox_avp_g12_X::AVP_TILE_CODING_CMD_LST cmd;
1817 MHW_RESOURCE_PARAMS resourceParams;
1818 MEDIA_SYSTEM_INFO *gtSystemInfo = m_osInterface->pfnGetGtSystemInfo(m_osInterface);
1819 uint8_t numVdbox = (uint8_t)gtSystemInfo->VDBoxInfo.NumberOfVDBoxEnabled;
1820
1821 cmd.DW1.FrameTileId = params->m_tileId;
1822 cmd.DW1.TgTileNum = params->m_tgTileNum;
1823 cmd.DW1.TileGroupId = params->m_tileGroupId;
1824
1825 cmd.DW2.TileColumnPositionInSbUnit = params->m_tileColPositionInSb;
1826 cmd.DW2.TileRowPositionInSbUnit = params->m_tileRowPositionInSb;
1827
1828 cmd.DW3.TileWidthInSuperblockUnitMinus1 = params->m_tileWidthInSbMinus1;
1829 cmd.DW3.TileHeightInSuperblockUnitMinus1 = params->m_tileHeightInSbMinus1;
1830
1831 cmd.DW4.IslasttileofcolumnFlag = params->m_isLastTileOfColumn;
1832 cmd.DW4.IslasttileofrowFlag = params->m_isLastTileOfRow;
1833 cmd.DW4.IsstarttileoftilegroupFlag = params->m_isFirstTileOfTileGroup;
1834 cmd.DW4.IsendtileoftilegroupFlag = params->m_isLastTileOfTileGroup;
1835 cmd.DW4.IslasttileofframeFlag = params->m_isLastTileOfFrame;
1836 cmd.DW4.DisableCdfUpdateFlag = params->m_disableCdfUpdateFlag;
1837 cmd.DW4.DisableFrameContextUpdateFlag = params->m_disableFrameContextUpdateFlag;
1838
1839 cmd.DW5.NumberOfActiveBePipes = params->m_numOfActiveBePipes;
1840 cmd.DW5.NumOfTileColumnsMinus1InAFrame = params->m_numOfTileColumnsInFrame - 1;
1841 cmd.DW5.NumOfTileRowsMinus1InAFrame = params->m_numOfTileRowsInFrame - 1;
1842
1843 cmd.DW6.OutputDecodedTileColumnPositionInSbUnit = params->m_outputDecodedTileColumnPositionInSBUnit;
1844 cmd.DW6.OutputDecodedTileRowPositionInSbUnit = params->m_outputDecodedTileRowPositionInSBUnit;
1845
1846 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1847
1848 return MOS_STATUS_SUCCESS;
1849 }
1850
AddAvpTileCodingCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,MhwVdboxAvpTileCodingParams * params)1851 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpTileCodingCmd(
1852 PMOS_COMMAND_BUFFER cmdBuffer,
1853 PMHW_BATCH_BUFFER batchBuffer,
1854 MhwVdboxAvpTileCodingParams *params)
1855 {
1856 MHW_FUNCTION_ENTER;
1857
1858 MHW_MI_CHK_NULL(params);
1859
1860 if (m_decodeInUse)
1861 {
1862 if (MEDIA_IS_SKU(m_osInterface->pfnGetSkuTable(m_osInterface), FtrAV1VLDLSTDecoding) && !m_disableLstCmd)
1863 {
1864 MHW_MI_CHK_STATUS(AddAvpDecodeTileCodingCmdLst(cmdBuffer, batchBuffer, params));
1865 }
1866 else
1867 {
1868 MHW_MI_CHK_STATUS(AddAvpDecodeTileCodingCmd(cmdBuffer, batchBuffer, params));
1869 }
1870 }
1871 else
1872 {
1873 return MOS_STATUS_UNIMPLEMENTED;
1874 }
1875
1876 return MOS_STATUS_SUCCESS;
1877 }
1878
AddAvpBsdObjectCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,MhwVdboxAvpBsdParams * params)1879 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpBsdObjectCmd(
1880 PMOS_COMMAND_BUFFER cmdBuffer,
1881 PMHW_BATCH_BUFFER batchBuffer,
1882 MhwVdboxAvpBsdParams *params)
1883 {
1884 MHW_FUNCTION_ENTER;
1885
1886 MHW_MI_CHK_NULL(params);
1887
1888 mhw_vdbox_avp_g12_X::AVP_BSD_OBJECT_CMD cmd;
1889
1890 cmd.DW1.TileIndirectBsdDataLength = params->m_bsdDataLength;
1891 cmd.DW2.TileIndirectDataStartAddress = params->m_bsdDataStartOffset;
1892
1893 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1894
1895 return MOS_STATUS_SUCCESS;
1896 }
1897
AddAvpInloopFilterStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,MhwVdboxAvpPicStateParams * params)1898 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpInloopFilterStateCmd(
1899 PMOS_COMMAND_BUFFER cmdBuffer,
1900 MhwVdboxAvpPicStateParams *params)
1901 {
1902 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1903
1904 MHW_FUNCTION_ENTER;
1905
1906 MHW_MI_CHK_NULL(m_osInterface);
1907 MHW_MI_CHK_NULL(params);
1908 mhw_vdbox_avp_g12_X::AVP_INLOOP_FILTER_STATE_CMD cmd;
1909
1910 cmd.DW1.LumaYDeblockerFilterLevelVertical = params->m_picParams->m_filterLevel[0];
1911 cmd.DW1.LumaYDeblockerFilterLevelHorizontal = params->m_picParams->m_filterLevel[1];
1912 cmd.DW1.ChromaUDeblockerFilterLevel = params->m_picParams->m_filterLevelU;
1913 cmd.DW1.ChromaVDeblockerFilterLevel = params->m_picParams->m_filterLevelV;
1914 cmd.DW1.DeblockerFilterSharpnessLevel = params->m_picParams->m_loopFilterInfoFlags.m_fields.m_sharpnessLevel;
1915 cmd.DW1.DeblockerFilterModeRefDeltaEnableFlag = params->m_picParams->m_loopFilterInfoFlags.m_fields.m_modeRefDeltaEnabled;
1916 cmd.DW1.DeblockerDeltaLfResolution = params->m_picParams->m_modeControlFlags.m_fields.m_log2DeltaLfRes;
1917 cmd.DW1.DeblockerFilterDeltaLfMultiFlag = params->m_picParams->m_modeControlFlags.m_fields.m_deltaLfMulti;
1918 cmd.DW1.DeblockerFilterDeltaLfPresentFlag = params->m_picParams->m_modeControlFlags.m_fields.m_deltaLfPresentFlag;
1919
1920 //ref_deltas[0..7]
1921 cmd.DW2.DeblockerFilterRefDeltas0 = params->m_picParams->m_refDeltas[0];
1922 cmd.DW2.DeblockerFilterRefDeltas1 = params->m_picParams->m_refDeltas[1];
1923 cmd.DW2.DeblockerFilterRefDeltas2 = params->m_picParams->m_refDeltas[2];
1924 cmd.DW2.DeblockerFilterRefDeltas3 = params->m_picParams->m_refDeltas[3];
1925
1926 cmd.DW3.DeblockerFilterRefDeltas4 = params->m_picParams->m_refDeltas[4];
1927 cmd.DW3.DeblockerFilterRefDeltas5 = params->m_picParams->m_refDeltas[5];
1928 cmd.DW3.DeblockerFilterRefDeltas6 = params->m_picParams->m_refDeltas[6];
1929 cmd.DW3.DeblockerFilterRefDeltas7 = params->m_picParams->m_refDeltas[7];
1930
1931 //mode_deltas[0..1]
1932 cmd.DW4.DeblockerFilterModeDeltas0 = params->m_picParams->m_modeDeltas[0];
1933 cmd.DW4.DeblockerFilterModeDeltas1 = params->m_picParams->m_modeDeltas[1];
1934
1935 //cdef strength
1936 cmd.DW5.CdefYStrength0 = params->m_picParams->m_cdefYStrengths[0];
1937 cmd.DW5.CdefYStrength1 = params->m_picParams->m_cdefYStrengths[1];
1938 cmd.DW5.CdefYStrength2 = params->m_picParams->m_cdefYStrengths[2];
1939 cmd.DW5.CdefYStrength3 = params->m_picParams->m_cdefYStrengths[3];
1940 cmd.DW5.CdefBits = params->m_picParams->m_cdefBits;
1941 cmd.DW5.CdefFilterDampingFactorMinus3 = params->m_picParams->m_cdefDampingMinus3;
1942
1943 cmd.DW6.CdefYStrength4 = params->m_picParams->m_cdefYStrengths[4];
1944 cmd.DW6.CdefYStrength5 = params->m_picParams->m_cdefYStrengths[5];
1945 cmd.DW6.CdefYStrength6 = params->m_picParams->m_cdefYStrengths[6];
1946 cmd.DW6.CdefYStrength7 = params->m_picParams->m_cdefYStrengths[7];
1947
1948 cmd.DW7.CdefUvStrength0 = params->m_picParams->m_cdefUvStrengths[0];
1949 cmd.DW7.CdefUvStrength1 = params->m_picParams->m_cdefUvStrengths[1];
1950 cmd.DW7.CdefUvStrength2 = params->m_picParams->m_cdefUvStrengths[2];
1951 cmd.DW7.CdefUvStrength3 = params->m_picParams->m_cdefUvStrengths[3];
1952
1953 cmd.DW8.CdefUvStrength4 = params->m_picParams->m_cdefUvStrengths[4];
1954 cmd.DW8.CdefUvStrength5 = params->m_picParams->m_cdefUvStrengths[5];
1955 cmd.DW8.CdefUvStrength6 = params->m_picParams->m_cdefUvStrengths[6];
1956 cmd.DW8.CdefUvStrength7 = params->m_picParams->m_cdefUvStrengths[7];
1957
1958 //super-resolution
1959 cmd.DW9.SuperResUpscaledFrameWidthMinus1 = params->m_picParams->m_superResUpscaledWidthMinus1;
1960 cmd.DW9.SuperResDenom = params->m_picParams->m_picInfoFlags.m_fields.m_useSuperres ? params->m_picParams->m_superresScaleDenominator : 8;
1961
1962 //loop restoration
1963 cmd.DW10.FrameLoopRestorationFilterTypeForLumaY = params->m_picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType;
1964 cmd.DW10.FrameLoopRestorationFilterTypeForChromaU = params->m_picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType;
1965 cmd.DW10.FrameLoopRestorationFilterTypeForChromaV = params->m_picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType;
1966
1967 //LRU size for Y
1968 if (params->m_picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType == 0 &&
1969 params->m_picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType == 0 &&
1970 params->m_picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType == 0)
1971 {
1972 cmd.DW10.LoopRestorationUnitSizeForLumaY = 0;
1973 }
1974 else
1975 {
1976 cmd.DW10.LoopRestorationUnitSizeForLumaY = params->m_picParams->m_loopRestorationFlags.m_fields.m_lrUnitShift + 1;
1977 }
1978
1979 //LRU size for UV
1980 if (params->m_picParams->m_loopRestorationFlags.m_fields.m_yframeRestorationType == 0 &&
1981 params->m_picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType == 0 &&
1982 params->m_picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType == 0)
1983 {
1984 cmd.DW10.UseSameLoopRestorationUnitSizeForChromasUvFlag = 0;
1985 }
1986 else if(params->m_picParams->m_loopRestorationFlags.m_fields.m_cbframeRestorationType != 0 ||
1987 params->m_picParams->m_loopRestorationFlags.m_fields.m_crframeRestorationType != 0)
1988 {
1989 cmd.DW10.UseSameLoopRestorationUnitSizeForChromasUvFlag = (params->m_picParams->m_loopRestorationFlags.m_fields.m_lrUvShift == 0) ? 1 : 0;
1990 }
1991
1992 //super-res
1993 cmd.DW11.LumaPlaneXStepQn = params->m_lumaPlaneXStepQn;
1994 cmd.DW12.LumaPlaneX0Qn = params->m_lumaPlaneX0Qn;
1995 cmd.DW13.ChromaPlaneXStepQn = params->m_chromaPlaneXStepQn;
1996 cmd.DW14.ChromaPlaneX0Qn = params->m_chromaPlaneX0Qn;
1997
1998 if (params->m_picParams->m_picInfoFlags.m_fields.m_largeScaleTile)
1999 {
2000 //set to 0 to disable
2001 cmd.DW1.ChromaUDeblockerFilterLevel = 0;
2002 cmd.DW1.ChromaVDeblockerFilterLevel = 0;
2003
2004 //ref_deltas[0..7]
2005 cmd.DW2.DeblockerFilterRefDeltas0 = 1;
2006 cmd.DW2.DeblockerFilterRefDeltas1 = 0;
2007 cmd.DW2.DeblockerFilterRefDeltas2 = 0;
2008 cmd.DW2.DeblockerFilterRefDeltas3 = 0;
2009 cmd.DW3.DeblockerFilterRefDeltas4 = 0;
2010 cmd.DW3.DeblockerFilterRefDeltas5 = -1;
2011 cmd.DW3.DeblockerFilterRefDeltas6 = -1;
2012 cmd.DW3.DeblockerFilterRefDeltas7 = -1;
2013 }
2014
2015 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
2016
2017 return eStatus;
2018 }
2019
AddAvpInterPredStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,MhwVdboxAvpPicStateParams * params)2020 MOS_STATUS MhwVdboxAvpInterfaceG12::AddAvpInterPredStateCmd(
2021 PMOS_COMMAND_BUFFER cmdBuffer,
2022 MhwVdboxAvpPicStateParams *params)
2023 {
2024 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
2025
2026 MHW_FUNCTION_ENTER;
2027
2028 MHW_MI_CHK_NULL(m_osInterface);
2029 MHW_MI_CHK_NULL(params);
2030 mhw_vdbox_avp_g12_X::AVP_INTER_PRED_STATE_CMD cmd;
2031
2032 //LAST
2033 cmd.DW1.SavedOrderHintsForAllReferences00 = params->m_savedRefOrderHints[0][0];
2034 cmd.DW1.SavedOrderHintsForAllReferences01 = params->m_savedRefOrderHints[0][1];
2035 cmd.DW1.SavedOrderHintsForAllReferences02 = params->m_savedRefOrderHints[0][2];
2036 cmd.DW1.SavedOrderHintsForAllReferences03 = params->m_savedRefOrderHints[0][3];
2037 cmd.DW2.SavedOrderHintsForAllReferences04 = params->m_savedRefOrderHints[0][4];
2038 cmd.DW2.SavedOrderHintsForAllReferences05 = params->m_savedRefOrderHints[0][5];
2039 cmd.DW2.SavedOrderHintsForAllReferences06 = params->m_savedRefOrderHints[0][6];
2040 cmd.DW2.ActiveReferenceBitmaskForMotionFieldProjection = params->m_refMaskMfProj;
2041
2042 //LAST2
2043 cmd.DW3.SavedOrderHintsForAllReferences10 = params->m_savedRefOrderHints[1][0];
2044 cmd.DW3.SavedOrderHintsForAllReferences11 = params->m_savedRefOrderHints[1][1];
2045 cmd.DW3.SavedOrderHintsForAllReferences12 = params->m_savedRefOrderHints[1][2];
2046 cmd.DW3.SavedOrderHintsForAllReferences13 = params->m_savedRefOrderHints[1][3];
2047 cmd.DW4.SavedOrderHintsForAllReferences14 = params->m_savedRefOrderHints[1][4];
2048 cmd.DW4.SavedOrderHintsForAllReferences15 = params->m_savedRefOrderHints[1][5];
2049 cmd.DW4.SavedOrderHintsForAllReferences16 = params->m_savedRefOrderHints[1][6];
2050
2051 //LAST3
2052 cmd.DW5.SavedOrderHintsForAllReferences20 = params->m_savedRefOrderHints[2][0];
2053 cmd.DW5.SavedOrderHintsForAllReferences21 = params->m_savedRefOrderHints[2][1];
2054 cmd.DW5.SavedOrderHintsForAllReferences22 = params->m_savedRefOrderHints[2][2];
2055 cmd.DW5.SavedOrderHintsForAllReferences23 = params->m_savedRefOrderHints[2][3];
2056 cmd.DW6.SavedOrderHintsForAllReferences24 = params->m_savedRefOrderHints[2][4];
2057 cmd.DW6.SavedOrderHintsForAllReferences25 = params->m_savedRefOrderHints[2][5];
2058 cmd.DW6.SavedOrderHintsForAllReferences26 = params->m_savedRefOrderHints[2][6];
2059
2060 //GOLDEN_FRAME
2061 cmd.DW7.SavedOrderHintsForAllReferences30 = params->m_savedRefOrderHints[3][0];
2062 cmd.DW7.SavedOrderHintsForAllReferences31 = params->m_savedRefOrderHints[3][1];
2063 cmd.DW7.SavedOrderHintsForAllReferences32 = params->m_savedRefOrderHints[3][2];
2064 cmd.DW7.SavedOrderHintsForAllReferences33 = params->m_savedRefOrderHints[3][3];
2065 cmd.DW8.SavedOrderHintsForAllReferences34 = params->m_savedRefOrderHints[3][4];
2066 cmd.DW8.SavedOrderHintsForAllReferences35 = params->m_savedRefOrderHints[3][5];
2067 cmd.DW8.SavedOrderHintsForAllReferences36 = params->m_savedRefOrderHints[3][6];
2068
2069 //BWDREF_FRAME
2070 cmd.DW9.SavedOrderHintsForAllReferences40 = params->m_savedRefOrderHints[4][0];
2071 cmd.DW9.SavedOrderHintsForAllReferences41 = params->m_savedRefOrderHints[4][1];
2072 cmd.DW9.SavedOrderHintsForAllReferences42 = params->m_savedRefOrderHints[4][2];
2073 cmd.DW9.SavedOrderHintsForAllReferences43 = params->m_savedRefOrderHints[4][3];
2074 cmd.DW10.SavedOrderHintsForAllReferences44 = params->m_savedRefOrderHints[4][4];
2075 cmd.DW10.SavedOrderHintsForAllReferences45 = params->m_savedRefOrderHints[4][5];
2076 cmd.DW10.SavedOrderHintsForAllReferences46 = params->m_savedRefOrderHints[4][6];
2077
2078 //ALTREF2_FRAME
2079 cmd.DW11.SavedOrderHintsForAllReferences50 = params->m_savedRefOrderHints[5][0];
2080 cmd.DW11.SavedOrderHintsForAllReferences51 = params->m_savedRefOrderHints[5][1];
2081 cmd.DW11.SavedOrderHintsForAllReferences52 = params->m_savedRefOrderHints[5][2];
2082 cmd.DW11.SavedOrderHintsForAllReferences53 = params->m_savedRefOrderHints[5][3];
2083 cmd.DW12.SavedOrderHintsForAllReferences54 = params->m_savedRefOrderHints[5][4];
2084 cmd.DW12.SavedOrderHintsForAllReferences55 = params->m_savedRefOrderHints[5][5];
2085 cmd.DW12.SavedOrderHintsForAllReferences56 = params->m_savedRefOrderHints[5][6];
2086
2087 //ALTREF_FRAME
2088 cmd.DW13.SavedOrderHintsForAllReferences60 = params->m_savedRefOrderHints[6][0];
2089 cmd.DW13.SavedOrderHintsForAllReferences61 = params->m_savedRefOrderHints[6][1];
2090 cmd.DW13.SavedOrderHintsForAllReferences62 = params->m_savedRefOrderHints[6][2];
2091 cmd.DW13.SavedOrderHintsForAllReferences63 = params->m_savedRefOrderHints[6][3];
2092 cmd.DW14.SavedOrderHintsForAllReferences64 = params->m_savedRefOrderHints[6][4];
2093 cmd.DW14.SavedOrderHintsForAllReferences65 = params->m_savedRefOrderHints[6][5];
2094 cmd.DW14.SavedOrderHintsForAllReferences66 = params->m_savedRefOrderHints[6][6];
2095
2096 MHW_MI_CHK_STATUS(m_osInterface->pfnAddCommand(cmdBuffer, &cmd, cmd.byteSize));
2097
2098 return eStatus;
2099 }
2100