COMMIT_MESSAGE

parallel-filters

Signed-off-by: Zoltan Herczeg <zherczeg@inf.u-szeged.hu>

WebCore/platform/graphics/filters/FELighting.cpp

@@void FELighting::setPixel(int offset, LightingData& data, LightSource::PaintingD

    inlineSetPixel(offset, data, paintingData, lightX, lightY, factorX, factorY, normalVector);

}

inline void FELighting::setInteriorPixels(LightingData& data, LightSource::PaintingData& paintingData, int fromY, int toY)

{

    IntPoint normalVector;

    int offset;

    for (int y = fromY; y < toY; ++y) {

        offset = y * data.widthMultipliedByPixelSize + cPixelSize;

        for (int x = 1; x < data.widthDecreasedByOne; ++x, offset += cPixelSize) {

            data.interior(offset, normalVector);

            inlineSetPixel(offset, data, paintingData, x, y, cFactor1div4, cFactor1div4, normalVector);

        }

    }

}

#ifdef FILTER_THREAD

void* FELighting::paintThread(void* parameter)

{

    PaintThreadData& data = *reinterpret_cast<PaintThreadData*>(parameter);

    data.filter->setInteriorPixels(data.lightingData, data.paintingData, 1, data.endY);

    return 0;

}

#endif

bool FELighting::drawLighting(ByteArray* pixels, int width, int height)

{

    LightSource::PaintingData paintingData;

@@bool FELighting::drawLighting(ByteArray* pixels, int width, int height)

    paintingData.colorVector = FloatPoint3D(m_lightingColor.red(), m_lightingColor.green(), m_lightingColor.blue());

    m_lightSource->initPaintingData(paintingData);

    int startY = 1;

#ifdef FILTER_THREAD

    PaintThreadData paintThreadData(this, data, paintingData);

    if (width >= 3 && height >= 10 && width * height > 4000) {

        startY = (height >> 1) + 3;

        paintThreadData.endY = startY;

        if (!execute(paintThread, &paintThreadData))

            startY = 1;

    }

#endif

    // Top/Left corner

    IntPoint normalVector;

    int offset = 0;

@@bool FELighting::drawLighting(ByteArray* pixels, int width, int height)

        }

    }

    if (width >= 3 && height >= 3) {

        // Interior pixels

        for (int y = 1; y < data.heightDecreasedByOne; ++y) {

            offset = y * data.widthMultipliedByPixelSize + cPixelSize;

            for (int x = 1; x < data.widthDecreasedByOne; ++x, offset += cPixelSize) {

                data.interior(offset, normalVector);

                inlineSetPixel(offset, data, paintingData, x, y, cFactor1div4, cFactor1div4, normalVector);

            }

        }

    }

    if (width >= 3 && height >= 3)

        setInteriorPixels(data, paintingData, startY, data.heightDecreasedByOne);

#ifdef FILTER_THREAD

    if (startY != 1)

        waitForFinish();

#endif

    int lastPixel = data.widthMultipliedByPixelSize * height;

    if (m_lightingType == DiffuseLighting) {

WebCore/platform/graphics/filters/FELighting.h

@@protected:

        inline void bottomRight(int offset, IntPoint& normalVector);

    };

#ifdef FILTER_THREAD

    struct PaintThreadData {

        PaintThreadData(FELighting* filter, LightingData& lightingData, LightSource::PaintingData& paintingData)

            : filter(filter)

            , lightingData(lightingData)

            , paintingData(paintingData)

            , endY(0)

        {

        }

        FELighting* filter;

        LightingData& lightingData;

        // LightSource::PaintingData must be duplicated.

        LightSource::PaintingData paintingData;

        int endY;

    };

#endif

    FELighting(LightingType, const Color&, float, float, float, float, float, float, PassRefPtr<LightSource>);

    bool drawLighting(ByteArray*, int, int);

@@protected:

    LightingType m_lightingType;

    RefPtr<LightSource> m_lightSource;

    inline void setInteriorPixels(LightingData&, LightSource::PaintingData&, int fromY, int toY);

