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 //! ~MhwVdboxVdencInterfaceG9()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<TVdencCmds>(PMOS_INTERFACE osInterface) : MhwVdboxVdencInterfaceGeneric<TVdencCmds>(osInterface) 55 { 56 MHW_FUNCTION_ENTER; 57 58 this->InitRowstoreUserFeatureSettings(); 59 } 60 InitRowstoreUserFeatureSettings()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 GetRowstoreCachingAddrs(PMHW_VDBOX_ROWSTORE_PARAMS rowstoreParams)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 GetVdencStateCommandsDataSize(uint32_t mode,uint32_t waAddDelayInVDEncDynamicSlice,uint32_t * commandsSize,uint32_t * patchListSize)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 GetVdencPrimitiveCommandsDataSize(uint32_t mode,uint32_t * commandsSize,uint32_t * patchListSize)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 CreateMhwVdboxPipeModeSelectParams()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 ReleaseMhwVdboxPipeModeSelectParams(PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams)218 void ReleaseMhwVdboxPipeModeSelectParams(PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS pipeModeSelectParams) 219 { 220 MOS_Delete(pipeModeSelectParams); 221 } 222 AddVdencPipeModeSelectCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_PIPE_MODE_SELECT_PARAMS params)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(cmdBuffer); 230 MHW_MI_CHK_NULL(params); 231 232 typename TVdencCmds::VDENC_PIPE_MODE_SELECT_CMD cmd; 233 234 cmd.DW1.StandardSelect = CodecHal_GetStandardFromMode(params->Mode); 235 cmd.DW1.FrameStatisticsStreamOutEnable = 1; 236 cmd.DW1.TlbPrefetchEnable = params->bTlbPrefetchEnable; 237 cmd.DW1.PakThresholdCheckEnable = params->bDynamicSliceEnable; 238 cmd.DW1.VdencStreamInEnable = params->bVdencStreamInEnable; 239 240 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd))); 241 242 return MOS_STATUS_SUCCESS; 243 } 244 AddVdencPipeBufAddrCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params)245 MOS_STATUS AddVdencPipeBufAddrCmd( 246 PMOS_COMMAND_BUFFER cmdBuffer, 247 PMHW_VDBOX_PIPE_BUF_ADDR_PARAMS params) 248 { 249 MOS_SURFACE details; 250 uint8_t refIdx; 251 252 MHW_FUNCTION_ENTER; 253 254 MHW_MI_CHK_NULL(cmdBuffer); 255 MHW_MI_CHK_NULL(params); 256 MHW_MI_CHK_NULL(this->m_osInterface); 257 258 typename TVdencCmds::VDENC_PIPE_BUF_ADDR_STATE_CMD cmd; 259 260 MOS_MEMCOMP_STATE mmcMode = MOS_MEMCOMP_DISABLED; 261 MHW_RESOURCE_PARAMS resourceParams; 262 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 263 resourceParams.dwLsbNum = MHW_VDBOX_MFX_GENERAL_STATE_SHIFT; 264 resourceParams.HwCommandType = MOS_VDENC_PIPE_BUF_ADDR; 265 266 if (params->psRawSurface != nullptr) 267 { 268 269 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, ¶ms->psRawSurface->OsResource, &mmcMode)); 270 271 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionEnable = 272 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 273 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 274 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryCompressionMode = 275 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 276 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 277 cmd.OriginalUncompressedPicture.PictureFields.DW0.MemoryObjectControlState = 278 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_ORIGINAL_UNCOMPRESSED_PICTURE_ENCODE].Value; 279 280 cmd.OriginalUncompressedPicture.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(params->psRawSurface->TileType); 281 282 resourceParams.presResource = ¶ms->psRawSurface->OsResource; 283 resourceParams.dwOffset = params->psRawSurface->dwOffset; 284 resourceParams.pdwCmd = &(cmd.OriginalUncompressedPicture.LowerAddress.DW0.Value); 285 resourceParams.dwLocationInCmd = 10; 286 resourceParams.bIsWritable = false; 287 288 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 289 this->m_osInterface, 290 cmdBuffer, 291 &resourceParams)); 292 } 293 294 if (this->m_vdencRowStoreCache.bEnabled) 295 { 296 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.CacheSelect = TVdencCmds::VDENC_Surface_Control_Bits_CMD::CACHE_SELECT_UNNAMED1; 297 cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value = this->m_vdencRowStoreCache.dwAddress << 6; 298 } 299 else if (params->presVdencIntraRowStoreScratchBuffer != nullptr) 300 { 301 cmd.RowStoreScratchBuffer.BufferPictureFields.DW0.MemoryObjectControlState = 302 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_ROW_STORE_BUFFER_CODEC].Value; 303 304 resourceParams.presResource = params->presVdencIntraRowStoreScratchBuffer; 305 resourceParams.dwOffset = 0; 306 resourceParams.pdwCmd = &(cmd.RowStoreScratchBuffer.LowerAddress.DW0.Value); 307 resourceParams.dwLocationInCmd = 16; 308 resourceParams.bIsWritable = true; 309 310 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 311 this->m_osInterface, 312 cmdBuffer, 313 &resourceParams)); 314 } 315 316 if (params->presVdencStreamOutBuffer != nullptr) 317 { 318 cmd.VdencStatisticsStreamout.PictureFields.DW0.MemoryObjectControlState = 319 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_STREAMOUT_DATA_CODEC].Value; 320 321 resourceParams.presResource = params->presVdencStreamOutBuffer; 322 resourceParams.dwOffset = 0; 323 resourceParams.pdwCmd = &(cmd.VdencStatisticsStreamout.LowerAddress.DW0.Value); 324 resourceParams.dwLocationInCmd = 34; 325 resourceParams.bIsWritable = true; 326 327 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 328 this->m_osInterface, 329 cmdBuffer, 330 &resourceParams)); 331 } 332 333 if (params->presVdencStreamInBuffer != nullptr) 334 { 335 cmd.StreaminDataPicture.PictureFields.DW0.MemoryObjectControlState = 336 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_VDENC_STREAMIN_CODEC].Value; 337 338 resourceParams.presResource = params->presVdencStreamInBuffer; 339 resourceParams.dwOffset = 0; 340 resourceParams.pdwCmd = &(cmd.StreaminDataPicture.LowerAddress.DW0.Value); 341 resourceParams.dwLocationInCmd = 13; 342 resourceParams.bIsWritable = false; 343 344 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 345 this->m_osInterface, 346 cmdBuffer, 347 &resourceParams)); 348 } 349 350 for (refIdx = 0; refIdx <= params->dwNumRefIdxL0ActiveMinus1; refIdx++) 351 { 352 if (params->presVdencReferences[refIdx]) 353 { 354 // L0 references 355 MOS_ZeroMemory(&details, sizeof(details)); 356 details.Format = Format_Invalid; 357 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdencReferences[refIdx], &details)); 358 359 resourceParams.presResource = params->presVdencReferences[refIdx]; 360 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset; 361 resourceParams.dwLocationInCmd = (refIdx * 3) + 22; 362 resourceParams.bIsWritable = false; 363 switch (refIdx) 364 { 365 case 0: 366 resourceParams.pdwCmd = &(cmd.FwdRef0.LowerAddress.DW0.Value); 367 break; 368 case 1: 369 resourceParams.pdwCmd = &(cmd.FwdRef1.LowerAddress.DW0.Value); 370 break; 371 case 2: 372 resourceParams.pdwCmd = &(cmd.FwdRef2.LowerAddress.DW0.Value); 373 break; 374 default: 375 break; 376 } 377 378 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode)); 379 380 switch (refIdx) 381 { 382 case 0: 383 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionEnable = 384 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 385 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 386 cmd.FwdRef0.PictureFields.DW0.MemoryCompressionMode = 387 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 388 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 389 cmd.FwdRef0.PictureFields.DW0.MemoryObjectControlState = 390 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value; 391 cmd.FwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType); 392 break; 393 case 1: 394 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionEnable = 395 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 396 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 397 cmd.FwdRef1.PictureFields.DW0.MemoryCompressionMode = 398 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 399 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 400 cmd.FwdRef1.PictureFields.DW0.MemoryObjectControlState = 401 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value; 402 cmd.FwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType); 403 break; 404 case 2: 405 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionEnable = 406 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 407 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 408 cmd.FwdRef2.PictureFields.DW0.MemoryCompressionMode = 409 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 410 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 411 cmd.FwdRef2.PictureFields.DW0.MemoryObjectControlState = 412 this->m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_REFERENCE_PICTURE_CODEC].Value; 413 cmd.FwdRef2.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType); 414 break; 415 default: 416 break; 417 } 418 419 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 420 this->m_osInterface, 421 cmdBuffer, 422 &resourceParams)); 423 } 424 425 // so far VDEnc only support 2 4x/8x DS Ref Pictures 426 if ((refIdx <= 1) && params->presVdenc4xDsSurface[refIdx]) 427 { 428 // 4x DS surface for VDEnc 429 MOS_ZeroMemory(&details, sizeof(details)); 430 details.Format = Format_Invalid; 431 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetResourceInfo(this->m_osInterface, params->presVdenc4xDsSurface[refIdx], &details)); 432 433 resourceParams.presResource = params->presVdenc4xDsSurface[refIdx]; 434 resourceParams.dwOffset = details.RenderOffset.YUV.Y.BaseOffset; 435 resourceParams.dwLocationInCmd = (refIdx * 3) + 1; 436 resourceParams.bIsWritable = false; 437 switch (refIdx) 438 { 439 case 0: 440 resourceParams.pdwCmd = &(cmd.DsFwdRef0.LowerAddress.DW0.Value); 441 break; 442 case 1: 443 resourceParams.pdwCmd = &(cmd.DsFwdRef1.LowerAddress.DW0.Value); 444 break; 445 default: 446 break; 447 } 448 449 MHW_MI_CHK_STATUS(this->m_osInterface->pfnGetMemoryCompressionMode(this->m_osInterface, resourceParams.presResource, &mmcMode)); 450 451 switch (refIdx) 452 { 453 case 0: 454 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionEnable = 455 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 456 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 457 cmd.DsFwdRef0.PictureFields.DW0.MemoryCompressionMode = 458 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 459 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 460 cmd.DsFwdRef0.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType); 461 break; 462 case 1: 463 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionEnable = 464 mmcMode != MOS_MEMCOMP_DISABLED ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_ENABLE 465 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_ENABLE_DISABLE; 466 cmd.DsFwdRef1.PictureFields.DW0.MemoryCompressionMode = 467 mmcMode == MOS_MEMCOMP_HORIZONTAL ? TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_HORIZONTALCOMPRESSIONMODE 468 : TVdencCmds::VDENC_Surface_Control_Bits_CMD::MEMORY_COMPRESSION_MODE_VERTICALCOMPRESSIONMODE; 469 cmd.DsFwdRef1.PictureFields.DW0.TiledResourceMode = Mhw_ConvertToTRMode(details.TileType); 470 break; 471 default: 472 break; 473 } 474 475 MHW_MI_CHK_STATUS(this->AddResourceToCmd( 476 this->m_osInterface, 477 cmdBuffer, 478 &resourceParams)); 479 } 480 } 481 482 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd))); 483 484 return MOS_STATUS_SUCCESS; 485 } 486 AddVdencRefSurfaceStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_SURFACE_PARAMS params)487 MOS_STATUS AddVdencRefSurfaceStateCmd( 488 PMOS_COMMAND_BUFFER cmdBuffer, 489 PMHW_VDBOX_SURFACE_PARAMS params) 490 { 491 MHW_FUNCTION_ENTER; 492 493 MHW_MI_CHK_NULL(cmdBuffer); 494 MHW_MI_CHK_NULL(params); 495 MHW_MI_CHK_NULL(params->psSurface); 496 497 typename TVdencCmds::VDENC_REF_SURFACE_STATE_CMD cmd; 498 499 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1; 500 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1; 501 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection; 502 503 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0; 504 505 if (cmd.Dwords25.DW1.TiledSurface) 506 { 507 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType); 508 } 509 510 cmd.Dwords25.DW1.SurfaceFormat = this->MosToMediaStateFormat(params->psSurface->Format); //dwSurfaceFormat; should be 4 511 cmd.Dwords25.DW1.InterleaveChroma = 1; 512 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1; 513 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset; 514 515 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd))); 516 517 return MOS_STATUS_SUCCESS; 518 } 519 AddVdencDsRefSurfaceStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_VDBOX_SURFACE_PARAMS params,uint8_t numSurfaces)520 MOS_STATUS AddVdencDsRefSurfaceStateCmd( 521 PMOS_COMMAND_BUFFER cmdBuffer, 522 PMHW_VDBOX_SURFACE_PARAMS params, 523 uint8_t numSurfaces) 524 { 525 MHW_FUNCTION_ENTER; 526 527 MOS_UNUSED(numSurfaces); 528 529 MHW_MI_CHK_NULL(cmdBuffer); 530 MHW_MI_CHK_NULL(params); 531 MHW_MI_CHK_NULL(params->psSurface); 532 533 typename TVdencCmds::VDENC_DS_REF_SURFACE_STATE_CMD cmd; 534 535 cmd.Dwords25.DW0.Width = params->psSurface->dwWidth - 1; 536 cmd.Dwords25.DW0.Height = params->psSurface->dwHeight - 1; 537 cmd.Dwords25.DW0.CrVCbUPixelOffsetVDirection = params->ucVDirection; 538 539 cmd.Dwords25.DW1.TiledSurface = IS_TILE_FORMAT(params->psSurface->TileType) ? 1 : 0; 540 541 if (cmd.Dwords25.DW1.TiledSurface) 542 { 543 cmd.Dwords25.DW1.TileWalk = (params->psSurface->TileType); 544 } 545 cmd.Dwords25.DW1.SurfaceFormat = this->MosToMediaStateFormat(params->psSurface->Format); //dwSurfaceFormat; should be 4 546 cmd.Dwords25.DW1.InterleaveChroma = 1; 547 cmd.Dwords25.DW1.SurfacePitch = params->psSurface->dwPitch - 1; 548 cmd.Dwords25.DW2.YOffsetForUCb = cmd.Dwords25.DW3.YOffsetForVCr = params->psSurface->UPlaneOffset.iYOffset; 549 550 MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, sizeof(cmd))); 551 552 return MOS_STATUS_SUCCESS; 553 } 554 AddVdencWeightsOffsetsStateCmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,PMHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS params)555 MOS_STATUS AddVdencWeightsOffsetsStateCmd( 556 PMOS_COMMAND_BUFFER cmdBuffer, 557 PMHW_BATCH_BUFFER batchBuffer, 558 PMHW_VDBOX_VDENC_WEIGHT_OFFSET_PARAMS params) 559 { 560 MOS_UNUSED(cmdBuffer); 561 MOS_UNUSED(batchBuffer); 562 MOS_UNUSED(params); 563 return MOS_STATUS_PLATFORM_NOT_SUPPORTED; 564 } 565 AddVdencCmd1Cmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,PMHW_VDBOX_VDENC_CMD1_PARAMS params)566 MOS_STATUS AddVdencCmd1Cmd( 567 PMOS_COMMAND_BUFFER cmdBuffer, 568 PMHW_BATCH_BUFFER batchBuffer, 569 PMHW_VDBOX_VDENC_CMD1_PARAMS params) 570 { 571 MOS_UNUSED(cmdBuffer); 572 MOS_UNUSED(batchBuffer); 573 MOS_UNUSED(params); 574 return MOS_STATUS_SUCCESS; 575 } 576 AddVdencCmd2Cmd(PMOS_COMMAND_BUFFER cmdBuffer,PMHW_BATCH_BUFFER batchBuffer,PMHW_VDBOX_VDENC_CMD2_STATE params)577 MOS_STATUS AddVdencCmd2Cmd( 578 PMOS_COMMAND_BUFFER cmdBuffer, 579 PMHW_BATCH_BUFFER batchBuffer, 580 PMHW_VDBOX_VDENC_CMD2_STATE params) 581 { 582 MOS_UNUSED(cmdBuffer); 583 MOS_UNUSED(batchBuffer); 584 MOS_UNUSED(params); 585 return MOS_STATUS_SUCCESS; 586 } 587 588 public: GetVdencCmd1Size()589 inline uint32_t GetVdencCmd1Size() 590 { 591 return 0; 592 } 593 GetVdencCmd2Size()594 inline uint32_t GetVdencCmd2Size() 595 { 596 return 0; 597 } 598 }; 599 600 #endif 601