ChangeLog

2021-11-10  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Remove the reference to Filter from FilterEffect

        https://bugs.webkit.org/show_bug.cgi?id=232551

        rdar://85136447

        Reviewed by NOBODY (OOPS!).

        Instead of having a reference to the Filter in the FilterEffect, we are

        going to pass a reference to the Filter to the FilterEffect functions

        only when needed. FilterEffect may need access to the Filter only in two

        methods: determineAbsolutePaintRect() and platformApplySoftware().

        We need to change all the FilterEffect create methods to not take a Filter

        as input. This requires the SVG filter effect elements to change their

        build() method. And it requires also CSSFilter to not pass itself to the

        FilterEffects its create.

        * platform/graphics/coreimage/FilterEffectRendererCoreImage.h:

        * platform/graphics/coreimage/FilterEffectRendererCoreImage.mm:

        (WebCore::FilterEffectRendererCoreImage::applyEffects):

        (WebCore::FilterEffectRendererCoreImage::connectCIFilters):

        (WebCore::FilterEffectRendererCoreImage::imageForSourceGraphic):

        * platform/graphics/cpu/arm/filters/FEBlendNEON.h:

        (WebCore::FEBlend::platformApplySoftware):

        * platform/graphics/filters/FEBlend.cpp:

        (WebCore::FEBlend::create):

        (WebCore::FEBlend::FEBlend):

        (WebCore::FEBlend::platformApplySoftware):

        * platform/graphics/filters/FEBlend.h:

        * platform/graphics/filters/FEColorMatrix.cpp:

        (WebCore::FEColorMatrix::create):

        (WebCore::FEColorMatrix::FEColorMatrix):

        (WebCore::FEColorMatrix::platformApplySoftware):

        * platform/graphics/filters/FEColorMatrix.h:

        * platform/graphics/filters/FEComponentTransfer.cpp:

        (WebCore::FEComponentTransfer::create):

        (WebCore::FEComponentTransfer::FEComponentTransfer):

        (WebCore::FEComponentTransfer::platformApplySoftware):

        * platform/graphics/filters/FEComponentTransfer.h:

        * platform/graphics/filters/FEComposite.cpp:

        (WebCore::FEComposite::create):

        (WebCore::FEComposite::FEComposite):

        (WebCore::FEComposite::determineAbsolutePaintRect):

        (WebCore::FEComposite::platformApplySoftware):

        * platform/graphics/filters/FEComposite.h:

        * platform/graphics/filters/FEConvolveMatrix.cpp:

        (WebCore::FEConvolveMatrix::create):

        (WebCore::FEConvolveMatrix::FEConvolveMatrix):

        (WebCore::FEConvolveMatrix::platformApplySoftware):

        * platform/graphics/filters/FEConvolveMatrix.h:

        * platform/graphics/filters/FEDiffuseLighting.cpp:

        (WebCore::FEDiffuseLighting::create):

        (WebCore::FEDiffuseLighting::FEDiffuseLighting):

        * platform/graphics/filters/FEDiffuseLighting.h:

        * platform/graphics/filters/FEDisplacementMap.cpp:

        (WebCore::FEDisplacementMap::create):

        (WebCore::FEDisplacementMap::FEDisplacementMap):

        (WebCore::FEDisplacementMap::platformApplySoftware):

        * platform/graphics/filters/FEDisplacementMap.h:

        * platform/graphics/filters/FEDropShadow.cpp:

        (WebCore::FEDropShadow::create):

        (WebCore::FEDropShadow::FEDropShadow):

        (WebCore::FEDropShadow::determineAbsolutePaintRect):

        (WebCore::FEDropShadow::platformApplySoftware):

        * platform/graphics/filters/FEDropShadow.h:

        * platform/graphics/filters/FEFlood.cpp:

        (WebCore::FEFlood::create):

        (WebCore::FEFlood::FEFlood):

        (WebCore::FEFlood::platformApplySoftware):

        * platform/graphics/filters/FEFlood.h:

        * platform/graphics/filters/FEGaussianBlur.cpp:

        (WebCore::FEGaussianBlur::create):

        (WebCore::FEGaussianBlur::FEGaussianBlur):

        (WebCore::FEGaussianBlur::determineAbsolutePaintRect):

        (WebCore::FEGaussianBlur::platformApplySoftware):

        * platform/graphics/filters/FEGaussianBlur.h:

        * platform/graphics/filters/FELighting.cpp:

        (WebCore::FELighting::FELighting):

        (WebCore::FELighting::platformApplySoftware):

        * platform/graphics/filters/FELighting.h:

        * platform/graphics/filters/FEMerge.cpp:

        (WebCore::FEMerge::create):

        (WebCore::FEMerge::FEMerge):

        (WebCore::FEMerge::platformApplySoftware):

        * platform/graphics/filters/FEMerge.h:

        * platform/graphics/filters/FEMorphology.cpp:

        (WebCore::FEMorphology::create):

        (WebCore::FEMorphology::FEMorphology):

        (WebCore::FEMorphology::determineAbsolutePaintRect):

        (WebCore::FEMorphology::platformApplySoftware):

        * platform/graphics/filters/FEMorphology.h:

        * platform/graphics/filters/FEOffset.cpp:

        (WebCore::FEOffset::create):

        (WebCore::FEOffset::FEOffset):

        (WebCore::FEOffset::determineAbsolutePaintRect):

        (WebCore::FEOffset::platformApplySoftware):

        * platform/graphics/filters/FEOffset.h:

        * platform/graphics/filters/FESpecularLighting.cpp:

        (WebCore::FESpecularLighting::create):

        (WebCore::FESpecularLighting::FESpecularLighting):

        * platform/graphics/filters/FESpecularLighting.h:

        * platform/graphics/filters/FETile.cpp:

        (WebCore::FETile::create):

        (WebCore::FETile::FETile):

        (WebCore::FETile::platformApplySoftware):

        * platform/graphics/filters/FETile.h:

        * platform/graphics/filters/FETurbulence.cpp:

        (WebCore::FETurbulence::create):

        (WebCore::FETurbulence::FETurbulence):

        (WebCore::FETurbulence::fillRegion const):

        (WebCore::FETurbulence::fillRegionWorker):

        (WebCore::FETurbulence::platformApplySoftware):

        * platform/graphics/filters/FETurbulence.h:

        * platform/graphics/filters/Filter.h:

        (WebCore::Filter::sourceImage const):

        (WebCore::Filter::sourceImage): Deleted.

        * platform/graphics/filters/FilterEffect.cpp:

        (WebCore::FilterEffect::FilterEffect):

        (WebCore::FilterEffect::determineAbsolutePaintRect):

        (WebCore::FilterEffect::determineFilterPrimitiveSubregion):

        (WebCore::FilterEffect::apply):

        (WebCore::FilterEffect::imageBufferResult):

        (WebCore::FilterEffect::convertPixelBufferToColorSpace):

        (WebCore::FilterEffect::convertImageBufferToColorSpace):

        (WebCore::FilterEffect::createImageBufferResult):

        * platform/graphics/filters/FilterEffect.h:

        (WebCore::FilterEffect::filter): Deleted.

        (WebCore::FilterEffect::filter const): Deleted.

        Create a unaccelerated filter image result for now. This will be fixed 

        in the following patch. Anyway currently we never create accelerated

        intermediate ImageBuffers for filters.

        * platform/graphics/filters/FilterEffectRenderer.h:

        * platform/graphics/filters/SourceAlpha.cpp:

        (WebCore::SourceAlpha::SourceAlpha):

        (WebCore::SourceAlpha::determineAbsolutePaintRect):

        (WebCore::SourceAlpha::platformApplySoftware):

        * platform/graphics/filters/SourceAlpha.h:

        * platform/graphics/filters/SourceGraphic.cpp:

        (WebCore::SourceGraphic::create):

        (WebCore::SourceGraphic::SourceGraphic):

        (WebCore::SourceGraphic::determineAbsolutePaintRect):

        (WebCore::SourceGraphic::platformApplySoftware):

        * platform/graphics/filters/SourceGraphic.h:

        (WebCore::SourceGraphic::SourceGraphic): Deleted.

        * rendering/CSSFilter.cpp:

        (WebCore::createBlurEffect):

        (WebCore::createBrightnessEffect):

        (WebCore::createContrastEffect):

        (WebCore::createDropShadowEffect):

        (WebCore::createGrayScaleEffect):

        (WebCore::createHueRotateEffect):

        (WebCore::createInvertEffect):

        (WebCore::createOpacityEffect):

        (WebCore::createSaturateEffect):

        (WebCore::createSepiaEffect):

        (WebCore::CSSFilter::buildFilterFunctions):

        (WebCore::CSSFilter::determineFilterPrimitiveSubregion):

        (WebCore::CSSFilter::apply):

        * rendering/CSSFilter.h:

        Apply the FilterFunctions of the CSSFilter in the forward direction.

        * rendering/svg/RenderSVGResourceFilter.cpp:

        (WebCore::RenderSVGResourceFilter::applyResource):

        (WebCore::RenderSVGResourceFilter::postApplyResource):

        * svg/SVGFEBlendElement.cpp:

        (WebCore::SVGFEBlendElement::build const):

        * svg/SVGFEBlendElement.h:

        * svg/SVGFEColorMatrixElement.cpp:

        (WebCore::SVGFEColorMatrixElement::build const):

        * svg/SVGFEColorMatrixElement.h:

        * svg/SVGFEComponentTransferElement.cpp:

        (WebCore::SVGFEComponentTransferElement::build const):

        * svg/SVGFEComponentTransferElement.h:

        * svg/SVGFECompositeElement.cpp:

        (WebCore::SVGFECompositeElement::build const):

        * svg/SVGFECompositeElement.h:

        * svg/SVGFEConvolveMatrixElement.cpp:

        (WebCore::SVGFEConvolveMatrixElement::build const):

        * svg/SVGFEConvolveMatrixElement.h:

        * svg/SVGFEDiffuseLightingElement.cpp:

        (WebCore::SVGFEDiffuseLightingElement::build const):

        * svg/SVGFEDiffuseLightingElement.h:

        * svg/SVGFEDisplacementMapElement.cpp:

        (WebCore::SVGFEDisplacementMapElement::build const):

        * svg/SVGFEDisplacementMapElement.h:

        * svg/SVGFEDropShadowElement.cpp:

        (WebCore::SVGFEDropShadowElement::build const):

        * svg/SVGFEDropShadowElement.h:

        * svg/SVGFEFloodElement.cpp:

        (WebCore::SVGFEFloodElement::build const):

        * svg/SVGFEFloodElement.h:

        * svg/SVGFEGaussianBlurElement.cpp:

        (WebCore::SVGFEGaussianBlurElement::build const):

        * svg/SVGFEGaussianBlurElement.h:

        * svg/SVGFEImageElement.cpp:

        (WebCore::SVGFEImageElement::build const):

        * svg/SVGFEImageElement.h:

        * svg/SVGFEMergeElement.cpp:

        (WebCore::SVGFEMergeElement::build const):

        * svg/SVGFEMergeElement.h:

        * svg/SVGFEMorphologyElement.cpp:

        (WebCore::SVGFEMorphologyElement::build const):

        * svg/SVGFEMorphologyElement.h:

        * svg/SVGFEOffsetElement.cpp:

        (WebCore::SVGFEOffsetElement::build const):

        * svg/SVGFEOffsetElement.h:

        * svg/SVGFESpecularLightingElement.cpp:

        (WebCore::SVGFESpecularLightingElement::build const):

        * svg/SVGFESpecularLightingElement.h:

        * svg/SVGFETileElement.cpp:

        (WebCore::SVGFETileElement::build const):

        * svg/SVGFETileElement.h:

        * svg/SVGFETurbulenceElement.cpp:

        (WebCore::SVGFETurbulenceElement::build const):

        * svg/SVGFETurbulenceElement.h:

        * svg/SVGFilterPrimitiveStandardAttributes.h:

        Remove the Filter as an input to the build() method and pass a reference

        to SVGFilterBuilder instead of passing a pointer.

        * svg/graphics/filters/SVGFEImage.cpp:

        (WebCore::FEImage::create):

        (WebCore::FEImage::FEImage):

        (WebCore::FEImage::determineAbsolutePaintRect):

        (WebCore::FEImage::platformApplySoftware):

        * svg/graphics/filters/SVGFEImage.h:

        * svg/graphics/filters/SVGFilter.cpp:

        (WebCore::SVGFilter::create):

        (WebCore::SVGFilter::apply):

        * svg/graphics/filters/SVGFilter.h:

        * svg/graphics/filters/SVGFilterBuilder.cpp:

        (WebCore::SVGFilterBuilder::buildFilterEffects):

        * svg/graphics/filters/SVGFilterBuilder.h:

2021-11-10  Said Abou-Hallawa  <said@apple.com>

        [GPU Process] Make CSSFilter be a composite of FilterFunctions

Source/WebCore/platform/graphics/coreimage/FilterEffectRendererCoreImage.h

