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