#ifdef FILTER_THREAD

    static void* paintThread(void* parameter);

#endif

    Color m_lightingColor;

    float m_surfaceScale;

    float m_diffuseConstant;

WebCore/platform/graphics/filters/FETurbulence.cpp

#include "FETurbulence.h"

#include "Filter.h"

30 #include "ImageData.h"

#include <wtf/MathExtras.h>

@@void FETurbulence::setStitchTiles(bool stitch)

FETurbulence::PaintingData::PaintingData(long paintingSeed, const IntSize& paintingSize)

    : seed(paintingSeed)

130 , filterSize(paintingSize)

    , width(0)

    , height(0)

    , wrapX(0)

    , wrapY(0)

135 , channel(0)

136 , filterSize(paintingSize)

{

}

@@inline void checkNoise(int& noiseValue, int limitValue, int newValue)

        noiseValue -= newValue - 1;

}

207 float FETurbulence::noise2D(PaintingData& paintingData, const FloatPoint& noiseVector)

205float FETurbulence::noise2D(int channel, PaintingData& paintingData, const FloatPoint& noiseVector)

{

    struct Noise {

        int noisePositionIntegerValue;

@@float FETurbulence::noise2D(PaintingData& paintingData, const FloatPoint& noiseV

    // This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement.

    int temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue];

242 q = paintingData.gradient[~~paintingData.~~channel][temp];

240 q = paintingData.gradient[channel][temp];

243241 u = noiseX.noisePositionFractionValue * q[0] + noiseY.noisePositionFractionValue * q[1];

244242 temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue];

245 q = paintingData.gradient[~~paintingData.~~channel][temp];

243 q = paintingData.gradient[channel][temp];

    v = (noiseX.noisePositionFractionValue - 1) * q[0] + noiseY.noisePositionFractionValue * q[1];

    a = linearInterpolation(sx, u, v);

    temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue + 1];

249 q = paintingData.gradient[~~paintingData.~~channel][temp];

247 q = paintingData.gradient[channel][temp];

250248 u = noiseX.noisePositionFractionValue * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];

251249 temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue + 1];

252 q = paintingData.gradient[~~paintingData.~~channel][temp];

250 q = paintingData.gradient[channel][temp];

    v = (noiseX.noisePositionFractionValue - 1) * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];

    b = linearInterpolation(sx, u, v);

    return linearInterpolation(sy, a, b);

}

258 unsigned char FETurbulence::calculateTurbulenceValueForPoint(PaintingData& paintingData, const FloatPoint& point)

256inline unsigned char FETurbulence::calculateTurbulenceValueForPoint(int channel, PaintingData& paintingData, const FloatPoint& point)

