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.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 #include "surface_type.h" 39 40 namespace vp 41 { 42 class VpInterface; 43 class SwFilterSubPipe; 44 45 #define FEATURE_TYPE_ENGINE_BITS_SFC 0x20 46 #define FEATURE_TYPE_ENGINE_BITS_VEBOX 0x40 47 #define FEATURE_TYPE_ENGINE_BITS_RENDER 0x80 48 49 #define FEATURE_TYPE_ENGINE_BITS_SUB_STEP 0x01 50 51 #define IS_FEATURE_TYPE_ON_SFC(type) ((type)&FEATURE_TYPE_ENGINE_BITS_SFC) 52 #define IS_FEATURE_TYPE_ON_VEBOX(type) ((type)&FEATURE_TYPE_ENGINE_BITS_VEBOX) 53 #define IS_FEATURE_TYPE_ON_VEBOX_SFC(type) (IS_FEATURE_TYPE_ON_SFC(type) || IS_FEATURE_TYPE_ON_VEBOX(type)) 54 #define IS_FEATURE_TYPE_ON_RENDER(type) ((type)&FEATURE_TYPE_ENGINE_BITS_RENDER) 55 56 #define FEATURE_TYPE_MASK 0xffffff00 57 #define FEATURE_TYPE_ENGINE_ASSIGNED(feature) (((feature)&FEATURE_TYPE_MASK) != (feature)) 58 59 #define VPHAL_MAX_HDR_INPUT_LAYER 8 60 #define VPHAL_MAX_HDR_OUTPUT_LAYER 1 61 #define VPHAL_HDR_BTINDEX_LAYER0 16 62 #define VPHAL_HDR_BTINDEX_PER_LAYER0 5 63 #define VPHAL_HDR_BTINDEX_RENDERTARGET 56 64 #define VPHAL_HDR_BTINDEX_PER_TARGET 3 65 #define VPHAL_HDR_SAMPLER8X8_TABLE_NUM 2 66 #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) 67 68 enum FeatureType 69 { 70 FeatureTypeInvalid = 0, 71 FeatureTypeCsc = 0x100, 72 FeatureTypeCscOnSfc = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_SFC, 73 FeatureTypeCscOnVebox = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_VEBOX, 74 FeatureTypeCscOnRender = FeatureTypeCsc | FEATURE_TYPE_ENGINE_BITS_RENDER, 75 FeatureTypeRotMir = 0x200, 76 FeatureTypeRotMirOnSfc = FeatureTypeRotMir | FEATURE_TYPE_ENGINE_BITS_SFC, 77 FeatureTypeRotMirOnRender = FeatureTypeRotMir | FEATURE_TYPE_ENGINE_BITS_RENDER, 78 FeatureTypeScaling = 0x300, 79 FeatureTypeScalingOnSfc = FeatureTypeScaling | FEATURE_TYPE_ENGINE_BITS_SFC, 80 FeatureTypeScalingOnRender = FeatureTypeScaling | FEATURE_TYPE_ENGINE_BITS_RENDER, 81 FeatureTypeDn = 0x400, 82 FeatureTypeDnOnVebox = FeatureTypeDn | FEATURE_TYPE_ENGINE_BITS_VEBOX, 83 FeatureTypeDnHVSCalOnRender = FeatureTypeDn | FEATURE_TYPE_ENGINE_BITS_RENDER | FEATURE_TYPE_ENGINE_BITS_SUB_STEP, 84 FeatureTypeDi = 0x500, 85 FeatureTypeDiOnVebox = FeatureTypeDi | FEATURE_TYPE_ENGINE_BITS_VEBOX, 86 FeatureTypeDiOnRender = FeatureTypeDi | FEATURE_TYPE_ENGINE_BITS_RENDER, 87 FeatureTypeSte = 0x600, 88 FeatureTypeSteOnVebox = FeatureTypeSte | FEATURE_TYPE_ENGINE_BITS_VEBOX, 89 FeatureTypeVeboxUpdate = 0x700, 90 FeatureTypeVeboxUpdateOnRender = FeatureTypeVeboxUpdate | FEATURE_TYPE_ENGINE_BITS_RENDER, 91 FeatureTypeTcc = 0x800, 92 FeatureTypeTccOnVebox = FeatureTypeTcc | FEATURE_TYPE_ENGINE_BITS_VEBOX, 93 FeatureTypeProcamp = 0x900, 94 FeatureTypeProcampOnVebox = FeatureTypeProcamp | FEATURE_TYPE_ENGINE_BITS_VEBOX, 95 FeatureTypeProcampOnRender = FeatureTypeProcamp | FEATURE_TYPE_ENGINE_BITS_RENDER, 96 FeatureTypeCgc = 0xA00, 97 FeatureTypeCgcOnVebox = FeatureTypeCgc | FEATURE_TYPE_ENGINE_BITS_VEBOX, 98 FeatureTypeHdr = 0xB00, 99 FeatureTypeHdrOnVebox = FeatureTypeHdr | FEATURE_TYPE_ENGINE_BITS_VEBOX, 100 FeatureTypeHdr3DLutCalOnRender = FeatureTypeHdr | FEATURE_TYPE_ENGINE_BITS_RENDER | FEATURE_TYPE_ENGINE_BITS_SUB_STEP, 101 FeatureTypeHdrOnRender = FeatureTypeHdr | FEATURE_TYPE_ENGINE_BITS_RENDER, 102 FeatureTypeSecureCopy = 0xC00, 103 FeatureTypeSecureCopyOnRender = FeatureTypeSecureCopy | FEATURE_TYPE_ENGINE_BITS_RENDER, 104 FeatureTypeGamutExt = 0xD00, 105 FeatureTypeFc = 0xE00, 106 FeatureTypeFcOnRender = FeatureTypeFc | FEATURE_TYPE_ENGINE_BITS_RENDER, 107 FeatureTypeLumakey = 0xF00, 108 FeatureTypeLumakeyOnRender = FeatureTypeLumakey | FEATURE_TYPE_ENGINE_BITS_RENDER, 109 FeatureTypeBlending = 0x1000, 110 FeatureTypeBlendingOnRender = FeatureTypeBlending | FEATURE_TYPE_ENGINE_BITS_RENDER, 111 FeatureTypeColorFill = 0x1100, 112 FeatureTypeColorFillOnSfc = FeatureTypeColorFill | FEATURE_TYPE_ENGINE_BITS_SFC, 113 FeatureTypeColorFillOnRender = FeatureTypeColorFill | FEATURE_TYPE_ENGINE_BITS_RENDER, 114 FeatureTypeAlpha = 0x1200, 115 FeatureTypeAlphaOnSfc = FeatureTypeAlpha | FEATURE_TYPE_ENGINE_BITS_SFC, 116 FeatureTypeAlphaOnVebox = FeatureTypeAlpha | FEATURE_TYPE_ENGINE_BITS_VEBOX, 117 FeatureTypeAlphaOnRender = FeatureTypeAlpha | FEATURE_TYPE_ENGINE_BITS_RENDER, 118 NumOfFeatureTypeBase, 119 120 #ifdef _MEDIA_RESERVED 121 #include "feature_type_ext.h" 122 #endif 123 124 NumOfFeatureType 125 }; 126 127 enum RenderTargetType 128 { 129 RenderTargetTypeInvalid = 0, 130 RenderTargetTypeSurface, 131 RenderTargetTypeParameter 132 }; 133 134 using VP_SURFACE_GROUP = std::map<SurfaceType, VP_SURFACE*>; 135 136 enum OutMode 137 { 138 OUT_DISABLED = 0, 139 OUT_TO_TARGET, 140 OUT_TO_NEXTPASS 141 }; 142 143 struct REMOVE_BB_SETTING 144 { 145 bool isRemoveBB = false; 146 bool isKeepMaxBlob = false; 147 uint32_t index = 0; 148 uint32_t height = 0; 149 uint32_t width = 0; 150 uint32_t size = 0; 151 uint16_t inputActiveRegionWidth = 0; 152 uint16_t inputActiveRegionHeight = 0; 153 uint8_t *removeBlobLinearAddressAligned = 0; 154 }; 155 156 struct MOTIONLESS_SETTING 157 { 158 bool isEnable = false; 159 bool isSkipDetection = false; 160 bool isInfer = false; 161 bool isFirstConv = false; 162 bool isMotion = false; 163 bool isResUpdate = false; 164 bool forceDisable = false; 165 uint32_t width = 0; 166 uint32_t height = 0; 167 }; 168 169 struct COLOR_BALANCE_SETTING 170 { 171 bool isEnable = false; 172 uint32_t index = 0; 173 uint32_t skipThreshold = 0; 174 uint16_t inputActiveRegionWidth = 0; 175 uint16_t inputActiveRegionHeight = 0; 176 uint32_t pitch = 0; 177 uint32_t mPitch = 0; 178 uint8_t downScaleFactor = 1; 179 uint8_t colorTemperature = 0; 180 uint8_t *cbLinearAddressAligned = 0; 181 double backgroundWhiteMatrix[3] = {1, 1, 1}; 182 }; 183 184 struct VP_POSTPROCESS_SURFACE 185 { 186 REMOVE_BB_SETTING removeBBSetting; 187 MOTIONLESS_SETTING motionlessSetting; 188 COLOR_BALANCE_SETTING colorBalanceSetting; 189 }; 190 191 struct VP_SURFACE_SETTING 192 { 193 VP_SURFACE_GROUP surfGroup; 194 bool isPastHistogramValid = false; 195 uint32_t imageWidthOfPastHistogram = 0; 196 uint32_t imageHeightOfPastHistogram = 0; 197 uint32_t dwVeboxPerBlockStatisticsHeight = 0; 198 uint32_t dwVeboxPerBlockStatisticsWidth = 0; 199 uint32_t aggregateBlockSize = 0; 200 bool laceLutValid = false; 201 bool updateGlobalToneMappingCurveLUTSurface = false; 202 bool updateWeitCoefSurface = false; 203 bool dumpLaceSurface = false; 204 bool dumpPreSurface = false; 205 bool dumpPostSurface = false; 206 VP_POSTPROCESS_SURFACE postProcessSurface = {}; 207 const uint16_t *pHDRStageConfigTable = nullptr; 208 bool coeffAllocated = false; 209 bool OETF1DLUTAllocated = false; 210 bool Cri3DLUTAllocated = false; 211 CleanVP_SURFACE_SETTING212 void Clean() 213 { 214 surfGroup.clear(); 215 isPastHistogramValid = false; 216 imageWidthOfPastHistogram = 0; 217 imageHeightOfPastHistogram = 0; 218 dwVeboxPerBlockStatisticsHeight = 0; 219 dwVeboxPerBlockStatisticsWidth = 0; 220 aggregateBlockSize = 0; 221 laceLutValid = false; 222 updateGlobalToneMappingCurveLUTSurface = true; 223 updateWeitCoefSurface = true; 224 dumpLaceSurface = false; 225 dumpPreSurface = false; 226 dumpPostSurface = false; 227 postProcessSurface.removeBBSetting = {}; 228 postProcessSurface.motionlessSetting = {}; 229 postProcessSurface.colorBalanceSetting = {}; 230 pHDRStageConfigTable = nullptr; 231 coeffAllocated = false; 232 OETF1DLUTAllocated = false; 233 Cri3DLUTAllocated = false; 234 } 235 }; 236 237 #define FEATURE_TYPE_MASK 0xffffff00 238 #define FEATURE_TYPE_ENGINE_ASSIGNED(feature) (((feature)&FEATURE_TYPE_MASK) != (feature)) 239 240 inline bool operator==(FeatureType a, FeatureType b) 241 { 242 return (int)a == (int)b || (int)(a & FEATURE_TYPE_MASK) == (int)b || (int)a == (int)(FEATURE_TYPE_MASK & b); 243 } 244 245 inline bool operator!=(FeatureType a, FeatureType b) 246 { 247 return !(a == b); 248 } 249 250 inline bool operator<(FeatureType a, FeatureType b) 251 { 252 return a != b && (int)a < (int)b; 253 } 254 255 #define RECT_ROTATE(rcOut, rcIn) \ 256 { \ 257 (rcOut).left = (rcIn).top; \ 258 (rcOut).right = (rcIn).bottom; \ 259 (rcOut).top = (rcIn).left; \ 260 (rcOut).bottom = (rcIn).right; \ 261 } 262 263 struct FeatureParam 264 { 265 FeatureType type = FeatureTypeInvalid; 266 MOS_FORMAT formatInput = Format_None; 267 MOS_FORMAT formatOutput = Format_None; 268 }; 269 270 enum FeatureCategory 271 { 272 FeatureCategoryBasic = 0, 273 FeatureCategoryIsolated, 274 FeatureCategoryFC, 275 }; 276 277 class SwFilterSet; 278 279 class SwFilter 280 { 281 public: 282 SwFilter(VpInterface &vpInterface, FeatureType type); 283 virtual ~SwFilter(); Clean()284 virtual MOS_STATUS Clean() 285 { 286 MOS_ZeroMemory(&m_EngineCaps, sizeof(m_EngineCaps)); 287 m_noNeedUpdate = false; 288 m_isInExePipe = false; 289 return MOS_STATUS_SUCCESS; 290 } GetFeatureType()291 virtual FeatureType GetFeatureType() 292 { 293 return m_type; 294 } IsEngineAssigned()295 virtual bool IsEngineAssigned() 296 { 297 return m_type != (m_type & FEATURE_TYPE_MASK); 298 } GetRenderTargetType()299 virtual RenderTargetType GetRenderTargetType() 300 { 301 return m_renderTargetType; 302 } IsFeatureEnabled(VP_EXECUTE_CAPS caps)303 bool IsFeatureEnabled(VP_EXECUTE_CAPS caps) 304 { 305 return m_EngineCaps.bEnabled && (m_EngineCaps.SfcNeeded && caps.bSFC || 306 m_EngineCaps.VeboxNeeded && caps.bVebox || m_EngineCaps.RenderNeeded && caps.bRender); 307 } 308 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool bInputSurf, int surfIndex) = 0; Configure(PVP_SURFACE surfInput,PVP_SURFACE surfOutput,VP_EXECUTE_CAPS caps)309 virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps) 310 { 311 return MOS_STATUS_UNIMPLEMENTED; 312 } 313 Configure(VEBOX_SFC_PARAMS & params)314 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms) 315 { 316 return MOS_STATUS_UNIMPLEMENTED; 317 } 318 Configure(SwFilter & swFilter,VP_EXECUTE_CAPS caps)319 virtual MOS_STATUS Configure(SwFilter& swFilter, VP_EXECUTE_CAPS caps) 320 { 321 return MOS_STATUS_UNIMPLEMENTED; 322 } 323 324 virtual SwFilter *Clone() = 0; 325 virtual bool operator == (class SwFilter&) = 0; 326 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe) = 0; 327 virtual MOS_STATUS SetFeatureType(FeatureType type); 328 virtual MOS_STATUS ResetFeatureType(); 329 virtual MOS_STATUS SetRenderTargetType(RenderTargetType type); 330 SwFilter* CreateSwFilter(FeatureType type); 331 void DestroySwFilter(SwFilter* p); 332 SetLocation(SwFilterSet * swFilterSet)333 void SetLocation(SwFilterSet *swFilterSet) 334 { 335 m_location = swFilterSet; 336 } 337 GetLocation()338 SwFilterSet *GetLocation() 339 { 340 return m_location; 341 } 342 GetVpInterface()343 VpInterface& GetVpInterface() 344 { 345 return m_vpInterface; 346 } 347 GetFilterEngineCaps()348 VP_EngineEntry& GetFilterEngineCaps() 349 { 350 return m_EngineCaps; 351 } 352 353 // For some feature in output pipe, enable or disable depends on other feature status of input pipe. 354 // If singleInputPipeSelected != nullptr, means single input pipe inuse, otherwise, multi-input pipe in use. GetCombinedFilterEngineCaps(SwFilterSubPipe * singleInputPipeSelected)355 virtual VP_EngineEntry GetCombinedFilterEngineCaps(SwFilterSubPipe *singleInputPipeSelected) 356 { 357 return m_EngineCaps; 358 } 359 360 // The child class need to implement SetResourceAssignmentHint only when any feature 361 // parameters will affect the resource assignment. SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)362 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 363 { 364 return MOS_STATUS_SUCCESS; 365 } 366 AddFeatureGraphRTLog()367 virtual MOS_STATUS AddFeatureGraphRTLog() 368 { 369 return MOS_STATUS_SUCCESS; 370 } 371 SetExePipeFlag(bool isInExePipe)372 void SetExePipeFlag(bool isInExePipe) 373 { 374 m_isInExePipe = isInExePipe; 375 } 376 377 VP_MHWINTERFACE* GetHwInterface(); 378 379 protected: 380 VpInterface &m_vpInterface; 381 FeatureType m_type = FeatureTypeInvalid; 382 // SwFilterSet current swFilter belongs to. 383 SwFilterSet *m_location = nullptr; 384 VP_EngineEntry m_EngineCaps = {}; 385 bool m_noNeedUpdate = false; 386 RenderTargetType m_renderTargetType = RenderTargetTypeSurface; 387 bool m_isInExePipe = false; 388 389 MEDIA_CLASS_DEFINE_END(vp__SwFilter) 390 }; 391 392 struct FeatureParamCsc : public FeatureParam 393 { 394 struct CSC_PARAMS 395 { 396 VPHAL_CSPACE colorSpace = CSpace_None; 397 uint32_t chromaSiting = 0; 398 MOS_TILE_MODE_GMM tileMode = MOS_TILE_4_GMM; 399 bool operator == (const struct CSC_PARAMS &b) 400 { 401 return colorSpace == b.colorSpace && chromaSiting == b.chromaSiting; 402 } 403 }; 404 CSC_PARAMS input = {}; 405 CSC_PARAMS output = {}; 406 PVPHAL_IEF_PARAMS pIEFParams = nullptr; 407 PVPHAL_ALPHA_PARAMS pAlphaParams = nullptr; 408 MOS_FORMAT formatforCUS = Format_None; //!< Only valid when formatforCUS != Format_None for Chromaupsampling. To be cleared in SwFilterCsc::Configure 409 FeatureParamCsc *next = nullptr; //!< pointe to new/next generated CSC params 410 bool isFullRgbG10P709 = false; //!< whether output colorspace is DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 411 }; 412 413 class SwFilterCsc : public SwFilter 414 { 415 public: 416 SwFilterCsc(VpInterface &vpInterface); 417 virtual ~SwFilterCsc(); 418 virtual MOS_STATUS Clean(); 419 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 420 virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps); 421 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms); 422 virtual MOS_STATUS Configure(FeatureParamCsc ¶ms); 423 virtual FeatureParamCsc &GetSwFilterParams(); 424 virtual SwFilter *Clone(); 425 virtual bool operator == (SwFilter& swFilter); 426 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); 427 virtual MOS_STATUS SetFeatureType(FeatureType type); AddFeatureGraphRTLog()428 virtual MOS_STATUS AddFeatureGraphRTLog() 429 { 430 MT_LOG5(MT_VP_FEATURE_GRAPH_SWFILTERCSC, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_INPUTCOLORSPACE, m_Params.input.colorSpace, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTCOLORSPACE, m_Params.output.colorSpace, 431 MT_VP_FEATURE_GRAPH_FILTER_INPUTFORMAT, m_Params.formatInput, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTFORMAT, m_Params.formatOutput, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 432 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterCsc: inputcolorSpace %d, outputcolorSpace, %d, formatInput %d, formatOutput %d, FeatureType %d", m_Params.input.colorSpace, m_Params.output.colorSpace, 433 m_Params.formatInput, m_Params.formatOutput, GetFeatureType()); 434 return MOS_STATUS_SUCCESS; 435 } 436 437 private: 438 FeatureParamCsc m_Params = {}; 439 440 MEDIA_CLASS_DEFINE_END(vp__SwFilterCsc) 441 }; 442 443 struct FeatureParamScaling : public FeatureParam 444 { 445 struct SCALING_PARAMS 446 { 447 uint32_t dwWidth = 0; 448 uint32_t dwHeight = 0; 449 uint32_t dwPitch = 0; 450 RECT rcSrc = {0, 0, 0, 0}; 451 RECT rcDst = {0, 0, 0, 0}; //!< Input dst rect without rotate being applied. 452 RECT rcMaxSrc = {0, 0, 0, 0}; 453 VPHAL_SAMPLE_TYPE sampleType = SAMPLE_PROGRESSIVE; 454 MOS_TILE_MODE_GMM tileMode = MOS_TILE_4_GMM; 455 bool operator == (struct SCALING_PARAMS &b) 456 { 457 // no use sizeof(SCALING_PARAMS) to avoid undefined padding data being used. 458 return 0 == memcmp(this, &b, (uint64_t)(&tileMode) - (uint64_t)(this) + sizeof(tileMode)); 459 } 460 }; 461 462 // Parameters maintained by scaling feature parameters 463 SCALING_PARAMS input = {}; 464 SCALING_PARAMS output = {}; 465 bool isPrimary = false; 466 VPHAL_SCALING_MODE scalingMode = VPHAL_SCALING_NEAREST; 467 VPHAL_SCALING_PREFERENCE scalingPreference = VPHAL_SCALING_PREFER_SFC; //!< DDI indicate Scaling preference 468 bool bDirectionalScalar = false; //!< Vebox Directional Scalar 469 bool bTargetRectangle = false; // Target rectangle enabled 470 PVPHAL_COLORFILL_PARAMS pColorFillParams = nullptr; //!< ColorFill - BG only 471 PVPHAL_ALPHA_PARAMS pCompAlpha = nullptr; //!< Alpha for composited surfaces 472 VPHAL_ISCALING_TYPE interlacedScalingType = ISCALING_NONE; 473 474 // Parameters maintained by other feature parameters. 475 struct { 476 VPHAL_CSPACE colorSpaceOutput = CSpace_None; 477 } csc; 478 479 struct { 480 bool rotationNeeded = false; //!< Whether rotate SwFilter exists on SwFilterPipe. 481 } rotation; 482 483 bool operator == (struct FeatureParamScaling &b) 484 { 485 return formatInput == b.formatInput && 486 formatOutput == b.formatOutput && 487 input == b.input && 488 output == b.output && 489 isPrimary == b.isPrimary && 490 scalingMode == b.scalingMode && 491 scalingPreference == b.scalingPreference && 492 bDirectionalScalar == b.bDirectionalScalar && 493 bTargetRectangle == b.bTargetRectangle && 494 interlacedScalingType == b.interlacedScalingType && 495 csc.colorSpaceOutput == b.csc.colorSpaceOutput && 496 rotation.rotationNeeded == b.rotation.rotationNeeded && 497 (nullptr == pColorFillParams && nullptr == b.pColorFillParams || 498 nullptr != pColorFillParams && nullptr != b.pColorFillParams && 499 0 == memcmp(pColorFillParams, b.pColorFillParams, sizeof(VPHAL_COLORFILL_PARAMS))) && 500 (nullptr == pCompAlpha && nullptr == b.pCompAlpha || 501 nullptr != pCompAlpha && nullptr != b.pCompAlpha && 502 0 == memcmp(pCompAlpha, b.pCompAlpha, sizeof(VPHAL_ALPHA_PARAMS))); 503 } 504 505 FeatureParamScaling *next = nullptr; //!< pointe to new/next generated scaling params 506 }; 507 508 class SwFilterScaling : public SwFilter 509 { 510 public: 511 SwFilterScaling(VpInterface &vpInterface); 512 virtual ~SwFilterScaling(); 513 virtual MOS_STATUS Clean(); 514 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 515 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms); 516 virtual MOS_STATUS Configure(PVP_SURFACE surfInput, PVP_SURFACE surfOutput, VP_EXECUTE_CAPS caps); 517 virtual FeatureParamScaling &GetSwFilterParams(); 518 virtual SwFilter *Clone(); 519 virtual bool operator == (SwFilter& swFilter); 520 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)521 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 522 { 523 hint.isIScalingTypeNone = ISCALING_NONE == m_Params.interlacedScalingType; 524 hint.isFieldWeaving = ISCALING_FIELD_TO_INTERLEAVED == m_Params.interlacedScalingType; 525 return MOS_STATUS_SUCCESS; 526 } AddFeatureGraphRTLog()527 virtual MOS_STATUS AddFeatureGraphRTLog() 528 { 529 MT_LOG7(MT_VP_FEATURE_GRAPH_SWFILTERSCALING, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_INPUTHEIGHT, m_Params.input.dwHeight, MT_VP_FEATURE_GRAPH_FILTER_INPUTWIDTH, m_Params.input.dwWidth, 530 MT_VP_FEATURE_GRAPH_FILTER_INPUTTILEMODE, m_Params.input.tileMode, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTHEIGHT, m_Params.output.dwHeight, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTWIDTH, 531 m_Params.output.dwWidth, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTTILEMODE, m_Params.output.tileMode, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 532 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterScaling: input_dwHeight %d, input_dwWidth, %d, input_tileMode %d, output_dwHeight %d, output_dwWidth %d, output_tileMode %d, interlacedScalingType %d, \ 533 scalingMode %d, FeatureType %d", m_Params.input.dwHeight, m_Params.input.dwWidth, m_Params.input.tileMode, m_Params.output.dwHeight, m_Params.output.dwWidth, 534 m_Params.output.tileMode, m_Params.interlacedScalingType, m_Params.scalingMode, GetFeatureType()); 535 536 return MOS_STATUS_SUCCESS; 537 } 538 539 private: 540 FeatureParamScaling m_Params = {}; 541 542 MEDIA_CLASS_DEFINE_END(vp__SwFilterScaling) 543 }; 544 545 struct FeatureParamRotMir : public FeatureParam 546 { 547 // Parameters maintained by rotation feature parameters 548 VPHAL_ROTATION rotation = VPHAL_ROTATION_IDENTITY; 549 550 // Parameters maintained by other feature parameters. 551 struct { 552 MOS_TILE_TYPE tileOutput = MOS_TILE_X; 553 } surfInfo; 554 555 bool operator == (const struct FeatureParamRotMir &b) 556 { 557 return rotation == b.rotation && 558 surfInfo.tileOutput == b.surfInfo.tileOutput; 559 } 560 }; 561 562 class SwFilterRotMir : public SwFilter 563 { 564 public: 565 SwFilterRotMir(VpInterface &vpInterface); 566 virtual ~SwFilterRotMir(); 567 virtual MOS_STATUS Clean(); 568 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 569 virtual MOS_STATUS Configure(VEBOX_SFC_PARAMS ¶ms); 570 virtual FeatureParamRotMir &GetSwFilterParams(); 571 virtual SwFilter *Clone(); 572 virtual bool operator == (SwFilter& swFilter); 573 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()574 virtual MOS_STATUS AddFeatureGraphRTLog() 575 { 576 MT_LOG2(MT_VP_FEATURE_GRAPH_SWFILTERROTMIR, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_ROTATION, m_Params.rotation, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 577 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterRotMir: rotation %d, FeatureType %d", m_Params.rotation, GetFeatureType()); 578 return MOS_STATUS_SUCCESS; 579 } 580 581 private: 582 FeatureParamRotMir m_Params = {}; 583 584 MEDIA_CLASS_DEFINE_END(vp__SwFilterRotMir) 585 }; 586 587 enum DN_STAGE 588 { 589 DN_STAGE_DEFAULT = 0, 590 DN_STAGE_HVS_KERNEL, 591 DN_STAGE_VEBOX_HVS_UPDATE, 592 DN_STAGE_VEBOX_HVS_NO_UPDATE, 593 }; 594 595 struct FeatureParamDenoise : public FeatureParam 596 { 597 VPHAL_SAMPLE_TYPE sampleTypeInput = SAMPLE_PROGRESSIVE; 598 VPHAL_DENOISE_PARAMS denoiseParams = {}; 599 uint32_t widthAlignUnitInput = 0; 600 uint32_t heightAlignUnitInput = 0; 601 uint32_t heightInput = 0; 602 bool secureDnNeeded = false; 603 DN_STAGE stage = DN_STAGE_DEFAULT; 604 uint32_t srcBottom = 0; 605 bool operator==(const struct FeatureParamDenoise &b) 606 { 607 return sampleTypeInput == b.sampleTypeInput && 608 denoiseParams == b.denoiseParams && 609 widthAlignUnitInput == b.widthAlignUnitInput && 610 heightAlignUnitInput == b.heightAlignUnitInput && 611 MOS_MIN(heightInput, srcBottom) == MOS_MIN(b.heightInput, srcBottom) && 612 secureDnNeeded == b.secureDnNeeded && 613 stage == b.stage; 614 } 615 }; 616 617 class SwFilterDenoise : public SwFilter 618 { 619 public: 620 SwFilterDenoise(VpInterface& vpInterface); 621 virtual ~SwFilterDenoise(); 622 virtual MOS_STATUS Clean(); 623 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 624 virtual MOS_STATUS Configure(FeatureParamDenoise ¶ms); 625 virtual FeatureParamDenoise& GetSwFilterParams(); 626 virtual SwFilter* Clone(); 627 virtual bool operator == (SwFilter& swFilter); 628 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)629 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 630 { 631 hint.isHVSTableNeeded = DN_STAGE_HVS_KERNEL == m_Params.stage || 632 DN_STAGE_VEBOX_HVS_UPDATE == m_Params.stage; 633 return MOS_STATUS_SUCCESS; 634 } AddFeatureGraphRTLog()635 virtual MOS_STATUS AddFeatureGraphRTLog() 636 { 637 MT_LOG7(MT_VP_FEATURE_GRAPH_SWFILTERDENOISE, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_CHROMADN, m_Params.denoiseParams.bEnableChroma, MT_VP_FEATURE_GRAPH_FILTER_LUMADN, m_Params.denoiseParams.bEnableLuma, 638 MT_VP_FEATURE_GRAPH_FILTER_AUTODETECT, m_Params.denoiseParams.bAutoDetect, MT_VP_FEATURE_GRAPH_FILTER_HVSDN, m_Params.denoiseParams.bEnableHVSDenoise, MT_VP_FEATURE_GRAPH_FILTER_DNFACTOR, 639 (int64_t)m_Params.denoiseParams.fDenoiseFactor, MT_VP_FEATURE_GRAPH_FILTER_SECUREDNNEED, m_Params.secureDnNeeded, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 640 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterDenoise: bEnableChroma %d, bEnableLuma %d, bAutoDetect %d, bEnableHVSDenoise %d, fDenoiseFactor %f, secureDnNeeded %d, FeatureType %d", m_Params.denoiseParams.bEnableChroma, 641 m_Params.denoiseParams.bEnableLuma, m_Params.denoiseParams.bAutoDetect, m_Params.denoiseParams.bEnableHVSDenoise, m_Params.denoiseParams.fDenoiseFactor, m_Params.secureDnNeeded, GetFeatureType()); 642 return MOS_STATUS_SUCCESS; 643 } 644 645 private: 646 FeatureParamDenoise m_Params = {}; 647 648 MEDIA_CLASS_DEFINE_END(vp__SwFilterDenoise) 649 }; 650 651 struct FeatureParamDeinterlace : public FeatureParam 652 { 653 VPHAL_SAMPLE_TYPE sampleTypeInput = SAMPLE_PROGRESSIVE; 654 bool bHDContent = false; 655 PVPHAL_DI_PARAMS diParams = nullptr; 656 bool bFmdExtraVariance = false; //!< Check if extra FMD variances need to be calculated 657 bool bQueryVarianceEnable = false; //!< Query variance enabled 658 uint32_t heightInput = 0; 659 RECT rcSrc = {0, 0, 0, 0}; 660 }; 661 662 class SwFilterDeinterlace : public SwFilter 663 { 664 public: 665 SwFilterDeinterlace(VpInterface& vpInterface); 666 virtual ~SwFilterDeinterlace(); 667 virtual MOS_STATUS Clean(); 668 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 669 virtual FeatureParamDeinterlace& GetSwFilterParams(); 670 virtual SwFilter* Clone(); 671 virtual bool operator == (SwFilter& swFilter); 672 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)673 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 674 { 675 hint.bDi = 1; 676 hint.b60fpsDi = m_Params.diParams && !m_Params.diParams->bSingleField; 677 return MOS_STATUS_SUCCESS; 678 } AddFeatureGraphRTLog()679 virtual MOS_STATUS AddFeatureGraphRTLog() 680 { 681 MT_LOG4(MT_VP_FEATURE_GRAPH_SWFILTERDEINTERLACE, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_SAMPLETYPEINPUT, m_Params.sampleTypeInput, 682 MT_VP_FEATURE_GRAPH_FILTER_SINGLEFIELD, m_Params.diParams ? m_Params.diParams->bSingleField : -1, MT_VP_FEATURE_GRAPH_FILTER_DIMODE, m_Params.diParams ? m_Params.diParams->DIMode : -1, 683 MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 684 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterDeinterlace: sampleTypeInput %d, bSingleField %d, DIMode %d, FeatureType %d", m_Params.sampleTypeInput, 685 m_Params.diParams ? m_Params.diParams->bSingleField : -1, m_Params.diParams ? m_Params.diParams->DIMode : -1, GetFeatureType()); 686 return MOS_STATUS_SUCCESS; 687 } 688 689 private: 690 FeatureParamDeinterlace m_Params = {}; 691 692 MEDIA_CLASS_DEFINE_END(vp__SwFilterDeinterlace) 693 }; 694 695 struct FeatureParamSte : public FeatureParam 696 { 697 bool bEnableSTE = false; 698 uint32_t dwSTEFactor = 0; 699 700 // For STD alone case 701 bool bEnableSTD = false; 702 VPHAL_STD_PARAMS STDParam = {}; 703 }; 704 705 class SwFilterSte : public SwFilter 706 { 707 public: 708 SwFilterSte(VpInterface& vpInterface); 709 virtual ~SwFilterSte(); 710 virtual MOS_STATUS Clean(); 711 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 712 virtual FeatureParamSte& GetSwFilterParams(); 713 virtual SwFilter* Clone(); 714 virtual bool operator == (SwFilter& swFilter); 715 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)716 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 717 { 718 MT_LOG1(MT_VP_FEATURE_GRAPH_SWFILTERSTD, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_STD_OUTPUT_ENABLE, m_Params.bEnableSTD); 719 VP_PUBLIC_NORMALMESSAGE("STD Output Enable: %d", m_Params.bEnableSTD); 720 if (m_Params.bEnableSTD) 721 { 722 // isSkinScoreDumpNeededForSTDonly for STD output to internal surface and copy to STDParam. 723 // isSkinScoreOutputNeededForSTDOnly for STD output to output surface directly. It set internal 724 // SkinScore surface to VeboxCurrentOutput and external output surface to VeboxSkinScore to 725 // achieve it, instead of setting Output STD Decisions to 1. 726 hint.isSkinScoreDumpNeededForSTDonly = !m_Params.STDParam.bOutputSkinScore; 727 hint.isSkinScoreOutputNeededForSTDOnly = m_Params.STDParam.bOutputSkinScore; 728 MT_LOG2(MT_VP_FEATURE_GRAPH_SWFILTERSTD, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_STD_OUTPUT_TO_STDPARAM, hint.isSkinScoreDumpNeededForSTDonly, MT_VP_FEATURE_GRAPH_FILTER_STD_OUTPUT_TO_OUTPUT_SURFACE, hint.isSkinScoreOutputNeededForSTDOnly); 729 VP_PUBLIC_NORMALMESSAGE("STD Output isSkinScoreDumpNeededForSTDonly: %d, isSkinScoreOutputNeededForSTDOnly: %d", hint.isSkinScoreDumpNeededForSTDonly, hint.isSkinScoreOutputNeededForSTDOnly); 730 } 731 732 return MOS_STATUS_SUCCESS; 733 } AddFeatureGraphRTLog()734 virtual MOS_STATUS AddFeatureGraphRTLog() 735 { 736 MT_LOG3(MT_VP_FEATURE_GRAPH_SWFILTERSTE, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_STEFACTOR, m_Params.dwSTEFactor, MT_VP_FEATURE_GRAPH_FILTER_ENABLESTD, m_Params.bEnableSTD, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 737 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterSte: dwSTEFactor %d, bEnableSTD %d, FeatureType %d", m_Params.dwSTEFactor, m_Params.bEnableSTD, GetFeatureType()); 738 return MOS_STATUS_SUCCESS; 739 } 740 741 private: 742 FeatureParamSte m_Params = {}; 743 744 MEDIA_CLASS_DEFINE_END(vp__SwFilterSte) 745 }; 746 747 struct FeatureParamTcc : public FeatureParam 748 { 749 bool bEnableTCC = false; 750 uint8_t Red = 0; 751 uint8_t Green = 0; 752 uint8_t Blue = 0; 753 uint8_t Cyan = 0; 754 uint8_t Magenta = 0; 755 uint8_t Yellow = 0; 756 }; 757 758 class SwFilterTcc : public SwFilter 759 { 760 public: 761 SwFilterTcc(VpInterface& vpInterface); 762 virtual ~SwFilterTcc(); 763 virtual MOS_STATUS Clean(); 764 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 765 virtual FeatureParamTcc& GetSwFilterParams(); 766 virtual SwFilter* Clone(); 767 virtual bool operator == (SwFilter& swFilter); 768 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()769 virtual MOS_STATUS AddFeatureGraphRTLog() 770 { 771 MT_LOG4(MT_VP_FEATURE_GRAPH_SWFILTERTCC, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_TCCRED, m_Params.Red, MT_VP_FEATURE_GRAPH_FILTER_TCCGREEN, m_Params.Green, MT_VP_FEATURE_GRAPH_FILTER_TCCBLUE, 772 m_Params.Blue, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 773 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterTcc: Red %d, Green %d, Blue %d, FeatureType %d", m_Params.Red, m_Params.Green, m_Params.Blue, GetFeatureType()); 774 return MOS_STATUS_SUCCESS; 775 } 776 777 private: 778 FeatureParamTcc m_Params = {}; 779 780 MEDIA_CLASS_DEFINE_END(vp__SwFilterTcc) 781 }; 782 783 struct FeatureParamProcamp : public FeatureParam 784 { 785 PVPHAL_PROCAMP_PARAMS procampParams = nullptr; 786 }; 787 788 class SwFilterProcamp : public SwFilter 789 { 790 public: 791 SwFilterProcamp(VpInterface& vpInterface); 792 virtual ~SwFilterProcamp(); 793 virtual MOS_STATUS Clean(); 794 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 795 virtual FeatureParamProcamp& GetSwFilterParams(); 796 virtual SwFilter* Clone(); 797 virtual bool operator == (SwFilter& swFilter); 798 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()799 virtual MOS_STATUS AddFeatureGraphRTLog() 800 { 801 MT_LOG5(MT_VP_FEATURE_GRAPH_SWFILTERPROCAMP, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_BRIGHTNESS, m_Params.procampParams ? (int64_t)m_Params.procampParams->fBrightness : -1, 802 MT_VP_FEATURE_GRAPH_FILTER_CONTRAST, m_Params.procampParams ? (int64_t)m_Params.procampParams->fContrast : -1, MT_VP_FEATURE_GRAPH_FILTER_HUE, m_Params.procampParams ? (int64_t)m_Params.procampParams->fHue : -1, 803 MT_VP_FEATURE_GRAPH_FILTER_SATURATION, m_Params.procampParams ? (int64_t) m_Params.procampParams->fSaturation : -1, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 804 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterProcamp: fBrightness %f, fContrast %f, fHue %f, fSaturation %f, FeatureType %d", m_Params.procampParams ? m_Params.procampParams->fBrightness : -1, 805 m_Params.procampParams ? m_Params.procampParams->fContrast : -1, m_Params.procampParams ? m_Params.procampParams->fHue : -1, 806 m_Params.procampParams ? m_Params.procampParams->fSaturation : -1, GetFeatureType()); 807 return MOS_STATUS_SUCCESS; 808 } 809 810 private: 811 FeatureParamProcamp m_Params = {}; 812 813 MEDIA_CLASS_DEFINE_END(vp__SwFilterProcamp) 814 }; 815 816 enum HDR_STAGE 817 { 818 HDR_STAGE_DEFAULT = 0, 819 HDR_STAGE_3DLUT_KERNEL, 820 HDR_STAGE_VEBOX_3DLUT_UPDATE, 821 HDR_STAGE_VEBOX_3DLUT_NO_UPDATE, 822 HDR_STAGE_VEBOX_EXTERNAL_3DLUT, 823 }; 824 825 //! 826 //! \brief Hdr stages enable flag 827 //! 828 typedef union _HDRStageEnables 829 { 830 uint16_t value; 831 struct 832 { 833 uint16_t PriorCSCEnable : 1; 834 uint16_t EOTFEnable : 1; 835 uint16_t CCMEnable : 1; 836 uint16_t PWLFEnable : 1; 837 uint16_t CCMExt1Enable : 1; 838 uint16_t GamutClamp1Enable : 1; 839 uint16_t CCMExt2Enable : 1; 840 uint16_t GamutClamp2Enable : 1; 841 uint16_t OETFEnable : 1; 842 uint16_t PostCSCEnable : 1; 843 uint16_t Reserved : 6; 844 }; 845 } HDRStageEnables, *PHDRStageEnables; 846 847 //! 848 //! Structure VPHAL_HDR_PARAMS 849 //! \brief High Dynamic Range parameters 850 //! 851 typedef struct _HDR_PARAMS 852 { 853 VPHAL_HDR_EOTF_TYPE EOTF = VPHAL_HDR_EOTF_INVALID; //!< Electronic-Optimal Transfer Function 854 uint16_t display_primaries_x[3] = {0}; //!< Display Primaries X chromaticity coordinates 855 uint16_t display_primaries_y[3] = {0}; //!< Display Primaries Y chromaticity coordinates 856 uint16_t white_point_x = 0; //!< X Chromaticity coordinate of White Point 857 uint16_t white_point_y = 0; //!< Y Chromaticity coordinate of White Point 858 uint16_t max_display_mastering_luminance = 0; //!< The nominal maximum display luminance of the mastering display 859 uint16_t min_display_mastering_luminance = 0; //!< The nominal minimum display luminance of the mastering display 860 uint16_t MaxCLL = 0; //!< Max Content Light Level 861 uint16_t MaxFALL = 0; //!< Max Frame Average Light Level 862 bool bAutoMode = false; //!< Hdr auto mode. 863 bool bPathKernel = false; //!< Hdr path config to use kernel 864 } HDR_PARAMS, *PHDR_PARAMS; 865 866 struct FeatureParamHdr : public FeatureParam 867 { 868 uint32_t uiMaxDisplayLum = 0; //!< Maximum Display Luminance 869 uint32_t uiMaxContentLevelLum = 0; //!< Maximum Content Level Luminance 870 VPHAL_HDR_MODE hdrMode = VPHAL_HDR_MODE_NONE; 871 VPHAL_CSPACE srcColorSpace = CSpace_None; 872 VPHAL_CSPACE dstColorSpace = CSpace_None; 873 HDR_STAGE stage = HDR_STAGE_DEFAULT; 874 uint32_t widthInput = 0; 875 uint32_t heightInput = 0; 876 uint32_t lutSize = 0; 877 VPHAL_HDR_LUT_MODE lutMode = VPHAL_HDR_LUT_MODE_NONE; //!< LUT Mode 878 VPHAL_HDR_LUT_MODE globalLutMode = VPHAL_HDR_LUT_MODE_NONE; //!< Global LUT mode control for debugging purpose 879 bool bGpuGenerate3DLUT = false; //!< Flag for per frame GPU generation of 3DLUT 880 bool is3DLutKernelOnly = false; 881 882 PVPHAL_COLORFILL_PARAMS pColorFillParams = nullptr; //!< ColorFill - BG only 883 bool bDisableAutoMode = false; //!< Force to disable Hdr auto mode tone mapping for debugging purpose 884 uint32_t uiSplitFramePortions = 1; //!< Split Frame flag 885 bool bForceSplitFrame = false; 886 bool bNeed3DSampler = false; //!< indicate whether 3D should neede by force considering AVS removal etc. 887 bool isL0KernelEnabled = false; 888 889 HDR_PARAMS srcHDRParams = {}; 890 HDR_PARAMS targetHDRParams = {}; 891 PVPHAL_3DLUT_PARAMS external3DLutParams = nullptr; 892 }; 893 894 class SwFilterHdr : public SwFilter 895 { 896 public: 897 SwFilterHdr(VpInterface &vpInterface); 898 virtual ~SwFilterHdr(); 899 virtual MOS_STATUS Clean(); 900 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 901 virtual FeatureParamHdr &GetSwFilterParams(); 902 virtual SwFilter * Clone(); 903 virtual bool operator==(SwFilter &swFilter); 904 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT & hint)905 virtual MOS_STATUS SetResourceAssignmentHint(RESOURCE_ASSIGNMENT_HINT &hint) 906 { 907 hint.is3DLut2DNeeded = HDR_STAGE_3DLUT_KERNEL == m_Params.stage || 908 HDR_STAGE_VEBOX_3DLUT_UPDATE == m_Params.stage; 909 return MOS_STATUS_SUCCESS; 910 } 911 912 MOS_STATUS HdrIsInputFormatSupported( 913 PVPHAL_SURFACE pSrcSurface, 914 bool *pbSupported); 915 916 MOS_STATUS HdrIsOutputFormatSupported( 917 PVPHAL_SURFACE pTargetSurface, 918 bool *pbSupported); AddFeatureGraphRTLog()919 virtual MOS_STATUS AddFeatureGraphRTLog() 920 { 921 MT_LOG7(MT_VP_FEATURE_GRAPH_SWFILTERHDR, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_HDRMODE, m_Params.hdrMode, MT_VP_FEATURE_GRAPH_FILTER_GPUGENERATE3DLUT, m_Params.bGpuGenerate3DLUT, 922 MT_VP_FEATURE_GRAPH_FILTER_INPUTFORMAT, m_Params.formatInput, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTFORMAT, m_Params.formatOutput, MT_VP_FEATURE_GRAPH_FILTER_INPUTCOLORSPACE, 923 m_Params.srcColorSpace, MT_VP_FEATURE_GRAPH_FILTER_OUTPUTCOLORSPACE, m_Params.dstColorSpace, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 924 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterHdr: hdrMode %d, lutMode %d, bGpuGenerate3DLUT %d, formatInput %d, formatOutput %d, srcColorSpace %d, dstColorSpace %d, FeatureType %d", m_Params.hdrMode, 925 m_Params.lutMode, m_Params.bGpuGenerate3DLUT, m_Params.formatInput, m_Params.formatOutput, m_Params.srcColorSpace, m_Params.dstColorSpace, GetFeatureType()); 926 927 return MOS_STATUS_SUCCESS; 928 } 929 930 private: 931 FeatureParamHdr m_Params = {}; 932 933 MEDIA_CLASS_DEFINE_END(vp__SwFilterHdr) 934 }; 935 936 struct FeatureParamLumakey : public FeatureParam 937 { 938 PVPHAL_LUMAKEY_PARAMS lumaKeyParams = nullptr; 939 }; 940 941 class SwFilterLumakey : public SwFilter 942 { 943 public: 944 SwFilterLumakey(VpInterface &vpInterface); 945 virtual ~SwFilterLumakey(); 946 virtual MOS_STATUS Clean(); 947 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 948 virtual FeatureParamLumakey &GetSwFilterParams(); 949 virtual SwFilter * Clone(); 950 virtual bool operator==(SwFilter &swFilter); 951 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()952 virtual MOS_STATUS AddFeatureGraphRTLog() 953 { 954 MT_LOG3(MT_VP_FEATURE_GRAPH_SWFILTERLUMAKEY, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_LUMAHIGH, m_Params.lumaKeyParams ? m_Params.lumaKeyParams->LumaHigh : -1, MT_VP_FEATURE_GRAPH_FILTER_LUMALOW, 955 m_Params.lumaKeyParams ? m_Params.lumaKeyParams->LumaLow : -1, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 956 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterLumakey: LumaHigh %d, LumaLow %d, FeatureType %d", m_Params.lumaKeyParams ? m_Params.lumaKeyParams->LumaHigh : -1, m_Params.lumaKeyParams ? m_Params.lumaKeyParams->LumaLow : -1, 957 GetFeatureType()); 958 return MOS_STATUS_SUCCESS; 959 } 960 961 private: 962 FeatureParamLumakey m_Params = {}; 963 964 MEDIA_CLASS_DEFINE_END(vp__SwFilterLumakey) 965 }; 966 967 struct FeatureParamBlending : public FeatureParam 968 { 969 PVPHAL_BLENDING_PARAMS blendingParams = nullptr; 970 }; 971 972 class SwFilterBlending : public SwFilter 973 { 974 public: 975 SwFilterBlending(VpInterface &vpInterface); 976 virtual ~SwFilterBlending(); 977 virtual MOS_STATUS Clean(); 978 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 979 virtual FeatureParamBlending &GetSwFilterParams(); 980 virtual SwFilter * Clone(); 981 virtual bool operator==(SwFilter &swFilter); 982 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()983 virtual MOS_STATUS AddFeatureGraphRTLog() 984 { 985 MT_LOG3(MT_VP_FEATURE_GRAPH_SWFILTERBLENDING, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_BLENDTYPE, m_Params.blendingParams ? m_Params.blendingParams->BlendType : -1, MT_VP_FEATURE_GRAPH_FILTER_FALPHA, 986 m_Params.blendingParams ? (int64_t) m_Params.blendingParams->fAlpha : -1, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 987 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterBlending: BlendType %d, fAlpha %f, FeatureType %d", m_Params.blendingParams ? m_Params.blendingParams->BlendType : -1, 988 m_Params.blendingParams ? m_Params.blendingParams->fAlpha : -1, GetFeatureType()); 989 return MOS_STATUS_SUCCESS; 990 } 991 992 private: 993 FeatureParamBlending m_Params = {}; 994 995 MEDIA_CLASS_DEFINE_END(vp__SwFilterBlending) 996 }; 997 998 struct FeatureParamColorFill : public FeatureParam 999 { 1000 PVPHAL_COLORFILL_PARAMS colorFillParams = nullptr; //!< ColorFill - BG only 1001 bool operator == (const struct FeatureParamColorFill &b) 1002 { 1003 return (nullptr == colorFillParams && nullptr == b.colorFillParams || 1004 nullptr != colorFillParams && nullptr != b.colorFillParams && 1005 0 == memcmp(colorFillParams, b.colorFillParams, sizeof(*b.colorFillParams))); 1006 } 1007 }; 1008 1009 class SwFilterColorFill : public SwFilter 1010 { 1011 public: 1012 SwFilterColorFill(VpInterface &vpInterface); 1013 virtual ~SwFilterColorFill(); 1014 virtual MOS_STATUS Clean(); 1015 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 1016 virtual FeatureParamColorFill &GetSwFilterParams(); 1017 virtual SwFilter * Clone(); 1018 virtual bool operator==(SwFilter &swFilter); 1019 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); 1020 virtual VP_EngineEntry GetCombinedFilterEngineCaps(SwFilterSubPipe *singleInputPipeSelected); AddFeatureGraphRTLog()1021 virtual MOS_STATUS AddFeatureGraphRTLog() 1022 { 1023 MT_LOG3(MT_VP_FEATURE_GRAPH_SWFILTERCOLORFILL, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_INPUTCOLORSPACE, m_Params.colorFillParams ? m_Params.colorFillParams->CSpace : -1, 1024 MT_VP_FEATURE_GRAPH_FILTER_DISABLECFINSFC, m_Params.colorFillParams ? m_Params.colorFillParams->bDisableColorfillinSFC : -1, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 1025 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterColorFill: CSpace %d, bDisableColorfillinSFC %d, FeatureType %d", m_Params.colorFillParams ? m_Params.colorFillParams->CSpace : -1, 1026 m_Params.colorFillParams ? m_Params.colorFillParams->bDisableColorfillinSFC : -1, GetFeatureType()); 1027 return MOS_STATUS_SUCCESS; 1028 } 1029 1030 private: 1031 FeatureParamColorFill m_Params = {}; 1032 1033 MEDIA_CLASS_DEFINE_END(vp__SwFilterColorFill) 1034 }; 1035 1036 struct FeatureParamAlpha : public FeatureParam 1037 { 1038 PVPHAL_ALPHA_PARAMS compAlpha = nullptr; //!< Alpha for composited surface 1039 bool calculatingAlpha = false; //!< Alpha calculation parameters 1040 bool operator == (const struct FeatureParamAlpha &b) 1041 { 1042 return calculatingAlpha == b.calculatingAlpha && 1043 (nullptr == compAlpha && nullptr == b.compAlpha || 1044 nullptr != compAlpha && nullptr != b.compAlpha && 1045 0 == memcmp(compAlpha, b.compAlpha, sizeof(*b.compAlpha))); 1046 } 1047 }; 1048 1049 class SwFilterAlpha : public SwFilter 1050 { 1051 public: 1052 SwFilterAlpha(VpInterface &vpInterface); 1053 virtual ~SwFilterAlpha(); 1054 virtual MOS_STATUS Clean(); 1055 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS ¶ms, bool isInputSurf, int surfIndex); 1056 virtual FeatureParamAlpha &GetSwFilterParams(); 1057 virtual SwFilter * Clone(); 1058 virtual bool operator==(SwFilter &swFilter); 1059 virtual MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); AddFeatureGraphRTLog()1060 virtual MOS_STATUS AddFeatureGraphRTLog() 1061 { 1062 MT_LOG4(MT_VP_FEATURE_GRAPH_SWFILTERALPHA, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_CALCULATINGALPHA, m_Params.calculatingAlpha, MT_VP_FEATURE_GRAPH_FILTER_ALPHAMODE, 1063 m_Params.compAlpha ? m_Params.compAlpha->AlphaMode : -1, MT_VP_FEATURE_GRAPH_FILTER_FALPHA, m_Params.compAlpha ? (int64_t) m_Params.compAlpha->fAlpha*1000 : -1, 1064 MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 1065 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterAlpha: calculatingAlpha %d, AlphaMode %d, fAlpha %f, FeatureType %d", m_Params.calculatingAlpha, m_Params.compAlpha ? m_Params.compAlpha->AlphaMode : -1, 1066 m_Params.compAlpha ? m_Params.compAlpha->fAlpha : -1, GetFeatureType()); 1067 return MOS_STATUS_SUCCESS; 1068 } 1069 1070 private: 1071 FeatureParamAlpha m_Params = {}; 1072 1073 MEDIA_CLASS_DEFINE_END(vp__SwFilterAlpha) 1074 }; 1075 1076 struct FeatureParamCgc : public FeatureParam 1077 { 1078 VPHAL_GAMUT_MODE GCompMode = GAMUT_MODE_NONE; 1079 VPHAL_CSPACE colorSpace = CSpace_None; 1080 VPHAL_CSPACE dstColorSpace = CSpace_None; 1081 bool bBt2020ToRGB = false; 1082 bool bExtendedSrcGamut = false; 1083 bool bExtendedDstGamut = false; 1084 uint32_t dwAttenuation = 0; //!< U2.10 [0, 1024] 0 = No down scaling, 1024 = Full down scaling 1085 float displayRGBW_x[4] = {}; 1086 float displayRGBW_y[4] = {}; 1087 }; 1088 1089 class SwFilterCgc : public SwFilter 1090 { 1091 public: 1092 SwFilterCgc(VpInterface& vpInterface); 1093 virtual ~SwFilterCgc(); 1094 virtual MOS_STATUS Clean(); 1095 virtual MOS_STATUS Configure(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); 1096 virtual FeatureParamCgc& GetSwFilterParams(); 1097 virtual SwFilter* Clone(); 1098 virtual bool operator == (SwFilter& swFilter); 1099 virtual MOS_STATUS Update(VP_SURFACE* inputSurf, VP_SURFACE* outputSurf, SwFilterSubPipe &pipe); 1100 virtual bool IsBt2020ToRGB(VP_PIPELINE_PARAMS& params, bool isInputSurf, int surfIndex); IsBt2020ToRGBEnabled()1101 virtual bool IsBt2020ToRGBEnabled() 1102 { 1103 return m_Params.bBt2020ToRGB; 1104 } AddFeatureGraphRTLog()1105 virtual MOS_STATUS AddFeatureGraphRTLog() 1106 { 1107 MT_LOG5(MT_VP_FEATURE_GRAPH_SWFILTERCGC, MT_NORMAL, MT_VP_FEATURE_GRAPH_FILTER_GCOMPMODE, m_Params.GCompMode, MT_VP_FEATURE_GRAPH_FILTER_INPUTCOLORSPACE, m_Params.colorSpace, 1108 MT_VP_FEATURE_GRAPH_FILTER_OUTPUTCOLORSPACE, m_Params.dstColorSpace, MT_VP_FEATURE_GRAPH_FILTER_BT2020TORGB, m_Params.bBt2020ToRGB, MT_VP_FEATURE_GRAPH_FILTER_FEATURETYPE, GetFeatureType()); 1109 VP_PUBLIC_NORMALMESSAGE("Feature Graph: SwFilterCgc: GCompMode %d, srccolorSpace %d, dstColorSpace %d, bBt2020ToRGB %d, FeatureType %d", m_Params.GCompMode, m_Params.colorSpace, 1110 m_Params.dstColorSpace, m_Params.bBt2020ToRGB, GetFeatureType()); 1111 return MOS_STATUS_SUCCESS; 1112 } 1113 1114 protected: 1115 FeatureParamCgc m_Params = {}; 1116 1117 MEDIA_CLASS_DEFINE_END(vp__SwFilterCgc) 1118 }; 1119 1120 class SwFilterSet 1121 { 1122 public: 1123 SwFilterSet(); 1124 virtual ~SwFilterSet(); 1125 1126 MOS_STATUS AddSwFilter(SwFilter *swFilter); 1127 MOS_STATUS RemoveSwFilter(SwFilter *swFilter); 1128 MOS_STATUS Update(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, SwFilterSubPipe &pipe); 1129 MOS_STATUS AddFeatureGraphRTLog(); 1130 MOS_STATUS Clean(); 1131 SwFilter *GetSwFilter(FeatureType type); IsEmpty()1132 bool IsEmpty() 1133 { 1134 return m_swFilters.empty(); 1135 } 1136 1137 std::vector<class SwFilterSet *> *GetLocation(); 1138 void SetLocation(std::vector<class SwFilterSet *> *location); 1139 RenderTargetType GetRenderTargetType(); 1140 1141 private: 1142 std::map<FeatureType, SwFilter *> m_swFilters; 1143 // nullptr if it is unordered filters, otherwise, it's the pointer to m_OrderedFilters it belongs to. 1144 std::vector<class SwFilterSet *> *m_location = nullptr; 1145 1146 MEDIA_CLASS_DEFINE_END(vp__SwFilterSet) 1147 }; 1148 1149 } 1150 #endif // !__SW_FILTER_H__ 1151