1 /*
2 * Copyright (c) 2015-2020, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file mhw_sfc_g12_X.cpp
24 //! \brief Constructs sfc commands on Gen12-based platforms
25 //! \details Each client facing function both creates a HW command and adds
26 //! that command to a command or batch buffer.
27 //!
28
29 #include "mhw_sfc_g12_X.h"
30
AddSfcLock(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_LOCK_PARAMS pSfcLockParams)31 MOS_STATUS MhwSfcInterfaceG12::AddSfcLock(
32 PMOS_COMMAND_BUFFER pCmdBuffer,
33 PMHW_SFC_LOCK_PARAMS pSfcLockParams)
34 {
35 MHW_CHK_NULL_RETURN(pCmdBuffer);
36 MHW_CHK_NULL_RETURN(pSfcLockParams);
37
38 mhw_sfc_g12_X::SFC_LOCK_CMD cmd, *cmdPtr;
39 cmdPtr = (mhw_sfc_g12_X::SFC_LOCK_CMD *)pCmdBuffer->pCmdPtr;
40
41 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcLock(pCmdBuffer, pSfcLockParams));
42
43 if (pSfcLockParams->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
44 {
45 MHW_CHK_NULL_RETURN(cmdPtr);
46 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
47 }
48
49 return MOS_STATUS_SUCCESS;
50 }
51
AddSfcState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_STATE_PARAMS pSfcStateParams,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)52 MOS_STATUS MhwSfcInterfaceG12::AddSfcState(
53 PMOS_COMMAND_BUFFER pCmdBuffer,
54 PMHW_SFC_STATE_PARAMS pSfcStateParams,
55 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)
56 {
57 PMOS_INTERFACE pOsInterface;
58 bool bHalfPitchForChroma;
59 bool bInterleaveChroma;
60 uint16_t wUXOffset;
61 uint16_t wUYOffset;
62 uint16_t wVXOffset;
63 uint16_t wVYOffset;
64 MHW_RESOURCE_PARAMS ResourceParams;
65 MEDIA_WA_TABLE *pWaTable = nullptr;
66
67 PMHW_SFC_STATE_PARAMS_G12 pSfcStateParamsG12 = static_cast<PMHW_SFC_STATE_PARAMS_G12>(pSfcStateParams);
68 mhw_sfc_g12_X::SFC_STATE_CMD cmd;
69
70 MHW_CHK_NULL_RETURN(pCmdBuffer);
71 MHW_CHK_NULL_RETURN(pSfcStateParams);
72 MHW_CHK_NULL_RETURN(pOutSurface);
73
74 pOsInterface = m_osInterface;
75 MHW_CHK_NULL_RETURN(pOsInterface);
76 pWaTable = pOsInterface->pfnGetWaTable(pOsInterface);
77 MHW_CHK_NULL_RETURN(pWaTable);
78
79 bHalfPitchForChroma = false;
80 bInterleaveChroma = false;
81 wUXOffset = 0;
82 wUYOffset = 0;
83 wVXOffset = 0;
84 wVYOffset = 0;
85
86 // Check input/output size
87 MHW_ASSERT(pSfcStateParamsG12->dwInputFrameWidth >= m_minWidth);
88 MHW_ASSERT(pSfcStateParamsG12->dwInputFrameHeight >= m_minHeight);
89 MHW_ASSERT(pSfcStateParamsG12->dwOutputFrameWidth <= m_maxWidth);
90 MHW_ASSERT(pSfcStateParamsG12->dwOutputFrameHeight <= m_maxHeight);
91
92 // Set DW0
93 if (pSfcStateParamsG12->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
94 {
95 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHCPSFCMODE;
96 }
97 else
98 {
99 cmd.DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMFXVEBOXSFCMODE;
100 }
101
102 // Set DW1
103 cmd.DW1.SfcPipeMode = pSfcStateParamsG12->sfcPipeMode;
104 cmd.DW1.SfcInputChromaSubSampling = pSfcStateParamsG12->dwInputChromaSubSampling;
105 cmd.DW1.VdVeInputOrderingMode = pSfcStateParamsG12->dwVDVEInputOrderingMode;
106 cmd.DW1.SfcEngineMode = pSfcStateParamsG12->engineMode;
107 cmd.DW1.SfcInputStreamBitDepth = pSfcStateParamsG12->inputBitDepth;
108
109 // Set DW2
110 cmd.DW2.InputFrameResolutionWidth = pSfcStateParamsG12->dwInputFrameWidth - 1;
111 cmd.DW2.InputFrameResolutionHeight = pSfcStateParamsG12->dwInputFrameHeight - 1;
112
113 // Set DW3
114 cmd.DW3.OutputChromaDownsamplingCoSitingPositionVerticalDirection = pSfcStateParamsG12->dwChromaDownSamplingVerticalCoef;
115 cmd.DW3.OutputChromaDownsamplingCoSitingPositionHorizontalDirection = pSfcStateParamsG12->dwChromaDownSamplingHorizontalCoef;
116 cmd.DW3.InputColorSpace0Yuv1Rgb = pSfcStateParamsG12->bInputColorSpace;
117
118 switch(pSfcStateParamsG12->OutputFrameFormat)
119 {
120 case Format_AYUV:
121 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_AYUV;
122 break;
123 case Format_X8R8G8B8:
124 case Format_A8R8G8B8:
125 case Format_X8B8G8R8:
126 case Format_A8B8G8R8:
127 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A8B8G8R8;
128 break;
129 case Format_R10G10B10A2:
130 case Format_B10G10R10A2:
131 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_A2R10G10B10;
132 break;
133 case Format_R5G6B5:
134 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_R5G6B5;
135 break;
136 case Format_NV12:
137 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_NV12;
138 bInterleaveChroma = true;
139 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
140 break;
141 case Format_YUY2:
142 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_YUYV;
143 break;
144 case Format_UYVY:
145 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_UYVY;
146 break;
147 case Format_P010:
148 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_P016;
149 cmd.DW4.Bitdepth = 0;
150 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
151 break;
152 case Format_P016:
153 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_P016;
154 cmd.DW4.Bitdepth = 1;
155 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
156 break;
157 case Format_Y210:
158 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y216;
159 cmd.DW4.Bitdepth = 0;
160 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
161 break;
162 case Format_Y216:
163 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y216;
164 cmd.DW4.Bitdepth = 1;
165 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
166 break;
167 case Format_Y410:
168 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y416;
169 cmd.DW4.Bitdepth = 0;
170 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
171 break;
172 case Format_Y416:
173 cmd.DW3.OutputSurfaceFormatType = cmd.OUTPUT_SURFACE_FORMAT_TYPE_Y416;
174 cmd.DW4.Bitdepth = 1;
175 wUYOffset = (uint16_t)pOutSurface->dwUYoffset;
176 break;
177 default:
178 MHW_ASSERTMESSAGE("Unknown Output Format.");
179 return MOS_STATUS_UNKNOWN;
180
181 }
182
183 // RGBASwapEnable is true when the OutputSurfaceFormatType is set as A8B8G8R8 for X8R8G8B8 and A8R8G8B8 output,
184 // and the OutputSurfaceFormatType is set as A2R10G10B10 for R10G10B10A2 output.
185 cmd.DW3.RgbaChannelSwapEnable = pSfcStateParamsG12->bRGBASwapEnable;
186
187 // Set DW4
188 cmd.DW4.IefEnable = pSfcStateParamsG12->bIEFEnable;
189 cmd.DW4.SkinToneTunedIefEnable = pSfcStateParamsG12->bSkinToneTunedIEFEnable;
190 cmd.DW4.AvsFilterMode = pSfcStateParamsG12->dwAVSFilterMode;
191 if (pSfcStateParamsG12->b8tapChromafiltering)
192 {
193 cmd.DW4.AdaptiveFilterForAllChannels = true;
194 }
195 else
196 {
197 cmd.DW4.AdaptiveFilterForAllChannels = false;
198 }
199
200 cmd.DW4.AvsScalingEnable = ((pSfcStateParamsG12->fAVSXScalingRatio == 1.0F) &&
201 (pSfcStateParamsG12->fAVSYScalingRatio == 1.0F)) ? false : true;
202 cmd.DW4.BypassYAdaptiveFiltering = pSfcStateParamsG12->bBypassYAdaptiveFilter;
203 cmd.DW4.BypassXAdaptiveFiltering = pSfcStateParamsG12->bBypassXAdaptiveFilter;
204 cmd.DW4.ChromaUpsamplingEnable = pSfcStateParamsG12->bAVSChromaUpsamplingEnable;
205 cmd.DW4.RotationMode = pSfcStateParamsG12->RotationMode;
206 cmd.DW4.ColorFillEnable = pSfcStateParamsG12->bColorFillEnable;
207 cmd.DW4.CscEnable = pSfcStateParamsG12->bCSCEnable;
208 cmd.DW4.Enable8TapForChromaChannelsFiltering = pSfcStateParamsG12->b8tapChromafiltering;
209 cmd.DW4.TileType = pSfcStateParamsG12->tileType;
210 cmd.DW4.RgbAdaptive = pSfcStateParamsG12->bRGBAdaptive;
211
212 if (pSfcStateParams->bMirrorEnable)
213 {
214 cmd.DW4.Value |= (uint32_t)(1 << 14) & 0x00004000; // Mirror Mode
215 cmd.DW4.Value |= (uint32_t)(pSfcStateParams->dwMirrorType << 13) & 0x00002000; // Mirror Type
216 }
217
218 // Set DW5, DW6, DW7, DW8, DW9
219 cmd.DW5.SourceRegionWidth = pSfcStateParamsG12->dwSourceRegionWidth - 1;
220 cmd.DW5.SourceRegionHeight = pSfcStateParamsG12->dwSourceRegionHeight - 1;
221 cmd.DW6.SourceRegionHorizontalOffset = pSfcStateParamsG12->dwSourceRegionHorizontalOffset;
222 cmd.DW6.SourceRegionVerticalOffset = pSfcStateParamsG12->dwSourceRegionVerticalOffset;
223 cmd.DW7.OutputFrameWidth = pSfcStateParamsG12->dwOutputFrameWidth + pOutSurface->dwSurfaceXOffset - 1;
224 cmd.DW7.OutputFrameHeight = pSfcStateParamsG12->dwOutputFrameHeight + pOutSurface->dwSurfaceYOffset - 1;
225 cmd.DW8.ScaledRegionSizeWidth = pSfcStateParamsG12->dwScaledRegionWidth - 1;
226 cmd.DW8.ScaledRegionSizeHeight = pSfcStateParamsG12->dwScaledRegionHeight - 1;
227 cmd.DW9.ScaledRegionHorizontalOffset = pSfcStateParamsG12->dwScaledRegionHorizontalOffset + pOutSurface->dwSurfaceXOffset;
228 cmd.DW9.ScaledRegionVerticalOffset = pSfcStateParamsG12->dwScaledRegionVerticalOffset + pOutSurface->dwSurfaceYOffset;
229
230 // Set DW10
231 cmd.DW10.GrayBarPixelUG = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateParamsG12->fColorFillUGPixel * 1024.0F), 0, 1023); // U10
232 cmd.DW10.GrayBarPixelYR = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateParamsG12->fColorFillYRPixel * 1024.0F), 0, 1023); // U10
233
234 // Set DW11
235 cmd.DW11.GrayBarPixelA = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateParamsG12->fColorFillAPixel * 1024.0F), 0, 1023); // U10
236 cmd.DW11.GrayBarPixelVB = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateParamsG12->fColorFillVBPixel * 1024.0F), 0, 1023); // U10
237
238 // Set DW13
239 cmd.DW13.AlphaDefaultValue = MOS_CLAMP_MIN_MAX(MOS_F_ROUND(pSfcStateParamsG12->fAlphaPixel * 1024.0F), 0, 1023); // U10
240
241 // Set DW14
242 cmd.DW14.ScalingFactorHeight = MOS_UF_ROUND((double)pSfcStateParamsG12->dwSourceRegionHeight / (double)pSfcStateParamsG12->dwScaledRegionHeight * 524288.0F); // U4.19
243
244 // Set DW15
245 cmd.DW15.ScalingFactorWidth = MOS_UF_ROUND((double)pSfcStateParamsG12->dwSourceRegionWidth / (double)pSfcStateParamsG12->dwScaledRegionWidth * 524288.0F); // U4.19
246
247 // Set DW19
248 if (pSfcStateParamsG12->MMCMode == MOS_MMC_RC || pSfcStateParamsG12->MMCMode == MOS_MMC_MC)
249 {
250 cmd.DW19.OutputFrameSurfaceBaseAddressMemoryCompressionEnable = pSfcStateParamsG12->bMMCEnable;
251 }
252 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = m_outputSurfCtrl.Gen12.Index;
253 if (pOutSurface->pOsResource)
254 {
255 pOutSurface->pOsResource->memObjCtrlState.DwordValue = m_outputSurfCtrl.Value;
256 }
257 cmd.DW19.OutputFrameSurfaceBaseAddressMemoryCompressionMode = (pSfcStateParamsG12->MMCMode == MOS_MMC_RC) ? 1 : 0;
258
259 switch (pSfcStateParamsG12->tileType)
260 {
261 case MOS_TILE_YF:
262 cmd.DW19.OutputSurfaceTiledMode = TRMODE_TILEYF;
263 break;
264 case MOS_TILE_YS:
265 cmd.DW19.OutputSurfaceTiledMode = TRMODE_TILEYS;
266 break;
267 default:
268 cmd.DW19.OutputSurfaceTiledMode = TRMODE_NONE;
269 break;
270 }
271
272 // Set DW29
273 cmd.DW29.OutputSurfaceTileWalk = (pOutSurface->TileType == MOS_TILE_Y) ?
274 true : false;
275 cmd.DW29.OutputSurfaceTiled = (pOutSurface->TileType != MOS_TILE_LINEAR) ?
276 true : false;
277 cmd.DW29.OutputSurfaceHalfPitchForChroma
278 = bHalfPitchForChroma;
279 cmd.DW29.OutputSurfacePitch = pOutSurface->dwPitch - 1;
280 cmd.DW29.OutputSurfaceInterleaveChromaEnable
281 = bInterleaveChroma;
282 cmd.DW29.OutputSurfaceFormat = cmd.DW3.OutputSurfaceFormatType;
283
284 // Set DW30, DW31
285 cmd.DW30.OutputSurfaceYOffsetForU = wUYOffset;
286 cmd.DW30.OutputSurfaceXOffsetForU = wUXOffset;
287 cmd.DW31.OutputSurfaceYOffsetForV = wVYOffset;
288 cmd.DW31.OutputSurfaceXOffsetForV = wVXOffset;
289
290 // DW34, DW35
291 cmd.DW34.SourceStartX = pSfcStateParamsG12->srcStartX;
292 cmd.DW34.SourceEndX = pSfcStateParamsG12->srcEndX;
293 cmd.DW35.DestinationStartX = pSfcStateParamsG12->dstStartX;
294 cmd.DW35.DestinationEndX = pSfcStateParamsG12->dstEndX;
295
296 // Set DW36, DW37
297 //Change SFC outputcentering scaling X/Yphaseshift value and limition limitione with 19bit following Fuslim setting.
298 if (m_outputCenteringEnable)
299 {
300 cmd.DW36.Xphaseshift = MOS_CLAMP_MIN_MAX(MOS_F_ROUND((((double)cmd.DW15.ScalingFactorWidth / 524288.0F - 1.0) / 2.0) * 524288.0F), -(1 << (4 + 19)), ((1 << (4 + 19)) - 1));
301 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));
302 }
303
304 if (pSfcStateParamsG12->pOsResOutputSurface)
305 {
306 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
307 InitMocsParams(ResourceParams, &cmd.DW19.Value, 1, 6);
308 ResourceParams.presResource = pSfcStateParamsG12->pOsResOutputSurface;
309 ResourceParams.pdwCmd = &(cmd.DW17.Value);
310 ResourceParams.dwLocationInCmd = 17;
311 ResourceParams.HwCommandType = MOS_SFC_STATE;
312 ResourceParams.bIsWritable = true;
313 ResourceParams.dwOffset = pSfcStateParamsG12->dwOutputSurfaceOffset;
314
315 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
316 pOsInterface,
317 pCmdBuffer,
318 &ResourceParams));
319 if (m_outputSurfCtrl.Gen12.Index != 0)
320 {
321 cmd.DW19.OutputFrameSurfaceBaseAddressIndexToMemoryObjectControlStateMocsTables = m_outputSurfCtrl.Gen12.Index;
322 }
323 }
324
325 if (pSfcStateParamsG12->pOsResAVSLineBuffer)
326 {
327 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
328 InitMocsParams(ResourceParams, &cmd.DW22.Value, 1, 6);
329 ResourceParams.presResource = pSfcStateParamsG12->pOsResAVSLineBuffer;
330 ResourceParams.pdwCmd = &(cmd.DW20.Value);
331 ResourceParams.dwLocationInCmd = 20;
332 ResourceParams.HwCommandType = MOS_SFC_STATE;
333 ResourceParams.bIsWritable = true;
334 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
335 pOsInterface,
336 pCmdBuffer,
337 &ResourceParams));
338 if (m_avsLineBufferCtrl.Gen12.Index != 0)
339 {
340 cmd.DW22.AvsLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineBufferCtrl.Gen12.Index;
341 }
342 }
343
344 if (pSfcStateParamsG12->pOsResIEFLineBuffer)
345 {
346 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
347 InitMocsParams(ResourceParams, &cmd.DW25.Value, 1, 6);
348 ResourceParams.presResource = pSfcStateParamsG12->pOsResIEFLineBuffer;
349 ResourceParams.pdwCmd = &(cmd.DW23.Value);
350 ResourceParams.dwLocationInCmd = 23;
351 ResourceParams.HwCommandType = MOS_SFC_STATE;
352 ResourceParams.bIsWritable = true;
353
354 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
355 pOsInterface,
356 pCmdBuffer,
357 &ResourceParams));
358 if (m_iefLineBufferCtrl.Gen12.Index != 0)
359 {
360 cmd.DW25.IefLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineBufferCtrl.Gen12.Index;
361 }
362 }
363
364 if (pSfcStateParamsG12->resSfdLineBuffer && !Mos_ResourceIsNull(pSfcStateParamsG12->resSfdLineBuffer))
365 {
366 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
367 InitMocsParams(ResourceParams, &cmd.DW28.Value, 1, 6);
368 ResourceParams.presResource = pSfcStateParamsG12->resSfdLineBuffer;
369 ResourceParams.pdwCmd = &(cmd.DW26.Value);
370 ResourceParams.dwLocationInCmd = 26;
371 ResourceParams.HwCommandType = MOS_SFC_STATE;
372 ResourceParams.bIsWritable = true;
373
374 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
375 pOsInterface,
376 pCmdBuffer,
377 &ResourceParams));
378 if (m_sfdLineBufferCtrl.Gen12.Index != 0)
379 {
380 cmd.DW28.SfdLineBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineBufferCtrl.Gen12.Index;
381 }
382 }
383
384 if (pSfcStateParamsG12->resAvsLineTileBuffer && !Mos_ResourceIsNull(pSfcStateParamsG12->resAvsLineTileBuffer))
385 {
386 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
387 InitMocsParams(ResourceParams, &cmd.DW40.Value, 1, 6);
388 ResourceParams.presResource = pSfcStateParamsG12->resAvsLineTileBuffer;
389 ResourceParams.pdwCmd = &(cmd.DW38.Value);
390 ResourceParams.dwLocationInCmd = 38;
391 ResourceParams.HwCommandType = MOS_SFC_STATE;
392 ResourceParams.bIsWritable = true;
393
394 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
395 pOsInterface,
396 pCmdBuffer,
397 &ResourceParams));
398
399 if (m_avsLineTileBufferCtrl.Gen12.Index != 0)
400 {
401 cmd.DW40.AvsLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_avsLineTileBufferCtrl.Gen12.Index;
402 }
403 }
404
405 if (pSfcStateParamsG12->resIefLineTileBuffer && !Mos_ResourceIsNull(pSfcStateParamsG12->resIefLineTileBuffer))
406 {
407 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
408 InitMocsParams(ResourceParams, &cmd.DW43.Value, 1, 6);
409 ResourceParams.presResource = pSfcStateParamsG12->resIefLineTileBuffer;
410 ResourceParams.pdwCmd = &(cmd.DW41.Value);
411 ResourceParams.dwLocationInCmd = 41;
412 ResourceParams.HwCommandType = MOS_SFC_STATE;
413 ResourceParams.bIsWritable = true;
414
415 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
416 pOsInterface,
417 pCmdBuffer,
418 &ResourceParams));
419
420 if (m_iefLineTileBufferCtrl.Gen12.Index != 0)
421 {
422 cmd.DW43.IefLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_iefLineTileBufferCtrl.Gen12.Index;
423 }
424 }
425
426 if (pSfcStateParamsG12->resSfdLineTileBuffer && !Mos_ResourceIsNull(pSfcStateParamsG12->resSfdLineTileBuffer))
427 {
428 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
429 InitMocsParams(ResourceParams, &cmd.DW46.Value, 1, 6);
430 ResourceParams.presResource = pSfcStateParamsG12->resSfdLineTileBuffer;
431 ResourceParams.pdwCmd = &(cmd.DW44.Value);
432 ResourceParams.dwLocationInCmd = 44;
433 ResourceParams.HwCommandType = MOS_SFC_STATE;
434 ResourceParams.bIsWritable = true;
435
436 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
437 pOsInterface,
438 pCmdBuffer,
439 &ResourceParams));
440
441 if (m_sfdLineTileBufferCtrl.Gen12.Index != 0)
442 {
443 cmd.DW46.SfdLineTileBufferBaseAddressIndexToMemoryObjectControlStateMocsTables = m_sfdLineTileBufferCtrl.Gen12.Index;
444 }
445 }
446
447 if (pSfcStateParamsG12->histogramSurface && !Mos_ResourceIsNull(&pSfcStateParamsG12->histogramSurface->OsResource))
448 {
449 cmd.DW4.HistogramStreamout = 1;
450 cmd.DW49.Value = 0;
451
452 MOS_ZeroMemory(&ResourceParams, sizeof(ResourceParams));
453 ResourceParams.presResource = &pSfcStateParamsG12->histogramSurface->OsResource;
454 ResourceParams.dwOffset = pSfcStateParamsG12->histogramSurface->dwOffset;
455 ResourceParams.pdwCmd = &(cmd.DW47.Value);
456 ResourceParams.dwLocationInCmd = 47;
457 ResourceParams.HwCommandType = MOS_SFC_STATE;
458 ResourceParams.bIsWritable = true;
459 InitMocsParams(ResourceParams, &cmd.DW49.Value, 1, 6);
460
461 MHW_CHK_STATUS_RETURN(pfnAddResourceToCmd(
462 pOsInterface,
463 pCmdBuffer,
464 &ResourceParams));
465
466 if (m_histogramBufferCtrl.Gen12.Index != 0)
467 {
468 cmd.DW49.HistogramBaseAddressMOCSIndex = m_histogramBufferCtrl.Gen12.Index;
469 }
470 }
471
472 MHW_CHK_STATUS_RETURN(pOsInterface->pfnAddCommand(pCmdBuffer, &cmd, cmd.byteSize));
473
474 return MOS_STATUS_SUCCESS;
475 }
476
AddSfcAvsState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_STATE pSfcAvsState)477 MOS_STATUS MhwSfcInterfaceG12::AddSfcAvsState(
478 PMOS_COMMAND_BUFFER pCmdBuffer,
479 PMHW_SFC_AVS_STATE pSfcAvsState)
480 {
481 MHW_CHK_NULL_RETURN(pCmdBuffer);
482 MHW_CHK_NULL_RETURN(pSfcAvsState);
483 mhw_sfc_g12_X::SFC_AVS_STATE_CMD cmd, *cmdPtr;
484 cmdPtr = (mhw_sfc_g12_X::SFC_AVS_STATE_CMD *)pCmdBuffer->pCmdPtr;
485
486 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcAvsState(pCmdBuffer, pSfcAvsState));
487
488 MHW_CHK_NULL_RETURN(cmdPtr);
489 if (pSfcAvsState->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
490 {
491 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
492 }
493 else
494 {
495 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAMFXVEBOXSFCMODE;
496 }
497
498 cmdPtr->DW3.InputHorizontalSitingValueSpecifiesTheHorizontalSitingOfTheInput = pSfcAvsState->dwInputHorizontalSiting;
499 cmdPtr->DW3.InputVerticalSitingSpecifiesTheVerticalSitingOfTheInput = pSfcAvsState->dwInputVerticalSitting;
500
501 return MOS_STATUS_SUCCESS;
502 }
503
AddSfcFrameStart(PMOS_COMMAND_BUFFER pCmdBuffer,uint8_t sfcPipeMode)504 MOS_STATUS MhwSfcInterfaceG12::AddSfcFrameStart(
505 PMOS_COMMAND_BUFFER pCmdBuffer,
506 uint8_t sfcPipeMode)
507 {
508 MHW_CHK_NULL_RETURN(pCmdBuffer);
509 mhw_sfc_g12_X::SFC_FRAME_START_CMD cmd, *cmdPtr;
510 cmdPtr = (mhw_sfc_g12_X::SFC_FRAME_START_CMD *)pCmdBuffer->pCmdPtr;
511
512 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcFrameStart(pCmdBuffer, sfcPipeMode));
513 MHW_CHK_NULL_RETURN(cmdPtr);
514 if (sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
515 {
516 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
517 }
518 return MOS_STATUS_SUCCESS;
519 }
520
AddSfcIefState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_IEF_STATE_PARAMS pSfcIefStateParams)521 MOS_STATUS MhwSfcInterfaceG12::AddSfcIefState(
522 PMOS_COMMAND_BUFFER pCmdBuffer,
523 PMHW_SFC_IEF_STATE_PARAMS pSfcIefStateParams)
524 {
525 MHW_CHK_NULL_RETURN(pCmdBuffer);
526 MHW_CHK_NULL_RETURN(pSfcIefStateParams);
527
528 mhw_sfc_g12_X::SFC_IEF_STATE_CMD cmd, *cmdPtr;
529 cmdPtr = (mhw_sfc_g12_X::SFC_IEF_STATE_CMD *)pCmdBuffer->pCmdPtr;
530
531 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcIefState(pCmdBuffer, pSfcIefStateParams));
532
533 if (pSfcIefStateParams->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP)
534 {
535 MHW_CHK_NULL_RETURN(cmdPtr);
536 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
537 }
538
539 return MOS_STATUS_SUCCESS;
540 }
541
AddSfcAvsChromaTable(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_CHROMA_TABLE pChromaTable)542 MOS_STATUS MhwSfcInterfaceG12::AddSfcAvsChromaTable(
543 PMOS_COMMAND_BUFFER pCmdBuffer,
544 PMHW_SFC_AVS_CHROMA_TABLE pChromaTable)
545 {
546 MHW_CHK_NULL_RETURN(pCmdBuffer);
547 MHW_CHK_NULL_RETURN(pChromaTable);
548
549 mhw_sfc_g12_X::SFC_AVS_CHROMA_Coeff_Table_CMD cmd, *cmdPtr;
550 cmdPtr = (mhw_sfc_g12_X::SFC_AVS_CHROMA_Coeff_Table_CMD *)pCmdBuffer->pCmdPtr;
551 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcAvsChromaTable(pCmdBuffer, pChromaTable));
552
553 if (pChromaTable->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP) // HCP-to-SFC
554 {
555 MHW_CHK_NULL_RETURN(cmdPtr);
556 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
557 }
558
559 return MOS_STATUS_SUCCESS;
560 }
561
AddSfcAvsLumaTable(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_LUMA_TABLE pLumaTable)562 MOS_STATUS MhwSfcInterfaceG12::AddSfcAvsLumaTable(
563 PMOS_COMMAND_BUFFER pCmdBuffer,
564 PMHW_SFC_AVS_LUMA_TABLE pLumaTable)
565 {
566 MHW_CHK_NULL_RETURN(pCmdBuffer);
567 MHW_CHK_NULL_RETURN(pLumaTable);
568
569 mhw_sfc_g12_X::SFC_AVS_LUMA_Coeff_Table_CMD cmd, *cmdPtr;
570 cmdPtr = (mhw_sfc_g12_X::SFC_AVS_LUMA_Coeff_Table_CMD *)pCmdBuffer->pCmdPtr;
571 MHW_CHK_STATUS_RETURN(MhwSfcInterfaceGeneric::AddSfcAvsLumaTable(pCmdBuffer, pLumaTable));
572
573 if (pLumaTable->sfcPipeMode == MhwSfcInterfaceG12::SFC_PIPE_MODE_HCP) // HCP-to-SFC
574 {
575 MHW_CHK_NULL_RETURN(cmdPtr);
576 cmdPtr->DW0.MediaCommandOpcode = cmd.MEDIA_COMMAND_OPCODE_MEDIAHEVCSFCMODE;
577 }
578
579 return MOS_STATUS_SUCCESS;
580 }
581
SetSfcSamplerTable(PMHW_SFC_AVS_LUMA_TABLE pLumaTable,PMHW_SFC_AVS_CHROMA_TABLE pChromaTable,PMHW_AVS_PARAMS pAvsParams,MOS_FORMAT SrcFormat,float fScaleX,float fScaleY,uint32_t dwChromaSiting,bool bUse8x8Filter,float fHPStrength,float fLanczosT)582 MOS_STATUS MhwSfcInterfaceG12 :: SetSfcSamplerTable(
583 PMHW_SFC_AVS_LUMA_TABLE pLumaTable,
584 PMHW_SFC_AVS_CHROMA_TABLE pChromaTable,
585 PMHW_AVS_PARAMS pAvsParams,
586 MOS_FORMAT SrcFormat,
587 float fScaleX,
588 float fScaleY,
589 uint32_t dwChromaSiting,
590 bool bUse8x8Filter,
591 float fHPStrength,
592 float fLanczosT)
593 {
594 int32_t *piYCoefsX, *piYCoefsY;
595 int32_t *piUVCoefsX, *piUVCoefsY;
596 MHW_PLANE Plane;
597
598 MHW_CHK_NULL_RETURN(pLumaTable);
599 MHW_CHK_NULL_RETURN(pChromaTable);
600 MHW_CHK_NULL_RETURN(pAvsParams);
601
602 fHPStrength = 0.0F;
603 piYCoefsX = pAvsParams->piYCoefsX;
604 piYCoefsY = pAvsParams->piYCoefsY;
605 piUVCoefsX = pAvsParams->piUVCoefsX;
606 piUVCoefsY = pAvsParams->piUVCoefsY;
607
608 // Skip calculation if no changes to AVS parameters
609 if (SrcFormat == pAvsParams->Format &&
610 fScaleX == pAvsParams->fScaleX &&
611 fScaleY == pAvsParams->fScaleY)
612 {
613 return MOS_STATUS_SUCCESS;
614 }
615
616 // AVS Coefficients don't change for Scaling Factors > 1.0x
617 // Hence recalculation is avoided
618 if (fScaleX > 1.0F && pAvsParams->fScaleX > 1.0F)
619 {
620 pAvsParams->fScaleX = fScaleX;
621 }
622
623 // AVS Coefficients don't change for Scaling Factors > 1.0x
624 // Hence recalculation is avoided
625 if (fScaleY > 1.0F && pAvsParams->fScaleY > 1.0F)
626 {
627 pAvsParams->fScaleY = fScaleY;
628 }
629
630 // Recalculate Horizontal scaling table
631 if (SrcFormat != pAvsParams->Format || fScaleX != pAvsParams->fScaleX || pAvsParams->bUse8x8Filter != bUse8x8Filter)
632 {
633 MOS_ZeroMemory(
634 piYCoefsX,
635 8 * 32 * sizeof(int32_t));
636
637 MOS_ZeroMemory(
638 piUVCoefsX,
639 4 * 32 * sizeof(int32_t));
640
641 Plane = (IS_RGB32_FORMAT(SrcFormat) && !bUse8x8Filter) ? MHW_U_PLANE : MHW_Y_PLANE;
642
643 pAvsParams->fScaleX = fScaleX;
644
645 if (m_scalingMode == MHW_SCALING_NEAREST)
646 {
647 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
648 piYCoefsX,
649 Plane,
650 true));
651 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
652 piUVCoefsX,
653 MHW_U_PLANE,
654 true));
655 }
656 else
657 {
658 // For 1x scaling in horizontal direction and not force polyphase coefs, use special coefficients for filtering
659 if ((fScaleX == 1.0F && !pAvsParams->bForcePolyPhaseCoefs))
660 {
661 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
662 piYCoefsX,
663 Plane,
664 true));
665
666 // The 8-tap adaptive is enabled for all channel if RGB format input, then UV/RB use the same coefficient as Y/G
667 // So, coefficient for UV/RB channels caculation can be passed
668 if ((!(IS_RGB32_FORMAT(SrcFormat) && bUse8x8Filter)))
669 {
670 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
671 piUVCoefsX,
672 MHW_U_PLANE,
673 true));
674 }
675 }
676 else
677 {
678 // Clamp the Scaling Factor if > 1.0x
679 fScaleX = MOS_MIN(1.0F, fScaleX);
680
681 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesY(
682 piYCoefsX,
683 fScaleX,
684 Plane,
685 SrcFormat,
686 fHPStrength,
687 bUse8x8Filter,
688 NUM_HW_POLYPHASE_TABLES,
689 0));
690 }
691
692 // The 8-tap adaptive is enabled for all channel if RGB format input, then UV/RB use the same coefficient as Y/G
693 // So, coefficient for UV/RB channels caculation can be passed
694 if (!(IS_RGB32_FORMAT(SrcFormat) && bUse8x8Filter))
695 {
696 // If Chroma Siting info is present
697 if (dwChromaSiting & MHW_CHROMA_SITING_HORZ_LEFT)
698 {
699 // No Chroma Siting
700 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUV(
701 piUVCoefsX,
702 2.0F,
703 fScaleX));
704 }
705 else
706 {
707 // Chroma siting offset will be add in the HW cmd
708 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUV(
709 piUVCoefsX,
710 3.0F,
711 fScaleX));
712 }
713 }
714 }
715 }
716
717 // Recalculate Vertical scaling table
718 if (SrcFormat != pAvsParams->Format || fScaleY != pAvsParams->fScaleY || pAvsParams->bUse8x8Filter != bUse8x8Filter)
719 {
720 memset((void *)piYCoefsY, 0, 8 * 32 * sizeof(int32_t));
721
722 memset((void *)piUVCoefsY, 0, 4 * 32 * sizeof(int32_t));
723
724 Plane = (IS_RGB32_FORMAT(SrcFormat) && !bUse8x8Filter) ? MHW_U_PLANE : MHW_Y_PLANE;
725
726 pAvsParams->fScaleY = fScaleY;
727
728 if (m_scalingMode == MHW_SCALING_NEAREST)
729 {
730 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
731 piYCoefsY,
732 Plane,
733 true));
734 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
735 piUVCoefsY,
736 MHW_U_PLANE,
737 true));
738 }
739 else
740 {
741 // For 1x scaling in vertical direction and not force polyphase coefs, use special coefficients for filtering
742 if ((fScaleY == 1.0F && !pAvsParams->bForcePolyPhaseCoefs))
743 {
744 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
745 piYCoefsY,
746 Plane,
747 true));
748
749 // The 8-tap adaptive is enabled for all channel if RGB format input, then UV/RB use the same coefficient as Y/G
750 // So, coefficient for UV/RB channels caculation can be passed
751 if ((!(IS_RGB32_FORMAT(SrcFormat) && bUse8x8Filter)))
752 {
753 MHW_CHK_STATUS_RETURN(Mhw_SetNearestModeTable(
754 piUVCoefsY,
755 MHW_U_PLANE,
756 true));
757 }
758 }
759 else
760 {
761 // Clamp the Scaling Factor if > 1.0x
762 fScaleY = MOS_MIN(1.0F, fScaleY);
763
764 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesY(
765 piYCoefsY,
766 fScaleY,
767 Plane,
768 SrcFormat,
769 fHPStrength,
770 bUse8x8Filter,
771 NUM_HW_POLYPHASE_TABLES, 0));
772 }
773
774 // The 8-tap adaptive is enabled for all channel if RGB format input, then UV/RB use the same coefficient as Y/G
775 // So, coefficient for UV/RB channels caculation can be passed
776 if (!(IS_RGB32_FORMAT(SrcFormat) && bUse8x8Filter))
777 {
778 // If Chroma Siting info is present
779 if (dwChromaSiting & MHW_CHROMA_SITING_VERT_TOP)
780 {
781 // No Chroma Siting
782 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUV(
783 piUVCoefsY,
784 2.0F,
785 fScaleY));
786 }
787 else
788 {
789 // Chroma siting offset will be add in the HW cmd
790 MHW_CHK_STATUS_RETURN(Mhw_CalcPolyphaseTablesUV(
791 piUVCoefsY,
792 3.0F,
793 fScaleY));
794 }
795 }
796 }
797 }
798
799 // Save format used to calculate AVS parameters
800 pAvsParams->Format = SrcFormat;
801 // Need to recaculate if use8x8Filter changed
802 pAvsParams->bUse8x8Filter = bUse8x8Filter;
803
804 MhwSfcInterface::SetSfcAVSLumaTable(
805 SrcFormat,
806 pLumaTable->LumaTable,
807 piYCoefsX,
808 piYCoefsY,
809 bUse8x8Filter);
810
811 MhwSfcInterface::SetSfcAVSChromaTable(
812 pChromaTable->ChromaTable,
813 piUVCoefsX,
814 piUVCoefsY);
815
816 return MOS_STATUS_SUCCESS;
817 }
818
MhwSfcInterfaceG12(PMOS_INTERFACE pOsInterface)819 MhwSfcInterfaceG12::MhwSfcInterfaceG12(PMOS_INTERFACE pOsInterface) : MhwSfcInterfaceGeneric(pOsInterface)
820 {
821 if (m_osInterface == nullptr)
822 {
823 MHW_ASSERTMESSAGE("Invalid Input Parameter: m_osInterface is nullptr");
824 return;
825 }
826
827 // Get Memory control object directly from MOS.
828 // If any override is needed, something like pfnOverrideMemoryObjectCtrl() / pfnComposeSurfaceCacheabilityControl()
829 // will need to be implemented.
830 m_outputSurfCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
831 MOS_MHW_RESOURCE_USAGE_Sfc_CurrentOutputSurface,
832 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
833
834 m_avsLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
835 MOS_MHW_RESOURCE_USAGE_Sfc_AvsLineBufferSurface,
836 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
837 m_iefLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
838 MOS_MHW_RESOURCE_USAGE_Sfc_IefLineBufferSurface,
839 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
840 m_sfdLineBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
841 MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED,
842 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
843 m_avsLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
844 MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED,
845 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
846 m_iefLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
847 MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED,
848 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
849 m_sfdLineTileBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
850 MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED,
851 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
852 m_histogramBufferCtrl.Value = m_osInterface->pfnCachePolicyGetMemoryObject(
853 MOS_CODEC_RESOURCE_USAGE_SURFACE_UNCACHED,
854 m_osInterface->pfnGetGmmClientContext(m_osInterface)).DwordValue;
855
856 m_maxWidth = MHW_SFC_MAX_WIDTH_G12;
857 m_maxHeight = MHW_SFC_MAX_HEIGHT_G12;
858 }
859
IsOutPutCenterEnable(bool inputEnable)860 void MhwSfcInterfaceG12::IsOutPutCenterEnable(bool inputEnable)
861 {
862 m_outputCenteringEnable = inputEnable;
863 }
864