@@class FilterEffectRendererCoreImage : public FilterEffectRenderer {

public:

    static std::unique_ptr<FilterEffectRendererCoreImage> tryCreate(FilterEffect&);

    RetainPtr<CIContext> sharedCIContext();

50 void applyEffects(FilterEffect&) final;

50 void applyEffects(const Filter&, FilterEffect&) final;

    bool hasResult() const final { return m_outputImage; }

    ImageBuffer* output() const final;

    FloatRect destRect(const FilterEffect&) const final;

@@public:

    FilterEffectRendererCoreImage();

private:

58 RetainPtr<CIImage> connectCIFilters(FilterEffect&);

58 RetainPtr<CIImage> connectCIFilters(const Filter&, FilterEffect&);

    void renderToImageBuffer(FilterEffect&) final;

    static bool supportsCoreImageRendering(FilterEffect&);

    static bool canRenderUsingCIFilters(FilterEffect&);

63 RetainPtr<CIImage> imageForSourceGraphic(Sou~~rceGraphic~~&);

63 RetainPtr<CIImage> imageForSourceGraphic(const Filter&);

    RetainPtr<CIImage> imageForFEColorMatrix(const FEColorMatrix&, const Vector<RetainPtr<CIImage>>&);

    RetainPtr<CIImage> imageForFEComponentTransfer(const FEComponentTransfer&, Vector<RetainPtr<CIImage>>&);

Source/WebCore/platform/graphics/coreimage/FilterEffectRendererCoreImage.mm

@@bool FilterEffectRendererCoreImage::supportsCoreImageRendering(FilterEffect& eff

    return false;

}

100 void FilterEffectRendererCoreImage::applyEffects(FilterEffect& lastEffect)

100void FilterEffectRendererCoreImage::applyEffects(const Filter& filter, FilterEffect& lastEffect)

101101{

102 m_outputImage = connectCIFilters(lastEffect);

102 m_outputImage = connectCIFilters(filter, lastEffect);

    if (!m_outputImage)

        return;

    renderToImageBuffer(lastEffect);

}

108 RetainPtr<CIImage> FilterEffectRendererCoreImage::connectCIFilters(FilterEffect& effect)

108RetainPtr<CIImage> FilterEffectRendererCoreImage::connectCIFilters(const Filter& filter, FilterEffect& effect)

{

    Vector<RetainPtr<CIImage>> inputImages;

    for (auto in : effect.inputEffects()) {

113 auto inputImage = connectCIFilters(*in);

113 auto inputImage = connectCIFilters(filter, *in);

        if (!inputImage)

            return nullptr;

        inputImages.append(inputImage);

    }

118 effect.determineAbsolutePaintRect();

118 effect.determineAbsolutePaintRect(filter);

    effect.setResultColorSpace(effect.operatingColorSpace());

    if (effect.absolutePaintRect().isEmpty() || ImageBuffer::sizeNeedsClamping(effect.absolutePaintRect().size()))

@@RetainPtr<CIImage> FilterEffectRendererCoreImage::connectCIFilters(FilterEffect&

    
    switch (effect.filterType()) {

    case FilterEffect::Type::SourceGraphic:

126 return imageForSourceGraphic(~~downcast<SourceGraphic>(effect)~~);

126 return imageForSourceGraphic(filter);

    case FilterEffect::Type::FEColorMatrix:

        return imageForFEColorMatrix(downcast<FEColorMatrix>(effect), inputImages);

    case FilterEffect::Type::FEComponentTransfer:

@@RetainPtr<CIImage> FilterEffectRendererCoreImage::connectCIFilters(FilterEffect&

    return nullptr;

}

138 RetainPtr<CIImage> FilterEffectRendererCoreImage::imageForSourceGraphic(Sou~~rceGraphic~~& ~~effect~~)

138RetainPtr<CIImage> FilterEffectRendererCoreImage::imageForSourceGraphic(const Filter& filter)

139139{

140 ImageBuffer* sourceImage = ~~effect.~~filter().sourceImage();

140 ImageBuffer* sourceImage = filter.sourceImage();

    if (!sourceImage)

        return nullptr;

Source/WebCore/platform/graphics/cpu/arm/filters/FEBlendNEON.h

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

28 #ifndef FEBlendNEON_h

29 #define FEBlendNEON_h

28#pragma once

#if HAVE(ARM_NEON_INTRINSICS)

@@public:

    }

};

110 void FEBlend::platformApplySoftware()

109void FEBlend::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

    FilterEffect* in2 = inputEffect(1);

@@void FEBlend::platformApplyNEON(unsigned char* srcPixelArrayA, unsigned char* sr

} // namespace WebCore

#endif // HAVE(ARM_NEON_INTRINSICS)

208

209 #endif // FEBlendNEON_h

Source/WebCore/platform/graphics/filters/FEBlend.cpp

#include "FEBlend.h"

#include "FEBlendNEON.h"

29 #include "Filter.h"

3029#include "FloatPoint.h"

3130#include "GraphicsContext.h"

31#include "ImageBuffer.h"

#include <JavaScriptCore/Uint8ClampedArray.h>

#include <wtf/text/TextStream.h>

namespace WebCore {

FEBlend::FEBlend(Filter& filter, BlendMode mode)

    : FilterEffect(filter, FilterEffect::Type::FEBlend)

    , m_mode(mode)

37Ref<FEBlend> FEBlend::create(BlendMode mode)

4038{

39 return adoptRef(*new FEBlend(mode));

4140}

4241

43 Ref<FEBlend> FEBlend::create(Filter& filter, BlendMode mode)

FEBlend::FEBlend(BlendMode mode)

    : FilterEffect(FilterEffect::Type::FEBlend)

    , m_mode(mode)

4445{

45 return adoptRef(*new FEBlend(filter, mode));

}

bool FEBlend::setBlendMode(BlendMode mode)

@@bool FEBlend::setBlendMode(BlendMode mode)

}

#if !HAVE(ARM_NEON_INTRINSICS)

57 void FEBlend::platformApplySoftware()

57void FEBlend::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

    FilterEffect* in2 = inputEffect(1);

Source/WebCore/platform/graphics/filters/FEBlend.h

#pragma once

#include "FilterEffect.h"

26

27 #include "Filter.h"

26#include "GraphicsTypes.h"

namespace WebCore {

class FEBlend : public FilterEffect {

public:

33 static Ref<FEBlend> create(~~Filter&,~~ BlendMode);

32 static Ref<FEBlend> create(BlendMode);

    BlendMode blendMode() const { return m_mode; }

    bool setBlendMode(BlendMode);

private:

39 void platformApplySoftware() override;

    FEBlend(BlendMode);

    void platformApplySoftware(const Filter&) override;

    void platformApplyGeneric(unsigned char* srcPixelArrayA, unsigned char* srcPixelArrayB, unsigned char* dstPixelArray,

                           unsigned colorArrayLength);

    void platformApplyNEON(unsigned char* srcPixelArrayA, unsigned char* srcPixelArrayB, unsigned char* dstPixelArray,

@@private:

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

47 FEBlend(Filter&, BlendMode);

48

    BlendMode m_mode;

};

Source/WebCore/platform/graphics/filters/FEColorMatrix.cpp

#include "config.h"

#include "FEColorMatrix.h"

26 #include "Filter.h"

2726#include "GraphicsContext.h"

27#include "ImageBuffer.h"

#include "PixelBuffer.h"

#include <wtf/MathExtras.h>

#include <wtf/text/TextStream.h>

namespace WebCore {

FEColorMatrix::FEColorMatrix(Filter& filter, ColorMatrixType type, Vector<float>&& values)

    : FilterEffect(filter, FilterEffect::Type::FEColorMatrix)

    , m_type(type)

    , m_values(WTFMove(values))

38Ref<FEColorMatrix> FEColorMatrix::create(ColorMatrixType type, Vector<float>&& values)

4239{

40 return adoptRef(*new FEColorMatrix(type, WTFMove(values)));

4341}

4442

45 Ref<FEColorMatrix> FEColorMatrix::create(Filter& filter, ColorMatrixType type, Vector<float>&& values)

FEColorMatrix::FEColorMatrix(ColorMatrixType type, Vector<float>&& values)

    : FilterEffect(FilterEffect::Type::FEColorMatrix)

    , m_type(type)

    , m_values(WTFMove(values))

4647{

47 return adoptRef(*new FEColorMatrix(filter, type, WTFMove(values)));

}

bool FEColorMatrix::setType(ColorMatrixType type)

@@void effectType(Uint8ClampedArray& pixelArray, const Vector<float>& values, IntS

    }

}

276 void FEColorMatrix::platformApplySoftware()

276void FEColorMatrix::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

Source/WebCore/platform/graphics/filters/FEColorMatrix.h

#pragma once

#include "FilterEffect.h"

25

26 #include "Filter.h"

#include <wtf/Vector.h>

namespace WebCore {

@@enum ColorMatrixType {

class FEColorMatrix : public FilterEffect {

public:

41 static Ref<FEColorMatrix> create(~~Filter&,~~ ColorMatrixType, Vector<float>&&);

39 static Ref<FEColorMatrix> create(ColorMatrixType, Vector<float>&&);

    ColorMatrixType type() const { return m_type; }

    bool setType(ColorMatrixType);

@@public:

    static inline void calculateHueRotateComponents(float* components, float value);

private:

53 FEColorMatrix(~~Filter&,~~ ColorMatrixType, Vector<float>&&);

51 FEColorMatrix(ColorMatrixType, Vector<float>&&);

5452

55 void platformApplySoftware() override;

53 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FEComponentTransfer.cpp

#include "config.h"

#include "FEComponentTransfer.h"

27 #include "Filter.h"

#include "GraphicsContext.h"

#include "PixelBuffer.h"

#include <wtf/MathExtras.h>

namespace WebCore {

36 FEComponentTransfer::FEComponentTransfer(Filter& filter, const ComponentTransferFunction& redFunction, const ComponentTransferFunction& greenFunction, const ComponentTransferFunction& blueFunction, const ComponentTransferFunction& alphaFunction)

37 : FilterEffect(filter, FilterEffect::Type::FEComponentTransfer)

Ref<FEComponentTransfer> FEComponentTransfer::create(const ComponentTransferFunction& redFunction, const ComponentTransferFunction& greenFunction, const ComponentTransferFunction& blueFunction, const ComponentTransferFunction& alphaFunction)

{

    return adoptRef(*new FEComponentTransfer(redFunction, greenFunction, blueFunction, alphaFunction));

}

FEComponentTransfer::FEComponentTransfer(const ComponentTransferFunction& redFunction, const ComponentTransferFunction& greenFunction, const ComponentTransferFunction& blueFunction, const ComponentTransferFunction& alphaFunction)

    : FilterEffect(FilterEffect::Type::FEComponentTransfer)

    , m_redFunction(redFunction)

    , m_greenFunction(greenFunction)

    , m_blueFunction(blueFunction)

@@FEComponentTransfer::FEComponentTransfer(Filter& filter, const ComponentTransfer

{

}

Ref<FEComponentTransfer> FEComponentTransfer::create(Filter& filter, const ComponentTransferFunction& redFunction,

    const ComponentTransferFunction& greenFunction, const ComponentTransferFunction& blueFunction, const ComponentTransferFunction& alphaFunction)

{

    return adoptRef(*new FEComponentTransfer(filter, redFunction, greenFunction, blueFunction, alphaFunction));

}

void FEComponentTransfer::computeIdentityTable(LookupTable&, const ComponentTransferFunction&)

{

}

@@void FEComponentTransfer::computeGammaTable(LookupTable& values, const Component

    }

}

106 void FEComponentTransfer::platformApplySoftware()

104void FEComponentTransfer::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

Source/WebCore/platform/graphics/filters/FEComponentTransfer.h

#pragma once

#include "FilterEffect.h"

25

26 #include "Filter.h"

#include <wtf/Vector.h>

namespace WebCore {

@@struct ComponentTransferFunction {

class FEComponentTransfer : public FilterEffect {

public:

56 static Ref<FEComponentTransfer> create(Filter&, const ComponentTransferFunction& redFunc, const ComponentTransferFunction& greenFunc,

57 const ComponentTransferFunction& blueFunc, const ComponentTransferFunction& alphaFunc);

54 static Ref<FEComponentTransfer> create(const ComponentTransferFunction& redFunc, const ComponentTransferFunction& greenFunc, const ComponentTransferFunction& blueFunc, const ComponentTransferFunction& alphaFunc);

    ComponentTransferFunction redFunction() const { return m_redFunction; }

    ComponentTransferFunction greenFunction() const { return m_greenFunction; }

@@public:

    ComponentTransferFunction alphaFunction() const { return m_alphaFunction; }

private:

65 FEComponentTransfer(Filter&, const ComponentTransferFunction& redFunc, const ComponentTransferFunction& greenFunc,

66 const ComponentTransferFunction& blueFunc, const ComponentTransferFunction& alphaFunc);

62 FEComponentTransfer(const ComponentTransferFunction& redFunc, const ComponentTransferFunction& greenFunc, const ComponentTransferFunction& blueFunc, const ComponentTransferFunction& alphaFunc);

    using LookupTable = std::array<uint8_t, 256>;

@@private:

    void computeLookupTables(LookupTable& redTable, LookupTable& greenTable, LookupTable& blueTable, LookupTable& alphaTable);

78 void platformApplySoftware() override;

74 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FEComposite.cpp

#include "FEComposite.h"

#include "FECompositeArithmeticNEON.h"

28 #include "Filter.h"

2928#include "GraphicsContext.h"

29#include "ImageBuffer.h"

#include "PixelBuffer.h"

#include <wtf/text/TextStream.h>

namespace WebCore {

35 FEComposite::FEComposite(Filter& filter, const CompositeOperationType& type, float k1, float k2, float k3, float k4)

36 : FilterEffect(filter, FilterEffect::Type::FEComposite)

Ref<FEComposite> FEComposite::create(const CompositeOperationType& type, float k1, float k2, float k3, float k4)

{

    return adoptRef(*new FEComposite(type, k1, k2, k3, k4));

}

FEComposite::FEComposite(const CompositeOperationType& type, float k1, float k2, float k3, float k4)

    : FilterEffect(FilterEffect::Type::FEComposite)

    , m_type(type)

    , m_k1(k1)

    , m_k2(k2)

@@FEComposite::FEComposite(Filter& filter, const CompositeOperationType& type, flo

{

}

Ref<FEComposite> FEComposite::create(Filter& filter, const CompositeOperationType& type, float k1, float k2, float k3, float k4)

{

    return adoptRef(*new FEComposite(filter, type, k1, k2, k3, k4));

}

bool FEComposite::setOperation(CompositeOperationType type)

{

    if (m_type == type)

@@inline void FEComposite::platformArithmeticSoftware(const Uint8ClampedArray& sou

#endif

}

204 void FEComposite::determineAbsolutePaintRect()

204void FEComposite::determineAbsolutePaintRect(const Filter& filter)

{

    switch (m_type) {

    case FECOMPOSITE_OPERATOR_IN:

@@void FEComposite::determineAbsolutePaintRect()

        return;

    default:

        // Take the union of both input effects.

221 FilterEffect::determineAbsolutePaintRect();

221 FilterEffect::determineAbsolutePaintRect(filter);

        return;

    }

}

226 void FEComposite::platformApplySoftware()

226void FEComposite::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

    FilterEffect* in2 = inputEffect(1);

Source/WebCore/platform/graphics/filters/FEComposite.h

#pragma once

#include "FilterEffect.h"

25

26 #include "Filter.h"

#include <wtf/text/WTFString.h>

namespace WebCore {

@@enum CompositeOperationType {

class FEComposite : public FilterEffect {

public:

44 static Ref<FEComposite> create(~~Filter&,~~ const CompositeOperationType&, float, float, float, float);

42 static Ref<FEComposite> create(const CompositeOperationType&, float k1, float k2, float k3, float k4);

    CompositeOperationType operation() const { return m_type; }

    bool setOperation(CompositeOperationType);

@@public:

    float k4() const { return m_k4; }

    bool setK4(float);

protected:

    bool requiresValidPreMultipliedPixels() override { return m_type != FECOMPOSITE_OPERATOR_ARITHMETIC; }

6459private:

65 FEComposite(~~Filter&,~~ const CompositeOperationType&, float, float, float, float);

60 FEComposite(const CompositeOperationType&, float k1, float k2, float k3, float k4);

6661

6762 void correctFilterResultIfNeeded() override;

68 void determineAbsolutePaintRect() override;

6963

70 void platformApplySoftware() override;

    bool requiresValidPreMultipliedPixels() override { return m_type != FECOMPOSITE_OPERATOR_ARITHMETIC; }

    void determineAbsolutePaintRect(const Filter&) override;

    void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

    inline void platformArithmeticSoftware(const Uint8ClampedArray& source, Uint8ClampedArray& destination, float k1, float k2, float k3, float k4);

Source/WebCore/platform/graphics/filters/FEConvolveMatrix.cpp

#include "config.h"

#include "FEConvolveMatrix.h"

27 #include "Filter.h"

#include "PixelBuffer.h"

#include <wtf/ParallelJobs.h>

#include <wtf/WorkQueue.h>

namespace WebCore {

35 FEConvolveMatrix::FEConvolveMatrix(Filter& filter, const IntSize& kernelSize, float divisor, float bias, const IntPoint& targetOffset, EdgeModeType edgeMode, const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)

36 : FilterEffect(filter, FilterEffect::Type::FEConvolveMatrix)

Ref<FEConvolveMatrix> FEConvolveMatrix::create(const IntSize& kernelSize, float divisor, float bias, const IntPoint& targetOffset, EdgeModeType edgeMode, const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)

{

    return adoptRef(*new FEConvolveMatrix(kernelSize, divisor, bias, targetOffset, edgeMode, kernelUnitLength, preserveAlpha, kernelMatrix));

}

FEConvolveMatrix::FEConvolveMatrix(const IntSize& kernelSize, float divisor, float bias, const IntPoint& targetOffset, EdgeModeType edgeMode, const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)

    : FilterEffect(FilterEffect::Type::FEConvolveMatrix)

    , m_kernelSize(kernelSize)

    , m_divisor(divisor)

    , m_bias(bias)

@@FEConvolveMatrix::FEConvolveMatrix(Filter& filter, const IntSize& kernelSize, fl

    ASSERT(m_kernelSize.height() > 0);

}

Ref<FEConvolveMatrix> FEConvolveMatrix::create(Filter& filter, const IntSize& kernelSize,

    float divisor, float bias, const IntPoint& targetOffset, EdgeModeType edgeMode,

    const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix)

{

    return adoptRef(*new FEConvolveMatrix(filter, kernelSize, divisor, bias, targetOffset, edgeMode, kernelUnitLength,

        preserveAlpha, kernelMatrix));

}

void FEConvolveMatrix::setKernelSize(const IntSize& kernelSize)

{

    ASSERT(kernelSize.width() > 0);

@@ALWAYS_INLINE void FEConvolveMatrix::setOuterPixels(PaintingData& paintingData,

        fastSetOuterPixels<false>(paintingData, x1, y1, x2, y2);

}

368 void FEConvolveMatrix::platformApplySoftware()

364void FEConvolveMatrix::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

Source/WebCore/platform/graphics/filters/FEConvolveMatrix.h

#include "FilterEffect.h"

#include "FloatPoint.h"

27 #include "Filter.h"

#include <wtf/Vector.h>

namespace WebCore {

@@enum EdgeModeType {

class FEConvolveMatrix : public FilterEffect {

public:

    static Ref<FEConvolveMatrix> create(Filter&, const IntSize&,

            float, float, const IntPoint&, EdgeModeType, const FloatPoint&,

            bool, const Vector<float>&);

40 static Ref<FEConvolveMatrix> create(const IntSize& kernelSize, float divisor, float bias, const IntPoint& targetOffset, EdgeModeType, const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix);

    IntSize kernelSize() const { return m_kernelSize; }

    void setKernelSize(const IntSize&);

@@private:

        Vector<float> kernelMatrix;

    };

80 FEConvolveMatrix(Filter&, const IntSize&, float, float,

81 const IntPoint&, EdgeModeType, const FloatPoint&, bool, const Vector<float>&);

77 FEConvolveMatrix(const IntSize& kernelSize, float divisor, float bias, const IntPoint& targetOffset, EdgeModeType, const FloatPoint& kernelUnitLength, bool preserveAlpha, const Vector<float>& kernelMatrix);

8278

83 void determineAbsolutePaintRect() override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

79 void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

8480

85 void platformApplySoftware() override;

81 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FEDiffuseLighting.cpp

namespace WebCore {

30 FEDiffuseLighting::FEDiffuseLighting(Filter& filter, const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

31 : FELighting(filter, DiffuseLighting, lightingColor, surfaceScale, diffuseConstant, 0, 0, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource), FilterEffect::Type::FEDiffuseLighting)

30Ref<FEDiffuseLighting> FEDiffuseLighting::create(const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

3231{

32 return adoptRef(*new FEDiffuseLighting(lightingColor, surfaceScale, diffuseConstant, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource)));

3333}

3434

35 Ref<FEDiffuseLighting> FEDiffuseLighting::create(Filter& filter, const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

35FEDiffuseLighting::FEDiffuseLighting(const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

36 : FELighting(DiffuseLighting, lightingColor, surfaceScale, diffuseConstant, 0, 0, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource), FilterEffect::Type::FEDiffuseLighting)

3637{

37 return adoptRef(*new FEDiffuseLighting(filter, lightingColor, surfaceScale, diffuseConstant, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource)));

}

bool FEDiffuseLighting::setDiffuseConstant(float diffuseConstant)

Source/WebCore/platform/graphics/filters/FEDiffuseLighting.h

@@class LightSource;

class FEDiffuseLighting : public FELighting {

public:

32 static Ref<FEDiffuseLighting> create(~~Filter&,~~ const Color&, float, float, float, f~~loa~~t, Ref<LightSource>&&);

32 static Ref<FEDiffuseLighting> create(const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&&);

    float diffuseConstant() const { return m_diffuseConstant; }

    bool setDiffuseConstant(float);

@@public:

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

private:

40 FEDiffuseLighting(~~Filter&,~~ const Color&, float, float, float, f~~loa~~t, Ref<LightSource>&&);

40 FEDiffuseLighting(const Color& lightingColor, float surfaceScale, float diffuseConstant, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&&);

};

} // namespace WebCore

Source/WebCore/platform/graphics/filters/FEDisplacementMap.cpp

namespace WebCore {

FEDisplacementMap::FEDisplacementMap(Filter& filter, ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale)

    : FilterEffect(filter, FilterEffect::Type::FEDisplacementMap)

    , m_xChannelSelector(xChannelSelector)

    , m_yChannelSelector(yChannelSelector)

    , m_scale(scale)

34Ref<FEDisplacementMap> FEDisplacementMap::create(ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale)

3935{

36 return adoptRef(*new FEDisplacementMap(xChannelSelector, yChannelSelector, scale));

4037}

4138

42 Ref<FEDisplacementMap> FEDisplacementMap::create(Filter& filter, ChannelSelectorType xChannelSelector,

43 ChannelSelectorType yChannelSelector, float scale)

FEDisplacementMap::FEDisplacementMap(ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale)

    : FilterEffect(FilterEffect::Type::FEDisplacementMap)

    , m_xChannelSelector(xChannelSelector)

    , m_yChannelSelector(yChannelSelector)

    , m_scale(scale)

4444{

45 return adoptRef(*new FEDisplacementMap(filter, xChannelSelector, yChannelSelector, scale));

}

bool FEDisplacementMap::setXChannelSelector(const ChannelSelectorType xChannelSelector)

@@static inline unsigned byteOffsetOfPixel(unsigned x, unsigned y, unsigned rowByt

    return x * bytesPerPixel + y * rowBytes;

}

94 void FEDisplacementMap::platformApplySoftware()

93void FEDisplacementMap::platformApplySoftware(const Filter& filter)

{

    FilterEffect* in = inputEffect(0);

    FilterEffect* in2 = inputEffect(1);

@@void FEDisplacementMap::platformApplySoftware()

    ASSERT(inputImage->length() == displacementImage->length());

120 Filter& filter = this->filter();

    IntSize paintSize = absolutePaintRect().size();

    FloatSize scale = filter.scaledByFilterScale({ m_scale, m_scale });

Source/WebCore/platform/graphics/filters/FEDisplacementMap.h

#pragma once

#include "FilterEffect.h"

25 #include "Filter.h"

#include <wtf/text/WTFString.h>

namespace WebCore {

@@enum ChannelSelectorType {

class FEDisplacementMap : public FilterEffect {

public:

40 static Ref<FEDisplacementMap> create(~~Filter&,~~ ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale);

39 static Ref<FEDisplacementMap> create(ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float scale);

    ChannelSelectorType xChannelSelector() const { return m_xChannelSelector; }

    bool setXChannelSelector(const ChannelSelectorType);

@@public:

    void transformResultColorSpace(FilterEffect*, const int) override;

private:

55 FEDisplacementMap(~~Filter&,~~ ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float);

54 FEDisplacementMap(ChannelSelectorType xChannelSelector, ChannelSelectorType yChannelSelector, float);

5655

57 void platformApplySoftware() override;

56 void platformApplySoftware(const Filter&) override;

5857

59 void determineAbsolutePaintRect() override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

58 void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

    int xChannelIndex() const { return m_xChannelSelector - 1; }

    int yChannelIndex() const { return m_yChannelSelector - 1; }

Source/WebCore/platform/graphics/filters/FEDropShadow.cpp

#include "FEGaussianBlur.h"

#include "Filter.h"

#include "GraphicsContext.h"

27#include "ImageBuffer.h"

#include "PixelBuffer.h"

#include "ShadowBlur.h"

#include <wtf/MathExtras.h>

#include <wtf/text/TextStream.h>

namespace WebCore {

    
FEDropShadow::FEDropShadow(Filter& filter, float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity)

    : FilterEffect(filter, FilterEffect::Type::FEDropShadow)

Ref<FEDropShadow> FEDropShadow::create(float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity)

{

    return adoptRef(*new FEDropShadow(stdX, stdY, dx, dy, shadowColor, shadowOpacity));

}

FEDropShadow::FEDropShadow(float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity)

    : FilterEffect(FilterEffect::Type::FEDropShadow)

    , m_stdX(stdX)

    , m_stdY(stdY)

    , m_dx(dx)

@@FEDropShadow::FEDropShadow(Filter& filter, float stdX, float stdY, float dx, flo

{

}

45 ~~Ref<FEDropShadow>~~ FEDropShadow::create(Filter& filter~~, float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity~~)

51void FEDropShadow::determineAbsolutePaintRect(const Filter& filter)

4652{

    return adoptRef(*new FEDropShadow(filter, stdX, stdY, dx, dy, shadowColor, shadowOpacity));

}

void FEDropShadow::determineAbsolutePaintRect()

{

    Filter& filter = this->filter();

    FloatRect absolutePaintRect = inputEffect(0)->absolutePaintRect();

    FloatRect absoluteOffsetPaintRect(absolutePaintRect);

    absoluteOffsetPaintRect.move(filter.scaledByFilterScale({ m_dx, m_dy }));

@@void FEDropShadow::determineAbsolutePaintRect()

    setAbsolutePaintRect(enclosingIntRect(absolutePaintRect));

}

73 void FEDropShadow::platformApplySoftware()

72void FEDropShadow::platformApplySoftware(const Filter& filter)

{

    FilterEffect* in = inputEffect(0);

@@void FEDropShadow::platformApplySoftware()

    if (!resultImage)

        return;

81 Filter& filter = this->filter();

82

    FloatSize blurRadius = 2 * filter.scaledByFilterScale({ m_stdX, m_stdY });

    FloatSize offset = filter.scaledByFilterScale({ m_dx, m_dy });

Source/WebCore/platform/graphics/filters/FEDropShadow.h

#pragma once

#include "Color.h"

23 #include "Filter.h"

#include "FilterEffect.h"

namespace WebCore {

class FEDropShadow : public FilterEffect {

public:

30 static Ref<FEDropShadow> create(Fil~~ter&~~, float, float, float, ~~float~~, const Color&, float);

29 static Ref<FEDropShadow> create(float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity);

    float stdDeviationX() const { return m_stdX; }

    void setStdDeviationX(float stdX) { m_stdX = stdX; }

@@public:

    void setShadowOpacity(float shadowOpacity) { m_shadowOpacity = shadowOpacity; }

private:

51 FEDropShadow(Fil~~ter&~~, float, float, float, ~~float~~, const Color&, float);

50 FEDropShadow(float stdX, float stdY, float dx, float dy, const Color& shadowColor, float shadowOpacity);

5251

    void platformApplySoftware() override;

    void determineAbsolutePaintRect() override;

52 void determineAbsolutePaintRect(const Filter&) override;

    IntOutsets outsets() const override;

56 void platformApplySoftware(const Filter&) override;

57

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

    float m_stdX;

Source/WebCore/platform/graphics/filters/FEFlood.cpp

#include "FEFlood.h"

#include "ColorSerialization.h"

27 #include "Filter.h"

2827#include "GraphicsContext.h"

28#include "ImageBuffer.h"

#include <wtf/text/TextStream.h>

namespace WebCore {

FEFlood::FEFlood(Filter& filter, const Color& floodColor, float floodOpacity)

    : FilterEffect(filter, FilterEffect::Type::FEFlood)

    , m_floodColor(floodColor)

    , m_floodOpacity(floodOpacity)

33Ref<FEFlood> FEFlood::create(const Color& floodColor, float floodOpacity)

3734{

35 return adoptRef(*new FEFlood(floodColor, floodOpacity));

3836}

3937

40 Ref<FEFlood> FEFlood::create(Filter& filter, const Color& floodColor, float floodOpacity)

FEFlood::FEFlood(const Color& floodColor, float floodOpacity)

    : FilterEffect(FilterEffect::Type::FEFlood)

    , m_floodColor(floodColor)

    , m_floodOpacity(floodOpacity)

4142{

42 return adoptRef(*new FEFlood(filter, floodColor, floodOpacity));

}

bool FEFlood::setFloodColor(const Color& color)

@@bool FEFlood::setFloodOpacity(float floodOpacity)

    return true;

}

61 void FEFlood::platformApplySoftware()

61void FEFlood::platformApplySoftware(const Filter&)

{

    ImageBuffer* resultImage = createImageBufferResult();

    if (!resultImage)

Source/WebCore/platform/graphics/filters/FEFlood.h

#pragma once

#include "Color.h"

25 #include "Filter.h"

#include "FilterEffect.h"

namespace WebCore {

class FEFlood : public FilterEffect {

public:

32 static Ref<FEFlood> create(~~Filter&,~~ const Color&, float);

31 static Ref<FEFlood> create(const Color& floodColor, float floodOpacity);

    const Color& floodColor() const { return m_floodColor; }

    bool setFloodColor(const Color&);

@@public:

#endif

private:

48 FEFlood(~~Filter&,~~ const Color&, float);

47 FEFlood(const Color& floodColor, float floodOpacity);

4948

50 void ~~platfo~~rm~~ApplyS~~of~~tware(~~) override;

49 void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

5150

52 void deter~~mineAbsolutePaintRect(~~) override ~~{ setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }~~

51 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FEGaussianBlur.cpp

@@inline void kernelPosition(int blurIteration, unsigned& radius, int& deltaLeft,

    }

}

FEGaussianBlur::FEGaussianBlur(Filter& filter, float x, float y, EdgeModeType edgeMode)

    : FilterEffect(filter, FilterEffect::Type::FEGaussianBlur)

    , m_stdX(x)

    , m_stdY(y)

    , m_edgeMode(edgeMode)

82Ref<FEGaussianBlur> FEGaussianBlur::create(float x, float y, EdgeModeType edgeMode)

8783{

84 return adoptRef(*new FEGaussianBlur(x, y, edgeMode));

8885}

8986

90 Ref<FEGaussianBlur> FEGaussianBlur::create(Filter& filter, float x, float y, EdgeModeType edgeMode)

FEGaussianBlur::FEGaussianBlur(float x, float y, EdgeModeType edgeMode)

    : FilterEffect(FilterEffect::Type::FEGaussianBlur)

    , m_stdX(x)

    , m_stdY(y)

    , m_edgeMode(edgeMode)

9192{

92 return adoptRef(*new FEGaussianBlur(filter, x, y, edgeMode));

}

void FEGaussianBlur::setStdDeviationX(float x)

@@IntSize FEGaussianBlur::calculateOutsetSize(FloatSize stdDeviation)

    return { 3 * kernelSize.width() / 2, 3 * kernelSize.height() / 2 };

}

499 void FEGaussianBlur::determineAbsolutePaintRect()

499void FEGaussianBlur::determineAbsolutePaintRect(const Filter& filter)

500500{

501 IntSize kernelSize = calculateKernelSize(filter(), { m_stdX, m_stdY });

501 IntSize kernelSize = calculateKernelSize(filter, { m_stdX, m_stdY });

    FloatRect absolutePaintRect = inputEffect(0)->absolutePaintRect();

    // Edge modes other than 'none' do not inflate the affected paint rect.

@@void FEGaussianBlur::determineAbsolutePaintRect()

    setAbsolutePaintRect(enclosingIntRect(absolutePaintRect));

}

522 void FEGaussianBlur::platformApplySoftware()

522void FEGaussianBlur::platformApplySoftware(const Filter& filter)

{

    FilterEffect* in = inputEffect(0);

@@void FEGaussianBlur::platformApplySoftware()

    if (!m_stdX && !m_stdY)

        return;

539 IntSize kernelSize = calculateKernelSize(filter(), { m_stdX, m_stdY });

539 IntSize kernelSize = calculateKernelSize(filter, { m_stdX, m_stdY });

    IntSize paintSize = absolutePaintRect().size();

    auto tmpImageData = Uint8ClampedArray::tryCreateUninitialized(paintSize.area() * 4);

Source/WebCore/platform/graphics/filters/FEGaussianBlur.h

#pragma once

#include "FEConvolveMatrix.h"

25 #include "Filter.h"

#include "FilterEffect.h"

namespace WebCore {

class FEGaussianBlur : public FilterEffect {

public:

32 static Ref<FEGaussianBlur> create(Fil~~ter&~~, float, ~~float~~, EdgeModeType);

31 static Ref<FEGaussianBlur> create(float x, float y, EdgeModeType);

    float stdDeviationX() const { return m_stdX; }

    void setStdDeviationX(float);

@@public:

    static IntSize calculateOutsetSize(FloatSize stdDeviation);

private:

48 FEGaussianBlur(Fil~~ter&~~, float, ~~float~~, EdgeModeType);

47 FEGaussianBlur(float x, float y, EdgeModeType);

    static const int s_minimalRectDimension = 100 * 100; // Empirical data limit for parallel jobs

@@private:

        unsigned kernelSizeY;

    };

62 void ~~platfo~~rm~~ApplyS~~of~~tware(~~) override;

61 void determineAbsolutePaintRect(const Filter&) override;

6362

64 void deter~~mineAbsolutePaintRect(~~) override;

63 void platformApplySoftware(const Filter&) override;

    IntOutsets outsets() const override;

Source/WebCore/platform/graphics/filters/FELighting.cpp

namespace WebCore {

38 FELighting::FELighting(~~Filter& filter,~~ LightingType lightingType, const Color& lightingColor, float surfaceScale, float diffuseConstant, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource, Type type)

39 : FilterEffect(~~filter,~~ type)

38FELighting::FELighting(LightingType lightingType, const Color& lightingColor, float surfaceScale, float diffuseConstant, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource, Type type)

39 : FilterEffect(type)

    , m_lightingType(lightingType)

    , m_lightSource(WTFMove(lightSource))

    , m_lightingColor(lightingColor)

@@bool FELighting::drawLighting(Uint8ClampedArray& pixels, int width, int height)

    return true;

}

474 void FELighting::platformApplySoftware()

474void FELighting::platformApplySoftware(const Filter&)

{

    FilterEffect* in = inputEffect(0);

Source/WebCore/platform/graphics/filters/FELighting.h

#pragma once

#include "Color.h"

30 #include "Filter.h"

#include "FilterEffect.h"

#include "LightSource.h"

#include <JavaScriptCore/Forward.h>

@@struct FELightingPaintingDataForNeon;

class FELighting : public FilterEffect {

public:

43 void determineAbsolutePaintRect() override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

44

    float surfaceScale() const { return m_surfaceScale; }

    bool setSurfaceScale(float);

@@protected:

    static void platformApplyGenericWorker(PlatformApplyGenericParameters*);

    static void platformApplyNeonWorker(FELightingPaintingDataForNeon*);

131 FELighting(~~Filter&,~~ LightingType, const Color&, float, float, float, float, float, float, Ref<LightSource>&&, Type);

128 FELighting(LightingType, const Color& lightingColor, float surfaceScale, float diffuseConstant, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&&, Type);

    bool drawLighting(Uint8ClampedArray&, int, int);

    void setPixel(int offset, const LightingData&, const LightSource::PaintingData&, int x, int y, float factorX, float factorY, IntSize normalVector);

    void setPixelInternal(int offset, const LightingData&, const LightSource::PaintingData&, int x, int y, float factorX, float factorY, IntSize normalVector, float alpha);

138 void platformApplySoftware() override;

    void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

    void platformApplySoftware(const Filter&) override;

    void platformApply(const LightingData&, const LightSource::PaintingData&);

Source/WebCore/platform/graphics/filters/FEMerge.cpp

#include "config.h"

#include "FEMerge.h"

25 #include "Filter.h"

2625#include "GraphicsContext.h"

26#include "ImageBuffer.h"

#include <wtf/text/TextStream.h>

namespace WebCore {

31 FEMerge::FEMerge(Filter& filter)

32 : FilterEffect(filter, FilterEffect::Type::FEMerge)

31Ref<FEMerge> FEMerge::create()

3332{

33 return adoptRef(*new FEMerge());

3434}

3535

36 Ref<FEMerge> FEMerge::create(Filter& filter)

36FEMerge::FEMerge()

37 : FilterEffect(FilterEffect::Type::FEMerge)

3738{

38 return adoptRef(*new FEMerge(filter));

3939}

4040

41 void FEMerge::platformApplySoftware()

41void FEMerge::platformApplySoftware(const Filter&)

{

    unsigned size = numberOfEffectInputs();

    ASSERT(size > 0);

@@void FEMerge::platformApplySoftware()

    if (!resultImage)

        return;

50

    GraphicsContext& filterContext = resultImage->context();

    for (unsigned i = 0; i < size; ++i) {

        FilterEffect* in = inputEffect(i);

Source/WebCore/platform/graphics/filters/FEMerge.h

#pragma once

#include "FilterEffect.h"

25 #include "Filter.h"

namespace WebCore {

class FEMerge : public FilterEffect {

public:

31 static Ref<FEMerge> create(~~Filter&~~);

30 static Ref<FEMerge> create();

3231

3332private:

34 FEMerge(~~Filter&~~);

33 FEMerge();

3534

36 void platformApplySoftware() override;

35 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

};

Source/WebCore/platform/graphics/filters/FEMorphology.cpp

namespace WebCore {

FEMorphology::FEMorphology(Filter& filter, MorphologyOperatorType type, float radiusX, float radiusY)

    : FilterEffect(filter, FilterEffect::Type::FEMorphology)

    , m_type(type)

    , m_radiusX(radiusX)

    , m_radiusY(radiusY)

38Ref<FEMorphology> FEMorphology::create(MorphologyOperatorType type, float radiusX, float radiusY)

4339{

40 return adoptRef(*new FEMorphology(type, radiusX, radiusY));

4441}

4542

46 Ref<FEMorphology> FEMorphology::create(Filter& filter, MorphologyOperatorType type, float radiusX, float radiusY)

FEMorphology::FEMorphology(MorphologyOperatorType type, float radiusX, float radiusY)

    : FilterEffect(FilterEffect::Type::FEMorphology)

    , m_type(type)

    , m_radiusX(radiusX)

    , m_radiusY(radiusY)

4748{

48 return adoptRef(*new FEMorphology(filter, type, radiusX, radiusY));

}

bool FEMorphology::setMorphologyOperator(MorphologyOperatorType type)

@@bool FEMorphology::setRadiusY(float radiusY)

    return true;

}

75 void FEMorphology::determineAbsolutePaintRect()

75void FEMorphology::determineAbsolutePaintRect(const Filter& filter)

7676{

7777 FloatRect paintRect = inputEffect(0)->absolutePaintRect();

78 Filter& filter = this->filter();

    paintRect.inflate(filter.scaledByFilterScale({ m_radiusX, m_radiusY }));

    if (clipsToBounds())

        paintRect.intersect(maxEffectRect());

@@bool FEMorphology::platformApplyDegenerate(Uint8ClampedArray& dstPixelArray, con

    return false;

}

243 void FEMorphology::platformApplySoftware()

242void FEMorphology::platformApplySoftware(const Filter& filter)

{

    FilterEffect* in = inputEffect(0);

@@void FEMorphology::platformApplySoftware()

    if (platformApplyDegenerate(destinationPixelArray, effectDrawingRect, radius.width(), radius.height()))

        return;

261 Filter& filter = this->filter();

    auto sourcePixelArray = in->premultipliedResult(effectDrawingRect, operatingColorSpace());

    if (!sourcePixelArray)

        return;

Source/WebCore/platform/graphics/filters/FEMorphology.h

#pragma once

#include "FilterEffect.h"

25 #include "Filter.h"

namespace WebCore {

@@enum MorphologyOperatorType {

class FEMorphology : public FilterEffect {

public:

37 static Ref<FEMorphology> create(~~Filter&,~~ MorphologyOperatorType, float radiusX, float radiusY);

36 static Ref<FEMorphology> create(MorphologyOperatorType, float radiusX, float radiusY);

    MorphologyOperatorType morphologyOperator() const { return m_type; }

    bool setMorphologyOperator(MorphologyOperatorType);

@@public:

    bool setRadiusY(float);

private:

49 FEMorphology(~~Filter&,~~ MorphologyOperatorType, float radiusX, float radiusY);

48 FEMorphology(MorphologyOperatorType, float radiusX, float radiusY);

5049

51 void ~~platfo~~rm~~ApplyS~~of~~tware(~~) override;

50 void determineAbsolutePaintRect(const Filter&) override;

5251

53 void deter~~mineAbsolutePaintRect(~~) override;

52 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FEOffset.cpp

#include "Filter.h"

#include "GraphicsContext.h"

29#include "ImageBuffer.h"

#include <wtf/text/TextStream.h>

namespace WebCore {

FEOffset::FEOffset(Filter& filter, float dx, float dy)

    : FilterEffect(filter, FilterEffect::Type::FEOffset)

    , m_dx(dx)

    , m_dy(dy)

34Ref<FEOffset> FEOffset::create(float dx, float dy)

3735{

36 return adoptRef(*new FEOffset(dx, dy));

3837}

3938

40 Ref<FEOffset> FEOffset::create(Filter& filter, float dx, float dy)

FEOffset::FEOffset(float dx, float dy)

    : FilterEffect(FilterEffect::Type::FEOffset)

    , m_dx(dx)

    , m_dy(dy)

4143{

42 return adoptRef(*new FEOffset(filter, dx, dy));

}

void FEOffset::setDx(float dx)

@@void FEOffset::setDy(float dy)

    m_dy = dy;

}

55 void FEOffset::determineAbsolutePaintRect()

56void FEOffset::determineAbsolutePaintRect(const Filter& filter)

5657{

5758 FloatRect paintRect = inputEffect(0)->absolutePaintRect();

58 Filter& filter = this->filter();

    paintRect.move(filter.scaledByFilterScale({ m_dx, m_dy }));

    if (clipsToBounds())

        paintRect.intersect(maxEffectRect());

@@void FEOffset::determineAbsolutePaintRect()

    setAbsolutePaintRect(enclosingIntRect(paintRect));

}

67 void FEOffset::platformApplySoftware()

67void FEOffset::platformApplySoftware(const Filter& filter)

{

    FilterEffect* in = inputEffect(0);

@@void FEOffset::platformApplySoftware()

    setIsAlphaImage(in->isAlphaImage());

    FloatRect drawingRegion = drawingRegionOfInputImage(in->absolutePaintRect());

79 Filter& filter = this->filter();

    drawingRegion.move(filter.scaledByFilterScale({ m_dx, m_dy }));

    resultImage->context().drawImageBuffer(*inBuffer, drawingRegion);

}

Source/WebCore/platform/graphics/filters/FEOffset.h

#pragma once

#include "FilterEffect.h"

25 #include "Filter.h"

namespace WebCore {

class FEOffset : public FilterEffect {

public:

31 static Ref<FEOffset> create(~~Filter&,~~ float dx, float dy);

30 static Ref<FEOffset> create(float dx, float dy);

    float dx() const { return m_dx; }

    void setDx(float);

@@public:

    void setDy(float);

private:

40 FEOffset(~~Filter&,~~ float dx, float dy);

39 FEOffset(float dx, float dy);

4140

    void platformApplySoftware() override;

    void determineAbsolutePaintRect() override;

    void determineAbsolutePaintRect(const Filter&) override;

    void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

Source/WebCore/platform/graphics/filters/FESpecularLighting.cpp

namespace WebCore {

30 FESpecularLighting::FESpecularLighting(Filter& filter, const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

31 : FELighting(filter, SpecularLighting, lightingColor, surfaceScale, 0, specularConstant, specularExponent, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource), FilterEffect::Type::FESpecularLighting)

30Ref<FESpecularLighting> FESpecularLighting::create(const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

3231{

32 return adoptRef(*new FESpecularLighting(lightingColor, surfaceScale, specularConstant, specularExponent, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource)));

3333}

3434

35 Ref<FESpecularLighting> FESpecularLighting::create(Filter& filter, const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

35FESpecularLighting::FESpecularLighting(const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&& lightSource)

36 : FELighting(SpecularLighting, lightingColor, surfaceScale, 0, specularConstant, specularExponent, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource), FilterEffect::Type::FESpecularLighting)

3637{

37 return adoptRef(*new FESpecularLighting(filter, lightingColor, surfaceScale, specularConstant, specularExponent, kernelUnitLengthX, kernelUnitLengthY, WTFMove(lightSource)));

}

bool FESpecularLighting::setSpecularConstant(float specularConstant)

Source/WebCore/platform/graphics/filters/FESpecularLighting.h

@@namespace WebCore {

class FESpecularLighting : public FELighting {

public:

30 static Ref<FESpecularLighting> create(~~Filter&,~~ const Color&, float, float, float, float, float, Ref<LightSource>&&);

30 static Ref<FESpecularLighting> create(const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&&);

    float specularConstant() const { return m_specularConstant; }

    bool setSpecularConstant(float);

@@public:

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

private:

41 FESpecularLighting(~~Filter&,~~ const Color&, float, float, float, float, float, Ref<LightSource>&&);

41 FESpecularLighting(const Color& lightingColor, float surfaceScale, float specularConstant, float specularExponent, float kernelUnitLengthX, float kernelUnitLengthY, Ref<LightSource>&&);

};

} // namespace WebCore

Source/WebCore/platform/graphics/filters/FETile.cpp

#include "AffineTransform.h"

#include "Filter.h"

#include "GraphicsContext.h"

27#include "ImageBuffer.h"

#include "Pattern.h"

#include "RenderTreeAsText.h"

#include "SVGRenderingContext.h"

namespace WebCore {

34 FETile::FETile(Filter& filter)

35 : FilterEffect(filter, FilterEffect::Type::FETile)

35Ref<FETile> FETile::create()

3636{

37 return adoptRef(*new FETile());

3738}

3839

39 Ref<FETile> FETile::create(Filter& filter)

40FETile::FETile()

41 : FilterEffect(FilterEffect::Type::FETile)

4042{

41 return adoptRef(*new FETile(filter));

4243}

4344

44 void FETile::platformApplySoftware()

45void FETile::platformApplySoftware(const Filter& filter)

{

// FIXME: See bug 47315. This is a hack to work around a compile failure, but is incorrect behavior otherwise.

    FilterEffect* in = inputEffect(0);

@@void FETile::platformApplySoftware()

    FloatPoint inMaxEffectLocation = tileRect.location();

    FloatPoint maxEffectLocation = maxEffectRect().location();

    if (in->filterType() == FilterEffect::Type::SourceGraphic || in->filterType() == FilterEffect::Type::SourceAlpha) {

62 Filter& filter = this->filter();

        tileRect = filter.filterRegion();

        tileRect.scale(filter.filterScale());

    }

67 auto tileImage = SVGRenderingContext::createImageBuffer(tileRect, tileRect, DestinationColorSpace::SRGB(), filter().renderingMode());

67 auto tileImage = SVGRenderingContext::createImageBuffer(tileRect, tileRect, DestinationColorSpace::SRGB(), filter.renderingMode());

    if (!tileImage)

        return;

Source/WebCore/platform/graphics/filters/FETile.h

#pragma once

#include "FilterEffect.h"

25 #include "Filter.h"

namespace WebCore {

class FETile : public FilterEffect {

public:

31 static Ref<FETile> create(~~Filter&~~);

30 static Ref<FETile> create();

3231

3332private:

34 FETile(~~Filter&~~);

33 FETile();

3534

36 void ~~platfo~~rm~~ApplyS~~of~~tware(~~) override;

35 void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

3736

38 void deter~~mineAbsolutePaintRect(~~) override ~~{ setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }~~

37 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

};

Source/WebCore/platform/graphics/filters/FETurbulence.cpp

@@static const int s_randAmplitude = 16807; // 7**5; primitive root of m

static const int s_randQ = 127773; // m / a

static const int s_randR = 2836; // m % a

51 FETurbulence::FETurbulence(Filter& filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)

52 : FilterEffect(filter, FilterEffect::Type::FETurbulence)

Ref<FETurbulence> FETurbulence::create(TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)

{

    return adoptRef(*new FETurbulence(type, baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles));

}

FETurbulence::FETurbulence(TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)

    : FilterEffect(FilterEffect::Type::FETurbulence)

    , m_type(type)

    , m_baseFrequencyX(baseFrequencyX)

    , m_baseFrequencyY(baseFrequencyY)

@@FETurbulence::FETurbulence(Filter& filter, TurbulenceType type, float baseFreque

{

}

Ref<FETurbulence> FETurbulence::create(Filter& filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)

{

    return adoptRef(*new FETurbulence(filter, type, baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles));

}

bool FETurbulence::setType(TurbulenceType type)

{

    if (m_type == type)

@@ColorComponents<uint8_t, 4> FETurbulence::calculateTurbulenceValueForPoint(const

    return toIntBasedColorComponents(turbulenceFunctionResult);

}

369 void FETurbulence::fillRegion(Uint8ClampedArray& pixelArray, const PaintingData& paintingData, StitchData stitchData, int startY, int endY) const

369void FETurbulence::fillRegion(const Filter& filter, Uint8ClampedArray& pixelArray, const PaintingData& paintingData, StitchData stitchData, int startY, int endY) const

{

    ASSERT(endY > startY);

    IntRect filterRegion = absolutePaintRect();

    FloatPoint point(0, filterRegion.y() + startY);

    int indexOfPixelChannel = startY * (filterRegion.width() << 2);

376 FloatSize inverseScale = { 1 / filter().filterScale().width(), 1 / filter().filterScale().height() };

376 FloatSize inverseScale = { 1 / filter.filterScale().width(), 1 / filter.filterScale().height() };

    for (int y = startY; y < endY; ++y) {

        point.setY(point.y() + 1);

@@void FETurbulence::fillRegion(Uint8ClampedArray& pixelArray, const PaintingData&

void FETurbulence::fillRegionWorker(FillRegionParameters* parameters)

{

393 parameters->filter~~->fillRegion(~~*parameters->pixelArray, *parameters->paintingData, parameters->stitchData, parameters->startY, parameters->endY);

393 parameters->effect->fillRegion(*parameters->filter, *parameters->pixelArray, *parameters->paintingData, parameters->stitchData, parameters->startY, parameters->endY);

394394}

395395

396 void FETurbulence::platformApplySoftware()

396void FETurbulence::platformApplySoftware(const Filter& filter)

{

    auto& destinationPixelBuffer = createUnmultipliedImageResult();

    if (!destinationPixelBuffer)

@@void FETurbulence::platformApplySoftware()

            for (unsigned i = 0; i < numJobs; ++i) {

                FillRegionParameters& params = parallelJobs.parameter(i);

441 params.filter = this;

441 params.filter = &filter;

442 params.effect = this;

                params.pixelArray = &destinationPixelArray;

                params.paintingData = &paintingData;

                params.stitchData = stitchData;

@@void FETurbulence::platformApplySoftware()

    }

    // Fallback to single threaded mode if there is no room for a new thread or the paint area is too small.

458 fillRegion(destinationPixelArray, paintingData, stitchData, 0, height);

459 fillRegion(filter, destinationPixelArray, paintingData, stitchData, 0, height);

}

static TextStream& operator<<(TextStream& ts, TurbulenceType type)

Source/WebCore/platform/graphics/filters/FETurbulence.h

#include "ColorComponents.h"

#include "FilterEffect.h"

29 #include "Filter.h"

namespace WebCore {

@@enum class TurbulenceType {

class FETurbulence : public FilterEffect {

public:

41 static Ref<FETurbulence> create(~~Filter&,~~ TurbulenceType, float, float, int, float, bool);

40 static Ref<FETurbulence> create(TurbulenceType, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles);

    TurbulenceType type() const { return m_type; }

    bool setType(TurbulenceType);

@@private:

    };

    struct FillRegionParameters {

96 FETurbulence* filter;

95 const Filter* filter;

96 FETurbulence* effect;

        Uint8ClampedArray* pixelArray;

        PaintingData* paintingData;

        StitchData stitchData;

@@private:

    static void fillRegionWorker(FillRegionParameters*);

106 FETurbulence(~~Filter&,~~ TurbulenceType, float, float, int, float, bool);

106 FETurbulence(TurbulenceType, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles);

107107

108 void ~~platfo~~rm~~ApplyS~~of~~tware(~~) override;

109 void deter~~mineAbsolutePaintRect(~~) override ~~{ setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }~~

108 void determineAbsolutePaintRect(const Filter&) override { setAbsolutePaintRect(enclosingIntRect(maxEffectRect())); }

109 void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

    void initPaint(PaintingData&);

    StitchData computeStitching(IntSize tileSize, float& baseFrequencyX, float& baseFrequencyY) const;

    ColorComponents<float, 4> noise2D(const PaintingData&, const StitchData&, const FloatPoint&) const;

    ColorComponents<uint8_t, 4> calculateTurbulenceValueForPoint(const PaintingData&, StitchData, const FloatPoint&) const;

116 void fillRegion(Uint8ClampedArray&, const PaintingData&, StitchData, int startY, int endY) const;

116 void fillRegion(const Filter&, Uint8ClampedArray&, const PaintingData&, StitchData, int startY, int endY) const;

    static void fillRegionWorker(void*);

Source/WebCore/platform/graphics/filters/Filter.h

@@public:

    void setFilterRegion(const FloatRect& filterRegion) { m_filterRegion = filterRegion; }

    virtual FloatSize scaledByFilterScale(FloatSize size) const { return size * m_filterScale; }

46 virtual void apply() = 0;

4647

47 ImageBuffer* sourceImage() { return m_sourceImage.get(); }

48 ImageBuffer* sourceImage() const { return m_sourceImage.get(); }

    void setSourceImage(RefPtr<ImageBuffer>&& sourceImage) { m_sourceImage = WTFMove(sourceImage); }

    RenderingMode renderingMode() const { return m_renderingMode; }

Source/WebCore/platform/graphics/filters/FilterEffect.cpp

namespace WebCore {

48 FilterEffect::FilterEffect(Filter~~& filter, Filter~~Effect::Type type)

48FilterEffect::FilterEffect(FilterEffect::Type type)

4949 : FilterFunction(type)

50 , m_filter(filter)

{

}

54 void FilterEffect::determineAbsolutePaintRect()

53void FilterEffect::determineAbsolutePaintRect(const Filter&)

{

    m_absolutePaintRect = IntRect();

    for (auto& effect : m_inputEffects)

@@FloatRect FilterEffect::drawingRegionOfInputImage(const IntRect& srcRect) const

    return transform.mapRect(srcRect);

}

97 FloatRect FilterEffect::determineFilterPrimitiveSubregion()

96FloatRect FilterEffect::determineFilterPrimitiveSubregion(const Filter& filter)

{

    // FETile, FETurbulence, FEFlood don't have input effects, take the filter region as unite rect.

    FloatRect subregion;

    if (unsigned numberOfInputEffects = inputEffects().size()) {

102 subregion = inputEffect(0)->determineFilterPrimitiveSubregion();

101 subregion = inputEffect(0)->determineFilterPrimitiveSubregion(filter);

103102 for (unsigned i = 1; i < numberOfInputEffects; ++i) {

104 auto inputPrimitiveSubregion = inputEffect(i)->determineFilterPrimitiveSubregion();

103 auto inputPrimitiveSubregion = inputEffect(i)->determineFilterPrimitiveSubregion(filter);

            subregion.unite(inputPrimitiveSubregion);

        }

    } else

108 subregion = m_filter.filterRegion();

107 subregion = filter.filterRegion();

    // After calling determineFilterPrimitiveSubregion on the target effect, reset the subregion again for <feTile>.

    if (filterType() == FilterEffect::Type::FETile)

112 subregion = m_filter.filterRegion();

111 subregion = filter.filterRegion();

    auto boundaries = effectBoundaries();

    if (hasX())

@@FloatRect FilterEffect::determineFilterPrimitiveSubregion()

    setFilterPrimitiveSubregion(subregion);

    auto absoluteSubregion = subregion;

127 absoluteSubregion.scale(m_filter.filterScale());

126 absoluteSubregion.scale(filter.filterScale());

    // Save this before clipping so we can use it to map lighting points from user space to buffer coordinates.

    setUnclippedAbsoluteSubregion(absoluteSubregion);

    // Clip every filter effect to the filter region.

132 auto absoluteScaledFilterRegion = m_filter.filterRegion();

133 absoluteScaledFilterRegion.scale(m_filter.filterScale());

131 auto absoluteScaledFilterRegion = filter.filterRegion();

132 absoluteScaledFilterRegion.scale(filter.filterScale());

    absoluteSubregion.intersect(absoluteScaledFilterRegion);

    setMaxEffectRect(absoluteSubregion);

@@FilterEffect* FilterEffect::inputEffect(unsigned number) const

    return m_inputEffects.at(number).get();

}

146 void FilterEffect::apply()

145void FilterEffect::apply(const Filter& filter)

{

    if (hasResult())

        return;

    unsigned size = m_inputEffects.size();

    for (unsigned i = 0; i < size; ++i) {

        FilterEffect* in = m_inputEffects.at(i).get();

153 in->apply();

152 in->apply(filter);

        if (!in->hasResult())

            return;

@@void FilterEffect::apply()

        transformResultColorSpace(in, i);

    }

161 determineAbsolutePaintRect();

160 determineAbsolutePaintRect(filter);

162161 setResultColorSpace(m_operatingColorSpace);

163162

164 LOG_WITH_STREAM(Filters, stream << "FilterEffect " << filterName() << " " << this << " apply():\n filterPrimitiveSubregion " << m_filterPrimitiveSubregion << "\n effectBoundaries " << m_effectBoundaries << "\n absoluteUnclippedSubregion " << m_absoluteUnclippedSubregion << "\n absolutePaintRect " << m_absolutePaintRect << "\n maxEffectRect " << m_maxEffectRect << "\n filter scale " << m_filter.filterScale());

163 LOG_WITH_STREAM(Filters, stream << "FilterEffect " << filterName() << " " << this << " apply():\n filterPrimitiveSubregion " << m_filterPrimitiveSubregion << "\n effectBoundaries " << m_effectBoundaries << "\n absoluteUnclippedSubregion " << m_absoluteUnclippedSubregion << "\n absolutePaintRect " << m_absolutePaintRect << "\n maxEffectRect " << m_maxEffectRect << "\n filter scale " << filter.filterScale());

    if (m_absolutePaintRect.isEmpty() || ImageBuffer::sizeNeedsClamping(m_absolutePaintRect.size()))

        return;

@@void FilterEffect::apply()

    }

    // Add platform specific apply functions here and return earlier.

175 platformApplySoftware();

174 platformApplySoftware(filter);

}

void FilterEffect::forceValidPreMultipliedPixels()

@@ImageBuffer* FilterEffect::imageBufferResult()

    if (m_imageBufferResult)

        return m_imageBufferResult.get();

256 m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), ~~m_filter.r~~enderingMode(), 1, m_resultColorSpace, PixelFormat::BGRA8);

255 m_imageBufferResult = ImageBuffer::create(m_absolutePaintRect.size(), RenderingMode::Unaccelerated, 1, m_resultColorSpace, PixelFormat::BGRA8);

    if (!m_imageBufferResult)

        return nullptr;

@@std::optional<PixelBuffer> FilterEffect::convertPixelBufferToColorSpace(const De

    IntRect destinationRect(IntPoint(), pixelBuffer.size());

    FloatSize clampedSize = ImageBuffer::clampedSize(destinationRect.size());

    // Create an ImageBuffer to store incoming PixelBuffer

425 auto buffer = ImageBuffer::create(clampedSize, ~~m_filter.r~~enderingMode(), 1, operatingColorSpace(), PixelFormat::BGRA8);

424 auto buffer = ImageBuffer::create(clampedSize, RenderingMode::Unaccelerated, 1, operatingColorSpace(), PixelFormat::BGRA8);

    if (!buffer)

        return std::nullopt;

    buffer->putPixelBuffer(pixelBuffer, destinationRect);

@@std::optional<PixelBuffer> FilterEffect::convertImageBufferToColorSpace(const De

    FloatSize clampedSize = ImageBuffer::clampedSize(rect.size());

    // Create an ImageBuffer with the correct color space and utilize CG to handle color space conversion

439 auto convertedBuffer = ImageBuffer::create(clampedSize, ~~m_filter.r~~enderingMode(), 1, targetColorSpace, PixelFormat::BGRA8);

438 auto convertedBuffer = ImageBuffer::create(clampedSize, RenderingMode::Unaccelerated, 1, targetColorSpace, PixelFormat::BGRA8);

    if (!convertedBuffer)

        return std::nullopt;

@@ImageBuffer* FilterEffect::createImageBufferResult()

        return nullptr;

    FloatSize clampedSize = ImageBuffer::clampedSize(m_absolutePaintRect.size());

556 m_imageBufferResult = ImageBuffer::create(clampedSize, ~~m_filter.r~~enderingMode(), 1, m_resultColorSpace, PixelFormat::BGRA8);

555 m_imageBufferResult = ImageBuffer::create(clampedSize, RenderingMode::Unaccelerated, 1, m_resultColorSpace, PixelFormat::BGRA8);

    return m_imageBufferResult.get();

}

Source/WebCore/platform/graphics/filters/FilterEffect.h

@@public:

    IntRect requestedRegionOfInputPixelBuffer(const IntRect&) const;

    // Recurses on inputs.

75 FloatRect determineFilterPrimitiveSubregion();

75 FloatRect determineFilterPrimitiveSubregion(const Filter&);

    // Solid black image with different alpha values.

    bool isAlphaImage() const { return m_alphaImage; }

@@public:

    FloatRect maxEffectRect() const { return m_maxEffectRect; }

    void setMaxEffectRect(const FloatRect& maxEffectRect) { m_maxEffectRect = maxEffectRect; }

87 void apply();

87 void apply(const Filter&);

    // Correct any invalid pixels, if necessary, in the result of a filter operation.

    // This method is used to ensure valid pixel values on filter inputs and the final result.

    // Only the arithmetic composite filter ever needs to perform correction.

    virtual void correctFilterResultIfNeeded() { }

94 virtual void determineAbsolutePaintRect();

94 virtual void determineAbsolutePaintRect(const Filter&);

    enum class RepresentationType { TestOutput, Debugging };

    virtual WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType = RepresentationType::TestOutput) const;

@@public:

    
    FloatPoint mapPointFromUserSpaceToBuffer(FloatPoint) const;

    Filter& filter() { return m_filter; }

    const Filter& filter() const { return m_filter; }

    bool clipsToBounds() const { return m_clipsToBounds; }

    void setClipsToBounds(bool value) { m_clipsToBounds = value; }

@@public:

    }

protected:

146 FilterEffect(~~Filter&,~~ Type);

143 FilterEffect(Type);

    
    ImageBuffer* createImageBufferResult();

    std::optional<PixelBuffer>& createUnmultipliedImageResult();

@@protected:

    void clipAbsolutePaintRect();

private:

162 virtual void platformApplySoftware() = 0;

159 virtual void platformApplySoftware(const Filter&) = 0;

    void copyImageBytes(const Uint8ClampedArray& source, Uint8ClampedArray& destination, const IntRect&) const;

    void copyConvertedImageBufferToDestination(Uint8ClampedArray&, const DestinationColorSpace&, AlphaPremultiplication, const IntRect&);

@@private:

    std::optional<PixelBuffer> convertImageBufferToColorSpace(const DestinationColorSpace&, ImageBuffer&, const IntRect&, AlphaPremultiplication);

    std::optional<PixelBuffer> convertPixelBufferToColorSpace(const DestinationColorSpace&, PixelBuffer&);

171

172 Filter& m_filter;

    FilterEffectVector m_inputEffects;

    RefPtr<ImageBuffer> m_imageBufferResult;

Source/WebCore/platform/graphics/filters/FilterEffectRenderer.h

@@class FilterEffectRenderer {

    
public:

    static std::unique_ptr<FilterEffectRenderer> tryCreate(bool, FilterEffect&);

39 virtual void applyEffects(FilterEffect&) = 0;

39 virtual void applyEffects(const Filter&, FilterEffect&) = 0;

    virtual bool hasResult() const = 0;

    virtual ImageBuffer* output() const = 0;

    virtual FloatRect destRect(const FilterEffect&) const = 0;

Source/WebCore/platform/graphics/filters/SourceAlpha.cpp

@@Ref<SourceAlpha> SourceAlpha::create(FilterEffect& sourceEffect)

}

SourceAlpha::SourceAlpha(FilterEffect& sourceEffect)

36 : FilterEffect(~~sourceEffect.filter(),~~ FilterEffect::Type::SourceAlpha)

36 : FilterEffect(FilterEffect::Type::SourceAlpha)

{

    setOperatingColorSpace(sourceEffect.operatingColorSpace());

    inputEffects().append(&sourceEffect);

}

42 void SourceAlpha::determineAbsolutePaintRect()

42void SourceAlpha::determineAbsolutePaintRect(const Filter& filter)

4343{

44 inputEffect(0)->determineAbsolutePaintRect();

44 inputEffect(0)->determineAbsolutePaintRect(filter);

    setAbsolutePaintRect(inputEffect(0)->absolutePaintRect());

}

48 void SourceAlpha::platformApplySoftware()

48void SourceAlpha::platformApplySoftware(const Filter&)

{

    ImageBuffer* resultImage = createImageBufferResult();

    if (!resultImage)

Source/WebCore/platform/graphics/filters/SourceAlpha.h

@@public:

private:

    explicit SourceAlpha(FilterEffect&);

35 void platformApplySoftware() override;

36 void determineAbsolutePaintRect() override;

    void determineAbsolutePaintRect(const Filter&) override;

    void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

};

Source/WebCore/platform/graphics/filters/SourceGraphic.cpp

namespace WebCore {

29 Ref<SourceGraphic> SourceGraphic::create(~~Filter& filter~~)

29Ref<SourceGraphic> SourceGraphic::create()

3030{

31 return adoptRef(*new SourceGraphic(~~filter~~));

31 return adoptRef(*new SourceGraphic());

3232}

3333

34 void SourceGraphic::determineAbsolutePaintRect()

SourceGraphic::SourceGraphic()

    : FilterEffect(FilterEffect::Type::SourceGraphic)

{

    setOperatingColorSpace(DestinationColorSpace::SRGB());

}

void SourceGraphic::determineAbsolutePaintRect(const Filter& filter)

3541{

36 Filter& filter = this->filter();

    FloatRect paintRect = filter.sourceImageRect();

    setAbsolutePaintRect(enclosingIntRect(paintRect));

}

41 void SourceGraphic::platformApplySoftware()

46void SourceGraphic::platformApplySoftware(const Filter& filter)

4247{

43 Filter& filter = this->filter();

44

    ImageBuffer* resultImage = createImageBufferResult();

    ImageBuffer* sourceImage = filter.sourceImage();

    if (!resultImage || !sourceImage)

Source/WebCore/platform/graphics/filters/SourceGraphic.h

@@namespace WebCore {

class SourceGraphic : public FilterEffect {

public:        

29 static Ref<SourceGraphic> create(~~Filter&~~);

29 static Ref<SourceGraphic> create();

    static AtomString effectName() { return FilterEffect::sourceGraphicName(); }

private:

    SourceGraphic(Filter& filter)

        : FilterEffect(filter, FilterEffect::Type::SourceGraphic)

    {

        setOperatingColorSpace(DestinationColorSpace::SRGB());

    }

    void determineAbsolutePaintRect() override;

    void platformApplySoftware() override;

    SourceGraphic();

    void determineAbsolutePaintRect(const Filter&) override;

    void platformApplySoftware(const Filter&) override;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const override;

};

Source/WebCore/rendering/CSSFilter.cpp

@@CSSFilter::CSSFilter(bool hasFilterThatMovesPixels, bool hasFilterThatShouldBeRe

{

}

67 static RefPtr<FilterEffect> createBlurEffect(~~CSSFilter& filter,~~ const BlurFilterOperation& blurOperation, FilterConsumer consumer)

67static RefPtr<FilterEffect> createBlurEffect(const BlurFilterOperation& blurOperation, FilterConsumer consumer)

6868{

6969 float stdDeviation = floatValueForLength(blurOperation.stdDeviation(), 0);

70 return FEGaussianBlur::create(~~filter,~~ stdDeviation, stdDeviation, consumer == FilterConsumer::FilterProperty ? EDGEMODE_NONE : EDGEMODE_DUPLICATE);

70 return FEGaussianBlur::create(stdDeviation, stdDeviation, consumer == FilterConsumer::FilterProperty ? EDGEMODE_NONE : EDGEMODE_DUPLICATE);

7171}

7272

73 static RefPtr<FilterEffect> createBrightnessEffect(~~CSSFilter& filter,~~ const BasicComponentTransferFilterOperation& componentTransferOperation)

73static RefPtr<FilterEffect> createBrightnessEffect(const BasicComponentTransferFilterOperation& componentTransferOperation)

{

    ComponentTransferFunction transferFunction;

    transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;

@@static RefPtr<FilterEffect> createBrightnessEffect(CSSFilter& filter, const Basi

    transferFunction.intercept = 0;

    ComponentTransferFunction nullFunction;

81 return FEComponentTransfer::create(~~filter,~~ transferFunction, transferFunction, transferFunction, nullFunction);

81 return FEComponentTransfer::create(transferFunction, transferFunction, transferFunction, nullFunction);

8282}

8383

84 static RefPtr<FilterEffect> createContrastEffect(~~CSSFilter& filter,~~ const BasicComponentTransferFilterOperation& componentTransferOperation)

84static RefPtr<FilterEffect> createContrastEffect(const BasicComponentTransferFilterOperation& componentTransferOperation)

{

    ComponentTransferFunction transferFunction;

    transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;

@@static RefPtr<FilterEffect> createContrastEffect(CSSFilter& filter, const BasicC

    transferFunction.intercept = -0.5 * amount + 0.5;

    ComponentTransferFunction nullFunction;

93 return FEComponentTransfer::create(~~filter,~~ transferFunction, transferFunction, transferFunction, nullFunction);

93 return FEComponentTransfer::create(transferFunction, transferFunction, transferFunction, nullFunction);

9494}

9595

96 static RefPtr<FilterEffect> createDropShadowEffect(~~CSSFilter& filter,~~ const DropShadowFilterOperation& dropShadowOperation)

96static RefPtr<FilterEffect> createDropShadowEffect(const DropShadowFilterOperation& dropShadowOperation)

9797{

9898 float std = dropShadowOperation.stdDeviation();

99 return FEDropShadow::create(~~filter,~~ std, std, dropShadowOperation.x(), dropShadowOperation.y(), dropShadowOperation.color(), 1);

99 return FEDropShadow::create(std, std, dropShadowOperation.x(), dropShadowOperation.y(), dropShadowOperation.color(), 1);

100100}

101101

102 static RefPtr<FilterEffect> createGrayScaleEffect(~~CSSFilter& filter,~~ const BasicColorMatrixFilterOperation& colorMatrixOperation)

102static RefPtr<FilterEffect> createGrayScaleEffect(const BasicColorMatrixFilterOperation& colorMatrixOperation)

{

    double oneMinusAmount = clampTo(1 - colorMatrixOperation.amount(), 0.0, 1.0);

@@static RefPtr<FilterEffect> createGrayScaleEffect(CSSFilter& filter, const Basic

        0,

    };

135 return FEColorMatrix::create(~~filter,~~ FECOLORMATRIX_TYPE_MATRIX, WTFMove(inputParameters));

135 return FEColorMatrix::create(FECOLORMATRIX_TYPE_MATRIX, WTFMove(inputParameters));

136136}

137137

138 static RefPtr<FilterEffect> createHueRotateEffect(~~CSSFilter& filter,~~ const BasicColorMatrixFilterOperation& colorMatrixOperation)

138static RefPtr<FilterEffect> createHueRotateEffect(const BasicColorMatrixFilterOperation& colorMatrixOperation)

139139{

140140 Vector<float> inputParameters { narrowPrecisionToFloat(colorMatrixOperation.amount()) };

141 return FEColorMatrix::create(~~filter,~~ FECOLORMATRIX_TYPE_HUEROTATE, WTFMove(inputParameters));

141 return FEColorMatrix::create(FECOLORMATRIX_TYPE_HUEROTATE, WTFMove(inputParameters));

142142}

143143

144 static RefPtr<FilterEffect> createInvertEffect(~~CSSFilter& filter,~~ const BasicComponentTransferFilterOperation& componentTransferOperation)

144static RefPtr<FilterEffect> createInvertEffect(const BasicComponentTransferFilterOperation& componentTransferOperation)

{

    ComponentTransferFunction transferFunction;

    transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;

@@static RefPtr<FilterEffect> createInvertEffect(CSSFilter& filter, const BasicCom

    transferFunction.intercept = amount;

    ComponentTransferFunction nullFunction;

153 return FEComponentTransfer::create(~~filter,~~ transferFunction, transferFunction, transferFunction, nullFunction);

153 return FEComponentTransfer::create(transferFunction, transferFunction, transferFunction, nullFunction);

154154}

155155

156 static RefPtr<FilterEffect> createOpacityEffect(~~CSSFilter& filter,~~ const BasicComponentTransferFilterOperation& componentTransferOperation)

156static RefPtr<FilterEffect> createOpacityEffect(const BasicComponentTransferFilterOperation& componentTransferOperation)

{

    ComponentTransferFunction transferFunction;

    transferFunction.type = FECOMPONENTTRANSFER_TYPE_LINEAR;

@@static RefPtr<FilterEffect> createOpacityEffect(CSSFilter& filter, const BasicCo

    transferFunction.intercept = 0;

    ComponentTransferFunction nullFunction;

165 return FEComponentTransfer::create(~~filter,~~ nullFunction, nullFunction, nullFunction, transferFunction);

165 return FEComponentTransfer::create(nullFunction, nullFunction, nullFunction, transferFunction);

166166}

167167

168 static RefPtr<FilterEffect> createSaturateEffect(~~CSSFilter& filter,~~ const BasicColorMatrixFilterOperation& colorMatrixOperation)

168static RefPtr<FilterEffect> createSaturateEffect(const BasicColorMatrixFilterOperation& colorMatrixOperation)

169169{

170170 Vector<float> inputParameters { narrowPrecisionToFloat(colorMatrixOperation.amount()) };

171 return FEColorMatrix::create(~~filter,~~ FECOLORMATRIX_TYPE_SATURATE, WTFMove(inputParameters));

171 return FEColorMatrix::create(FECOLORMATRIX_TYPE_SATURATE, WTFMove(inputParameters));

172172}

173173

174 static RefPtr<FilterEffect> createSepiaEffect(~~CSSFilter& filter,~~ const BasicColorMatrixFilterOperation& colorMatrixOperation)

174static RefPtr<FilterEffect> createSepiaEffect(const BasicColorMatrixFilterOperation& colorMatrixOperation)

{

    double oneMinusAmount = clampTo(1 - colorMatrixOperation.amount(), 0.0, 1.0);

@@static RefPtr<FilterEffect> createSepiaEffect(CSSFilter& filter, const BasicColo

        0,

    };

207 return FEColorMatrix::create(~~filter,~~ FECOLORMATRIX_TYPE_MATRIX, WTFMove(inputParameters));

207 return FEColorMatrix::create(FECOLORMATRIX_TYPE_MATRIX, WTFMove(inputParameters));

}

static RefPtr<SVGFilter> createSVGFilter(CSSFilter& filter, const ReferenceFilterOperation& filterOperation, RenderElement& renderer, FilterEffect& previousEffect)

@@bool CSSFilter::buildFilterFunctions(RenderElement& renderer, const FilterOperat

    m_functions.clear();

    m_outsets = { };

240 RefPtr<FilterEffect> previousEffect = SourceGraphic::create(*this);

240 RefPtr<FilterEffect> previousEffect = SourceGraphic::create();

    m_functions.append({ *previousEffect });

    RefPtr<SVGFilter> filter;

@@bool CSSFilter::buildFilterFunctions(RenderElement& renderer, const FilterOperat

            break;

        case FilterOperation::BLUR:

254 effect = createBlurEffect(*this, downcast<BlurFilterOperation>(*operation), consumer);

254 effect = createBlurEffect(downcast<BlurFilterOperation>(*operation), consumer);

            break;

        case FilterOperation::BRIGHTNESS:

258 effect = createBrightnessEffect(*this, downcast<BasicComponentTransferFilterOperation>(*operation));

258 effect = createBrightnessEffect(downcast<BasicComponentTransferFilterOperation>(*operation));

            break;

        case FilterOperation::CONTRAST:

262 effect = createContrastEffect(*this, downcast<BasicComponentTransferFilterOperation>(*operation));

262 effect = createContrastEffect(downcast<BasicComponentTransferFilterOperation>(*operation));

            break;

        case FilterOperation::DROP_SHADOW:

266 effect = createDropShadowEffect(*this, downcast<DropShadowFilterOperation>(*operation));

266 effect = createDropShadowEffect(downcast<DropShadowFilterOperation>(*operation));

            break;

        case FilterOperation::GRAYSCALE:

270 effect = createGrayScaleEffect(*this, downcast<BasicColorMatrixFilterOperation>(*operation));

270 effect = createGrayScaleEffect(downcast<BasicColorMatrixFilterOperation>(*operation));

            break;

        case FilterOperation::HUE_ROTATE:

274 effect = createHueRotateEffect(*this, downcast<BasicColorMatrixFilterOperation>(*operation));

274 effect = createHueRotateEffect(downcast<BasicColorMatrixFilterOperation>(*operation));

            break;

        case FilterOperation::INVERT:

278 effect = createInvertEffect(*this, downcast<BasicComponentTransferFilterOperation>(*operation));

278 effect = createInvertEffect(downcast<BasicComponentTransferFilterOperation>(*operation));

            break;

        case FilterOperation::OPACITY:

282 effect = createOpacityEffect(*this, downcast<BasicComponentTransferFilterOperation>(*operation));

282 effect = createOpacityEffect(downcast<BasicComponentTransferFilterOperation>(*operation));

            break;

        case FilterOperation::SATURATE:

286 effect = createSaturateEffect(*this, downcast<BasicColorMatrixFilterOperation>(*operation));

286 effect = createSaturateEffect(downcast<BasicColorMatrixFilterOperation>(*operation));

            break;

        case FilterOperation::SEPIA:

290 effect = createSepiaEffect(*this, downcast<BasicColorMatrixFilterOperation>(*operation));

290 effect = createSepiaEffect(downcast<BasicColorMatrixFilterOperation>(*operation));

            break;

        case FilterOperation::REFERENCE:

@@RefPtr<FilterEffect> CSSFilter::lastEffect()

void CSSFilter::determineFilterPrimitiveSubregion()

{

    auto effect = lastEffect();

388 effect->determineFilterPrimitiveSubregion();

388 effect->determineFilterPrimitiveSubregion(*this);

    FloatRect subRegion = effect->maxEffectRect();

    // At least one FilterEffect has a too big image size, recalculate the effect sizes with new scale factors.

    FloatSize filterScale { 1, 1 };

    if (ImageBuffer::sizeNeedsClamping(subRegion.size(), filterScale)) {

        setFilterScale(filterScale);

394 effect->determineFilterPrimitiveSubregion();

394 effect->determineFilterPrimitiveSubregion(*this);

    }

}

@@void CSSFilter::apply()

{

    auto effect = lastEffect();

    if (m_filterRenderer) {

408 m_filterRenderer->applyEffects(*effect);

408 m_filterRenderer->applyEffects(*this, *effect);

        if (m_filterRenderer->hasResult()) {

            effect->transformResultColorSpace(DestinationColorSpace::SRGB());

            return;

        }

    }

414 effect->apply();

    for (auto& function : m_functions) {

        if (function->isSVGFilter()) {

            downcast<SVGFilter>(function.ptr())->setSourceImage({ sourceImage() });

            downcast<SVGFilter>(function.ptr())->apply();

        } else if (function->isFilterEffect())

            downcast<FilterEffect>(function.ptr())->apply(*this);

    }

    effect->transformResultColorSpace(DestinationColorSpace::SRGB());

}

Source/WebCore/rendering/CSSFilter.h

@@public:

    IntOutsets outsets() const override;

    void clearIntermediateResults();

62 void apply();

62 void apply() override;

    ImageBuffer* output();

Source/WebCore/rendering/svg/RenderSVGResourceFilter.cpp

@@bool RenderSVGResourceFilter::applyResource(RenderElement& renderer, const Rende

    LOG_WITH_STREAM(Filters, stream << "RenderSVGResourceFilter::applyResource\n" << *filterData->builder->lastEffect());

134 lastEffect->determineFilterPrimitiveSubregion();

134 lastEffect->determineFilterPrimitiveSubregion(*filterData->filter);

    FloatRect subRegion = lastEffect->maxEffectRect();

    // At least one FilterEffect has a too big image size,

    // recalculate the effect sizes with new scale factors.

    if (ImageBuffer::sizeNeedsClamping(subRegion.size(), filterScale)) {

        filterData->filter->setFilterScale(filterScale);

141 lastEffect->determineFilterPrimitiveSubregion();

141 lastEffect->determineFilterPrimitiveSubregion(*filterData->filter);

    }

    // If the drawingRegion is empty, we have something like <g filter=".."/>.

@@void RenderSVGResourceFilter::postApplyResource(RenderElement& renderer, Graphic

        break;

    }

227 ~~Fil~~terEffect* lastEffect = filterData.bu~~ild~~er->lastEffect();

227 auto lastEffect = filterData.filter->lastEffect();

    if (lastEffect && !filterData.boundaries.isEmpty() && !lastEffect->filterPrimitiveSubregion().isEmpty()) {

        // This is the real filtering of the object. It just needs to be called on the

@@void RenderSVGResourceFilter::postApplyResource(RenderElement& renderer, Graphic

        // Always true if filterData is just built (filterData->state == FilterData::Built).

        if (!lastEffect->hasResult()) {

            filterData.state = FilterData::Applying;

239 lastEff~~ect~~->apply();

239 filterData.filter->apply();

            lastEffect->correctFilterResultIfNeeded();

            lastEffect->transformResultColorSpace(DestinationColorSpace::SRGB());

        }

Source/WebCore/svg/SVGFEBlendElement.cpp

@@void SVGFEBlendElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

103 RefPtr<FilterEffect> SVGFEBlendElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

103RefPtr<FilterEffect> SVGFEBlendElement::build(SVGFilterBuilder& filterBuilder) const

104104{

105 auto input1 = filterBuilder->getEffectById(in1());

106 auto input2 = filterBuilder->getEffectById(in2());

105 auto input1 = filterBuilder.getEffectById(in1());

106 auto input2 = filterBuilder.getEffectById(in2());

    if (!input1 || !input2)

        return nullptr;

    auto effect = FEBlend::create(filter, mode());

    FilterEffectVector& inputEffects = effect->inputEffects();

    inputEffects.reserveCapacity(2);

    inputEffects.append(input1);

    inputEffects.append(input2);

111 auto effect = FEBlend::create(mode());

112 effect->inputEffects() = { WTFMove(input1), WTFMove(input2) };

    return effect;

}

Source/WebCore/svg/SVGFEBlendElement.h

@@private:

    void parseAttribute(const QualifiedName&, const AtomString&) override;

    void svgAttributeChanged(const QualifiedName&) override;

72 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

72 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName) override;

    PropertyRegistry m_propertyRegistry { *this };

Source/WebCore/svg/SVGFEColorMatrixElement.cpp

@@void SVGFEColorMatrixElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

103 RefPtr<FilterEffect> SVGFEColorMatrixElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

103RefPtr<FilterEffect> SVGFEColorMatrixElement::build(SVGFilterBuilder& filterBuilder) const

104104{

105 auto input1 = filterBuilder->getEffectById(in1());

105 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

@@RefPtr<FilterEffect> SVGFEColorMatrixElement::build(SVGFilterBuilder* filterBuil

        filterValues.shrinkToFit();

    }

144 auto effect = FEColorMatrix::create(filter~~, filter~~Type, WTFMove(filterValues));

145 effect->inputEffects() = { input1 };

144 auto effect = FEColorMatrix::create(filterType, WTFMove(filterValues));

145 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEColorMatrixElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

89 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

89 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEComponentTransferElement.cpp

@@void SVGFEComponentTransferElement::parseAttribute(const QualifiedName& name, co

    SVGFilterPrimitiveStandardAttributes::parseAttribute(name, value);

}

66 RefPtr<FilterEffect> SVGFEComponentTransferElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

66RefPtr<FilterEffect> SVGFEComponentTransferElement::build(SVGFilterBuilder& filterBuilder) const

6767{

68 auto input1 = filterBuilder->getEffectById(in1());

68 auto input1 = filterBuilder.getEffectById(in1());

    
    if (!input1)

        return nullptr;

@@RefPtr<FilterEffect> SVGFEComponentTransferElement::build(SVGFilterBuilder* filt

        else if (is<SVGFEFuncAElement>(child))

            alpha = downcast<SVGFEFuncAElement>(child).transferFunction();

    }

    
    auto effect = FEComponentTransfer::create(filter, red, green, blue, alpha);

    effect->inputEffects() = { input1 };

    auto effect = FEComponentTransfer::create(red, green, blue, alpha);

    effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEComponentTransferElement.h

@@private:

    // FIXME: svgAttributeChanged missing.

    void parseAttribute(const QualifiedName&, const AtomString&) override;

46 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

46 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFECompositeElement.cpp

@@void SVGFECompositeElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

134 RefPtr<FilterEffect> SVGFECompositeElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

134RefPtr<FilterEffect> SVGFECompositeElement::build(SVGFilterBuilder& filterBuilder) const

135135{

136 auto input1 = filterBuilder->getEffectById(in1());

137 auto input2 = filterBuilder->getEffectById(in2());

136 auto input1 = filterBuilder.getEffectById(in1());

137 auto input2 = filterBuilder.getEffectById(in2());

    
    if (!input1 || !input2)

        return nullptr;

    auto effect = FEComposite::create(filter, svgOperator(), k1(), k2(), k3(), k4());

    FilterEffectVector& inputEffects = effect->inputEffects();

    inputEffects.reserveCapacity(2);

    inputEffects.append(input1);

    inputEffects.append(input2);

142 auto effect = FEComposite::create(svgOperator(), k1(), k2(), k3(), k4());

143 effect->inputEffects() = { WTFMove(input1), WTFMove(input2) };

    return effect;

}

Source/WebCore/svg/SVGFECompositeElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

112 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

112 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEConvolveMatrixElement.cpp

@@void SVGFEConvolveMatrixElement::svgAttributeChanged(const QualifiedName& attrNa

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

194 RefPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

194RefPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder& filterBuilder) const

195195{

196 auto input1 = filterBuilder->getEffectById(in1());

196 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

@@RefPtr<FilterEffect> SVGFEConvolveMatrixElement::build(SVGFilterBuilder* filterB

            divisorValue = 1;

    }

249 auto effect = FEConvolveMatrix::create(~~filter,~~ IntSize(orderXValue, orderYValue), divisorValue, bias(), IntPoint(targetXValue, targetYValue), edgeMode(), FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix);

250 effect->inputEffects() = { input1 };

249 auto effect = FEConvolveMatrix::create(IntSize(orderXValue, orderYValue), divisorValue, bias(), IntPoint(targetXValue, targetYValue), edgeMode(), FloatPoint(kernelUnitLengthXValue, kernelUnitLengthYValue), preserveAlpha(), kernelMatrix);

250 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEConvolveMatrixElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

106 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

106 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEDiffuseLightingElement.cpp

@@void SVGFEDiffuseLightingElement::lightElementAttributeChanged(const SVGFELightE

    primitiveAttributeChanged(attrName);

}

154 RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

154RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder& filterBuilder) const

155155{

156 auto input1 = filterBuilder->getEffectById(in1());

156 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

@@RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filter

    if (!lightElement)

        return nullptr;

165 auto lightSource = lightElement->lightSource(*filterBuilder);

165 auto lightSource = lightElement->lightSource(filterBuilder);

    RenderObject* renderer = this->renderer();

    if (!renderer)

@@RefPtr<FilterEffect> SVGFEDiffuseLightingElement::build(SVGFilterBuilder* filter

    Color color = renderer->style().colorByApplyingColorFilter(renderer->style().svgStyle().lightingColor());

173 auto effect = FEDiffuseLighting::create(~~filter,~~ color, surfaceScale(), diffuseConstant(), kernelUnitLengthX(), kernelUnitLengthY(), WTFMove(lightSource));

174 effect->inputEffects() = { input1 };

173 auto effect = FEDiffuseLighting::create(color, surfaceScale(), diffuseConstant(), kernelUnitLengthX(), kernelUnitLengthY(), WTFMove(lightSource));

174 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEDiffuseLightingElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

61 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

61 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEDisplacementMapElement.cpp

@@void SVGFEDisplacementMapElement::svgAttributeChanged(const QualifiedName& attrN

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

118 RefPtr<FilterEffect> SVGFEDisplacementMapElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

118RefPtr<FilterEffect> SVGFEDisplacementMapElement::build(SVGFilterBuilder& filterBuilder) const

119119{

120 auto input1 = filterBuilder->getEffectById(in1());

121 auto input2 = filterBuilder->getEffectById(in2());

120 auto input1 = filterBuilder.getEffectById(in1());

121 auto input2 = filterBuilder.getEffectById(in2());

    
    if (!input1 || !input2)

        return nullptr;

    auto effect = FEDisplacementMap::create(filter, xChannelSelector(), yChannelSelector(), scale());

    FilterEffectVector& inputEffects = effect->inputEffects();

    inputEffects.reserveCapacity(2);

    inputEffects.append(input1);

    inputEffects.append(input2);

126 auto effect = FEDisplacementMap::create(xChannelSelector(), yChannelSelector(), scale());

127 effect->inputEffects() = { WTFMove(input1), WTFMove(input2) };

    return effect;

}

Source/WebCore/svg/SVGFEDisplacementMapElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName) override;

94 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

94 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEDropShadowElement.cpp

@@void SVGFEDropShadowElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

100 RefPtr<FilterEffect> SVGFEDropShadowElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

100RefPtr<FilterEffect> SVGFEDropShadowElement::build(SVGFilterBuilder& filterBuilder) const

101101{

    auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

    RenderObject* renderer = this->renderer();

    if (!renderer)

        return nullptr;

@@RefPtr<FilterEffect> SVGFEDropShadowElement::build(SVGFilterBuilder* filterBuild

    Color color = renderer->style().colorByApplyingColorFilter(svgStyle.floodColor());

    float opacity = svgStyle.floodOpacity();

    auto input1 = filterBuilder->getEffectById(in1());

    if (!input1)

        return nullptr;

    auto effect = FEDropShadow::create(filter, stdDeviationX(), stdDeviationY(), dx(), dy(), color, opacity);

    effect->inputEffects() = { input1 };

118 auto effect = FEDropShadow::create(stdDeviationX(), stdDeviationY(), dx(), dy(), color, opacity);

119 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEDropShadowElement.h

@@private:

    void parseAttribute(const QualifiedName&, const AtomString&) override;

    void svgAttributeChanged(const QualifiedName&) override;

56 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

56 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEFloodElement.cpp

@@bool SVGFEFloodElement::setFilterEffectAttribute(FilterEffect* effect, const Qua

    return false;

}

61 RefPtr<FilterEffect> SVGFEFloodElement::build(SVGFilterBuilder*, Filter~~& filter~~) const

61RefPtr<FilterEffect> SVGFEFloodElement::build(SVGFilterBuilder&) const

{

    RenderObject* renderer = this->renderer();

    if (!renderer)

@@RefPtr<FilterEffect> SVGFEFloodElement::build(SVGFilterBuilder*, Filter& filter)

    Color color = renderer->style().colorByApplyingColorFilter(svgStyle.floodColor());

    float opacity = svgStyle.floodOpacity();

72 return FEFlood::create(~~filter,~~ color, opacity);

72 return FEFlood::create(color, opacity);

}

}

Source/WebCore/svg/SVGFEFloodElement.h

@@private:

    const SVGPropertyRegistry& propertyRegistry() const final { return m_propertyRegistry; }

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName) override;

39 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

39 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

};

Source/WebCore/svg/SVGFEGaussianBlurElement.cpp

@@void SVGFEGaussianBlurElement::svgAttributeChanged(const QualifiedName& attrName

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

98 RefPtr<FilterEffect> SVGFEGaussianBlurElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

98RefPtr<FilterEffect> SVGFEGaussianBlurElement::build(SVGFilterBuilder& filterBuilder) const

9999{

100 auto input1 = filterBuilder->getEffectById(in1());

100 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

    if (stdDeviationX() < 0 || stdDeviationY() < 0)

        return nullptr;

107 auto effect = FEGaussianBlur::create(~~filter,~~ stdDeviationX(), stdDeviationY(), edgeMode());

108 effect->inputEffects() = { input1 };

107 auto effect = FEGaussianBlur::create(stdDeviationX(), stdDeviationY(), edgeMode());

108 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEGaussianBlurElement.h

@@private:

    void parseAttribute(const QualifiedName&, const AtomString&) override;

    void svgAttributeChanged(const QualifiedName&) override;

56 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

56 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEImageElement.cpp

@@std::tuple<RefPtr<ImageBuffer>, FloatRect> SVGFEImageElement::imageBufferForEffe

    return { imageBuffer, imageRect };

}

211 RefPtr<FilterEffect> SVGFEImageElement::build(SVGFilterBuilder*, Filter~~& filter~~) const

211RefPtr<FilterEffect> SVGFEImageElement::build(SVGFilterBuilder&) const

212212{

213213 if (m_cachedImage)

214 return FEImage::create(~~filter,~~ Ref<Image> { *m_cachedImage->imageForRenderer(renderer()) }, preserveAspectRatio());

214 return FEImage::create(Ref<Image> { *m_cachedImage->imageForRenderer(renderer()) }, preserveAspectRatio());

    auto [imageBuffer, imageRect] = imageBufferForEffect();

    if (!imageBuffer)

        return nullptr;

220 return FEImage::create(~~filter,~~ imageBuffer.releaseNonNull(), imageRect, preserveAspectRatio());

220 return FEImage::create(imageBuffer.releaseNonNull(), imageRect, preserveAspectRatio());

}

void SVGFEImageElement::addSubresourceAttributeURLs(ListHashSet<URL>& urls) const

Source/WebCore/svg/SVGFEImageElement.h

@@private:

    std::tuple<RefPtr<ImageBuffer>, FloatRect> imageBufferForEffect() const;

60 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

60 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    void clearResourceReferences();

    void requestImageResource();

Source/WebCore/svg/SVGFEMergeElement.cpp

@@Ref<SVGFEMergeElement> SVGFEMergeElement::create(const QualifiedName& tagName, D

    return adoptRef(*new SVGFEMergeElement(tagName, document));

}

48 RefPtr<FilterEffect> SVGFEMergeElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

48RefPtr<FilterEffect> SVGFEMergeElement::build(SVGFilterBuilder& filterBuilder) const

4949{

50 auto effect = FEMerge::create(filter);

51 auto& mergeInputs = effect->inputEffects();

50 FilterEffectVector mergeInputs;

5251

5352 for (auto& mergeNode : childrenOfType<SVGFEMergeNodeElement>(*this)) {

54 auto mergeEffect = filterBuilder->getEffectById(mergeNode.in1());

53 auto mergeEffect = filterBuilder.getEffectById(mergeNode.in1());

        if (!mergeEffect)

            return nullptr;

        mergeInputs.append(WTFMove(mergeEffect));

@@RefPtr<FilterEffect> SVGFEMergeElement::build(SVGFilterBuilder* filterBuilder, F

    if (mergeInputs.isEmpty())

        return nullptr;

64 auto effect = FEMerge::create();

65 effect->inputEffects() = WTFMove(mergeInputs);

    return effect;

}

Source/WebCore/svg/SVGFEMergeElement.h

@@private:

    using PropertyRegistry = SVGPropertyOwnerRegistry<SVGFEMergeElement, SVGFilterPrimitiveStandardAttributes>;

    const SVGPropertyRegistry& propertyRegistry() const final { return m_propertyRegistry; }

38 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

38 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

};

Source/WebCore/svg/SVGFEMorphologyElement.cpp

@@void SVGFEMorphologyElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

117 RefPtr<FilterEffect> SVGFEMorphologyElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

117RefPtr<FilterEffect> SVGFEMorphologyElement::build(SVGFilterBuilder& filterBuilder) const

118118{

    auto input1 = filterBuilder->getEffectById(in1());

    float xRadius = radiusX();

    float yRadius = radiusY();

119 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

123 float xRadius = radiusX();

124 float yRadius = radiusY();

    if (xRadius < 0 || yRadius < 0)

        return nullptr;

129 auto effect = FEMorphology::create(~~filter,~~ svgOperator(), xRadius, yRadius);

130 effect->inputEffects() = { input1 };

128 auto effect = FEMorphology::create(svgOperator(), xRadius, yRadius);

129 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEMorphologyElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

84 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

84 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFEOffsetElement.cpp

@@void SVGFEOffsetElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

84 RefPtr<FilterEffect> SVGFEOffsetElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

84RefPtr<FilterEffect> SVGFEOffsetElement::build(SVGFilterBuilder& filterBuilder) const

8585{

86 auto input1 = filterBuilder->getEffectById(in1());

87

86 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

91 auto effect = FEOffset::create(~~filter,~~ dx(), dy());

92 effect->inputEffects() = { input1 };

90 auto effect = FEOffset::create(dx(), dy());

91 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFEOffsetElement.h

@@private:

    void parseAttribute(const QualifiedName&, const AtomString&) override;

    void svgAttributeChanged(const QualifiedName&) override;

50 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

50 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFESpecularLightingElement.cpp

@@void SVGFESpecularLightingElement::lightElementAttributeChanged(const SVGFELight

    primitiveAttributeChanged(attrName);

}

163 RefPtr<FilterEffect> SVGFESpecularLightingElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

163RefPtr<FilterEffect> SVGFESpecularLightingElement::build(SVGFilterBuilder& filterBuilder) const

164164{

165 auto input1 = filterBuilder->getEffectById(in1());

166

165 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

@@RefPtr<FilterEffect> SVGFESpecularLightingElement::build(SVGFilterBuilder* filte

    if (!lightElement)

        return nullptr;

174 auto lightSource = lightElement->lightSource(*filterBuilder);

173 auto lightSource = lightElement->lightSource(filterBuilder);

    RenderObject* renderer = this->renderer();

    if (!renderer)

@@RefPtr<FilterEffect> SVGFESpecularLightingElement::build(SVGFilterBuilder* filte

    

    Color color = renderer->style().colorByApplyingColorFilter(renderer->style().svgStyle().lightingColor());

182 auto effect = FESpecularLighting::create(~~filter,~~ color, surfaceScale(), specularConstant(), specularExponent(), kernelUnitLengthX(), kernelUnitLengthY(), WTFMove(lightSource));

183 effect->inputEffects() = { input1 };

181 auto effect = FESpecularLighting::create(color, surfaceScale(), specularConstant(), specularExponent(), kernelUnitLengthX(), kernelUnitLengthY(), WTFMove(lightSource));

182 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFESpecularLightingElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&) override;

61 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

61 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFETileElement.cpp

@@void SVGFETileElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

73 RefPtr<FilterEffect> SVGFETileElement::build(SVGFilterBuilder* filterBuilder~~, Filter& filter~~) const

73RefPtr<FilterEffect> SVGFETileElement::build(SVGFilterBuilder& filterBuilder) const

7474{

75 auto input1 = filterBuilder->getEffectById(in1());

76

75 auto input1 = filterBuilder.getEffectById(in1());

    if (!input1)

        return nullptr;

80 auto effect = FETile::create(~~filter~~);

81 effect->inputEffects() = { input1 };

79 auto effect = FETile::create();

80 effect->inputEffects() = { WTFMove(input1) };

    return effect;

}

Source/WebCore/svg/SVGFETileElement.h

@@private:

    void parseAttribute(const QualifiedName&, const AtomString&) override;

    void svgAttributeChanged(const QualifiedName&) override;

45 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

45 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedString> m_in1 { SVGAnimatedString::create(this) };

Source/WebCore/svg/SVGFETurbulenceElement.cpp

@@void SVGFETurbulenceElement::svgAttributeChanged(const QualifiedName& attrName)

    SVGFilterPrimitiveStandardAttributes::svgAttributeChanged(attrName);

}

120 RefPtr<FilterEffect> SVGFETurbulenceElement::build(SVGFilterBuilder*, Filter~~& filter~~) const

120RefPtr<FilterEffect> SVGFETurbulenceElement::build(SVGFilterBuilder&) const

{

    if (baseFrequencyX() < 0 || baseFrequencyY() < 0)

        return nullptr;

124 return FETurbulence::create(~~filter,~~ type(), baseFrequencyX(), baseFrequencyY(), numOctaves(), seed(), stitchTiles() == SVG_STITCHTYPE_STITCH);

124 return FETurbulence::create(type(), baseFrequencyX(), baseFrequencyY(), numOctaves(), seed(), stitchTiles() == SVG_STITCHTYPE_STITCH);

}

}

Source/WebCore/svg/SVGFETurbulenceElement.h

@@private:

    void svgAttributeChanged(const QualifiedName&) override;

    bool setFilterEffectAttribute(FilterEffect*, const QualifiedName& attrName) override;

122 RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const override;

122 RefPtr<FilterEffect> build(SVGFilterBuilder&) const override;

    PropertyRegistry m_propertyRegistry { *this };

    Ref<SVGAnimatedNumber> m_baseFrequencyX { SVGAnimatedNumber::create(this) };

Source/WebCore/svg/SVGFilterPrimitiveStandardAttributes.h

@@class SVGFilterPrimitiveStandardAttributes : public SVGElement {

public:

    void setStandardAttributes(FilterEffect*) const;

41 virtual RefPtr<FilterEffect> build(SVGFilterBuilder*, Filter&) const = 0;

41 virtual RefPtr<FilterEffect> build(SVGFilterBuilder&) const = 0;

    // Returns true, if the new value is different from the old one.

    virtual bool setFilterEffectAttribute(FilterEffect*, const QualifiedName&);

Source/WebCore/svg/graphics/filters/SVGFEImage.cpp

namespace WebCore {

33 Ref<FEImage> FEImage::create(~~Filter& filter,~~ Ref<Image>&& image, const SVGPreserveAspectRatioValue& preserveAspectRatio)

33Ref<FEImage> FEImage::create(Ref<Image>&& image, const SVGPreserveAspectRatioValue& preserveAspectRatio)

3434{

3535 auto imageRect = FloatRect { { }, image->size() };

36 return create(~~filter,~~ WTFMove(image), imageRect, preserveAspectRatio);

36 return create(WTFMove(image), imageRect, preserveAspectRatio);

3737}

3838

39 Ref<FEImage> FEImage::create(~~Filter& filter,~~ SourceImage&& sourceImage, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue& preserveAspectRatio)

39Ref<FEImage> FEImage::create(SourceImage&& sourceImage, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue& preserveAspectRatio)

4040{

41 return adoptRef(*new FEImage(~~filter,~~ WTFMove(sourceImage), sourceImageRect, preserveAspectRatio));

41 return adoptRef(*new FEImage(WTFMove(sourceImage), sourceImageRect, preserveAspectRatio));

4242}

4343

44 FEImage::FEImage(~~Filter& filter,~~ SourceImage&& sourceImage, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue& preserveAspectRatio)

45 : FilterEffect(~~filter,~~ Type::FEImage)

44FEImage::FEImage(SourceImage&& sourceImage, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue& preserveAspectRatio)

45 : FilterEffect(Type::FEImage)

    , m_sourceImage(WTFMove(sourceImage))

    , m_sourceImageRect(sourceImageRect)

    , m_preserveAspectRatio(preserveAspectRatio)

{

}

52 void FEImage::determineAbsolutePaintRect()

52void FEImage::determineAbsolutePaintRect(const Filter& filter)

{

    auto primitiveSubregion = filterPrimitiveSubregion();

@@void FEImage::determineAbsolutePaintRect()

        }

    );

68 imageRect.scale(filter().filterScale());

68 imageRect.scale(filter.filterScale());

    if (clipsToBounds())

        imageRect.intersect(maxEffectRect());

@@void FEImage::determineAbsolutePaintRect()

    setAbsolutePaintRect(enclosingIntRect(imageRect));

}

77 void FEImage::platformApplySoftware()

77void FEImage::platformApplySoftware(const Filter& filter)

{

    // FEImage results are always in DestinationColorSpace::SRGB()

    setResultColorSpace(DestinationColorSpace::SRGB());

@@void FEImage::platformApplySoftware()

            auto imageRect = primitiveSubregion;

            auto srcRect = m_sourceImageRect;

            m_preserveAspectRatio.transformRect(imageRect, srcRect);

94 imageRect.scale(filter().filterScale());

94 imageRect.scale(filter.filterScale());

            imageRect = drawingRegionOfInputImage(IntRect(imageRect));

            context.drawImage(image, imageRect, srcRect);

        },

        [&] (const Ref<ImageBuffer>& imageBuffer) {

            auto imageRect = primitiveSubregion;

            imageRect.moveBy(m_sourceImageRect.location());

101 imageRect.scale(filter().filterScale());

101 imageRect.scale(filter.filterScale());

            imageRect = drawingRegionOfInputImage(IntRect(imageRect));

            context.drawImageBuffer(imageBuffer, imageRect.location());

        }

Source/WebCore/svg/graphics/filters/SVGFEImage.h

@@class FEImage final : public FilterEffect {

public:

    using SourceImage = std::variant<Ref<Image>, Ref<ImageBuffer>>;

38 static Ref<FEImage> create(~~Filter&,~~ Ref<Image>&&, const SVGPreserveAspectRatioValue&);

39 static Ref<FEImage> create(~~Filter&,~~ SourceImage&&, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue&);

38 static Ref<FEImage> create(Ref<Image>&&, const SVGPreserveAspectRatioValue&);

39 static Ref<FEImage> create(SourceImage&&, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue&);

    SourceImage& sourceImage() { return m_sourceImage; }

    void setImageSource(SourceImage&& sourceImage) { m_sourceImage = WTFMove(sourceImage); }

private:

45 FEImage(Filter&, SourceImage&&, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue&);

    FEImage(SourceImage&&, const FloatRect& sourceImageRect, const SVGPreserveAspectRatioValue&);

    void determineAbsolutePaintRect(const Filter&) final;

    void platformApplySoftware(const Filter&) final;

4650

47 void platformApplySoftware() final;

48 void determineAbsolutePaintRect() final;

    WTF::TextStream& externalRepresentation(WTF::TextStream&, RepresentationType) const final;

    SourceImage m_sourceImage;

Source/WebCore/svg/graphics/filters/SVGFilter.cpp

@@RefPtr<SVGFilter> SVGFilter::create(SVGFilterElement& filterElement, SVGFilterBu

    auto filter = adoptRef(*new SVGFilter(filterScale, sourceImageRect, filterRegion, targetBoundingBox, primitiveBoundingBoxMode));

    if (!previousEffect)

48 builder.setupBuiltinEffects(SourceGraphic::create(~~filter~~));

48 builder.setupBuiltinEffects(SourceGraphic::create());

    else

        builder.setupBuiltinEffects({ *previousEffect });

    builder.setTargetBoundingBox(targetBoundingBox);

    builder.setPrimitiveUnits(filterElement.primitiveUnits());

55 auto lastEffect = builder.buildFilterEffects(filter~~, filter~~Element);

55 auto lastEffect = builder.buildFilterEffects(filterElement);

    if (!lastEffect)

        return nullptr;

@@FloatSize SVGFilter::scaledByFilterScale(FloatSize size) const

    return Filter::scaledByFilterScale(size);

}

void SVGFilter::apply()

{

    m_lastEffect->apply(*this);

}

IntOutsets SVGFilter::outsets() const

{

    return m_lastEffect->outsets();

Source/WebCore/svg/graphics/filters/SVGFilter.h

@@public:

    FloatSize scaledByFilterScale(FloatSize) const final;

    FloatRect targetBoundingBox() const { return m_targetBoundingBox; }

42 void apply() override;

    RefPtr<FilterEffect> lastEffect() { return m_lastEffect; }

    void setLastEffect(RefPtr<FilterEffect>&& lastEffect) { m_lastEffect = WTFMove(lastEffect); }

Source/WebCore/svg/graphics/filters/SVGFilterBuilder.cpp

@@static unsigned totalNumberFilterEffects(const FilterEffect& lastEffect)

    return collectEffects(&lastEffect, allEffects);

}

78 RefPtr<FilterEffect> SVGFilterBuilder::buildFilterEffects(~~Filter& filter,~~ SVGFilterElement& filterElement)

78RefPtr<FilterEffect> SVGFilterBuilder::buildFilterEffects(SVGFilterElement& filterElement)

{

    static constexpr unsigned maxCountChildNodes = 200;

    static constexpr unsigned maxTotalNumberFilterEffects = 100;

@@RefPtr<FilterEffect> SVGFilterBuilder::buildFilterEffects(Filter& filter, SVGFil

    RefPtr<FilterEffect> effect;

    for (auto& effectElement : childrenOfType<SVGFilterPrimitiveStandardAttributes>(filterElement)) {

89 effect = effectElement.build(this~~, filter~~);

89 effect = effectElement.build(*this);

        if (!effect) {

            clearEffects();

            return nullptr;

Source/WebCore/svg/graphics/filters/SVGFilterBuilder.h

@@public:

    void clearResultsRecursive(FilterEffect*);

    void setupBuiltinEffects(Ref<FilterEffect> sourceGraphic);

69 RefPtr<FilterEffect> buildFilterEffects(~~Filter&,~~ SVGFilterElement&);

69 RefPtr<FilterEffect> buildFilterEffects(SVGFilterElement&);

private:

    inline void addBuiltinEffects()