1 /* 2 * Copyright (c) 2024, 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_sfc_xe2_hpm_next_impl.h 24 //! \brief MHW sfc interface for Xe2_HPM 25 //! \details 26 //! 27 28 #ifndef __MHW_SFC_XE2_HPM_NEXT_IMPL_H__ 29 #define __MHW_SFC_XE2_HPM_NEXT_IMPL_H__ 30 31 #include "mhw_sfc_impl.h" 32 #include "mhw_sfc_xe_lpm_plus_base_next_impl.h" 33 #include "mhw_sfc_hwcmd_xe2_hpm_next.h" 34 #include "mhw_sfc_itf.h" 35 #include "mhw_impl.h" 36 37 #define VALUE_XOFFSET 3 38 namespace mhw 39 { 40 namespace sfc 41 { 42 namespace xe2_hpm_next 43 { 44 class Impl : public sfc::Impl<mhw::sfc::xe2_hpm_next::Cmd> 45 { 46 public: Impl(PMOS_INTERFACE osItf)47 Impl(PMOS_INTERFACE osItf) : base_t(osItf) 48 { 49 MHW_FUNCTION_ENTER; 50 }; 51 SetOutputSurfaceFormatType(mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD * cmd,SFC_STATE_PAR params,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface,bool & bInterleaveChroma,uint16_t & wUYOffset)52 MOS_STATUS SetOutputSurfaceFormatType( 53 mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD *cmd, 54 SFC_STATE_PAR params, 55 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface, 56 bool &bInterleaveChroma, 57 uint16_t &wUYOffset) 58 { 59 MHW_CHK_NULL_RETURN(cmd); 60 MHW_CHK_NULL_RETURN(pOutSurface); 61 switch (params.OutputFrameFormat) 62 { 63 case Format_RGBP: 64 case Format_BGRP: 65 cmd->DW3.RgbPlanarMemoryFormatEnable = 1; 66 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R8; 67 break; 68 case Format_R8G8B8: 69 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_INTEGRAL_32; 70 break; 71 case Format_AYUV: 72 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_AYUV; 73 break; 74 case Format_X8R8G8B8: 75 case Format_A8R8G8B8: 76 case Format_X8B8G8R8: 77 case Format_A8B8G8R8: 78 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R8; 79 break; 80 case Format_R10G10B10A2: 81 case Format_B10G10R10A2: 82 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A2R10G10B10; 83 break; 84 case Format_R5G6B5: 85 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_R5G6B5; 86 break; 87 case Format_NV12: 88 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_NV12; 89 bInterleaveChroma = true; 90 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 91 break; 92 case Format_YVYU: 93 case Format_YUY2: 94 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_YUYV; 95 break; 96 case Format_VYUY: 97 case Format_UYVY: 98 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_UYVY; 99 break; 100 case Format_P010: 101 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_P016; 102 cmd->DW4.Bitdepth = 0; 103 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 104 break; 105 case Format_P016: 106 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_P016; 107 cmd->DW4.Bitdepth = 1; 108 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 109 break; 110 case Format_Y210: 111 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_Y216; 112 cmd->DW4.Bitdepth = 0; 113 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 114 break; 115 case Format_Y216: 116 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_Y216; 117 cmd->DW4.Bitdepth = 1; 118 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 119 break; 120 case Format_Y410: 121 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_Y416; 122 cmd->DW4.Bitdepth = 0; 123 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 124 break; 125 case Format_Y416: 126 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_Y416; 127 cmd->DW4.Bitdepth = 1; 128 wUYOffset = (uint16_t)pOutSurface->dwUYoffset; 129 break; 130 case Format_Y8: 131 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R83; 132 cmd->DW4.Bitdepth = 0; 133 break; 134 case Format_Y16U: 135 case Format_Y16S: 136 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R84; 137 cmd->DW4.Bitdepth = 0; 138 break; 139 case Format_A16R16G16B16: 140 case Format_A16B16G16R16: 141 cmd->DW3.OutputSurfaceFormatType = cmd->OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R85; 142 cmd->DW4.Bitdepth = 0; 143 break; 144 default: 145 MHW_ASSERTMESSAGE("Unknown Output Format."); 146 return MOS_STATUS_UNKNOWN; 147 } 148 149 return MOS_STATUS_SUCCESS; 150 } 151 SetOutputFrameSurface(mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD * cmd,SFC_STATE_PAR params,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)152 MOS_STATUS SetOutputFrameSurface( 153 mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD *cmd, 154 SFC_STATE_PAR params, 155 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface) 156 { 157 MHW_CHK_NULL_RETURN(cmd); 158 MHW_CHK_NULL_RETURN(pOutSurface); 159 // Set DW19 160 if (params.bMMCEnable && 161 (params.MMCMode == MOS_MMC_RC || 162 params.MMCMode == MOS_MMC_MC)) 163 { 164 cmd->DW3.OutputCompressionFormat = pOutSurface->dwCompressionFormat; 165 } 166 167 cmd->DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = m_outputSurfCtrl.Gen9.Index; 168 169 // copy from base surface 170 cmd->DW57.BottomFieldSurfaceBaseAddressArbitrationPriorityControl = 171 cmd->DW19.OutputFrameSurfaceBaseAddressArbitrationPriorityControl; 172 cmd->DW57.BottomFieldSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = 173 cmd->DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables; 174 175 return MOS_STATUS_SUCCESS; 176 } 177 SetOutputSurfaceOffset(mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD * cmd,uint16_t wUYOffset,uint16_t wUXOffset,uint16_t wVYOffset,uint16_t wVXOffset,SFC_STATE_PAR params,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)178 MOS_STATUS SetOutputSurfaceOffset( 179 mhw::sfc::xe2_hpm_next::Cmd::SFC_STATE_CMD *cmd, 180 uint16_t wUYOffset, 181 uint16_t wUXOffset, 182 uint16_t wVYOffset, 183 uint16_t wVXOffset, 184 SFC_STATE_PAR params, 185 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface) 186 { 187 MHW_CHK_NULL_RETURN(cmd); 188 MHW_CHK_NULL_RETURN(pOutSurface); 189 // Set DW30, DW31 190 cmd->DW30.OutputSurfaceYOffsetForU = wUYOffset; 191 cmd->DW30.OutputSurfaceXOffsetForU = wUXOffset; 192 cmd->DW31.OutputSurfaceYOffsetForV = wVYOffset; 193 cmd->DW31.OutputSurfaceXOffsetForV = wVXOffset; 194 195 if (Format_RGBP == params.OutputFrameFormat || Format_BGRP == params.OutputFrameFormat) 196 { 197 cmd->DW30.OutputSurfaceYOffsetForU = (uint16_t)pOutSurface->dwUYoffset; 198 cmd->DW31.OutputSurfaceYOffsetForV = (uint16_t)pOutSurface->dwVUoffset + (uint16_t)pOutSurface->dwUYoffset; 199 } 200 return MOS_STATUS_SUCCESS; 201 } 202 _MHW_SETCMD_OVERRIDE_DECL(SFC_LOCK)203 _MHW_SETCMD_OVERRIDE_DECL(SFC_LOCK) 204 { 205 _MHW_SETCMD_CALLBASE(SFC_LOCK); 206 207 //MHW_CHK_NULL_RETURN(cmd.cmdPtr); 208 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) 209 { 210 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 211 } 212 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 213 { 214 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 215 } 216 else 217 { 218 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 219 } 220 221 return MOS_STATUS_SUCCESS; 222 } 223 _MHW_SETCMD_OVERRIDE_DECL(SFC_STATE)224 _MHW_SETCMD_OVERRIDE_DECL(SFC_STATE) 225 { 226 _MHW_SETCMD_CALLBASE(SFC_STATE); 227 228 bool bHalfPitchForChroma; 229 bool bInterleaveChroma; 230 uint16_t wUXOffset; 231 uint16_t wUYOffset; 232 uint16_t wVXOffset; 233 uint16_t wVYOffset; 234 MHW_RESOURCE_PARAMS resourceParams; 235 MEDIA_WA_TABLE * pWaTable = nullptr; 236 PMOS_INTERFACE pOsInterface = nullptr; 237 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface = nullptr; 238 239 MHW_CHK_NULL_RETURN(this->m_currentCmdBuf); 240 pOutSurface = params.pOutSurface; 241 MHW_CHK_NULL_RETURN(pOutSurface); 242 243 pOsInterface = m_osItf; 244 MHW_CHK_NULL_RETURN(m_osItf); 245 pWaTable = pOsInterface->pfnGetWaTable(pOsInterface); 246 MHW_CHK_NULL_RETURN(pWaTable); 247 248 bHalfPitchForChroma = false; 249 bInterleaveChroma = false; 250 wUXOffset = 0; 251 wUYOffset = 0; 252 wVXOffset = 0; 253 wVYOffset = 0; 254 255 // Check input/output size 256 MHW_ASSERT(params.dwInputFrameWidth >= m_minWidth); 257 MHW_ASSERT(params.dwInputFrameHeight >= m_minHeight); 258 MHW_ASSERT(params.dwOutputFrameWidth <= m_maxWidth); 259 MHW_ASSERT(params.dwOutputFrameHeight <= m_maxHeight); 260 261 // Set DW0 262 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) 263 { 264 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHCPSFCMODE; 265 } 266 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 267 { 268 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 269 } 270 else 271 { 272 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMFXVEBOXSFCMODE; 273 } 274 275 // Set DW1 276 cmd.DW1.SfcPipeMode = params.sfcPipeMode; 277 cmd.DW1.SfcInputChromaSubSampling = params.dwInputChromaSubSampling; 278 cmd.DW1.VdVeInputOrderingMode = params.dwVDVEInputOrderingMode; 279 cmd.DW1.SfcEngineMode = params.engineMode; 280 281 // Set DW2 282 cmd.DW2.InputFrameResolutionWidth = params.dwInputFrameWidth - 1; 283 cmd.DW2.InputFrameResolutionHeight = params.dwInputFrameHeight - 1; 284 285 // Set DW3 286 cmd.DW3.OutputChromaDownsamplingCoSitingPositionVerticalDirection = params.dwChromaDownSamplingVerticalCoef; 287 cmd.DW3.OutputChromaDownsamplingCoSitingPositionHorizontalDirection = params.dwChromaDownSamplingHorizontalCoef; 288 cmd.DW3.InputColorSpace0Yuv1Rgb = params.bInputColorSpace; 289 290 bool &refInterleaveChroma = bInterleaveChroma; 291 uint16_t &refUYOffset = wUYOffset; 292 SetOutputSurfaceFormatType(&cmd, params, pOutSurface, refInterleaveChroma, refUYOffset); 293 // RGBASwapEnable is true when the OutputSurfaceFormatType is set as A8B8G8R8 for X8R8G8B8 and A8R8G8B8 output, 294 // the OutputSurfaceFormatType is set as A2R10G10B10 for R10G10B10A2 output, 295 // the OutputSurfaceFormatType is set as YUYV for YVYU output, 296 // the OutputSurfaceFormatType is set as UYVY for VYUY output and 297 // the OutputSurfaceFormatType is set as A8B8G8R84 for A16R16G16B16 output. 298 cmd.DW3.ChannelSwapEnable = params.bRGBASwapEnable; 299 // Set DW4 300 cmd.DW4.IefEnable = params.bIEFEnable; 301 cmd.DW4.SkinToneTunedIefEnable = params.bSkinToneTunedIEFEnable; 302 cmd.DW4.AvsFilterMode = params.dwAVSFilterMode; 303 if (params.b8tapChromafiltering) 304 { 305 cmd.DW4.AdaptiveFilterForAllChannels = true; 306 } 307 else 308 { 309 cmd.DW4.AdaptiveFilterForAllChannels = false; 310 } 311 312 cmd.DW4.AvsScalingEnable = ((params.fAVSXScalingRatio == 1.0F) && 313 (params.fAVSYScalingRatio == 1.0F)) 314 ? false 315 : true; 316 cmd.DW4.BypassYAdaptiveFiltering = params.bBypassYAdaptiveFilter; 317 cmd.DW4.BypassXAdaptiveFiltering = params.bBypassXAdaptiveFilter; 318 cmd.DW4.ChromaUpsamplingEnable = params.bAVSChromaUpsamplingEnable; 319 cmd.DW4.RotationMode = params.RotationMode; 320 cmd.DW4.ColorFillEnable = params.bColorFillEnable; 321 cmd.DW4.CscEnable = params.bCSCEnable; 322 cmd.DW4.Enable8TapForChromaChannelsFiltering = params.b8tapChromafiltering; 323 cmd.DW4.TileType = params.tileType; 324 cmd.DW4.RgbAdaptive = params.bRGBAdaptive; 325 326 if (params.bMirrorEnable) 327 { 328 cmd.DW4.Value |= (uint32_t)(1 << 14) & 0x00004000; // Mirror Mode 329 cmd.DW4.Value |= (uint32_t)(params.dwMirrorType << 13) & 0x00002000; // Mirror Type 330 } 331 332 // Set DW5, DW6, DW7, DW8, DW9 333 cmd.DW5.SourceRegionWidth = params.dwSourceRegionWidth - 1; 334 cmd.DW5.SourceRegionHeight = params.dwSourceRegionHeight - 1; 335 cmd.DW6.SourceRegionHorizontalOffset = params.dwSourceRegionHorizontalOffset; 336 cmd.DW6.SourceRegionVerticalOffset = params.dwSourceRegionVerticalOffset; 337 cmd.DW7.OutputFrameWidth = params.dwOutputFrameWidth + pOutSurface->dwSurfaceXOffset - 1; 338 cmd.DW7.OutputFrameHeight = params.dwOutputFrameHeight + pOutSurface->dwSurfaceYOffset - 1; 339 cmd.DW8.ScaledRegionSizeWidth = params.dwScaledRegionWidth - 1; 340 cmd.DW8.ScaledRegionSizeHeight = params.dwScaledRegionHeight - 1; 341 cmd.DW9.ScaledRegionHorizontalOffset = params.dwScaledRegionHorizontalOffset + pOutSurface->dwSurfaceXOffset; 342 cmd.DW9.ScaledRegionVerticalOffset = params.dwScaledRegionVerticalOffset + pOutSurface->dwSurfaceYOffset; 343 344 // Set DW10 345 cmd.DW10.GrayBarPixelUG = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillUGPixel * 1024.0F), 0, 1023); // U10 346 cmd.DW10.GrayBarPixelYR = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillYRPixel * 1024.0F), 0, 1023); // U10 347 348 // Set DW11 349 cmd.DW11.GrayBarPixelA = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillAPixel * 1024.0F), 0, 1023); // U10 350 cmd.DW11.GrayBarPixelVB = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillVBPixel * 1024.0F), 0, 1023); // U10 351 352 // Set DW13 353 cmd.DW13.AlphaDefaultValue = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fAlphaPixel * 1024.0F), 0, 1023); // U10 354 355 // Use round to zero for the scaling factor calculation to resolve tdr issue in scalability case 356 // Set DW14 357 cmd.DW14.ScalingFactorHeight = (uint32_t)((double)params.dwSourceRegionHeight / (double)params.dwScaledRegionHeight * 524288.0F); // U4.19 358 359 // Set DW15 360 cmd.DW15.ScaleFactorWidth = (uint32_t)((double)params.dwSourceRegionWidth / (double)params.dwScaledRegionWidth * 524288.0F); // U4.19 361 362 SetOutputFrameSurface(&cmd, params, pOutSurface); 363 364 // Set DW29 365 cmd.DW29.TiledMode = MosGetHWTileType(pOutSurface->TileType, pOutSurface->TileModeGMM, pOutSurface->bGMMTileEnabled); 366 cmd.DW29.OutputSurfaceHalfPitchForChroma = bHalfPitchForChroma; 367 cmd.DW29.OutputSurfacePitch = pOutSurface->dwPitch - 1; 368 cmd.DW29.OutputSurfaceInterleaveChromaEnable = bInterleaveChroma; 369 cmd.DW29.OutputSurfaceFormat = cmd.DW3.OutputSurfaceFormatType; 370 371 SetOutputSurfaceOffset(&cmd, wUYOffset, wUXOffset, wVYOffset, wVXOffset, params, pOutSurface); 372 373 // Set DW33 374 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 375 { 376 cmd.DW33.Av1TileColumnNumber = params.av1TileColumnNumber; 377 cmd.DW33.Av1TileRowNumber = params.av1TileRowNumber; 378 } 379 else 380 { 381 cmd.DW33.Av1TileColumnNumber = 0; 382 cmd.DW33.Av1TileRowNumber = 0; 383 } 384 385 // DW34, DW35 386 cmd.DW34.Sourcestartx = params.srcStartX; 387 cmd.DW34.Sourceendx = params.srcEndX; 388 cmd.DW35.Destinationstartx = params.dstStartX; 389 cmd.DW35.Destinationendx = params.dstEndX; 390 391 // Set DW36, DW37 392 //Change SFC outputcentering scaling X/Yphaseshift value and limition limitione with 19bit following Fuslim setting. 393 if (m_outputCenteringEnable) 394 { 395 cmd.DW36.Xphaseshift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)cmd.DW15.ScaleFactorWidth / 524288.0F - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1)); 396 cmd.DW37.Yphaseshift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)cmd.DW14.ScalingFactorHeight / 524288.0F - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1)); 397 } 398 399 if (params.pOsResOutputSurface) 400 { 401 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 402 if (params.iScalingType == ISCALING_INTERLEAVED_TO_FIELD && 403 params.outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD) 404 { 405 resourceParams.presResource = params.tempFieldResource; 406 resourceParams.pdwCmd = &(cmd.DW17.Value); 407 resourceParams.dwLocationInCmd = 17; 408 resourceParams.HwCommandType = MOS_SFC_STATE; 409 resourceParams.bIsWritable = true; 410 } 411 else 412 { 413 resourceParams.presResource = params.pOsResOutputSurface; 414 resourceParams.pdwCmd = &(cmd.DW17.Value); 415 resourceParams.dwLocationInCmd = 17; 416 resourceParams.HwCommandType = MOS_SFC_STATE; 417 resourceParams.bIsWritable = true; 418 } 419 resourceParams.dwOffset = params.dwOutputSurfaceOffset; 420 InitMocsParams(resourceParams, &cmd.DW19.Value, 1, 6); 421 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 422 pOsInterface, 423 m_currentCmdBuf, 424 &resourceParams)); 425 if (m_outputSurfCtrl.Gen12_7.Index != 0) 426 { 427 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = m_outputSurfCtrl.Gen12_7.Index; 428 } 429 } 430 431 if (params.pOsResAVSLineBuffer) 432 { 433 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 434 resourceParams.presResource = params.pOsResAVSLineBuffer; 435 resourceParams.pdwCmd = &(cmd.DW20.Value); 436 resourceParams.dwLocationInCmd = 20; 437 resourceParams.HwCommandType = MOS_SFC_STATE; 438 resourceParams.bIsWritable = true; 439 InitMocsParams(resourceParams, &cmd.DW22.Value, 1, 6); 440 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 441 pOsInterface, 442 m_currentCmdBuf, 443 &resourceParams)); 444 // Set DW22 445 if (m_avsLineBufferCtrl.Gen12_7.Index != 0) 446 { 447 cmd.DW22.AvsLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineBufferCtrl.Gen12_7.Index; 448 } 449 } 450 451 if (params.pOsResIEFLineBuffer) 452 { 453 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 454 resourceParams.presResource = params.pOsResIEFLineBuffer; 455 resourceParams.pdwCmd = &(cmd.DW23.Value); 456 resourceParams.dwLocationInCmd = 23; 457 resourceParams.HwCommandType = MOS_SFC_STATE; 458 resourceParams.bIsWritable = true; 459 InitMocsParams(resourceParams, &cmd.DW25.Value, 1, 6); 460 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 461 pOsInterface, 462 m_currentCmdBuf, 463 &resourceParams)); 464 // Set DW25 465 if (m_iefLineBufferCtrl.Gen12_7.Index != 0) 466 { 467 cmd.DW25.IefLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineBufferCtrl.Gen12_7.Index; 468 } 469 } 470 471 if (params.resSfdLineBuffer && !Mos_ResourceIsNull(params.resSfdLineBuffer)) 472 { 473 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 474 resourceParams.presResource = params.resSfdLineBuffer; 475 resourceParams.pdwCmd = &(cmd.DW26.Value); 476 resourceParams.dwLocationInCmd = 26; 477 resourceParams.HwCommandType = MOS_SFC_STATE; 478 resourceParams.bIsWritable = true; 479 InitMocsParams(resourceParams, &cmd.DW28.Value, 1, 6); 480 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 481 pOsInterface, 482 m_currentCmdBuf, 483 &resourceParams)); 484 if (m_sfdLineBufferCtrl.Gen12_7.Index != 0) 485 { 486 cmd.DW28.SfdLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineBufferCtrl.Gen12_7.Index; 487 } 488 } 489 490 if (params.resAvsLineTileBuffer && !Mos_ResourceIsNull(params.resAvsLineTileBuffer)) 491 { 492 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 493 resourceParams.presResource = params.resAvsLineTileBuffer; 494 resourceParams.pdwCmd = &(cmd.DW38.Value); 495 resourceParams.dwLocationInCmd = 38; 496 resourceParams.HwCommandType = MOS_SFC_STATE; 497 resourceParams.bIsWritable = true; 498 InitMocsParams(resourceParams, &cmd.DW40.Value, 1, 6); 499 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 500 pOsInterface, 501 m_currentCmdBuf, 502 &resourceParams)); 503 if (m_avsLineTileBufferCtrl.Gen12_7.Index != 0) 504 { 505 cmd.DW40.AvsLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineTileBufferCtrl.Gen12_7.Index; 506 } 507 } 508 509 if (params.resIefLineTileBuffer && !Mos_ResourceIsNull(params.resIefLineTileBuffer)) 510 { 511 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 512 resourceParams.presResource = params.resIefLineTileBuffer; 513 resourceParams.pdwCmd = &(cmd.DW41.Value); 514 resourceParams.dwLocationInCmd = 41; 515 resourceParams.HwCommandType = MOS_SFC_STATE; 516 resourceParams.bIsWritable = true; 517 InitMocsParams(resourceParams, &cmd.DW43.Value, 1, 6); 518 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 519 pOsInterface, 520 m_currentCmdBuf, 521 &resourceParams)); 522 if (m_iefLineTileBufferCtrl.Gen12_7.Index != 0) 523 { 524 cmd.DW43.IefLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineTileBufferCtrl.Gen12_7.Index; 525 } 526 } 527 528 if (params.resSfdLineTileBuffer && !Mos_ResourceIsNull(params.resSfdLineTileBuffer)) 529 { 530 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 531 resourceParams.presResource = params.resSfdLineTileBuffer; 532 resourceParams.pdwCmd = &(cmd.DW44.Value); 533 resourceParams.dwLocationInCmd = 44; 534 resourceParams.HwCommandType = MOS_SFC_STATE; 535 resourceParams.bIsWritable = true; 536 InitMocsParams(resourceParams, &cmd.DW46.Value, 1, 6); 537 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 538 pOsInterface, 539 m_currentCmdBuf, 540 &resourceParams)); 541 if (m_sfdLineTileBufferCtrl.Gen12_7.Index != 0) 542 { 543 cmd.DW46.SfdLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineTileBufferCtrl.Gen12_7.Index; 544 } 545 } 546 547 if (params.histogramSurface && !Mos_ResourceIsNull(¶ms.histogramSurface->OsResource)) 548 { 549 cmd.DW4.HistogramStreamout = 1; 550 cmd.DW49.Value = 0; 551 552 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 553 resourceParams.presResource = ¶ms.histogramSurface->OsResource; 554 resourceParams.dwOffset = params.histogramSurface->dwOffset; 555 resourceParams.pdwCmd = &(cmd.DW47.Value); 556 resourceParams.dwLocationInCmd = 47; 557 resourceParams.HwCommandType = MOS_SFC_STATE; 558 resourceParams.bIsWritable = true; 559 InitMocsParams(resourceParams, &cmd.DW49.Value, 1, 6); 560 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 561 pOsInterface, 562 m_currentCmdBuf, 563 &resourceParams)); 564 if (m_histogramBufferCtrl.Gen12_7.Index != 0) 565 { 566 cmd.DW49.HisgotramBaseAddressIndexToMemoryObjectControlStateMocsTables = m_histogramBufferCtrl.Gen12_7.Index; 567 } 568 } 569 570 // Input/Output frame format 571 cmd.DW1.InputFrameDataFormat = params.inputFrameDataFormat; 572 cmd.DW1.OutputFrameDataFormat = params.outputFrameDataFormat; 573 574 // interleaved to interleaved 575 if (params.iScalingType == ISCALING_INTERLEAVED_TO_INTERLEAVED) 576 { 577 cmd.DW54.BottomFieldVerticalScalingOffset = params.bottomFieldVerticalScalingOffset; 578 } 579 580 // Input is field mode 581 if (params.iScalingType == ISCALING_FIELD_TO_INTERLEAVED) 582 { 583 cmd.DW1.TopBottomField = params.topBottomField; 584 cmd.DW1.TopBottomFieldFirst = params.topBottomFieldFirst; 585 } 586 587 // interleaved to field 588 if (params.iScalingType == ISCALING_INTERLEAVED_TO_FIELD) 589 { 590 // Add bottom field address to cmd 591 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams)); 592 if (params.outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD) 593 { 594 resourceParams.dwLsbNum = 12; 595 resourceParams.presResource = params.pOsResOutputSurface; 596 resourceParams.pdwCmd = &cmd.DW55.Value; 597 resourceParams.dwLocationInCmd = 55; 598 resourceParams.bIsWritable = true; 599 } 600 else 601 { 602 resourceParams.dwLsbNum = 12; 603 resourceParams.presResource = params.tempFieldResource; 604 resourceParams.pdwCmd = &cmd.DW55.Value; 605 resourceParams.dwLocationInCmd = 55; 606 resourceParams.bIsWritable = true; 607 } 608 InitMocsParams(resourceParams, &cmd.DW57.Value, 1, 6); 609 MHW_CHK_STATUS_RETURN(AddResourceToCmd( 610 pOsInterface, 611 m_currentCmdBuf, 612 &resourceParams)); 613 if (m_outputSurfCtrl.Gen12_7.Index != 0) 614 { 615 cmd.DW57.BottomFieldSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = 616 m_outputSurfCtrl.Gen12_7.Index; 617 } 618 619 cmd.DW58.BottomFieldSurfaceHalfPitchForChroma = cmd.DW29.OutputSurfaceHalfPitchForChroma; 620 cmd.DW58.BottomFieldSurfaceInterleaveChromaEnable = cmd.DW29.OutputSurfaceHalfPitchForChroma; 621 cmd.DW58.BottomFieldSurfacePitch = cmd.DW29.OutputSurfacePitch; 622 cmd.DW58.BottomFieldSurfaceTiled = (pOutSurface->TileType != MOS_TILE_LINEAR) ? true : false; 623 cmd.DW58.BottomFieldSurfaceTileWalk = (pOutSurface->TileType == MOS_TILE_Y) ? true : false; 624 cmd.DW59.BottomFieldSurfaceXOffsetForU = cmd.DW30.OutputSurfaceXOffsetForU; 625 cmd.DW59.BottomFieldSurfaceYOffsetForU = cmd.DW30.OutputSurfaceYOffsetForU; 626 cmd.DW60.BottomFieldSurfaceXOffsetForV = cmd.DW31.OutputSurfaceXOffsetForV; 627 cmd.DW60.BottomFieldSurfaceYOffsetForV = cmd.DW31.OutputSurfaceYOffsetForV; 628 } 629 630 // update dithering setting 631 cmd.DW3.DitherEnable = params.ditheringEn; 632 if (cmd.DW3.DitherEnable) 633 { 634 cmd.DW50.DitheringLutDelta12 = 0; 635 cmd.DW50.DitheringLutDelta13 = 1; 636 cmd.DW50.DitheringLutDelta14 = 1; 637 cmd.DW50.DitheringLutDelta15 = 1; 638 639 cmd.DW51.DitheringLutDelta8 = 0; 640 cmd.DW51.DitheringLutDelta9 = 1; 641 cmd.DW51.DitheringLutDelta10 = 1; 642 cmd.DW51.DitheringLutDelta11 = 0; 643 644 cmd.DW52.DitheringLutDelta4 = 0; 645 cmd.DW52.DitheringLutDelta5 = 1; 646 cmd.DW52.DitheringLutDelta6 = 0; 647 cmd.DW52.DitheringLutDelta7 = 0; 648 649 cmd.DW53.DitheringLutDelta0 = 0; 650 cmd.DW53.DitheringLutDelta1 = 0; 651 cmd.DW53.DitheringLutDelta2 = 0; 652 cmd.DW53.DitheringLutDelta3 = 0; 653 } 654 655 if (m_sfcScalabilityEnabled == true) 656 { 657 uint32_t iMediumX; 658 uint32_t xOffset; 659 uint32_t src_startX[MHW_SFC_MAX_PIPE_NUM_XE_M_PLUS]; 660 uint32_t src_endX[MHW_SFC_MAX_PIPE_NUM_XE_M_PLUS]; 661 uint32_t dest_startX[MHW_SFC_MAX_PIPE_NUM_XE_M_PLUS]; 662 uint32_t dest_endX[MHW_SFC_MAX_PIPE_NUM_XE_M_PLUS]; 663 uint32_t tile_endX; 664 uint32_t dest_first_valid_left_tile = 0; 665 uint32_t dest_last_valid_right_tile = m_numofSfc - 1; 666 uint32_t dest_cntX = 0; 667 double xLandingpoint; 668 uint32_t one_by_sf = (uint32_t)(((uint64_t)params.dwSourceRegionWidth * 524288L) / params.dwScaledRegionWidth); 669 const uint32_t one_by_sf_fraction_precision = 19; 670 const uint32_t beta_precision = 5; 671 int32_t xPhaseShift; 672 double tempDestCntx; 673 uint32_t i; 674 MHW_ASSERT(params.dwInputFrameWidth > m_numofSfc * 64); 675 676 iMediumX = MOS_ALIGN_FLOOR((params.dwInputFrameWidth / m_numofSfc), 64); 677 iMediumX = MOS_CLAMP_MIN_MAX(iMediumX, 64, (params.dwInputFrameWidth - 64)); 678 679 src_startX[0] = dest_startX[0] = 0; 680 681 for (i = 0; i < m_numofSfc; i++) 682 { 683 if (i == m_numofSfc - 1) 684 { 685 src_endX[i] = params.dwInputFrameWidth - 1; 686 } 687 else 688 { 689 src_endX[i] = iMediumX * (i + 1) - 1; 690 if (params.dwInputFrameWidth != m_numofSfc * iMediumX) 691 { 692 src_endX[i] += 64; 693 } 694 } 695 696 if (params.dwSourceRegionHorizontalOffset + params.dwSourceRegionWidth - 1 <= src_endX[i]) 697 { 698 xOffset = 0; 699 tile_endX = params.dwSourceRegionHorizontalOffset + params.dwSourceRegionWidth - 1; 700 } 701 else 702 { 703 xOffset = VALUE_XOFFSET; 704 tile_endX = src_endX[i]; 705 } 706 707 while (1) 708 { 709 if (src_endX[i] - params.dwSourceRegionHorizontalOffset < (xOffset + 1)) 710 { 711 dest_endX[i] = 0; 712 break; 713 } 714 715 if (dest_cntX == 0) 716 { 717 dest_first_valid_left_tile = i; 718 } 719 720 xPhaseShift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)params.dwSourceRegionWidth / params.dwScaledRegionWidth - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1)); 721 tempDestCntx = (((double)dest_cntX * (double)one_by_sf) + xPhaseShift); 722 if (tempDestCntx < 0) 723 { 724 tempDestCntx = 0; 725 } 726 xLandingpoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288.0F) + params.dwSourceRegionHorizontalOffset); 727 728 if (xLandingpoint >= (double)(tile_endX - xOffset)) 729 { 730 dest_endX[i] = dest_cntX - 1; 731 break; 732 } 733 else 734 { 735 dest_cntX++; 736 } 737 738 if (xOffset == 0) 739 { 740 dest_last_valid_right_tile = i; 741 dest_endX[i] = params.dwScaledRegionWidth - 1; 742 break; 743 } 744 } 745 } 746 747 for (i = 1; i < m_numofSfc; i++) 748 { 749 src_startX[i] = src_endX[i - 1] + 1 - 64; 750 751 if (i <= dest_first_valid_left_tile) 752 { 753 dest_startX[i] = 0; 754 } 755 else if (i <= dest_last_valid_right_tile) 756 { 757 dest_startX[i] = dest_endX[i - 1] + 1; 758 } 759 else 760 { 761 dest_startX[i] = 0; 762 dest_endX[i] = 0; 763 } 764 } 765 766 // Set SFC Engine Mode 767 if (m_numofSfc == 2) 768 { 769 if (m_indexofSfc == MHW_SFC_INDEX_0_XE_LPM_PLUS_BASE) 770 { 771 cmd.DW1.SfcEngineMode = 1; 772 } 773 else 774 { 775 cmd.DW1.SfcEngineMode = 2; 776 } 777 } 778 else if (m_numofSfc == 3) 779 { 780 if (m_indexofSfc == MHW_SFC_INDEX_0_XE_LPM_PLUS_BASE) 781 { 782 cmd.DW1.SfcEngineMode = 1; 783 } 784 else if (m_indexofSfc == MHW_SFC_INDEX_1_XE_LPM_PLUS_BASE) 785 { 786 cmd.DW1.SfcEngineMode = 3; 787 } 788 else 789 { 790 cmd.DW1.SfcEngineMode = 2; 791 } 792 } 793 else if (m_numofSfc == 4) 794 { 795 if (m_indexofSfc == MHW_SFC_INDEX_0_XE_LPM_PLUS_BASE) 796 { 797 cmd.DW1.SfcEngineMode = 1; 798 } 799 else if (m_indexofSfc == MHW_SFC_INDEX_1_XE_LPM_PLUS_BASE || 800 m_indexofSfc == MHW_SFC_INDEX_2_XE_LPM_PLUS_BASE) 801 { 802 cmd.DW1.SfcEngineMode = 3; 803 } 804 else 805 { 806 cmd.DW1.SfcEngineMode = 2; 807 } 808 } 809 810 if (m_indexofSfc < dest_first_valid_left_tile) 811 { 812 cmd.DW4.ColorFillEnable = 0; 813 } 814 else if (m_indexofSfc > dest_last_valid_right_tile) 815 { 816 cmd.DW4.ColorFillEnable = 0; 817 } 818 819 if (params.bIEFEnable) 820 { 821 if (dest_startX[m_indexofSfc] >= 4) 822 { 823 dest_startX[m_indexofSfc] -= 4; 824 } 825 else 826 { 827 dest_startX[m_indexofSfc] = 0; 828 } 829 } 830 831 if (VpHalDDIUtils::GetSurfaceColorPack(params.OutputFrameFormat) != VPHAL_COLORPACK_444 && 832 (dest_startX[m_indexofSfc] % 2 != 0)) 833 { 834 if (dest_startX[m_indexofSfc] >= 1) 835 { 836 dest_startX[m_indexofSfc] -= 1; 837 } 838 else 839 { 840 dest_startX[m_indexofSfc] = 0; 841 } 842 } 843 844 cmd.DW34.Sourcestartx = src_startX[m_indexofSfc]; 845 cmd.DW34.Sourceendx = src_endX[m_indexofSfc]; 846 cmd.DW35.Destinationstartx = dest_startX[m_indexofSfc]; 847 cmd.DW35.Destinationendx = dest_endX[m_indexofSfc]; 848 849 MHW_NORMALMESSAGE("SFC%d STATE: src startx %d endx %d", m_indexofSfc, cmd.DW34.Sourcestartx, cmd.DW34.Sourceendx); 850 MHW_NORMALMESSAGE("SFC%d STATE: dest startx %d endx %d", m_indexofSfc, cmd.DW35.Destinationstartx, cmd.DW35.Destinationendx); 851 } 852 853 return MOS_STATUS_SUCCESS; 854 } 855 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_STATE)856 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_STATE) 857 { 858 _MHW_SETCMD_CALLBASE(SFC_AVS_STATE); 859 860 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) 861 { 862 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 863 } 864 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 865 { 866 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 867 } 868 else 869 { 870 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 871 } 872 873 cmd.DW3.InputHorizontalSitingValueSpecifiesTheHorizontalSitingOfTheInput = params.dwInputHorizontalSiting; 874 cmd.DW3.InputVerticalSitingSpecifiesTheVerticalSitingOfTheInput = params.dwInputVerticalSitting; 875 876 return MOS_STATUS_SUCCESS; 877 } 878 _MHW_SETCMD_OVERRIDE_DECL(SFC_FRAME_START)879 _MHW_SETCMD_OVERRIDE_DECL(SFC_FRAME_START) 880 { 881 _MHW_SETCMD_CALLBASE(SFC_FRAME_START); 882 883 //MHW_CHK_NULL_RETURN(cmdPtr); 884 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) 885 { 886 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 887 } 888 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 889 { 890 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 891 } 892 else 893 { 894 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 895 } 896 897 return MOS_STATUS_SUCCESS; 898 } 899 _MHW_SETCMD_OVERRIDE_DECL(SFC_IEF_STATE)900 _MHW_SETCMD_OVERRIDE_DECL(SFC_IEF_STATE) 901 { 902 _MHW_SETCMD_CALLBASE(SFC_IEF_STATE); 903 904 //MHW_CHK_NULL_RETURN(cmdPtr); 905 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) 906 { 907 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 908 } 909 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 910 { 911 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 912 } 913 else 914 { 915 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 916 } 917 918 return MOS_STATUS_SUCCESS; 919 } 920 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_CHROMA_Coeff_Table)921 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_CHROMA_Coeff_Table) 922 { 923 _MHW_SETCMD_CALLBASE(SFC_AVS_CHROMA_Coeff_Table); 924 925 //MHW_CHK_NULL_RETURN(cmdPtr); 926 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) // HCP-to-SFC 927 { 928 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 929 } 930 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 931 { 932 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 933 } 934 else 935 { 936 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 937 } 938 939 return MOS_STATUS_SUCCESS; 940 } 941 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_LUMA_Coeff_Table)942 _MHW_SETCMD_OVERRIDE_DECL(SFC_AVS_LUMA_Coeff_Table) 943 { 944 _MHW_SETCMD_CALLBASE(SFC_AVS_LUMA_Coeff_Table); 945 946 //MHW_CHK_NULL_RETURN(cmdPtr); 947 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP) // HCP-to-SFC 948 { 949 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE; 950 } 951 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP) 952 { 953 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE; 954 } 955 else 956 { 957 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMISC; 958 } 959 960 return MOS_STATUS_SUCCESS; 961 } 962 963 protected: 964 using base_t = sfc::Impl<mhw::sfc::xe2_hpm_next::Cmd>; 965 966 MEDIA_CLASS_DEFINE_END(mhw__sfc__xe2_hpm_next__Impl) 967 }; 968 969 } // namespace xe2_hpm_next 970 } // namespace sfc 971 } // namespace mhw 972 973 #endif // __MHW_SFC_XE2_HPM_NEXT_IMPL_H__ 974