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 ¶ms, 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 ¶ms) 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 ¶ms, 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 ¶ms); 403 virtual MOS_STATUS Configure(FeatureParamCsc ¶ms); 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 ¶ms, bool isInputSurf, int surfIndex); 458 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms); 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 ¶ms, bool isInputSurf, int surfIndex); 495 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms); 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 ¶ms, 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 ¶ms, 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 ¶ms, 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 ¶ms, 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 ¶ms, 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