Unreviewed, rolling out r100913.
[WebKit-https.git] / Source / WebCore / platform / graphics / filters / FETurbulence.cpp
1 /*
2  * Copyright (C) 2004, 2005, 2006, 2007 Nikolas Zimmermann <zimmermann@kde.org>
3  * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
4  * Copyright (C) 2005 Eric Seidel <eric@webkit.org>
5  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
6  * Copyright (C) 2010 Renata Hodovan <reni@inf.u-szeged.hu>
7  * Copyright (C) 2011 Gabor Loki <loki@webkit.org>
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26
27 #if ENABLE(FILTERS)
28 #include "FETurbulence.h"
29
30 #include "Filter.h"
31 #include "RenderTreeAsText.h"
32 #include "TextStream.h"
33
34 #include <wtf/ByteArray.h>
35 #include <wtf/MathExtras.h>
36 #include <wtf/ParallelJobs.h>
37
38 namespace WebCore {
39
40 /*
41     Produces results in the range [1, 2**31 - 2]. Algorithm is:
42     r = (a * r) mod m where a = randAmplitude = 16807 and
43     m = randMaximum = 2**31 - 1 = 2147483647, r = seed.
44     See [Park & Miller], CACM vol. 31 no. 10 p. 1195, Oct. 1988
45     To test: the algorithm should produce the result 1043618065
46     as the 10,000th generated number if the original seed is 1.
47 */
48 static const int s_perlinNoise = 4096;
49 static const long s_randMaximum = 2147483647; // 2**31 - 1
50 static const int s_randAmplitude = 16807; // 7**5; primitive root of m
51 static const int s_randQ = 127773; // m / a
52 static const int s_randR = 2836; // m % a
53
54 FETurbulence::FETurbulence(Filter* filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
55     : FilterEffect(filter)
56     , m_type(type)
57     , m_baseFrequencyX(baseFrequencyX)
58     , m_baseFrequencyY(baseFrequencyY)
59     , m_numOctaves(numOctaves)
60     , m_seed(seed)
61     , m_stitchTiles(stitchTiles)
62 {
63 }
64
65 PassRefPtr<FETurbulence> FETurbulence::create(Filter* filter, TurbulenceType type, float baseFrequencyX, float baseFrequencyY, int numOctaves, float seed, bool stitchTiles)
66 {
67     return adoptRef(new FETurbulence(filter, type, baseFrequencyX, baseFrequencyY, numOctaves, seed, stitchTiles));
68 }
69
70 TurbulenceType FETurbulence::type() const
71 {
72     return m_type;
73 }
74
75 bool FETurbulence::setType(TurbulenceType type)
76 {
77     if (m_type == type)
78         return false;
79     m_type = type;
80     return true;
81 }
82
83 float FETurbulence::baseFrequencyY() const
84 {
85     return m_baseFrequencyY;
86 }
87
88 bool FETurbulence::setBaseFrequencyY(float baseFrequencyY)
89 {
90     if (m_baseFrequencyY == baseFrequencyY)
91         return false;
92     m_baseFrequencyY = baseFrequencyY;
93     return true;
94 }
95
96 float FETurbulence::baseFrequencyX() const
97 {
98     return m_baseFrequencyX;
99 }
100
101 bool FETurbulence::setBaseFrequencyX(float baseFrequencyX)
102 {
103     if (m_baseFrequencyX == baseFrequencyX)
104         return false;
105     m_baseFrequencyX = baseFrequencyX;
106     return true;
107 }
108
109 float FETurbulence::seed() const
110 {
111     return m_seed; 
112 }
113
114 bool FETurbulence::setSeed(float seed)
115 {
116     if (m_seed == seed)
117         return false;
118     m_seed = seed;
119     return true;
120 }
121
122 int FETurbulence::numOctaves() const
123 {
124     return m_numOctaves;
125 }
126
127 bool FETurbulence::setNumOctaves(int numOctaves)
128 {
129     if (m_numOctaves == numOctaves)
130         return false;
131     m_numOctaves = numOctaves;
132     return true;
133 }
134
135 bool FETurbulence::stitchTiles() const
136 {
137     return m_stitchTiles;
138 }
139
140 bool FETurbulence::setStitchTiles(bool stitch)
141 {
142     if (m_stitchTiles == stitch)
143         return false;
144     m_stitchTiles = stitch;
145     return true;
146 }
147
148 // The turbulence calculation code is an adapted version of what appears in the SVG 1.1 specification:
149 // http://www.w3.org/TR/SVG11/filters.html#feTurbulence
150
151 FETurbulence::PaintingData::PaintingData(long paintingSeed, const IntSize& paintingSize)
152     : seed(paintingSeed)
153     , width(0)
154     , height(0)
155     , wrapX(0)
156     , wrapY(0)
157     , filterSize(paintingSize)
158 {
159 }
160
161 // Compute pseudo random number.
162 inline long FETurbulence::PaintingData::random()
163 {
164     long result = s_randAmplitude * (seed % s_randQ) - s_randR * (seed / s_randQ);
165     if (result <= 0)
166         result += s_randMaximum;
167     seed = result;
168     return result;
169 }
170
171 inline float smoothCurve(float t)
172 {
173     return t * t * (3 - 2 * t);
174 }
175
176 inline float linearInterpolation(float t, float a, float b)
177 {
178     return a + t * (b - a);
179 }
180
181 inline void FETurbulence::initPaint(PaintingData& paintingData)
182 {
183     float normalizationFactor;
184
185     // The seed value clamp to the range [1, s_randMaximum - 1].
186     if (paintingData.seed <= 0)
187         paintingData.seed = -(paintingData.seed % (s_randMaximum - 1)) + 1;
188     if (paintingData.seed > s_randMaximum - 1)
189         paintingData.seed = s_randMaximum - 1;
190
191     float* gradient;
192     for (int channel = 0; channel < 4; ++channel) {
193         for (int i = 0; i < s_blockSize; ++i) {
194             paintingData.latticeSelector[i] = i;
195             gradient = paintingData.gradient[channel][i];
196             gradient[0] = static_cast<float>((paintingData.random() % (2 * s_blockSize)) - s_blockSize) / s_blockSize;
197             gradient[1] = static_cast<float>((paintingData.random() % (2 * s_blockSize)) - s_blockSize) / s_blockSize;
198             normalizationFactor = sqrtf(gradient[0] * gradient[0] + gradient[1] * gradient[1]);
199             gradient[0] /= normalizationFactor;
200             gradient[1] /= normalizationFactor;
201         }
202     }
203     for (int i = s_blockSize - 1; i > 0; --i) {
204         int k = paintingData.latticeSelector[i];
205         int j = paintingData.random() % s_blockSize;
206         ASSERT(j >= 0);
207         ASSERT(j < 2 * s_blockSize + 2);
208         paintingData.latticeSelector[i] = paintingData.latticeSelector[j];
209         paintingData.latticeSelector[j] = k;
210     }
211     for (int i = 0; i < s_blockSize + 2; ++i) {
212         paintingData.latticeSelector[s_blockSize + i] = paintingData.latticeSelector[i];
213         for (int channel = 0; channel < 4; ++channel) {
214             paintingData.gradient[channel][s_blockSize + i][0] = paintingData.gradient[channel][i][0];
215             paintingData.gradient[channel][s_blockSize + i][1] = paintingData.gradient[channel][i][1];
216         }
217     }
218 }
219
220 inline void checkNoise(int& noiseValue, int limitValue, int newValue)
221 {
222     if (noiseValue >= limitValue)
223         noiseValue -= newValue;
224     if (noiseValue >= limitValue - 1)
225         noiseValue -= newValue - 1;
226 }
227
228 float FETurbulence::noise2D(int channel, PaintingData& paintingData, const FloatPoint& noiseVector)
229 {
230     struct Noise {
231         int noisePositionIntegerValue;
232         float noisePositionFractionValue;
233
234         Noise(float component)
235         {
236             float position = component + s_perlinNoise;
237             noisePositionIntegerValue = static_cast<int>(position);
238             noisePositionFractionValue = position - noisePositionIntegerValue;
239         }
240     };
241
242     Noise noiseX(noiseVector.x());
243     Noise noiseY(noiseVector.y());
244     float* q;
245     float sx, sy, a, b, u, v;
246
247     // If stitching, adjust lattice points accordingly.
248     if (m_stitchTiles) {
249         checkNoise(noiseX.noisePositionIntegerValue, paintingData.wrapX, paintingData.width);
250         checkNoise(noiseY.noisePositionIntegerValue, paintingData.wrapY, paintingData.height);
251     }
252
253     noiseX.noisePositionIntegerValue &= s_blockMask;
254     noiseY.noisePositionIntegerValue &= s_blockMask;
255     int latticeIndex = paintingData.latticeSelector[noiseX.noisePositionIntegerValue];
256     int nextLatticeIndex = paintingData.latticeSelector[(noiseX.noisePositionIntegerValue + 1) & s_blockMask];
257
258     sx = smoothCurve(noiseX.noisePositionFractionValue);
259     sy = smoothCurve(noiseY.noisePositionFractionValue);
260
261     // This is taken 1:1 from SVG spec: http://www.w3.org/TR/SVG11/filters.html#feTurbulenceElement.
262     int temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue];
263     q = paintingData.gradient[channel][temp];
264     u = noiseX.noisePositionFractionValue * q[0] + noiseY.noisePositionFractionValue * q[1];
265     temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue];
266     q = paintingData.gradient[channel][temp];
267     v = (noiseX.noisePositionFractionValue - 1) * q[0] + noiseY.noisePositionFractionValue * q[1];
268     a = linearInterpolation(sx, u, v);
269     temp = paintingData.latticeSelector[latticeIndex + noiseY.noisePositionIntegerValue + 1];
270     q = paintingData.gradient[channel][temp];
271     u = noiseX.noisePositionFractionValue * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];
272     temp = paintingData.latticeSelector[nextLatticeIndex + noiseY.noisePositionIntegerValue + 1];
273     q = paintingData.gradient[channel][temp];
274     v = (noiseX.noisePositionFractionValue - 1) * q[0] + (noiseY.noisePositionFractionValue - 1) * q[1];
275     b = linearInterpolation(sx, u, v);
276     return linearInterpolation(sy, a, b);
277 }
278
279 unsigned char FETurbulence::calculateTurbulenceValueForPoint(int channel, PaintingData& paintingData, const FloatPoint& point)
280 {
281     float tileWidth = paintingData.filterSize.width();
282     ASSERT(tileWidth > 0);
283     float tileHeight = paintingData.filterSize.height();
284     ASSERT(tileHeight > 0);
285     // Adjust the base frequencies if necessary for stitching.
286     if (m_stitchTiles) {
287         // When stitching tiled turbulence, the frequencies must be adjusted
288         // so that the tile borders will be continuous.
289         if (m_baseFrequencyX) {
290             float lowFrequency = floorf(tileWidth * m_baseFrequencyX) / tileWidth;
291             float highFrequency = ceilf(tileWidth * m_baseFrequencyX) / tileWidth;
292             // BaseFrequency should be non-negative according to the standard.
293             if (m_baseFrequencyX / lowFrequency < highFrequency / m_baseFrequencyX)
294                 m_baseFrequencyX = lowFrequency;
295             else
296                 m_baseFrequencyX = highFrequency;
297         }
298         if (m_baseFrequencyY) {
299             float lowFrequency = floorf(tileHeight * m_baseFrequencyY) / tileHeight;
300             float highFrequency = ceilf(tileHeight * m_baseFrequencyY) / tileHeight;
301             if (m_baseFrequencyY / lowFrequency < highFrequency / m_baseFrequencyY)
302                 m_baseFrequencyY = lowFrequency;
303             else
304                 m_baseFrequencyY = highFrequency;
305         }
306         // Set up TurbulenceInitial stitch values.
307         paintingData.width = roundf(tileWidth * m_baseFrequencyX);
308         paintingData.wrapX = s_perlinNoise + paintingData.width;
309         paintingData.height = roundf(tileHeight * m_baseFrequencyY);
310         paintingData.wrapY = s_perlinNoise + paintingData.height;
311     }
312     float turbulenceFunctionResult = 0;
313     FloatPoint noiseVector(point.x() * m_baseFrequencyX, point.y() * m_baseFrequencyY);
314     float ratio = 1;
315     for (int octave = 0; octave < m_numOctaves; ++octave) {
316         if (m_type == FETURBULENCE_TYPE_FRACTALNOISE)
317             turbulenceFunctionResult += noise2D(channel, paintingData, noiseVector) / ratio;
318         else
319             turbulenceFunctionResult += fabsf(noise2D(channel, paintingData, noiseVector)) / ratio;
320         noiseVector.setX(noiseVector.x() * 2);
321         noiseVector.setY(noiseVector.y() * 2);
322         ratio *= 2;
323         if (m_stitchTiles) {
324             // Update stitch values. Subtracting s_perlinNoiseoise before the multiplication and
325             // adding it afterward simplifies to subtracting it once.
326             paintingData.width *= 2;
327             paintingData.wrapX = 2 * paintingData.wrapX - s_perlinNoise;
328             paintingData.height *= 2;
329             paintingData.wrapY = 2 * paintingData.wrapY - s_perlinNoise;
330         }
331     }
332
333     // The value of turbulenceFunctionResult comes from ((turbulenceFunctionResult * 255) + 255) / 2 by fractalNoise
334     // and (turbulenceFunctionResult * 255) by turbulence.
335     if (m_type == FETURBULENCE_TYPE_FRACTALNOISE)
336         turbulenceFunctionResult = turbulenceFunctionResult * 0.5f + 0.5f;
337     // Clamp result
338     turbulenceFunctionResult = std::max(std::min(turbulenceFunctionResult, 1.f), 0.f);
339     return static_cast<unsigned char>(turbulenceFunctionResult * 255);
340 }
341
342 inline void FETurbulence::fillRegion(ByteArray* pixelArray, PaintingData& paintingData, int startY, int endY)
343 {
344     IntRect filterRegion = absolutePaintRect();
345     IntPoint point(0, filterRegion.y() + startY);
346     int indexOfPixelChannel = startY * (filterRegion.width() << 2);
347     int channel;
348
349     for (int y = startY; y < endY; ++y) {
350         point.setY(point.y() + 1);
351         point.setX(filterRegion.x());
352         for (int x = 0; x < filterRegion.width(); ++x) {
353             point.setX(point.x() + 1);
354             for (channel = 0; channel < 4; ++channel, ++indexOfPixelChannel)
355                 pixelArray->set(indexOfPixelChannel, calculateTurbulenceValueForPoint(channel, paintingData, filter()->mapAbsolutePointToLocalPoint(point)));
356         }
357     }
358 }
359
360 #if ENABLE(PARALLEL_JOBS)
361 void FETurbulence::fillRegionWorker(FillRegionParameters* parameters)
362 {
363     parameters->filter->fillRegion(parameters->pixelArray, *parameters->paintingData, parameters->startY, parameters->endY);
364 }
365 #endif // ENABLE(PARALLEL_JOBS)
366
367 void FETurbulence::platformApplySoftware()
368 {
369     ByteArray* pixelArray = createUnmultipliedImageResult();
370     if (!pixelArray)
371         return;
372
373     if (absolutePaintRect().isEmpty()) {
374         pixelArray->clear();
375         return;
376     }
377
378     PaintingData paintingData(m_seed, roundedIntSize(filterPrimitiveSubregion().size()));
379     initPaint(paintingData);
380
381 #if ENABLE(PARALLEL_JOBS)
382
383     int optimalThreadNumber = (absolutePaintRect().width() * absolutePaintRect().height()) / s_minimalRectDimension;
384     if (optimalThreadNumber > 1) {
385         // Initialize parallel jobs
386         ParallelJobs<FillRegionParameters> parallelJobs(&WebCore::FETurbulence::fillRegionWorker, optimalThreadNumber);
387
388         // Fill the parameter array
389         int i = parallelJobs.numberOfJobs();
390         if (i > 1) {
391             int startY = 0;
392             int stepY = absolutePaintRect().height() / i;
393             for (; i > 0; --i) {
394                 FillRegionParameters& params = parallelJobs.parameter(i-1);
395                 params.filter = this;
396                 params.pixelArray = pixelArray;
397                 params.paintingData = &paintingData;
398                 params.startY = startY;
399                 if (i != 1) {
400                     params.endY = startY + stepY;
401                     startY = startY + stepY;
402                 } else
403                     params.endY = absolutePaintRect().height();
404             }
405
406             // Execute parallel jobs
407             parallelJobs.execute();
408
409             return;
410         }
411     }
412     // Fallback to sequential mode if there is no room for a new thread or the paint area is too small
413
414 #endif // ENABLE(PARALLEL_JOBS)
415
416     fillRegion(pixelArray, paintingData, 0, absolutePaintRect().height());
417 }
418
419 void FETurbulence::dump()
420 {
421 }
422
423 static TextStream& operator<<(TextStream& ts, const TurbulenceType& type)
424 {
425     switch (type) {
426     case FETURBULENCE_TYPE_UNKNOWN:
427         ts << "UNKNOWN";
428         break;
429     case FETURBULENCE_TYPE_TURBULENCE:
430         ts << "TURBULANCE";
431         break;
432     case FETURBULENCE_TYPE_FRACTALNOISE:
433         ts << "NOISE";
434         break;
435     }
436     return ts;
437 }
438
439 TextStream& FETurbulence::externalRepresentation(TextStream& ts, int indent) const
440 {
441     writeIndent(ts, indent);
442     ts << "[feTurbulence";
443     FilterEffect::externalRepresentation(ts);
444     ts << " type=\"" << type() << "\" "
445        << "baseFrequency=\"" << baseFrequencyX() << ", " << baseFrequencyY() << "\" "
446        << "seed=\"" << seed() << "\" "
447        << "numOctaves=\"" << numOctaves() << "\" "
448        << "stitchTiles=\"" << stitchTiles() << "\"]\n";
449     return ts;
450 }
451
452 } // namespace WebCore
453
454 #endif // ENABLE(FILTERS)