Debian Codegraph @

media_driver/agnostic/gen11/hw/vdbox/mhw_vdbox_vdenc_g11_X.h

raw
1 /*
2 * Copyright (c) 2017-2021, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22
23 //! \file mhw_vdbox_vdenc_g11_X.h
24 //! \details Defines functions for constructing Vdbox Vdenc commands on Gen11-based platforms
25 //!
26
27 #ifndef __MHW_VDBOX_VDENC_G11_X_H__
28 #define __MHW_VDBOX_VDENC_G11_X_H__
29
30 #include "mhw_vdbox_vdenc_generic.h"
31 #include "mhw_vdbox_vdenc_hwcmd_g11_X.h"
32 #include "mhw_vdbox_g11_X.h"
33 #include "mos_interface.h"
34
35 #define MHW_VDBOX_PICWIDTH_1920 1920
36 #define MHW_VDBOX_PICWIDTH_3840 3840
37 #define VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_LESS_THAN_1920 360
38 #define VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_1920_AND_3840 480
39 #define VP9VDENCROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_1920 180
40 #define VP9VDENCROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_1920_4208B 570
41
42 struct MHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G11 : public MHW_VDBOX_VDENC_WALKER_STATE_PARAMS
43 {
44 // GEN11+ tiling support
45 PMHW_VDBOX_HCP_TILE_CODING_PARAMS_G11 pTileCodingParams = nullptr;
46 uint32_t dwNumberOfPipes = 0;
47 uint32_t dwTileId = 0;
48 };
49 using PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G11 = MHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G11 *;
50
51 //! MHW Vdbox Vdenc interface for Gen11
52 /*!
53 This class defines the Vdenc command construction functions for Gen11 platforms as template
54 */
55 template <class TVdencCmds>
56 class MhwVdboxVdencInterfaceG11 : public MhwVdboxVdencInterfaceGeneric<TVdencCmds>
57 {
58 protected:
59 enum CommandsNumberOfAddresses
60 {
61 MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES = 1,
62 MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES = 1,
63 VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES = 21
64 };
65
66 enum VdencSurfaceFormat
67 {
68 vdencSurfaceFormatYuv422 = 0x0,
69 vdencSurfaceFormatRgba4444 = 0x1,
70 vdencSurfaceFormatYuv444 = 0x2,
71 vdencSurfaceFormatP010Variant = 0x3,
72 vdencSurfaceFormatPlanar420_8 = 0x4,
73 vdencSurfaceFormatYcrcbSwapy422 = 0x5,
74 vdencSurfaceFormatYcrcbSwapuv422 = 0x6,
75 vdencSurfaceFormatYcrcbSwapuvy422 = 0x7,
76 vdencSurfaceFormatY216 = 0x8,
77 vdencSurfaceFormatY210 = 0x8, // Same value is used to represent Y216 and Y210
78 vdencSurfaceFormatRgba_10_10_10_2 = 0x9,
79 vdencSurfaceFormatY410 = 0xa,
80 vdencSurfaceFormatNv21 = 0xb,
81 vdencSurfaceFormatY416 = 0xc,
82 vdencSurfaceFormatP010 = 0xd,
83 vdencSurfaceFormatPlanarP016 = 0xe,
84 vdencSurfaceFormatY8Unorm = 0xf,
85 vdencSurfaceFormatY16 = 0x10,
86 vdencSurfaceFormatY216Variant = 0x11,
87 vdencSurfaceFormatY416Variant = 0x12,
88 vdencSurfaceFormatYuyvVariant = 0x13,
89 vdencSurfaceFormatAyuvVariant = 0x14,
90 };
91
92 //!
93 //! \brief Translate MOS type format to Vdenc surface raw format
94 //! \details VDBOX protected function to translate mos format to media state format
95 //! \param MOS_FORMAT Format
96 //! [in] MOS type format
97 //! \return VdencSurfaceFormat
98 //! media state surface format
99 //!
100 VdencSurfaceFormat MosFormatToVdencSurfaceRawFormat(
101 MOS_FORMAT format)
102 {
103 MHW_FUNCTION_ENTER;
104
105 switch (format)
106 {
107 case Format_A8R8G8B8:
108 case Format_X8R8G8B8:
109 case Format_A8B8G8R8:
110 return vdencSurfaceFormatRgba4444;
111 case Format_NV12:
112 case Format_NV11:
113 case Format_P208:
114 case Format_IMC1:
115 case Format_IMC2:
116 case Format_IMC3:
117 case Format_IMC4:
118 return vdencSurfaceFormatPlanar420_8;
119 case Format_400P:
120 case Format_P8:
121 return vdencSurfaceFormatY8Unorm;
122 case Format_UYVY:
123 return vdencSurfaceFormatYcrcbSwapy422;
124 case Format_YVYU:
125 return vdencSurfaceFormatYcrcbSwapuv422;
126 case Format_VYUY:
127 return vdencSurfaceFormatYcrcbSwapuvy422;
128 case Format_444P:
129 case Format_AYUV:
130 return vdencSurfaceFormatYuv444;
131 case Format_YUY2:
132 case Format_YUYV:
133 return vdencSurfaceFormatYuv422;
134 case Format_P010:
135 return vdencSurfaceFormatP010;
136 case Format_R10G10B10A2:
137 case Format_B10G10R10A2:
138 return vdencSurfaceFormatRgba_10_10_10_2;
139 // Only Y210 supported now, allocated as Y216 format by 3D driver
140 case Format_Y210:
141 case Format_Y216:
142 return vdencSurfaceFormatY216;
143 case Format_Y410:
144 return vdencSurfaceFormatY410;
145 case Format_NV21:
146 return vdencSurfaceFormatNv21;
147 default:
148 return vdencSurfaceFormatPlanar420_8;
149 }
150
151 return vdencSurfaceFormatYuv422;
152 }
153
154 //!
155 //! \brief Translate MOS type format to Vdenc surface recon format
156 //! \details VDBOX protected function to translate mos format to media state recon format
157 //! \param MOS_FORMAT Format
158 //! [in] MOS type format
159 //! \return VdencSurfaceFormat
160 //! media state surface format
161 //!
162 VdencSurfaceFormat MosFormatToVdencSurfaceReconFormat(
163 MOS_FORMAT format)
164 {
165 MHW_FUNCTION_ENTER;
166
167 switch (format)
168 {
169 case Format_A8R8G8B8:
170 case Format_X8R8G8B8:
171 case Format_A8B8G8R8:
172 return vdencSurfaceFormatRgba4444;
173 case Format_NV12:
174 case Format_IMC1:
175 case Format_IMC2:
176 case Format_IMC3:
177 case Format_IMC4:
178 return vdencSurfaceFormatPlanar420_8;
179 case Format_400P:
180 case Format_P8:
181 return vdencSurfaceFormatY8Unorm;
182 case Format_UYVY:
183 return vdencSurfaceFormatYcrcbSwapy422;
184 case Format_YVYU:
185 return vdencSurfaceFormatYcrcbSwapuv422;
186 case Format_VYUY:
187 return vdencSurfaceFormatYcrcbSwapuvy422;
188 case Format_444P:
189 case Format_AYUV:
190 return vdencSurfaceFormatAyuvVariant;
191 case Format_YUY2:
192 case Format_YUYV:
193 return vdencSurfaceFormatYuyvVariant;
194 case Format_P010:
195 return vdencSurfaceFormatP010Variant;
196 case Format_R10G10B10A2:
197 return vdencSurfaceFormatRgba_10_10_10_2;
198 case Format_Y216:
199 return vdencSurfaceFormatY216Variant;
200 case Format_Y410:
201 return vdencSurfaceFormatY416Variant;
202 case Format_NV21:
203 return vdencSurfaceFormatNv21;
204 default:
205 return vdencSurfaceFormatPlanar420_8;
206 }
207 }
208
209 public:
210 //!
211 //! \brief Constructor
212 //!
213 MhwVdboxVdencInterfaceG11(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceGeneric<TVdencCmds>(osInterface)
214 {
215 MHW_FUNCTION_ENTER;
216
217 this->m_rhoDomainStatsEnabled = true;
218 this->InitRowstoreUserFeatureSettings();
219 }
220
221 inline uint32_t GetVdencCmd1Size()
222 {
223 return 0;
224 }
225
226 inline uint32_t GetVdencCmd2Size()
227 {
228 return 0;
229 }
230
231 //!
232 //! \brief Destructor
233 //!
234 virtual ~MhwVdboxVdencInterfaceG11() { }
235
236 MOS_STATUS InitRowstoreUserFeatureSettings()
237 {
238 MHW_FUNCTION_ENTER;
239
240 MOS_USER_FEATURE_VALUE_DATA userFeatureData;
241 MEDIA_FEATURE_TABLE *skuTable = this->m_osInterface->pfnGetSkuTable(this->m_osInterface);
242
243 MHW_MI_CHK_NULL(skuTable);
244
245 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
246
247 if (this->m_osInterface->bSimIsActive)
248 {
249 // Disable RowStore Cache on simulation by default
250 userFeatureData.u32Data = 1;
251 }
252 else
253 {
254 userFeatureData.u32Data = 0;
255 }
256
257 userFeatureData.i32DataFlag = MOS_USER_FEATURE_VALUE_DATA_FLAG_CUSTOM_DEFAULT_VALUE_TYPE;
258 #if (_DEBUG || _RELEASE_INTERNAL)
259 MOS_UserFeature_ReadValue_ID(
260 nullptr,
261 __MEDIA_USER_FEATURE_VALUE_ROWSTORE_CACHE_DISABLE_ID,
262 &userFeatureData,
263 this->m_osInterface->pOsContext);
264 #endif // _DEBUG || _RELEASE_INTERNAL
265 this->m_rowstoreCachingSupported = userFeatureData.i32Data ? false : true;
266
267 if (this->m_rowstoreCachingSupported)
268 {
269 MOS_ZeroMemory(&userFeatureData, sizeof(userFeatureData));
270 #if (_DEBUG || _RELEASE_INTERNAL)
271 MOS_UserFeature_ReadValue_ID(
272 nullptr,
273 __MEDIA_USER_FEATURE_VALUE_VDENCROWSTORECACHE_DISABLE_ID,
274 &userFeatureData,
275 this->m_osInterface->pOsContext);
276 #endif // _DEBUG || _RELEASE_INTERNAL
277 this->m_vdencRowStoreCache.bSupported = userFeatureData.i32Data ? false : true;
278 }
279
280 return MOS_STATUS_SUCCESS;
281 }
282
283 MOS_STATUS GetRowstoreCachingAddrs(
284 PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)
285 {
286 MHW_FUNCTION_ENTER;
287
288 MHW_CHK_NULL_RETURN(rowstoreParams);
289
290 if (this->m_vdencRowStoreCache.bSupported)
291 {
292 this->m_vdencRowStoreCache.bEnabled = true;
293
294 if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_HEVC)
295 {
296 if (rowstoreParams->dwPicWidth > MHW_VDBOX_PICWIDTH_1920 && rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_3840)
297 {
298 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_1920_AND_3840;
299 }
300 else if (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_1920 &&
301 rowstoreParams->ucChromaFormat == HCP_CHROMA_FORMAT_YUV444 &&
302 rowstoreParams->ucBitDepthMinus8 > 0)
303 {
304 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_LESS_THAN_1920;
305 }
306 else
307 {
308 this->m_vdencRowStoreCache.dwAddress = 0;
309 this->m_vdencRowStoreCache.bEnabled = false;
310 }
311 }
312 else if (rowstoreParams->Mode == CODECHAL_ENCODE_MODE_VP9)
313 {
314 if (rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_1920)
315 {
316 if (rowstoreParams->ucBitDepthMinus8 == 0 && rowstoreParams->ucChromaFormat != HCP_CHROMA_FORMAT_YUV444)
317 {
318 this->m_vdencRowStoreCache.dwAddress = VP9VDENCROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_1920_4208B;
319 }
320 else
321 {
322 this->m_vdencRowStoreCache.dwAddress = VP9VDENCROWSTORE_BASEADDRESS_PICWIDTH_LESS_THAN_OR_EQU_TO_1920;
323 }
324 }
325 else if (rowstoreParams->dwPicWidth > MHW_VDBOX_PICWIDTH_1920 && rowstoreParams->dwPicWidth <= MHW_VDBOX_PICWIDTH_3840)
326 {
327 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_LESS_THAN_1920;
328 }
329 else
330 {
331 this->m_vdencRowStoreCache.bEnabled = false;
332 this->m_vdencRowStoreCache.dwAddress = 0;
333 }
334 }
335 else
336 {
337 if (rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_2K)
338 {
339 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_LESS_THAN_2K;
340 }
341 else if (rowstoreParams->dwPicWidth >= MHW_VDBOX_PICWIDTH_2K && rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_3K)
342 {
343 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_2K_AND_3K;
344 }
345 else if (rowstoreParams->dwPicWidth >= MHW_VDBOX_PICWIDTH_3K && rowstoreParams->dwPicWidth < MHW_VDBOX_PICWIDTH_4K)
346 {
347 this->m_vdencRowStoreCache.dwAddress = VDENCROWSTORE_FRAME_BASEADDRESS_PICWIDTH_BETWEEN_3K_AND_4K;
348 }
349 else
350 {
351 this->m_vdencRowStoreCache.dwAddress = 0;
352 this->m_vdencRowStoreCache.bEnabled = false;
353 }
354 }
355 }
356
357 return MOS_STATUS_SUCCESS;
358 }
359
360 MOS_STATUS GetVdencStateCommandsDataSize(
361 uint32_t mode,
362 uint32_t waAddDelayInVDEncDynamicSlice,
363 uint32_t *commandsSize,
364 uint32_t *patchListSize)
365 {
366 MHW_FUNCTION_ENTER;
367
368 uint32_t maxSize = 0;
369 uint32_t patchListMaxSize = 0;
370 uint32_t standard = CodecHal_GetStandardFromMode(mode);
371
372 if (standard == CODECHAL_AVC)
373 {
374 maxSize =
375 TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
376 TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
377 TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
378 TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
379 TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
380 TVdencCmds::VDENC_CONST_QPT_STATE_CMD::byteSize +
381 TVdencCmds::VDENC_IMG_STATE_CMD::byteSize +
382 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
383 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
384
385 if (waAddDelayInVDEncDynamicSlice)
386 {
387 maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
388 }
389
390 patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
391 }
392 else if (standard == CODECHAL_HEVC)
393 {
394 maxSize =
395 TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
396 TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
397 TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
398 TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
399 TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
400 TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize +
401 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
402 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
403
404 if (waAddDelayInVDEncDynamicSlice)
405 {
406 maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
407 }
408
409 patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
410 }
411 else if (standard == CODECHAL_VP9)
412 {
413 maxSize =
414 TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD::byteSize +
415 TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD::byteSize +
416 TVdencCmds::VDENC_REF_SURFACE_STATE_CMD::byteSize +
417 TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD::byteSize +
418 TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD::byteSize +
419 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
420 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
421
422 if (waAddDelayInVDEncDynamicSlice)
423 {
424 maxSize += TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize * MHW_VDBOX_VDENC_DYNAMIC_SLICE_WA_COUNT;
425 }
426
427 patchListMaxSize =
428 MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES +
429 MI_BATCH_BUFFER_START_CMD_NUMBER_OF_ADDRESSES +
430 VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
431 }
432 else
433 {
434 MHW_ASSERTMESSAGE("Unsupported encode mode.");
435 *commandsSize = 0;
436 *patchListSize = 0;
437 return MOS_STATUS_UNKNOWN;
438 }
439
440 *commandsSize = maxSize;
441 *patchListSize = patchListMaxSize;
442
443 return MOS_STATUS_SUCCESS;
444 }
445
446 MOS_STATUS GetVdencPrimitiveCommandsDataSize(
447 uint32_t mode,
448 uint32_t *commandsSize,
449 uint32_t *patchListSize)
450 {
451 MHW_FUNCTION_ENTER;
452
453 uint32_t maxSize = 0;
454 uint32_t patchListMaxSize = 0;
455 uint32_t standard = CodecHal_GetStandardFromMode(mode);
456
457 if (standard == CODECHAL_AVC)
458 {
459 maxSize =
460 TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD::byteSize +
461 TVdencCmds::VDENC_WALKER_STATE_CMD::byteSize +
462 TVdencCmds::VD_PIPELINE_FLUSH_CMD::byteSize;
463
464 patchListMaxSize = VDENC_PIPE_BUF_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES;
465 }
466 else
467 {
468 MHW_ASSERTMESSAGE("Unsupported encode mode.");
469 *commandsSize = 0;
470 *patchListSize = 0;
471 return MOS_STATUS_UNKNOWN;
472 }
473
474 *commandsSize = maxSize;
475 *patchListSize = patchListMaxSize;
476
477 return MOS_STATUS_SUCCESS;
478 }
479
480 MOS_STATUS AddVdencPipeModeSelectCmd(
481 PMOS_COMMAND_BUFFER cmdBuffer,
482 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)
483 {
484 MHW_FUNCTION_ENTER;
485
486 MHW_MI_CHK_NULL(this->m_osInterface);
487 MHW_MI_CHK_NULL(cmdBuffer);
488 MHW_MI_CHK_NULL(params);
489
490 auto paramsG11 = dynamic_cast<PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11>(params);
491 MHW_MI_CHK_NULL(paramsG11);
492 typename TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD cmd;
493
494 cmd.DW1.StandardSelect = CodecHal_GetStandardFromMode(params->Mode);
495 cmd.DW1.ScalabilityMode = !(paramsG11->MultiEngineMode == MHW_VDBOX_HCP_MULTI_ENGINE_MODE_FE_LEGACY);
496 cmd.DW1.FrameStatisticsStreamOutEnable = 1;
497 cmd.DW1.VdencPakObjCmdStreamOutEnable = params->bVdencPakObjCmdStreamOutEnable;
498 cmd.DW1.TlbPrefetchEnable = params->bTlbPrefetchEnable;
499 cmd.DW1.PakThresholdCheckEnable = params->bDynamicSliceEnable;
500 cmd.DW1.VdencStreamInEnable = params->bVdencStreamInEnable;
501 cmd.DW1.BitDepth = params->ucVdencBitDepthMinus8;
502
503 if (CODECHAL_ENCODE_MODE_HEVC == params->Mode || CODECHAL_ENCODE_MODE_VP9 == params->Mode)
504 {
505 cmd.DW1.PakChromaSubSamplingType = params->ChromaType;
506 }
507 // by default RGB to YUV using full to studio range
508 // can add a DDI flag to control if needed
509 cmd.DW1.OutputRangeControlAfterColorSpaceConversion = 1;
510
511 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
512
513 return MOS_STATUS_SUCCESS;
514 }
515
516 MOS_STATUS AddVdencPipeBufAddrCmd(
517 PMOS_COMMAND_BUFFER cmdBuffer,
518 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)
519 {
520 MOS_SURFACE details;
521 uint8_t refIdx;
522
523 MHW_FUNCTION_ENTER;
524
525 MHW_MI_CHK_NULL(cmdBuffer);
526 MHW_MI_CHK_NULL(params);
527 MHW_MI_CHK_NULL(this->m_osInterface);
528
529 typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD cmd;
530
531 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED;
532 MHW_RESOURCE_PARAMS resourceParams;
533 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
534 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT;
535 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR;
536
537 if (params->psRawSurface != nullptr)
538 {
539
540 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, &params->psRawSurface->OsResource, &mmcMode));
541
542 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable =
543 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
544 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
545 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionMode =
546 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
547 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
548 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState =
549 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value;
550
551 cmd.OriginalUncompressedPicture.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType);
552
553 resourceParams.presResource = &params->psRawSurface->OsResource;
554 resourceParams.dwOffset = params->psRawSurface->dwOffset;
555 resourceParams.pdwCmd = (uint32_t*) &(cmd.OriginalUncompressedPicture.LowerAddress);
556 resourceParams.dwLocationInCmd = 10;
557 resourceParams.bIsWritable = false;
558
559 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
560 this->m_osInterface,
561 cmdBuffer,
562 &resourceParams));
563 }
564
565 if (this->m_vdencRowStoreCache.bEnabled)
566 {
567 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = TVdencCmds::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1;
568 cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_vdencRowStoreCache.dwAddress << 6;
569 }
570 else if (!Mos_ResourceIsNull(params->presVdencIntraRowStoreScratchBuffer))
571 {
572 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState =
573 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value;
574
575 resourceParams.presResource = params->presVdencIntraRowStoreScratchBuffer;
576 resourceParams.dwOffset = 0;
577 resourceParams.pdwCmd = (uint32_t*) &(cmd.RowStoreScratchBuffer.LowerAddress);
578 resourceParams.dwLocationInCmd = 16;
579 resourceParams.bIsWritable = true;
580
581 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
582 this->m_osInterface,
583 cmdBuffer,
584 &resourceParams));
585 }
586
587 if (params->presVdencStreamOutBuffer != nullptr)
588 {
589 cmd.VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState =
590 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
591
592 resourceParams.presResource = params->presVdencStreamOutBuffer;
593 resourceParams.dwOffset = params->dwVdencStatsStreamOutOffset;
594 resourceParams.pdwCmd = (uint32_t*) &(cmd.VdencStatisticsStreamout.LowerAddress);
595 resourceParams.dwLocationInCmd = 34;
596 resourceParams.bIsWritable = true;
597
598 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
599 this->m_osInterface,
600 cmdBuffer,
601 &resourceParams));
602 }
603
604 if (params->presVdencStreamInBuffer != nullptr)
605 {
606 cmd.StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState =
607 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
608
609 resourceParams.presResource = params->presVdencStreamInBuffer;
610 resourceParams.dwOffset = 0;
611 resourceParams.pdwCmd = (uint32_t*) &(cmd.StreaminDataPicture.LowerAddress);
612 resourceParams.dwLocationInCmd = 13;
613 resourceParams.bIsWritable = false;
614
615 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
616 this->m_osInterface,
617 cmdBuffer,
618 &resourceParams));
619 }
620
621 for (refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++)
622 {
623 if (params->presVdencReferences[refIdx])
624 {
625 // L0 references
626 MOS_ZeroMemory(&details, sizeof(details));
627 details.Format = Format_Invalid;
628 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdencReferences[refIdx], &details));
629
630 resourceParams.presResource = params->presVdencReferences[refIdx];
631 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
632 resourceParams.dwLocationInCmd = (refIdx * 3) + 22;
633 resourceParams.bIsWritable = false;
634
635 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
636
637 switch (refIdx)
638 {
639 case 0:
640 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionEnable =
641 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
642 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
643 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionMode =
644 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
645 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
646 cmd.FwdRef0.PictureFields.DW0.MemoryObjectControlState =
647 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
648 cmd.FwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
649 resourceParams.pdwCmd = (uint32_t*) &(cmd.FwdRef0.LowerAddress);
650 break;
651 case 1:
652 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionEnable =
653 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
654 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
655 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionMode =
656 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
657 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
658 cmd.FwdRef1.PictureFields.DW0.MemoryObjectControlState =
659 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
660 cmd.FwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
661 resourceParams.pdwCmd = (uint32_t*) &(cmd.FwdRef1.LowerAddress);
662 break;
663 case 2:
664 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionEnable =
665 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
666 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
667 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionMode =
668 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
669 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
670 cmd.FwdRef2.PictureFields.DW0.MemoryObjectControlState =
671 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
672 cmd.FwdRef2.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
673 resourceParams.pdwCmd = (uint32_t*) &(cmd.FwdRef2.LowerAddress);
674 break;
675 default:
676 break;
677 }
678
679 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
680 this->m_osInterface,
681 cmdBuffer,
682 &resourceParams));
683 }
684
685 // so far VDEnc only support 2 4x/8x DS Ref Pictures
686 if ((refIdx <= 1) && params->presVdenc4xDsSurface[refIdx])
687 {
688 if (params->Mode == CODECHAL_ENCODE_MODE_AVC)
689 {
690 // 4x DS surface for VDEnc
691 MOS_ZeroMemory(&details, sizeof(details));
692 details.Format = Format_Invalid;
693 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));
694
695 resourceParams.presResource = params->presVdenc4xDsSurface[refIdx];
696 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
697 resourceParams.dwLocationInCmd = (refIdx * 3) + 1;
698 resourceParams.bIsWritable = false;
699
700 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
701
702 switch (refIdx)
703 {
704 case 0:
705 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable =
706 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
707 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
708 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionMode =
709 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
710 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
711 cmd.DsFwdRef0.PictureFields.DW0.MemoryObjectControlState =
712 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
713 cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
714 resourceParams.pdwCmd = (uint32_t*) &(cmd.DsFwdRef0.LowerAddress);
715 break;
716 case 1:
717 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable =
718 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
719 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
720 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionMode =
721 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
722 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
723 cmd.DsFwdRef1.PictureFields.DW0.MemoryObjectControlState =
724 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
725 cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
726 resourceParams.pdwCmd = (uint32_t*) &(cmd.DsFwdRef1.LowerAddress);
727 break;
728 default:
729 break;
730 }
731
732 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
733 this->m_osInterface,
734 cmdBuffer,
735 &resourceParams));
736 }
737 else if (params->Mode == CODECHAL_ENCODE_MODE_HEVC || params->Mode == CODECHAL_ENCODE_MODE_VP9)
738 {
739 // 8x DS surface
740 MOS_ZeroMemory(&details, sizeof(details));
741 details.Format = Format_Invalid;
742 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc8xDsSurface[refIdx], &details));
743
744 resourceParams.presResource = params->presVdenc8xDsSurface[refIdx];
745 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
746 resourceParams.dwLocationInCmd = (refIdx * 3) + 1;
747 resourceParams.bIsWritable = false;
748
749 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
750 switch (refIdx)
751 {
752 case 0:
753 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable =
754 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
755 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
756 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionMode =
757 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
758 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
759 cmd.DsFwdRef0.PictureFields.DW0.MemoryObjectControlState =
760 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
761 cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
762 resourceParams.pdwCmd = (uint32_t*) &(cmd.DsFwdRef0.LowerAddress);
763 break;
764 case 1:
765 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable =
766 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
767 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
768 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionMode =
769 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
770 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
771 cmd.DsFwdRef1.PictureFields.DW0.MemoryObjectControlState =
772 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
773 cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
774 resourceParams.pdwCmd = (uint32_t*) &(cmd.DsFwdRef1.LowerAddress);
775 break;
776 default:
777 break;
778 }
779
780 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
781 this->m_osInterface,
782 cmdBuffer,
783 &resourceParams));
784
785 // 4x DS surface
786 MOS_ZeroMemory(&details, sizeof(details));
787 details.Format = Format_Invalid;
788 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details));
789
790 resourceParams.presResource = params->presVdenc4xDsSurface[refIdx];
791 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset;
792 resourceParams.dwLocationInCmd = (refIdx * 3) + 37;
793 resourceParams.bIsWritable = false;
794
795 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
796 switch (refIdx)
797 {
798 case 0:
799 cmd.DsFwdRef04X.PictureFields.DW0.MemoryCompressionEnable =
800 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
801 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
802 cmd.DsFwdRef04X.PictureFields.DW0.MemoryCompressionMode =
803 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
804 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
805 cmd.DsFwdRef04X.PictureFields.DW0.MemoryObjectControlState =
806 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
807 cmd.DsFwdRef04X.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
808 resourceParams.pdwCmd = (uint32_t*)&(cmd.DsFwdRef04X.LowerAddress);
809 break;
810 case 1:
811 cmd.DsFwdRef14X.PictureFields.DW0.MemoryCompressionEnable =
812 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
813 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
814 cmd.DsFwdRef14X.PictureFields.DW0.MemoryCompressionMode =
815 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
816 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
817 cmd.DsFwdRef14X.PictureFields.DW0.MemoryObjectControlState =
818 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
819 cmd.DsFwdRef14X.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType);
820 resourceParams.pdwCmd = (uint32_t*) &(cmd.DsFwdRef14X.LowerAddress);
821 break;
822 default:
823 break;
824 }
825
826 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
827 this->m_osInterface,
828 cmdBuffer,
829 &resourceParams));
830 }
831 else
832 {
833 MHW_ASSERTMESSAGE("Encode mode = %d not supported", params->Mode);
834 return MOS_STATUS_INVALID_PARAMETER;
835 }
836 }
837 }
838
839 // extra surface for HEVC/VP9
840 if ((params->Mode == CODECHAL_ENCODE_MODE_HEVC) || (params->Mode == CODECHAL_ENCODE_MODE_VP9))
841 {
842 if (params->presColMvTempBuffer[0] != nullptr)
843 {
844 resourceParams.presResource = params->presColMvTempBuffer[0];
845 resourceParams.dwOffset = 0;
846 resourceParams.pdwCmd = (uint32_t*) &(cmd.ColocatedMv.LowerAddress);
847 resourceParams.dwLocationInCmd = 19;
848 resourceParams.bIsWritable = true;
849
850 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
851 cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionEnable =
852 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
853 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
854 cmd.ColocatedMv.PictureFields.DW0.MemoryCompressionMode =
855 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
856 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
857 cmd.ColocatedMv.PictureFields.DW0.MemoryObjectControlState =
858 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_SURFACE_ENC_MV_TEMPORAL_BUFFER_ENCODE].Value;
859
860 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
861 this->m_osInterface,
862 cmdBuffer,
863 &resourceParams));
864 }
865
866 if (params->ps8xDsSurface != nullptr)
867 {
868 resourceParams.presResource = &params->ps8xDsSurface->OsResource;
869 resourceParams.dwOffset = params->ps8xDsSurface->dwOffset;
870 resourceParams.pdwCmd = (uint32_t*) &(cmd.ScaledReferenceSurface8X.LowerAddress);
871 resourceParams.dwLocationInCmd = 49;
872 resourceParams.bIsWritable = true;
873
874 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
875 cmd.ScaledReferenceSurface8X.PictureFields.DW0.MemoryCompressionEnable =
876 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
877 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
878 cmd.ScaledReferenceSurface8X.PictureFields.DW0.MemoryCompressionMode =
879 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
880 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
881 cmd.ScaledReferenceSurface8X.PictureFields.DW0.MemoryObjectControlState =
882 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
883
884 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
885 this->m_osInterface,
886 cmdBuffer,
887 &resourceParams));
888 }
889
890 if (params->ps4xDsSurface != nullptr)
891 {
892 resourceParams.presResource = &params->ps4xDsSurface->OsResource;
893 resourceParams.dwOffset = params->ps4xDsSurface->dwOffset;
894 resourceParams.pdwCmd = (uint32_t*) &(cmd.ScaledReferenceSurface4X.LowerAddress);
895 resourceParams.dwLocationInCmd = 52;
896 resourceParams.bIsWritable = true;
897
898 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
899 cmd.ScaledReferenceSurface4X.PictureFields.DW0.MemoryCompressionEnable =
900 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
901 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
902 cmd.ScaledReferenceSurface4X.PictureFields.DW0.MemoryCompressionMode =
903 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
904 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
905 cmd.ScaledReferenceSurface4X.PictureFields.DW0.MemoryObjectControlState =
906 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value;
907
908 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
909 this->m_osInterface,
910 cmdBuffer,
911 &resourceParams));
912 }
913
914 // CuRecord stream-out buffer, not used so far
915 if (params->presVdencCuObjStreamOutBuffer)
916 {
917 resourceParams.presResource = params->presVdencCuObjStreamOutBuffer;
918 resourceParams.dwOffset = 0;
919 resourceParams.pdwCmd = (uint32_t*) &(cmd.VdencCuRecordStreamOutBuffer.LowerAddress);
920 resourceParams.dwLocationInCmd = 43;
921 resourceParams.bIsWritable = true;
922
923 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
924 cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.MemoryCompressionEnable =
925 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
926 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
927 cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.MemoryCompressionMode =
928 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
929 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
930 cmd.VdencCuRecordStreamOutBuffer.PictureFields.DW0.MemoryObjectControlState =
931 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
932
933 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
934 this->m_osInterface,
935 cmdBuffer,
936 &resourceParams));
937 }
938
939 if (params->presVdencPakObjCmdStreamOutBuffer)
940 {
941 resourceParams.presResource = params->presVdencPakObjCmdStreamOutBuffer;
942 resourceParams.dwOffset = 0;
943 resourceParams.pdwCmd = (uint32_t*) &(cmd.VdencLcuPakObjCmdBuffer.LowerAddress);
944 resourceParams.dwLocationInCmd = 46;
945 resourceParams.bIsWritable = true;
946
947 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode));
948 cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionEnable =
949 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE
950 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE;
951 cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryCompressionMode =
952 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE
953 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE;
954 cmd.VdencLcuPakObjCmdBuffer.PictureFields.DW0.MemoryObjectControlState =
955 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
956
957 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
958 this->m_osInterface,
959 cmdBuffer,
960 &resourceParams));
961 }
962
963 if (params->presSegmentMapStreamOut)
964 {
965 resourceParams.presResource = params->presSegmentMapStreamOut;
966 resourceParams.dwOffset = 0;
967 resourceParams.pdwCmd = (uint32_t*) &(cmd.Vp9SegmentationMapStreaminBuffer.LowerAddress);
968 resourceParams.dwLocationInCmd = 55;
969 resourceParams.bIsWritable = true;
970
971 cmd.Vp9SegmentationMapStreaminBuffer.PictureFields.DW0.MemoryObjectControlState =
972 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value;
973
974 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
975 this->m_osInterface,
976 cmdBuffer,
977 &resourceParams));
978
979 resourceParams.presResource = params->presSegmentMapStreamOut;
980 resourceParams.dwOffset = 0;
981 resourceParams.pdwCmd = (uint32_t*) &(cmd.Vp9SegmentationMapStreamoutBuffer.LowerAddress);
982 resourceParams.dwLocationInCmd = 58;
983 resourceParams.bIsWritable = true;
984
985 cmd.Vp9SegmentationMapStreamoutBuffer.PictureFields.DW0.MemoryObjectControlState =
986 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value;
987
988 MHW_MI_CHK_STATUS(this->AddResourceToCmd(
989 this->m_osInterface,
990 cmdBuffer,
991 &resourceParams));
992 }
993 }
994
995 // DW61: Weights Histogram Streamout offset
996 // This parameter specifies the 64 byte aligned offset in the VDEnc Statistics Streamout buffer where the luma and chroma histogram for the weights/offsets determination is written out.
997
998 // Hard-coding the value
999 // The first 2 CLs(cacheline=64bytes) are ENC frame statistics data.
1000 // The 3rd CL is for VDL1* stats (hits & misses).
1001 // Hence it's a dummy CL for us. Histogram stats start from 4th CL onwards.
1002 cmd.DW61.WeightsHistogramStreamoutOffset = 3 * MHW_CACHELINE_SIZE;
1003
1004 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1005
1006 return MOS_STATUS_SUCCESS;
1007 }
1008
1009 MOS_STATUS AddVdencSrcSurfaceStateCmd(
1010 PMOS_COMMAND_BUFFER cmdBuffer,
1011 PMHW_VDBOX_SURFACE_PARAMS params)
1012 {
1013 MHW_FUNCTION_ENTER;
1014
1015 MHW_MI_CHK_NULL(this->m_osInterface);
1016 MHW_MI_CHK_NULL(cmdBuffer);
1017 MHW_MI_CHK_NULL(params);
1018 MHW_MI_CHK_NULL(params->psSurface);
1019
1020 typename TVdencCmds::VDENC_SRC_SURFACE_STATE_CMD cmd;
1021
1022 cmd.Dwords25.DW0.Width = params->dwActualWidth - 1;
1023 cmd.Dwords25.DW0.Height = params->dwActualHeight - 1;
1024 cmd.Dwords25.DW0.ColorSpaceSelection = params->bColorSpaceSelection;
1025
1026 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
1027
1028 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
1029
1030 if (cmd.Dwords25.DW1.TiledSurface)
1031 {
1032 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType);
1033 }
1034
1035 if (params->psSurface->TileType == MOS_TILE_LINEAR)
1036 {
1037 cmd.Dwords25.DW1.TileWalk = 0;
1038 }
1039
1040 cmd.Dwords25.DW1.SurfaceFormat = this->MosFormatToVdencSurfaceRawFormat(params->psSurface->Format);
1041 cmd.Dwords25.DW0.SurfaceFormatByteSwizzle = params->bDisplayFormatSwizzle;
1042 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
1043 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr =
1044 MOS_ALIGN_CEIL(params->psSurface->UPlaneOffset.iYOffset, MHW_VDBOX_MFX_RAW_UV_PLANE_ALIGNMENT_GEN9);
1045
1046 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1047
1048 return MOS_STATUS_SUCCESS;
1049 }
1050
1051 MOS_STATUS AddVdencRefSurfaceStateCmd(
1052 PMOS_COMMAND_BUFFER cmdBuffer,
1053 PMHW_VDBOX_SURFACE_PARAMS params)
1054 {
1055 MHW_FUNCTION_ENTER;
1056
1057 MHW_MI_CHK_NULL(this->m_osInterface);
1058 MHW_MI_CHK_NULL(cmdBuffer);
1059 MHW_MI_CHK_NULL(params);
1060 MHW_MI_CHK_NULL(params->psSurface);
1061
1062 typename TVdencCmds::VDENC_REF_SURFACE_STATE_CMD cmd;
1063
1064 if (params->bVdencDynamicScaling)
1065 {
1066 if (params->ucSurfaceStateId == CODECHAL_HCP_LAST_SURFACE_ID)
1067 {
1068 cmd.DW1.SurfaceId = 4;
1069 }
1070 else if (params->ucSurfaceStateId == CODECHAL_HCP_GOLDEN_SURFACE_ID)
1071 {
1072 cmd.DW1.SurfaceId = 5;
1073 }
1074 else if (params->ucSurfaceStateId == CODECHAL_HCP_ALTREF_SURFACE_ID)
1075 {
1076 cmd.DW1.SurfaceId = 6;
1077 }
1078 }
1079
1080 if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
1081 {
1082 cmd.Dwords25.DW0.Width = params->dwActualWidth - 1;
1083 cmd.Dwords25.DW0.Height = params->dwActualHeight - 1;
1084 }
1085 else
1086 {
1087 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1;
1088 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
1089 }
1090
1091 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
1092
1093 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
1094
1095 if (cmd.Dwords25.DW1.TiledSurface)
1096 {
1097 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType);
1098 }
1099
1100 cmd.Dwords25.DW1.SurfaceFormat = this->MosFormatToVdencSurfaceReconFormat(params->psSurface->Format);
1101
1102 if (cmd.Dwords25.DW1.SurfaceFormat == TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_P010)
1103 {
1104 cmd.Dwords25.DW1.SurfaceFormat = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_P010_VARIANT;
1105 }
1106
1107 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
1108 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset;
1109
1110 if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY416Variant ||
1111 cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatAyuvVariant)
1112 {
1113 /* Y410/Y416 Reconstructed format handling */
1114 if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY416Variant)
1115 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch / 2 - 1;
1116 /* AYUV Reconstructed format handling */
1117 if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatAyuvVariant)
1118 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch / 4 - 1;
1119
1120 cmd.Dwords25.DW2.YOffsetForUCb = params->dwReconSurfHeight;
1121 cmd.Dwords25.DW3.YOffsetForVCr = params->dwReconSurfHeight << 1;
1122 }
1123 else if (cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatY216Variant ||
1124 cmd.Dwords25.DW1.SurfaceFormat == vdencSurfaceFormatYuyvVariant)
1125 {
1126 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->dwReconSurfHeight;
1127 }
1128
1129 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1130
1131 return MOS_STATUS_SUCCESS;
1132 }
1133
1134 MOS_STATUS AddVdencDsRefSurfaceStateCmd(
1135 PMOS_COMMAND_BUFFER cmdBuffer,
1136 PMHW_VDBOX_SURFACE_PARAMS params,
1137 uint8_t numSurfaces)
1138 {
1139 MHW_FUNCTION_ENTER;
1140
1141 MHW_MI_CHK_NULL(this->m_osInterface);
1142 MHW_MI_CHK_NULL(cmdBuffer);
1143 MHW_MI_CHK_NULL(params);
1144 MHW_MI_CHK_NULL(params->psSurface);
1145
1146 typename TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD cmd;
1147
1148 if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
1149 {
1150 cmd.Dwords25.DW0.Width = params->dwActualWidth - 1;
1151 cmd.Dwords25.DW0.Height = params->dwActualHeight - 1;
1152 }
1153 else
1154 {
1155 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1;
1156 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1;
1157 }
1158 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
1159
1160 cmd.Dwords25.DW1.TiledSurface =
1161 IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
1162
1163 if (cmd.Dwords25.DW1.TiledSurface)
1164 {
1165 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType);
1166 }
1167
1168 cmd.Dwords25.DW1.SurfaceFormat = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8;
1169 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
1170 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset;
1171
1172 // 2nd surface
1173 if (numSurfaces > 1)
1174 {
1175 params = params + 1; // Increment pointer to move from 1st surface to 2nd surface.
1176 MHW_MI_CHK_NULL(params);
1177 MHW_MI_CHK_NULL(params->psSurface);
1178
1179 if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
1180 {
1181 cmd.Dwords69.DW0.Width = params->dwActualWidth - 1;
1182 cmd.Dwords69.DW0.Height = params->dwActualHeight - 1;
1183 }
1184 else
1185 {
1186 cmd.Dwords69.DW0.Width = params->psSurface->dwWidth - 1;
1187 cmd.Dwords69.DW0.Height = params->psSurface->dwHeight - 1;
1188 }
1189 cmd.Dwords69.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection;
1190
1191 cmd.Dwords69.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0;
1192
1193 if (cmd.Dwords69.DW1.TiledSurface)
1194 {
1195 cmd.Dwords69.DW1.TileWalk = (params->psSurface->TileType);
1196 }
1197
1198 cmd.Dwords69.DW1.SurfaceFormat = TVdencCmds::VDENC_Surface_State_Fields_CMD::SURFACE_FORMAT_PLANAR_420_8;
1199 cmd.Dwords69.DW1.SurfacePitch = params->psSurface->dwPitch - 1;
1200 cmd.Dwords69.DW2.YOffsetForUCb = cmd.Dwords69.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset;
1201 }
1202
1203 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1204
1205 return MOS_STATUS_SUCCESS;
1206 }
1207
1208 MOS_STATUS AddVdencImgStateCmd(
1209 PMOS_COMMAND_BUFFER cmdBuffer,
1210 PMHW_BATCH_BUFFER batchBuffer,
1211 PMHW_VDBOX_AVC_IMG_PARAMS params)
1212 {
1213 MHW_FUNCTION_ENTER;
1214
1215 MHW_MI_CHK_NULL(params);
1216 MHW_MI_CHK_NULL(params->pEncodeAvcSeqParams);
1217 MHW_MI_CHK_NULL(params->pEncodeAvcPicParams);
1218
1219 typename TVdencCmds::VDENC_IMG_STATE_CMD cmd;
1220
1221 auto avcSeqParams = params->pEncodeAvcSeqParams;
1222 auto avcPicParams = params->pEncodeAvcPicParams;
1223 auto avcSliceParams = params->pEncodeAvcSliceParams;
1224
1225 // initialize
1226 cmd.DW1.VdencExtendedPakObjCmdEnable = 1;
1227 cmd.DW2.UnidirectionalMixDisable = false;
1228 cmd.DW4.IntraSadMeasureAdjustment = 2;
1229 cmd.DW4.SubMacroblockSubPartitionMask = 0x70;
1230 cmd.DW8.BilinearFilterEnable = false;
1231 cmd.DW9.Mode0Cost = 10;
1232 cmd.DW9.Mode1Cost = 0;
1233 cmd.DW9.Mode2Cost = 3;
1234 cmd.DW9.Mode3Cost = 30;
1235 cmd.DW20.PenaltyForIntra16X16NondcPrediction = 36;
1236 cmd.DW20.PenaltyForIntra8X8NondcPrediction = 12;
1237 cmd.DW20.PenaltyForIntra4X4NondcPrediction = 4;
1238 cmd.DW22.Smallmbsizeinword = 0xff;
1239 cmd.DW22.Largembsizeinword = 0xff;
1240 cmd.DW27.MaxHmvR = 0x2000;
1241 cmd.DW27.MaxVmvR = 0x200;
1242 cmd.DW33.Maxdeltaqp = 0x0f;
1243
1244 // initialize for P frame
1245 if (avcPicParams->CodingType != I_TYPE)
1246 {
1247 cmd.DW2.BidirectionalWeight = 0x20;
1248 cmd.DW4.SubPelMode = (avcPicParams->bEnableSubPelMode) ? avcPicParams->SubPelMode : 3;
1249 cmd.DW4.BmeDisableForFbrMessage = 1;
1250 cmd.DW4.InterSadMeasureAdjustment = 2;
1251 cmd.DW5.CrePrefetchEnable = 1;
1252 cmd.DW8.NonSkipZeroMvCostAdded = 1;
1253 cmd.DW8.NonSkipMbModeCostAdded = 1;
1254 cmd.DW9.Mode0Cost = 7;
1255 cmd.DW9.Mode1Cost = 26;
1256 cmd.DW9.Mode2Cost = 30;
1257 cmd.DW9.Mode3Cost = 57;
1258 cmd.DW10.Mode4Cost = 8;
1259 cmd.DW10.Mode5Cost = 2;
1260 cmd.DW10.Mode6Cost = 4;
1261 cmd.DW10.Mode7Cost = 6;
1262 cmd.DW11.Mode8Cost = 5;
1263 cmd.DW11.Mode9Cost = 0;
1264 cmd.DW11.RefIdCost = 4;
1265 cmd.DW12.MvCost0 = 0;
1266 cmd.DW12.MvCost1 = 6;
1267 cmd.DW12.MvCost2 = 6;
1268 cmd.DW12.MvCost3 = 9;
1269 cmd.DW13.MvCost4 = 10;
1270 cmd.DW13.MvCost5 = 13;
1271 cmd.DW13.MvCost6 = 14;
1272 cmd.DW13.MvCost7 = 24;
1273 cmd.DW31.SadHaarThreshold0 = 800;
1274 cmd.DW32.SadHaarThreshold1 = 1600;
1275 cmd.DW32.SadHaarThreshold2 = 2400;
1276 cmd.DW34.MidpointSadHaar = 0x640;
1277 }
1278
1279 cmd.DW1.VdencPerfmode = params->bVDEncPerfModeEnabled;
1280 cmd.DW1.Transform8X8Flag = avcPicParams->transform_8x8_mode_flag;
1281 cmd.DW3.PictureWidth = params->wPicWidthInMb;
1282 cmd.DW4.ForwardTransformSkipCheckEnable = this->m_vdencFTQEnabled[avcSeqParams->TargetUsage];
1283 cmd.DW4.BlockBasedSkipEnabled = this->m_vdencBlockBasedSkipEnabled[avcSeqParams->TargetUsage];
1284 cmd.DW5.CrePrefetchEnable = params->bCrePrefetchEnable;
1285 cmd.DW5.PictureHeightMinusOne = params->wPicHeightInMb - 1;
1286 cmd.DW5.PictureType = avcPicParams->CodingType - 1;
1287 cmd.DW5.ConstrainedIntraPredictionFlag = avcPicParams->constrained_intra_pred_flag;
1288
1289 // HME Ref1 Disable should be set as 0 when VDEnc Perf Mode is enabled
1290 if ((avcPicParams->CodingType != I_TYPE) &&
1291 (!params->pEncodeAvcSliceParams->num_ref_idx_l0_active_minus1) &&
1292 (!params->bVDEncPerfModeEnabled))
1293 {
1294 cmd.DW5.HmeRef1Disable = true;
1295 }
1296
1297 if (avcSeqParams->EnableSliceLevelRateCtrl)
1298 {
1299 cmd.DW5.MbSliceThresholdValue = params->dwMbSlcThresholdValue;
1300 }
1301
1302 cmd.DW6.SliceMacroblockHeightMinusOne = params->wPicHeightInMb - 1;
1303
1304 cmd.DW8.LumaIntraPartitionMask = avcPicParams->transform_8x8_mode_flag ? 0 : TVdencCmds::VDENC_IMG_STATE_CMD::LUMA_INTRA_PARTITION_MASK_UNNAMED2;
1305
1306 cmd.DW14.QpPrimeY = avcPicParams->QpY + avcSliceParams->slice_qp_delta;
1307
1308 if (params->pVDEncModeCost)
1309 {
1310 cmd.DW9.Mode0Cost = *(params->pVDEncModeCost);
1311 cmd.DW9.Mode1Cost = *(params->pVDEncModeCost + 1);
1312 cmd.DW9.Mode2Cost = *(params->pVDEncModeCost + 2);
1313 cmd.DW9.Mode3Cost = *(params->pVDEncModeCost + 3);
1314
1315 cmd.DW10.Mode4Cost = *(params->pVDEncModeCost + 4);
1316 cmd.DW10.Mode5Cost = *(params->pVDEncModeCost + 5);
1317 cmd.DW10.Mode6Cost = *(params->pVDEncModeCost + 6);
1318 cmd.DW10.Mode7Cost = *(params->pVDEncModeCost + 7);
1319
1320 cmd.DW11.Mode8Cost = *(params->pVDEncModeCost + 8);
1321 cmd.DW11.RefIdCost = *(params->pVDEncModeCost + 10);
1322 }
1323 if (params->pVDEncMvCost)
1324 {
1325 cmd.DW12.MvCost0 = *(params->pVDEncMvCost);
1326 cmd.DW12.MvCost1 = *(params->pVDEncMvCost + 1);
1327 cmd.DW12.MvCost2 = *(params->pVDEncMvCost + 2);
1328 cmd.DW12.MvCost3 = *(params->pVDEncMvCost + 3);
1329 cmd.DW13.MvCost4 = *(params->pVDEncMvCost + 4);
1330 cmd.DW13.MvCost5 = *(params->pVDEncMvCost + 5);
1331 cmd.DW13.MvCost6 = *(params->pVDEncMvCost + 6);
1332 cmd.DW13.MvCost7 = *(params->pVDEncMvCost + 7);
1333 }
1334
1335 cmd.DW27.MaxVmvR = params->dwMaxVmvR;
1336
1337 if (params->pVDEncHmeMvCost)
1338 {
1339 cmd.DW28.HmeMvCost0 = *(params->pVDEncHmeMvCost);
1340 cmd.DW28.HmeMvCost1 = *(params->pVDEncHmeMvCost + 1);
1341 cmd.DW28.HmeMvCost2 = *(params->pVDEncHmeMvCost + 2);
1342 cmd.DW28.HmeMvCost3 = *(params->pVDEncHmeMvCost + 3);
1343 cmd.DW29.HmeMvCost4 = *(params->pVDEncHmeMvCost + 4);
1344 cmd.DW29.HmeMvCost5 = *(params->pVDEncHmeMvCost + 5);
1345 cmd.DW29.HmeMvCost6 = *(params->pVDEncHmeMvCost + 6);
1346 cmd.DW29.HmeMvCost7 = *(params->pVDEncHmeMvCost + 7);
1347 }
1348
1349 // HMEOffset is in range of -128 to 127, clip value to within range
1350 if (avcPicParams->bEnableHMEOffset)
1351 {
1352 cmd.DW7.Hme0XOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[0][0][0], -128, 127);
1353 cmd.DW7.Hme0YOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[0][0][1], -128, 127);
1354 cmd.DW7.Hme1XOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[1][0][0], -128, 127);
1355 cmd.DW7.Hme1YOffset = MOS_CLAMP_MIN_MAX(avcPicParams->HMEOffset[1][0][1], -128, 127);
1356 }
1357
1358 // Rolling-I settings
1359 if ((avcPicParams->CodingType != I_TYPE) && (avcPicParams->EnableRollingIntraRefresh != ROLLING_I_DISABLED))
1360 {
1361 cmd.DW21.IntraRefreshEnableRollingIEnable = avcPicParams->EnableRollingIntraRefresh != ROLLING_I_DISABLED ? 1 : 0;
1362 cmd.DW21.IntraRefreshMode = avcPicParams->EnableRollingIntraRefresh == ROLLING_I_ROW ? 0 : 1; // 0->Row based ; 1->Column based
1363 cmd.DW21.IntraRefreshMBPos = avcPicParams->IntraRefreshMBNum;
1364 cmd.DW21.IntraRefreshMBSizeMinusOne = avcPicParams->IntraRefreshUnitinMB;
1365 cmd.DW21.QpAdjustmentForRollingI = avcPicParams->IntraRefreshQPDelta;
1366
1367 auto waTable = this->m_osInterface->pfnGetWaTable(this->m_osInterface);
1368 MHW_MI_CHK_NULL(waTable);
1369
1370 // WA to prevent error propagation from top-right direction.
1371 // Disable prediction modes 3, 7 for 4x4
1372 // and modes 0, 2, 3, 4, 5, 7 for 8x8 (due to filtering)
1373 if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_COLUMN &&
1374 MEDIA_IS_WA(waTable, Wa_18011246551))
1375 {
1376 cmd.DW17.AvcIntra4X4ModeMask = 0x88;
1377 cmd.DW17.AvcIntra8X8ModeMask = 0xBD;
1378 }
1379 }
1380
1381 // Setting MinMaxQP values if they are presented
1382 if (avcPicParams->ucMaximumQP && avcPicParams->ucMinimumQP)
1383 {
1384 cmd.DW33.MaxQp = avcPicParams->ucMaximumQP;
1385 cmd.DW33.MinQp = avcPicParams->ucMinimumQP;
1386 }
1387 else
1388 {
1389 // Set default values
1390 cmd.DW33.MaxQp = 0x33;
1391 cmd.DW33.MinQp = 0x0a;
1392 }
1393
1394 // VDEnc CQP case ROI settings, BRC ROI will be handled in HuC FW
1395 if (!params->bVdencBRCEnabled && avcPicParams->NumROI)
1396 {
1397 MHW_ASSERT(avcPicParams->NumROI < 4);
1398
1399 int8_t priorityLevelOrDQp[ENCODE_VDENC_AVC_MAX_ROI_NUMBER_G9] = { 0 };
1400
1401 for (uint8_t i = 0; i < avcPicParams->NumROI; i++)
1402 {
1403 int8_t dQpRoi = avcPicParams->ROIDistinctDeltaQp[i];
1404
1405 // clip delta qp roi to VDEnc supported range
1406 priorityLevelOrDQp[i] = (char)CodecHal_Clip3(
1407 ENCODE_VDENC_AVC_MIN_ROI_DELTA_QP_G9, ENCODE_VDENC_AVC_MAX_ROI_DELTA_QP_G9, dQpRoi);
1408 }
1409
1410 cmd.DW34.RoiEnable = true;
1411
1412 // Zone0 is reserved for non-ROI region
1413 cmd.DW30.RoiQpAdjustmentForZone1 = priorityLevelOrDQp[0];
1414 cmd.DW30.RoiQpAdjustmentForZone2 = priorityLevelOrDQp[1];
1415 cmd.DW30.RoiQpAdjustmentForZone3 = priorityLevelOrDQp[2];
1416 }
1417
1418 if (avcSeqParams->RateControlMethod != RATECONTROL_CQP)
1419 {
1420 cmd.DW30.QpAdjustmentForShapeBestIntra4X4Winner = 0;
1421 cmd.DW30.QpAdjustmentForShapeBestIntra8X8Winner = 0;
1422 cmd.DW30.QpAdjustmentForShapeBestIntra16X16Winner = 0;
1423
1424 cmd.DW31.BestdistortionQpAdjustmentForZone0 = 0;
1425 cmd.DW31.BestdistortionQpAdjustmentForZone1 = 1;
1426 cmd.DW31.BestdistortionQpAdjustmentForZone2 = 2;
1427 cmd.DW31.BestdistortionQpAdjustmentForZone3 = 3;
1428 }
1429
1430 if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED && params->bVdencStreamInEnabled &&
1431 (avcPicParams->NumDirtyROI && params->bVdencBRCEnabled || avcPicParams->NumROI && avcPicParams->bNativeROI ||
1432 (avcPicParams->TargetFrameSize > 0 && !avcSeqParams->LookaheadDepth))) // TCBRC (for AdaptiveRegionBoost)
1433 {
1434 cmd.DW34.RoiEnable = true;
1435 }
1436
1437 // non-native ROI in ForceQP mode (VDEnc StreamIn filled by HuC in BRC mode and by UMD driver in CQP) or MBQP
1438 if (avcPicParams->EnableRollingIntraRefresh == ROLLING_I_DISABLED && params->bVdencStreamInEnabled &&
1439 avcPicParams->NumROI && !avcPicParams->bNativeROI)
1440 {
1441 cmd.DW34.MbLevelQpEnable = true;
1442 }
1443
1444 if (params->bVdencStreamInEnabled)
1445 {
1446 cmd.DW34.FwdPredictor0MvEnable = 1;
1447 cmd.DW34.PpmvDisable = 1;
1448 }
1449 if (cmdBuffer == nullptr && batchBuffer == nullptr)
1450 {
1451 MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
1452 return MOS_STATUS_NULL_POINTER;
1453 }
1454
1455 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1456
1457 return MOS_STATUS_SUCCESS;
1458 }
1459
1460 MOS_STATUS AddVdencWalkerStateCmd(
1461 PMOS_COMMAND_BUFFER cmdBuffer,
1462 PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS params)
1463 {
1464 MHW_FUNCTION_ENTER;
1465
1466 MHW_MI_CHK_NULL(this->m_osInterface);
1467 MHW_MI_CHK_NULL(cmdBuffer);
1468 MHW_MI_CHK_NULL(params);
1469
1470 typename TVdencCmds::VDENC_WALKER_STATE_CMD cmd;
1471
1472 if (params->Mode == CODECHAL_ENCODE_MODE_AVC)
1473 {
1474 MHW_MI_CHK_NULL(params->pAvcSeqParams);
1475 MHW_MI_CHK_NULL(params->pAvcSlcParams);
1476
1477 auto avcSeqParams = params->pAvcSeqParams;
1478 auto avcSlcParams = params->pAvcSlcParams;
1479
1480 cmd.DW1.MbLcuStartYPosition = avcSlcParams->first_mb_in_slice / CODECHAL_GET_WIDTH_IN_MACROBLOCKS(avcSeqParams->FrameWidth);
1481
1482 cmd.DW2.NextsliceMbStartYPosition = (avcSlcParams->first_mb_in_slice + avcSlcParams->NumMbsForSlice) / CODECHAL_GET_WIDTH_IN_MACROBLOCKS(avcSeqParams->FrameWidth);
1483
1484 if (cmd.DW2.NextsliceMbStartYPosition > (uint32_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(avcSeqParams->FrameHeight))
1485 {
1486 cmd.DW2.NextsliceMbStartYPosition = (uint32_t)CODECHAL_GET_HEIGHT_IN_MACROBLOCKS(avcSeqParams->FrameHeight);
1487 }
1488
1489 cmd.DW3.Log2WeightDenomLuma = avcSlcParams->luma_log2_weight_denom;
1490
1491 cmd.DW5.TileWidth = avcSeqParams->FrameWidth - 1;
1492 }
1493 else if (params->Mode == CODECHAL_ENCODE_MODE_HEVC)
1494 {
1495 auto paramsG11 = dynamic_cast<PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G11>(params);
1496 MHW_MI_CHK_NULL(paramsG11);
1497 MHW_MI_CHK_NULL(params->pHevcEncSeqParams);
1498 MHW_MI_CHK_NULL(params->pHevcEncPicParams);
1499 MHW_MI_CHK_NULL(params->pEncodeHevcSliceParams);
1500
1501 auto seqParams = params->pHevcEncSeqParams;
1502 auto picParams = params->pHevcEncPicParams;
1503 auto sliceParams = params->pEncodeHevcSliceParams;
1504
1505 uint32_t ctbSize = 1 << (seqParams->log2_max_coding_block_size_minus3 + 3);
1506 uint32_t widthInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameWidthInMinCbMinus1 + 1);
1507 uint32_t widthInCtb = (widthInPix / ctbSize) + ((widthInPix % ctbSize) ? 1 : 0); // round up
1508 uint32_t heightInPix = (1 << (seqParams->log2_min_coding_block_size_minus3 + 3)) * (seqParams->wFrameHeightInMinCbMinus1 + 1);
1509 uint32_t heightInCtb = (heightInPix / ctbSize) + ((heightInPix % ctbSize) ? 1 : 0); // round up
1510 uint32_t shift = seqParams->log2_max_coding_block_size_minus3 - seqParams->log2_min_coding_block_size_minus3;
1511
1512 cmd.DW3.Log2WeightDenomLuma = cmd.DW3.HevcLog2WeightDemonLuma =
1513 (picParams->weighted_pred_flag || picParams->weighted_bipred_flag) ? (picParams->bEnableGPUWeightedPrediction ? 6 : sliceParams->luma_log2_weight_denom) : 0;
1514
1515 if (paramsG11->pTileCodingParams == nullptr)
1516 {
1517 // No tiling support
1518 cmd.DW1.MbLcuStartYPosition = sliceParams->slice_segment_address / widthInCtb;
1519 cmd.DW2.NextsliceMbLcuStartXPosition = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / heightInCtb;
1520 cmd.DW2.NextsliceMbStartYPosition = (sliceParams->slice_segment_address + sliceParams->NumLCUsInSlice) / widthInCtb;
1521 cmd.DW5.TileWidth = widthInPix - 1;
1522 cmd.DW5.TileHeight = heightInPix - 1;
1523 }
1524 else
1525 {
1526 cmd.DW1.MbLcuStartXPosition = paramsG11->pTileCodingParams->TileStartLCUX;
1527 cmd.DW1.MbLcuStartYPosition = paramsG11->pTileCodingParams->TileStartLCUY;
1528
1529 cmd.DW2.NextsliceMbLcuStartXPosition = paramsG11->pTileCodingParams->TileStartLCUX + (paramsG11->pTileCodingParams->TileWidthInMinCbMinus1 >> shift) + 1;
1530 cmd.DW2.NextsliceMbStartYPosition = paramsG11->pTileCodingParams->TileStartLCUY + (paramsG11->pTileCodingParams->TileHeightInMinCbMinus1 >> shift) + 1;
1531
1532 cmd.DW4.TileStartCtbX = paramsG11->pTileCodingParams->TileStartLCUX * ctbSize;
1533 cmd.DW4.TileStartCtbY = paramsG11->pTileCodingParams->TileStartLCUY * ctbSize;
1534
1535 cmd.DW5.TileWidth = ((paramsG11->pTileCodingParams->TileWidthInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) - 1;
1536 cmd.DW5.TileHeight = ((paramsG11->pTileCodingParams->TileHeightInMinCbMinus1 + 1) << (seqParams->log2_min_coding_block_size_minus3 + 3)) - 1;
1537 cmd.DW1.FirstSuperSlice = 1;
1538 cmd.DW3.NumParEngine = paramsG11->dwNumberOfPipes;
1539 cmd.DW3.TileNumber = paramsG11->dwTileId;
1540
1541 //Aligned Tile height & frame width
1542 uint32_t frameHeightInLCU = ((seqParams->wFrameHeightInMinCbMinus1 + 1) * (1 << (seqParams->log2_min_coding_block_size_minus3 + 3))) / ctbSize;
1543 //StreamIn data is 4 CLs per LCU, Offset is programmed every tile
1544 cmd.DW6.StreaminOffsetEnable = 1;
1545 cmd.DW6.TileStreaminOffset = paramsG11->pTileCodingParams->TileStreaminOffset;
1546
1547 cmd.DW8.TileStreamoutOffsetEnable = 1;
1548 cmd.DW8.TileStreamoutOffset = paramsG11->dwTileId * 19;
1549
1550 //PAK Object StreamOut Offset Computation : Only on Tile Columns
1551 if (cmd.DW4.TileStartCtbY == 0)
1552 {
1553 //RowStore Offset Computation
1554 uint32_t num32x32InX = (cmd.DW4.TileStartCtbX) / 32;
1555 cmd.DW7.RowStoreOffsetEnable = 1;
1556 cmd.DW7.TileRowstoreOffset = num32x32InX;
1557
1558 cmd.DW9.LcuStreamOutOffsetEnable = 1;
1559 //Aligned Tile width & frame height
1560 uint32_t widthInLCU = cmd.DW4.TileStartCtbX / ctbSize;
1561
1562 // we need additional buffer for (1) 1 CL for size info at the beginning of each tile column (max of 4 vdbox in scalability mode)
1563 // (2) CL alignment at end of every tile column
1564 // as a result, increase the height by 1 for offset purposes
1565 uint32_t numOfLCU = widthInLCU*(frameHeightInLCU + 1);
1566 uint32_t maxNumCUInLCU = (64 / 8)*(64 / 8); //max LCU size is 64, min Cu size is 8
1567
1568 uint32_t tileLCUStreamOutByteOffset = 2 * BYTES_PER_DWORD * numOfLCU * (NUM_PAK_DWS_PER_LCU + maxNumCUInLCU * NUM_DWS_PER_CU);
1569 cmd.DW9.TileLcuStreamOutOffset = MOS_ROUNDUP_DIVIDE(tileLCUStreamOutByteOffset, MHW_CACHELINE_SIZE);
1570 }
1571 }
1572 }
1573 else if (params->Mode == CODECHAL_ENCODE_MODE_VP9)
1574 {
1575 auto paramsG11 = dynamic_cast<PMHW_VDBOX_VDENC_WALKER_STATE_PARAMS_G11>(params);
1576 MHW_MI_CHK_NULL(paramsG11);
1577 MHW_MI_CHK_NULL(params->pVp9EncPicParams);
1578 auto vp9PicParams = params->pVp9EncPicParams;
1579 auto tileCodingParams = paramsG11->pTileCodingParams;
1580
1581 cmd.DW8.TileStreamoutOffsetEnable = 1;
1582 cmd.DW6.StreaminOffsetEnable = 1;
1583
1584 if (tileCodingParams == nullptr)
1585 {
1586 cmd.DW2.NextsliceMbLcuStartXPosition = CODECHAL_GET_WIDTH_IN_BLOCKS(vp9PicParams->SrcFrameWidthMinus1, CODEC_VP9_SUPER_BLOCK_WIDTH);
1587 cmd.DW2.NextsliceMbStartYPosition = CODECHAL_GET_HEIGHT_IN_BLOCKS(vp9PicParams->SrcFrameHeightMinus1, CODEC_VP9_SUPER_BLOCK_HEIGHT);
1588 cmd.DW5.TileWidth = vp9PicParams->SrcFrameWidthMinus1;
1589 cmd.DW5.TileHeight = vp9PicParams->SrcFrameHeightMinus1;
1590 cmd.DW1.FirstSuperSlice = 1;
1591 }
1592 else
1593 {
1594 cmd.DW1.MbLcuStartXPosition = tileCodingParams->TileStartLCUX;
1595 cmd.DW1.MbLcuStartYPosition = tileCodingParams->TileStartLCUY;
1596
1597 cmd.DW5.TileWidth = ((tileCodingParams->TileWidthInMinCbMinus1 + 1) * CODEC_VP9_MIN_BLOCK_WIDTH) - 1;
1598 cmd.DW5.TileHeight = ((tileCodingParams->TileHeightInMinCbMinus1 + 1) * CODEC_VP9_MIN_BLOCK_HEIGHT) - 1;
1599
1600 cmd.DW4.TileStartCtbX = tileCodingParams->TileStartLCUX * CODEC_VP9_SUPER_BLOCK_WIDTH;
1601 cmd.DW4.TileStartCtbY = tileCodingParams->TileStartLCUY * CODEC_VP9_SUPER_BLOCK_HEIGHT;
1602
1603 cmd.DW2.NextsliceMbLcuStartXPosition = CODECHAL_GET_WIDTH_IN_BLOCKS((cmd.DW4.TileStartCtbX + cmd.DW5.TileWidth + 1), CODEC_VP9_SUPER_BLOCK_WIDTH);
1604 cmd.DW2.NextsliceMbStartYPosition = CODECHAL_GET_HEIGHT_IN_BLOCKS((cmd.DW4.TileStartCtbY + cmd.DW5.TileHeight + 1), CODEC_VP9_SUPER_BLOCK_HEIGHT);
1605
1606 cmd.DW1.FirstSuperSlice = 1;
1607 cmd.DW3.NumParEngine = paramsG11->dwNumberOfPipes;
1608 cmd.DW3.TileNumber = paramsG11->dwTileId;
1609
1610 uint32_t tileStartXInSBs = (cmd.DW4.TileStartCtbX / CODEC_VP9_SUPER_BLOCK_WIDTH);
1611 uint32_t tileStartYInSBs = (cmd.DW4.TileStartCtbY / CODEC_VP9_SUPER_BLOCK_HEIGHT);
1612 //Aligned Tile height & frame width
1613 uint32_t tileHeightInSBs = (cmd.DW5.TileHeight + 1 + (CODEC_VP9_SUPER_BLOCK_HEIGHT - 1)) / CODEC_VP9_SUPER_BLOCK_HEIGHT;
1614 uint32_t frameWidthInSBs = (vp9PicParams->SrcFrameWidthMinus1 + 1 + (CODEC_VP9_SUPER_BLOCK_WIDTH - 1)) / CODEC_VP9_SUPER_BLOCK_WIDTH;
1615
1616 cmd.DW6.TileStreaminOffset = (tileStartYInSBs * frameWidthInSBs + tileStartXInSBs * tileHeightInSBs) * (4); //StreamIn data is 4 CLs per LCU
1617
1618 //Frame Stats Offset
1619 cmd.DW8.TileStreamoutOffset = (paramsG11->dwTileId * 19); // 3 CLs or 48 DWs of statistics data + 16CLs or 256 DWs of Histogram data
1620
1621 // If Tile Column, compute PAK Object StreamOut Offsets
1622 if (cmd.DW4.TileStartCtbY == 0)
1623 {
1624 //RowStore Offset Computation
1625 uint32_t num32x32sInX = (cmd.DW4.TileStartCtbX) / 32;
1626 cmd.DW7.RowStoreOffsetEnable = 1;
1627 cmd.DW7.TileRowstoreOffset = num32x32sInX;
1628
1629 //Aligned Tile width & frame height
1630 uint32_t widthInSBs = (cmd.DW4.TileStartCtbX) / CODEC_VP9_SUPER_BLOCK_WIDTH;
1631 uint32_t frameHeightInSBs = ((vp9PicParams->SrcFrameHeightMinus1 + 1) + (CODEC_VP9_SUPER_BLOCK_HEIGHT - 1)) / CODEC_VP9_SUPER_BLOCK_HEIGHT;
1632 uint32_t numOfSBs = widthInSBs * (frameHeightInSBs + 1);
1633 uint32_t maxNumOfCUInSB = (CODEC_VP9_SUPER_BLOCK_HEIGHT / CODEC_VP9_MIN_BLOCK_HEIGHT)*(CODEC_VP9_SUPER_BLOCK_WIDTH / CODEC_VP9_MIN_BLOCK_WIDTH); //max LCU size is 64, min Cu size is 8
1634 uint32_t tileLCUStreamOutOffsetInBytes = 2 * 4 * ((numOfSBs * 5) + (numOfSBs*maxNumOfCUInSB * 8));
1635
1636 cmd.DW9.LcuStreamOutOffsetEnable = 1;
1637 cmd.DW9.TileLcuStreamOutOffset = MOS_ROUNDUP_DIVIDE(tileLCUStreamOutOffsetInBytes, MHW_CACHELINE_SIZE);
1638 }
1639 }
1640 }
1641
1642 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1643
1644 return MOS_STATUS_SUCCESS;
1645 }
1646
1647 MOS_STATUS AddVdencAvcWeightsOffsetsStateCmd(
1648 PMOS_COMMAND_BUFFER cmdBuffer,
1649 PMHW_VDBOX_AVC_WEIGHTOFFSET_PARAMS params)
1650 {
1651 MHW_FUNCTION_ENTER;
1652
1653 MHW_MI_CHK_NULL(this->m_osInterface);
1654 MHW_MI_CHK_NULL(cmdBuffer);
1655 MHW_MI_CHK_NULL(params);
1656 MHW_MI_CHK_NULL(params->pAvcPicParams);
1657
1658 typename TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD cmd;
1659
1660 auto avcPicParams = params->pAvcPicParams;
1661
1662 if (avcPicParams->weighted_pred_flag == 1)
1663 {
1664 cmd.DW1.WeightsForwardReference0 = params->Weights[0][0][0][0];
1665 cmd.DW1.OffsetForwardReference0 = params->Weights[0][0][0][1];
1666 cmd.DW1.WeightsForwardReference1 = params->Weights[0][1][0][0];
1667 cmd.DW1.OffsetForwardReference1 = params->Weights[0][1][0][1];
1668 cmd.DW2.WeightsForwardReference2 = params->Weights[0][2][0][0];
1669 cmd.DW2.OffsetForwardReference2 = params->Weights[0][2][0][1];
1670 }
1671 //set to default value when weighted prediction not enabled
1672 else
1673 {
1674 cmd.DW1.WeightsForwardReference0 = 1;
1675 cmd.DW1.OffsetForwardReference0 = 0;
1676 cmd.DW1.WeightsForwardReference1 = 1;
1677 cmd.DW1.OffsetForwardReference1 = 0;
1678 cmd.DW2.WeightsForwardReference2 = 1;
1679 cmd.DW2.OffsetForwardReference2 = 0;
1680 }
1681
1682 MHW_MI_CHK_STATUS(this->m_osInterface->pfnAddCommand(cmdBuffer, &cmd, sizeof(cmd)));
1683
1684 return MOS_STATUS_SUCCESS;
1685 }
1686
1687 MOS_STATUS AddVdencWeightsOffsetsStateCmd(
1688 PMOS_COMMAND_BUFFER cmdBuffer,
1689 PMHW_BATCH_BUFFER batchBuffer,
1690 PMHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS params)
1691 {
1692 MHW_FUNCTION_ENTER;
1693
1694 MHW_MI_CHK_NULL(params);
1695
1696 typename TVdencCmds::VDENC_WEIGHTSOFFSETS_STATE_CMD cmd;
1697
1698 cmd.DW1.WeightsForwardReference0 = 1;
1699 cmd.DW1.OffsetForwardReference0 = 0;
1700 cmd.DW1.WeightsForwardReference1 = 1;
1701 cmd.DW1.OffsetForwardReference1 = 0;
1702 cmd.DW2.WeightsForwardReference2 = 1;
1703 cmd.DW2.OffsetForwardReference2 = 0;
1704 cmd.DW3.HevcVp9WeightsForwardReference0 = 1;
1705 cmd.DW3.HevcVp9OffsetForwardReference0 = 0;
1706 cmd.DW3.HevcVp9WeightsForwardReference1 = 1;
1707 cmd.DW3.HevcVp9OffsetForwardReference1 = 0;
1708 cmd.DW4.HevcVp9WeightsForwardReference2 = 1;
1709 cmd.DW4.HevcVp9OffsetForwardReference2 = 0;
1710 cmd.DW4.HevcVp9WeightsBackwardReference0 = 1;
1711 cmd.DW4.HevcVp9OffsetBackwardReference0 = 0;
1712
1713 // Luma Offsets and Weights
1714 if (params->bWeightedPredEnabled)
1715 {
1716 uint32_t refPicListNum = 0;
1717 // DWORD 3
1718 cmd.DW3.HevcVp9WeightsForwardReference0 = CodecHal_Clip3(-128, 127,
1719 params->LumaWeights[refPicListNum][0] + params->dwDenom);
1720 cmd.DW3.HevcVp9OffsetForwardReference0 = params->LumaOffsets[refPicListNum][0];
1721 cmd.DW3.HevcVp9WeightsForwardReference1 = CodecHal_Clip3(-128, 127,
1722 params->LumaWeights[refPicListNum][1] + params->dwDenom);
1723 cmd.DW3.HevcVp9OffsetForwardReference1 = params->LumaOffsets[refPicListNum][1];
1724 // DWORD 4
1725 cmd.DW4.HevcVp9WeightsForwardReference2 = CodecHal_Clip3(-128, 127,
1726 params->LumaWeights[refPicListNum][2] + params->dwDenom);
1727 cmd.DW4.HevcVp9OffsetForwardReference2 = params->LumaOffsets[refPicListNum][2];
1728 // HEVC VDEnc currently only supports LDB. LDB doesn't have backward reference.
1729 cmd.DW4.HevcVp9WeightsBackwardReference0 = 0;
1730 cmd.DW4.HevcVp9OffsetBackwardReference0 = 0;
1731 }
1732
1733 if (cmdBuffer == nullptr && batchBuffer == nullptr)
1734 {
1735 MHW_ASSERTMESSAGE("There was no valid buffer to add the HW command to.");
1736 return MOS_STATUS_NULL_POINTER;
1737 }
1738
1739 MHW_MI_CHK_STATUS(Mhw_AddCommandCmdOrBB(this->m_osInterface, cmdBuffer, batchBuffer, &cmd, sizeof(cmd)));
1740
1741 return MOS_STATUS_SUCCESS;
1742 }
1743
1744 MOS_STATUS AddVdencCmd1Cmd(
1745 PMOS_COMMAND_BUFFER cmdBuffer,
1746 PMHW_BATCH_BUFFER batchBuffer,
1747 PMHW_VDBOX_VDENC_CMD1_PARAMS params)
1748 {
1749 return MOS_STATUS_SUCCESS;
1750 }
1751
1752 MOS_STATUS AddVdencCmd2Cmd(
1753 PMOS_COMMAND_BUFFER cmdBuffer,
1754 PMHW_BATCH_BUFFER batchBuffer,
1755 PMHW_VDBOX_VDENC_CMD2_STATE params)
1756 {
1757 return MOS_STATUS_SUCCESS;
1758 }
1759
1760 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS CreateMhwVdboxPipeModeSelectParams()
1761 {
1762 PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams = MOS_New(MHW_VDBOX_PIPE_MODE_SELECT_PARAMS_G11);
1763
1764 return pipeModeSelectParams;
1765 }
1766
1767 void ReleaseMhwVdboxPipeModeSelectParams(PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams)
1768 {
1769 MOS_Delete(pipeModeSelectParams);
1770 }
1771 };
1772
1773 //! MHW Vdbox Vdenc interface for Gen11 ICL
1774 /*!
1775 This class defines the Vdenc command construction functions for Gen11 platform
1776 */
1777 class MhwVdboxVdencInterfaceG11Icl : public MhwVdboxVdencInterfaceG11<mhw_vdbox_vdenc_g11_X>
1778 {
1779 public:
1780 //!
1781 //! \brief Constructor
1782 //!
1783 MhwVdboxVdencInterfaceG11Icl(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceG11(osInterface)
1784 {
1785 MHW_FUNCTION_ENTER;
1786 }
1787
1788 //!
1789 //! \brief Destructor
1790 //!
1791 virtual ~MhwVdboxVdencInterfaceG11Icl() { }
1792
1793 };
1794
1795 #endif
1796