Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#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