1 /*===================== begin_copyright_notice ==================================
2
3 # Copyright (c) 2020-2022, Intel Corporation
4
5 # Permission is hereby granted, free of charge, to any person obtaining a
6 # copy of this software and associated documentation files (the "Software"),
7 # to deal in the Software without restriction, including without limitation
8 # the rights to use, copy, modify, merge, publish, distribute, sublicense,
9 # and/or sell copies of the Software, and to permit persons to whom the
10 # Software is furnished to do so, subject to the following conditions:
11
12 # The above copyright notice and this permission notice shall be included
13 # in all copies or substantial portions of the Software.
14
15 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
16 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
19 # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
20 # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
21 # OTHER DEALINGS IN THE SOFTWARE.
22
23 ======================= end_copyright_notice ==================================*/
24 //!
25 //! \file mhw_sfc_xe_xpm.cpp
26 //! \brief Constructs sfc commands on Gen12-based platforms
27 //! \details Each client facing function both creates a HW command and adds
28 //! that command to a command or batch buffer.
29 //!
30
31 #include "vphal_common.h"
32 #include "mhw_sfc_xe_xpm.h"
33 #include "mhw_sfc_hwcmd_xe_xpm.h"
34 #include "mhw_utilities_xe_xpm.h"
35 #include "vp_hal_ddi_utils.h"
36
37 #define VALUE_XOFFSET 3
38
MhwSfcInterfaceXe_Xpm(PMOS_INTERFACE pOsInterface)39 MhwSfcInterfaceXe_Xpm::MhwSfcInterfaceXe_Xpm(PMOS_INTERFACE pOsInterface)
40 : MhwSfcInterfaceG12(pOsInterface)
41 {
42 MHW_FUNCTION_ENTER;
43
44 m_sfcScalabilitySupported = false;
45 m_sfcScalabilityEnabled = false;
46 m_indexofSfc = 0;
47 m_numofSfc = 1;
48
49 MHW_CHK_NULL_NO_STATUS_RETURN(m_osInterface);
50
51 // Get Memory control object directly from MOS.
52 // If any override is needed, something like pfnOverrideMemoryObjectCtrl() / pfnComposeSurfaceCacheabilityControl()
53 // will need to be implemented.
54 m_outputSurfCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
55 MOS_MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface,
56 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
57
58 m_avsLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
59 MOS_MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface,
60 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
61 m_iefLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
62 MOS_MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface,
63 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
64 m_sfdLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
65 MOS_MP_RESOURCE_USAGE_DEFAULT,
66 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
67 m_avsLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
68 MOS_MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface,
69 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
70 m_iefLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
71 MOS_MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface,
72 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
73 m_sfdLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
74 MOS_MP_RESOURCE_USAGE_DEFAULT,
75 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
76 m_histogramBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
77 MOS_MP_RESOURCE_USAGE_DEFAULT,
78 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
79 }
80
~MhwSfcInterfaceXe_Xpm()81 MhwSfcInterfaceXe_Xpm::~MhwSfcInterfaceXe_Xpm()
82 {
83 MHW_FUNCTION_ENTER;
84 }
85
AddSfcState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_STATE_PARAMS pSfcStateParams,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)86 MOS_STATUS MhwSfcInterfaceXe_Xpm::AddSfcState(
87 PMOS_COMMAND_BUFFER pCmdBuffer,
88 PMHW_SFC_STATE_PARAMS pSfcStateParams,
89 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)
90 {
91 PMOS_INTERFACE pOsInterface;
92 bool bHalfPitchForChroma;
93 bool bInterleaveChroma;
94 uint16_t wUXOffset;
95 uint16_t wUYOffset;
96 uint16_t wVXOffset;
97 uint16_t wVYOffset;
98 MHW_RESOURCE_PARAMS ResourceParams;
99 MEDIA_WA_TABLE *pWaTable = nullptr;
100 PMHW_SFC_STATE_PARAMS_XE_XPM pSfcStateparamsXe_Xpm;
101 mhw_sfc_xe_xpm::SFC_STATE_CMD cmd;
102
103 MHW_CHK_NULL_RETURN(pCmdBuffer);
104 MHW_CHK_NULL_RETURN(pSfcStateParams);
105 MHW_CHK_NULL_RETURN(pOutSurface);
106
107 pOsInterface = m_osInterface;
108 MHW_CHK_NULL_RETURN(pOsInterface);
109 pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
110 MHW_CHK_NULL_RETURN(pWaTable);
111
112 bHalfPitchForChroma = false;
113 bInterleaveChroma = false;
114 wUXOffset = 0;
115 wUYOffset = 0;
116 wVXOffset = 0;
117 wVYOffset = 0;
118
119 pSfcStateparamsXe_Xpm = static_cast<PMHW_SFC_STATE_PARAMS_XE_XPM>(pSfcStateParams);
120
121 // Check input/output size
122 MHW_ASSERT(pSfcStateparamsXe_Xpm->dwInputFrameWidth >= m_minWidth);
123 MHW_ASSERT(pSfcStateparamsXe_Xpm->dwInputFrameHeight >= m_minHeight);
124 MHW_ASSERT(pSfcStateparamsXe_Xpm->dwOutputFrameWidth <= m_maxWidth);
125 MHW_ASSERT(pSfcStateparamsXe_Xpm->dwOutputFrameHeight <= m_maxHeight);
126
127 // Set DW0
128 if (pSfcStateparamsXe_Xpm->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
129 {
130 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHCPSFCMODE;
131 }
132 else
133 {
134 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMFXVEBOXSFCMODE;
135 }
136
137 // Set DW1
138 cmd.DW1.SfcPipeMode = pSfcStateparamsXe_Xpm->sfcPipeMode;
139 cmd.DW1.SfcInputChromaSubSampling = pSfcStateparamsXe_Xpm->dwInputChromaSubSampling;
140 cmd.DW1.VdVeInputOrderingMode = pSfcStateparamsXe_Xpm->dwVDVEInputOrderingMode;
141 cmd.DW1.SfcEngineMode = pSfcStateparamsXe_Xpm->engineMode;
142
143 // Set DW2
144 cmd.DW2.InputFrameResolutionWidth = pSfcStateparamsXe_Xpm->dwInputFrameWidth - 1;
145 cmd.DW2.InputFrameResolutionHeight = pSfcStateparamsXe_Xpm->dwInputFrameHeight - 1;
146
147 // Set DW3
148 cmd.DW3.OutputChromaDownsamplingCoSitingPositionVerticalDirection = pSfcStateparamsXe_Xpm->dwChromaDownSamplingVerticalCoef;
149 cmd.DW3.OutputChromaDownsamplingCoSitingPositionHorizontalDirection = pSfcStateparamsXe_Xpm->dwChromaDownSamplingHorizontalCoef;
150 cmd.DW3.InputColorSpace0Yuv1Rgb = pSfcStateparamsXe_Xpm->bInputColorSpace;
151
152 switch(pSfcStateparamsXe_Xpm->OutputFrameFormat)
153 {
154 case Format_AYUV:
155 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_AYUV;
156 break;
157 case Format_X8R8G8B8:
158 case Format_A8R8G8B8:
159 case Format_X8B8G8R8:
160 case Format_A8B8G8R8:
161 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R8;
162 break;
163 case Format_R10G10B10A2:
164 case Format_B10G10R10A2:
165 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A2R10G10B10;
166 break;
167 case Format_R5G6B5:
168 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_R5G6B5;
169 break;
170 case Format_NV12:
171 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_NV12;
172 bInterleaveChroma = true;
173 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
174 break;
175 case Format_YVYU:
176 case Format_YUY2:
177 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_YUYV;
178 break;
179 case Format_VYUY:
180 case Format_UYVY:
181 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_UYVY;
182 break;
183 case Format_P010:
184 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_P016;
185 cmd.DW4.Bitdepth = 0;
186 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
187 break;
188 case Format_P016:
189 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_P016;
190 cmd.DW4.Bitdepth = 1;
191 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
192 break;
193 case Format_Y210:
194 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y216;
195 cmd.DW4.Bitdepth = 0;
196 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
197 break;
198 case Format_Y216:
199 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y216;
200 cmd.DW4.Bitdepth = 1;
201 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
202 break;
203 case Format_Y410:
204 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y416;
205 cmd.DW4.Bitdepth = 0;
206 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
207 break;
208 case Format_Y416:
209 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y416;
210 cmd.DW4.Bitdepth = 1;
211 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
212 break;
213 case Format_Y8:
214 cmd.DW3.OutputSurfaceFormatType = 13;
215 cmd.DW4.Bitdepth = 0;
216 break;
217 case Format_Y16U:
218 case Format_Y16S:
219 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R83;
220 cmd.DW4.Bitdepth = 0;
221 break;
222 case Format_A16R16G16B16:
223 case Format_A16B16G16R16:
224 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R84;
225 cmd.DW4.Bitdepth = 0;
226 break;
227 default:
228 MHW_ASSERTMESSAGE("Unknown Output Format.");
229 return MOS_STATUS_UNKNOWN;
230 }
231
232 // RGBASwapEnable is true when the OutputSurfaceFormatType is set as A8B8G8R8 for X8R8G8B8 and A8R8G8B8 output,
233 // the OutputSurfaceFormatType is set as A2R10G10B10 for R10G10B10A2 output,
234 // the OutputSurfaceFormatType is set as YUYV for YVYU output,
235 // the OutputSurfaceFormatType is set as UYVY for VYUY output and
236 // the OutputSurfaceFormatType is set as A8B8G8R84 for A16R16G16B16 output.
237 cmd.DW3.ChannelSwapEnable = pSfcStateparamsXe_Xpm->bRGBASwapEnable;
238 // Set DW4
239 cmd.DW4.IefEnable = pSfcStateparamsXe_Xpm->bIEFEnable;
240 cmd.DW4.SkinToneTunedIefEnable = pSfcStateparamsXe_Xpm->bSkinToneTunedIEFEnable;
241 cmd.DW4.AvsFilterMode = pSfcStateparamsXe_Xpm->dwAVSFilterMode;
242 if (pSfcStateparamsXe_Xpm->b8tapChromafiltering)
243 {
244 cmd.DW4.AdaptiveFilterForAllChannels = true;
245 }
246 else
247 {
248 cmd.DW4.AdaptiveFilterForAllChannels = false;
249 }
250
251 cmd.DW4.AvsScalingEnable = ((pSfcStateparamsXe_Xpm->fAVSXScalingRatio == 1.0F) &&
252 (pSfcStateparamsXe_Xpm->fAVSYScalingRatio == 1.0F)) ? false : true;
253 cmd.DW4.BypassYAdaptiveFiltering = pSfcStateparamsXe_Xpm->bBypassYAdaptiveFilter;
254 cmd.DW4.BypassXAdaptiveFiltering = pSfcStateparamsXe_Xpm->bBypassXAdaptiveFilter;
255 cmd.DW4.ChromaUpsamplingEnable = pSfcStateparamsXe_Xpm->bAVSChromaUpsamplingEnable;
256 cmd.DW4.RotationMode = pSfcStateparamsXe_Xpm->RotationMode;
257 cmd.DW4.ColorFillEnable = pSfcStateparamsXe_Xpm->bColorFillEnable;
258 cmd.DW4.CscEnable = pSfcStateparamsXe_Xpm->bCSCEnable;
259 cmd.DW4.Enable8TapForChromaChannelsFiltering = pSfcStateparamsXe_Xpm->b8tapChromafiltering;
260 cmd.DW4.TileType = pSfcStateparamsXe_Xpm->tileType;
261 cmd.DW4.RgbAdaptive = pSfcStateparamsXe_Xpm->bRGBAdaptive;
262
263 if (pSfcStateParams->bMirrorEnable)
264 {
265 cmd.DW4.Value |= (uint32_t)(1 << 14) & 0x00004000; // Mirror Mode
266 cmd.DW4.Value |= (uint32_t)(pSfcStateParams->dwMirrorType << 13) & 0x00002000; // Mirror Type
267 }
268
269 // Set DW5, DW6, DW7, DW8, DW9
270 cmd.DW5.SourceRegionWidth = pSfcStateparamsXe_Xpm->dwSourceRegionWidth - 1;
271 cmd.DW5.SourceRegionHeight = pSfcStateparamsXe_Xpm->dwSourceRegionHeight - 1;
272 cmd.DW6.SourceRegionHorizontalOffset = pSfcStateparamsXe_Xpm->dwSourceRegionHorizontalOffset;
273 cmd.DW6.SourceRegionVerticalOffset = pSfcStateparamsXe_Xpm->dwSourceRegionVerticalOffset;
274 cmd.DW7.OutputFrameWidth = pSfcStateparamsXe_Xpm->dwOutputFrameWidth + pOutSurface->dwSurfaceXOffset - 1;
275 cmd.DW7.OutputFrameHeight = pSfcStateparamsXe_Xpm->dwOutputFrameHeight + pOutSurface->dwSurfaceYOffset - 1;
276 cmd.DW8.ScaledRegionSizeWidth = pSfcStateparamsXe_Xpm->dwScaledRegionWidth - 1;
277 cmd.DW8.ScaledRegionSizeHeight = pSfcStateparamsXe_Xpm->dwScaledRegionHeight - 1;
278 cmd.DW9.ScaledRegionHorizontalOffset = pSfcStateparamsXe_Xpm->dwScaledRegionHorizontalOffset + pOutSurface->dwSurfaceXOffset;
279 cmd.DW9.ScaledRegionVerticalOffset = pSfcStateparamsXe_Xpm->dwScaledRegionVerticalOffset + pOutSurface->dwSurfaceYOffset;
280
281 // Set DW10
282 cmd.DW10.GrayBarPixelUG = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateparamsXe_Xpm->fColorFillUGPixel * 1024.0F), 0, 1023); // U10
283 cmd.DW10.GrayBarPixelYR = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateparamsXe_Xpm->fColorFillYRPixel * 1024.0F), 0, 1023); // U10
284
285 // Set DW11
286 cmd.DW11.GrayBarPixelA = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateparamsXe_Xpm->fColorFillAPixel * 1024.0F), 0, 1023); // U10
287 cmd.DW11.GrayBarPixelVB = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateparamsXe_Xpm->fColorFillVBPixel * 1024.0F), 0, 1023); // U10
288
289 // Set DW13
290 cmd.DW13.AlphaDefaultValue = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateparamsXe_Xpm->fAlphaPixel * 1024.0F), 0, 1023); // U10
291
292 // Use round to zero for the scaling factor calculation to resolve tdr issue in scalability case
293 // Set DW14
294 cmd.DW14.ScalingFactorHeight = (uint32_t)((double)pSfcStateparamsXe_Xpm->dwSourceRegionHeight / (double)pSfcStateparamsXe_Xpm->dwScaledRegionHeight * 524288.0F); // U4.19
295
296 // Set DW15
297 cmd.DW15.ScaleFactorWidth = (uint32_t)((double)pSfcStateparamsXe_Xpm->dwSourceRegionWidth / (double)pSfcStateparamsXe_Xpm->dwScaledRegionWidth * 524288.0F); // U4.19
298
299 // Set DW19
300 if (pSfcStateparamsXe_Xpm->bMMCEnable &&
301 (pSfcStateparamsXe_Xpm->MMCMode == MOS_MMC_RC ||
302 pSfcStateparamsXe_Xpm->MMCMode == MOS_MMC_MC))
303 {
304 cmd.DW19.OutputFrameSurfaceBaseAddressMemoryCompressionEnable = pSfcStateparamsXe_Xpm->bMMCEnable;
305 cmd.DW3.OutputCompressionFormat = pOutSurface->dwCompressionFormat;
306 }
307
308 cmd.DW19.CompressionType = (pSfcStateparamsXe_Xpm->MMCMode == MOS_MMC_RC) ? 1 : 0;
309
310 // Set DW29
311 cmd.DW29.OutputSurfaceTiledMode = MosGetHWTileType(pOutSurface->TileType, pOutSurface->TileModeGMM, pOutSurface->bGMMTileEnabled);
312 cmd.DW29.OutputSurfaceHalfPitchForChroma = bHalfPitchForChroma;
313 cmd.DW29.OutputSurfacePitch = pOutSurface->dwPitch - 1;
314 cmd.DW29.OutputSurfaceInterleaveChromaEnable = bInterleaveChroma;
315 cmd.DW29.OutputSurfaceFormat = cmd.DW3.OutputSurfaceFormatType;
316
317 // Set DW30, DW31
318 cmd.DW30.OutputSurfaceYOffsetForU = wUYOffset;
319 cmd.DW30.OutputSurfaceXOffsetForU = wUXOffset;
320 cmd.DW31.OutputSurfaceYOffsetForV = wVYOffset;
321 cmd.DW31.OutputSurfaceXOffsetForV = wVXOffset;
322
323 // DW34, DW35
324 cmd.DW34.Sourcestartx = pSfcStateparamsXe_Xpm->srcStartX;
325 cmd.DW34.Sourceendx = pSfcStateparamsXe_Xpm->srcEndX;
326 cmd.DW35.Destinationstartx = pSfcStateparamsXe_Xpm->dstStartX;
327 cmd.DW35.Destinationendx = pSfcStateparamsXe_Xpm->dstEndX;
328
329 // Set DW36, DW37
330 //Change SFC outputcentering scaling X/Yphaseshift value and limition limitione with 19bit following Fuslim setting.
331 if (m_outputCenteringEnable)
332 {
333 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));
334 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));
335 }
336
337 if (pSfcStateparamsXe_Xpm->pOsResOutputSurface)
338 {
339 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
340 if (pSfcStateparamsXe_Xpm->iScalingType == ISCALING_INTERLEAVED_TO_FIELD &&
341 pSfcStateparamsXe_Xpm->outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD)
342 {
343 ResourceParams.presResource = pSfcStateparamsXe_Xpm->tempFieldResource;
344 ResourceParams.pdwCmd = &(cmd.DW17.Value);
345 ResourceParams.dwLocationInCmd = 17;
346 ResourceParams.HwCommandType = MOS_SFC_STATE;
347 ResourceParams.bIsWritable = true;
348 }
349 else
350 {
351 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResOutputSurface;
352 ResourceParams.pdwCmd = &(cmd.DW17.Value);
353 ResourceParams.dwLocationInCmd = 17;
354 ResourceParams.HwCommandType = MOS_SFC_STATE;
355 ResourceParams.bIsWritable = true;
356 }
357 ResourceParams.dwOffset = pSfcStateparamsXe_Xpm->dwOutputSurfaceOffset;
358 InitMocsParams(ResourceParams, &cmd.DW19.Value, 1, 6);
359 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
360 pOsInterface,
361 pCmdBuffer,
362 &ResourceParams));
363 if (m_outputSurfCtrl.Gen12_5.Index != 0)
364 {
365 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = m_outputSurfCtrl.Gen12_5.Index;
366 }
367 }
368
369 if (pSfcStateparamsXe_Xpm->pOsResAVSLineBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->pOsResAVSLineBuffer))
370 {
371 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
372 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResAVSLineBuffer;
373 ResourceParams.pdwCmd = &(cmd.DW20.Value);
374 ResourceParams.dwLocationInCmd = 20;
375 ResourceParams.HwCommandType = MOS_SFC_STATE;
376 ResourceParams.bIsWritable = true;
377 InitMocsParams(ResourceParams, &cmd.DW22.Value, 1, 6);
378 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
379 pOsInterface,
380 pCmdBuffer,
381 &ResourceParams));
382 if (m_avsLineBufferCtrl.Gen12_5.Index != 0)
383 {
384 cmd.DW22.AvsLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineBufferCtrl.Gen12_5.Index;
385 }
386 }
387
388 if (pSfcStateparamsXe_Xpm->pOsResIEFLineBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->pOsResIEFLineBuffer))
389 {
390 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
391 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResIEFLineBuffer;
392 ResourceParams.pdwCmd = &(cmd.DW23.Value);
393 ResourceParams.dwLocationInCmd = 23;
394 ResourceParams.HwCommandType = MOS_SFC_STATE;
395 ResourceParams.bIsWritable = true;
396 InitMocsParams(ResourceParams, &cmd.DW25.Value, 1, 6);
397 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
398 pOsInterface,
399 pCmdBuffer,
400 &ResourceParams));
401 if (m_iefLineBufferCtrl.Gen12_5.Index != 0)
402 {
403 cmd.DW25.IefLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineBufferCtrl.Gen12_5.Index;
404 }
405 }
406
407 if (pSfcStateparamsXe_Xpm->resSfdLineBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->resSfdLineBuffer))
408 {
409 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
410 ResourceParams.presResource = pSfcStateparamsXe_Xpm->resSfdLineBuffer;
411 ResourceParams.pdwCmd = &(cmd.DW26.Value);
412 ResourceParams.dwLocationInCmd = 26;
413 ResourceParams.HwCommandType = MOS_SFC_STATE;
414 ResourceParams.bIsWritable = true;
415 InitMocsParams(ResourceParams, &cmd.DW28.Value, 1, 6);
416 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
417 pOsInterface,
418 pCmdBuffer,
419 &ResourceParams));
420 if (m_sfdLineBufferCtrl.Gen12_5.Index != 0)
421 {
422 cmd.DW28.SfdLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineBufferCtrl.Gen12_5.Index;
423 }
424 }
425
426 if (pSfcStateparamsXe_Xpm->resAvsLineTileBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->resAvsLineTileBuffer))
427 {
428 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
429 ResourceParams.presResource = pSfcStateparamsXe_Xpm->resAvsLineTileBuffer;
430 ResourceParams.pdwCmd = &(cmd.DW38.Value);
431 ResourceParams.dwLocationInCmd = 38;
432 ResourceParams.HwCommandType = MOS_SFC_STATE;
433 ResourceParams.bIsWritable = true;
434 InitMocsParams(ResourceParams, &cmd.DW40.Value, 1, 6);
435 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
436 pOsInterface,
437 pCmdBuffer,
438 &ResourceParams));
439 if (m_avsLineTileBufferCtrl.Gen12_5.Index != 0)
440 {
441 cmd.DW40.AvsLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineTileBufferCtrl.Gen12_5.Index;
442 }
443 }
444
445 if (pSfcStateparamsXe_Xpm->resIefLineTileBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->resIefLineTileBuffer))
446 {
447 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
448 ResourceParams.presResource = pSfcStateparamsXe_Xpm->resIefLineTileBuffer;
449 ResourceParams.pdwCmd = &(cmd.DW41.Value);
450 ResourceParams.dwLocationInCmd = 41;
451 ResourceParams.HwCommandType = MOS_SFC_STATE;
452 ResourceParams.bIsWritable = true;
453 InitMocsParams(ResourceParams, &cmd.DW43.Value, 1, 6);
454 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
455 pOsInterface,
456 pCmdBuffer,
457 &ResourceParams));
458 if (m_iefLineTileBufferCtrl.Gen12_5.Index != 0)
459 {
460 cmd.DW43.IefLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineTileBufferCtrl.Gen12_5.Index;
461 }
462 }
463
464 if (pSfcStateparamsXe_Xpm->resSfdLineTileBuffer && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->resSfdLineTileBuffer))
465 {
466 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
467 ResourceParams.presResource = pSfcStateparamsXe_Xpm->resSfdLineTileBuffer;
468 ResourceParams.pdwCmd = &(cmd.DW44.Value);
469 ResourceParams.dwLocationInCmd = 44;
470 ResourceParams.HwCommandType = MOS_SFC_STATE;
471 ResourceParams.bIsWritable = true;
472 InitMocsParams(ResourceParams, &cmd.DW46.Value, 1, 6);
473 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
474 pOsInterface,
475 pCmdBuffer,
476 &ResourceParams));
477 if (m_sfdLineTileBufferCtrl.Gen12_5.Index != 0)
478 {
479 cmd.DW46.SfdLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineTileBufferCtrl.Gen12_5.Index;
480 }
481 }
482
483 if (pSfcStateparamsXe_Xpm->histogramSurface && !Mos_ResourceIsNull(&pSfcStateparamsXe_Xpm->histogramSurface->OsResource))
484 {
485 cmd.DW4.HistogramStreamout = 1;
486 cmd.DW49.Value = 0;
487
488 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
489 ResourceParams.presResource = &pSfcStateparamsXe_Xpm->histogramSurface->OsResource;
490 ResourceParams.dwOffset = pSfcStateparamsXe_Xpm->histogramSurface->dwOffset;
491 ResourceParams.pdwCmd = &(cmd.DW47.Value);
492 ResourceParams.dwLocationInCmd = 47;
493 ResourceParams.HwCommandType = MOS_SFC_STATE;
494 ResourceParams.bIsWritable = true;
495 InitMocsParams(ResourceParams, &cmd.DW49.Value, 1, 6);
496 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
497 pOsInterface,
498 pCmdBuffer,
499 &ResourceParams));
500 if (m_histogramBufferCtrl.Gen12_5.Index != 0)
501 {
502 cmd.DW49.HisgotramBaseAddressIndexToMemoryObjectControlStateMocsTables = m_histogramBufferCtrl.Gen12_5.Index;
503 }
504 }
505
506 // Input/Output frame format
507 cmd.DW1.InputFrameDataFormat = pSfcStateparamsXe_Xpm->inputFrameDataFormat;
508 cmd.DW1.OutputFrameDataFormat = pSfcStateparamsXe_Xpm->outputFrameDataFormat;
509
510 // interleaved to interleaved
511 if (pSfcStateparamsXe_Xpm->iScalingType == ISCALING_INTERLEAVED_TO_INTERLEAVED)
512 {
513 cmd.DW54.BottomFieldVerticalScalingOffset = pSfcStateparamsXe_Xpm->bottomFieldVerticalScalingOffset;
514 }
515
516 // Input is field mode
517 if (pSfcStateparamsXe_Xpm->iScalingType == ISCALING_FIELD_TO_INTERLEAVED)
518 {
519 cmd.DW1.TopBottomField = pSfcStateparamsXe_Xpm->topBottomField;
520 cmd.DW1.TopBottomFieldFirst = pSfcStateparamsXe_Xpm->topBottomFieldFirst;
521 }
522
523 // interleaved to field
524 if (pSfcStateparamsXe_Xpm->iScalingType == ISCALING_INTERLEAVED_TO_FIELD)
525 {
526 // Add bottom field address to cmd
527 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
528 if (pSfcStateparamsXe_Xpm->outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD)
529 {
530 ResourceParams.dwLsbNum = 12;
531 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResOutputSurface;
532 ResourceParams.pdwCmd = &cmd.DW55.Value;
533 ResourceParams.dwLocationInCmd = 55;
534 ResourceParams.bIsWritable = true;
535 }
536 else
537 {
538 ResourceParams.dwLsbNum = 12;
539 ResourceParams.presResource = pSfcStateparamsXe_Xpm->tempFieldResource;
540 ResourceParams.pdwCmd = &cmd.DW55.Value;
541 ResourceParams.dwLocationInCmd = 55;
542 ResourceParams.bIsWritable = true;
543 }
544 InitMocsParams(ResourceParams, &cmd.DW57.Value, 1, 6);
545 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
546 m_osInterface,
547 pCmdBuffer,
548 &ResourceParams));
549
550 // copy from base surface
551 cmd.DW57.BottomFieldSurfaceBaseAddressArbitrationPriorityControl =
552 cmd.DW19.OutputFrameSurfaceBaseAddressArbitrationPriorityControl;
553 cmd.DW57.BottomFieldSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables =
554 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables;
555 cmd.DW57.BottomFiledSurfaceBaseAddressMemoryCompressionEnable =
556 cmd.DW19.OutputFrameSurfaceBaseAddressMemoryCompressionEnable;
557 cmd.DW57.BottomFiledSurfaceBaseAddressMemoryCompressionType =
558 cmd.DW19.CompressionType;
559
560 cmd.DW58.BottomFieldSurfaceHalfPitchForChroma = cmd.DW29.OutputSurfaceHalfPitchForChroma;
561 cmd.DW58.BottomFieldSurfaceInterleaveChromaEnable = cmd.DW29.OutputSurfaceHalfPitchForChroma;
562 cmd.DW58.BottomFieldSurfacePitch = cmd.DW29.OutputSurfacePitch;
563 cmd.DW58.BottomFieldSurfaceTiled = (pOutSurface->TileType != MOS_TILE_LINEAR) ? true : false;
564 cmd.DW58.BottomFieldSurfaceTileWalk = (pOutSurface->TileType == MOS_TILE_Y) ? true : false;
565 cmd.DW59.BottomFieldSurfaceXOffsetForU = cmd.DW30.OutputSurfaceXOffsetForU;
566 cmd.DW59.BottomFieldSurfaceYOffsetForU = cmd.DW30.OutputSurfaceYOffsetForU;
567 cmd.DW60.BottomFieldSurfaceXOffsetForV = cmd.DW31.OutputSurfaceXOffsetForV;
568 cmd.DW60.BottomFieldSurfaceYOffsetForV = cmd.DW31.OutputSurfaceYOffsetForV;
569 }
570
571 // update dithering setting
572 cmd.DW3.DitherEnable = pSfcStateparamsXe_Xpm->ditheringEn;
573 if (cmd.DW3.DitherEnable)
574 {
575 cmd.DW50.DitheringLutDelta12 = 0;
576 cmd.DW50.DitheringLutDelta13 = 1;
577 cmd.DW50.DitheringLutDelta14 = 1;
578 cmd.DW50.DitheringLutDelta15 = 1;
579
580 cmd.DW51.DitheringLutDelta8 = 0;
581 cmd.DW51.DitheringLutDelta9 = 1;
582 cmd.DW51.DitheringLutDelta10 = 1;
583 cmd.DW51.DitheringLutDelta11 = 0;
584
585 cmd.DW52.DitheringLutDelta4 = 0;
586 cmd.DW52.DitheringLutDelta5 = 1;
587 cmd.DW52.DitheringLutDelta6 = 0;
588 cmd.DW52.DitheringLutDelta7 = 0;
589
590 cmd.DW53.DitheringLutDelta0 = 0;
591 cmd.DW53.DitheringLutDelta1 = 0;
592 cmd.DW53.DitheringLutDelta2 = 0;
593 cmd.DW53.DitheringLutDelta3 = 0;
594 }
595
596 if (m_sfcScalabilityEnabled == true)
597 {
598 uint32_t iMediumX;
599 uint32_t Xoffset;
600 uint32_t src_startX[MHW_SFC_MAX_PIPE_NUM_XE_XPM];
601 uint32_t src_endX[MHW_SFC_MAX_PIPE_NUM_XE_XPM];
602 uint32_t dest_startX[MHW_SFC_MAX_PIPE_NUM_XE_XPM];
603 uint32_t dest_endX[MHW_SFC_MAX_PIPE_NUM_XE_XPM];
604 uint32_t tile_endX;
605 uint32_t dest_first_valid_left_tile = 0;
606 uint32_t dest_last_valid_right_tile = m_numofSfc - 1;
607 uint32_t dest_cntX = 0;
608 double Xlandingpoint;
609 uint32_t one_by_sf = (uint32_t)(((uint64_t)pSfcStateparamsXe_Xpm->dwSourceRegionWidth * 524288L)/ pSfcStateparamsXe_Xpm->dwScaledRegionWidth);
610 const uint32_t one_by_sf_fraction_precision = 19;
611 const uint32_t beta_precision = 5;
612 int32_t xPhaseShift;
613 double tempDestCntx;
614 uint32_t i;
615 MHW_ASSERT(pSfcStateparamsXe_Xpm->dwInputFrameWidth > m_numofSfc * 64);
616
617 iMediumX = MOS_ALIGN_FLOOR((pSfcStateparamsXe_Xpm->dwInputFrameWidth / m_numofSfc), 64);
618 iMediumX = MOS_CLAMP_MIN_MAX(iMediumX, 64, (pSfcStateparamsXe_Xpm->dwInputFrameWidth - 64));
619
620 src_startX[0] = dest_startX[0] = 0;
621
622 for (i = 0; i < m_numofSfc; i++)
623 {
624 if (i == m_numofSfc - 1)
625 {
626 src_endX[i] = pSfcStateparamsXe_Xpm->dwInputFrameWidth - 1;
627 }
628 else
629 {
630 src_endX[i] = iMediumX * (i + 1) - 1;
631 if (pSfcStateparamsXe_Xpm->dwInputFrameWidth != m_numofSfc * iMediumX)
632 {
633 src_endX[i] += 64;
634 }
635 }
636
637 if (pSfcStateparamsXe_Xpm->dwSourceRegionHorizontalOffset + pSfcStateparamsXe_Xpm->dwSourceRegionWidth - 1 <= src_endX[i])
638 {
639 Xoffset = 0;
640 tile_endX = pSfcStateparamsXe_Xpm->dwSourceRegionHorizontalOffset + pSfcStateparamsXe_Xpm->dwSourceRegionWidth - 1;
641 }
642 else
643 {
644 // Fix tdr issue with odd width output, the Xoffset was set to VALUE_XOFFSET always for vesfc workload
645 Xoffset = VALUE_XOFFSET;
646 tile_endX = src_endX[i];
647 }
648
649 while (1)
650 {
651 if (src_endX[i] - pSfcStateparamsXe_Xpm->dwSourceRegionHorizontalOffset < (Xoffset + 1))
652 {
653 dest_endX[i] = 0;
654 break;
655 }
656
657 if (dest_cntX == 0)
658 {
659 dest_first_valid_left_tile = i;
660 }
661
662 xPhaseShift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)pSfcStateparamsXe_Xpm->dwSourceRegionWidth / pSfcStateparamsXe_Xpm->dwScaledRegionWidth - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1));
663 tempDestCntx = (((double)dest_cntX * (double)one_by_sf) + xPhaseShift);
664 if (tempDestCntx < 0)
665 {
666 tempDestCntx = 0;
667 }
668 Xlandingpoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288.0F) + pSfcStateparamsXe_Xpm->dwSourceRegionHorizontalOffset);
669
670 if (Xlandingpoint >= (double)(tile_endX - Xoffset))
671 {
672 dest_endX[i] = dest_cntX - 1;
673 break;
674 }
675 else
676 {
677 dest_cntX ++;
678 }
679
680 if (Xoffset == 0)
681 {
682 dest_last_valid_right_tile = i;
683 dest_endX[i] = pSfcStateparamsXe_Xpm->dwScaledRegionWidth - 1;
684 break;
685 }
686 }
687 }
688
689 for (i = 1; i < m_numofSfc; i++)
690 {
691 src_startX[i] = src_endX[i - 1] + 1 - 64;
692
693 if (i <= dest_first_valid_left_tile)
694 {
695 dest_startX[i] = 0;
696 }
697 else if (i <= dest_last_valid_right_tile)
698 {
699 dest_startX[i] = dest_endX[i-1] + 1;
700 }
701 else
702 {
703 dest_startX[i] = 0;
704 dest_endX[i] = 0;
705 }
706 }
707
708 // Set SFC Engine Mode
709 if (m_numofSfc == 2)
710 {
711 if (m_indexofSfc == MHW_SFC_INDEX_0)
712 {
713 cmd.DW1.SfcEngineMode = 1;
714 }
715 else
716 {
717 cmd.DW1.SfcEngineMode = 2;
718 }
719 }
720 else if (m_numofSfc == 3)
721 {
722 if (m_indexofSfc == MHW_SFC_INDEX_0)
723 {
724 cmd.DW1.SfcEngineMode = 1;
725 }
726 else if (m_indexofSfc == MHW_SFC_INDEX_1)
727 {
728 cmd.DW1.SfcEngineMode = 3;
729 }
730 else
731 {
732 cmd.DW1.SfcEngineMode = 2;
733 }
734 }
735 else if (m_numofSfc == 4)
736 {
737 if (m_indexofSfc == MHW_SFC_INDEX_0)
738 {
739 cmd.DW1.SfcEngineMode = 1;
740 }
741 else if (m_indexofSfc == MHW_SFC_INDEX_1 ||
742 m_indexofSfc == MHW_SFC_INDEX_2)
743 {
744 cmd.DW1.SfcEngineMode = 3;
745 }
746 else
747 {
748 cmd.DW1.SfcEngineMode = 2;
749 }
750 }
751
752 if (m_indexofSfc < dest_first_valid_left_tile)
753 {
754 cmd.DW4.ColorFillEnable = 0;
755 }
756 else if (m_indexofSfc > dest_last_valid_right_tile)
757 {
758 cmd.DW4.ColorFillEnable = 0;
759 }
760
761 if (pSfcStateparamsXe_Xpm->bIEFEnable)
762 {
763 if (dest_startX[m_indexofSfc] >= 4)
764 {
765 dest_startX[m_indexofSfc] -= 4;
766 }
767 else
768 {
769 dest_startX[m_indexofSfc] = 0;
770 }
771 }
772
773 if (VpHalDDIUtils::GetSurfaceColorPack(pSfcStateparamsXe_Xpm->OutputFrameFormat) != VPHAL_COLORPACK_444 &&
774 (dest_startX[m_indexofSfc] %2 != 0))
775 {
776 if (dest_startX[m_indexofSfc] >= 1)
777 {
778 dest_startX[m_indexofSfc] -= 1;
779 }
780 else
781 {
782 dest_startX[m_indexofSfc] = 0;
783 }
784 }
785
786 cmd.DW34.Sourcestartx = src_startX[m_indexofSfc];
787 cmd.DW34.Sourceendx = src_endX[m_indexofSfc];
788 cmd.DW35.Destinationstartx = dest_startX[m_indexofSfc];
789 cmd.DW35.Destinationendx = dest_endX[m_indexofSfc];
790
791 if (pSfcStateparamsXe_Xpm->pOsResAVSLineBufferSplit[m_indexofSfc] && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->pOsResAVSLineBufferSplit[m_indexofSfc]))
792 {
793 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
794 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResAVSLineBufferSplit[m_indexofSfc];
795 ResourceParams.pdwCmd = &(cmd.DW20.Value);
796 ResourceParams.dwLocationInCmd = 20;
797 ResourceParams.HwCommandType = MOS_SFC_STATE;
798 ResourceParams.bIsWritable = true;
799
800 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
801 pOsInterface,
802 pCmdBuffer,
803 &ResourceParams));
804 }
805
806 if (pSfcStateparamsXe_Xpm->pOsResIEFLineBufferSplit[m_indexofSfc] && !Mos_ResourceIsNull(pSfcStateparamsXe_Xpm->pOsResIEFLineBufferSplit[m_indexofSfc]))
807 {
808 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
809 ResourceParams.presResource = pSfcStateparamsXe_Xpm->pOsResIEFLineBufferSplit[m_indexofSfc];
810 ResourceParams.pdwCmd = &(cmd.DW23.Value);
811 ResourceParams.dwLocationInCmd = 23;
812 ResourceParams.HwCommandType = MOS_SFC_STATE;
813 ResourceParams.bIsWritable = true;
814
815 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
816 pOsInterface,
817 pCmdBuffer,
818 &ResourceParams));
819 }
820
821 MHW_NORMALMESSAGE("SFC%d STATE: src startx %d endx %d", m_indexofSfc, cmd.DW34.Sourcestartx, cmd.DW34.Sourceendx);
822 MHW_NORMALMESSAGE("SFC%d STATE: dest startx %d endx %d", m_indexofSfc, cmd.DW35.Destinationstartx, cmd.DW35.Destinationendx);
823 }
824
825 MHW_CHK_STATUS_RETURN(pOsInterface->pfnAddCommand(pCmdBuffer, &cmd, cmd.byteSize));
826
827 return MOS_STATUS_SUCCESS;
828 }
829
830 //!
831 //! \brief Set which Sfc can be used by HW
832 //! \details VPHAL set which Sfc can be use by HW
833 //! \param [in] dwSfcIndex;
834 //! set which Sfc can be used by HW
835 //! \param [in] dwSfcCount;
836 //! set Sfc Count
837 //! \return MOS_STATUS
838 //! MOS_STATUS_SUCCESS if success, else fail reason
SetSfcIndex(uint32_t dwSfcIndex,uint32_t dwSfcCount)839 MOS_STATUS MhwSfcInterfaceXe_Xpm::SetSfcIndex(
840 uint32_t dwSfcIndex,
841 uint32_t dwSfcCount)
842 {
843 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
844
845 MHW_ASSERT(dwSfcIndex < dwSfcCount);
846
847 m_indexofSfc = dwSfcIndex;
848 m_numofSfc = dwSfcCount;
849 m_sfcScalabilityEnabled = (dwSfcCount > 1) ? true : false;
850
851 return eStatus;
852 }
853