1 /*
2 * Copyright (c) 2019-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 //!
24 //! \file sw_filter.cpp
25 //! \brief Defines the common interface for vp features manager
26 //! \details The vp manager is further sub-divided by vp type
27 //! this file is for the base interface which is shared by all components.
28 //!
29 #include "sw_filter.h"
30 #include "vp_obj_factories.h"
31 #include "sw_filter_handle.h"
32 #include "vp_utils.h"
33 #include "vp_user_feature_control.h"
34 #include "vp_utils.h"
35
36 using namespace vp;
37
38 template <typename T>
swap(T & a,T & b)39 inline void swap(T &a, T &b)
40 {
41 T tmp = b;
42 b = a;
43 a = tmp;
44 }
45
46 /****************************************************************************************************/
47 /* SwFilter */
48 /****************************************************************************************************/
49
SwFilter(VpInterface & vpInterface,FeatureType type)50 SwFilter::SwFilter(VpInterface &vpInterface, FeatureType type) : m_vpInterface(vpInterface), m_type(type)
51 {
52 if (m_EngineCaps.value != 0)
53 {
54 // Some complier may not work well for m_EngineCaps initialization by m_EngineCaps = {}. Force set to 0 here.
55 VP_PUBLIC_NORMALMESSAGE("m_EngineCaps is not initialized correctly since complier issue, m_EngineCaps.value: %x. Force reset to 0.", m_EngineCaps.value);
56 m_EngineCaps.value = 0;
57 }
58 }
59
~SwFilter()60 SwFilter::~SwFilter()
61 {
62 Clean();
63 }
64
SetFeatureType(FeatureType type)65 MOS_STATUS SwFilter::SetFeatureType(FeatureType type)
66 {
67 VP_FUNC_CALL();
68
69 if ((type & FEATURE_TYPE_MASK) != (m_type & FEATURE_TYPE_MASK))
70 {
71 return MOS_STATUS_INVALID_PARAMETER;
72 }
73 m_type = type;
74
75 return MOS_STATUS_SUCCESS;
76 }
77
ResetFeatureType()78 MOS_STATUS SwFilter::ResetFeatureType()
79 {
80 VP_FUNC_CALL();
81
82 m_type = (FeatureType)(m_type & FEATURE_TYPE_MASK);
83
84 return MOS_STATUS_SUCCESS;
85 }
86
SetRenderTargetType(RenderTargetType type)87 MOS_STATUS SwFilter::SetRenderTargetType(RenderTargetType type)
88 {
89 VP_FUNC_CALL();
90
91 m_renderTargetType = type;
92
93 return MOS_STATUS_SUCCESS;
94 }
95
CreateSwFilter(FeatureType type)96 SwFilter* SwFilter::CreateSwFilter(FeatureType type)
97 {
98 VP_FUNC_CALL();
99
100 auto handle = m_vpInterface.GetSwFilterHandler(m_type);
101 SwFilter* p = nullptr;
102 if (handle)
103 {
104 p = handle->CreateSwFilter();
105 if (nullptr == p)
106 {
107 return nullptr;
108 }
109 p->SetRenderTargetType(m_renderTargetType);
110 p->GetFilterEngineCaps().value = 0;
111 }
112 else
113 {
114 VP_PUBLIC_ASSERTMESSAGE("SwFilter Handler didn't Init, return Fail");
115 return nullptr;
116 }
117
118 return p;
119 }
120
DestroySwFilter(SwFilter * p)121 void SwFilter::DestroySwFilter(SwFilter* p)
122 {
123 VP_FUNC_CALL();
124
125 auto handle = m_vpInterface.GetSwFilterHandler(m_type);
126
127 if (handle)
128 {
129 handle->Destory(p);
130 }
131 else
132 {
133 VP_PUBLIC_ASSERTMESSAGE("SwFilter Handler didn't Init, return Fail");
134 return;
135 }
136 }
137
GetHwInterface()138 VP_MHWINTERFACE *SwFilter::GetHwInterface()
139 {
140 VP_FUNC_CALL();
141
142 return m_vpInterface.GetHwInterface();
143 }
144
145 /****************************************************************************************************/
146 /* SwFilterCsc */
147 /****************************************************************************************************/
148
SwFilterCsc(VpInterface & vpInterface)149 SwFilterCsc::SwFilterCsc(VpInterface &vpInterface) : SwFilter(vpInterface, FeatureTypeCsc)
150 {
151 m_Params.type = m_type;
152 }
153
~SwFilterCsc()154 SwFilterCsc::~SwFilterCsc()
155 {
156 Clean();
157 }
158
Clean()159 MOS_STATUS SwFilterCsc::Clean()
160 {
161 VP_FUNC_CALL();
162
163 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
164 return MOS_STATUS_SUCCESS;
165 }
166
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)167 MOS_STATUS SwFilterCsc::Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex)
168 {
169 VP_FUNC_CALL();
170
171 // Parameter checking should be done in SwFilterCscHandler::IsFeatureEnabled.
172 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
173 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
174
175 m_Params.input.colorSpace = surfInput->ColorSpace;
176 m_Params.output.colorSpace = surfOutput->ColorSpace;
177 m_Params.pIEFParams = surfInput->pIEFParams;
178 m_Params.formatInput = surfInput->Format;
179 m_Params.formatOutput = surfOutput->Format;
180 m_Params.input.chromaSiting = surfInput->ChromaSiting;
181 m_Params.output.chromaSiting = surfOutput->ChromaSiting;
182 m_Params.input.tileMode = surfInput->TileModeGMM;
183 m_Params.output.tileMode = surfOutput->TileModeGMM;
184 m_Params.isFullRgbG10P709 = surfOutput->pGamutParams ? surfOutput->pGamutParams->GammaValue == GAMMA_1P0 : 0 && surfOutput->ColorSpace == CSpace_sRGB && IS_RGB64_FLOAT_FORMAT(surfOutput->Format);
185 // Alpha should be handled in input pipe to avoid alpha data lost from image.
186 m_Params.pAlphaParams = params.pCompAlpha;
187 // formatForCUS will be set on demand in Policy::GetCSCExecutionCapsBT2020ToRGB.
188 m_Params.formatforCUS = Format_None;
189
190 VP_PUBLIC_NORMALMESSAGE("formatInput %d, formatOutput %d", m_Params.formatInput, m_Params.formatOutput);
191
192 return MOS_STATUS_SUCCESS;
193 }
194
195 namespace vp
196 {
197 MOS_STATUS GetVeboxOutputParams(VP_EXECUTE_CAPS &executeCaps, MOS_FORMAT inputFormat, MOS_TILE_TYPE inputTileType, MOS_FORMAT outputFormat,
198 MOS_FORMAT &veboxOutputFormat, MOS_TILE_TYPE &veboxOutputTileType, VPHAL_CSPACE colorSpaceOutput);
199 }
200
Configure(PVP_SURFACE surfInput,PVP_SURFACE surfOutput,VP_EXECUTE_CAPS caps)201 MOS_STATUS SwFilterCsc::Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps)
202 {
203 VP_FUNC_CALL();
204
205 VP_PUBLIC_CHK_NULL_RETURN(surfInput);
206 VP_PUBLIC_CHK_NULL_RETURN(surfInput->osSurface);
207 VP_PUBLIC_CHK_NULL_RETURN(surfOutput);
208 VP_PUBLIC_CHK_NULL_RETURN(surfOutput->osSurface);
209
210 if (caps.bSFC)
211 {
212 MOS_FORMAT veboxOutputFormat = surfInput->osSurface->Format;
213 MOS_TILE_TYPE veboxOutputTileType = surfInput->osSurface->TileType;
214
215 GetVeboxOutputParams(caps, surfInput->osSurface->Format, surfInput->osSurface->TileType,
216 surfOutput->osSurface->Format, veboxOutputFormat, veboxOutputTileType, surfOutput->ColorSpace);
217 m_Params.input.colorSpace = surfInput->ColorSpace;
218 m_Params.output.colorSpace = surfInput->ColorSpace;
219
220 m_Params.input.tileMode = surfInput->osSurface->TileModeGMM;
221 m_Params.output.tileMode = surfOutput->osSurface->TileModeGMM;
222 m_Params.formatInput = surfInput->osSurface->Format;
223 // formatForCUS will be set on demand in Policy::GetCSCExecutionCapsBT2020ToRGB.
224 m_Params.formatforCUS = Format_None;
225 m_Params.formatOutput = veboxOutputFormat;
226 m_Params.input.chromaSiting = surfInput->ChromaSiting;
227 m_Params.output.chromaSiting = surfOutput->ChromaSiting;
228
229 m_Params.pAlphaParams = nullptr;
230 m_Params.pIEFParams = nullptr;
231
232 m_noNeedUpdate = true;
233
234 return MOS_STATUS_SUCCESS;
235 }
236 else
237 {
238 // Skip CSC and only for chroma sitting purpose
239 m_Params.input.colorSpace = m_Params.output.colorSpace = surfInput->ColorSpace;
240 m_Params.formatInput = m_Params.formatOutput = surfInput->osSurface->Format;
241 m_Params.input.tileMode = surfInput->osSurface->TileModeGMM;
242 m_Params.output.tileMode = surfOutput->osSurface->TileModeGMM;
243 // formatForCUS will be set on demand in Policy::GetCSCExecutionCapsBT2020ToRGB.
244 m_Params.formatforCUS = Format_None;
245 m_Params.input.chromaSiting = surfInput->ChromaSiting;
246 m_Params.output.chromaSiting = surfOutput->ChromaSiting;
247 m_Params.pAlphaParams = nullptr;
248 m_Params.pIEFParams = nullptr;
249
250 m_noNeedUpdate = true;
251
252 return MOS_STATUS_SUCCESS;
253 }
254 }
255
Configure(FeatureParamCsc & params)256 MOS_STATUS SwFilterCsc::Configure(FeatureParamCsc ¶ms)
257 {
258 // Skip CSC and only for chroma sitting purpose
259 m_Params = params;
260 m_noNeedUpdate = true;
261
262 return MOS_STATUS_SUCCESS;
263 }
264
Configure(VEBOX_SFC_PARAMS & params)265 MOS_STATUS SwFilterCsc::Configure(VEBOX_SFC_PARAMS ¶ms)
266 {
267 VP_FUNC_CALL();
268
269 if (m_noNeedUpdate)
270 {
271 return MOS_STATUS_SUCCESS;
272 }
273 m_Params.input.colorSpace = params.input.colorSpace;
274 m_Params.output.colorSpace = params.output.colorSpace;
275 m_Params.input.tileMode = params.input.surface->TileModeGMM;
276 m_Params.output.tileMode = params.output.surface->TileModeGMM;
277 m_Params.pIEFParams = nullptr;
278 m_Params.formatInput = params.input.surface->Format;
279 // formatForCUS will be set on demand in Policy::GetCSCExecutionCapsBT2020ToRGB.
280 m_Params.formatforCUS = Format_None;
281 m_Params.formatOutput = params.output.surface->Format;
282 m_Params.input.chromaSiting = params.input.chromaSiting;
283 m_Params.output.chromaSiting = params.output.chromaSiting;
284 m_Params.pAlphaParams = nullptr;
285 return MOS_STATUS_SUCCESS;
286 }
287
GetSwFilterParams()288 FeatureParamCsc &SwFilterCsc::GetSwFilterParams()
289 {
290 VP_FUNC_CALL();
291
292 return m_Params;
293 }
294
Clone()295 SwFilter *SwFilterCsc::Clone()
296 {
297 VP_FUNC_CALL();
298
299 SwFilter* p = CreateSwFilter(m_type);
300
301 SwFilterCsc *swFilter = dynamic_cast<SwFilterCsc *>(p);
302 if (nullptr == swFilter)
303 {
304 DestroySwFilter(p);
305 return nullptr;
306 }
307
308 swFilter->m_Params = m_Params;
309 return p;
310 }
311
operator ==(SwFilter & swFilter)312 bool SwFilterCsc::operator == (SwFilter& swFilter)
313 {
314 VP_FUNC_CALL();
315
316 SwFilterCsc *p = dynamic_cast<SwFilterCsc *>(&swFilter);
317 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamCsc));
318 }
319
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)320 MOS_STATUS SwFilterCsc::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe)
321 {
322 VP_FUNC_CALL();
323
324 if (FeatureTypeCscOnVebox == m_type)
325 {
326 // BeCSC may be added for IECP/DI. No need update.
327 return MOS_STATUS_SUCCESS;
328 }
329
330 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
331 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
332 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
333 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
334
335 m_Params.formatInput = inputSurf->osSurface->Format;
336 m_Params.formatOutput = outputSurf->osSurface->Format;
337 m_Params.input.colorSpace = inputSurf->ColorSpace;
338 m_Params.output.colorSpace = outputSurf->ColorSpace;
339 m_Params.input.chromaSiting = inputSurf->ChromaSiting;
340 m_Params.output.chromaSiting = outputSurf->ChromaSiting;
341
342 return MOS_STATUS_SUCCESS;
343 }
344
SetFeatureType(FeatureType type)345 MOS_STATUS SwFilterCsc::SetFeatureType(FeatureType type)
346 {
347 VP_FUNC_CALL();
348
349 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::SetFeatureType(type));
350 m_Params.type = m_type;
351 return MOS_STATUS_SUCCESS;
352 }
353
354 /****************************************************************************************************/
355 /* SwFilterScaling */
356 /****************************************************************************************************/
357
SwFilterScaling(VpInterface & vpInterface)358 SwFilterScaling::SwFilterScaling(VpInterface &vpInterface) : SwFilter(vpInterface, FeatureTypeScaling)
359 {
360 m_Params.type = m_type;
361 }
362
~SwFilterScaling()363 SwFilterScaling::~SwFilterScaling()
364 {
365 Clean();
366 }
367
Clean()368 MOS_STATUS SwFilterScaling::Clean()
369 {
370 VP_FUNC_CALL();
371
372 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
373 return MOS_STATUS_SUCCESS;
374 }
375
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)376 MOS_STATUS SwFilterScaling::Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex)
377 {
378 VP_FUNC_CALL();
379
380 // Parameter checking should be done in SwFilterScalingHandler::IsFeatureEnabled.
381 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
382 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
383
384 m_Params.isPrimary = params.uSrcCount == 1 || SURF_IN_PRIMARY == surfInput->SurfType;
385 m_Params.scalingMode = surfInput->ScalingMode;
386 m_Params.scalingPreference = surfInput->ScalingPreference;
387 m_Params.bDirectionalScalar = surfInput->bDirectionalScalar;
388 m_Params.formatInput = surfInput->Format;
389 m_Params.input.rcSrc = surfInput->rcSrc;
390
391 m_Params.input.rcMaxSrc = surfInput->rcMaxSrc;
392 m_Params.input.dwWidth = surfInput->dwWidth;
393 m_Params.input.dwHeight = surfInput->dwHeight;
394 m_Params.formatOutput = surfOutput->Format;
395 m_Params.csc.colorSpaceOutput = surfOutput->ColorSpace;
396 // Will be assigned during PolicySfcColorFillHandler::UpdateFeaturePipe.
397 m_Params.pColorFillParams = nullptr;
398 // Alpha should be handled in input pipe to avoid alpha data lost from image.
399 m_Params.pCompAlpha = params.pCompAlpha;
400
401 if (!VpUtils::IsVerticalRotation(surfInput->Rotation))
402 {
403 m_Params.rotation.rotationNeeded = false;
404 m_Params.output.dwWidth = surfOutput->dwWidth;
405 m_Params.output.dwHeight = surfOutput->dwHeight;
406 m_Params.output.dwPitch = surfOutput->dwPitch;
407 m_Params.input.rcDst = surfInput->rcDst;
408 m_Params.output.rcSrc = surfOutput->rcSrc;
409 m_Params.output.rcDst = surfOutput->rcDst;
410 m_Params.output.rcMaxSrc = surfOutput->rcMaxSrc;
411 }
412 else
413 {
414 m_Params.rotation.rotationNeeded = true;
415 m_Params.output.dwWidth = surfOutput->dwHeight;
416 m_Params.output.dwHeight = surfOutput->dwWidth;
417 m_Params.output.dwPitch = surfOutput->dwPitch;
418 RECT_ROTATE(m_Params.input.rcDst, surfInput->rcDst);
419 RECT_ROTATE(m_Params.output.rcSrc, surfOutput->rcSrc);
420 RECT_ROTATE(m_Params.output.rcDst, surfOutput->rcDst);
421 RECT_ROTATE(m_Params.output.rcMaxSrc, surfOutput->rcMaxSrc);
422 }
423
424 m_Params.bTargetRectangle = !((surfOutput->rcSrc.left == 0) && (surfOutput->rcSrc.top == 0) && (surfOutput->rcSrc.bottom == surfOutput->dwHeight) && (surfOutput->rcSrc.right == surfOutput->dwWidth));
425 VP_PUBLIC_NORMALMESSAGE("Target Rectangle is enabled: %d", m_Params.bTargetRectangle);
426
427 if (surfInput->bInterlacedScaling)
428 {
429 m_Params.interlacedScalingType = ISCALING_INTERLEAVED_TO_INTERLEAVED;
430 }
431 else if (surfInput->bFieldWeaving)
432 {
433 m_Params.interlacedScalingType = ISCALING_FIELD_TO_INTERLEAVED;
434 }
435 else
436 {
437 m_Params.interlacedScalingType = surfInput->InterlacedScalingType;
438 }
439
440 m_Params.input.sampleType = surfInput->SampleType;
441 m_Params.output.sampleType = surfOutput->SampleType;
442
443 VP_PUBLIC_NORMALMESSAGE("interlacedScalingType %d", m_Params.interlacedScalingType);
444
445 m_Params.input.tileMode = surfInput->TileModeGMM;
446 m_Params.output.tileMode = surfOutput->TileModeGMM;
447
448 VP_PUBLIC_NORMALMESSAGE("Input Surface: TileType %d, TileModeGMM %d", surfInput->TileType, surfInput->TileModeGMM);
449 VP_PUBLIC_NORMALMESSAGE("Output Surface: TileType %d, TileModeGMM %d", surfOutput->TileType, surfOutput->TileModeGMM);
450
451 // For field-to-interleaved scaling, the height of rcSrcInput is input field height,
452 // the height of rcDstInput is output frame height, for scaling ratio calculation, the
453 // bottom of rcDstInput need to divide 2.
454 if(m_Params.interlacedScalingType == ISCALING_FIELD_TO_INTERLEAVED)
455 {
456 m_Params.input.rcDst.bottom /= 2;
457 }
458 // For interleaved--to-field scaling, the height of rcSrcInput is input frame height,
459 // the height of rcDstInput is output field height, for scaling ratio calculation, the
460 // bottom of rcDstInput need to multiple 2.
461 if(m_Params.interlacedScalingType == ISCALING_INTERLEAVED_TO_FIELD)
462 {
463 m_Params.input.rcDst.bottom *= 2;
464 m_Params.output.dwHeight *= 2;
465 }
466
467 VP_PUBLIC_NORMALMESSAGE("Configure scaling parameters by VP_PIPELINE_PARAMS: intput %d x %d, output %d x %d, (%d, %d, %d, %d) -> (%d, %d, %d, %d)",
468 m_Params.input.dwWidth, m_Params.input.dwHeight, m_Params.output.dwWidth, m_Params.output.dwHeight,
469 m_Params.input.rcSrc.left, m_Params.input.rcSrc.top, m_Params.input.rcSrc.right, m_Params.input.rcSrc.bottom,
470 m_Params.input.rcDst.left, m_Params.input.rcDst.top, m_Params.input.rcDst.right, m_Params.input.rcDst.bottom);
471
472 return MOS_STATUS_SUCCESS;
473 }
474
Configure(VEBOX_SFC_PARAMS & params)475 MOS_STATUS SwFilterScaling::Configure(VEBOX_SFC_PARAMS ¶ms)
476 {
477 VP_FUNC_CALL();
478
479 m_Params.isPrimary = true;
480 m_Params.scalingMode = VPHAL_SCALING_AVS;
481 m_Params.scalingPreference = VPHAL_SCALING_PREFER_SFC;
482 m_Params.bDirectionalScalar = false;
483 m_Params.formatInput = params.input.surface->Format;
484 m_Params.input.rcSrc = params.input.rcSrc;
485 m_Params.input.rcMaxSrc = params.input.rcSrc;
486 m_Params.input.dwWidth = params.input.surface->dwWidth;
487 m_Params.input.dwHeight = params.input.surface->dwHeight;
488 m_Params.formatOutput = params.output.surface->Format;
489 m_Params.csc.colorSpaceOutput = params.output.colorSpace;
490 m_Params.pColorFillParams = nullptr;
491 m_Params.pCompAlpha = nullptr;
492
493 m_Params.input.tileMode = params.input.surface->TileModeGMM;
494 m_Params.output.tileMode = params.output.surface->TileModeGMM;
495
496 VP_PUBLIC_NORMALMESSAGE("Input Surface: TileType %d, TileModeGMM %d", params.input.surface->TileType, params.input.surface->TileModeGMM);
497 VP_PUBLIC_NORMALMESSAGE("Output Surface: TileType %d, TileModeGMM %d", params.output.surface->TileType, params.output.surface->TileModeGMM);
498
499 RECT recOutput = {0, 0, (int32_t)params.output.surface->dwWidth, (int32_t)params.output.surface->dwHeight};
500
501 if (params.input.rotation == (MEDIA_ROTATION)VPHAL_ROTATION_IDENTITY ||
502 params.input.rotation == (MEDIA_ROTATION)VPHAL_ROTATION_180 ||
503 params.input.rotation == (MEDIA_ROTATION)VPHAL_MIRROR_HORIZONTAL ||
504 params.input.rotation == (MEDIA_ROTATION)VPHAL_MIRROR_VERTICAL)
505 {
506 m_Params.rotation.rotationNeeded = false;
507 m_Params.output.dwWidth = params.output.surface->dwWidth;
508 m_Params.output.dwHeight = params.output.surface->dwHeight;
509 m_Params.output.dwPitch = params.output.surface->dwPitch;
510 m_Params.input.rcDst = params.output.rcDst;
511 m_Params.output.rcSrc = recOutput;
512 m_Params.output.rcDst = recOutput;
513 m_Params.output.rcMaxSrc = recOutput;
514 }
515 else
516 {
517 m_Params.rotation.rotationNeeded = true;
518 m_Params.output.dwWidth = params.output.surface->dwHeight;
519 m_Params.output.dwHeight = params.output.surface->dwWidth;
520 m_Params.output.dwPitch = params.output.surface->dwPitch;
521
522 RECT_ROTATE(m_Params.input.rcDst, params.output.rcDst);
523 RECT_ROTATE(m_Params.output.rcSrc, recOutput);
524 RECT_ROTATE(m_Params.output.rcDst, recOutput);
525 RECT_ROTATE(m_Params.output.rcMaxSrc, recOutput);
526 }
527
528 VP_PUBLIC_NORMALMESSAGE("Configure scaling parameters by VEBOX_SFC_PARAMS: intput %d x %d, output %d x %d, (%d, %d, %d, %d) -> (%d, %d, %d, %d)",
529 m_Params.input.dwWidth, m_Params.input.dwHeight, m_Params.output.dwWidth, m_Params.output.dwHeight,
530 m_Params.input.rcSrc.left, m_Params.input.rcSrc.top, m_Params.input.rcSrc.right, m_Params.input.rcSrc.bottom,
531 m_Params.input.rcDst.left, m_Params.input.rcDst.top, m_Params.input.rcDst.right, m_Params.input.rcDst.bottom);
532
533 return MOS_STATUS_SUCCESS;
534 }
535
Configure(PVP_SURFACE surfInput,PVP_SURFACE surfOutput,VP_EXECUTE_CAPS caps)536 MOS_STATUS SwFilterScaling::Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps)
537 {
538 VP_FUNC_CALL();
539
540 VP_PUBLIC_CHK_NULL_RETURN(surfInput);
541 VP_PUBLIC_CHK_NULL_RETURN(surfInput->osSurface);
542 VP_PUBLIC_CHK_NULL_RETURN(surfOutput);
543 VP_PUBLIC_CHK_NULL_RETURN(surfOutput->osSurface);
544
545 m_Params.type = FeatureTypeScaling;
546 m_Params.formatInput = surfInput->osSurface->Format;
547 m_Params.formatOutput = surfOutput->osSurface->Format;
548
549 m_Params.input.dwWidth = surfInput->osSurface->dwWidth;
550 m_Params.input.dwHeight = surfInput->osSurface->dwHeight;
551 m_Params.input.rcSrc = surfInput->rcSrc;
552 m_Params.input.rcDst = surfInput->rcDst;
553 m_Params.input.rcMaxSrc = surfInput->rcMaxSrc;
554 m_Params.input.sampleType = surfInput->SampleType;
555
556 m_Params.rotation.rotationNeeded = false;
557 m_Params.output.dwWidth = surfOutput->osSurface->dwWidth;
558 m_Params.output.dwHeight = surfOutput->osSurface->dwHeight;
559 m_Params.output.dwPitch = surfOutput->osSurface->dwPitch;
560 m_Params.output.rcSrc = surfOutput->rcSrc;
561 m_Params.output.rcDst = surfOutput->rcDst;
562 m_Params.output.rcMaxSrc = surfOutput->rcMaxSrc;
563 m_Params.output.sampleType = surfOutput->SampleType;
564
565 m_Params.isPrimary = SURF_IN_PRIMARY == surfInput->SurfType;
566 m_Params.scalingMode = VPHAL_SCALING_NEAREST;
567 m_Params.scalingPreference = VPHAL_SCALING_PREFER_SFC;
568
569 m_Params.interlacedScalingType = ISCALING_NONE;
570 m_Params.pColorFillParams = nullptr;
571 m_Params.pCompAlpha = nullptr;
572 m_Params.bDirectionalScalar = false;
573
574 m_Params.csc.colorSpaceOutput = surfOutput->ColorSpace;
575 m_Params.rotation.rotationNeeded = false;
576
577 m_Params.input.tileMode = surfInput->osSurface->TileModeGMM;
578 m_Params.output.tileMode = surfOutput->osSurface->TileModeGMM;
579
580 VP_PUBLIC_NORMALMESSAGE("Input Surface: TileType %d, TileModeGMM %d", surfInput->osSurface->TileType, surfInput->osSurface->TileModeGMM);
581 VP_PUBLIC_NORMALMESSAGE("Output Surface: TileType %d, TileModeGMM %d", surfOutput->osSurface->TileType, surfOutput->osSurface->TileModeGMM);
582
583 VP_PUBLIC_NORMALMESSAGE("Configure scaling parameters by Surfaces: intput %d x %d, output %d x %d, (%d, %d, %d, %d) -> (%d, %d, %d, %d)",
584 m_Params.input.dwWidth, m_Params.input.dwHeight, m_Params.output.dwWidth, m_Params.output.dwHeight,
585 m_Params.input.rcSrc.left, m_Params.input.rcSrc.top, m_Params.input.rcSrc.right, m_Params.input.rcSrc.bottom,
586 m_Params.input.rcDst.left, m_Params.input.rcDst.top, m_Params.input.rcDst.right, m_Params.input.rcDst.bottom);
587
588 return MOS_STATUS_SUCCESS;
589 }
590
GetSwFilterParams()591 FeatureParamScaling &SwFilterScaling::GetSwFilterParams()
592 {
593 VP_FUNC_CALL();
594
595 return m_Params;
596 }
597
Clone()598 SwFilter *SwFilterScaling::Clone()
599 {
600 VP_FUNC_CALL();
601
602 SwFilter* p = CreateSwFilter(m_type);
603
604 SwFilterScaling *swFilter = dynamic_cast<SwFilterScaling *>(p);
605 if (nullptr == swFilter)
606 {
607 DestroySwFilter(p);
608 return nullptr;
609 }
610
611 swFilter->m_Params = m_Params;
612 return p;
613 }
614
operator ==(SwFilter & swFilter)615 bool SwFilterScaling::operator == (SwFilter& swFilter)
616 {
617 VP_FUNC_CALL();
618
619 SwFilterScaling *p = dynamic_cast<SwFilterScaling *>(&swFilter);
620 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamScaling));
621 }
622
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)623 MOS_STATUS SwFilterScaling::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe)
624 {
625 VP_FUNC_CALL();
626
627 SwFilterRotMir *rotMir = dynamic_cast<SwFilterRotMir *>(pipe.GetSwFilter(FeatureTypeRotMir));
628
629 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
630 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
631 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
632 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
633
634 m_Params.formatInput = inputSurf->osSurface->Format;
635 m_Params.formatOutput = outputSurf->osSurface->Format;
636 m_Params.csc.colorSpaceOutput = outputSurf->ColorSpace;
637
638 if (rotMir &&
639 VpUtils::IsVerticalRotation(rotMir->GetSwFilterParams().rotation))
640 {
641 m_Params.rotation.rotationNeeded = true;
642
643 // Update the rectangle on input surface. The input surface may be used as output in previous
644 // step, in which case the rectangle may be different.
645 // The rcDst in surface should be the one after rotation.
646 inputSurf->rcSrc = m_Params.input.rcSrc;
647 RECT_ROTATE(inputSurf->rcDst, m_Params.input.rcDst);
648 inputSurf->rcMaxSrc = m_Params.input.rcMaxSrc;
649 }
650 else
651 {
652 // 90/270 rotation has been done in execute pipe. Update scaling parameters in swfilter.
653 if (m_Params.rotation.rotationNeeded && !m_isInExePipe)
654 {
655 // width and height cannot be used to check whether rotation has been done,
656 // as width and height may be same.
657 if (m_Params.input.dwWidth != inputSurf->osSurface->dwHeight ||
658 m_Params.input.dwHeight != inputSurf->osSurface->dwWidth ||
659 m_Params.output.dwWidth != outputSurf->osSurface->dwHeight ||
660 m_Params.output.dwHeight != outputSurf->osSurface->dwWidth)
661 {
662 VP_PUBLIC_ASSERTMESSAGE("The Rotation not matching between input params and output params of scaling.");
663 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
664 }
665 // For VE-SFC + FC case, scaling is done by sfc, but scaling filter is still needed
666 // by render workload for composition position.
667 VP_PUBLIC_NORMALMESSAGE("Rotation has been done in execute pipe. Update scaling parameters.");
668 swap(m_Params.input.dwWidth, m_Params.input.dwHeight);
669 RECT tmp = m_Params.input.rcSrc;
670 RECT_ROTATE(m_Params.input.rcSrc, tmp);
671 tmp = m_Params.input.rcDst;
672 RECT_ROTATE(m_Params.input.rcDst, tmp);
673 tmp = m_Params.input.rcMaxSrc;
674 RECT_ROTATE(m_Params.input.rcMaxSrc, tmp);
675
676 swap(m_Params.output.dwWidth, m_Params.output.dwHeight);
677 tmp = m_Params.output.rcSrc;
678 RECT_ROTATE(m_Params.output.rcSrc, tmp);
679 tmp = m_Params.output.rcDst;
680 RECT_ROTATE(m_Params.output.rcDst, tmp);
681 tmp = m_Params.output.rcMaxSrc;
682 RECT_ROTATE(m_Params.output.rcMaxSrc, tmp);
683 }
684
685 m_Params.rotation.rotationNeeded = false;
686
687 // Update the rectangle on input surface. The input surface may be used as output in previous
688 // step, in which case the rectangle may be different.
689 inputSurf->rcSrc = m_Params.input.rcSrc;
690 inputSurf->rcDst = m_Params.input.rcDst;
691 inputSurf->rcMaxSrc = m_Params.input.rcMaxSrc;
692 }
693
694 // update source sample type for field to interleaved mode.
695 m_Params.input.sampleType = inputSurf->SampleType;
696
697 VP_PUBLIC_NORMALMESSAGE("Update scaling parameters: intput %d x %d, output %d x %d, (%d, %d, %d, %d) -> (%d, %d, %d, %d)",
698 m_Params.input.dwWidth, m_Params.input.dwHeight, m_Params.output.dwWidth, m_Params.output.dwHeight,
699 m_Params.input.rcSrc.left, m_Params.input.rcSrc.top, m_Params.input.rcSrc.right, m_Params.input.rcSrc.bottom,
700 m_Params.input.rcDst.left, m_Params.input.rcDst.top, m_Params.input.rcDst.right, m_Params.input.rcDst.bottom);
701
702 return MOS_STATUS_SUCCESS;
703 }
704 /****************************************************************************************************/
705 /* SwFilter Rotation/Mirror */
706 /****************************************************************************************************/
707
SwFilterRotMir(VpInterface & vpInterface)708 SwFilterRotMir::SwFilterRotMir(VpInterface &vpInterface) : SwFilter(vpInterface, FeatureTypeRotMir)
709 {
710 m_Params.type = m_type;
711 }
712
~SwFilterRotMir()713 SwFilterRotMir::~SwFilterRotMir()
714 {
715 Clean();
716 }
717
Clean()718 MOS_STATUS SwFilterRotMir::Clean()
719 {
720 VP_FUNC_CALL();
721
722 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
723 return MOS_STATUS_SUCCESS;
724 }
725
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)726 MOS_STATUS SwFilterRotMir::Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex)
727 {
728 VP_FUNC_CALL();
729
730 // Parameter checking should be done in SwFilterRotMirHandler::IsFeatureEnabled.
731 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
732 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
733
734 m_Params.rotation = surfInput->Rotation;
735 m_Params.surfInfo.tileOutput = surfOutput->TileType;
736 m_Params.formatInput = surfInput->Format;
737 m_Params.formatOutput = surfOutput->Format;
738 return MOS_STATUS_SUCCESS;
739 }
740
Configure(VEBOX_SFC_PARAMS & params)741 MOS_STATUS SwFilterRotMir::Configure(VEBOX_SFC_PARAMS ¶ms)
742 {
743 VP_FUNC_CALL();
744
745 // Parameter checking should be done in SwFilterRotMirHandler::IsFeatureEnabled.
746 m_Params.rotation = (VPHAL_ROTATION)params.input.rotation;
747 m_Params.surfInfo.tileOutput = params.output.surface->TileType;
748 m_Params.formatInput = params.input.surface->Format;
749 m_Params.formatOutput = params.output.surface->Format;
750 return MOS_STATUS_SUCCESS;
751 }
752
GetSwFilterParams()753 FeatureParamRotMir &SwFilterRotMir::GetSwFilterParams()
754 {
755 VP_FUNC_CALL();
756
757 return m_Params;
758 }
759
Clone()760 SwFilter *SwFilterRotMir::Clone()
761 {
762 VP_FUNC_CALL();
763
764 SwFilter* p = CreateSwFilter(m_type);
765
766 SwFilterRotMir *swFilter = dynamic_cast<SwFilterRotMir *>(p);
767 if (nullptr == swFilter)
768 {
769 DestroySwFilter(p);
770 return nullptr;
771 }
772
773 swFilter->m_Params = m_Params;
774 return p;
775 }
776
operator ==(SwFilter & swFilter)777 bool SwFilterRotMir::operator == (SwFilter& swFilter)
778 {
779 VP_FUNC_CALL();
780
781 SwFilterRotMir *p = dynamic_cast<SwFilterRotMir *>(&swFilter);
782 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamRotMir));
783 }
784
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)785 MOS_STATUS SwFilterRotMir::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe)
786 {
787 VP_FUNC_CALL();
788
789 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
790 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
791 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
792 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
793 m_Params.formatInput = inputSurf->osSurface->Format;
794 m_Params.formatOutput = outputSurf->osSurface->Format;
795 m_Params.surfInfo.tileOutput = outputSurf->osSurface->TileType;
796 return MOS_STATUS_SUCCESS;
797 }
798
799 /****************************************************************************************************/
800 /* SwFilterDenoise */
801 /****************************************************************************************************/
802
SwFilterDenoise(VpInterface & vpInterface)803 SwFilterDenoise::SwFilterDenoise(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeDn)
804 {
805 m_Params.type = m_type;
806 }
807
~SwFilterDenoise()808 SwFilterDenoise::~SwFilterDenoise()
809 {
810 Clean();
811 }
812
Clean()813 MOS_STATUS SwFilterDenoise::Clean()
814 {
815 VP_FUNC_CALL();
816
817 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
818 return MOS_STATUS_SUCCESS;
819 }
820
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)821 MOS_STATUS SwFilterDenoise::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
822 {
823 VP_FUNC_CALL();
824
825 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
826
827 m_Params.sampleTypeInput = surfInput->SampleType;
828 m_Params.denoiseParams = *surfInput->pDenoiseParams;
829 m_Params.formatInput = surfInput->Format;
830 m_Params.formatOutput = surfInput->Format;// Denoise didn't change the original format;
831 m_Params.heightInput = surfInput->dwHeight;
832 m_Params.srcBottom = surfInput->rcSrc.bottom;
833
834 m_Params.denoiseParams.bEnableChroma =
835 m_Params.denoiseParams.bEnableChroma && m_Params.denoiseParams.bEnableLuma;
836 #if !EMUL
837 GMM_RESOURCE_INFO* pSrcGmmResInfo = surfInput->OsResource.pGmmResInfo;
838 GMM_RESOURCE_INFO* pTargetGmmResInfo = params.pTarget[0]->OsResource.pGmmResInfo;
839 VP_PUBLIC_CHK_NULL_RETURN(pSrcGmmResInfo);
840 VP_PUBLIC_CHK_NULL_RETURN(pTargetGmmResInfo);
841
842 bool inputProtected = pSrcGmmResInfo->GetSetCpSurfTag(0, 0);
843 bool outputProtected = pTargetGmmResInfo->GetSetCpSurfTag(0, 0);
844
845 if (inputProtected || outputProtected ||
846 (m_vpInterface.GetHwInterface()->m_osInterface->osCpInterface &&
847 m_vpInterface.GetHwInterface()->m_osInterface->osCpInterface->IsHMEnabled()))
848 {
849 m_Params.secureDnNeeded = true;
850 }
851 #endif
852
853 VP_PUBLIC_NORMALMESSAGE("denoiseLevel = %d,secureDn = %d, AutoDn = %d", m_Params.denoiseParams.NoiseLevel, m_Params.secureDnNeeded, m_Params.denoiseParams.bAutoDetect);
854 return MOS_STATUS_SUCCESS;
855 }
856
Configure(FeatureParamDenoise & params)857 MOS_STATUS SwFilterDenoise::Configure(FeatureParamDenoise ¶ms)
858 {
859 VP_FUNC_CALL();
860
861 m_Params.sampleTypeInput = params.sampleTypeInput;
862 m_Params.denoiseParams = params.denoiseParams;
863 m_Params.formatInput = params.formatInput;
864 m_Params.formatOutput = params.formatOutput;
865 m_Params.heightInput = params.heightInput;
866 m_Params.secureDnNeeded = params.secureDnNeeded;
867
868 VP_PUBLIC_NORMALMESSAGE("denoiseLevel = %d,secureDn = %d, AutoDn = %d", m_Params.denoiseParams.NoiseLevel, m_Params.secureDnNeeded, m_Params.denoiseParams.bAutoDetect);
869 return MOS_STATUS_SUCCESS;
870 }
871
GetSwFilterParams()872 FeatureParamDenoise& SwFilterDenoise::GetSwFilterParams()
873 {
874 VP_FUNC_CALL();
875
876 return m_Params;
877 }
878
Clone()879 SwFilter *SwFilterDenoise::Clone()
880 {
881 VP_FUNC_CALL();
882
883 SwFilter* p = CreateSwFilter(m_type);
884
885 SwFilterDenoise *swFilter = dynamic_cast<SwFilterDenoise *>(p);
886 if (nullptr == swFilter)
887 {
888 DestroySwFilter(p);
889 return nullptr;
890 }
891
892 swFilter->m_Params = m_Params;
893 return p;
894 }
895
operator ==(SwFilter & swFilter)896 bool SwFilterDenoise::operator==(SwFilter& swFilter)
897 {
898 VP_FUNC_CALL();
899
900 SwFilterDenoise* p = dynamic_cast<SwFilterDenoise*>(&swFilter);
901 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamDenoise));
902 }
903
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)904 MOS_STATUS SwFilterDenoise::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
905 {
906 VP_FUNC_CALL();
907
908 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
909 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
910 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
911 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
912 m_Params.formatInput = inputSurf->osSurface->Format;
913 m_Params.formatOutput = outputSurf->osSurface->Format;
914 return MOS_STATUS_SUCCESS;
915 }
916
917 /****************************************************************************************************/
918 /* SwFilterDeinterlace */
919 /****************************************************************************************************/
920
SwFilterDeinterlace(VpInterface & vpInterface)921 SwFilterDeinterlace::SwFilterDeinterlace(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeDi)
922 {
923 m_Params.type = m_type;
924 }
925
~SwFilterDeinterlace()926 SwFilterDeinterlace::~SwFilterDeinterlace()
927 {
928 Clean();
929 }
930
Clean()931 MOS_STATUS SwFilterDeinterlace::Clean()
932 {
933 VP_FUNC_CALL();
934
935 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
936 MOS_ZeroMemory(&m_Params, sizeof(m_Params));
937 return MOS_STATUS_SUCCESS;
938 }
939
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)940 MOS_STATUS SwFilterDeinterlace::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
941 {
942 VP_FUNC_CALL();
943
944 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
945 VP_PUBLIC_CHK_NULL_RETURN(surfInput);
946 VP_PUBLIC_CHK_NULL_RETURN(surfInput->pDeinterlaceParams);
947
948 MOS_ZeroMemory(&m_Params, sizeof(m_Params));
949
950 m_Params.formatInput = surfInput->Format;
951 m_Params.formatOutput = surfInput->Format;
952 m_Params.sampleTypeInput = surfInput->SampleType;
953 m_Params.diParams = surfInput->pDeinterlaceParams;
954 m_Params.bHDContent = MEDIA_IS_HDCONTENT(surfInput->dwWidth, surfInput->dwHeight);
955 m_Params.bQueryVarianceEnable = false; // Feature is not supported in current filter, disable in current stage
956 m_Params.heightInput = surfInput->dwHeight;
957 m_Params.rcSrc = surfInput->rcSrc;
958
959 return MOS_STATUS_SUCCESS;
960 }
961
GetSwFilterParams()962 FeatureParamDeinterlace& SwFilterDeinterlace::GetSwFilterParams()
963 {
964 VP_FUNC_CALL();
965
966 return m_Params;
967 }
968
Clone()969 SwFilter *SwFilterDeinterlace::Clone()
970 {
971 VP_FUNC_CALL();
972
973 SwFilter* p = CreateSwFilter(m_type);
974
975 SwFilterDeinterlace *swFilter = dynamic_cast<SwFilterDeinterlace *>(p);
976 if (nullptr == swFilter)
977 {
978 DestroySwFilter(p);
979 return nullptr;
980 }
981
982 swFilter->m_Params = m_Params;
983 return p;
984 }
985
operator ==(SwFilter & swFilter)986 bool vp::SwFilterDeinterlace::operator==(SwFilter& swFilter)
987 {
988 VP_FUNC_CALL();
989
990 SwFilterDeinterlace* p = dynamic_cast<SwFilterDeinterlace*>(&swFilter);
991 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamDeinterlace));
992 }
993
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)994 MOS_STATUS vp::SwFilterDeinterlace::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
995 {
996 VP_FUNC_CALL();
997
998 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
999 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1000 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1001 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1002 m_Params.formatInput = inputSurf->osSurface->Format;
1003 m_Params.formatOutput = outputSurf->osSurface->Format;
1004 return MOS_STATUS_SUCCESS;
1005 }
1006
1007 /****************************************************************************************************/
1008 /* SwFilterSte */
1009 /****************************************************************************************************/
1010
SwFilterSte(VpInterface & vpInterface)1011 SwFilterSte::SwFilterSte(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeSte)
1012 {
1013 m_Params.type = m_type;
1014 }
1015
~SwFilterSte()1016 SwFilterSte::~SwFilterSte()
1017 {
1018 Clean();
1019 }
1020
Clean()1021 MOS_STATUS SwFilterSte::Clean()
1022 {
1023 VP_FUNC_CALL();
1024
1025 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1026 return MOS_STATUS_SUCCESS;
1027 }
1028
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1029 MOS_STATUS SwFilterSte::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1030 {
1031 VP_FUNC_CALL();
1032
1033 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
1034
1035 m_Params.formatInput = surfInput->Format;
1036 m_Params.formatOutput = surfInput->Format; // STE didn't change the original format;
1037
1038 if (surfInput->pColorPipeParams)
1039 {
1040 m_Params.bEnableSTE = surfInput->pColorPipeParams->bEnableSTE;
1041 m_Params.bEnableSTD = surfInput->pColorPipeParams->bEnableSTD;
1042 m_Params.STDParam = surfInput->pColorPipeParams->StdParams;
1043 m_Params.dwSTEFactor = surfInput->pColorPipeParams->SteParams.dwSTEFactor;
1044 }
1045 else
1046 {
1047 m_Params.bEnableSTE = false;
1048 m_Params.bEnableSTD = false;
1049 m_Params.STDParam = {};
1050 m_Params.dwSTEFactor = 0;
1051 }
1052
1053 return MOS_STATUS_SUCCESS;
1054 }
1055
GetSwFilterParams()1056 FeatureParamSte& SwFilterSte::GetSwFilterParams()
1057 {
1058 VP_FUNC_CALL();
1059
1060 return m_Params;
1061 }
1062
Clone()1063 SwFilter * SwFilterSte::Clone()
1064 {
1065 VP_FUNC_CALL();
1066
1067 SwFilter* p = CreateSwFilter(m_type);
1068
1069 SwFilterSte *swFilter = dynamic_cast<SwFilterSte *>(p);
1070 if (nullptr == swFilter)
1071 {
1072 DestroySwFilter(p);
1073 return nullptr;
1074 }
1075
1076 swFilter->m_Params = m_Params;
1077 return p;
1078 }
1079
operator ==(SwFilter & swFilter)1080 bool vp::SwFilterSte::operator==(SwFilter& swFilter)
1081 {
1082 VP_FUNC_CALL();
1083
1084 SwFilterSte* p = dynamic_cast<SwFilterSte*>(&swFilter);
1085 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamSte));
1086 }
1087
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1088 MOS_STATUS vp::SwFilterSte::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1089 {
1090 VP_FUNC_CALL();
1091
1092 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1093 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1094 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1095 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1096 m_Params.formatInput = inputSurf->osSurface->Format;
1097 m_Params.formatOutput = outputSurf->osSurface->Format;
1098 return MOS_STATUS_SUCCESS;
1099 }
1100
1101 /****************************************************************************************************/
1102 /* SwFilterTcc */
1103 /****************************************************************************************************/
1104
SwFilterTcc(VpInterface & vpInterface)1105 SwFilterTcc::SwFilterTcc(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeTcc)
1106 {
1107 m_Params.type = m_type;
1108 }
1109
~SwFilterTcc()1110 SwFilterTcc::~SwFilterTcc()
1111 {
1112 Clean();
1113 }
1114
Clean()1115 MOS_STATUS SwFilterTcc::Clean()
1116 {
1117 VP_FUNC_CALL();
1118
1119 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1120 return MOS_STATUS_SUCCESS;
1121 }
1122
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1123 MOS_STATUS SwFilterTcc::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1124 {
1125 VP_FUNC_CALL();
1126
1127 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
1128
1129 m_Params.formatInput = surfInput->Format;
1130 m_Params.formatOutput = surfInput->Format;// TCC didn't change the original format;
1131
1132 if (surfInput->pColorPipeParams)
1133 {
1134 m_Params.bEnableTCC = surfInput->pColorPipeParams->bEnableTCC;
1135 m_Params.Red = surfInput->pColorPipeParams->TccParams.Red;
1136 m_Params.Green = surfInput->pColorPipeParams->TccParams.Green;
1137 m_Params.Blue = surfInput->pColorPipeParams->TccParams.Blue;
1138 m_Params.Cyan = surfInput->pColorPipeParams->TccParams.Cyan;
1139 m_Params.Magenta = surfInput->pColorPipeParams->TccParams.Magenta;
1140 m_Params.Yellow = surfInput->pColorPipeParams->TccParams.Yellow;
1141 }
1142 else
1143 {
1144 m_Params.bEnableTCC = false;
1145 m_Params.Red = 0;
1146 m_Params.Green = 0;
1147 m_Params.Blue = 0;
1148 m_Params.Cyan = 0;
1149 m_Params.Magenta = 0;
1150 m_Params.Yellow = 0;
1151 }
1152
1153 return MOS_STATUS_SUCCESS;
1154 }
1155
GetSwFilterParams()1156 FeatureParamTcc& SwFilterTcc::GetSwFilterParams()
1157 {
1158 VP_FUNC_CALL();
1159
1160 return m_Params;
1161 }
1162
Clone()1163 SwFilter * SwFilterTcc::Clone()
1164 {
1165 VP_FUNC_CALL();
1166
1167 SwFilter* p = CreateSwFilter(m_type);
1168
1169 SwFilterTcc *swFilter = dynamic_cast<SwFilterTcc *>(p);
1170 if (nullptr == swFilter)
1171 {
1172 DestroySwFilter(p);
1173 return nullptr;
1174 }
1175
1176 swFilter->m_Params = m_Params;
1177 return p;
1178 }
1179
operator ==(SwFilter & swFilter)1180 bool vp::SwFilterTcc::operator==(SwFilter& swFilter)
1181 {
1182 VP_FUNC_CALL();
1183
1184 SwFilterTcc* p = dynamic_cast<SwFilterTcc*>(&swFilter);
1185 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamTcc));
1186 }
1187
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1188 MOS_STATUS vp::SwFilterTcc::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1189 {
1190 VP_FUNC_CALL();
1191
1192 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1193 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1194 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1195 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1196 m_Params.formatInput = inputSurf->osSurface->Format;
1197 m_Params.formatOutput = outputSurf->osSurface->Format;
1198 return MOS_STATUS_SUCCESS;
1199 }
1200
1201 /****************************************************************************************************/
1202 /* SwFilterProcamp */
1203 /****************************************************************************************************/
1204
SwFilterProcamp(VpInterface & vpInterface)1205 SwFilterProcamp::SwFilterProcamp(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeProcamp)
1206 {
1207 m_Params.type = m_type;
1208 }
1209
~SwFilterProcamp()1210 SwFilterProcamp::~SwFilterProcamp()
1211 {
1212 Clean();
1213 }
1214
Clean()1215 MOS_STATUS SwFilterProcamp::Clean()
1216 {
1217 VP_FUNC_CALL();
1218
1219 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1220 return MOS_STATUS_SUCCESS;
1221 }
1222
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1223 MOS_STATUS SwFilterProcamp::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1224 {
1225 VP_FUNC_CALL();
1226
1227 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
1228
1229 m_Params.formatInput = surfInput->Format;
1230 m_Params.formatOutput = surfInput->Format;// Procamp didn't change the original format;
1231
1232 m_Params.procampParams = surfInput->pProcampParams;
1233
1234 return MOS_STATUS_SUCCESS;
1235 }
1236
GetSwFilterParams()1237 FeatureParamProcamp& SwFilterProcamp::GetSwFilterParams()
1238 {
1239 VP_FUNC_CALL();
1240
1241 return m_Params;
1242 }
1243
Clone()1244 SwFilter * SwFilterProcamp::Clone()
1245 {
1246 VP_FUNC_CALL();
1247
1248 SwFilter* p = CreateSwFilter(m_type);
1249
1250 SwFilterProcamp *swFilter = dynamic_cast<SwFilterProcamp *>(p);
1251 if (nullptr == swFilter)
1252 {
1253 DestroySwFilter(p);
1254 return nullptr;
1255 }
1256
1257 swFilter->m_Params = m_Params;
1258 return p;
1259 }
1260
operator ==(SwFilter & swFilter)1261 bool vp::SwFilterProcamp::operator==(SwFilter& swFilter)
1262 {
1263 VP_FUNC_CALL();
1264
1265 SwFilterProcamp* p = dynamic_cast<SwFilterProcamp*>(&swFilter);
1266 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamProcamp));
1267 }
1268
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1269 MOS_STATUS vp::SwFilterProcamp::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1270 {
1271 VP_FUNC_CALL();
1272
1273 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1274 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1275 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1276 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1277 m_Params.formatInput = inputSurf->osSurface->Format;
1278 m_Params.formatOutput = outputSurf->osSurface->Format;
1279 return MOS_STATUS_SUCCESS;
1280 }
1281
1282 /****************************************************************************************************/
1283 /* SwFilterHdr */
1284 /****************************************************************************************************/
SwFilterHdr(VpInterface & vpInterface)1285 SwFilterHdr::SwFilterHdr(VpInterface &vpInterface) : SwFilter(vpInterface, FeatureTypeHdr)
1286 {
1287 m_Params.type = m_type;
1288 }
1289
~SwFilterHdr()1290 SwFilterHdr::~SwFilterHdr()
1291 {
1292 Clean();
1293 }
1294
Clean()1295 MOS_STATUS SwFilterHdr::Clean()
1296 {
1297 VP_FUNC_CALL();
1298
1299 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1300 return MOS_STATUS_SUCCESS;
1301 }
1302
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1303 MOS_STATUS SwFilterHdr::Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex)
1304 {
1305 VP_FUNC_CALL();
1306 PVPHAL_SURFACE surfInput = isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0];
1307 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
1308 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1309 uint32_t i = 0;
1310 uint32_t dwUpdateMask = 0;
1311 bool bSupported = false;
1312 VPHAL_HDR_LUT_MODE CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
1313 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface());
1314 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_userFeatureControl);
1315 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_vpPlatformInterface);
1316 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_reporting);
1317
1318 auto userFeatureControl = m_vpInterface.GetHwInterface()->m_userFeatureControl;
1319 auto vpPlatformInterface = m_vpInterface.GetHwInterface()->m_vpPlatformInterface;
1320 VpFeatureReport *vpFeatureReport = dynamic_cast<VpFeatureReport *>(m_vpInterface.GetHwInterface()->m_reporting);
1321 #if (_DEBUG || _RELEASE_INTERNAL)
1322 m_Params.isL0KernelEnabled = (vpPlatformInterface->IsAdvanceNativeKernelSupported() && userFeatureControl->EnableL03DLut());
1323 vpFeatureReport->GetFeatures().isL03DLut = m_Params.isL0KernelEnabled;
1324 #endif
1325
1326 VP_PUBLIC_CHK_NULL_RETURN(surfInput);
1327 VP_PUBLIC_CHK_NULL_RETURN(surfOutput);
1328 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface());
1329 VP_PUBLIC_CHK_NULL_RETURN(m_vpInterface.GetHwInterface()->m_osInterface);
1330
1331 m_Params.formatInput = surfInput->Format;
1332 m_Params.formatOutput = surfOutput->Format;
1333 m_Params.widthInput = surfInput->dwWidth;
1334 m_Params.heightInput = surfInput->dwHeight;
1335 if (surfInput->p3DLutParams)
1336 {
1337 m_Params.external3DLutParams = surfInput->p3DLutParams;
1338 }
1339
1340 // For H2S, it is possible that there is no HDR params for render target.
1341 m_Params.uiMaxContentLevelLum = 4000;
1342 m_Params.srcColorSpace = surfInput->ColorSpace;
1343 m_Params.dstColorSpace = surfOutput->ColorSpace;
1344
1345 if (surfInput->pHDRParams)
1346 {
1347 m_Params.uiMaxContentLevelLum = surfInput->pHDRParams->MaxCLL;
1348 if (surfInput->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084 ||
1349 (surfInput->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR && IS_RGB64_FLOAT_FORMAT(surfInput->Format))) // For FP16 HDR CSC typical usage
1350 {
1351 m_Params.hdrMode = VPHAL_HDR_MODE_TONE_MAPPING;
1352 if (surfOutput->pHDRParams)
1353 {
1354 m_Params.uiMaxDisplayLum = surfOutput->pHDRParams->max_display_mastering_luminance;
1355 if (surfOutput->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
1356 {
1357 m_Params.hdrMode = VPHAL_HDR_MODE_H2H;
1358 }
1359 }
1360 }
1361 else if (surfInput->pHDRParams->EOTF == VPHAL_HDR_EOTF_TRADITIONAL_GAMMA_SDR && surfOutput->pHDRParams->EOTF == VPHAL_HDR_EOTF_SMPTE_ST2084)
1362 {
1363 m_Params.hdrMode = VPHAL_HDR_MODE_INVERSE_TONE_MAPPING;
1364 }
1365 }
1366
1367 m_Params.pColorFillParams = params.pColorFillParams;
1368
1369 if (surfInput->SurfType == SURF_IN_PRIMARY && m_Params.globalLutMode != VPHAL_HDR_LUT_MODE_3D)
1370 {
1371 CurrentLUTMode = VPHAL_HDR_LUT_MODE_2D;
1372 }
1373 else
1374 {
1375 CurrentLUTMode = VPHAL_HDR_LUT_MODE_3D;
1376 }
1377
1378 // Neither 1D nor 3D LUT is needed in linear output case.
1379 if (IS_RGB64_FLOAT_FORMAT(surfOutput->Format))
1380 {
1381 CurrentLUTMode = VPHAL_HDR_LUT_MODE_NONE;
1382 }
1383
1384 m_Params.lutMode = CurrentLUTMode;
1385
1386 VP_PUBLIC_CHK_STATUS_RETURN(HdrIsInputFormatSupported(surfInput, &bSupported));
1387
1388 if (!bSupported)
1389 {
1390 VP_RENDER_ASSERTMESSAGE("HDR Unsupported Source Format\n");
1391 return MOS_STATUS_SUCCESS;
1392 }
1393
1394 if (surfInput && surfInput->pHDRParams)
1395 {
1396 MOS_SecureMemcpy(&m_Params.srcHDRParams, sizeof(HDR_PARAMS), (HDR_PARAMS *)surfInput->pHDRParams, sizeof(HDR_PARAMS));
1397 }
1398 else
1399 {
1400 MOS_ZeroMemory(&m_Params.srcHDRParams, sizeof(HDR_PARAMS));
1401 }
1402
1403 VP_PUBLIC_CHK_STATUS_RETURN(HdrIsOutputFormatSupported(surfOutput, &bSupported));
1404
1405 if (!bSupported)
1406 {
1407 VP_RENDER_ASSERTMESSAGE("HDR Unsupported Target Format\n");
1408 return MOS_STATUS_SUCCESS;
1409 }
1410
1411 if (surfOutput && surfOutput->pHDRParams)
1412 {
1413 MOS_SecureMemcpy(&m_Params.targetHDRParams, sizeof(HDR_PARAMS), (HDR_PARAMS *)surfOutput->pHDRParams, sizeof(HDR_PARAMS));
1414 }
1415 else
1416 {
1417 MOS_ZeroMemory(&m_Params.targetHDRParams, sizeof(HDR_PARAMS));
1418 }
1419
1420 return MOS_STATUS_SUCCESS;
1421 }
1422
GetSwFilterParams()1423 FeatureParamHdr &SwFilterHdr::GetSwFilterParams()
1424 {
1425 VP_FUNC_CALL();
1426
1427 return m_Params;
1428 }
1429
Clone()1430 SwFilter *SwFilterHdr::Clone()
1431 {
1432 VP_FUNC_CALL();
1433
1434 SwFilter *p = CreateSwFilter(m_type);
1435
1436 SwFilterHdr *swFilter = dynamic_cast<SwFilterHdr *>(p);
1437 if (nullptr == swFilter)
1438 {
1439 DestroySwFilter(p);
1440 return nullptr;
1441 }
1442
1443 swFilter->m_Params = m_Params;
1444 return p;
1445 }
1446
1447 //!
1448 //! \brief Checks to see if HDR can be enabled for the formats
1449 //! \details Checks to see if HDR can be enabled for the formats
1450 //! \param PVPHAL_SURFACE pSrcSurface
1451 //! [in] Pointer to source surface
1452 //! \param bool* pbSupported
1453 //! [out] true supported false not supported
1454 //! \return MOS_STATUS
1455 //! MOS_STATUS_SUCCESS if successful, otherwise failed
1456 //!
HdrIsInputFormatSupported(PVPHAL_SURFACE pSrcSurface,bool * pbSupported)1457 MOS_STATUS SwFilterHdr::HdrIsInputFormatSupported(
1458 PVPHAL_SURFACE pSrcSurface,
1459 bool *pbSupported)
1460 {
1461 VP_FUNC_CALL();
1462
1463 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1464
1465 VP_PUBLIC_CHK_NULL(pSrcSurface);
1466 VP_PUBLIC_CHK_NULL(pbSupported);
1467
1468 // HDR supported formats
1469 if (pSrcSurface->Format == Format_A8R8G8B8 ||
1470 pSrcSurface->Format == Format_X8R8G8B8 ||
1471 pSrcSurface->Format == Format_A8B8G8R8 ||
1472 pSrcSurface->Format == Format_X8B8G8R8 ||
1473 pSrcSurface->Format == Format_R10G10B10A2 ||
1474 pSrcSurface->Format == Format_B10G10R10A2 ||
1475 pSrcSurface->Format == Format_A16B16G16R16 ||
1476 pSrcSurface->Format == Format_A16R16G16B16 ||
1477 pSrcSurface->Format == Format_A16B16G16R16F ||
1478 pSrcSurface->Format == Format_A16R16G16B16F ||
1479 pSrcSurface->Format == Format_P016 ||
1480 pSrcSurface->Format == Format_NV12 ||
1481 pSrcSurface->Format == Format_P010 ||
1482 pSrcSurface->Format == Format_YUY2 ||
1483 pSrcSurface->Format == Format_AYUV ||
1484 pSrcSurface->Format == Format_Y410 ||
1485 pSrcSurface->Format == Format_Y416 ||
1486 pSrcSurface->Format == Format_Y210 ||
1487 pSrcSurface->Format == Format_Y216)
1488 {
1489 *pbSupported = true;
1490 goto finish;
1491 }
1492 else
1493 {
1494 VP_RENDER_ASSERTMESSAGE(
1495 "HDR Unsupported Source Format: '0x%08x'\n",
1496 pSrcSurface->Format);
1497 *pbSupported = false;
1498 }
1499
1500 finish:
1501 return eStatus;
1502 }
1503
1504 //!
1505 //! \brief Checks to see if HDR can be enabled for the formats
1506 //! \details Checks to see if HDR can be enabled for the formats
1507 //! \param PVPHAL_SURFACE pTargetSurface
1508 //! [in] Pointer to target surface
1509 //! \param bool* pbSupported
1510 //! [out] true supported false not supported
1511 //! \return MOS_STATUS
1512 //! MOS_STATUS_SUCCESS if successful, otherwise failed
1513 //!
HdrIsOutputFormatSupported(PVPHAL_SURFACE pTargetSurface,bool * pbSupported)1514 MOS_STATUS SwFilterHdr::HdrIsOutputFormatSupported(
1515 PVPHAL_SURFACE pTargetSurface,
1516 bool *pbSupported)
1517 {
1518 VP_FUNC_CALL();
1519
1520 MOS_STATUS eStatus = MOS_STATUS_SUCCESS;
1521
1522 VP_PUBLIC_CHK_NULL(pTargetSurface);
1523 VP_PUBLIC_CHK_NULL(pbSupported);
1524
1525 // HDR supported formats
1526 if (pTargetSurface->Format == Format_A8R8G8B8 ||
1527 pTargetSurface->Format == Format_X8R8G8B8 ||
1528 pTargetSurface->Format == Format_A8B8G8R8 ||
1529 pTargetSurface->Format == Format_X8B8G8R8 ||
1530 pTargetSurface->Format == Format_R10G10B10A2 ||
1531 pTargetSurface->Format == Format_B10G10R10A2 ||
1532 pTargetSurface->Format == Format_A16B16G16R16 ||
1533 pTargetSurface->Format == Format_A16R16G16B16 ||
1534 pTargetSurface->Format == Format_YUY2 ||
1535 pTargetSurface->Format == Format_P016 ||
1536 pTargetSurface->Format == Format_NV12 ||
1537 pTargetSurface->Format == Format_P010 ||
1538 pTargetSurface->Format == Format_P016 ||
1539 pTargetSurface->Format == Format_A16R16G16B16F ||
1540 pTargetSurface->Format == Format_A16B16G16R16F)
1541 {
1542 *pbSupported = true;
1543 goto finish;
1544 }
1545 else
1546 {
1547 VP_RENDER_ASSERTMESSAGE(
1548 "HDR Unsupported Target Format: '0x%08x'\n",
1549 pTargetSurface->Format);
1550 *pbSupported = false;
1551 }
1552
1553 finish:
1554 return eStatus;
1555 }
1556
operator ==(SwFilter & swFilter)1557 bool vp::SwFilterHdr::operator==(SwFilter &swFilter)
1558 {
1559 VP_FUNC_CALL();
1560
1561 SwFilterHdr *p = dynamic_cast<SwFilterHdr *>(&swFilter);
1562 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamHdr));
1563 }
1564
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1565 MOS_STATUS vp::SwFilterHdr::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe)
1566 {
1567 VP_FUNC_CALL();
1568
1569 if (m_Params.stage == HDR_STAGE_VEBOX_3DLUT_UPDATE)
1570 {
1571 VP_PUBLIC_NORMALMESSAGE("HDR 3DLUT Kernel path already update format, skip further update.");
1572 return MOS_STATUS_SUCCESS;
1573 }
1574
1575 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1576 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1577 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1578 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1579 m_Params.formatInput = inputSurf->osSurface->Format;
1580 m_Params.formatOutput = outputSurf->osSurface->Format;
1581 return MOS_STATUS_SUCCESS;
1582 }
1583
1584 /****************************************************************************************************/
1585 /* SwFilterLumakey */
1586 /****************************************************************************************************/
1587
SwFilterLumakey(VpInterface & vpInterface)1588 SwFilterLumakey::SwFilterLumakey(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeLumakey)
1589 {
1590 m_Params.type = m_type;
1591 }
1592
~SwFilterLumakey()1593 SwFilterLumakey::~SwFilterLumakey()
1594 {
1595 Clean();
1596 }
1597
Clean()1598 MOS_STATUS SwFilterLumakey::Clean()
1599 {
1600 VP_FUNC_CALL();
1601
1602 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1603 return MOS_STATUS_SUCCESS;
1604 }
1605
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1606 MOS_STATUS SwFilterLumakey::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1607 {
1608 VP_FUNC_CALL();
1609
1610 if (!isInputSurf ||
1611 nullptr == params.pSrc[surfIndex]->pLumaKeyParams)
1612 {
1613 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1614 }
1615
1616 auto surfInput = params.pSrc[surfIndex];
1617
1618 m_Params.formatInput = surfInput->Format;
1619 m_Params.formatOutput = surfInput->Format;
1620 m_Params.lumaKeyParams = surfInput->pLumaKeyParams;
1621
1622 return MOS_STATUS_SUCCESS;
1623 }
1624
GetSwFilterParams()1625 FeatureParamLumakey& SwFilterLumakey::GetSwFilterParams()
1626 {
1627 VP_FUNC_CALL();
1628
1629 return m_Params;
1630 }
1631
Clone()1632 SwFilter *SwFilterLumakey::Clone()
1633 {
1634 VP_FUNC_CALL();
1635
1636 SwFilter* p = CreateSwFilter(m_type);
1637
1638 SwFilterLumakey *swFilter = dynamic_cast<SwFilterLumakey *>(p);
1639 if (nullptr == swFilter)
1640 {
1641 DestroySwFilter(p);
1642 return nullptr;
1643 }
1644
1645 swFilter->m_Params = m_Params;
1646 return p;
1647 }
1648
operator ==(SwFilter & swFilter)1649 bool vp::SwFilterLumakey::operator==(SwFilter& swFilter)
1650 {
1651 VP_FUNC_CALL();
1652
1653 SwFilterLumakey* p = dynamic_cast<SwFilterLumakey*>(&swFilter);
1654 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamLumakey));
1655 }
1656
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1657 MOS_STATUS vp::SwFilterLumakey::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1658 {
1659 VP_FUNC_CALL();
1660
1661 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1662 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1663 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1664 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1665 m_Params.formatInput = inputSurf->osSurface->Format;
1666 m_Params.formatOutput = inputSurf->osSurface->Format;
1667 return MOS_STATUS_SUCCESS;
1668 }
1669
1670 /****************************************************************************************************/
1671 /* SwFilterBlending */
1672 /****************************************************************************************************/
1673
SwFilterBlending(VpInterface & vpInterface)1674 SwFilterBlending::SwFilterBlending(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeBlending)
1675 {
1676 m_Params.type = m_type;
1677 }
1678
~SwFilterBlending()1679 SwFilterBlending::~SwFilterBlending()
1680 {
1681 Clean();
1682 }
1683
Clean()1684 MOS_STATUS SwFilterBlending::Clean()
1685 {
1686 VP_FUNC_CALL();
1687
1688 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1689 return MOS_STATUS_SUCCESS;
1690 }
1691
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1692 MOS_STATUS SwFilterBlending::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1693 {
1694 VP_FUNC_CALL();
1695
1696 if (!isInputSurf ||
1697 nullptr == params.pSrc[surfIndex]->pBlendingParams)
1698 {
1699 VP_PUBLIC_CHK_STATUS_RETURN(MOS_STATUS_INVALID_PARAMETER);
1700 }
1701
1702 auto surfInput = params.pSrc[surfIndex];
1703
1704 m_Params.formatInput = surfInput->Format;
1705 m_Params.formatOutput = surfInput->Format;
1706 m_Params.blendingParams = surfInput->pBlendingParams;
1707
1708 //Skip Blend PARTIAL for alpha input non alpha output
1709 if (m_Params.blendingParams && m_Params.blendingParams->BlendType == BLEND_PARTIAL)
1710 {
1711 auto surfOutput = params.pTarget[0];
1712 if (surfOutput)
1713 {
1714 if (IS_ALPHA_FORMAT(m_Params.formatInput) &&
1715 !IS_ALPHA_FORMAT(surfOutput->Format))
1716 {
1717 VP_PUBLIC_NORMALMESSAGE("Force to use Blend Source instead of Blend Partial");
1718 m_Params.blendingParams->BlendType = BLEND_SOURCE;
1719 }
1720 }
1721 }
1722 return MOS_STATUS_SUCCESS;
1723 }
1724
GetSwFilterParams()1725 FeatureParamBlending& SwFilterBlending::GetSwFilterParams()
1726 {
1727 VP_FUNC_CALL();
1728
1729 return m_Params;
1730 }
1731
Clone()1732 SwFilter *SwFilterBlending::Clone()
1733 {
1734 VP_FUNC_CALL();
1735
1736 SwFilter* p = CreateSwFilter(m_type);
1737
1738 SwFilterBlending *swFilter = dynamic_cast<SwFilterBlending *>(p);
1739 if (nullptr == swFilter)
1740 {
1741 DestroySwFilter(p);
1742 return nullptr;
1743 }
1744
1745 swFilter->m_Params = m_Params;
1746 return p;
1747 }
1748
operator ==(SwFilter & swFilter)1749 bool vp::SwFilterBlending::operator==(SwFilter& swFilter)
1750 {
1751 VP_FUNC_CALL();
1752
1753 SwFilterBlending* p = dynamic_cast<SwFilterBlending*>(&swFilter);
1754 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamBlending));
1755 }
1756
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1757 MOS_STATUS vp::SwFilterBlending::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1758 {
1759 VP_FUNC_CALL();
1760
1761 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
1762 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1763 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1764 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1765 m_Params.formatInput = inputSurf->osSurface->Format;
1766 m_Params.formatOutput = inputSurf->osSurface->Format;
1767 return MOS_STATUS_SUCCESS;
1768 }
1769
1770 /****************************************************************************************************/
1771 /* SwFilterColorFill */
1772 /****************************************************************************************************/
1773
SwFilterColorFill(VpInterface & vpInterface)1774 SwFilterColorFill::SwFilterColorFill(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeColorFill)
1775 {
1776 m_Params.type = m_type;
1777 }
1778
~SwFilterColorFill()1779 SwFilterColorFill::~SwFilterColorFill()
1780 {
1781 Clean();
1782 }
1783
Clean()1784 MOS_STATUS SwFilterColorFill::Clean()
1785 {
1786 VP_FUNC_CALL();
1787
1788 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1789 return MOS_STATUS_SUCCESS;
1790 }
1791
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1792 MOS_STATUS SwFilterColorFill::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1793 {
1794 VP_FUNC_CALL();
1795
1796 if (isInputSurf ||
1797 nullptr == params.pColorFillParams)
1798 {
1799 return MOS_STATUS_SUCCESS;
1800 }
1801
1802 auto surfOutput = params.pTarget[0];
1803
1804 m_Params.formatInput = surfOutput->Format;
1805 m_Params.formatOutput = surfOutput->Format;
1806 m_Params.colorFillParams = params.pColorFillParams;
1807
1808 if (m_Params.colorFillParams)
1809 {
1810 VP_PUBLIC_NORMALMESSAGE("Color 0x%x, CSpace %d", m_Params.colorFillParams->Color, m_Params.colorFillParams->CSpace);
1811 }
1812 else
1813 {
1814 VP_PUBLIC_NORMALMESSAGE("nullptr == m_Params.colorFillParams");
1815 }
1816
1817 return MOS_STATUS_SUCCESS;
1818 }
1819
GetSwFilterParams()1820 FeatureParamColorFill& SwFilterColorFill::GetSwFilterParams()
1821 {
1822 VP_FUNC_CALL();
1823
1824 return m_Params;
1825 }
1826
Clone()1827 SwFilter *SwFilterColorFill::Clone()
1828 {
1829 VP_FUNC_CALL();
1830
1831 SwFilter* p = CreateSwFilter(m_type);
1832
1833 SwFilterColorFill *swFilter = dynamic_cast<SwFilterColorFill *>(p);
1834 if (nullptr == swFilter)
1835 {
1836 DestroySwFilter(p);
1837 return nullptr;
1838 }
1839
1840 swFilter->m_Params = m_Params;
1841 return p;
1842 }
1843
operator ==(SwFilter & swFilter)1844 bool vp::SwFilterColorFill::operator==(SwFilter& swFilter)
1845 {
1846 VP_FUNC_CALL();
1847
1848 SwFilterColorFill* p = dynamic_cast<SwFilterColorFill*>(&swFilter);
1849 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamColorFill));
1850 }
1851
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1852 MOS_STATUS vp::SwFilterColorFill::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1853 {
1854 VP_FUNC_CALL();
1855
1856 if (nullptr == inputSurf)
1857 {
1858 VP_PUBLIC_NORMALMESSAGE("ColorFill does not have input surface!");
1859 }
1860 else
1861 {
1862 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
1863 }
1864 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
1865 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
1866 m_Params.formatInput = outputSurf->osSurface->Format;
1867 m_Params.formatOutput = outputSurf->osSurface->Format;
1868 return MOS_STATUS_SUCCESS;
1869 }
1870
GetCombinedFilterEngineCaps(SwFilterSubPipe * inputPipeSelected)1871 VP_EngineEntry SwFilterColorFill::GetCombinedFilterEngineCaps(SwFilterSubPipe *inputPipeSelected)
1872 {
1873 if (nullptr == inputPipeSelected)
1874 {
1875 return m_EngineCaps;
1876 }
1877 else
1878 {
1879 VP_EngineEntry engineCaps = m_EngineCaps;
1880
1881 SwFilterScaling *scaling = dynamic_cast<SwFilterScaling *>(inputPipeSelected->GetSwFilter(FeatureTypeScaling));
1882
1883 if (nullptr == scaling)
1884 {
1885 // return default one for no scaling filter case.
1886 VP_PUBLIC_ASSERTMESSAGE("No scaling filter exists");
1887 return engineCaps;
1888 }
1889
1890 FeatureParamScaling &scalingParams = scaling->GetSwFilterParams();
1891 VP_EngineEntry &scalingCaps = scaling->GetFilterEngineCaps();
1892
1893 bool isColorFill = (m_Params.colorFillParams &&
1894 (!m_Params.colorFillParams->bDisableColorfillinSFC) &&
1895 (m_Params.colorFillParams->bOnePixelBiasinSFC ?
1896 (!RECT1_CONTAINS_RECT2_ONEPIXELBIAS(scalingParams.input.rcDst, scalingParams.output.rcDst)):
1897 (!RECT1_CONTAINS_RECT2(scalingParams.input.rcDst, scalingParams.output.rcDst))))
1898 ? true
1899 : false;
1900
1901 if (!scalingCaps.SfcNeeded || !isColorFill && (engineCaps.VeboxNeeded || engineCaps.SfcNeeded))
1902 {
1903 engineCaps.VeboxNeeded = 0;
1904 engineCaps.SfcNeeded = 0;
1905 engineCaps.bypassIfVeboxSfcInUse = 1;
1906 VP_PUBLIC_NORMALMESSAGE("engineCaps updated. value 0x%x (bEnabled %d, VeboxNeeded %d, SfcNeeded %d, RenderNeeded %d, fcSupported %d, isolated %d)",
1907 engineCaps.value, engineCaps.bEnabled, engineCaps.VeboxNeeded, engineCaps.SfcNeeded,
1908 engineCaps.RenderNeeded, engineCaps.fcSupported, engineCaps.isolated);
1909 }
1910
1911 return engineCaps;
1912 }
1913 }
1914
1915 /****************************************************************************************************/
1916 /* SwFilterAlpha */
1917 /****************************************************************************************************/
1918
SwFilterAlpha(VpInterface & vpInterface)1919 SwFilterAlpha::SwFilterAlpha(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeAlpha)
1920 {
1921 m_Params.type = m_type;
1922 }
1923
~SwFilterAlpha()1924 SwFilterAlpha::~SwFilterAlpha()
1925 {
1926 Clean();
1927 }
1928
Clean()1929 MOS_STATUS SwFilterAlpha::Clean()
1930 {
1931 VP_FUNC_CALL();
1932
1933 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
1934 return MOS_STATUS_SUCCESS;
1935 }
1936
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)1937 MOS_STATUS SwFilterAlpha::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
1938 {
1939 VP_FUNC_CALL();
1940
1941 if (isInputSurf ||
1942 nullptr == params.pCompAlpha)
1943 {
1944 return MOS_STATUS_SUCCESS;
1945 }
1946
1947 auto surfOutput = params.pTarget[0];
1948
1949 m_Params.formatInput = surfOutput->Format;
1950 m_Params.formatOutput = surfOutput->Format;
1951 m_Params.compAlpha = params.pCompAlpha;
1952 m_Params.calculatingAlpha = params.bCalculatingAlpha;
1953
1954 if (m_Params.compAlpha)
1955 {
1956 VP_PUBLIC_NORMALMESSAGE("AlphaMode %d, fAlpha %f", m_Params.compAlpha->AlphaMode, m_Params.compAlpha->fAlpha);
1957 }
1958 else
1959 {
1960 VP_PUBLIC_NORMALMESSAGE("nullptr == m_Params.compAlpha");
1961 }
1962
1963 return MOS_STATUS_SUCCESS;
1964 }
1965
GetSwFilterParams()1966 FeatureParamAlpha& SwFilterAlpha::GetSwFilterParams()
1967 {
1968 VP_FUNC_CALL();
1969
1970 return m_Params;
1971 }
1972
Clone()1973 SwFilter *SwFilterAlpha::Clone()
1974 {
1975 VP_FUNC_CALL();
1976
1977 SwFilter* p = CreateSwFilter(m_type);
1978
1979 SwFilterAlpha *swFilter = dynamic_cast<SwFilterAlpha *>(p);
1980 if (nullptr == swFilter)
1981 {
1982 DestroySwFilter(p);
1983 return nullptr;
1984 }
1985
1986 swFilter->m_Params = m_Params;
1987 return p;
1988 }
1989
operator ==(SwFilter & swFilter)1990 bool vp::SwFilterAlpha::operator==(SwFilter& swFilter)
1991 {
1992 VP_FUNC_CALL();
1993
1994 SwFilterAlpha* p = dynamic_cast<SwFilterAlpha*>(&swFilter);
1995 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamAlpha));
1996 }
1997
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)1998 MOS_STATUS vp::SwFilterAlpha::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
1999 {
2000 VP_FUNC_CALL();
2001
2002 if (nullptr == inputSurf)
2003 {
2004 VP_PUBLIC_NORMALMESSAGE("Alpha does not have input surface!");
2005 }
2006 else
2007 {
2008 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
2009 }
2010 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
2011 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
2012 m_Params.formatInput = outputSurf->osSurface->Format;
2013 m_Params.formatOutput = outputSurf->osSurface->Format;
2014 return MOS_STATUS_SUCCESS;
2015 }
2016
2017 /****************************************************************************************************/
2018 /* SwFilterCgc */
2019 /****************************************************************************************************/
2020
SwFilterCgc(VpInterface & vpInterface)2021 SwFilterCgc::SwFilterCgc(VpInterface& vpInterface) : SwFilter(vpInterface, FeatureTypeCgc)
2022 {
2023 m_Params.type = m_type;
2024 }
2025
~SwFilterCgc()2026 SwFilterCgc::~SwFilterCgc()
2027 {
2028 Clean();
2029 }
2030
Clean()2031 MOS_STATUS SwFilterCgc::Clean()
2032 {
2033 VP_FUNC_CALL();
2034
2035 VP_PUBLIC_CHK_STATUS_RETURN(SwFilter::Clean());
2036 return MOS_STATUS_SUCCESS;
2037 }
2038
Configure(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)2039 MOS_STATUS SwFilterCgc::Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
2040 {
2041 VP_FUNC_CALL();
2042
2043 PVPHAL_SURFACE surfInput = static_cast<PVPHAL_SURFACE>(isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0]);
2044 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
2045 VP_PUBLIC_CHK_NULL_RETURN(surfInput);
2046 VP_PUBLIC_CHK_NULL_RETURN(surfOutput);
2047
2048 m_Params.formatInput = surfInput->Format;
2049 m_Params.formatOutput = surfInput->Format; // CGC didn't change the original format;
2050
2051 if (IsBt2020ToRGB(params, isInputSurf, surfIndex))
2052 {
2053 m_Params.formatOutput = Format_A8B8G8R8;
2054 m_Params.bBt2020ToRGB = true;
2055 m_Params.colorSpace = surfInput->ColorSpace;
2056 m_Params.GCompMode = GAMUT_MODE_NONE;
2057 m_Params.bExtendedSrcGamut = false;
2058 m_Params.bExtendedDstGamut = false;
2059 m_Params.dwAttenuation = 0;
2060 MOS_ZeroMemory(m_Params.displayRGBW_x, sizeof(m_Params.displayRGBW_x));
2061 MOS_ZeroMemory(m_Params.displayRGBW_y, sizeof(m_Params.displayRGBW_y));
2062 }
2063 else
2064 {
2065 m_Params.GCompMode = GAMUT_MODE_NONE;
2066 m_Params.colorSpace = CSpace_Any;
2067 m_Params.bExtendedSrcGamut = false;
2068 m_Params.bExtendedDstGamut = false;
2069 m_Params.dwAttenuation = 0;
2070 MOS_ZeroMemory(m_Params.displayRGBW_x, sizeof(m_Params.displayRGBW_x));
2071 MOS_ZeroMemory(m_Params.displayRGBW_y, sizeof(m_Params.displayRGBW_y));
2072 }
2073
2074 return MOS_STATUS_SUCCESS;
2075 }
2076
GetSwFilterParams()2077 FeatureParamCgc& SwFilterCgc::GetSwFilterParams()
2078 {
2079 VP_FUNC_CALL();
2080
2081 return m_Params;
2082 }
2083
Clone()2084 SwFilter * SwFilterCgc::Clone()
2085 {
2086 VP_FUNC_CALL();
2087
2088 SwFilter* p = CreateSwFilter(m_type);
2089
2090 SwFilterCgc *swFilter = dynamic_cast<SwFilterCgc *>(p);
2091 if (nullptr == swFilter)
2092 {
2093 DestroySwFilter(p);
2094 return nullptr;
2095 }
2096
2097 swFilter->m_Params = m_Params;
2098 return p;
2099 }
2100
operator ==(SwFilter & swFilter)2101 bool SwFilterCgc::operator==(SwFilter& swFilter)
2102 {
2103 VP_FUNC_CALL();
2104
2105 SwFilterCgc* p = dynamic_cast<SwFilterCgc*>(&swFilter);
2106 return nullptr != p && 0 == memcmp(&this->m_Params, &p->m_Params, sizeof(FeatureParamCgc));
2107 }
2108
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)2109 MOS_STATUS SwFilterCgc::Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe)
2110 {
2111 VP_FUNC_CALL();
2112
2113 VP_PUBLIC_CHK_NULL_RETURN(inputSurf);
2114 VP_PUBLIC_CHK_NULL_RETURN(inputSurf->osSurface);
2115 VP_PUBLIC_CHK_NULL_RETURN(outputSurf);
2116 VP_PUBLIC_CHK_NULL_RETURN(outputSurf->osSurface);
2117 m_Params.formatInput = inputSurf->osSurface->Format;
2118 m_Params.formatOutput = outputSurf->osSurface->Format;
2119 return MOS_STATUS_SUCCESS;
2120 }
2121
IsBt2020ToRGB(VP_PIPELINE_PARAMS & params,bool isInputSurf,int surfIndex)2122 bool SwFilterCgc::IsBt2020ToRGB(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex)
2123 {
2124 VP_FUNC_CALL();
2125
2126 PVPHAL_SURFACE surfInput = static_cast<PVPHAL_SURFACE>(isInputSurf ? params.pSrc[surfIndex] : params.pSrc[0]);
2127 PVPHAL_SURFACE surfOutput = isInputSurf ? params.pTarget[0] : params.pTarget[surfIndex];
2128
2129 if (surfInput && surfOutput &&
2130 IS_COLOR_SPACE_BT2020_YUV(surfInput->ColorSpace))
2131 {
2132 if ((surfOutput->ColorSpace == CSpace_BT601) ||
2133 (surfOutput->ColorSpace == CSpace_BT709) ||
2134 (surfOutput->ColorSpace == CSpace_BT601_FullRange) ||
2135 (surfOutput->ColorSpace == CSpace_BT709_FullRange) ||
2136 (surfOutput->ColorSpace == CSpace_stRGB) ||
2137 (surfOutput->ColorSpace == CSpace_sRGB))
2138 {
2139 return true;
2140 }
2141 }
2142
2143 return false;
2144 }
2145
2146 /****************************************************************************************************/
2147 /* SwFilterSet */
2148 /****************************************************************************************************/
2149
SwFilterSet()2150 SwFilterSet::SwFilterSet()
2151 {}
~SwFilterSet()2152 SwFilterSet::~SwFilterSet()
2153 {
2154 Clean();
2155 }
2156
AddSwFilter(SwFilter * swFilter)2157 MOS_STATUS SwFilterSet::AddSwFilter(SwFilter *swFilter)
2158 {
2159 VP_FUNC_CALL();
2160
2161 auto it = m_swFilters.find(swFilter->GetFeatureType());
2162 if (m_swFilters.end() != it)
2163 {
2164 VP_PUBLIC_ASSERTMESSAGE("Invalid parameter! SwFilter for feature %d has already been exists in swFilterSet!", swFilter->GetFeatureType());
2165 return MOS_STATUS_INVALID_PARAMETER;
2166 }
2167 m_swFilters.insert(std::make_pair(swFilter->GetFeatureType(), swFilter));
2168 swFilter->SetLocation(this);
2169 return MOS_STATUS_SUCCESS;
2170 }
2171
RemoveSwFilter(SwFilter * swFilter)2172 MOS_STATUS SwFilterSet::RemoveSwFilter(SwFilter *swFilter)
2173 {
2174 VP_FUNC_CALL();
2175
2176 auto it = m_swFilters.find(swFilter->GetFeatureType());
2177 if (m_swFilters.end() == it)
2178 {
2179 // The feature does not exist in current swFilterSet.
2180 return MOS_STATUS_SUCCESS;
2181 }
2182
2183 if (it->second != swFilter)
2184 {
2185 // swFilter does not belong to current swFilterSet.
2186 return MOS_STATUS_SUCCESS;
2187 }
2188
2189 m_swFilters.erase(it);
2190 swFilter->SetLocation(nullptr);
2191
2192 return MOS_STATUS_SUCCESS;
2193 }
2194
Clean()2195 MOS_STATUS SwFilterSet::Clean()
2196 {
2197 VP_FUNC_CALL();
2198
2199 while (!m_swFilters.empty())
2200 {
2201 auto it = m_swFilters.begin();
2202 auto swFilter = (*it).second;
2203 m_swFilters.erase(it);
2204 if (swFilter)
2205 {
2206 VpInterface &vpIntf = swFilter->GetVpInterface();
2207 SwFilterFeatureHandler *swFilterHandler = vpIntf.GetSwFilterHandler(swFilter->GetFeatureType());
2208 VP_PUBLIC_CHK_NULL_RETURN(swFilterHandler);
2209 swFilterHandler->Destory(swFilter);
2210 }
2211 }
2212 return MOS_STATUS_SUCCESS;
2213 }
2214
GetSwFilter(FeatureType type)2215 SwFilter *SwFilterSet::GetSwFilter(FeatureType type)
2216 {
2217 VP_FUNC_CALL();
2218
2219 auto it = m_swFilters.find(type);
2220 if (m_swFilters.end() == it)
2221 {
2222 // The feature does not exist in current swFilterSet.
2223 return nullptr;
2224 }
2225
2226 return it->second;
2227 }
2228
GetLocation()2229 std::vector<SwFilterSet *> *SwFilterSet::GetLocation()
2230 {
2231 VP_FUNC_CALL();
2232
2233 return m_location;
2234 }
SetLocation(std::vector<SwFilterSet * > * location)2235 void SwFilterSet::SetLocation(std::vector<SwFilterSet *> *location)
2236 {
2237 VP_FUNC_CALL();
2238
2239 m_location = location;
2240 }
2241
Update(VP_SURFACE * inputSurf,VP_SURFACE * outputSurf,SwFilterSubPipe & pipe)2242 MOS_STATUS SwFilterSet::Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe)
2243 {
2244 VP_FUNC_CALL();
2245
2246 for (auto swFilter : m_swFilters)
2247 {
2248 VP_PUBLIC_CHK_NULL_RETURN(swFilter.second);
2249 VP_PUBLIC_CHK_STATUS_RETURN(swFilter.second->Update(inputSurf, outputSurf, pipe));
2250 }
2251 return MOS_STATUS_SUCCESS;
2252 }
2253
AddFeatureGraphRTLog()2254 MOS_STATUS SwFilterSet::AddFeatureGraphRTLog()
2255 {
2256 VP_FUNC_CALL();
2257
2258 for (auto swFilter : m_swFilters)
2259 {
2260 if (swFilter.second)
2261 {
2262 swFilter.second->AddFeatureGraphRTLog();
2263 }
2264 }
2265 return MOS_STATUS_SUCCESS;
2266 }
2267
GetRenderTargetType()2268 RenderTargetType SwFilterSet::GetRenderTargetType()
2269 {
2270 VP_FUNC_CALL();
2271
2272 for (auto swFilter : m_swFilters)
2273 {
2274 if (swFilter.second)
2275 {
2276 RenderTargetType renderTargetType = swFilter.second->GetRenderTargetType();
2277 if (renderTargetType == RenderTargetTypeSurface)
2278 {
2279 return RenderTargetTypeSurface;
2280 }
2281 }
2282 }
2283 return RenderTargetTypeParameter;
2284 }
2285