1 /* 2 * Copyright (c) 2024, Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice shall be included 12 * in all copies or substantial portions of the Software. 13 * 14 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 15 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 16 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 17 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 18 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 19 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 20 * OTHER DEALINGS IN THE SOFTWARE. 21 */ 22 //! 23 //! \file vp_l0_fc_filter.h 24 //! \brief Defines the common interface for denoise 25 //! this file is for the base interface which is shared by all l0 fc in driver. 26 27 28 #ifndef __VP_L0_FC_FILTER_H__ 29 #define __VP_L0_FC_FILTER_H__ 30 #include "vp_filter.h" 31 #include "sw_filter.h" 32 #include "vp_fc_filter.h" 33 34 namespace vp{ 35 36 struct L0_FC_LUMA_KEY_PARAMS 37 { 38 bool enabled = false; 39 VPHAL_LUMAKEY_PARAMS params = {}; 40 }; 41 42 struct L0_FC_DI_PARAMS 43 { 44 bool enabled = false; 45 VPHAL_DI_PARAMS params = {}; 46 }; 47 48 struct L0_FC_LAYER_PARAM 49 { 50 VP_SURFACE *surf = nullptr; 51 uint32_t layerID = 0; 52 uint32_t layerIDOrigin = 0; //!< Origin layerID before layerSkipped, which can be used to reference surfaces in SurfaceGroup. 53 VPHAL_SCALING_MODE scalingMode = VPHAL_SCALING_NEAREST; 54 VPHAL_ROTATION rotation = VPHAL_ROTATION_IDENTITY; 55 L0_FC_LUMA_KEY_PARAMS lumaKey = {}; 56 VPHAL_BLENDING_PARAMS blendingParams = {}; 57 VPHAL_PROCAMP_PARAMS procampParams = {}; 58 L0_FC_DI_PARAMS diParams = {}; 59 bool needIntermediaSurface = false; 60 MOS_FORMAT interMediaOverwriteSurface = Format_Any; 61 }; 62 63 struct L0_FC_COMP_PARAM 64 { 65 L0_FC_LAYER_PARAM inputLayersParam[8] = {}; 66 VPHAL_CSPACE mainCSpace = CSpace_Any; 67 uint32_t layerNumber = 0; 68 L0_FC_LAYER_PARAM outputLayerParam = {}; 69 bool enableColorFill = false; 70 VPHAL_COLORFILL_PARAMS colorFillParams = {}; //!< ColorFill - BG only 71 VPHAL_ALPHA_PARAMS compAlpha = {}; //!< Alpha for composited surface 72 bool bAlphaCalculateEnable = false; //!< Alpha Calculation flag 73 }; 74 75 class VpL0FcFilter : public VpFilter 76 { 77 public: 78 VpL0FcFilter(PVP_MHWINTERFACE vpMhwInterface); 79 ~VpL0FcFilter()80 ~VpL0FcFilter() 81 { 82 Destroy(); 83 }; 84 85 virtual MOS_STATUS Init() override; 86 87 virtual MOS_STATUS Prepare() override; 88 89 virtual MOS_STATUS Destroy() override; 90 91 virtual MOS_STATUS SetExecuteEngineCaps( 92 SwFilterPipe *executingPipe, 93 VP_EXECUTE_CAPS vpExecuteCaps); 94 95 MOS_STATUS CalculateEngineParams(); GetFcParams()96 PRENDER_L0_FC_PARAMS GetFcParams() 97 { 98 return m_renderL0FcParams; 99 } 100 101 protected: 102 //Kernel Curbe Struct 103 typedef struct _L0_FC_KRN_RECT 104 { 105 int32_t left; 106 int32_t right; 107 int32_t top; 108 int32_t bottom; 109 } L0_FC_KRN_RECT; 110 111 typedef struct _L0_FC_KRN_CSC_MATRIX 112 { 113 float s0123[4]; 114 float s4567[4]; 115 float s89AB[4]; 116 float sCDEF[4]; 117 } L0_FC_KRN_CSC_MATRIX; 118 119 typedef struct _L0_FC_KRN_SCALE_PARAM 120 { 121 L0_FC_KRN_RECT trg; 122 struct 123 { 124 float startX; 125 float startY; 126 float strideX; 127 float strideY; 128 } src; 129 uint32_t rotateIndices[2]; 130 } L0_FC_KRN_SCALE_PARAM; 131 132 typedef struct _L0_FC_KRN_COORD_SHIFT_PARAM 133 { 134 float commonShiftX; 135 float commonShiftY; 136 float chromaShiftX; 137 float chromaShiftY; 138 } L0_FC_KRN_COORD_SHIFT_PARAM; 139 140 typedef struct _L0_FC_KRN_INPUT_CONTROL_PARAM 141 { 142 uint8_t samplerType; 143 uint8_t isChromaShift; 144 uint8_t ignoreSrcPixelAlpha; 145 uint8_t ignoreDstPixelAlpha; 146 } L0_FC_KRN_INPUT_CONTROL_PARAM; 147 148 typedef struct _L0_FC_KRN_TARGET_CONTROL_PARAM 149 { 150 uint8_t isColorFill; 151 uint8_t alphaLayerIndex; 152 uint8_t hitSecPlaneFactorX; 153 uint8_t hitSecPlaneFactorY; 154 } L0_FC_KRN_TARGET_CONTROL_PARAM; 155 156 //common path params 157 typedef struct _L0_FC_KRN_IMAGE_PARAM 158 { 159 L0_FC_KRN_CSC_MATRIX csc; 160 uint32_t inputChannelIndices[4]; 161 L0_FC_KRN_SCALE_PARAM scale; 162 L0_FC_KRN_COORD_SHIFT_PARAM coordShift; 163 uint32_t inputPlaneNum; 164 L0_FC_KRN_INPUT_CONTROL_PARAM controlSetting; 165 float constAlphs; 166 struct L0_FC_KRN_LUMA_PARAM 167 { 168 float low; 169 float high; 170 } lumaKey; 171 } L0_FC_KRN_IMAGE_PARAM; 172 173 typedef struct _L0_FC_KRN_TARGET_PARAM 174 { 175 L0_FC_KRN_RECT targetROI; 176 uint32_t dynamicChannelIndices[4]; 177 float background[4]; 178 float chromaSitingFactor[4]; 179 uint32_t planeNumber; 180 L0_FC_KRN_TARGET_CONTROL_PARAM controlSetting; 181 float alpha; 182 uint32_t reserved; 183 } L0_FC_KRN_TARGET_PARAM; 184 185 186 //fast path params 187 typedef struct _L0_FC_FP_KRN_IMAGE_PARAM 188 { 189 L0_FC_KRN_CSC_MATRIX csc; 190 uint32_t inputChannelIndices[4]; 191 L0_FC_KRN_SCALE_PARAM scaleParam; 192 L0_FC_KRN_COORD_SHIFT_PARAM coordShift; 193 uint32_t inputPlaneNum; 194 L0_FC_KRN_INPUT_CONTROL_PARAM controlSetting; 195 } L0_FC_FP_KRN_IMAGE_PARAM; 196 197 typedef struct _L0_FC_FP_KRN_TARGET_PARAM 198 { 199 L0_FC_KRN_RECT targetROI; 200 uint32_t dynamicChannelIndices[4]; 201 float background[4]; 202 float chromaSitingFactor[4]; 203 uint32_t combineChannelIndices[2]; 204 uint32_t planeNumber; 205 struct 206 { 207 uint16_t x; 208 uint16_t y; 209 } alignedTrgRectStart; 210 struct 211 { 212 uint16_t width; 213 uint16_t height; 214 } alignedTrgRectSize; 215 L0_FC_KRN_TARGET_CONTROL_PARAM controlSetting; 216 float alpha; 217 uint32_t reserved; 218 } L0_FC_FP_KRN_TARGET_PARAM; 219 220 protected: 221 MOS_STATUS InitKrnParams(L0_FC_KERNEL_PARAMS &krnParam, SwFilterPipe &executingPipe); 222 MOS_STATUS InitLayer(SwFilterPipe &executingPipe, bool isInputPipe, int index, VPHAL_SCALING_MODE defaultScalingMode, L0_FC_LAYER_PARAM &layer); 223 MOS_STATUS InitCompParam(SwFilterPipe &executingPipe, L0_FC_COMP_PARAM &compParam); 224 225 MOS_STATUS GenerateFcCommonKrnParam(L0_FC_COMP_PARAM &compParam, L0_FC_KERNEL_PARAM ¶m); 226 MOS_STATUS SetupSingleFcCommonKrnArg(uint32_t layerNum, std::vector<L0_FC_KRN_IMAGE_PARAM> &imageParams, L0_FC_KRN_TARGET_PARAM &targetParam, uint32_t localSize[3], KRN_ARG &krnArg, bool &bInit); 227 MOS_STATUS SetupSingleFcCommonBti(uint32_t uIndex, const L0_FC_COMP_PARAM &compParam, SURFACE_PARAMS &surfaceParam, bool &bInit); 228 229 MOS_STATUS GenerateFc444PL3InputParam(L0_FC_LAYER_PARAM &layer, uint32_t layerNumber, L0_FC_KERNEL_PARAM ¶m, uint32_t layerIndex); 230 MOS_STATUS SetupSingleFc444PL3InputKrnArg(uint32_t localSize[3], KRN_ARG &krnArg, bool &bInit, uint32_t inputChannelIndices[4], uint32_t outputChannelIndices[4], uint32_t planeChannelIndices); 231 MOS_STATUS SetupSingleFc444PL3InputBti(uint32_t uIndex, SURFACE_PARAMS &surfaceParam, uint32_t layerIndex, bool &bInit); 232 233 MOS_STATUS GetDefaultScalingMode(VPHAL_SCALING_MODE &defaultScalingMode, SwFilterPipe &executedPipe); 234 MOS_STATUS GetChromaSitingFactor(MOS_FORMAT format, uint8_t &hitSecPlaneFactorX, uint8_t &hitSecPlaneFactorY); 235 MOS_STATUS GetBitNumber(MOS_FORMAT format, uint8_t *pOriginBitNumber, uint8_t *pStoredBitNumber, uint8_t *pAlphaBitNumber); 236 237 MOS_STATUS GenerateInputImageParam(L0_FC_LAYER_PARAM &layer, VPHAL_CSPACE mainCSpace, L0_FC_KRN_IMAGE_PARAM &imageParam); 238 MOS_STATUS ConvertCscToKrnParam(VPHAL_CSPACE srcColorSpace, VPHAL_CSPACE dstColorSpace, L0_FC_KRN_CSC_MATRIX &csc); 239 MOS_STATUS ConvertScalingRotToKrnParam(RECT &rcSrc, RECT &rcDst, VPHAL_SCALING_MODE scalingMode, uint32_t inputWidth, uint32_t inputHeight, VPHAL_ROTATION rotation, L0_FC_KRN_SCALE_PARAM &scaling, uint8_t &samplerType, L0_FC_KRN_COORD_SHIFT_PARAM &coordShift); 240 MOS_STATUS ConvertRotationToKrnParam(VPHAL_ROTATION rotation, float strideX, float strideY, float startLeft, float startRight, float startTop, float startBottom, L0_FC_KRN_SCALE_PARAM &scaling); 241 MOS_STATUS ConvertChromaUpsampleToKrnParam(MOS_FORMAT format, uint32_t chromaSitingLoc, VPHAL_SCALING_MODE scalingMode, uint32_t inputWidth, uint32_t inputHeight, float &chromaShiftX, float &chromaShiftY, uint8_t &isChromaShift); 242 MOS_STATUS ConvertInputChannelIndicesToKrnParam(MOS_FORMAT format, uint32_t* inputChannelIndices); 243 MOS_STATUS ConvertPlaneNumToKrnParam(MOS_FORMAT format, bool isInput, uint32_t &planeNum); 244 MOS_STATUS ConvertBlendingToKrnParam(VPHAL_BLENDING_PARAMS &blend, uint8_t &ignoreSrcPixelAlpha, uint8_t &ignoreDstPixelAlpha, float &constAlpha); 245 246 MOS_STATUS GenerateTargetParam(L0_FC_COMP_PARAM &compParam, L0_FC_KRN_TARGET_PARAM &targetParam); 247 MOS_STATUS ConvertOuputChannelIndicesToKrnParam(MOS_FORMAT format, uint32_t *dynamicChannelIndices); 248 MOS_STATUS ConvertTargetRoiToKrnParam(RECT &outputRcDst, uint32_t outputWidth, uint32_t outputHeight, L0_FC_KRN_RECT &targetROI); 249 MOS_STATUS ConvertChromaDownsampleToKrnParam(MOS_FORMAT format, uint32_t chromaSitingLoc, float *chromaSitingFactor, uint8_t &hitSecPlaneFactorX, uint8_t &hitSecPlaneFactorY); 250 MOS_STATUS ConvertAlphaToKrnParam(bool bAlphaCalculateEnable, VPHAL_ALPHA_PARAMS &compAlpha, float colorFillAlpha, uint8_t &alphaLayerIndex, float &alpha); 251 MOS_STATUS ConvertColorFillToKrnParam(bool enableColorFill, VPHAL_COLORFILL_PARAMS &colorFillParams, MEDIA_CSPACE dstCspace, uint8_t &isColorFill, float *background); 252 253 void PrintCompParam(L0_FC_COMP_PARAM &compParam); 254 void PrintCompLayerParam(uint32_t index, bool isInput, L0_FC_LAYER_PARAM &layerParam); 255 void PrintKrnParam(std::vector<L0_FC_KRN_IMAGE_PARAM> &imageParams, L0_FC_KRN_TARGET_PARAM &targetParam); 256 void PrintKrnImageParam(uint32_t index, L0_FC_KRN_IMAGE_PARAM &imageParam); 257 void PrintKrnTargetParam(L0_FC_KRN_TARGET_PARAM &targetParam); 258 void ReportDiffLog(const L0_FC_COMP_PARAM &compParam); 259 260 bool FastExpressConditionMeet(const L0_FC_COMP_PARAM &compParam); 261 MOS_STATUS GenerateFcFastExpressKrnParam(L0_FC_COMP_PARAM &compParam, L0_FC_KERNEL_PARAM ¶m); 262 MOS_STATUS GenerateFastExpressInputOutputParam(L0_FC_COMP_PARAM &compParam, L0_FC_FP_KRN_IMAGE_PARAM &imageParam, L0_FC_FP_KRN_TARGET_PARAM &targetParam); 263 MOS_STATUS SetupSingleFcFastExpressKrnArg(L0_FC_FP_KRN_IMAGE_PARAM &imageParams, L0_FC_FP_KRN_TARGET_PARAM &targetParam, uint32_t localSize[3], uint32_t globalSize[3], KRN_ARG &krnArg, bool &bInit); 264 MOS_STATUS SetupSingleFcFastExpressBti(uint32_t uIndex, const L0_FC_COMP_PARAM &compParam, SURFACE_PARAMS &surfaceParam, bool &bInit); 265 MOS_STATUS ConvertAlignedTrgRectToKrnParam(VP_SURFACE *inputSurf, VP_SURFACE *outputSurf, bool enableColorFill, L0_FC_FP_KRN_TARGET_PARAM &targetParam); 266 void PrintFastExpressKrnParam(L0_FC_FP_KRN_IMAGE_PARAM &imageParam, L0_FC_FP_KRN_TARGET_PARAM &targetParam); 267 268 MOS_STATUS SetPerfTag(L0_FC_COMP_PARAM &compParam, VPHAL_PERFTAG &perfTag); 269 270 SwFilterPipe *m_executingPipe = nullptr; 271 PRENDER_L0_FC_PARAMS m_renderL0FcParams = nullptr; 272 273 //to avoid duplicate allocate and free 274 KERNEL_INDEX_ARG_MAP m_fcCommonKrnArgs; 275 KERNEL_INDEX_ARG_MAP m_fcFastExpressKrnArgs; 276 KERNEL_INDEX_ARG_MAP m_fc444PL3InputKrnArgs; 277 278 MEDIA_CLASS_DEFINE_END(vp__VpL0FcFilter) 279 }; 280 281 struct HW_FILTER_L0_FC_PARAM : public HW_FILTER_PARAM 282 { 283 SwFilterPipe *executingPipe; 284 }; 285 286 class HwFilterL0FcParameter : public HwFilterParameter 287 { 288 public: 289 static HwFilterParameter *Create(HW_FILTER_L0_FC_PARAM ¶m, FeatureType featureType); 290 HwFilterL0FcParameter(FeatureType featureType); 291 virtual ~HwFilterL0FcParameter(); 292 virtual MOS_STATUS ConfigParams(HwFilter &hwFilter); 293 294 MOS_STATUS Initialize(HW_FILTER_L0_FC_PARAM ¶m); 295 296 private: 297 HW_FILTER_L0_FC_PARAM m_Params = {}; 298 299 MEDIA_CLASS_DEFINE_END(vp__HwFilterL0FcParameter) 300 }; 301 302 class VpRenderL0FcParameter : public VpPacketParameter 303 { 304 public: 305 static VpPacketParameter *Create(HW_FILTER_L0_FC_PARAM ¶m); 306 VpRenderL0FcParameter(PVP_MHWINTERFACE pHwInterface, PacketParamFactoryBase *packetParamFactory); 307 virtual ~VpRenderL0FcParameter(); 308 309 virtual bool SetPacketParam(VpCmdPacket *pPacket); 310 311 private: 312 MOS_STATUS Initialize(HW_FILTER_L0_FC_PARAM ¶ms); 313 314 VpL0FcFilter m_fcFilter; 315 316 MEDIA_CLASS_DEFINE_END(vp__VpRenderL0FcParameter) 317 }; 318 319 class PolicyL0FcFeatureHandler : public PolicyFeatureHandler 320 { 321 public: PolicyL0FcFeatureHandler(VP_HW_CAPS & hwCaps)322 PolicyL0FcFeatureHandler(VP_HW_CAPS &hwCaps) : PolicyFeatureHandler(hwCaps) 323 { 324 m_Type = FeatureTypeFc; 325 } ~PolicyL0FcFeatureHandler()326 virtual ~PolicyL0FcFeatureHandler() 327 { 328 } IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps)329 virtual bool IsFeatureEnabled(VP_EXECUTE_CAPS vpExecuteCaps) 330 { 331 // Not create hwFilters for single FC features. 332 return false; 333 } CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps,SwFilterPipe & swFilterPipe,PVP_MHWINTERFACE pHwInterface)334 virtual HwFilterParameter *CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps, SwFilterPipe &swFilterPipe, PVP_MHWINTERFACE pHwInterface) 335 { 336 return nullptr; 337 } 338 virtual MOS_STATUS UpdateFeaturePipe(VP_EXECUTE_CAPS caps, SwFilter &feature, SwFilterPipe &featurePipe, SwFilterPipe &executePipe, bool isInputPipe, int index); CreatePacketParam(HW_FILTER_PARAM & param)339 static VpPacketParameter *CreatePacketParam(HW_FILTER_PARAM ¶m) 340 { 341 return nullptr; 342 } 343 virtual MOS_STATUS UpdateUnusedFeature(VP_EXECUTE_CAPS caps, SwFilter &feature, SwFilterPipe &featurePipe, SwFilterPipe &executePipe, bool isInputPipe, int index); 344 345 MEDIA_CLASS_DEFINE_END(vp__PolicyL0FcFeatureHandler) 346 }; 347 348 class PolicyL0FcHandler : public PolicyFcHandler 349 { 350 public: 351 PolicyL0FcHandler(VP_HW_CAPS &hwCaps); 352 virtual ~PolicyL0FcHandler(); 353 virtual HwFilterParameter *CreateHwFilterParam(VP_EXECUTE_CAPS vpExecuteCaps, SwFilterPipe &swFilterPipe, PVP_MHWINTERFACE pHwInterface) override; CreatePacketParam(HW_FILTER_PARAM & param)354 static VpPacketParameter *CreatePacketParam(HW_FILTER_PARAM ¶m) 355 { 356 if (param.type != FeatureTypeFcOnRender) 357 { 358 VP_PUBLIC_ASSERTMESSAGE("Invalid parameter for FC!"); 359 return nullptr; 360 } 361 362 HW_FILTER_L0_FC_PARAM *fcParam = (HW_FILTER_L0_FC_PARAM *)(¶m); 363 return VpRenderL0FcParameter::Create(*fcParam); 364 } 365 366 private: 367 PacketParamFactory<VpRenderL0FcParameter> m_PacketL0ParamFactory; 368 369 MEDIA_CLASS_DEFINE_END(vp__PolicyL0FcHandler) 370 }; 371 372 } 373 374 #endif