1 /*
2 * Copyright (c) 2019-2021, 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.h
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 #ifndef __SW_FILTER_H__
30 #define __SW_FILTER_H__
31 
32 #include "media_feature_manager.h"
33 #include "vp_utils.h"
34 #include "vp_pipeline_common.h"
35 #include "vp_render_common.h"
36 #include <vector>
37 #include "media_sfc_interface.h"
38 
39 namespace vp
40 {
41 class VpInterface;
42 class SwFilterSubPipe;
43 
44 #define FEATURE_TYPE_ENGINE_BITS_SFC        0x20
45 #define FEATURE_TYPE_ENGINE_BITS_VEBOX      0x40
46 #define FEATURE_TYPE_ENGINE_BITS_RENDER     0x80
47 
48 #define FEATURE_TYPE_ENGINE_BITS_SUB_STEP   0x01
49 
50 #define IS_FEATURE_TYPE_ON_SFC(type)        ((type)&FEATURE_TYPE_ENGINE_BITS_SFC)
51 #define IS_FEATURE_TYPE_ON_VEBOX(type)      ((type)&FEATURE_TYPE_ENGINE_BITS_VEBOX)
52 #define IS_FEATURE_TYPE_ON_VEBOX_SFC(type)  (IS_FEATURE_TYPE_ON_SFC(type) || IS_FEATURE_TYPE_ON_VEBOX(type))
53 #define IS_FEATURE_TYPE_ON_RENDER(type)     ((type)&FEATURE_TYPE_ENGINE_BITS_RENDER)
54 
55 #define FEATURE_TYPE_MASK                   0xffffff00
56 #define FEATURE_TYPE_ENGINE_ASSIGNED(feature) (((feature)&FEATURE_TYPE_MASK) != (feature))
57 
58 enum FeatureType
59 {
60     FeatureTypeInvalid          = 0,
61     FeatureTypeCsc              = 0x100,
62     FeatureTypeCscOnSfc         = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_SFC,
63     FeatureTypeCscOnVebox       = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_VEBOX,
64     FeatureTypeCscOnRender      = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_RENDER,
65     FeatureTypeRotMir           = 0x200,
66     FeatureTypeRotMirOnSfc      = FeatureTypeRotMir | FEATURE_TYPE_ENGINE_BITS_SFC,
67     FeatureTypeRotMirOnRender   = FeatureTypeRotMir | FEATURE_TYPE_ENGINE_BITS_RENDER,
68     FeatureTypeScaling          = 0x300,
69     FeatureTypeScalingOnSfc     = FeatureTypeScaling | FEATURE_TYPE_ENGINE_BITS_SFC,
70     FeatureTypeScalingOnRender  = FeatureTypeScaling | FEATURE_TYPE_ENGINE_BITS_RENDER,
71     FeatureTypeDn               = 0x400,
72     FeatureTypeDnOnVebox        = FeatureTypeDn | FEATURE_TYPE_ENGINE_BITS_VEBOX,
73     FeatureTypeDi               = 0x500,
74     FeatureTypeDiOnVebox        = FeatureTypeDi | FEATURE_TYPE_ENGINE_BITS_VEBOX,
75     FeatureTypeDiOnRender       = FeatureTypeDi | FEATURE_TYPE_ENGINE_BITS_RENDER,
76     FeatureTypeDiFmdOnRender    = FeatureTypeDi | FEATURE_TYPE_ENGINE_BITS_RENDER | FEATURE_TYPE_ENGINE_BITS_SUB_STEP,
77     FeatureTypeSte              = 0x600,
78     FeatureTypeSteOnVebox       = FeatureTypeSte | FEATURE_TYPE_ENGINE_BITS_VEBOX,
79     FeatureTypeAce              = 0x700,
80     FeatureTypeAceOnVebox       = FeatureTypeAce | FEATURE_TYPE_ENGINE_BITS_VEBOX,
81     FeatureTypeVeboxUpdate      = 0x800,
82     FeatureTypeVeboxUpdateOnRender = FeatureTypeVeboxUpdate | FEATURE_TYPE_ENGINE_BITS_RENDER,
83     FeatureTypeTcc              = 0x900,
84     FeatureTypeTccOnVebox       = FeatureTypeTcc | FEATURE_TYPE_ENGINE_BITS_VEBOX,
85     FeatureTypeProcamp          = 0xA00,
86     FeatureTypeProcampOnVebox   = FeatureTypeProcamp | FEATURE_TYPE_ENGINE_BITS_VEBOX,
87     FeatureTypeProcampOnRender  = FeatureTypeProcamp | FEATURE_TYPE_ENGINE_BITS_RENDER,
88     FeatureTypeCgc              = 0xB00,
89     FeatureTypeCgcOnVebox       = FeatureTypeCgc | FEATURE_TYPE_ENGINE_BITS_VEBOX,
90     FeatureTypeHdr              = 0xC00,
91     FeatureTypeHdrOnVebox       = FeatureTypeHdr | FEATURE_TYPE_ENGINE_BITS_VEBOX,
92     FeatureTypeFD               = 0xD00,
93     FeatureTypeFLD              = 0xE00,
94     FeatureTypeFB               = 0xF00,
95     FeatureTypeSecureCopy       = 0x1000,
96     FeatureTypeSecureCopyOnRender = FeatureTypeSecureCopy | FEATURE_TYPE_ENGINE_BITS_RENDER,
97     FeatureTypeSR               = 0x1100,
98     FeatureTypeSROnRender       = FeatureTypeSR | FEATURE_TYPE_ENGINE_BITS_RENDER,
99     FeatureTypeLace             = 0x1200,
100     FeatureTypeLaceOnVebox      = FeatureTypeLace | FEATURE_TYPE_ENGINE_BITS_VEBOX,
101     FeatureTypeLaceOnRender     = FeatureTypeLace | FEATURE_TYPE_ENGINE_BITS_RENDER,
102     FeatureTypeGamutExt         = 0x1300,
103     FeatureTypeDV               = 0x1400,
104     FeatureTypeDVOnVebox        = FeatureTypeDV | FEATURE_TYPE_ENGINE_BITS_VEBOX,
105     FeatureTypeFc               = 0x1500,
106     FeatureTypeFcOnRender       = FeatureTypeFc | FEATURE_TYPE_ENGINE_BITS_RENDER,
107     FeatureTypeLumakey          = 0x1600,
108     FeatureTypeLumakeyOnRender  = FeatureTypeLumakey | FEATURE_TYPE_ENGINE_BITS_RENDER,
109     FeatureTypeBlending         = 0x1700,
110     FeatureTypeBlendingOnRender = FeatureTypeBlending | FEATURE_TYPE_ENGINE_BITS_RENDER,
111     FeatureTypeColorFill        = 0x1800,
112     FeatureTypeColorFillOnSfc   = FeatureTypeColorFill | FEATURE_TYPE_ENGINE_BITS_SFC,
113     FeatureTypeColorFillOnRender = FeatureTypeColorFill | FEATURE_TYPE_ENGINE_BITS_RENDER,
114     FeatureTypeAlpha            = 0x1900,
115     FeatureTypeAlphaOnSfc       = FeatureTypeAlpha | FEATURE_TYPE_ENGINE_BITS_SFC,
116     FeatureTypeAlphaOnRender    = FeatureTypeAlpha | FEATURE_TYPE_ENGINE_BITS_RENDER,
117     FeatureTypeCappipe          = 0x2000,
118     FeatureTypeCappipeOnVebox   = FeatureTypeCappipe | FEATURE_TYPE_ENGINE_BITS_VEBOX,
119     FeatureTypeCappipeOnRender  = FeatureTypeCappipe | FEATURE_TYPE_ENGINE_BITS_RENDER,
120     // ...
121     NumOfFeatureType
122 };
123 
124 enum RenderTargetType
125 {
126     RenderTargetTypeInvalid = 0,
127     RenderTargetTypeSurface,
128     RenderTargetTypeParameter
129 };
130 
131 enum SurfaceType
132 {
133     SurfaceTypeInvalid = 0,
134     SurfaceTypeVeboxInput,
135     SurfaceTypeVeboxPreviousInput,
136     SurfaceTypeDNOutput,
137     SurfaceTypeVeboxCurrentOutput,
138     SurfaceTypeVeboxPreviousOutput,
139     SurfaceTypeScalar,
140     SurfaceTypeSTMMIn,
141     SurfaceTypeSTMMOut,
142     SurfaceTypeACEHistory,
143     SurfaceTypeFMDHistory,
144     SurfaceTypeLaceAceRGBHistogram,
145     SurfaceTypeLaceLut,
146     SurfaceTypeStatistics,
147     SurfaceTypeSkinScore,
148     SurfaceType3dLut,
149     SurfaceType1dLutHDR,
150     SurfaceTypeAlphaOrVignette,
151     SurfaceTypeVeboxStateHeap_Drv,
152     SurfaceTypeVeboxStateHeap_Knr,
153     SurfaceTypeAutoDNNoiseLevel, // with kernel path needed
154     SurfaceTypeAutoDNSpatialConfig,
155     SurfaceTypeRenderInput,
156     SurfaceTypeRenderOutput,
157     SurfaceTypeRenderSRInput, //Super Resolution related Surface and Buffer index Reserved
158     SurfaceTypeRenderSRBuffer = SurfaceTypeRenderSRInput + 0x100,
159     SurfaceTypeRenderSRMax = SurfaceTypeRenderSRBuffer + 0x100,
160     SurfaceTypeAggregatedHistogram,
161     SurfaceTypeFrameHistogram,
162     SurfaceTypeStdStatistics,
163     SurfaceTypePwlfIn,
164     SurfaceTypePwlfOut,
165     SurfaceTypeWeitCoef,
166     SurfaceTypGlobalToneMappingCurveLUT,
167     // FC
168     SurfaceTypeFcInputLayer0,
169     SurfaceTypeFcInputLayer1,
170     SurfaceTypeFcInputLayer2,
171     SurfaceTypeFcInputLayer3,
172     SurfaceTypeFcInputLayer4,
173     SurfaceTypeFcInputLayer5,
174     SurfaceTypeFcInputLayer6,
175     SurfaceTypeFcInputLayer7,
176     SurfaceTypeFcInputLayerMax = SurfaceTypeFcInputLayer7,
177     SurfaceTypeFcInputLayer0Field1Dual,
178     SurfaceTypeFcInputLayer1Field1Dual,
179     SurfaceTypeFcInputLayer2Field1Dual,
180     SurfaceTypeFcInputLayer3Field1Dual,
181     SurfaceTypeFcInputLayer4Field1Dual,
182     SurfaceTypeFcInputLayer5Field1Dual,
183     SurfaceTypeFcInputLayer6Field1Dual,
184     SurfaceTypeFcInputLayer7Field1Dual,
185     SurfaceTypeFcInputLayerMaxField1Dual = SurfaceTypeFcInputLayer7Field1Dual,
186     SurfaceTypeFcTarget0,
187     SurfaceTypeFcTarget1,
188     SurfaceTypeFcCscCoeff,
189     //LGCA related Surfaces
190     SurfaceTypeSamplerSurfaceR,
191     SurfaceTypeSamplerSurfaceG,
192     SurfaceTypeSamplerSurfaceB,
193     SurfaceTypeOutputSurfaceR,
194     SurfaceTypeOutputSurfaceG,
195     SurfaceTypeOutputSurfaceB,
196     SurfaceTypeSamplerParamsMinMax,
197     NumberOfSurfaceType
198 };
199 
200 using  VP_SURFACE_GROUP = std::map<SurfaceType, VP_SURFACE*>;
201 
202 struct VP_SURFACE_SETTING
203 {
204     VP_SURFACE_GROUP    surfGroup;
205     bool                isPastHistogramValid       = false;
206     uint32_t            imageWidthOfPastHistogram  = 0;
207     uint32_t            imageHeightOfPastHistogram = 0;
208     uint32_t            dwVeboxPerBlockStatisticsHeight = 0;
209     uint32_t            dwVeboxPerBlockStatisticsWidth  = 0;
210     uint32_t            aggregateBlockSize              = 0;
211     bool                laceLutValid                    = false;
212     bool                updateGlobalToneMappingCurveLUTSurface = false;
213     bool                updateWeitCoefSurface                  = false;
214     bool                dumpLaceSurface                        = false;
215 
CleanVP_SURFACE_SETTING216     void Clean()
217     {
218         surfGroup.clear();
219         isPastHistogramValid        = false;
220         imageWidthOfPastHistogram   = 0;
221         imageHeightOfPastHistogram  = 0;
222         dwVeboxPerBlockStatisticsHeight = 0;
223         dwVeboxPerBlockStatisticsWidth  = 0;
224         aggregateBlockSize              = 0;
225         laceLutValid                    = false;
226         updateGlobalToneMappingCurveLUTSurface = true;
227         updateWeitCoefSurface                  = true;
228         dumpLaceSurface                        = false;
229     }
230 };
231 
232 #define FEATURE_TYPE_MASK   0xffffff00
233 #define FEATURE_TYPE_ENGINE_ASSIGNED(feature) (((feature)&FEATURE_TYPE_MASK) != (feature))
234 
235 inline bool operator==(FeatureType a, FeatureType b)
236 {
237     return (int)a == (int)b || (int)(a & FEATURE_TYPE_MASK) == (int)b || (int)a == (int)(FEATURE_TYPE_MASK & b);
238 }
239 
240 inline bool operator!=(FeatureType a, FeatureType b)
241 {
242     return !(a == b);
243 }
244 
245 inline bool operator<(FeatureType a, FeatureType b)
246 {
247     return a != b && (int)a < (int)b;
248 }
249 
250 #define RECT_ROTATE(rcOut, rcIn)        \
251 {                                       \
252     (rcOut).left    = (rcIn).top;       \
253     (rcOut).right   = (rcIn).bottom;    \
254     (rcOut).top     = (rcIn).left;      \
255     (rcOut).bottom  = (rcIn).right;     \
256 }
257 
258 struct FeatureParam
259 {
260     FeatureType type         = FeatureTypeInvalid;
261     MOS_FORMAT  formatInput  = Format_None;
262     MOS_FORMAT  formatOutput = Format_None;
263 };
264 
265 enum FeatureCategory
266 {
267     FeatureCategoryBasic    = 0,
268     FeatureCategoryIsolated,
269     FeatureCategoryFC,
270 };
271 
272 class SwFilterSet;
273 
274 class SwFilter
275 {
276 public:
277     SwFilter(VpInterface &vpInterface, FeatureType type);
278     virtual ~SwFilter();
Clean()279     virtual MOS_STATUS Clean()
280     {
281         MOS_ZeroMemory(&m_EngineCaps, sizeof(m_EngineCaps));
282         m_noNeedUpdate = false;
283         m_isInExePipe = false;
284         return MOS_STATUS_SUCCESS;
285     }
GetFeatureType()286     virtual FeatureType GetFeatureType()
287     {
288         return m_type;
289     }
IsEngineAssigned()290     virtual bool IsEngineAssigned()
291     {
292         return m_type != (m_type & FEATURE_TYPE_MASK);
293     }
GetRenderTargetType()294     virtual RenderTargetType GetRenderTargetType()
295     {
296         return m_renderTargetType;
297     }
IsFeatureEnabled(VP_EXECUTE_CAPS caps)298     bool IsFeatureEnabled(VP_EXECUTE_CAPS caps)
299     {
300         return m_EngineCaps.bEnabled && (m_EngineCaps.SfcNeeded && caps.bSFC ||
301             m_EngineCaps.VeboxNeeded && caps.bVebox || m_EngineCaps.RenderNeeded && caps.bRender);
302     }
303     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS &params, bool bInputSurf, int surfIndex) = 0;
Configure(PVP_SURFACE surfInput,PVP_SURFACE surfOutput,VP_EXECUTE_CAPS caps)304     virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps)
305     {
306         return MOS_STATUS_UNIMPLEMENTED;
307     }
308 
Configure(VEBOX_SFC_PARAMS & params)309     virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS &params)
310     {
311         return MOS_STATUS_UNIMPLEMENTED;
312     }
313 
Configure(SwFilter & swFilter,VP_EXECUTE_CAPS caps)314     virtual MOS_STATUS Configure(SwFilter& swFilter, VP_EXECUTE_CAPS caps)
315     {
316         return MOS_STATUS_UNIMPLEMENTED;
317     }
318 
319     virtual SwFilter *Clone() = 0;
320     virtual bool operator == (class SwFilter&) = 0;
321     virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe) = 0;
322     virtual MOS_STATUS SetFeatureType(FeatureType type);
323     virtual MOS_STATUS ResetFeatureType();
324     virtual MOS_STATUS SetRenderTargetType(RenderTargetType type);
325     SwFilter* CreateSwFilter(FeatureType type);
326     void DestroySwFilter(SwFilter* p);
327 
SetLocation(SwFilterSet * swFilterSet)328     void SetLocation(SwFilterSet *swFilterSet)
329     {
330         m_location = swFilterSet;
331     }
332 
GetLocation()333     SwFilterSet *GetLocation()
334     {
335         return m_location;
336     }
337 
GetVpInterface()338     VpInterface& GetVpInterface()
339     {
340         return m_vpInterface;
341     }
342 
GetFilterEngineCaps()343     VP_EngineEntry& GetFilterEngineCaps()
344     {
345         return m_EngineCaps;
346     }
347 
348     // For some feature in output pipe, enable or disable depends on other feature status of input pipe.
349     // If singleInputPipeSelected != nullptr, means single input pipe inuse, otherwise, multi-input pipe in use.
GetCombinedFilterEngineCaps(SwFilterSubPipe * singleInputPipeSelected)350     virtual VP_EngineEntry GetCombinedFilterEngineCaps(SwFilterSubPipe *singleInputPipeSelected)
351     {
352         return m_EngineCaps;
353     }
354 
355     // The child class need to implement SetResourceAssignmentHint only when any feature
356     // parameters will affect the resource assignment.
SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)357     virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint)
358     {
359         return MOS_STATUS_SUCCESS;
360     }
361 
SetExePipeFlag(bool isInExePipe)362     void SetExePipeFlag(bool isInExePipe)
363     {
364         m_isInExePipe = isInExePipe;
365     }
366 
367 protected:
368     VpInterface &m_vpInterface;
369     FeatureType m_type = FeatureTypeInvalid;
370     // SwFilterSet current swFilter belongs to.
371     SwFilterSet *m_location = nullptr;
372     VP_EngineEntry  m_EngineCaps = {};
373     bool m_noNeedUpdate = false;
374     RenderTargetType m_renderTargetType = RenderTargetTypeSurface;
375     bool m_isInExePipe = false;
376 
377 MEDIA_CLASS_DEFINE_END(SwFilter)
378 };
379 
380 struct FeatureParamCsc : public FeatureParam
381 {
382     struct CSC_PARAMS
383     {
384         VPHAL_CSPACE    colorSpace;
385         uint32_t        chromaSiting;
386     };
387     CSC_PARAMS          input;
388     CSC_PARAMS          output;
389     PVPHAL_IEF_PARAMS   pIEFParams;
390     PVPHAL_ALPHA_PARAMS pAlphaParams;
391     FeatureParamCsc     *next;                //!< pointe to new/next generated CSC params
392 };
393 
394 class SwFilterCsc : public SwFilter
395 {
396 public:
397     SwFilterCsc(VpInterface &vpInterface);
398     virtual ~SwFilterCsc();
399     virtual MOS_STATUS Clean();
400     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
401     virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps);
402     virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS &params);
403     virtual MOS_STATUS Configure(FeatureParamCsc &params);
404     virtual FeatureParamCsc &GetSwFilterParams();
405     virtual SwFilter *Clone();
406     virtual bool operator == (SwFilter& swFilter);
407     virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
408     virtual MOS_STATUS SetFeatureType(FeatureType type);
409 
410 private:
411     FeatureParamCsc m_Params = {};
412 
413 MEDIA_CLASS_DEFINE_END(SwFilterCsc)
414 };
415 
416 struct FeatureParamScaling : public FeatureParam
417 {
418     struct SCALING_PARAMS
419     {
420         uint32_t                dwWidth  = 0;
421         uint32_t                dwHeight = 0;
422         RECT                    rcSrc    = {0, 0, 0, 0};
423         RECT                    rcDst    = {0, 0, 0, 0};  //!< Input dst rect without rotate being applied.
424         RECT                    rcMaxSrc = {0, 0, 0, 0};
425         VPHAL_SAMPLE_TYPE       sampleType = SAMPLE_PROGRESSIVE;
426     };
427 
428     // Parameters maintained by scaling feature parameters
429     SCALING_PARAMS              input       = {};
430     SCALING_PARAMS              output      = {};
431     bool                        isPrimary   = false;
432     VPHAL_SCALING_MODE          scalingMode = VPHAL_SCALING_NEAREST;
433     VPHAL_SCALING_PREFERENCE    scalingPreference  = VPHAL_SCALING_PREFER_SFC;  //!< DDI indicate Scaling preference
434     bool                        bDirectionalScalar = false;     //!< Vebox Directional Scalar
435     PVPHAL_COLORFILL_PARAMS     pColorFillParams = nullptr;     //!< ColorFill - BG only
436     PVPHAL_ALPHA_PARAMS         pCompAlpha       = nullptr;     //!< Alpha for composited surfaces
437     VPHAL_ISCALING_TYPE         interlacedScalingType = ISCALING_NONE;
438 
439     // Parameters maintained by other feature parameters.
440     struct {
441         VPHAL_CSPACE colorSpaceOutput = CSpace_None;
442     } csc;
443 
444     struct {
445         bool                    rotationNeeded = false;                 //!< Whether rotate SwFilter exists on SwFilterPipe.
446     } rotation;
447 
448     FeatureParamScaling        *next = nullptr;                           //!< pointe to new/next generated scaling params
449 };
450 
451 class SwFilterScaling : public SwFilter
452 {
453 public:
454     SwFilterScaling(VpInterface &vpInterface);
455     virtual ~SwFilterScaling();
456     virtual MOS_STATUS Clean();
457     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
458     virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS &params);
459     virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps);
460     virtual FeatureParamScaling &GetSwFilterParams();
461     virtual SwFilter *Clone();
462     virtual bool operator == (SwFilter& swFilter);
463     virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)464     virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint)
465     {
466         hint.isIScalingTypeNone = ISCALING_NONE == m_Params.interlacedScalingType;
467         hint.isFieldWeaving     = ISCALING_FIELD_TO_INTERLEAVED == m_Params.interlacedScalingType;
468         return MOS_STATUS_SUCCESS;
469     }
470 
471 private:
472     FeatureParamScaling m_Params = {};
473 
474 MEDIA_CLASS_DEFINE_END(SwFilterScaling)
475 };
476 
477 struct FeatureParamRotMir : public FeatureParam
478 {
479     // Parameters maintained by rotation feature parameters
480     VPHAL_ROTATION rotation = VPHAL_ROTATION_IDENTITY;
481 
482     // Parameters maintained by other feature parameters.
483     struct {
484         MOS_TILE_TYPE tileOutput = MOS_TILE_X;
485     } surfInfo;
486 };
487 
488 class SwFilterRotMir : public SwFilter
489 {
490 public:
491     SwFilterRotMir(VpInterface &vpInterface);
492     virtual ~SwFilterRotMir();
493     virtual MOS_STATUS Clean();
494     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
495     virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS &params);
496     virtual FeatureParamRotMir &GetSwFilterParams();
497     virtual SwFilter *Clone();
498     virtual bool operator == (SwFilter& swFilter);
499     virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
500 
501 private:
502     FeatureParamRotMir m_Params = {};
503 
504 MEDIA_CLASS_DEFINE_END(SwFilterRotMir)
505 };
506 
507 struct FeatureParamDenoise : public FeatureParam
508 {
509     VPHAL_SAMPLE_TYPE    sampleTypeInput      = SAMPLE_PROGRESSIVE;
510     VPHAL_DENOISE_PARAMS denoiseParams        = {};
511     uint32_t             widthAlignUnitInput  = 0;
512     uint32_t             heightAlignUnitInput = 0;
513     uint32_t             heightInput          = 0;
514 };
515 
516 class SwFilterDenoise : public SwFilter
517 {
518 public:
519     SwFilterDenoise(VpInterface& vpInterface);
520     virtual ~SwFilterDenoise();
521     virtual MOS_STATUS Clean();
522     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
523     virtual FeatureParamDenoise& GetSwFilterParams();
524     virtual SwFilter* Clone();
525     virtual bool operator == (SwFilter& swFilter);
526     virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe);
527 
528 private:
529     FeatureParamDenoise m_Params = {};
530 
531 MEDIA_CLASS_DEFINE_END(SwFilterDenoise)
532 };
533 
534 struct FeatureParamDeinterlace : public FeatureParam
535 {
536     VPHAL_SAMPLE_TYPE       sampleTypeInput      = SAMPLE_PROGRESSIVE;
537     bool                    bHDContent           = false;
538     PVPHAL_DI_PARAMS        diParams             = nullptr;
539     bool                    bFmdExtraVariance    = false;     //!< Check if extra FMD variances need to be calculated
540     bool                    bFmdKernelEnable     = false;     //!< FMD kernel path enabled
541     bool                    bQueryVarianceEnable = false;     //!< Query variance enabled
542     uint32_t                heightInput          = 0;
543     RECT                    rcSrc                = {0, 0, 0, 0};
544 };
545 
546 class SwFilterDeinterlace : public SwFilter
547 {
548 public:
549     SwFilterDeinterlace(VpInterface& vpInterface);
550     virtual ~SwFilterDeinterlace();
551     virtual MOS_STATUS Clean();
552     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
553     virtual FeatureParamDeinterlace& GetSwFilterParams();
554     virtual SwFilter* Clone();
555     virtual bool operator == (SwFilter& swFilter);
556     virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe);
SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)557     virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint)
558     {
559         hint.bDi        = 1;
560         hint.b60fpsDi   = m_Params.diParams && !m_Params.diParams->bSingleField;
561         return MOS_STATUS_SUCCESS;
562     }
563 
564 private:
565     FeatureParamDeinterlace m_Params = {};
566 
567 MEDIA_CLASS_DEFINE_END(SwFilterDeinterlace)
568 };
569 
570 struct FeatureParamSte : public FeatureParam
571 {
572     bool                bEnableSTE;
573     uint32_t            dwSTEFactor;
574 };
575 
576 class SwFilterSte : public SwFilter
577 {
578 public:
579     SwFilterSte(VpInterface& vpInterface);
580     virtual ~SwFilterSte();
581     virtual MOS_STATUS Clean();
582     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
583     virtual FeatureParamSte& GetSwFilterParams();
584     virtual SwFilter* Clone();
585     virtual bool operator == (SwFilter& swFilter);
586     virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe);
587 
588 private:
589     FeatureParamSte m_Params = {};
590 
591 MEDIA_CLASS_DEFINE_END(SwFilterSte)
592 };
593 
594 struct FeatureParamTcc : public FeatureParam
595 {
596     bool                bEnableTCC = false;
597     uint8_t             Red        = 0;
598     uint8_t             Green      = 0;
599     uint8_t             Blue       = 0;
600     uint8_t             Cyan       = 0;
601     uint8_t             Magenta    = 0;
602     uint8_t             Yellow     = 0;
603 };
604 
605 class SwFilterTcc : public SwFilter
606 {
607 public:
608     SwFilterTcc(VpInterface& vpInterface);
609     virtual ~SwFilterTcc();
610     virtual MOS_STATUS Clean();
611     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
612     virtual FeatureParamTcc& GetSwFilterParams();
613     virtual SwFilter* Clone();
614     virtual bool operator == (SwFilter& swFilter);
615     virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe);
616 
617 private:
618     FeatureParamTcc m_Params = {};
619 
620 MEDIA_CLASS_DEFINE_END(SwFilterTcc)
621 };
622 
623 struct FeatureParamProcamp : public FeatureParam
624 {
625     PVPHAL_PROCAMP_PARAMS procampParams;
626 };
627 
628 class SwFilterProcamp : public SwFilter
629 {
630 public:
631     SwFilterProcamp(VpInterface& vpInterface);
632     virtual ~SwFilterProcamp();
633     virtual MOS_STATUS Clean();
634     virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex);
635     virtual FeatureParamProcamp& GetSwFilterParams();
636     virtual SwFilter* Clone();
637     virtual bool operator == (SwFilter& swFilter);
638     virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe);
639 
640 private:
641     FeatureParamProcamp m_Params = {};
642 
643 MEDIA_CLASS_DEFINE_END(SwFilterProcamp)
644 };
645 
646 struct FeatureParamHdr : public FeatureParam
647 {
648     uint32_t        uiMaxDisplayLum      = 0;  //!< Maximum Display Luminance
649     uint32_t        uiMaxContentLevelLum = 0;  //!< Maximum Content Level Luminance
650     VPHAL_HDR_MODE  hdrMode              = VPHAL_HDR_MODE_NONE;
651     VPHAL_CSPACE    srcColorSpace        = CSpace_None;
652     VPHAL_CSPACE    dstColorSpace        = CSpace_None;
653 };
654 
655 class SwFilterHdr : public SwFilter
656 {
657 public:
658     SwFilterHdr(VpInterface &vpInterface);
659     virtual ~SwFilterHdr();
660     virtual MOS_STATUS       Clean();
661     virtual MOS_STATUS       Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
662     virtual FeatureParamHdr &GetSwFilterParams();
663     virtual SwFilter *       Clone();
664     virtual bool             operator==(SwFilter &swFilter);
665     virtual MOS_STATUS       Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
666 
667 private:
668     FeatureParamHdr m_Params = {};
669 
670 MEDIA_CLASS_DEFINE_END(SwFilterHdr)
671 };
672 
673 struct FeatureParamLumakey : public FeatureParam
674 {
675     PVPHAL_LUMAKEY_PARAMS   lumaKeyParams;
676 };
677 
678 class SwFilterLumakey : public SwFilter
679 {
680 public:
681     SwFilterLumakey(VpInterface &vpInterface);
682     virtual ~SwFilterLumakey();
683     virtual MOS_STATUS       Clean();
684     virtual MOS_STATUS       Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
685     virtual FeatureParamLumakey &GetSwFilterParams();
686     virtual SwFilter *       Clone();
687     virtual bool             operator==(SwFilter &swFilter);
688     virtual MOS_STATUS       Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
689 
690 private:
691     FeatureParamLumakey m_Params = {};
692 
693 MEDIA_CLASS_DEFINE_END(SwFilterLumakey)
694 };
695 
696 struct FeatureParamBlending : public FeatureParam
697 {
698     PVPHAL_BLENDING_PARAMS  blendingParams;
699 };
700 
701 class SwFilterBlending : public SwFilter
702 {
703 public:
704     SwFilterBlending(VpInterface &vpInterface);
705     virtual ~SwFilterBlending();
706     virtual MOS_STATUS       Clean();
707     virtual MOS_STATUS       Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
708     virtual FeatureParamBlending &GetSwFilterParams();
709     virtual SwFilter *       Clone();
710     virtual bool             operator==(SwFilter &swFilter);
711     virtual MOS_STATUS       Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
712 
713 private:
714     FeatureParamBlending m_Params = {};
715 
716 MEDIA_CLASS_DEFINE_END(SwFilterBlending)
717 };
718 
719 struct FeatureParamColorFill : public FeatureParam
720 {
721     PVPHAL_COLORFILL_PARAMS colorFillParams;     //!< ColorFill - BG only
722 };
723 
724 class SwFilterColorFill : public SwFilter
725 {
726 public:
727     SwFilterColorFill(VpInterface &vpInterface);
728     virtual ~SwFilterColorFill();
729     virtual MOS_STATUS       Clean();
730     virtual MOS_STATUS       Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
731     virtual FeatureParamColorFill &GetSwFilterParams();
732     virtual SwFilter *       Clone();
733     virtual bool             operator==(SwFilter &swFilter);
734     virtual MOS_STATUS       Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
735     virtual VP_EngineEntry   GetCombinedFilterEngineCaps(SwFilterSubPipe *singleInputPipeSelected);
736 
737 private:
738     FeatureParamColorFill m_Params = {};
739 
740 MEDIA_CLASS_DEFINE_END(SwFilterColorFill)
741 };
742 
743 struct FeatureParamAlpha : public FeatureParam
744 {
745     PVPHAL_ALPHA_PARAMS     compAlpha         = nullptr;      //!< Alpha for composited surface
746     bool                    calculatingAlpha  = false;        //!< Alpha calculation parameters
747 };
748 
749 class SwFilterAlpha : public SwFilter
750 {
751 public:
752     SwFilterAlpha(VpInterface &vpInterface);
753     virtual ~SwFilterAlpha();
754     virtual MOS_STATUS       Clean();
755     virtual MOS_STATUS       Configure(VP_PIPELINE_PARAMS &params, bool isInputSurf, int surfIndex);
756     virtual FeatureParamAlpha &GetSwFilterParams();
757     virtual SwFilter *       Clone();
758     virtual bool             operator==(SwFilter &swFilter);
759     virtual MOS_STATUS       Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
760 
761 private:
762     FeatureParamAlpha m_Params = {};
763 
764 MEDIA_CLASS_DEFINE_END(SwFilterAlpha)
765 };
766 
767 class SwFilterSet
768 {
769 public:
770     SwFilterSet();
771     virtual ~SwFilterSet();
772 
773     MOS_STATUS AddSwFilter(SwFilter *swFilter);
774     MOS_STATUS RemoveSwFilter(SwFilter *swFilter);
775     MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe);
776     MOS_STATUS Clean();
777     SwFilter *GetSwFilter(FeatureType type);
IsEmpty()778     bool IsEmpty()
779     {
780         return m_swFilters.empty();
781     }
782 
783     std::vector<class SwFilterSet *> *GetLocation();
784     void SetLocation(std::vector<class SwFilterSet *> *location);
785     RenderTargetType                  GetRenderTargetType();
786 
787 private:
788     std::map<FeatureType, SwFilter *> m_swFilters;
789     // nullptr if it is unordered filters, otherwise, it's the pointer to m_OrderedFilters it belongs to.
790     std::vector<class SwFilterSet *> *m_location = nullptr;
791 
792 MEDIA_CLASS_DEFINE_END(SwFilterSet)
793 };
794 
795 }
796 #endif // !__SW_FILTER_H__
797