{

    float tileWidth = paintingData.filterSize.width();

    ASSERT(tileWidth > 0);

@@unsigned char FETurbulence::calculateTurbulenceValueForPoint(PaintingData& paint

    float ratio = 1;

    for (int octave = 0; octave < m_numOctaves; ++octave) {

        if (m_type == FETURBULENCE_TYPE_FRACTALNOISE)

296 turbulenceFunctionResult += noise2D(paintingData, noiseVector) / ratio;

294 turbulenceFunctionResult += noise2D(channel, paintingData, noiseVector) / ratio;

297295 else

298 turbulenceFunctionResult += fabsf(noise2D(paintingData, noiseVector)) / ratio;

296 turbulenceFunctionResult += fabsf(noise2D(channel, paintingData, noiseVector)) / ratio;

        noiseVector.setX(noiseVector.x() * 2);

        noiseVector.setY(noiseVector.y() * 2);

        ratio *= 2;

@@unsigned char FETurbulence::calculateTurbulenceValueForPoint(PaintingData& paint

    return static_cast<unsigned char>(turbulenceFunctionResult * 255);

}

inline void FETurbulence::setInteriorPixels(PaintingData& paintingData, ByteArray* pixelArray, int width, int fromY, int toY)

{

    FloatPoint point;

    point.setY(absolutePaintRect().y() + fromY);

    int indexOfPixelChannel = fromY * width * 4;

    for (int y = fromY; y < toY; ++y) {

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

        point.setX(absolutePaintRect().x());

        for (int x = 0; x < width; ++x) {

            point.setX(point.x() + 1);

            for (int channel = 0; channel < 4; ++channel, ++indexOfPixelChannel)

                pixelArray->set(indexOfPixelChannel, calculateTurbulenceValueForPoint(channel, paintingData, point));

        }

    }

}

#ifdef FILTER_THREAD

void* FETurbulence::paintThread(void* parameter)

{

    PaintThreadData& data = *reinterpret_cast<PaintThreadData*>(parameter);

    data.filter->setInteriorPixels(data.paintingData, data.pixelArray, data.width, 0, data.endY);

    return 0;

}

#endif

void FETurbulence::apply(Filter* filter)

{

    if (!effectContext(filter))

@@void FETurbulence::apply(Filter* filter)

    PaintingData paintingData(m_seed, roundedIntSize(filterPrimitiveSubregion().size()));

    initPaint(paintingData);

    FloatRect filterRegion = absolutePaintRect();

    FloatPoint point;

    point.setY(filterRegion.y());

    int indexOfPixelChannel = 0;

    for (int y = 0; y < imageRect.height(); ++y) {

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

        point.setX(filterRegion.x());

        for (int x = 0; x < imageRect.width(); ++x) {

            point.setX(point.x() + 1);

            for (paintingData.channel = 0; paintingData.channel < 4; ++paintingData.channel, ++indexOfPixelChannel)

                pixelArray->set(indexOfPixelChannel, calculateTurbulenceValueForPoint(paintingData, filter->mapAbsolutePointToLocalPoint(point)));

        }

    int startY = 0;

#ifdef FILTER_THREAD

    PaintThreadData paintThreadData(this, pixelArray, paintingData, imageRect.width());

    if (imageRect.height() >= 6 && imageRect.width() * imageRect.height() > 4000) {

        startY = imageRect.height() >> 1;

        paintThreadData.endY = startY;

        if (!execute(paintThread, &paintThreadData))

            startY = 0;

347367 }

#endif

    setInteriorPixels(paintingData, pixelArray, imageRect.width(), startY, imageRect.height());

#ifdef FILTER_THREAD

    if (startY)

        waitForFinish();

#endif

    resultImage()->putUnmultipliedImageData(imageData.get(), imageRect, IntPoint());

}

WebCore/platform/graphics/filters/FETurbulence.h

#if ENABLE(FILTERS)

#include "FilterEffect.h"

#include "Filter.h"

30#include "ImageData.h"

namespace WebCore {

@@private:

        long seed;

        int latticeSelector[2 * s_blockSize + 2];

        float gradient[4][2 * s_blockSize + 2][2];

77 IntSize filterSize;

        int width; // How much to subtract to wrap for stitching.

        int height;

        int wrapX; // Minimum value to wrap.

        int wrapY;

80 int channel;

81 IntSize filterSize;

        PaintingData(long paintingSeed, const IntSize& paintingSize);

        inline long random();

    };

#ifdef FILTER_THREAD

    struct PaintThreadData {

        PaintThreadData(FETurbulence* filter, ByteArray* pixelArray, PaintingData& paintingData, int width)

            : filter(filter)

            , pixelArray(pixelArray)

            , paintingData(paintingData)

            , width(width)

            , endY(0)

        {

        }

        FETurbulence* filter;

        ByteArray* pixelArray;

        PaintingData& paintingData;

        int width;

        int endY;

    };

#endif

    FETurbulence(TurbulanceType, float, float, int, float, bool);

    inline void initPaint(PaintingData&);

90 float noise2D(PaintingData&, const FloatPoint&);

91 unsigned char calculateTurbulenceValueForPoint(PaintingData&, const FloatPoint&);

    float noise2D(int channel, PaintingData&, const FloatPoint&);

    inline unsigned char calculateTurbulenceValueForPoint(int channel, PaintingData&, const FloatPoint&);

    inline void setInteriorPixels(PaintingData&, ByteArray*, int width, int fromY, int toY);

#ifdef FILTER_THREAD

    static void* paintThread(void* parameter);

#endif

    TurbulanceType m_type;

    float m_baseFrequencyX;

WebCore/platform/graphics/filters/FilterEffect.cpp

namespace WebCore {

#ifdef FILTER_THREAD

ThreadIdentifier FilterEffect::s_threadID;

FilterEffect::ThreadShared* FilterEffect::s_threadShared;

bool FilterEffect::s_stopThread;

#endif

FilterEffect::FilterEffect()

    : m_alphaImage(false)

    , m_hasX(false)

@@FilterEffect::FilterEffect()

    , m_hasWidth(false)

    , m_hasHeight(false)

{

#ifdef FILTER_THREAD

    if (!s_threadID) {

        if (!s_threadShared)

            s_threadShared = new ThreadShared;

        s_threadID = createThread(filterThread, 0, "Filter common thread");

    }

#endif

}

FilterEffect::~FilterEffect()

@@TextStream& FilterEffect::externalRepresentation(TextStream& ts, int) const

    return ts;

}

#ifdef FILTER_THREAD

bool FilterEffect::execute(WTF::ThreadFunction function, void* parameter)

{

    if (!s_threadShared)

        return false;

    ASSERT(!s_threadShared->m_start && !s_threadShared->m_finish);

    MutexLocker lock(s_threadShared->m_mutex);

    s_threadShared->m_function = function;

    s_threadShared->m_parameter = parameter;

    s_threadShared->m_start = true;

    s_threadShared->m_cond.signal();

    return true;

}

void FilterEffect::waitForFinish()

{

    ASSERT(s_threadShared);

    while (!s_threadShared->m_finish)

        s_threadShared->m_cond.wait(s_threadShared->m_mutex);

    s_threadShared->m_finish = false;

}

void* FilterEffect::filterThread(void*)

{

    while (!s_stopThread) {

        if (s_threadShared->m_start) {

            s_threadShared->m_function(s_threadShared->m_parameter);

            MutexLocker lock(s_threadShared->m_mutex);

            s_threadShared->m_start = false;

            s_threadShared->m_finish = true;

            s_threadShared->m_cond.signal();

        }

        s_threadShared->m_cond.wait(s_threadShared->m_mutex);

    }

    s_stopThread = false;

    return 0;

}

#endif

} // namespace WebCore

#endif // ENABLE(FILTERS)

WebCore/platform/graphics/filters/FilterEffect.h

#include <wtf/RefCounted.h>

#include <wtf/RefPtr.h>

#include <wtf/Vector.h>

#include <wtf/Threading.h>

#define FILTER_THREAD

namespace WebCore {

@@public:

protected:

    FilterEffect();

#ifdef FILTER_THREAD

    static bool execute(WTF::ThreadFunction, void* parameter);

    static void waitForFinish();

#endif

private:

    OwnPtr<ImageBuffer> m_effectBuffer;

    FilterEffectVector m_inputEffects;

@@private:

    IntRect m_maxEffectRect;

private:

#ifdef FILTER_THREAD

    static void* filterThread(void*);

    class ThreadShared : public FastAllocBase {

    public:

        ThreadShared()

            : m_start(false)

            , m_finish(false)

            , m_function(filterThread) // Dummy function.

        {

        }

        mutable Mutex m_mutex;

        ThreadCondition m_cond;

        bool m_start;

        bool m_finish;

        WTF::ThreadFunction m_function;

        void* m_parameter;

    };

#endif

    // The following member variables are SVG specific and will move to RenderSVGResourceFilterPrimitive.

    // See bug https://bugs.webkit.org/show_bug.cgi?id=45614.

@@private:

    bool m_hasY;

    bool m_hasWidth;

    bool m_hasHeight;

#ifdef FILTER_THREAD

    static ThreadIdentifier s_threadID;

    static ThreadShared* s_threadShared;

    static bool s_stopThread;

#endif

};

} // namespace WebCore