diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /gfx/src/FilterSupport.h | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'gfx/src/FilterSupport.h')
-rw-r--r-- | gfx/src/FilterSupport.h | 466 |
1 files changed, 466 insertions, 0 deletions
diff --git a/gfx/src/FilterSupport.h b/gfx/src/FilterSupport.h new file mode 100644 index 0000000000..94c535ab0f --- /dev/null +++ b/gfx/src/FilterSupport.h @@ -0,0 +1,466 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef __FilterSupport_h +#define __FilterSupport_h + +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Matrix.h" +#include "mozilla/gfx/Point.h" +#include "mozilla/gfx/Rect.h" +#include "nsRegion.h" +#include "nsTArray.h" + +namespace mozilla { +namespace gfx { +class FilterPrimitiveDescription; +class FilterNode; +struct FilterDescription; +} // namespace gfx +} // namespace mozilla + +extern const float gsRGBToLinearRGBMap[256]; + +namespace mozilla { +namespace gfx { +namespace FilterWrappers { +extern already_AddRefed<FilterNode> Clear(DrawTarget* aDT); +extern already_AddRefed<FilterNode> ForSurface( + DrawTarget* aDT, SourceSurface* aSurface, const IntPoint& aSurfacePosition); +} // namespace FilterWrappers + +// Morphology Operators +const unsigned short SVG_OPERATOR_UNKNOWN = 0; +const unsigned short SVG_OPERATOR_ERODE = 1; +const unsigned short SVG_OPERATOR_DILATE = 2; + +// ColorMatrix types +const unsigned short SVG_FECOLORMATRIX_TYPE_UNKNOWN = 0; +const unsigned short SVG_FECOLORMATRIX_TYPE_MATRIX = 1; +const unsigned short SVG_FECOLORMATRIX_TYPE_SATURATE = 2; +const unsigned short SVG_FECOLORMATRIX_TYPE_HUE_ROTATE = 3; +const unsigned short SVG_FECOLORMATRIX_TYPE_LUMINANCE_TO_ALPHA = 4; +// ColorMatrix types for CSS filters +const unsigned short SVG_FECOLORMATRIX_TYPE_SEPIA = 5; + +// ComponentTransfer types +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_UNKNOWN = 0; +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_IDENTITY = 1; +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_TABLE = 2; +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_DISCRETE = 3; +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_LINEAR = 4; +const unsigned short SVG_FECOMPONENTTRANSFER_TYPE_GAMMA = 5; +const unsigned short SVG_FECOMPONENTTRANSFER_SAME_AS_R = 6; + +// Blend Mode Values +const unsigned short SVG_FEBLEND_MODE_UNKNOWN = 0; +const unsigned short SVG_FEBLEND_MODE_NORMAL = 1; +const unsigned short SVG_FEBLEND_MODE_MULTIPLY = 2; +const unsigned short SVG_FEBLEND_MODE_SCREEN = 3; +const unsigned short SVG_FEBLEND_MODE_DARKEN = 4; +const unsigned short SVG_FEBLEND_MODE_LIGHTEN = 5; +const unsigned short SVG_FEBLEND_MODE_OVERLAY = 6; +const unsigned short SVG_FEBLEND_MODE_COLOR_DODGE = 7; +const unsigned short SVG_FEBLEND_MODE_COLOR_BURN = 8; +const unsigned short SVG_FEBLEND_MODE_HARD_LIGHT = 9; +const unsigned short SVG_FEBLEND_MODE_SOFT_LIGHT = 10; +const unsigned short SVG_FEBLEND_MODE_DIFFERENCE = 11; +const unsigned short SVG_FEBLEND_MODE_EXCLUSION = 12; +const unsigned short SVG_FEBLEND_MODE_HUE = 13; +const unsigned short SVG_FEBLEND_MODE_SATURATION = 14; +const unsigned short SVG_FEBLEND_MODE_COLOR = 15; +const unsigned short SVG_FEBLEND_MODE_LUMINOSITY = 16; + +// Edge Mode Values +const unsigned short SVG_EDGEMODE_UNKNOWN = 0; +const unsigned short SVG_EDGEMODE_DUPLICATE = 1; +const unsigned short SVG_EDGEMODE_WRAP = 2; +const unsigned short SVG_EDGEMODE_NONE = 3; + +// Channel Selectors +const unsigned short SVG_CHANNEL_UNKNOWN = 0; +const unsigned short SVG_CHANNEL_R = 1; +const unsigned short SVG_CHANNEL_G = 2; +const unsigned short SVG_CHANNEL_B = 3; +const unsigned short SVG_CHANNEL_A = 4; + +// Turbulence Types +const unsigned short SVG_TURBULENCE_TYPE_UNKNOWN = 0; +const unsigned short SVG_TURBULENCE_TYPE_FRACTALNOISE = 1; +const unsigned short SVG_TURBULENCE_TYPE_TURBULENCE = 2; + +// Composite Operators +const unsigned short SVG_FECOMPOSITE_OPERATOR_UNKNOWN = 0; +const unsigned short SVG_FECOMPOSITE_OPERATOR_OVER = 1; +const unsigned short SVG_FECOMPOSITE_OPERATOR_IN = 2; +const unsigned short SVG_FECOMPOSITE_OPERATOR_OUT = 3; +const unsigned short SVG_FECOMPOSITE_OPERATOR_ATOP = 4; +const unsigned short SVG_FECOMPOSITE_OPERATOR_XOR = 5; +const unsigned short SVG_FECOMPOSITE_OPERATOR_ARITHMETIC = 6; +const unsigned short SVG_FECOMPOSITE_OPERATOR_LIGHTER = 7; + +struct FilterAttribute; + +// Limits +const float kMaxStdDeviation = 500; + +// Simple PrimitiveAttributes: + +struct EmptyAttributes { + bool operator==(const EmptyAttributes& aOther) const { return true; } +}; + +struct BlendAttributes { + uint32_t mBlendMode; + + bool operator==(const BlendAttributes& aOther) const { + return mBlendMode == aOther.mBlendMode; + } +}; + +struct MorphologyAttributes { + uint32_t mOperator; + Size mRadii; + + bool operator==(const MorphologyAttributes& aOther) const { + return mOperator == aOther.mOperator && mRadii == aOther.mRadii; + } +}; + +struct FloodAttributes { + sRGBColor mColor; + + bool operator==(const FloodAttributes& aOther) const { + return mColor == aOther.mColor; + } +}; + +struct TileAttributes { + bool operator==(const TileAttributes& aOther) const { return true; } +}; + +struct OpacityAttributes { + float mOpacity; + + bool operator==(const OpacityAttributes& aOther) const { + return mOpacity == aOther.mOpacity; + } +}; + +struct OffsetAttributes { + IntPoint mValue; + + bool operator==(const OffsetAttributes& aOther) const { + return mValue == aOther.mValue; + } +}; + +struct DisplacementMapAttributes { + float mScale; + uint32_t mXChannel; + uint32_t mYChannel; + + bool operator==(const DisplacementMapAttributes& aOther) const { + return mScale == aOther.mScale && mXChannel == aOther.mXChannel && + mYChannel == aOther.mYChannel; + } +}; + +struct TurbulenceAttributes { + IntPoint mOffset; + Size mBaseFrequency; + float mSeed; + uint32_t mOctaves; + bool mStitchable; + uint32_t mType; + + bool operator==(const TurbulenceAttributes& aOther) const { + return mOffset == aOther.mOffset && + mBaseFrequency == aOther.mBaseFrequency && mSeed == aOther.mSeed && + mOctaves == aOther.mOctaves && mStitchable == aOther.mStitchable && + mType == aOther.mType; + } +}; + +struct MergeAttributes { + bool operator==(const MergeAttributes& aOther) const { return true; } +}; + +struct ImageAttributes { + uint32_t mFilter; + uint32_t mInputIndex; + Matrix mTransform; + + bool operator==(const ImageAttributes& aOther) const { + return mFilter == aOther.mFilter && mInputIndex == aOther.mInputIndex && + mTransform.ExactlyEquals(aOther.mTransform); + } +}; + +struct GaussianBlurAttributes { + Size mStdDeviation; + + bool operator==(const GaussianBlurAttributes& aOther) const { + return mStdDeviation == aOther.mStdDeviation; + } +}; + +struct DropShadowAttributes { + Size mStdDeviation; + Point mOffset; + sRGBColor mColor; + + bool operator==(const DropShadowAttributes& aOther) const { + return mStdDeviation == aOther.mStdDeviation && mOffset == aOther.mOffset && + mColor == aOther.mColor; + } +}; + +struct ToAlphaAttributes { + bool operator==(const ToAlphaAttributes& aOther) const { return true; } +}; + +// Complex PrimitiveAttributes: + +class ImplicitlyCopyableFloatArray : public CopyableTArray<float> { + public: + ImplicitlyCopyableFloatArray() = default; + + ImplicitlyCopyableFloatArray(ImplicitlyCopyableFloatArray&& aOther) = default; + + ImplicitlyCopyableFloatArray& operator=( + ImplicitlyCopyableFloatArray&& aOther) = default; + + ImplicitlyCopyableFloatArray(const ImplicitlyCopyableFloatArray& aOther) = + default; + + ImplicitlyCopyableFloatArray& operator=( + const ImplicitlyCopyableFloatArray& aOther) = default; +}; + +struct ColorMatrixAttributes { + uint32_t mType; + ImplicitlyCopyableFloatArray mValues; + + bool operator==(const ColorMatrixAttributes& aOther) const { + return mType == aOther.mType && mValues == aOther.mValues; + } +}; + +// If the types for G and B are SVG_FECOMPONENTTRANSFER_SAME_AS_R, +// use the R channel values - this lets us avoid copies. +const uint32_t kChannelROrRGB = 0; +const uint32_t kChannelG = 1; +const uint32_t kChannelB = 2; +const uint32_t kChannelA = 3; + +const uint32_t kComponentTransferSlopeIndex = 0; +const uint32_t kComponentTransferInterceptIndex = 1; + +const uint32_t kComponentTransferAmplitudeIndex = 0; +const uint32_t kComponentTransferExponentIndex = 1; +const uint32_t kComponentTransferOffsetIndex = 2; + +struct ComponentTransferAttributes { + uint8_t mTypes[4]; + ImplicitlyCopyableFloatArray mValues[4]; + + bool operator==(const ComponentTransferAttributes& aOther) const { + return mTypes[0] == aOther.mTypes[0] && mTypes[1] == aOther.mTypes[1] && + mTypes[2] == aOther.mTypes[2] && mTypes[3] == aOther.mTypes[3] && + mValues[0] == aOther.mValues[0] && mValues[1] == aOther.mValues[1] && + mValues[2] == aOther.mValues[2] && mValues[3] == aOther.mValues[3]; + } +}; + +struct ConvolveMatrixAttributes { + IntSize mKernelSize; + ImplicitlyCopyableFloatArray mKernelMatrix; + float mDivisor; + float mBias; + IntPoint mTarget; + uint32_t mEdgeMode; + Size mKernelUnitLength; + bool mPreserveAlpha; + + bool operator==(const ConvolveMatrixAttributes& aOther) const { + return mKernelSize == aOther.mKernelSize && + mKernelMatrix == aOther.mKernelMatrix && + mDivisor == aOther.mDivisor && mBias == aOther.mBias && + mTarget == aOther.mTarget && mEdgeMode == aOther.mEdgeMode && + mKernelUnitLength == aOther.mKernelUnitLength && + mPreserveAlpha == aOther.mPreserveAlpha; + } +}; + +struct CompositeAttributes { + uint32_t mOperator; + ImplicitlyCopyableFloatArray mCoefficients; + + bool operator==(const CompositeAttributes& aOther) const { + return mOperator == aOther.mOperator && + mCoefficients == aOther.mCoefficients; + } +}; + +enum class LightType { + None = 0, + Point, + Spot, + Distant, + Max, +}; + +const uint32_t kDistantLightAzimuthIndex = 0; +const uint32_t kDistantLightElevationIndex = 1; +const uint32_t kDistantLightNumAttributes = 2; + +const uint32_t kPointLightPositionXIndex = 0; +const uint32_t kPointLightPositionYIndex = 1; +const uint32_t kPointLightPositionZIndex = 2; +const uint32_t kPointLightNumAttributes = 3; + +const uint32_t kSpotLightPositionXIndex = 0; +const uint32_t kSpotLightPositionYIndex = 1; +const uint32_t kSpotLightPositionZIndex = 2; +const uint32_t kSpotLightPointsAtXIndex = 3; +const uint32_t kSpotLightPointsAtYIndex = 4; +const uint32_t kSpotLightPointsAtZIndex = 5; +const uint32_t kSpotLightFocusIndex = 6; +const uint32_t kSpotLightLimitingConeAngleIndex = 7; +const uint32_t kSpotLightNumAttributes = 8; + +struct DiffuseLightingAttributes { + LightType mLightType; + ImplicitlyCopyableFloatArray mLightValues; + float mSurfaceScale; + Size mKernelUnitLength; + sRGBColor mColor; + float mLightingConstant; + float mSpecularExponent; + + bool operator==(const DiffuseLightingAttributes& aOther) const { + return mLightType == aOther.mLightType && + mLightValues == aOther.mLightValues && + mSurfaceScale == aOther.mSurfaceScale && + mKernelUnitLength == aOther.mKernelUnitLength && + mColor == aOther.mColor; + } +}; + +struct SpecularLightingAttributes : public DiffuseLightingAttributes {}; + +enum class ColorSpace { SRGB, LinearRGB, Max }; + +enum class AlphaModel { Unpremultiplied, Premultiplied }; + +class ColorModel { + public: + static ColorModel PremulSRGB() { + return ColorModel(ColorSpace::SRGB, AlphaModel::Premultiplied); + } + + ColorModel(ColorSpace aColorSpace, AlphaModel aAlphaModel) + : mColorSpace(aColorSpace), mAlphaModel(aAlphaModel) {} + ColorModel() + : mColorSpace(ColorSpace::SRGB), mAlphaModel(AlphaModel::Premultiplied) {} + bool operator==(const ColorModel& aOther) const { + return mColorSpace == aOther.mColorSpace && + mAlphaModel == aOther.mAlphaModel; + } + + // Used to index FilterCachedColorModels::mFilterForColorModel. + uint8_t ToIndex() const { + return static_cast<uint8_t>(static_cast<uint8_t>(mColorSpace) << 1) | + static_cast<uint8_t>(mAlphaModel); + } + + ColorSpace mColorSpace; + AlphaModel mAlphaModel; +}; + +already_AddRefed<FilterNode> FilterNodeGraphFromDescription( + DrawTarget* aDT, const FilterDescription& aFilter, + const Rect& aResultNeededRect, FilterNode* aSourceGraphic, + const IntRect& aSourceGraphicRect, FilterNode* aFillPaint, + FilterNode* aStrokePaint, + nsTArray<RefPtr<SourceSurface>>& aAdditionalImages); + +/** + * The methods of this class are not on FilterDescription because + * FilterDescription is designed as a simple value holder that can be used + * on any thread. + */ +class FilterSupport { + public: + /** + * Draw the filter described by aFilter. All rect parameters are in filter + * space coordinates. aRenderRect specifies the part of the filter output + * that will be drawn at (0, 0) into the draw target aDT, subject to the + * current transform on aDT but with no additional scaling. + * The source surfaces must match their corresponding rect in size. + * aAdditionalImages carries the images that are referenced by the + * eImageInputIndex attribute on any image primitives in the filter. + */ + static void RenderFilterDescription( + DrawTarget* aDT, const FilterDescription& aFilter, + const Rect& aRenderRect, SourceSurface* aSourceGraphic, + const IntRect& aSourceGraphicRect, SourceSurface* aFillPaint, + const IntRect& aFillPaintRect, SourceSurface* aStrokePaint, + const IntRect& aStrokePaintRect, + nsTArray<RefPtr<SourceSurface>>& aAdditionalImages, + const Point& aDestPoint, const DrawOptions& aOptions = DrawOptions()); + + /** + * Computes the region that changes in the filter output due to a change in + * input. This is primarily needed when an individual piece of content inside + * a filtered container element changes. + */ + static nsIntRegion ComputeResultChangeRegion( + const FilterDescription& aFilter, const nsIntRegion& aSourceGraphicChange, + const nsIntRegion& aFillPaintChange, + const nsIntRegion& aStrokePaintChange); + + /** + * Computes the regions that need to be supplied in the filter inputs when + * painting aResultNeededRegion of the filter output. + */ + static void ComputeSourceNeededRegions( + const FilterDescription& aFilter, const nsIntRegion& aResultNeededRegion, + nsIntRegion& aSourceGraphicNeededRegion, + nsIntRegion& aFillPaintNeededRegion, + nsIntRegion& aStrokePaintNeededRegion); + + /** + * Computes the size of the filter output. + */ + static nsIntRegion ComputePostFilterExtents( + const FilterDescription& aFilter, + const nsIntRegion& aSourceGraphicExtents); + + /** + * Computes the size of a single FilterPrimitiveDescription's output given a + * set of input extents. + */ + static nsIntRegion PostFilterExtentsForPrimitive( + const FilterPrimitiveDescription& aDescription, + const nsTArray<nsIntRegion>& aInputExtents); +}; + +/** + * Create a 4x5 color matrix for the different ways to specify color matrices + * in SVG. + * + * Return false if the input is invalid or if the resulting matrix is the + * identity. + */ +bool ComputeColorMatrix(const ColorMatrixAttributes& aMatrixAttributes, + float aOutMatrix[20]); + +} // namespace gfx +} // namespace mozilla + +#endif // __FilterSupport_h |