Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

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