Debian Codegraph @

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

raw
1 /*
2 * Copyright (c) 2017-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 //! \file mhw_vdbox_vdenc_g9_X.h
24 //! \details Defines functions for constructing Vdbox Vdenc commands on Gen9-based platforms
25 //!
26
27 #ifndef __MHW_VDBOX_VDENC_G9_X_H__
28 #define __MHW_VDBOX_VDENC_G9_X_H__
29
30 #include "mhw_vdbox_vdenc_generic.h"
31
32 //! MHW Vdbox Vdenc interface for Gen9
33 /*!
34 This class defines the Vdenc command construction functions for Gen9 platforms as template
35 */
36 template <class TVdencCmds>
37 class MhwVdboxVdencInterfaceG9 : public MhwVdboxVdencInterfaceGeneric<TVdencCmds>
38 {
39 public:
40 //!
41 //! \brief Destructor
42 //!
43 virtual ~MhwVdboxVdencInterfaceG9() { }
44
45 protected:
46 enum CommandsNumberOfAddresses
47 {
48 VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 12
49 };
50
51 //!
52 //! \brief Constructor
53 //!
54 MhwVdboxVdencInterfaceG9(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceGeneric<TVdencCmds>(osInterface)
55 {
56 MHW_FUNCTION_ENTER;
57
58 this->InitRowstoreUserFeatureSettings();
59 }
60
61 MOS_STATUS InitRowstoreUserFeatureSettings()
62 {
63 MHW_FUNCTION_ENTER;
64
65 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
66 MEDIA_FEATURE_TABLE *skuTable = this->m_osInterface->pfnGetSkuTable(this->m_osInterface);
67
68 MHW_MI_CHK_NULL(skuTable);
69
70 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
71 userFeatureData.u32Data = 0;
72
73 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
74 #if (_DEBUG || _RELEASE_INTERNAL)
75 MOS_UserFeature_ReadValue_ID(
76 nullptr,
77 __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
78 &userFeatureData,
79 this->m_osInterface->pOsContext);
80 #endif // _DEBUG || _RELEASE_INTERNAL
81 this->m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;
82
83 if (this->m_rowstoreCachingSupported)
84 {
85 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
86 #if (_DEBUG || _RELEASE_INTERNAL)
87 MOS_UserFeature_ReadValue_ID(
88 nullptr,
89 __MEDIA_USER_FEATURE_VALUE_VDENCROWSTORECACHE_DISABLE_ID,
90 &userFeatureData,
91 this->m_osInterface->pOsContext);
92 #endif // _DEBUG || _RELEASE_INTERNAL
93 this->m_vdencRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
94 }
95
96 return MOS_STATUS_SUCCESS;
97 }
98
99 MOS_STATUS GetRowstoreCachingAddrs(
100 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
101 {
102 MHW_FUNCTION_ENTER;
103
104 MHW_CHK_NULL_RETURN(rowstoreParams);
105
106 if (this->m_vdencRowStoreCache.bSupported && rowstoreParams->Mode == CODECHAL_ENCODE_MODE_AVC)
107 {
108 this->m_vdencRowStoreCache.bEnabled = true;
109
110 if (rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_2K)
111 {
112 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_LESS_THAN_2K;
113 }
114 else if (rowstoreParams->dwPicWidth >= MHW_VDBOX_PICWIDTH_2K && rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_3K)
115 {
116 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_2K_AND_3K;
117 }
118 else if (rowstoreParams->dwPicWidth >= MHW_VDBOX_PICWIDTH_3K && rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_4K)
119 {
120 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_3K_AND_4K;
121 }
122 else
123 {
124 this->m_vdencRowStoreCache.dwAddress = 0;
125 this->m_vdencRowStoreCache.bEnabled = false;
126 }
127 }
128
129 return MOS_STATUS_SUCCESS;
130 }
131
132 MOS_STATUS GetVdencStateCommandsDataSize(
133 uint32_t mode,
134 uint32_t waAddDelayInVDEncDynamicSlice,
135 uint32_t *commandsSize,
136 uint32_t *patchListSize)
137 {
138 MHW_FUNCTION_ENTER;
139
140 uint32_t maxSize = 0;
141 uint32_t patchListMaxSize = 0;
142 uint32_t standard = CodecHal_GetStandardFromMode(mode);
143
144 if (standard == CODECHAL_AVC)
145 {
146 maxSize =
147 TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
148 TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
149 TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
150 TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
151 TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
152 TVdencCmds::VDENC_CONST_QPT_STATE_CMD::byteSize +
153 TVdencCmds::VDENC_IMG_STATE_CMD::byteSize +
154 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
155 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
156
157 if (waAddDelayInVDEncDynamicSlice)
158 {
159 maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
160 }
161
162 patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
163 }
164 else
165 {
166 MHW_ASSERTMESSAGE("Unsupported encode mode.");
167 *commandsSize = 0;
168 *patchListSize = 0;
169 return MOS_STATUS_UNKNOWN;
170 }
171
172 *commandsSize = maxSize;
173 *patchListSize = patchListMaxSize;
174
175 return MOS_STATUS_SUCCESS;
176 }
177
178 MOS_STATUS GetVdencPrimitiveCommandsDataSize(
179 uint32_t mode,
180 uint32_t *commandsSize,
181 uint32_t *patchListSize)
182 {
183 MHW_FUNCTION_ENTER;
184
185 uint32_t maxSize = 0;
186 uint32_t patchListMaxSize = 0;
187 uint32_t standard = CodecHal_GetStandardFromMode(mode);
188
189 if (standard == CODECHAL_AVC)
190 {
191 maxSize =
192 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
193 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
194
195 patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
196 }
197 else
198 {
199 MHW_ASSERTMESSAGE("Unsupported encode mode.");
200 *commandsSize = 0;
201 *patchListSize = 0;
202 return MOS_STATUS_UNKNOWN;
203 }
204
205 *commandsSize = maxSize;
206 *patchListSize = patchListMaxSize;
207
208 return MOS_STATUS_SUCCESS;
209 }
210
211 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS CreateMhwVdboxPipeModeSelectParams()
212 {
213 auto pipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS);
214
215 return pipeModeSelectParams;
216 }
217
218 void ReleaseMhwVdboxPipeModeSelectParams(PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams)
219 {
220 MOS_Delete(pipeModeSelectParams);
221 }
222
223 MOS_STATUS AddVdencPipeModeSelectCmd(
224 PMOS_COMMAND_BUFFER cmdBuffer,
225 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
226 {
227 MHW_FUNCTION_ENTER;
228
229 MHW_MI_CHK_NULL(this->m_osInterface);
230 MHW_MI_CHK_NULL(cmdBuffer);
231 MHW_MI_CHK_NULL(params);
232
233 typename TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD cmd;
234
235 cmd.DW1.StandardSelect = CodecHal_GetStandardFromMode(params->Mode);
236 cmd.DW1.FrameStatisticsStreamOutEnable = 1;
237 cmd.DW1.TlbPrefetchEnable = params->bTlbPrefetchEnable;
238 cmd.DW1.PakThresholdCheckEnable = params->bDynamicSliceEnable;
239 cmd.DW1.VdencStreamInEnable = params->bVdencStreamInEnable;
240
241 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
242
243 return MOS_STATUS_SUCCESS;
244 }
245
246 MOS_STATUS AddVdencPipeBufAddrCmd(
247 PMOS_COMMAND_BUFFER cmdBuffer,
248 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
249 {
250 MOS_SURFACE details;
251 uint8_t refIdx;
252
253 MHW_FUNCTION_ENTER;
254
255 MHW_MI_CHK_NULL(cmdBuffer);
256 MHW_MI_CHK_NULL(params);
257 MHW_MI_CHK_NULL(this->m_osInterface);
258
259 typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD cmd;
260
261 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
262 MHW_RESOURCE_PARAMS resourceParams;
263 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
264 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
265 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
266
267 if (params->psRawSurface != nullptr)
268 {
269
270 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, &params->psRawSurface->OsResource, &mmcMode));
271
272 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable =
273 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
274 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
275 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionMode =
276 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
277 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
278 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState =
279 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
280
281 cmd.OriginalUncompressedPicture.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
282
283 resourceParams.presResource = &params->psRawSurface->OsResource;
284 resourceParams.dwOffset = params->psRawSurface->dwOffset;
285 resourceParams.pdwCmd = &(cmd.OriginalUncompressedPicture.LowerAddress.DW0.Value);
286 resourceParams.dwLocationInCmd = 10;
287 resourceParams.bIsWritable = false;
288
289 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
290 this->m_osInterface,
291 cmdBuffer,
292 &resourceParams));
293 }
294
295 if (this->m_vdencRowStoreCache.bEnabled)
296 {
297 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = TVdencCmds::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
298 cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_vdencRowStoreCache.dwAddress << 6;
299 }
300 else if (params->presVdencIntraRowStoreScratchBuffer != nullptr)
301 {
302 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
303 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;
304
305 resourceParams.presResource = params->presVdencIntraRowStoreScratchBuffer;
306 resourceParams.dwOffset = 0;
307 resourceParams.pdwCmd = &(cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value);
308 resourceParams.dwLocationInCmd = 16;
309 resourceParams.bIsWritable = true;
310
311 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
312 this->m_osInterface,
313 cmdBuffer,
314 &resourceParams));
315 }
316
317 if (params->presVdencStreamOutBuffer != nullptr)
318 {
319 cmd.VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState =
320 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
321
322 resourceParams.presResource = params->presVdencStreamOutBuffer;
323 resourceParams.dwOffset = 0;
324 resourceParams.pdwCmd = &(cmd.VdencStatisticsStreamout.LowerAddress.DW0.Value);
325 resourceParams.dwLocationInCmd = 34;
326 resourceParams.bIsWritable = true;
327
328 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
329 this->m_osInterface,
330 cmdBuffer,
331 &resourceParams));
332 }
333
334 if (params->presVdencStreamInBuffer != nullptr)
335 {
336 cmd.StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState =
337 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
338
339 resourceParams.presResource = params->presVdencStreamInBuffer;
340 resourceParams.dwOffset = 0;
341 resourceParams.pdwCmd = &(cmd.StreaminDataPicture.LowerAddress.DW0.Value);
342 resourceParams.dwLocationInCmd = 13;
343 resourceParams.bIsWritable = false;
344
345 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
346 this->m_osInterface,
347 cmdBuffer,
348 &resourceParams));
349 }
350
351 for (refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++)
352 {
353 if (params->presVdencReferences[refIdx])
354 {
355 // L0 references
356 MOS_ZeroMemory(&details, sizeof(details));
357 details.Format = Format_Invalid;
358 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdencReferences[refIdx], &details));
359
360 resourceParams.presResource = params->presVdencReferences[refIdx];
361 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
362 resourceParams.dwLocationInCmd = (refIdx * 3) + 22;
363 resourceParams.bIsWritable = false;
364 switch (refIdx)
365 {
366 case 0:
367 resourceParams.pdwCmd = &(cmd.FwdRef0.LowerAddress.DW0.Value);
368 break;
369 case 1:
370 resourceParams.pdwCmd = &(cmd.FwdRef1.LowerAddress.DW0.Value);
371 break;
372 case 2:
373 resourceParams.pdwCmd = &(cmd.FwdRef2.LowerAddress.DW0.Value);
374 break;
375 default:
376 break;
377 }
378
379 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
380
381 switch (refIdx)
382 {
383 case 0:
384 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionEnable =
385 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
386 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
387 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionMode =
388 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
389 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
390 cmd.FwdRef0.PictureFields.DW0.MemoryObjectControlState =
391 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
392 cmd.FwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
393 break;
394 case 1:
395 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionEnable =
396 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
397 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
398 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionMode =
399 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
400 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
401 cmd.FwdRef1.PictureFields.DW0.MemoryObjectControlState =
402 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
403 cmd.FwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
404 break;
405 case 2:
406 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionEnable =
407 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
408 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
409 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionMode =
410 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
411 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
412 cmd.FwdRef2.PictureFields.DW0.MemoryObjectControlState =
413 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
414 cmd.FwdRef2.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
415 break;
416 default:
417 break;
418 }
419
420 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
421 this->m_osInterface,
422 cmdBuffer,
423 &resourceParams));
424 }
425
426 // so far VDEnc only support 2 4x/8x DS Ref Pictures
427 if ((refIdx <= 1) && params->presVdenc4xDsSurface[refIdx])
428 {
429 // 4x DS surface for VDEnc
430 MOS_ZeroMemory(&details, sizeof(details));
431 details.Format = Format_Invalid;
432 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));
433
434 resourceParams.presResource = params->presVdenc4xDsSurface[refIdx];
435 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
436 resourceParams.dwLocationInCmd = (refIdx * 3) + 1;
437 resourceParams.bIsWritable = false;
438 switch (refIdx)
439 {
440 case 0:
441 resourceParams.pdwCmd = &(cmd.DsFwdRef0.LowerAddress.DW0.Value);
442 break;
443 case 1:
444 resourceParams.pdwCmd = &(cmd.DsFwdRef1.LowerAddress.DW0.Value);
445 break;
446 default:
447 break;
448 }
449
450 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
451
452 switch (refIdx)
453 {
454 case 0:
455 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable =
456 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
457 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
458 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionMode =
459 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
460 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
461 cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
462 break;
463 case 1:
464 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable =
465 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
466 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
467 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionMode =
468 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
469 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
470 cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
471 break;
472 default:
473 break;
474 }
475
476 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
477 this->m_osInterface,
478 cmdBuffer,
479 &resourceParams));
480 }
481 }
482
483 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
484
485 return MOS_STATUS_SUCCESS;
486 }
487
488 MOS_STATUS AddVdencRefSurfaceStateCmd(
489 PMOS_COMMAND_BUFFER cmdBuffer,
490 PMHW_VDBOX_SURFACE_PARAMS params)
491 {
492 MHW_FUNCTION_ENTER;
493
494 MHW_MI_CHK_NULL(this->m_osInterface);
495 MHW_MI_CHK_NULL(cmdBuffer);
496 MHW_MI_CHK_NULL(params);
497 MHW_MI_CHK_NULL(params->psSurface);
498
499 typename TVdencCmds::VDENC_REF_SURFACE_STATE_CMD cmd;
500
501 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1;
502 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
503 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
504
505 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
506
507 if (cmd.Dwords25.DW1.TiledSurface)
508 {
509 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType);
510 }
511
512 cmd.Dwords25.DW1.SurfaceFormat = this->MosToMediaStateFormat(params->psSurface->Format); //dwSurfaceFormat; should be 4
513 cmd.Dwords25.DW1.InterleaveChroma = 1;
514 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
515 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset;
516
517 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
518
519 return MOS_STATUS_SUCCESS;
520 }
521
522 MOS_STATUS AddVdencDsRefSurfaceStateCmd(
523 PMOS_COMMAND_BUFFER cmdBuffer,
524 PMHW_VDBOX_SURFACE_PARAMS params,
525 uint8_t numSurfaces)
526 {
527 MHW_FUNCTION_ENTER;
528
529 MOS_UNUSED(numSurfaces);
530
531 MHW_MI_CHK_NULL(this->m_osInterface);
532 MHW_MI_CHK_NULL(cmdBuffer);
533 MHW_MI_CHK_NULL(params);
534 MHW_MI_CHK_NULL(params->psSurface);
535
536 typename TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD cmd;
537
538 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1;
539 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
540 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
541
542 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
543
544 if (cmd.Dwords25.DW1.TiledSurface)
545 {
546 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType);
547 }
548 cmd.Dwords25.DW1.SurfaceFormat = this->MosToMediaStateFormat(params->psSurface->Format); //dwSurfaceFormat; should be 4
549 cmd.Dwords25.DW1.InterleaveChroma = 1;
550 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
551 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset;
552
553 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
554
555 return MOS_STATUS_SUCCESS;
556 }
557
558 MOS_STATUS AddVdencWeightsOffsetsStateCmd(
559 PMOS_COMMAND_BUFFER cmdBuffer,
560 PMHW_BATCH_BUFFER batchBuffer,
561 PMHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS params)
562 {
563 MOS_UNUSED(cmdBuffer);
564 MOS_UNUSED(batchBuffer);
565 MOS_UNUSED(params);
566 return MOS_STATUS_PLATFORM_NOT_SUPPORTED;
567 }
568
569 MOS_STATUS AddVdencCmd1Cmd(
570 PMOS_COMMAND_BUFFER cmdBuffer,
571 PMHW_BATCH_BUFFER batchBuffer,
572 PMHW_VDBOX_VDENC_CMD1_PARAMS params)
573 {
574 MOS_UNUSED(cmdBuffer);
575 MOS_UNUSED(batchBuffer);
576 MOS_UNUSED(params);
577 return MOS_STATUS_SUCCESS;
578 }
579
580 MOS_STATUS AddVdencCmd2Cmd(
581 PMOS_COMMAND_BUFFER cmdBuffer,
582 PMHW_BATCH_BUFFER batchBuffer,
583 PMHW_VDBOX_VDENC_CMD2_STATE params)
584 {
585 MOS_UNUSED(cmdBuffer);
586 MOS_UNUSED(batchBuffer);
587 MOS_UNUSED(params);
588 return MOS_STATUS_SUCCESS;
589 }
590
591 public:
592 inline uint32_t GetVdencCmd1Size()
593 {
594 return 0;
595 }
596
597 inline uint32_t GetVdencCmd2Size()
598 {
599 return 0;
600 }
601 };
602
603 #endif