Debian Codegraph @

media_softlet/agnostic/common/hw/mhw_sfc_common_impl.h

raw
1 // Copyright (c) 2026, Intel Corporation
2 //
3 // Permission is hereby granted, free of charge, to any person obtaining a
4 // copy of this software and associated documentation files (the "Software"),
5 // to deal in the Software without restriction, including without limitation
6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
7 // and/or sell copies of the Software, and to permit persons to whom the
8 // Software is furnished to do so, subject to the following conditions:
9 //
10 // The above copyright notice and this permission notice shall be included
11 // in all copies or substantial portions of the Software.
12 //
13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
16 // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
17 // OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
18 // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
19 // OTHER DEALINGS IN THE SOFTWARE.
20 //!
21 //! \file mhw_sfc_common_impl.h
22 //! \brief MHW SFC common non-member helper functions shared across platform implementations
23 //! \details Provides templated helper functions in namespace mhw::sfc::common that
24 //! encapsulate the shared logic of _MHW_SETCMD_OVERRIDE_DECL(SFC_STATE).
25 //!
26
27 #pragma once
28 #ifndef __MHW_SFC_COMMON_IMPL_H__
29 #define __MHW_SFC_COMMON_IMPL_H__
30
31 #include "mhw_sfc_cmdpar.h"
32 //#include "mhw_resource_params.h"
33 #include "mhw_utilities.h"
34 #include "mos_os.h"
35 #include "vp_hal_ddi_utils.h"
36
37 namespace mhw
38 {
39 namespace sfc
40 {
41 namespace common
42 {
43
44 #define VALUE_XOFFSET 3
45 //!
46 //! \brief SetSfcStateBasicFields
47 //! Sets DW0-DW9, DW14-DW15, DW33-DW37, DW1 frame format, DW54, DW1 TopBottom fields.
48 //! Note: SetOutputSurfaceFormatType must be called BEFORE this helper to set DW3.OutputSurfaceFormatType.
49 //! DW3.ChannelSwapEnable must be set BEFORE calling this helper as well.
50 //!
51 template <typename cmd_t>
52 inline void SetSfcStateBasicFields(
53 typename cmd_t::SFC_STATE_CMD &cmd,
54 const SFC_STATE_PAR &params,
55 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface,
56 bool outputCenteringEnable)
57 {
58 // Set DW0: pipe mode opcode
59 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_HCP)
60 {
61 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHCPSFCMODE;
62 }
63 else if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP)
64 {
65 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAAVPSFCMODE;
66 }
67 else
68 {
69 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMFXVEBOXSFCMODE;
70 }
71
72 // Set DW1: SfcPipeMode / ChromaSubSampling / VdVeInputOrderingMode / SfcEngineMode
73 cmd.DW1.SfcPipeMode = params.sfcPipeMode;
74 cmd.DW1.SfcInputChromaSubSampling = params.dwInputChromaSubSampling;
75 cmd.DW1.VdVeInputOrderingMode = params.dwVDVEInputOrderingMode;
76 cmd.DW1.SfcEngineMode = params.engineMode;
77
78 // Set DW2: input frame resolution
79 cmd.DW2.InputFrameResolutionWidth = params.dwInputFrameWidth - 1;
80 cmd.DW2.InputFrameResolutionHeight = params.dwInputFrameHeight - 1;
81
82 // Set DW3: chroma downsampling + color space
83 // Note: OutputSurfaceFormatType and ChannelSwapEnable are set by caller before this function
84 cmd.DW3.OutputChromaDownsamplingCoSitingPositionVerticalDirection = params.dwChromaDownSamplingVerticalCoef;
85 cmd.DW3.OutputChromaDownsamplingCoSitingPositionHorizontalDirection = params.dwChromaDownSamplingHorizontalCoef;
86 cmd.DW3.InputColorSpace0Yuv1Rgb = params.bInputColorSpace;
87 cmd.DW3.ChannelSwapEnable = params.bRGBASwapEnable;
88
89 // Set DW4: IEF/AVS/rotation/colorFill/CSC/mirror/tileType/RGBAdaptive
90 cmd.DW4.IefEnable = params.bIEFEnable;
91 cmd.DW4.SkinToneTunedIefEnable = params.bSkinToneTunedIEFEnable;
92 cmd.DW4.AvsFilterMode = params.dwAVSFilterMode;
93 if (params.b8tapChromafiltering)
94 {
95 cmd.DW4.AdaptiveFilterForAllChannels = true;
96 }
97 else
98 {
99 cmd.DW4.AdaptiveFilterForAllChannels = false;
100 }
101
102 cmd.DW4.AvsScalingEnable = ((params.fAVSXScalingRatio == 1.0F) &&
103 (params.fAVSYScalingRatio == 1.0F))
104 ? false
105 : true;
106 cmd.DW4.BypassYAdaptiveFiltering = params.bBypassYAdaptiveFilter;
107 cmd.DW4.BypassXAdaptiveFiltering = params.bBypassXAdaptiveFilter;
108 cmd.DW4.ChromaUpsamplingEnable = params.bAVSChromaUpsamplingEnable;
109 cmd.DW4.RotationMode = params.RotationMode;
110 cmd.DW4.ColorFillEnable = params.bColorFillEnable;
111 cmd.DW4.CscEnable = params.bCSCEnable;
112 cmd.DW4.Enable8TapForChromaChannelsFiltering = params.b8tapChromafiltering;
113 cmd.DW4.TileType = params.tileType;
114 cmd.DW4.RgbAdaptive = params.bRGBAdaptive;
115
116 if (params.bMirrorEnable)
117 {
118 cmd.DW4.Value |= (uint32_t)(1 << 14) & 0x00004000; // Mirror Mode
119 cmd.DW4.Value |= (uint32_t)(params.dwMirrorType << 13) & 0x00002000; // Mirror Type
120 }
121
122 // Set DW5, DW6, DW7, DW8, DW9: source/output/scaled region dimensions
123 cmd.DW5.SourceRegionWidth = params.dwSourceRegionWidth - 1;
124 cmd.DW5.SourceRegionHeight = params.dwSourceRegionHeight - 1;
125 cmd.DW6.SourceRegionHorizontalOffset = params.dwSourceRegionHorizontalOffset;
126 cmd.DW6.SourceRegionVerticalOffset = params.dwSourceRegionVerticalOffset;
127 cmd.DW7.OutputFrameWidth = params.dwOutputFrameWidth + pOutSurface->dwSurfaceXOffset - 1;
128 cmd.DW7.OutputFrameHeight = params.dwOutputFrameHeight + pOutSurface->dwSurfaceYOffset - 1;
129 cmd.DW8.ScaledRegionSizeWidth = params.dwScaledRegionWidth - 1;
130 cmd.DW8.ScaledRegionSizeHeight = params.dwScaledRegionHeight - 1;
131 cmd.DW9.ScaledRegionHorizontalOffset = params.dwScaledRegionHorizontalOffset + pOutSurface->dwSurfaceXOffset;
132 cmd.DW9.ScaledRegionVerticalOffset = params.dwScaledRegionVerticalOffset + pOutSurface->dwSurfaceYOffset;
133
134 // Set DW14-DW15: scaling factors (round-to-zero cast)
135 // Use round to zero for the scaling factor calculation to resolve tdr issue in scalability case
136 cmd.DW14.ScalingFactorHeight = (uint32_t)((double)params.dwSourceRegionHeight / (double)params.dwScaledRegionHeight * 524288.0F); // U4.19
137 cmd.DW15.ScaleFactorWidth = (uint32_t)((double)params.dwSourceRegionWidth / (double)params.dwScaledRegionWidth * 524288.0F); // U4.19
138
139 // Set DW33: AV1 tile numbers
140 if (params.sfcPipeMode == SFC_PIPE_MODE::SFC_PIPE_MODE_AVP)
141 {
142 cmd.DW33.Av1TileColumnNumber = params.av1TileColumnNumber;
143 cmd.DW33.Av1TileRowNumber = params.av1TileRowNumber;
144 }
145 else
146 {
147 cmd.DW33.Av1TileColumnNumber = 0;
148 cmd.DW33.Av1TileRowNumber = 0;
149 }
150
151 // DW34, DW35: initial src/dst start/end X from params
152 cmd.DW34.Sourcestartx = params.srcStartX;
153 cmd.DW34.Sourceendx = params.srcEndX;
154 cmd.DW35.Destinationstartx = params.dstStartX;
155 cmd.DW35.Destinationendx = params.dstEndX;
156
157 // Set DW36, DW37: phase shifts when output centering enabled
158 // Change SFC outputcentering scaling X/Yphaseshift value and limitation with 19bit following Fuslim setting.
159 if (outputCenteringEnable)
160 {
161 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));
162 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));
163 }
164
165 // Input/Output frame format
166 cmd.DW1.InputFrameDataFormat = params.inputFrameDataFormat;
167 cmd.DW1.OutputFrameDataFormat = params.outputFrameDataFormat;
168
169 // DW54: interleaved-to-interleaved bottom field vertical scaling offset
170 if (params.iScalingType == ISCALING_INTERLEAVED_TO_INTERLEAVED)
171 {
172 cmd.DW54.BottomFieldVerticalScalingOffset = params.bottomFieldVerticalScalingOffset;
173 }
174
175 // DW1: field-to-interleaved top/bottom field selection
176 if (params.iScalingType == ISCALING_FIELD_TO_INTERLEAVED)
177 {
178 cmd.DW1.TopBottomField = params.topBottomField;
179 cmd.DW1.TopBottomFieldFirst = params.topBottomFieldFirst;
180 }
181 }
182
183 //!
184 //! \brief SetSfcStateGrayBarPixelsU10
185 //! Sets DW10-DW11, DW13 gray bar pixel values using U10 fixed-point format.
186 //! Used by Group A and B platforms (no FP16 support).
187 //!
188 template <typename cmd_t>
189 inline void SetSfcStateGrayBarPixelsU10(
190 typename cmd_t::SFC_STATE_CMD &cmd,
191 const SFC_STATE_PAR &params)
192 {
193 // Set DW10
194 cmd.DW10.GrayBarPixelUG = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillUGPixel * 1024.0F), 0, 1023); // U10
195 cmd.DW10.GrayBarPixelYR = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillYRPixel * 1024.0F), 0, 1023); // U10
196
197 // Set DW11
198 cmd.DW11.GrayBarPixelA = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillAPixel * 1024.0F), 0, 1023); // U10
199 cmd.DW11.GrayBarPixelVB = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fColorFillVBPixel * 1024.0F), 0, 1023); // U10
200
201 // Set DW13
202 cmd.DW13.AlphaDefaultValue = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(params.fAlphaPixel * 1024.0F), 0, 1023); // U10
203 }
204
205 //!
206 //! \brief SetSfcStateSurfaceParams
207 //! Sets DW29: tile mode, pitch, interleave chroma, format.
208 //! Note: tiledMode is computed at call site to avoid this-> vs no-this-> divergence.
209 //!
210 template <typename cmd_t>
211 inline void SetSfcStateSurfaceParams(
212 typename cmd_t::SFC_STATE_CMD &cmd,
213 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface,
214 bool bHalfPitchForChroma,
215 bool bInterleaveChroma,
216 uint32_t tiledMode)
217 {
218 cmd.DW29.TiledMode = tiledMode;
219 cmd.DW29.OutputSurfaceHalfPitchForChroma = bHalfPitchForChroma;
220 cmd.DW29.OutputSurfacePitch = pOutSurface->dwPitch - 1;
221 cmd.DW29.OutputSurfaceInterleaveChromaEnable = bInterleaveChroma;
222 cmd.DW29.OutputSurfaceFormat = cmd.DW3.OutputSurfaceFormatType;
223 }
224
225 //!
226 //! \brief SetSfcStateResourceBindings
227 //! Handles all conditional DW17-DW60 AddResourceToCmd calls via pass-through lambdas.
228 //! Includes output surface, AVS/IEF/SFD line buffers, tile buffers, histogram, and
229 //! the ISCALING_INTERLEAVED_TO_FIELD bottom field resource block.
230 //!
231 template <typename cmd_t, typename AddResFnT, typename InitMocsFnT>
232 inline MOS_STATUS SetSfcStateResourceBindings(
233 typename cmd_t::SFC_STATE_CMD &cmd,
234 const SFC_STATE_PAR &params,
235 PMOS_INTERFACE pOsInterface,
236 PMOS_COMMAND_BUFFER pCmdBuf,
237 MHW_MEMORY_OBJECT_CONTROL_PARAMS outputSurfCtrl,
238 MHW_MEMORY_OBJECT_CONTROL_PARAMS avsLineBufferCtrl,
239 MHW_MEMORY_OBJECT_CONTROL_PARAMS iefLineBufferCtrl,
240 MHW_MEMORY_OBJECT_CONTROL_PARAMS sfdLineBufferCtrl,
241 MHW_MEMORY_OBJECT_CONTROL_PARAMS avsLineTileBufferCtrl,
242 MHW_MEMORY_OBJECT_CONTROL_PARAMS iefLineTileBufferCtrl,
243 MHW_MEMORY_OBJECT_CONTROL_PARAMS sfdLineTileBufferCtrl,
244 MHW_MEMORY_OBJECT_CONTROL_PARAMS histogramBufferCtrl,
245 AddResFnT addResourceFn,
246 InitMocsFnT initMocsFn)
247 {
248 MHW_RESOURCE_PARAMS resourceParams;
249
250 // Block 1 (DW17-19): Output surface
251 if (params.pOsResOutputSurface)
252 {
253 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
254 if (params.iScalingType == ISCALING_INTERLEAVED_TO_FIELD &&
255 params.outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD)
256 {
257 resourceParams.presResource = params.tempFieldResource;
258 resourceParams.pdwCmd = &(cmd.DW17.Value);
259 resourceParams.dwLocationInCmd = 17;
260 resourceParams.HwCommandType = MOS_SFC_STATE;
261 resourceParams.bIsWritable = true;
262 }
263 else
264 {
265 resourceParams.presResource = params.pOsResOutputSurface;
266 resourceParams.pdwCmd = &(cmd.DW17.Value);
267 resourceParams.dwLocationInCmd = 17;
268 resourceParams.HwCommandType = MOS_SFC_STATE;
269 resourceParams.bIsWritable = true;
270 }
271 resourceParams.dwOffset = params.dwOutputSurfaceOffset;
272 initMocsFn(resourceParams, &cmd.DW19.Value, 1, 6);
273 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
274 if (outputSurfCtrl.Gen12_7.Index != 0)
275 {
276 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = outputSurfCtrl.Gen12_7.Index;
277 }
278 }
279
280 // Block 2 (DW20-22): AVS line buffer
281 if (params.pOsResAVSLineBuffer)
282 {
283 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
284 resourceParams.presResource = params.pOsResAVSLineBuffer;
285 resourceParams.pdwCmd = &(cmd.DW20.Value);
286 resourceParams.dwLocationInCmd = 20;
287 resourceParams.HwCommandType = MOS_SFC_STATE;
288 resourceParams.bIsWritable = true;
289 initMocsFn(resourceParams, &cmd.DW22.Value, 1, 6);
290 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
291 // Set DW22
292 if (avsLineBufferCtrl.Gen12_7.Index != 0)
293 {
294 cmd.DW22.AvsLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = avsLineBufferCtrl.Gen12_7.Index;
295 }
296 }
297
298 // Block 3 (DW23-25): IEF line buffer
299 if (params.pOsResIEFLineBuffer)
300 {
301 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
302 resourceParams.presResource = params.pOsResIEFLineBuffer;
303 resourceParams.pdwCmd = &(cmd.DW23.Value);
304 resourceParams.dwLocationInCmd = 23;
305 resourceParams.HwCommandType = MOS_SFC_STATE;
306 resourceParams.bIsWritable = true;
307 initMocsFn(resourceParams, &cmd.DW25.Value, 1, 6);
308 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
309 // Set DW25
310 if (iefLineBufferCtrl.Gen12_7.Index != 0)
311 {
312 cmd.DW25.IefLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = iefLineBufferCtrl.Gen12_7.Index;
313 }
314 }
315
316 // Block 4 (DW26-28): SFD line buffer
317 if (params.resSfdLineBuffer && !Mos_ResourceIsNull(params.resSfdLineBuffer))
318 {
319 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
320 resourceParams.presResource = params.resSfdLineBuffer;
321 resourceParams.pdwCmd = &(cmd.DW26.Value);
322 resourceParams.dwLocationInCmd = 26;
323 resourceParams.HwCommandType = MOS_SFC_STATE;
324 resourceParams.bIsWritable = true;
325 initMocsFn(resourceParams, &cmd.DW28.Value, 1, 6);
326 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
327 if (sfdLineBufferCtrl.Gen12_7.Index != 0)
328 {
329 cmd.DW28.SfdLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = sfdLineBufferCtrl.Gen12_7.Index;
330 }
331 }
332
333 // Block 5 (DW38-40): AVS line tile buffer
334 if (params.resAvsLineTileBuffer && !Mos_ResourceIsNull(params.resAvsLineTileBuffer))
335 {
336 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
337 resourceParams.presResource = params.resAvsLineTileBuffer;
338 resourceParams.pdwCmd = &(cmd.DW38.Value);
339 resourceParams.dwLocationInCmd = 38;
340 resourceParams.HwCommandType = MOS_SFC_STATE;
341 resourceParams.bIsWritable = true;
342 initMocsFn(resourceParams, &cmd.DW40.Value, 1, 6);
343 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
344 if (avsLineTileBufferCtrl.Gen12_7.Index != 0)
345 {
346 cmd.DW40.AvsLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = avsLineTileBufferCtrl.Gen12_7.Index;
347 }
348 }
349
350 // Block 6 (DW41-43): IEF line tile buffer
351 if (params.resIefLineTileBuffer && !Mos_ResourceIsNull(params.resIefLineTileBuffer))
352 {
353 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
354 resourceParams.presResource = params.resIefLineTileBuffer;
355 resourceParams.pdwCmd = &(cmd.DW41.Value);
356 resourceParams.dwLocationInCmd = 41;
357 resourceParams.HwCommandType = MOS_SFC_STATE;
358 resourceParams.bIsWritable = true;
359 initMocsFn(resourceParams, &cmd.DW43.Value, 1, 6);
360 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
361 if (iefLineTileBufferCtrl.Gen12_7.Index != 0)
362 {
363 cmd.DW43.IefLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = iefLineTileBufferCtrl.Gen12_7.Index;
364 }
365 }
366
367 // Block 7 (DW44-46): SFD line tile buffer
368 if (params.resSfdLineTileBuffer && !Mos_ResourceIsNull(params.resSfdLineTileBuffer))
369 {
370 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
371 resourceParams.presResource = params.resSfdLineTileBuffer;
372 resourceParams.pdwCmd = &(cmd.DW44.Value);
373 resourceParams.dwLocationInCmd = 44;
374 resourceParams.HwCommandType = MOS_SFC_STATE;
375 resourceParams.bIsWritable = true;
376 initMocsFn(resourceParams, &cmd.DW46.Value, 1, 6);
377 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
378 if (sfdLineTileBufferCtrl.Gen12_7.Index != 0)
379 {
380 cmd.DW46.SfdLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = sfdLineTileBufferCtrl.Gen12_7.Index;
381 }
382 }
383
384 // Block 8 (DW47-49): Histogram surface
385 if (params.histogramSurface && !Mos_ResourceIsNull(&params.histogramSurface->OsResource))
386 {
387 cmd.DW4.HistogramStreamout = 1;
388 cmd.DW49.Value = 0;
389
390 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
391 resourceParams.presResource = &params.histogramSurface->OsResource;
392 resourceParams.dwOffset = params.histogramSurface->dwOffset;
393 resourceParams.pdwCmd = &(cmd.DW47.Value);
394 resourceParams.dwLocationInCmd = 47;
395 resourceParams.HwCommandType = MOS_SFC_STATE;
396 resourceParams.bIsWritable = true;
397 initMocsFn(resourceParams, &cmd.DW49.Value, 1, 6);
398 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
399 if (histogramBufferCtrl.Gen12_7.Index != 0)
400 {
401 cmd.DW49.HisgotramBaseAddressIndexToMemoryObjectControlStateMocsTables = histogramBufferCtrl.Gen12_7.Index;
402 }
403 }
404
405 // Block 9 (DW55-60): Interleaved to field - bottom field address
406 if (params.iScalingType == ISCALING_INTERLEAVED_TO_FIELD)
407 {
408 // Add bottom field address to cmd
409 MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
410 if (params.outputSampleType == SAMPLE_SINGLE_BOTTOM_FIELD)
411 {
412 resourceParams.dwLsbNum = 12;
413 resourceParams.presResource = params.pOsResOutputSurface;
414 resourceParams.pdwCmd = &cmd.DW55.Value;
415 resourceParams.dwLocationInCmd = 55;
416 resourceParams.bIsWritable = true;
417 }
418 else
419 {
420 resourceParams.dwLsbNum = 12;
421 resourceParams.presResource = params.tempFieldResource;
422 resourceParams.pdwCmd = &cmd.DW55.Value;
423 resourceParams.dwLocationInCmd = 55;
424 resourceParams.bIsWritable = true;
425 }
426 initMocsFn(resourceParams, &cmd.DW57.Value, 1, 6);
427 MHW_CHK_STATUS_RETURN(addResourceFn(pOsInterface, pCmdBuf, &resourceParams));
428 if (outputSurfCtrl.Gen12_7.Index != 0)
429 {
430 cmd.DW57.BottomFieldSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables =
431 outputSurfCtrl.Gen12_7.Index;
432 }
433
434 cmd.DW58.BottomFieldSurfaceHalfPitchForChroma = cmd.DW29.OutputSurfaceHalfPitchForChroma;
435 cmd.DW58.BottomFieldSurfaceInterleaveChromaEnable = cmd.DW29.OutputSurfaceHalfPitchForChroma;
436 cmd.DW58.BottomFieldSurfacePitch = cmd.DW29.OutputSurfacePitch;
437 cmd.DW58.BottomFieldSurfaceTiled = (params.pOutSurface->TileType != MOS_TILE_LINEAR) ? true : false;
438 cmd.DW58.BottomFieldSurfaceTileWalk = (params.pOutSurface->TileType == MOS_TILE_Y) ? true : false;
439 cmd.DW59.BottomFieldSurfaceXOffsetForU = cmd.DW30.OutputSurfaceXOffsetForU;
440 cmd.DW59.BottomFieldSurfaceYOffsetForU = cmd.DW30.OutputSurfaceYOffsetForU;
441 cmd.DW60.BottomFieldSurfaceXOffsetForV = cmd.DW31.OutputSurfaceXOffsetForV;
442 cmd.DW60.BottomFieldSurfaceYOffsetForV = cmd.DW31.OutputSurfaceYOffsetForV;
443 }
444
445 return MOS_STATUS_SUCCESS;
446 }
447
448 //!
449 //! \brief SetSfcStateDithering
450 //! Sets DW3.DitherEnable and DW50-DW53 LUT deltas.
451 //!
452 template <typename cmd_t>
453 inline void SetSfcStateDithering(
454 typename cmd_t::SFC_STATE_CMD &cmd,
455 const SFC_STATE_PAR &params)
456 {
457 // update dithering setting
458 cmd.DW3.DitherEnable = params.ditheringEn;
459 if (cmd.DW3.DitherEnable)
460 {
461 cmd.DW50.DitheringLutDelta12 = 0;
462 cmd.DW50.DitheringLutDelta13 = 1;
463 cmd.DW50.DitheringLutDelta14 = 1;
464 cmd.DW50.DitheringLutDelta15 = 1;
465
466 cmd.DW51.DitheringLutDelta8 = 0;
467 cmd.DW51.DitheringLutDelta9 = 1;
468 cmd.DW51.DitheringLutDelta10 = 1;
469 cmd.DW51.DitheringLutDelta11 = 0;
470
471 cmd.DW52.DitheringLutDelta4 = 0;
472 cmd.DW52.DitheringLutDelta5 = 1;
473 cmd.DW52.DitheringLutDelta6 = 0;
474 cmd.DW52.DitheringLutDelta7 = 0;
475
476 cmd.DW53.DitheringLutDelta0 = 0;
477 cmd.DW53.DitheringLutDelta1 = 0;
478 cmd.DW53.DitheringLutDelta2 = 0;
479 cmd.DW53.DitheringLutDelta3 = 0;
480 }
481 }
482
483 //!
484 //! \brief SetSfcStateScalability
485 //! Handles the entire m_sfcScalabilityEnabled block with parameterized
486 //! MaxPipeNum and SfcIndex constants.
487 //! maxPipeNum: maximum number of SFC pipes
488 //! sfcIndex0/1/2: platform-specific SFC index constants
489 //!
490 template <typename cmd_t>
491 inline void SetSfcStateScalability(
492 typename cmd_t::SFC_STATE_CMD &cmd,
493 const SFC_STATE_PAR &params,
494 bool sfcScalabilityEnabled,
495 uint32_t numofSfc,
496 uint32_t indexofSfc,
497 uint32_t maxPipeNum,
498 uint32_t sfcIndex0,
499 uint32_t sfcIndex1,
500 uint32_t sfcIndex2)
501 {
502 if (!sfcScalabilityEnabled)
503 {
504 return;
505 }
506
507 // Use a fixed upper bound for array sizes to avoid VLAs
508 const uint32_t MAX_PIPE_NUM_UPPER_BOUND = 4;
509 uint32_t iMediumX;
510 uint32_t xOffset;
511 uint32_t src_startX[MAX_PIPE_NUM_UPPER_BOUND];
512 uint32_t src_endX[MAX_PIPE_NUM_UPPER_BOUND];
513 uint32_t dest_startX[MAX_PIPE_NUM_UPPER_BOUND];
514 uint32_t dest_endX[MAX_PIPE_NUM_UPPER_BOUND];
515 uint32_t tile_endX;
516 uint32_t dest_first_valid_left_tile = 0;
517 uint32_t dest_last_valid_right_tile = numofSfc - 1;
518 uint32_t dest_cntX = 0;
519 double xLandingpoint;
520 uint32_t one_by_sf = (uint32_t)(((uint64_t)params.dwSourceRegionWidth * 524288L) / params.dwScaledRegionWidth);
521 const uint32_t one_by_sf_fraction_precision = 19;
522 const uint32_t beta_precision = 5;
523 int32_t xPhaseShift;
524 double tempDestCntx;
525 uint32_t i;
526
527 MHW_ASSERT(params.dwInputFrameWidth > numofSfc * 64);
528
529 iMediumX = MOS_ALIGN_FLOOR((params.dwInputFrameWidth / numofSfc), 64);
530 iMediumX = MOS_CLAMP_MIN_MAX(iMediumX, 64, (params.dwInputFrameWidth - 64));
531
532 src_startX[0] = dest_startX[0] = 0;
533
534 for (i = 0; i < numofSfc; i++)
535 {
536 if (i == numofSfc - 1)
537 {
538 src_endX[i] = params.dwInputFrameWidth - 1;
539 }
540 else
541 {
542 src_endX[i] = iMediumX * (i + 1) - 1;
543 if (params.dwInputFrameWidth != numofSfc * iMediumX)
544 {
545 src_endX[i] += 64;
546 }
547 }
548
549 if (params.dwSourceRegionHorizontalOffset + params.dwSourceRegionWidth - 1 <= src_endX[i])
550 {
551 xOffset = 0;
552 tile_endX = params.dwSourceRegionHorizontalOffset + params.dwSourceRegionWidth - 1;
553 }
554 else
555 {
556 xOffset = VALUE_XOFFSET;
557 tile_endX = src_endX[i];
558 }
559
560 while (1)
561 {
562 if (src_endX[i] - params.dwSourceRegionHorizontalOffset < (xOffset + 1))
563 {
564 dest_endX[i] = 0;
565 break;
566 }
567
568 if (dest_cntX == 0)
569 {
570 dest_first_valid_left_tile = i;
571 }
572
573 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));
574 tempDestCntx = (((double)dest_cntX * (double)one_by_sf) + xPhaseShift);
575 if (tempDestCntx < 0)
576 {
577 tempDestCntx = 0;
578 }
579 xLandingpoint = (double)(((tempDestCntx + ((double)(1 << (one_by_sf_fraction_precision - beta_precision - 1)))) / 524288.0F) + params.dwSourceRegionHorizontalOffset);
580
581 if (xLandingpoint >= (double)(tile_endX - xOffset))
582 {
583 dest_endX[i] = dest_cntX - 1;
584 break;
585 }
586 else
587 {
588 dest_cntX++;
589 }
590
591 if (xOffset == 0)
592 {
593 dest_last_valid_right_tile = i;
594 dest_endX[i] = params.dwScaledRegionWidth - 1;
595 break;
596 }
597 }
598 }
599
600 for (i = 1; i < numofSfc; i++)
601 {
602 src_startX[i] = src_endX[i - 1] + 1 - 64;
603
604 if (i <= dest_first_valid_left_tile)
605 {
606 dest_startX[i] = 0;
607 }
608 else if (i <= dest_last_valid_right_tile)
609 {
610 dest_startX[i] = dest_endX[i - 1] + 1;
611 }
612 else
613 {
614 dest_startX[i] = 0;
615 dest_endX[i] = 0;
616 }
617 }
618
619 // Set SFC Engine Mode
620 if (numofSfc == 2)
621 {
622 if (indexofSfc == sfcIndex0)
623 {
624 cmd.DW1.SfcEngineMode = 1;
625 }
626 else
627 {
628 cmd.DW1.SfcEngineMode = 2;
629 }
630 }
631 else if (numofSfc == 3)
632 {
633 if (indexofSfc == sfcIndex0)
634 {
635 cmd.DW1.SfcEngineMode = 1;
636 }
637 else if (indexofSfc == sfcIndex1)
638 {
639 cmd.DW1.SfcEngineMode = 3;
640 }
641 else
642 {
643 cmd.DW1.SfcEngineMode = 2;
644 }
645 }
646 else if (numofSfc == 4)
647 {
648 if (indexofSfc == sfcIndex0)
649 {
650 cmd.DW1.SfcEngineMode = 1;
651 }
652 else if (indexofSfc == sfcIndex1 ||
653 indexofSfc == sfcIndex2)
654 {
655 cmd.DW1.SfcEngineMode = 3;
656 }
657 else
658 {
659 cmd.DW1.SfcEngineMode = 2;
660 }
661 }
662
663 if (indexofSfc < dest_first_valid_left_tile)
664 {
665 cmd.DW4.ColorFillEnable = 0;
666 }
667 else if (indexofSfc > dest_last_valid_right_tile)
668 {
669 cmd.DW4.ColorFillEnable = 0;
670 }
671
672 if (params.bIEFEnable)
673 {
674 if (dest_startX[indexofSfc] >= 4)
675 {
676 dest_startX[indexofSfc] -= 4;
677 }
678 else
679 {
680 dest_startX[indexofSfc] = 0;
681 }
682 }
683
684 if (VpHalDDIUtils::GetSurfaceColorPack(params.OutputFrameFormat) != VPHAL_COLORPACK_444 &&
685 (dest_startX[indexofSfc] % 2 != 0))
686 {
687 if (dest_startX[indexofSfc] >= 1)
688 {
689 dest_startX[indexofSfc] -= 1;
690 }
691 else
692 {
693 dest_startX[indexofSfc] = 0;
694 }
695 }
696
697 cmd.DW34.Sourcestartx = src_startX[indexofSfc];
698 cmd.DW34.Sourceendx = src_endX[indexofSfc];
699 cmd.DW35.Destinationstartx = dest_startX[indexofSfc];
700 cmd.DW35.Destinationendx = dest_endX[indexofSfc];
701
702 MHW_NORMALMESSAGE("SFC%d STATE: src startx %d endx %d", indexofSfc, cmd.DW34.Sourcestartx, cmd.DW34.Sourceendx);
703 MHW_NORMALMESSAGE("SFC%d STATE: dest startx %d endx %d", indexofSfc, cmd.DW35.Destinationstartx, cmd.DW35.Destinationendx);
704 }
705
706 //!
707 //! \brief SetSfcStateRectangle
708 //! Handles the bRectangleEnabled DW61-DW62 block.
709 //! Used by Group B and Group C platforms.
710 //!
711 template <typename cmd_t>
712 inline void SetSfcStateRectangle(
713 typename cmd_t::SFC_STATE_CMD &cmd,
714 const SFC_STATE_PAR &params)
715 {
716 if (params.bRectangleEnabled)
717 {
718 cmd.DW61.TargetRectangleStartHorizontalOffset = params.dwTargetRectangleStartHorizontalOffset;
719 cmd.DW61.TargetRectangleStartVerticalOffset = params.dwTargetRectangleStartVerticalOffset;
720 cmd.DW62.TargetRectangleEndHorizontalOffset = params.dwTargetRectangleEndHorizontalOffset - 1; // target rectangle end offsets are considered as zero based for hw
721 cmd.DW62.TargetRectangleEndVerticalOffset = params.dwTargetRectangleEndVerticalOffset - 1; // target rectangle end offsets are considered as zero based for hw
722 }
723 else
724 {
725 cmd.DW61.TargetRectangleStartHorizontalOffset = 0;
726 cmd.DW61.TargetRectangleStartVerticalOffset = 0;
727 cmd.DW62.TargetRectangleEndHorizontalOffset = cmd.DW7.OutputFrameWidth; // target rectangle end offsets are considered as zero based for hw
728 cmd.DW62.TargetRectangleEndVerticalOffset = cmd.DW7.OutputFrameHeight; // target rectangle end offsets are considered as zero based for hw
729 }
730 }
731
732 } // namespace common
733 } // namespace sfc
734 } // namespace mhw
735
736 #endif // __MHW_SFC_COMMON_IMPL_H__