1 /*
2 * Copyright (c) 2018-2024, Intel Corporation
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice shall be included
12 * in all copies or substantial portions of the Software.
13 *
14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
20 * OTHER DEALINGS IN THE SOFTWARE.
21 */
22 //!
23 //! \file vp_render_sfc_base.cpp
24 //! \brief SFC rendering component
25 //! \details The SFC renderer supports Scaling, IEF, CSC/ColorFill and Rotation.
26 //! It's responsible for setting up HW states and generating the SFC
27 //! commands.
28 //!
29
30 #include "vp_render_sfc_base_legacy.h"
31 #include "vp_utils.h"
32 #include "mhw_vebox.h"
33 #include "mhw_sfc.h"
34 #include "vp_render_ief.h"
35 #include "vp_hal_ddi_utils.h"
36 #include "mos_interface.h"
37
38 namespace vp {
39
SfcRenderBaseLegacy(VP_MHWINTERFACE & vpMhwinterface,PVpAllocator & allocator,bool disbaleSfcDithering)40 SfcRenderBaseLegacy::SfcRenderBaseLegacy(
41 VP_MHWINTERFACE &vpMhwinterface,
42 PVpAllocator &allocator,
43 bool disbaleSfcDithering) :
44 SfcRenderBase(vpMhwinterface, allocator, disbaleSfcDithering)
45 {
46 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(vpMhwinterface.m_sfcInterface);
47 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(vpMhwinterface.m_mhwMiInterface);
48
49 m_miInterface = vpMhwinterface.m_mhwMiInterface;
50 m_sfcInterface = vpMhwinterface.m_sfcInterface;
51 }
52
~SfcRenderBaseLegacy()53 SfcRenderBaseLegacy::~SfcRenderBaseLegacy()
54 {
55 if (m_sfcStateParamsLegacy)
56 {
57 MOS_FreeMemAndSetNull(m_sfcStateParamsLegacy);
58 }
59 }
60
Init()61 MOS_STATUS SfcRenderBaseLegacy::Init()
62 {
63 VP_FUNC_CALL();
64
65 MOS_ZeroMemory(&m_renderDataLegacy, sizeof(m_renderDataLegacy));
66
67 m_pipeMode = MhwSfcInterface::SFC_PIPE_MODE_VEBOX;
68
69 m_scalabilityParams.numPipe = 1;
70 m_scalabilityParams.curPipe = 0;
71
72 MOS_ZeroMemory(&m_histogramSurf, sizeof(m_histogramSurf));
73
74 return InitSfcStateParams();
75 }
76
Init(VIDEO_PARAMS & videoParams)77 MOS_STATUS SfcRenderBaseLegacy::Init(VIDEO_PARAMS& videoParams)
78 {
79 VP_FUNC_CALL();
80
81 MOS_ZeroMemory(&m_renderDataLegacy, sizeof(m_renderDataLegacy));
82 //InitRenderData();
83 m_bVdboxToSfc = true;
84
85 m_videoConfig = videoParams;
86
87 m_videoConfig.scalabilityParams.numPipe = (0 == m_videoConfig.scalabilityParams.numPipe ? 1 : m_videoConfig.scalabilityParams.numPipe);
88 if (m_videoConfig.scalabilityParams.curPipe >= m_videoConfig.scalabilityParams.numPipe)
89 {
90 VP_RENDER_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
91 }
92
93 m_scalabilityParams = m_videoConfig.scalabilityParams;
94
95 VP_PUBLIC_CHK_STATUS_RETURN(SetCodecPipeMode(m_videoConfig.codecStandard));
96
97 MOS_ZeroMemory(&m_histogramSurf, sizeof(m_histogramSurf));
98
99 return InitSfcStateParams();
100 }
101
102
SetRotationAndMirrowParams(PMHW_SFC_STATE_PARAMS psfcStateParams)103 void SfcRenderBaseLegacy::SetRotationAndMirrowParams(PMHW_SFC_STATE_PARAMS psfcStateParams)
104 {
105 VP_FUNC_CALL();
106
107 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(psfcStateParams);
108
109 psfcStateParams->RotationMode = (MHW_ROTATION)m_renderDataLegacy.SfcRotation;
110 psfcStateParams->bMirrorEnable = m_renderDataLegacy.bMirrorEnable;
111 psfcStateParams->dwMirrorType = m_renderDataLegacy.mirrorType;
112 }
113
SetChromasitingParams(PMHW_SFC_STATE_PARAMS psfcStateParams)114 void SfcRenderBaseLegacy::SetChromasitingParams(PMHW_SFC_STATE_PARAMS psfcStateParams)
115 {
116 VP_FUNC_CALL();
117
118 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(psfcStateParams);
119 SetSfcStateInputChromaSubSampling(psfcStateParams);
120 SetSfcStateInputOrderingMode(psfcStateParams);
121 }
122
SetColorFillParams(PMHW_SFC_STATE_PARAMS psfcStateParams)123 void SfcRenderBaseLegacy::SetColorFillParams(
124 PMHW_SFC_STATE_PARAMS psfcStateParams)
125 {
126 VP_FUNC_CALL();
127
128 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(m_renderDataLegacy.pColorFillParams);
129
130 psfcStateParams->bColorFillEnable = m_renderDataLegacy.pColorFillParams->bColorfillEnable;
131
132 if (psfcStateParams->bColorFillEnable)
133 {
134 psfcStateParams->fColorFillYRPixel = m_renderDataLegacy.pColorFillParams->fColorFillYRPixel;
135 psfcStateParams->fColorFillUGPixel = m_renderDataLegacy.pColorFillParams->fColorFillUGPixel;
136 psfcStateParams->fColorFillVBPixel = m_renderDataLegacy.pColorFillParams->fColorFillVBPixel;
137 psfcStateParams->fColorFillAPixel = m_renderDataLegacy.pColorFillParams->fColorFillAPixel;
138 }
139 }
140
SetXYAdaptiveFilter(PMHW_SFC_STATE_PARAMS psfcStateParams)141 void SfcRenderBaseLegacy::SetXYAdaptiveFilter(
142 PMHW_SFC_STATE_PARAMS psfcStateParams)
143 {
144 VP_FUNC_CALL();
145
146 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(psfcStateParams);
147
148 // Enable Adaptive Filtering for YUV input only, if it is being upscaled
149 // in either direction. We must check for this before clamping the SF.
150 if ((IS_YUV_FORMAT(m_renderDataLegacy.SfcInputFormat) ||
151 m_renderDataLegacy.SfcInputFormat == Format_AYUV) &&
152 (m_renderDataLegacy.fScaleX > 1.0F ||
153 m_renderDataLegacy.fScaleY > 1.0F) &&
154 psfcStateParams->dwAVSFilterMode != MEDIASTATE_SFC_AVS_FILTER_BILINEAR)
155 {
156 //For AVS, we need set psfcStateParams->bBypassXAdaptiveFilter and bBypassYAdaptiveFilter as false;
157 psfcStateParams->bBypassXAdaptiveFilter = false;
158 psfcStateParams->bBypassYAdaptiveFilter = false;
159 }
160 else
161 {
162 psfcStateParams->bBypassXAdaptiveFilter = true;
163 psfcStateParams->bBypassYAdaptiveFilter = true;
164 }
165 }
166
SetRGBAdaptive(PMHW_SFC_STATE_PARAMS psfcStateParams)167 void SfcRenderBaseLegacy::SetRGBAdaptive(
168 PMHW_SFC_STATE_PARAMS psfcStateParams)
169 {
170 VP_FUNC_CALL();
171
172 VP_PUBLIC_CHK_NULL_NO_STATUS_RETURN(psfcStateParams);
173
174 if (IS_RGB_FORMAT(m_renderDataLegacy.SfcInputFormat) &&
175 psfcStateParams->b8tapChromafiltering == true)
176 {
177 psfcStateParams->bRGBAdaptive = true;
178 }
179 else
180 {
181 psfcStateParams->bRGBAdaptive = false;
182 }
183 }
184
SetIefStateCscParams(PMHW_SFC_STATE_PARAMS psfcStateParams,PMHW_SFC_IEF_STATE_PARAMS pIEFStateParams)185 MOS_STATUS SfcRenderBaseLegacy::SetIefStateCscParams(
186 PMHW_SFC_STATE_PARAMS psfcStateParams,
187 PMHW_SFC_IEF_STATE_PARAMS pIEFStateParams)
188 {
189 VP_FUNC_CALL();
190
191 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
192
193 VP_RENDER_CHK_NULL_RETURN(psfcStateParams);
194 VP_RENDER_CHK_NULL_RETURN(pIEFStateParams);
195
196 if (m_renderDataLegacy.bCSC)
197 {
198 psfcStateParams->bCSCEnable = true;
199 pIEFStateParams->bCSCEnable = true;
200 if (m_bVdboxToSfc)
201 {
202 m_cscInputSwapNeeded = false;
203 if (m_videoConfig.jpeg.jpegChromaType == jpegRGB && m_videoConfig.codecStandard == CODECHAL_JPEG)
204 {
205 m_cscCoeff[0] = 1.000000000f;
206 m_cscCoeff[1] = 0.000000000f;
207 m_cscCoeff[2] = 0.000000000f;
208 m_cscCoeff[3] = 0.000000000f;
209 m_cscCoeff[4] = 1.000000000f;
210 m_cscCoeff[5] = 0.000000000f;
211 m_cscCoeff[6] = 0.000000000f;
212 m_cscCoeff[7] = 0.000000000f;
213 m_cscCoeff[8] = 1.000000000f;
214
215 m_cscInOffset[0] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
216 m_cscInOffset[1] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
217 m_cscInOffset[2] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
218 }
219 else
220 {
221 if (m_renderDataLegacy.SfcInputFormat != Format_400P)
222 {
223 m_cscCoeff[0] = 1.16438353f;
224 m_cscCoeff[1] = 0.000000000f;
225 m_cscCoeff[2] = 1.59602666f;
226 m_cscCoeff[3] = 1.16438353f;
227 m_cscCoeff[4] = -0.391761959f;
228 m_cscCoeff[5] = -0.812967300f;
229 m_cscCoeff[6] = 1.16438353f;
230 m_cscCoeff[7] = 2.01723218f;
231 m_cscCoeff[8] = 0.000000000f;
232 }
233 else
234 {
235 m_cscCoeff[0] = 1.16438353f;
236 m_cscCoeff[1] = 0.000000000f;
237 m_cscCoeff[2] = 0.000000000f;
238 m_cscCoeff[3] = 1.16438353f;
239 m_cscCoeff[4] = 0.000000000f;
240 m_cscCoeff[5] = 0.000000000f;
241 m_cscCoeff[6] = 1.16438353f;
242 m_cscCoeff[7] = 0.000000000f;
243 m_cscCoeff[8] = 0.000000000f;
244 }
245 m_cscInOffset[0] = -16.000000f; // Adjusted to S8.2 to accommodate VPHAL
246 m_cscInOffset[1] = -128.000000f; // Adjusted to S8.2 to accommodate VPHAL
247 m_cscInOffset[2] = -128.000000f; // Adjusted to S8.2 to accommodate VPHAL
248 }
249 m_cscOutOffset[0] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
250 m_cscOutOffset[1] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
251 m_cscOutOffset[2] = 0.000000000f; // Adjusted to S8.2 to accommodate VPHAL
252 }
253 else if ((m_cscInputCspace != m_renderDataLegacy.SfcInputCspace) ||
254 (m_renderDataLegacy.pSfcPipeOutSurface && m_cscRTCspace != m_renderDataLegacy.pSfcPipeOutSurface->ColorSpace))
255 {
256 VpUtils::GetCscMatrixForVeSfc8Bit(
257 m_renderDataLegacy.SfcInputCspace,
258 m_renderDataLegacy.pSfcPipeOutSurface->ColorSpace,
259 m_cscCoeff,
260 m_cscInOffset,
261 m_cscOutOffset);
262
263 // swap the 1st and 3rd columns of the transfer matrix for A8R8G8B8 and X8R8G8B8
264 // to ensure SFC input being A8B8G8R8.
265 if (IsInputChannelSwapNeeded(m_renderDataLegacy.SfcInputFormat))
266 {
267 float fTemp[3] = {};
268 fTemp[0] = m_cscCoeff[0];
269 fTemp[1] = m_cscCoeff[3];
270 fTemp[2] = m_cscCoeff[6];
271
272 m_cscCoeff[0] = m_cscCoeff[2];
273 m_cscCoeff[3] = m_cscCoeff[5];
274 m_cscCoeff[6] = m_cscCoeff[8];
275
276 m_cscCoeff[2] = fTemp[0];
277 m_cscCoeff[5] = fTemp[1];
278 m_cscCoeff[8] = fTemp[2];
279 m_cscInputSwapNeeded = true;
280 }
281 else
282 {
283 m_cscInputSwapNeeded = false;
284 }
285
286 VP_RENDER_NORMALMESSAGE("sfc csc coeff calculated. (sfcInputCspace, cscRTCspace) current (%d, %d), previous (%d, %d) swap flag %d",
287 m_renderDataLegacy.SfcInputCspace, m_renderDataLegacy.pSfcPipeOutSurface->ColorSpace,
288 m_cscInputCspace, m_cscRTCspace, m_cscInputSwapNeeded ? 1 :0);
289
290 m_cscInputCspace = m_renderDataLegacy.SfcInputCspace;
291 m_cscRTCspace = m_renderDataLegacy.pSfcPipeOutSurface->ColorSpace;
292 }
293 else if (m_cscInputSwapNeeded != IsInputChannelSwapNeeded(m_renderDataLegacy.SfcInputFormat))
294 {
295 float fTemp[3] = {};
296 fTemp[0] = m_cscCoeff[0];
297 fTemp[1] = m_cscCoeff[3];
298 fTemp[2] = m_cscCoeff[6];
299
300 m_cscCoeff[0] = m_cscCoeff[2];
301 m_cscCoeff[3] = m_cscCoeff[5];
302 m_cscCoeff[6] = m_cscCoeff[8];
303
304 m_cscCoeff[2] = fTemp[0];
305 m_cscCoeff[5] = fTemp[1];
306 m_cscCoeff[8] = fTemp[2];
307
308 m_cscInputSwapNeeded = IsInputChannelSwapNeeded(m_renderDataLegacy.SfcInputFormat);
309
310 VP_RENDER_NORMALMESSAGE("sfc csc coeff swap flag need be updated to %d. sfcInputFormat %d, sfcInputCspace %d, cscRTCspace %d",
311 (m_cscInputSwapNeeded ? 1 : 0),
312 m_renderDataLegacy.SfcInputFormat, m_cscInputCspace, m_cscRTCspace);
313 }
314 else
315 {
316 VP_RENDER_NORMALMESSAGE("sfc csc coeff reused. sfcInputFormat %d, sfcInputCspace %d, cscRTCspace %d, swap flag %d",
317 m_renderDataLegacy.SfcInputFormat, m_cscInputCspace, m_cscRTCspace, (m_cscInputSwapNeeded ? 1 : 0));
318 }
319
320 pIEFStateParams->pfCscCoeff = m_cscCoeff;
321 pIEFStateParams->pfCscInOffset = m_cscInOffset;
322 pIEFStateParams->pfCscOutOffset = m_cscOutOffset;
323 }
324 return eStatus;
325 }
326
SetIefStateParams(PMHW_SFC_STATE_PARAMS psfcStateParams)327 MOS_STATUS SfcRenderBaseLegacy::SetIefStateParams(
328 PMHW_SFC_STATE_PARAMS psfcStateParams)
329 {
330 VP_FUNC_CALL();
331
332 PMHW_SFC_IEF_STATE_PARAMS pIefStateParams = nullptr;
333 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
334
335 VP_RENDER_CHK_NULL_RETURN(psfcStateParams);
336
337 pIefStateParams = &m_IefStateParamsLegacy;
338 MOS_ZeroMemory(pIefStateParams, sizeof(*pIefStateParams));
339 pIefStateParams->sfcPipeMode = m_pipeMode;
340
341 // Setup IEF and STE params
342 if (m_renderDataLegacy.bIEF && m_renderDataLegacy.pIefParams)
343 {
344 VP_RENDER_CHK_NULL_RETURN(m_iefObj);
345 m_iefObj->Init(m_renderDataLegacy.pIefParams, m_renderDataLegacy.SfcInputFormat, m_renderDataLegacy.fScaleX, m_renderDataLegacy.fScaleY);
346 m_iefObj->SetHwState(psfcStateParams, pIefStateParams);
347 } // end of setup IEF and STE params
348
349 // Setup CSC params
350 VP_RENDER_CHK_STATUS_RETURN(SetIefStateCscParams(
351 psfcStateParams,
352 pIefStateParams));
353
354 return eStatus;
355 }
356
SetAvsStateParams()357 MOS_STATUS SfcRenderBaseLegacy::SetAvsStateParams()
358 {
359 VP_FUNC_CALL();
360
361 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
362 PMHW_SFC_AVS_STATE pMhwAvsState = nullptr;
363 MHW_SCALING_MODE scalingMode = MHW_SCALING_AVS;
364 bool bUse8x8Filter = false;
365
366 pMhwAvsState = &m_avsStateLegacy.AvsStateParams;
367 MOS_ZeroMemory(pMhwAvsState, sizeof(MHW_SFC_AVS_STATE));
368 pMhwAvsState->sfcPipeMode = m_pipeMode;
369
370 if (m_renderDataLegacy.bScaling ||
371 m_renderDataLegacy.bForcePolyPhaseCoefs)
372 {
373 if (m_renderDataLegacy.SfcSrcChromaSiting == MHW_CHROMA_SITING_NONE)
374 {
375 if (VpHalDDIUtils::GetSurfaceColorPack(m_renderDataLegacy.SfcInputFormat) == VPHAL_COLORPACK_420) // For 420, default is Left & Center, else default is Left & Top
376 {
377 m_renderDataLegacy.SfcSrcChromaSiting = MHW_CHROMA_SITING_HORZ_LEFT | MHW_CHROMA_SITING_VERT_CENTER;
378 }
379 else
380 {
381 m_renderDataLegacy.SfcSrcChromaSiting = MHW_CHROMA_SITING_HORZ_LEFT | MHW_CHROMA_SITING_VERT_TOP;
382 }
383 }
384
385 pMhwAvsState->dwInputHorizontalSiting = (m_renderDataLegacy.SfcSrcChromaSiting & MHW_CHROMA_SITING_HORZ_CENTER) ? SFC_AVS_INPUT_SITING_COEF_4_OVER_8 : ((m_renderDataLegacy.SfcSrcChromaSiting & MHW_CHROMA_SITING_HORZ_RIGHT) ? SFC_AVS_INPUT_SITING_COEF_8_OVER_8 : SFC_AVS_INPUT_SITING_COEF_0_OVER_8);
386
387 pMhwAvsState->dwInputVerticalSitting = (m_renderDataLegacy.SfcSrcChromaSiting & MHW_CHROMA_SITING_VERT_CENTER) ? SFC_AVS_INPUT_SITING_COEF_4_OVER_8 : ((m_renderDataLegacy.SfcSrcChromaSiting & MHW_CHROMA_SITING_VERT_BOTTOM) ? SFC_AVS_INPUT_SITING_COEF_8_OVER_8 : SFC_AVS_INPUT_SITING_COEF_0_OVER_8);
388
389 if (m_renderDataLegacy.SfcScalingMode == VPHAL_SCALING_NEAREST)
390 {
391 scalingMode = MHW_SCALING_NEAREST;
392 }
393 else if (m_renderDataLegacy.SfcScalingMode == VPHAL_SCALING_BILINEAR)
394 {
395 scalingMode = MHW_SCALING_BILINEAR;
396 }
397 else
398 {
399 scalingMode = MHW_SCALING_AVS;
400 }
401 VP_RENDER_CHK_STATUS_RETURN(SetSfcAVSScalingMode(scalingMode));
402
403 if (m_renderDataLegacy.sfcStateParams)
404 {
405 pMhwAvsState->dwAVSFilterMode = m_renderDataLegacy.sfcStateParams->dwAVSFilterMode;
406 }
407 else
408 {
409 pMhwAvsState->dwAVSFilterMode = MEDIASTATE_SFC_AVS_FILTER_8x8;
410 }
411
412 if (pMhwAvsState->dwAVSFilterMode == MEDIASTATE_SFC_AVS_FILTER_8x8)
413 {
414 bUse8x8Filter = true;
415 }
416
417 m_avsStateLegacy.LumaCoeffs.sfcPipeMode = m_pipeMode;
418 m_avsStateLegacy.ChromaCoeffs.sfcPipeMode = m_pipeMode;
419
420 VP_RENDER_CHK_STATUS_RETURN(SetSfcSamplerTable(
421 &m_avsStateLegacy.LumaCoeffs,
422 &m_avsStateLegacy.ChromaCoeffs,
423 m_renderDataLegacy.pAvsParams,
424 m_renderDataLegacy.SfcInputFormat,
425 m_renderDataLegacy.fScaleX,
426 m_renderDataLegacy.fScaleY,
427 m_renderDataLegacy.SfcSrcChromaSiting,
428 bUse8x8Filter,
429 0,
430 0));
431 }
432
433 return eStatus;
434 }
435
SetupSfcState(PVP_SURFACE targetSurface)436 MOS_STATUS SfcRenderBaseLegacy::SetupSfcState(PVP_SURFACE targetSurface)
437 {
438 VP_FUNC_CALL();
439
440 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
441
442 VP_RENDER_CHK_NULL_RETURN(targetSurface);
443 VP_RENDER_CHK_NULL_RETURN(targetSurface->osSurface);
444
445 //---------------------------------
446 // Set SFC State: common properties
447 //---------------------------------
448 m_renderDataLegacy.sfcStateParams->sfcPipeMode = (MEDIASTATE_SFC_PIPE_MODE)m_pipeMode;
449
450 m_renderDataLegacy.sfcStateParams->InputFrameFormat = m_renderDataLegacy.SfcInputFormat;
451 m_renderDataLegacy.sfcStateParams->OutputFrameFormat = targetSurface->osSurface->Format;
452 m_renderDataLegacy.sfcStateParams->dwOutputSurfaceOffset = targetSurface->osSurface->YPlaneOffset.iSurfaceOffset;
453 m_renderDataLegacy.sfcStateParams->wOutputSurfaceUXOffset = (uint16_t)targetSurface->osSurface->UPlaneOffset.iXOffset;
454 m_renderDataLegacy.sfcStateParams->wOutputSurfaceUYOffset = (uint16_t)targetSurface->osSurface->UPlaneOffset.iYOffset;
455 m_renderDataLegacy.sfcStateParams->wOutputSurfaceVXOffset = (uint16_t)targetSurface->osSurface->VPlaneOffset.iXOffset;
456 m_renderDataLegacy.sfcStateParams->wOutputSurfaceVYOffset = (uint16_t)targetSurface->osSurface->VPlaneOffset.iYOffset;
457
458 m_renderDataLegacy.pSfcPipeOutSurface = targetSurface;
459 m_renderDataLegacy.pAvsParams = &m_AvsParameters;
460
461 //---------------------------------
462 // Set SFC State: Scaling
463 //---------------------------------
464 m_AvsParameters.bForcePolyPhaseCoefs = m_renderDataLegacy.bForcePolyPhaseCoefs;
465 VP_RENDER_CHK_STATUS_RETURN(SetAvsStateParams());
466 m_renderDataLegacy.sfcStateParams->bAVSChromaUpsamplingEnable = m_renderDataLegacy.bScaling ||
467 m_renderDataLegacy.bForcePolyPhaseCoefs;
468
469 //---------------------------------
470 // Set SFC State: CSC/IEF
471 //---------------------------------
472 if (m_renderDataLegacy.bIEF ||
473 m_renderDataLegacy.bCSC)
474 {
475 VP_RENDER_CHK_STATUS_RETURN(SetIefStateParams(
476 m_renderDataLegacy.sfcStateParams));
477 }
478
479 //---------------------------------
480 // Set SFC State: Rotation/Mirror
481 //---------------------------------
482 SetRotationAndMirrowParams(m_renderDataLegacy.sfcStateParams);
483
484 //---------------------------------
485 // Set SFC State: Chromasiting
486 //---------------------------------
487 SetChromasitingParams(m_renderDataLegacy.sfcStateParams);
488
489 //---------------------------------
490 // Set SFC State: XY Adaptive Filter
491 //---------------------------------
492 SetXYAdaptiveFilter(m_renderDataLegacy.sfcStateParams);
493
494 //---------------------------------
495 // Set SFC State: RGB Adaptive Filter
496 //---------------------------------
497 SetRGBAdaptive(m_renderDataLegacy.sfcStateParams);
498
499 //---------------------------------
500 // Set SFC State: Colorfill
501 //---------------------------------
502 SetColorFillParams(m_renderDataLegacy.sfcStateParams);
503
504 VP_RENDER_CHK_STATUS_RETURN(AllocateResources());
505
506 m_renderDataLegacy.sfcStateParams->pOsResOutputSurface = &targetSurface->osSurface->OsResource;
507
508 if (m_renderData.b1stPassOfSfc2PassScaling)
509 {
510 VP_RENDER_CHK_STATUS_RETURN(SetLineBuffer(m_renderDataLegacy.sfcStateParams->pOsResAVSLineBuffer, m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass[m_scalabilityParams.curPipe]));
511 VP_RENDER_CHK_STATUS_RETURN(SetLineBuffer(m_renderDataLegacy.sfcStateParams->pOsResIEFLineBuffer, m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass[m_scalabilityParams.curPipe]));
512 }
513 else
514 {
515 VP_RENDER_CHK_STATUS_RETURN(SetLineBuffer(m_renderDataLegacy.sfcStateParams->pOsResAVSLineBuffer, m_AVSLineBufferSurfaceArray[m_scalabilityParams.curPipe]));
516 VP_RENDER_CHK_STATUS_RETURN(SetLineBuffer(m_renderDataLegacy.sfcStateParams->pOsResIEFLineBuffer, m_IEFLineBufferSurfaceArray[m_scalabilityParams.curPipe]));
517 }
518
519 VP_RENDER_CHK_STATUS_RETURN(SetupScalabilityParams());
520
521 // Decompress resource if surfaces need write from a un-align offset
522 if ((targetSurface->osSurface->CompressionMode != MOS_MMC_DISABLED) &&
523 IsSFCUncompressedWriteNeeded(targetSurface))
524 {
525 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
526 MOS_SURFACE details = {};
527
528 eStatus = m_osInterface->pfnGetResourceInfo(m_osInterface, &targetSurface->osSurface->OsResource, &details);
529
530 if (eStatus != MOS_STATUS_SUCCESS)
531 {
532 VP_RENDER_ASSERTMESSAGE("Get SFC target surface resource info failed.");
533 }
534
535 if (!targetSurface->osSurface->OsResource.bUncompressedWriteNeeded)
536 {
537 eStatus = m_osInterface->pfnDecompResource(m_osInterface, &targetSurface->osSurface->OsResource);
538
539 if (eStatus != MOS_STATUS_SUCCESS)
540 {
541 VP_RENDER_ASSERTMESSAGE("inplace decompression failed for sfc target.");
542 }
543 else
544 {
545 VP_RENDER_NORMALMESSAGE("inplace decompression enabled for sfc target RECT is not compression block align.");
546 targetSurface->osSurface->OsResource.bUncompressedWriteNeeded = 1;
547 }
548 }
549 }
550
551 if (targetSurface->osSurface->OsResource.bUncompressedWriteNeeded)
552 {
553 // Update SFC as uncompressed write
554 m_renderDataLegacy.sfcStateParams->MMCMode = MOS_MMC_RC;
555 }
556
557 return eStatus;
558 }
559
IsSFCUncompressedWriteNeeded(PVP_SURFACE targetSurface)560 bool SfcRenderBaseLegacy::IsSFCUncompressedWriteNeeded(PVP_SURFACE targetSurface)
561 {
562 VP_FUNC_CALL();
563
564 if ((!targetSurface) ||
565 (!targetSurface->osSurface))
566 {
567 return false;
568 }
569
570 if (!MEDIA_IS_SKU(m_skuTable, FtrE2ECompression))
571 {
572 return false;
573 }
574
575 if (m_osInterface && m_osInterface->bSimIsActive)
576 {
577 return false;
578 }
579
580 uint32_t byteInpixel = 1;
581 #if !EMUL
582 if (!targetSurface->osSurface->OsResource.pGmmResInfo)
583 {
584 VP_RENDER_NORMALMESSAGE("IsSFCUncompressedWriteNeeded cannot support non GMM info cases");
585 return false;
586 }
587
588 byteInpixel = targetSurface->osSurface->OsResource.pGmmResInfo->GetBitsPerPixel() >> 3;
589 #endif // !EMUL
590
591 if (byteInpixel == 0)
592 {
593 VP_RENDER_NORMALMESSAGE("surface format is not a valid format for sfc");
594 return false;
595 }
596 uint32_t writeAlignInWidth = 32 / byteInpixel;
597 uint32_t writeAlignInHeight = 8;
598
599
600 if ((targetSurface->rcSrc.top % writeAlignInHeight) ||
601 ((targetSurface->rcSrc.bottom - targetSurface->rcSrc.top) % writeAlignInHeight) ||
602 (targetSurface->rcSrc.left % writeAlignInWidth) ||
603 ((targetSurface->rcSrc.right - targetSurface->rcSrc.left) % writeAlignInWidth))
604 {
605 // full Frame Write don't need decompression as it will not hit the compressed write limitation
606 if ((targetSurface->rcSrc.bottom - targetSurface->rcSrc.top) == targetSurface->osSurface->dwHeight &&
607 (targetSurface->rcSrc.right - targetSurface->rcSrc.left) == targetSurface->osSurface->dwWidth)
608 {
609 return false;
610 }
611
612 VP_RENDER_NORMALMESSAGE(
613 "SFC Render Target Uncompressed write needed, \
614 targetSurface->rcSrc.top % d, \
615 targetSurface->rcSrc.bottom % d, \
616 targetSurface->rcSrc.left % d, \
617 targetSurface->rcSrc.right % d \
618 targetSurface->Format % d",
619 targetSurface->rcSrc.top,
620 targetSurface->rcSrc.bottom,
621 targetSurface->rcSrc.left,
622 targetSurface->rcSrc.right,
623 targetSurface->osSurface->Format);
624
625 return true;
626 }
627
628 return false;
629 }
630
SetScalingParams(PSFC_SCALING_PARAMS scalingParams)631 MOS_STATUS SfcRenderBaseLegacy::SetScalingParams(PSFC_SCALING_PARAMS scalingParams)
632 {
633 VP_FUNC_CALL();
634
635 VP_PUBLIC_CHK_NULL_RETURN(scalingParams);
636
637 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX != m_pipeMode &&
638 (scalingParams->dwInputFrameHeight != scalingParams->dwSourceRegionHeight ||
639 scalingParams->dwInputFrameWidth != scalingParams->dwSourceRegionWidth))
640 {
641 // For Integral Image Mode, this source region width/height is Reserved.
642 // In VD modes, source region width/height must be programmed to same value as input frame resolution width/height.
643 VP_PUBLIC_ASSERTMESSAGE("Source region crop is not supported by Integral Image Mode and VD Mode!!");
644 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
645 }
646
647 // Adjust output width/height according to rotation.
648 if (VPHAL_ROTATION_90 == m_renderDataLegacy.SfcRotation ||
649 VPHAL_ROTATION_270 == m_renderDataLegacy.SfcRotation ||
650 VPHAL_ROTATE_90_MIRROR_VERTICAL == m_renderDataLegacy.SfcRotation ||
651 VPHAL_ROTATE_90_MIRROR_HORIZONTAL == m_renderDataLegacy.SfcRotation)
652 {
653 m_renderDataLegacy.sfcStateParams->dwOutputFrameWidth = scalingParams->dwOutputFrameHeight;
654 m_renderDataLegacy.sfcStateParams->dwOutputFrameHeight = scalingParams->dwOutputFrameWidth;
655 }
656 else
657 {
658 m_renderDataLegacy.sfcStateParams->dwOutputFrameWidth = scalingParams->dwOutputFrameWidth;
659 m_renderDataLegacy.sfcStateParams->dwOutputFrameHeight = scalingParams->dwOutputFrameHeight;
660 }
661
662 m_renderDataLegacy.sfcStateParams->dwInputFrameHeight = scalingParams->dwInputFrameHeight;
663 m_renderDataLegacy.sfcStateParams->dwInputFrameWidth = scalingParams->dwInputFrameWidth;
664 m_renderDataLegacy.sfcStateParams->dwAVSFilterMode = scalingParams->bBilinearScaling ? MEDIASTATE_SFC_AVS_FILTER_BILINEAR : (MhwSfcInterface::SFC_PIPE_MODE_VDBOX == m_pipeMode ? MEDIASTATE_SFC_AVS_FILTER_5x5 : MEDIASTATE_SFC_AVS_FILTER_8x8);
665 m_renderDataLegacy.sfcStateParams->dwSourceRegionHeight = scalingParams->dwSourceRegionHeight;
666 m_renderDataLegacy.sfcStateParams->dwSourceRegionWidth = scalingParams->dwSourceRegionWidth;
667 m_renderDataLegacy.sfcStateParams->dwSourceRegionVerticalOffset = scalingParams->dwSourceRegionVerticalOffset;
668 m_renderDataLegacy.sfcStateParams->dwSourceRegionHorizontalOffset = scalingParams->dwSourceRegionHorizontalOffset;
669 m_renderDataLegacy.sfcStateParams->dwScaledRegionHeight = scalingParams->dwScaledRegionHeight;
670 m_renderDataLegacy.sfcStateParams->dwScaledRegionWidth = scalingParams->dwScaledRegionWidth;
671 m_renderDataLegacy.sfcStateParams->dwScaledRegionVerticalOffset = scalingParams->dwScaledRegionVerticalOffset;
672 m_renderDataLegacy.sfcStateParams->dwScaledRegionHorizontalOffset = scalingParams->dwScaledRegionHorizontalOffset;
673 if (scalingParams->bRectangleEnabled)
674 {
675 m_renderDataLegacy.sfcStateParams->bRectangleEnabled = true;
676 m_renderDataLegacy.sfcStateParams->dwTargetRectangleStartHorizontalOffset = scalingParams->dwTargetRectangleStartHorizontalOffset;
677 m_renderDataLegacy.sfcStateParams->dwTargetRectangleStartVerticalOffset = scalingParams->dwTargetRectangleStartVerticalOffset;
678 m_renderDataLegacy.sfcStateParams->dwTargetRectangleEndHorizontalOffset = scalingParams->dwTargetRectangleEndHorizontalOffset;
679 m_renderDataLegacy.sfcStateParams->dwTargetRectangleEndVerticalOffset = scalingParams->dwTargetRectangleEndVerticalOffset;
680 }
681 else
682 {
683 m_renderDataLegacy.sfcStateParams->bRectangleEnabled = false;
684 }
685 m_renderDataLegacy.sfcStateParams->fAVSXScalingRatio = scalingParams->fAVSXScalingRatio;
686 m_renderDataLegacy.sfcStateParams->fAVSYScalingRatio = scalingParams->fAVSYScalingRatio;
687
688 m_renderDataLegacy.bScaling = ((scalingParams->fAVSXScalingRatio == 1.0F) && (scalingParams->fAVSYScalingRatio == 1.0F)) ? false : true;
689
690 m_renderDataLegacy.fScaleX = scalingParams->fAVSXScalingRatio;
691 m_renderDataLegacy.fScaleY = scalingParams->fAVSYScalingRatio;
692 m_renderDataLegacy.SfcScalingMode = scalingParams->sfcScalingMode;
693
694 // ColorFill/Alpha settings
695 m_renderDataLegacy.pColorFillParams = &(scalingParams->sfcColorfillParams);
696 m_renderDataLegacy.sfcStateParams->fAlphaPixel = scalingParams->sfcColorfillParams.fAlphaPixel;
697 m_renderDataLegacy.sfcStateParams->fColorFillAPixel = scalingParams->sfcColorfillParams.fColorFillAPixel;
698 m_renderDataLegacy.sfcStateParams->fColorFillUGPixel = scalingParams->sfcColorfillParams.fColorFillUGPixel;
699 m_renderDataLegacy.sfcStateParams->fColorFillVBPixel = scalingParams->sfcColorfillParams.fColorFillVBPixel;
700 m_renderDataLegacy.sfcStateParams->fColorFillYRPixel = scalingParams->sfcColorfillParams.fColorFillYRPixel;
701 m_renderDataLegacy.sfcStateParams->isDemosaicEnabled = scalingParams->isDemosaicNeeded;
702
703 // SfcInputFormat should be initialized during SetCscParams if SfcInputFormat not being Format_Any.
704 if (Format_Any == m_renderDataLegacy.SfcInputFormat)
705 {
706 m_renderDataLegacy.SfcInputFormat = scalingParams->inputFrameFormat;
707 }
708 else if (m_renderDataLegacy.SfcInputFormat != scalingParams->inputFrameFormat)
709 {
710 VP_PUBLIC_ASSERTMESSAGE("Input formats configured during SetCscParams and SetScalingParams are not same!");
711 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
712 }
713
714 return MOS_STATUS_SUCCESS;
715 }
716
UpdateIefParams(PVPHAL_IEF_PARAMS iefParams)717 MOS_STATUS SfcRenderBaseLegacy::UpdateIefParams(PVPHAL_IEF_PARAMS iefParams)
718 {
719 VP_FUNC_CALL();
720 m_renderDataLegacy.bIEF = (iefParams &&
721 iefParams->bEnabled &&
722 iefParams->fIEFFactor > 0.0F);
723 m_renderDataLegacy.pIefParams = iefParams;
724 return MOS_STATUS_SUCCESS;
725 }
726
UpdateCscParams(FeatureParamCsc & cscParams)727 MOS_STATUS SfcRenderBaseLegacy::UpdateCscParams(FeatureParamCsc &cscParams)
728 {
729 VP_RENDER_CHK_STATUS_RETURN(UpdateIefParams(cscParams.pIEFParams));
730 return MOS_STATUS_SUCCESS;
731 }
732
SetCSCParams(PSFC_CSC_PARAMS cscParams)733 MOS_STATUS SfcRenderBaseLegacy::SetCSCParams(PSFC_CSC_PARAMS cscParams)
734 {
735 VP_FUNC_CALL();
736
737 VP_PUBLIC_CHK_NULL_RETURN(cscParams);
738
739 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
740 {
741 m_renderDataLegacy.bIEF = cscParams->bIEFEnable;
742 m_renderDataLegacy.pIefParams = cscParams->iefParams;
743 }
744 else
745 {
746 if (cscParams->bIEFEnable)
747 {
748 VP_PUBLIC_ASSERTMESSAGE("IEF is not supported by Integral Image Mode and VD Mode!");
749 }
750 m_renderDataLegacy.bIEF = false;
751 m_renderDataLegacy.pIefParams = nullptr;
752 }
753 m_renderDataLegacy.bCSC = IsCscNeeded(*cscParams);
754 m_renderDataLegacy.SfcInputCspace = cscParams->inputColorSpace;
755 m_renderDataLegacy.SfcInputFormat = cscParams->inputFormat;
756
757 m_renderDataLegacy.sfcStateParams->bRGBASwapEnable = IsOutputChannelSwapNeeded(cscParams->outputFormat);
758 m_renderDataLegacy.sfcStateParams->bInputColorSpace = cscParams->isInputColorSpaceRGB;
759 m_renderDataLegacy.sfcStateParams->isDemosaicEnabled = cscParams->isDemosaicNeeded;
760
761 // Chromasitting config
762 // VEBOX use polyphase coefficients for 1x scaling for better quality,
763 // VDBOX dosen't use polyphase coefficients.
764 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
765 {
766 m_renderDataLegacy.bForcePolyPhaseCoefs = cscParams->bChromaUpSamplingEnable;
767 }
768 else
769 {
770 m_renderDataLegacy.bForcePolyPhaseCoefs = false;
771 }
772 m_renderDataLegacy.SfcSrcChromaSiting = cscParams->sfcSrcChromaSiting;
773
774 // 8-Tap chroma filter enabled or not
775 m_renderDataLegacy.sfcStateParams->b8tapChromafiltering = cscParams->b8tapChromafiltering;
776
777 // config SFC chroma down sampling
778 m_renderDataLegacy.sfcStateParams->dwChromaDownSamplingHorizontalCoef = cscParams->chromaDownSamplingHorizontalCoef;
779 m_renderDataLegacy.sfcStateParams->dwChromaDownSamplingVerticalCoef = cscParams->chromaDownSamplingVerticalCoef;
780
781 return MOS_STATUS_SUCCESS;
782 }
783
SetRotMirParams(PSFC_ROT_MIR_PARAMS rotMirParams)784 MOS_STATUS SfcRenderBaseLegacy::SetRotMirParams(PSFC_ROT_MIR_PARAMS rotMirParams)
785 {
786 VP_FUNC_CALL();
787
788 VP_PUBLIC_CHK_NULL_RETURN(rotMirParams);
789
790 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX != m_pipeMode &&
791 VPHAL_ROTATION_IDENTITY != rotMirParams->rotationMode &&
792 VPHAL_MIRROR_HORIZONTAL != rotMirParams->rotationMode)
793 {
794 VP_PUBLIC_ASSERTMESSAGE("Rotation is not supported by Integral Image Mode and VD Mode!");
795 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
796 }
797
798 m_renderDataLegacy.SfcRotation = rotMirParams->rotationMode;
799 m_renderDataLegacy.bMirrorEnable = rotMirParams->bMirrorEnable;
800 m_renderDataLegacy.mirrorType = rotMirParams->mirrorType;
801
802 // Adjust output width/height according to rotation.
803 if (VPHAL_ROTATION_90 == m_renderDataLegacy.SfcRotation ||
804 VPHAL_ROTATION_270 == m_renderDataLegacy.SfcRotation ||
805 VPHAL_ROTATE_90_MIRROR_VERTICAL == m_renderDataLegacy.SfcRotation ||
806 VPHAL_ROTATE_90_MIRROR_HORIZONTAL == m_renderDataLegacy.SfcRotation)
807 {
808 uint32_t width = m_renderDataLegacy.sfcStateParams->dwOutputFrameWidth;
809 m_renderDataLegacy.sfcStateParams->dwOutputFrameWidth = m_renderDataLegacy.sfcStateParams->dwOutputFrameHeight;
810 m_renderDataLegacy.sfcStateParams->dwOutputFrameHeight = width;
811 }
812
813 return MOS_STATUS_SUCCESS;
814 }
815
SetMmcParams(PMOS_SURFACE renderTarget,bool isFormalMmcSupported,bool isMmcEnabled)816 MOS_STATUS SfcRenderBaseLegacy::SetMmcParams(PMOS_SURFACE renderTarget, bool isFormalMmcSupported, bool isMmcEnabled)
817 {
818 VP_FUNC_CALL();
819
820 VP_PUBLIC_CHK_NULL_RETURN(renderTarget);
821 VP_PUBLIC_CHK_NULL_RETURN(m_renderDataLegacy.sfcStateParams);
822
823 if (renderTarget->CompressionMode &&
824 isFormalMmcSupported &&
825 renderTarget->TileType == MOS_TILE_Y &&
826 isMmcEnabled)
827 {
828 m_renderDataLegacy.sfcStateParams->bMMCEnable = true;
829 m_renderDataLegacy.sfcStateParams->MMCMode = renderTarget->CompressionMode;
830
831 if (renderTarget->OsResource.bUncompressedWriteNeeded)
832 {
833 m_renderDataLegacy.sfcStateParams->MMCMode = MOS_MMC_RC;
834 }
835 }
836 else
837 {
838 m_renderDataLegacy.sfcStateParams->bMMCEnable = false;
839 m_renderDataLegacy.sfcStateParams->MMCMode = MOS_MMC_DISABLED;
840 }
841
842 return MOS_STATUS_SUCCESS;
843 }
844
SetSfcStateInputChromaSubSampling(PMHW_SFC_STATE_PARAMS sfcStateParams)845 MOS_STATUS SfcRenderBaseLegacy::SetSfcStateInputChromaSubSampling(
846 PMHW_SFC_STATE_PARAMS sfcStateParams)
847 {
848 VP_FUNC_CALL();
849
850 VP_PUBLIC_CHK_NULL_RETURN(sfcStateParams);
851 VPHAL_COLORPACK colorPack = VpHalDDIUtils::GetSurfaceColorPack(m_renderDataLegacy.SfcInputFormat);
852 if (VPHAL_COLORPACK_400 == colorPack)
853 {
854 sfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_400;
855 }
856 else if (VPHAL_COLORPACK_411 == colorPack)
857 {
858 sfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_411;
859 }
860 else if (VPHAL_COLORPACK_420 == colorPack)
861 {
862 sfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_420;
863 }
864 else if (VPHAL_COLORPACK_422 == colorPack)
865 {
866 sfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_422H;
867 }
868 else if (VPHAL_COLORPACK_444 == colorPack)
869 {
870 sfcStateParams->dwInputChromaSubSampling = MEDIASTATE_SFC_CHROMA_SUBSAMPLING_444;
871 }
872 else
873 {
874 return MOS_STATUS_INVALID_PARAMETER;
875 }
876 return MOS_STATUS_SUCCESS;
877 }
878
SetSfcStateInputOrderingMode(PMHW_SFC_STATE_PARAMS sfcStateParams)879 MOS_STATUS SfcRenderBaseLegacy::SetSfcStateInputOrderingMode(
880 PMHW_SFC_STATE_PARAMS sfcStateParams)
881 {
882 VP_FUNC_CALL();
883
884 VP_PUBLIC_CHK_NULL_RETURN(sfcStateParams);
885
886 if (m_bVdboxToSfc)
887 {
888 VP_PUBLIC_CHK_STATUS_RETURN(SetSfcStateInputOrderingModeVdbox(sfcStateParams));
889 }
890 else if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
891 {
892 if (m_renderDataLegacy.sfcStateParams && m_renderDataLegacy.sfcStateParams->isDemosaicEnabled)
893 {
894 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VE_4x4;
895 }
896 else
897 {
898 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VE_4x8;
899 }
900 }
901 else if (MEDIASTATE_SFC_PIPE_VE_TO_SFC_INTEGRAL == m_pipeMode)
902 {
903 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VE_4x4;
904 }
905 else
906 {
907 return MOS_STATUS_INVALID_PARAMETER;
908 }
909 return MOS_STATUS_SUCCESS;
910 }
911
SetSfcStateInputOrderingModeVdbox(PMHW_SFC_STATE_PARAMS sfcStateParams)912 MOS_STATUS SfcRenderBaseLegacy::SetSfcStateInputOrderingModeVdbox(
913 PMHW_SFC_STATE_PARAMS sfcStateParams)
914 {
915 VP_FUNC_CALL();
916
917 VP_PUBLIC_CHK_NULL_RETURN(sfcStateParams);
918 switch (m_videoConfig.codecStandard)
919 {
920 case CODECHAL_VC1:
921 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_NOSHIFT;
922 break;
923 case CODECHAL_AVC:
924 sfcStateParams->dwVDVEInputOrderingMode = m_videoConfig.avc.deblockingEnabled ? MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_SHIFT : MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_NOSHIFT;
925 break;
926 case CODECHAL_VP8:
927 sfcStateParams->dwVDVEInputOrderingMode = m_videoConfig.vp8.deblockingEnabled ? MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_SHIFT : MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_VP8;
928 break;
929 case CODECHAL_JPEG:
930 return SetSfcStateInputOrderingModeJpeg(sfcStateParams);
931 case CODECHAL_HEVC:
932 case CODECHAL_VP9:
933 return SetSfcStateInputOrderingModeHcp(sfcStateParams);
934 default:
935 VP_PUBLIC_ASSERTMESSAGE("Unsupported codec standard.");
936 return MOS_STATUS_INVALID_PARAMETER;
937 }
938 return MOS_STATUS_SUCCESS;
939 }
940
SetSfcStateInputOrderingModeJpeg(PMHW_SFC_STATE_PARAMS sfcStateParams)941 MOS_STATUS SfcRenderBaseLegacy::SetSfcStateInputOrderingModeJpeg(
942 PMHW_SFC_STATE_PARAMS sfcStateParams)
943 {
944 VP_FUNC_CALL();
945
946 VP_PUBLIC_CHK_NULL_RETURN(sfcStateParams);
947 if (CODECHAL_JPEG != m_videoConfig.codecStandard)
948 {
949 return MOS_STATUS_INVALID_PARAMETER;
950 }
951 switch (m_videoConfig.jpeg.jpegChromaType)
952 {
953 case jpegYUV400:
954 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_8x8_JPEG;
955 break;
956 case jpegYUV411:
957 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_8x8_JPEG;
958 break;
959 case jpegYUV420:
960 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_JPEG;
961 break;
962 case jpegYUV422H2Y:
963 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_8x8_JPEG;
964 break;
965 case jpegYUV422H4Y:
966 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_16x16_JPEG;
967 break;
968 case jpegYUV444:
969 case jpegRGB:
970 case jpegBGR:
971 sfcStateParams->dwVDVEInputOrderingMode = MEDIASTATE_SFC_INPUT_ORDERING_VD_8x8_JPEG;
972 break;
973 default:
974 VP_PUBLIC_ASSERTMESSAGE("Unsupported input format of SFC.");
975 return MOS_STATUS_INVALID_PARAMETER;
976 }
977 return MOS_STATUS_SUCCESS;
978 }
979
SetSfcStateInputOrderingModeHcp(PMHW_SFC_STATE_PARAMS pSfcStateParams)980 MOS_STATUS SfcRenderBaseLegacy::SetSfcStateInputOrderingModeHcp(
981 PMHW_SFC_STATE_PARAMS pSfcStateParams)
982 {
983 return MOS_STATUS_UNIMPLEMENTED;
984 }
985
SendSfcCmd(bool bOutputToMemory,PMOS_COMMAND_BUFFER pCmdBuffer)986 MOS_STATUS SfcRenderBaseLegacy::SendSfcCmd(
987 bool bOutputToMemory,
988 PMOS_COMMAND_BUFFER pCmdBuffer)
989 {
990 VP_FUNC_CALL();
991
992 MHW_SFC_LOCK_PARAMS SfcLockParams;
993 MOS_STATUS eStatus;
994 MHW_SFC_OUT_SURFACE_PARAMS OutSurfaceParam;
995
996 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
997
998 eStatus = MOS_STATUS_SUCCESS;
999
1000 // Setup params for SFC Lock command
1001 SfcLockParams.sfcPipeMode = m_pipeMode;
1002 SfcLockParams.bOutputToMemory = bOutputToMemory;
1003
1004 // Send SFC_LOCK command to acquire SFC pipe for Vebox
1005 VP_RENDER_CHK_STATUS_RETURN(AddSfcLock(
1006 pCmdBuffer,
1007 &SfcLockParams));
1008
1009 VP_RENDER_CHK_STATUS_RETURN(InitMhwOutSurfParams(
1010 m_renderDataLegacy.pSfcPipeOutSurface,
1011 &OutSurfaceParam));
1012
1013 // Send SFC_STATE command
1014 VP_RENDER_CHK_STATUS_RETURN(AddSfcState(
1015 pCmdBuffer,
1016 m_renderDataLegacy.sfcStateParams,
1017 &OutSurfaceParam));
1018 //SETPAR_AND_ADDCMD(SFC_STATE, sfcItf, pCmdBuffer);
1019
1020 // Send SFC_AVS_STATE command
1021 VP_RENDER_CHK_STATUS_RETURN(AddSfcAvsState(
1022 pCmdBuffer,
1023 &m_avsStateLegacy.AvsStateParams));
1024 //SETPAR_AND_ADDCMD(SFC_AVS_STATE, sfcItf, pCmdBuffer);
1025
1026 if (m_renderDataLegacy.bScaling ||
1027 m_renderDataLegacy.bForcePolyPhaseCoefs)
1028 {
1029 // Send SFC_AVS_LUMA_TABLE command
1030 VP_RENDER_CHK_STATUS_RETURN(AddSfcAvsLumaTable(
1031 pCmdBuffer,
1032 &m_avsStateLegacy.LumaCoeffs));
1033 //SETPAR_AND_ADDCMD(SFC_AVS_LUMA_Coeff_Table, sfcItf, pCmdBuffer);
1034
1035 // Send SFC_AVS_CHROMA_TABLE command
1036 VP_RENDER_CHK_STATUS_RETURN(AddSfcAvsChromaTable(
1037 pCmdBuffer,
1038 &m_avsStateLegacy.ChromaCoeffs));
1039 //SETPAR_AND_ADDCMD(SFC_AVS_CHROMA_Coeff_Table, sfcItf, pCmdBuffer);
1040 }
1041
1042 // Send SFC_IEF_STATE command
1043 if (m_renderDataLegacy.bIEF || m_renderDataLegacy.bCSC)
1044 {
1045 // Will modified when enable IEF/CSC
1046 VP_RENDER_CHK_STATUS_RETURN(AddSfcIefState(
1047 pCmdBuffer,
1048 &m_IefStateParamsLegacy));
1049 //SETPAR_AND_ADDCMD(SFC_IEF_STATE, sfcItf, pCmdBuffer);
1050 }
1051
1052 // Send SFC_FRAME_START command to start processing a frame
1053 VP_RENDER_CHK_STATUS_RETURN(AddSfcFrameStart(
1054 pCmdBuffer,
1055 m_pipeMode));
1056
1057 return eStatus;
1058 }
1059
GetAvsLineBufferSize(bool lineTiledBuffer,bool b8tapChromafiltering,uint32_t width,uint32_t height)1060 uint32_t SfcRenderBaseLegacy::GetAvsLineBufferSize(bool lineTiledBuffer, bool b8tapChromafiltering, uint32_t width, uint32_t height)
1061 {
1062 VP_FUNC_CALL();
1063
1064 uint32_t size = 0;
1065 uint32_t linebufferSizePerPixel = 0;
1066
1067 if (MhwSfcInterface::SFC_PIPE_MODE_VDBOX == m_pipeMode)
1068 {
1069 if (b8tapChromafiltering)
1070 {
1071 linebufferSizePerPixel = SFC_AVS_LINEBUFFER_SIZE_PER_PIXEL_8_TAP_8BIT;
1072 }
1073 else
1074 {
1075 linebufferSizePerPixel = SFC_AVS_LINEBUFFER_SIZE_PER_PIXEL_4_TAP_8BIT;
1076 }
1077 }
1078 else
1079 {
1080 // For vebox and hcp.
1081 if (b8tapChromafiltering)
1082 {
1083 linebufferSizePerPixel = SFC_AVS_LINEBUFFER_SIZE_PER_PIXEL_8_TAP_12BIT;
1084 }
1085 else
1086 {
1087 linebufferSizePerPixel = SFC_AVS_LINEBUFFER_SIZE_PER_PIXEL_4_TAP_12BIT;
1088 }
1089 }
1090
1091 // For VD+SFC mode, width needs be used. For VE+SFC mode, height needs be used.
1092 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
1093 {
1094 size = height * linebufferSizePerPixel;
1095 }
1096 else
1097 {
1098 // Align width to 8 for AVS buffer size compute according to VDBOX SFC requirement.
1099 size = MOS_ALIGN_CEIL(width, 8) * linebufferSizePerPixel;
1100 }
1101
1102 // For tile column storage, based on above calcuation, an extra 1K CL need to be added as a buffer.
1103 // size == 0 means line buffer not needed.
1104 if (lineTiledBuffer && size > 0)
1105 {
1106 size += 1024 * MHW_SFC_CACHELINE_SIZE;
1107 }
1108
1109 return size;
1110 }
1111
GetIefLineBufferSize(bool lineTiledBuffer,uint32_t heightOutput)1112 uint32_t SfcRenderBaseLegacy::GetIefLineBufferSize(bool lineTiledBuffer, uint32_t heightOutput)
1113 {
1114 VP_FUNC_CALL();
1115
1116 uint32_t size = 0;
1117
1118 // For VE+SFC mode, height needs be used.
1119 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
1120 {
1121 size = heightOutput * SFC_IEF_LINEBUFFER_SIZE_PER_VERTICAL_PIXEL;
1122 }
1123 else
1124 {
1125 return 0;
1126 }
1127
1128 // For tile column storage, based on above calcuation, an extra 1K CL need to be added as a buffer.
1129 // size == 0 means line buffer not needed.
1130 if (lineTiledBuffer && size > 0)
1131 {
1132 size += 1024 * MHW_SFC_CACHELINE_SIZE;
1133 }
1134
1135 return size;
1136 }
1137
GetSfdLineBufferSize(bool lineTiledBuffer,MOS_FORMAT formatOutput,uint32_t widthOutput,uint32_t heightOutput)1138 uint32_t SfcRenderBaseLegacy::GetSfdLineBufferSize(bool lineTiledBuffer, MOS_FORMAT formatOutput, uint32_t widthOutput, uint32_t heightOutput)
1139 {
1140 VP_FUNC_CALL();
1141
1142 int size = 0;
1143
1144 // For VD+SFC mode, width needs be used. For VE+SFC mode, height needs be used.
1145 if (MhwSfcInterface::SFC_PIPE_MODE_VEBOX == m_pipeMode)
1146 {
1147 size = (VPHAL_COLORPACK_444 == VpHalDDIUtils::GetSurfaceColorPack(formatOutput)) ? 0 : (heightOutput * SFC_SFD_LINEBUFFER_SIZE_PER_PIXEL);
1148 }
1149 else
1150 {
1151 size = MOS_ROUNDUP_DIVIDE(widthOutput, 10) * SFC_CACHELINE_SIZE_IN_BYTES;
1152 size *= 2; //double for safe
1153 }
1154
1155 // For tile column storage, based on above calcuation, an extra 1K CL need to be added as a buffer.
1156 // size == 0 means line buffer not needed.
1157 if (lineTiledBuffer && size > 0)
1158 {
1159 size += 1024 * MHW_SFC_CACHELINE_SIZE;
1160 }
1161
1162 return size;
1163 }
1164
AllocateResources()1165 MOS_STATUS SfcRenderBaseLegacy::AllocateResources()
1166 {
1167 VP_FUNC_CALL();
1168
1169 uint32_t size;
1170 PMHW_SFC_STATE_PARAMS sfcStateParams;
1171
1172 VP_RENDER_CHK_NULL_RETURN(m_allocator);
1173 VP_RENDER_CHK_NULL_RETURN(m_renderDataLegacy.sfcStateParams);
1174
1175 sfcStateParams = m_renderDataLegacy.sfcStateParams;
1176
1177 // for 1st pass of Sfc 2Pass case, use the standalone line buffer array to avoid line buffer reallocation
1178 if (m_renderDataLegacy.b1stPassOfSfc2PassScaling)
1179 {
1180 if (m_scalabilityParams.numPipe > m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass ||
1181 nullptr == m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass ||
1182 nullptr == m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass ||
1183 nullptr == m_SFDLineBufferSurfaceArrayfor1stPassofSfc2Pass)
1184 {
1185 DestroyLineBufferArray(m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1186 DestroyLineBufferArray(m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1187 DestroyLineBufferArray(m_SFDLineBufferSurfaceArrayfor1stPassofSfc2Pass, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1188 m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass = m_scalabilityParams.numPipe;
1189 m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1190 VP_RENDER_CHK_NULL_RETURN(m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass);
1191 m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1192 VP_RENDER_CHK_NULL_RETURN(m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass);
1193 m_SFDLineBufferSurfaceArrayfor1stPassofSfc2Pass = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArrayfor1stPassofSfc2Pass);
1194 VP_RENDER_CHK_NULL_RETURN(m_SFDLineBufferSurfaceArrayfor1stPassofSfc2Pass);
1195 }
1196
1197 // for AVSLineBuffer, IEFLineBuffer and SFDLineBuffer, they are only needed when surface allocation bigger than 4150.
1198 // for AVSLineTileBuffer, IEFLineTileBuffer and SFDLineTileBuffer, they are only needed for VdBox SFC scalability case and not needed for VeBox SFC case.
1199
1200 // Allocate AVS Line Buffer surface----------------------------------------------
1201 size = GetAvsLineBufferSize(false, sfcStateParams->b8tapChromafiltering, sfcStateParams->dwInputFrameWidth, sfcStateParams->dwInputFrameHeight);
1202 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_AVSLineBufferSurfaceArrayfor1stPassofSfc2Pass, size, "SfcAVSLineBufferSurfacefor1stPassofSfc2Pass"));
1203
1204 // Allocate IEF Line Buffer surface----------------------------------------------
1205 size = GetIefLineBufferSize(false, sfcStateParams->dwScaledRegionHeight);
1206 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_IEFLineBufferSurfaceArrayfor1stPassofSfc2Pass, size, "SfcIEFLineBufferSurfacefor1stPassofSfc2Pass"));
1207
1208 if (sfcStateParams->dwScaledRegionHeight > SFC_LINEBUFEER_SIZE_LIMITED)
1209 {
1210 // Allocate SFD Line Buffer surface
1211 size = GetSfdLineBufferSize(false, sfcStateParams->OutputFrameFormat, sfcStateParams->dwScaledRegionWidth, sfcStateParams->dwScaledRegionHeight);
1212 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_SFDLineBufferSurfaceArrayfor1stPassofSfc2Pass, size, "SfcSFDLineBufferSurfacefor1stPassofSfc2Pass"));
1213 }
1214 }
1215 else
1216 {
1217 if (m_scalabilityParams.numPipe > m_lineBufferAllocatedInArray ||
1218 nullptr == m_AVSLineBufferSurfaceArray ||
1219 nullptr == m_IEFLineBufferSurfaceArray ||
1220 nullptr == m_SFDLineBufferSurfaceArray)
1221 {
1222 DestroyLineBufferArray(m_AVSLineBufferSurfaceArray, m_lineBufferAllocatedInArray);
1223 DestroyLineBufferArray(m_IEFLineBufferSurfaceArray, m_lineBufferAllocatedInArray);
1224 DestroyLineBufferArray(m_SFDLineBufferSurfaceArray, m_lineBufferAllocatedInArray);
1225 m_lineBufferAllocatedInArray = m_scalabilityParams.numPipe;
1226 m_AVSLineBufferSurfaceArray = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArray);
1227 VP_RENDER_CHK_NULL_RETURN(m_AVSLineBufferSurfaceArray);
1228 m_IEFLineBufferSurfaceArray = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArray);
1229 VP_RENDER_CHK_NULL_RETURN(m_IEFLineBufferSurfaceArray);
1230 m_SFDLineBufferSurfaceArray = MOS_NewArray(VP_SURFACE *, m_lineBufferAllocatedInArray);
1231 VP_RENDER_CHK_NULL_RETURN(m_SFDLineBufferSurfaceArray);
1232 }
1233
1234 // for AVSLineBuffer, IEFLineBuffer and SFDLineBuffer, they are only needed when surface allocation bigger than 4150.
1235 // for AVSLineTileBuffer, IEFLineTileBuffer and SFDLineTileBuffer, they are only needed for VdBox SFC scalability case and not needed for VeBox SFC case.
1236
1237 // Allocate AVS Line Buffer surface----------------------------------------------
1238 size = GetAvsLineBufferSize(false, sfcStateParams->b8tapChromafiltering, sfcStateParams->dwInputFrameWidth, sfcStateParams->dwInputFrameHeight);
1239 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_AVSLineBufferSurfaceArray, size, "SfcAVSLineBufferSurface"));
1240
1241 // Allocate IEF Line Buffer surface----------------------------------------------
1242 size = GetIefLineBufferSize(false, sfcStateParams->dwScaledRegionHeight);
1243 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_IEFLineBufferSurfaceArray, size, "SfcIEFLineBufferSurface"));
1244
1245 if (sfcStateParams->dwScaledRegionHeight > SFC_LINEBUFEER_SIZE_LIMITED)
1246 {
1247 // Allocate SFD Line Buffer surface
1248 size = GetSfdLineBufferSize(false, sfcStateParams->OutputFrameFormat, sfcStateParams->dwScaledRegionWidth, sfcStateParams->dwScaledRegionHeight);
1249 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBufferArray(m_SFDLineBufferSurfaceArray, size, "SfcSFDLineBufferSurface"));
1250 }
1251 }
1252
1253 if (m_bVdboxToSfc)
1254 {
1255 // Allocate AVS Line Tile Buffer surface----------------------------------------------
1256 size = GetAvsLineBufferSize(true, sfcStateParams->b8tapChromafiltering, sfcStateParams->dwInputFrameWidth, sfcStateParams->dwInputFrameHeight);
1257 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBuffer(m_AVSLineTileBufferSurface, size, "SfcAVSLineTileBufferSurface"));
1258
1259 // Allocate IEF Line Tile Buffer surface----------------------------------------------
1260 size = GetIefLineBufferSize(true, sfcStateParams->dwScaledRegionHeight);
1261 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBuffer(m_IEFLineTileBufferSurface, size, "SfcIEFLineTileBufferSurface"));
1262
1263 // Allocate SFD Line Tile Buffer surface
1264 size = GetSfdLineBufferSize(true, sfcStateParams->OutputFrameFormat, sfcStateParams->dwScaledRegionWidth, sfcStateParams->dwScaledRegionHeight);
1265 VP_RENDER_CHK_STATUS_RETURN(AllocateLineBuffer(m_SFDLineTileBufferSurface, size, "SfcSFDLineTileBufferSurface"));
1266 }
1267 return MOS_STATUS_SUCCESS;
1268 }
1269
AddSfcLock(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_LOCK_PARAMS pSfcLockParams)1270 MOS_STATUS SfcRenderBaseLegacy::AddSfcLock(
1271 PMOS_COMMAND_BUFFER pCmdBuffer,
1272 PMHW_SFC_LOCK_PARAMS pSfcLockParams)
1273 {
1274 VP_FUNC_CALL();
1275
1276 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1277
1278 // Send SFC_LOCK command to acquire SFC pipe for Vebox
1279 VP_RENDER_CHK_STATUS_RETURN(m_sfcInterface->AddSfcLock(
1280 pCmdBuffer,
1281 pSfcLockParams));
1282
1283 return MOS_STATUS_SUCCESS;
1284 }
1285
AddSfcState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_STATE_PARAMS pSfcState,PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)1286 MOS_STATUS SfcRenderBaseLegacy::AddSfcState(
1287 PMOS_COMMAND_BUFFER pCmdBuffer,
1288 PMHW_SFC_STATE_PARAMS pSfcState,
1289 PMHW_SFC_OUT_SURFACE_PARAMS pOutSurface)
1290 {
1291 VP_FUNC_CALL();
1292
1293 PMHW_SFC_INTERFACE pSfcInterface;
1294 MOS_STATUS eStatus;
1295
1296 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1297 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1298 VP_RENDER_CHK_NULL_RETURN(pSfcState);
1299 VP_RENDER_CHK_NULL_RETURN(pOutSurface);
1300
1301 eStatus = MOS_STATUS_SUCCESS;
1302 pSfcInterface = m_sfcInterface;
1303
1304 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcState(
1305 pCmdBuffer,
1306 pSfcState,
1307 pOutSurface));
1308
1309 return eStatus;
1310 }
1311
AddSfcAvsState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_STATE pSfcAvsStateParams)1312 MOS_STATUS SfcRenderBaseLegacy::AddSfcAvsState(
1313 PMOS_COMMAND_BUFFER pCmdBuffer,
1314 PMHW_SFC_AVS_STATE pSfcAvsStateParams)
1315 {
1316 VP_FUNC_CALL();
1317
1318 PMHW_SFC_INTERFACE pSfcInterface;
1319 MOS_STATUS eStatus;
1320
1321 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1322 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1323 VP_RENDER_CHK_NULL_RETURN(pSfcAvsStateParams);
1324
1325 eStatus = MOS_STATUS_SUCCESS;
1326 pSfcInterface = m_sfcInterface;
1327
1328 // Send SFC_AVS_STATE command
1329 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcAvsState(
1330 pCmdBuffer,
1331 pSfcAvsStateParams));
1332
1333 return eStatus;
1334 }
1335
AddSfcIefState(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_IEF_STATE_PARAMS pSfcIefStateParams)1336 MOS_STATUS SfcRenderBaseLegacy::AddSfcIefState(
1337 PMOS_COMMAND_BUFFER pCmdBuffer,
1338 PMHW_SFC_IEF_STATE_PARAMS pSfcIefStateParams)
1339 {
1340 VP_FUNC_CALL();
1341
1342 PMHW_SFC_INTERFACE pSfcInterface;
1343 MOS_STATUS eStatus;
1344
1345 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1346 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1347 VP_RENDER_CHK_NULL_RETURN(pSfcIefStateParams);
1348
1349 eStatus = MOS_STATUS_SUCCESS;
1350 pSfcInterface = m_sfcInterface;
1351
1352 // Will modified when enable IEF/CSC
1353 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcIefState(
1354 pCmdBuffer,
1355 pSfcIefStateParams));
1356
1357 return eStatus;
1358 }
1359
AddSfcAvsLumaTable(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_LUMA_TABLE pLumaTable)1360 MOS_STATUS SfcRenderBaseLegacy::AddSfcAvsLumaTable(
1361 PMOS_COMMAND_BUFFER pCmdBuffer,
1362 PMHW_SFC_AVS_LUMA_TABLE pLumaTable)
1363 {
1364 VP_FUNC_CALL();
1365
1366 PMHW_SFC_INTERFACE pSfcInterface;
1367 MOS_STATUS eStatus;
1368
1369 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1370 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1371 VP_RENDER_CHK_NULL_RETURN(pLumaTable);
1372
1373 eStatus = MOS_STATUS_SUCCESS;
1374 pSfcInterface = m_sfcInterface;
1375
1376 // Send SFC_AVS_LUMA_TABLE command
1377 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcAvsLumaTable(
1378 pCmdBuffer,
1379 pLumaTable));
1380
1381 return eStatus;
1382 }
1383
AddSfcAvsChromaTable(PMOS_COMMAND_BUFFER pCmdBuffer,PMHW_SFC_AVS_CHROMA_TABLE pChromaTable)1384 MOS_STATUS SfcRenderBaseLegacy::AddSfcAvsChromaTable(
1385 PMOS_COMMAND_BUFFER pCmdBuffer,
1386 PMHW_SFC_AVS_CHROMA_TABLE pChromaTable)
1387 {
1388 VP_FUNC_CALL();
1389
1390 MOS_STATUS eStatus;
1391 PMHW_SFC_INTERFACE pSfcInterface;
1392
1393 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1394 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1395 VP_RENDER_CHK_NULL_RETURN(pChromaTable);
1396
1397 eStatus = MOS_STATUS_SUCCESS;
1398 pSfcInterface = m_sfcInterface;
1399
1400 // Send SFC_AVS_CHROMA_TABLE command
1401 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcAvsChromaTable(
1402 pCmdBuffer,
1403 pChromaTable));
1404
1405 return eStatus;
1406 }
1407
AddSfcFrameStart(PMOS_COMMAND_BUFFER pCmdBuffer,uint8_t sfcPipeMode)1408 MOS_STATUS SfcRenderBaseLegacy::AddSfcFrameStart(
1409 PMOS_COMMAND_BUFFER pCmdBuffer,
1410 uint8_t sfcPipeMode)
1411 {
1412 VP_FUNC_CALL();
1413
1414 MOS_STATUS eStatus;
1415 PMHW_SFC_INTERFACE pSfcInterface;
1416
1417 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1418 VP_RENDER_CHK_NULL_RETURN(pCmdBuffer);
1419
1420 eStatus = MOS_STATUS_SUCCESS;
1421 pSfcInterface = m_sfcInterface;
1422
1423 // Send SFC_FRAME_START command to start processing a frame
1424 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->AddSfcFrameStart(
1425 pCmdBuffer,
1426 sfcPipeMode));
1427
1428 return eStatus;
1429 }
1430
SetSfcAVSScalingMode(MHW_SCALING_MODE ScalingMode)1431 MOS_STATUS SfcRenderBaseLegacy::SetSfcAVSScalingMode(
1432 MHW_SCALING_MODE ScalingMode)
1433 {
1434 VP_FUNC_CALL();
1435
1436 MOS_STATUS eStatus;
1437 PMHW_SFC_INTERFACE pSfcInterface;
1438
1439 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1440 eStatus = MOS_STATUS_SUCCESS;
1441 pSfcInterface = m_sfcInterface;
1442
1443 // Send SFC_FRAME_START command to start processing a frame
1444 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->SetSfcAVSScalingMode(
1445 ScalingMode));
1446
1447 return eStatus;
1448 }
1449
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)1450 MOS_STATUS SfcRenderBaseLegacy::SetSfcSamplerTable(
1451 PMHW_SFC_AVS_LUMA_TABLE pLumaTable,
1452 PMHW_SFC_AVS_CHROMA_TABLE pChromaTable,
1453 PMHW_AVS_PARAMS pAvsParams,
1454 MOS_FORMAT SrcFormat,
1455 float fScaleX,
1456 float fScaleY,
1457 uint32_t dwChromaSiting,
1458 bool bUse8x8Filter,
1459 float fHPStrength,
1460 float fLanczosT)
1461 {
1462 VP_FUNC_CALL();
1463
1464 MOS_STATUS eStatus;
1465 PMHW_SFC_INTERFACE pSfcInterface;
1466
1467 VP_RENDER_CHK_NULL_RETURN(m_sfcInterface);
1468 VP_RENDER_CHK_NULL_RETURN(pLumaTable);
1469 VP_RENDER_CHK_NULL_RETURN(pChromaTable);
1470 VP_RENDER_CHK_NULL_RETURN(pAvsParams);
1471
1472 eStatus = MOS_STATUS_SUCCESS;
1473 pSfcInterface = m_sfcInterface;
1474
1475 // Send SFC_FRAME_START command to start processing a frame
1476 VP_RENDER_CHK_STATUS_RETURN(pSfcInterface->SetSfcSamplerTable(
1477 pLumaTable,
1478 pChromaTable,
1479 pAvsParams,
1480 SrcFormat,
1481 fScaleX,
1482 fScaleY,
1483 dwChromaSiting,
1484 bUse8x8Filter,
1485 fHPStrength,
1486 fLanczosT));
1487
1488 return eStatus;
1489 }
1490 }
1491