REGRESSION (r226981): ASSERTION FAILED: startY >= 0 && endY <= height && startY ...
[WebKit-https.git] / Source / WebCore / platform / graphics / filters / FEMorphology.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) Research In Motion Limited 2010. All rights reserved.
7  * Copyright (C) Apple Inc. 2017-2018 All rights reserved.
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 #include "FEMorphology.h"
27
28 #include "ColorUtilities.h"
29 #include "Filter.h"
30 #include <runtime/Uint8ClampedArray.h>
31 #include <wtf/ParallelJobs.h>
32 #include <wtf/Vector.h>
33 #include <wtf/text/TextStream.h>
34
35 namespace WebCore {
36
37 FEMorphology::FEMorphology(Filter& filter, MorphologyOperatorType type, float radiusX, float radiusY)
38     : FilterEffect(filter)
39     , m_type(type)
40     , m_radiusX(radiusX)
41     , m_radiusY(radiusY)
42 {
43 }
44
45 Ref<FEMorphology> FEMorphology::create(Filter& filter, MorphologyOperatorType type, float radiusX, float radiusY)
46 {
47     return adoptRef(*new FEMorphology(filter, type, radiusX, radiusY));
48 }
49
50 bool FEMorphology::setMorphologyOperator(MorphologyOperatorType type)
51 {
52     if (m_type == type)
53         return false;
54     m_type = type;
55     return true;
56 }
57
58 bool FEMorphology::setRadiusX(float radiusX)
59 {
60     if (m_radiusX == radiusX)
61         return false;
62     m_radiusX = radiusX;
63     return true;
64 }
65
66 bool FEMorphology::setRadiusY(float radiusY)
67 {
68     if (m_radiusY == radiusY)
69         return false;
70     m_radiusY = radiusY;
71     return true;
72 }
73
74 void FEMorphology::determineAbsolutePaintRect()
75 {
76     FloatRect paintRect = inputEffect(0)->absolutePaintRect();
77     Filter& filter = this->filter();
78     paintRect.inflate(filter.scaledByFilterResolution({ m_radiusX, m_radiusY }));
79     if (clipsToBounds())
80         paintRect.intersect(maxEffectRect());
81     else
82         paintRect.unite(maxEffectRect());
83     setAbsolutePaintRect(enclosingIntRect(paintRect));
84 }
85
86 static inline int pixelArrayIndex(int x, int y, int width)
87 {
88     return (y * width + x) * 4;
89 }
90
91 template<MorphologyOperatorType type>
92 ALWAYS_INLINE ColorComponents minOrMax(const ColorComponents& a, const ColorComponents& b)
93 {
94     if (type == FEMORPHOLOGY_OPERATOR_ERODE)
95         return perComponentMin(a, b);
96
97     return perComponentMax(a, b);
98 }
99
100 template<MorphologyOperatorType type>
101 ALWAYS_INLINE ColorComponents columnExtremum(const Uint8ClampedArray& srcPixelArray, int x, int yStart, int yEnd, int width)
102 {
103     auto extremum = ColorComponents::fromRGBA(*reinterpret_cast<const unsigned*>(srcPixelArray.data() + pixelArrayIndex(x, yStart, width)));
104
105     for (int y = yStart + 1; y < yEnd; ++y) {
106         auto pixel = ColorComponents::fromRGBA(*reinterpret_cast<const unsigned*>(srcPixelArray.data() + pixelArrayIndex(x, y, width)));
107         extremum = minOrMax<type>(extremum, pixel);
108     }
109     return extremum;
110 }
111
112 ALWAYS_INLINE ColorComponents columnExtremum(const Uint8ClampedArray& srcPixelArray, int x, int yStart, int yEnd, int width, MorphologyOperatorType type)
113 {
114     if (type == FEMORPHOLOGY_OPERATOR_ERODE)
115         return columnExtremum<FEMORPHOLOGY_OPERATOR_ERODE>(srcPixelArray, x, yStart, yEnd, width);
116
117     return columnExtremum<FEMORPHOLOGY_OPERATOR_DILATE>(srcPixelArray, x, yStart, yEnd, width);
118 }
119
120 using ColumnExtrema = Vector<ColorComponents, 16>;
121
122 template<MorphologyOperatorType type>
123 ALWAYS_INLINE ColorComponents kernelExtremum(const ColumnExtrema& kernel)
124 {
125     auto extremum = kernel[0];
126     for (size_t i = 1; i < kernel.size(); ++i)
127         extremum = minOrMax<type>(extremum, kernel[i]);
128
129     return extremum;
130 }
131
132 ALWAYS_INLINE ColorComponents kernelExtremum(const ColumnExtrema& kernel, MorphologyOperatorType type)
133 {
134     if (type == FEMORPHOLOGY_OPERATOR_ERODE)
135         return kernelExtremum<FEMORPHOLOGY_OPERATOR_ERODE>(kernel);
136
137     return kernelExtremum<FEMORPHOLOGY_OPERATOR_DILATE>(kernel);
138 }
139
140 void FEMorphology::platformApplyGeneric(const PaintingData& paintingData, int startY, int endY)
141 {
142     ASSERT(endY > startY);
143
144     const auto& srcPixelArray = *paintingData.srcPixelArray;
145     auto& dstPixelArray = *paintingData.dstPixelArray;
146
147     const int radiusX = paintingData.radiusX;
148     const int radiusY = paintingData.radiusY;
149     const int width = paintingData.width;
150     const int height = paintingData.height;
151
152     ASSERT(radiusX <= width || radiusY <= height);
153     ASSERT(startY >= 0 && endY <= height && startY < endY);
154
155     ColumnExtrema extrema;
156     extrema.reserveInitialCapacity(2 * radiusX + 1);
157
158     for (int y = startY; y < endY; ++y) {
159         int yRadiusStart = std::max(0, y - radiusY);
160         int yRadiusEnd = std::min(height, y + radiusY + 1);
161
162         extrema.shrink(0);
163
164         // We start at the left edge, so compute extreme for the radiusX columns.
165         for (int x = 0; x < radiusX; ++x)
166             extrema.append(columnExtremum(srcPixelArray, x, yRadiusStart, yRadiusEnd, width, m_type));
167
168         // Kernel is filled, get extrema of next column
169         for (int x = 0; x < width; ++x) {
170             if (x < width - radiusX)
171                 extrema.append(columnExtremum(srcPixelArray, x + radiusX, yRadiusStart, yRadiusEnd, width, m_type));
172
173             if (x > radiusX)
174                 extrema.remove(0);
175
176             unsigned* destPixel = reinterpret_cast<unsigned*>(dstPixelArray.data() + pixelArrayIndex(x, y, width));
177             *destPixel = kernelExtremum(extrema, m_type).toRGBA();
178         }
179     }
180 }
181
182 void FEMorphology::platformApplyWorker(PlatformApplyParameters* param)
183 {
184     param->filter->platformApplyGeneric(*param->paintingData, param->startY, param->endY);
185 }
186
187 void FEMorphology::platformApply(const PaintingData& paintingData)
188 {
189     // Empirically, runtime is approximately linear over reasonable kernel sizes with a slope of about 0.65.
190     float kernelFactor = sqrt(paintingData.radiusX * paintingData.radiusY) * 0.65;
191
192     static const int minimalArea = (160 * 160); // Empirical data limit for parallel jobs
193     
194     unsigned maxNumThreads = paintingData.height / 8;
195     unsigned optimalThreadNumber = std::min<unsigned>((paintingData.width * paintingData.height * kernelFactor) / minimalArea, maxNumThreads);
196     if (optimalThreadNumber > 1) {
197         WTF::ParallelJobs<PlatformApplyParameters> parallelJobs(&WebCore::FEMorphology::platformApplyWorker, optimalThreadNumber);
198         auto numOfThreads = parallelJobs.numberOfJobs();
199         if (numOfThreads > 1) {
200             // Split the job into "jobSize"-sized jobs but there a few jobs that need to be slightly larger since
201             // jobSize * jobs < total size. These extras are handled by the remainder "jobsWithExtra".
202             int jobSize = paintingData.height / numOfThreads;
203             int jobsWithExtra = paintingData.height % numOfThreads;
204             int currentY = 0;
205             for (int job = numOfThreads - 1; job >= 0; --job) {
206                 PlatformApplyParameters& param = parallelJobs.parameter(job);
207                 param.filter = this;
208                 param.startY = currentY;
209                 currentY += job < jobsWithExtra ? jobSize + 1 : jobSize;
210                 param.endY = currentY;
211                 param.paintingData = &paintingData;
212             }
213             parallelJobs.execute();
214             return;
215         }
216         // Fallback to single thread model
217     }
218
219     platformApplyGeneric(paintingData, 0, paintingData.height);
220 }
221
222 bool FEMorphology::platformApplyDegenerate(Uint8ClampedArray& dstPixelArray, const IntRect& imageRect, int radiusX, int radiusY)
223 {
224     // Input radius is less than zero or an overflow happens when scaling it.
225     if (radiusX < 0 || radiusY < 0) {
226         dstPixelArray.zeroFill();
227         return true;
228     }
229
230     // FIXME: this should allow erode/dilate on one axis. webkit.org/b/181903.
231     // Also if both x radiusX and radiusY are zero, the result should be transparent black.
232     if (!radiusX || !radiusY) {
233         FilterEffect* in = inputEffect(0);
234         in->copyPremultipliedResult(dstPixelArray, imageRect);
235         return true;
236     }
237
238     return false;
239 }
240
241 void FEMorphology::platformApplySoftware()
242 {
243     FilterEffect* in = inputEffect(0);
244
245     Uint8ClampedArray* dstPixelArray = createPremultipliedImageResult();
246     if (!dstPixelArray)
247         return;
248
249     setIsAlphaImage(in->isAlphaImage());
250
251     IntRect effectDrawingRect = requestedRegionOfInputImageData(in->absolutePaintRect());
252
253     IntSize radius = flooredIntSize(FloatSize(m_radiusX, m_radiusY));
254     if (platformApplyDegenerate(*dstPixelArray, effectDrawingRect, radius.width(), radius.height()))
255         return;
256
257     Filter& filter = this->filter();
258     auto srcPixelArray = in->premultipliedResult(effectDrawingRect);
259     if (!srcPixelArray)
260         return;
261
262     radius = flooredIntSize(filter.scaledByFilterResolution({ m_radiusX, m_radiusY }));
263     int radiusX = std::min(effectDrawingRect.width() - 1, radius.width());
264     int radiusY = std::min(effectDrawingRect.height() - 1, radius.height());
265
266     if (platformApplyDegenerate(*dstPixelArray, effectDrawingRect, radiusX, radiusY))
267         return;
268     
269     PaintingData paintingData;
270     paintingData.srcPixelArray = srcPixelArray.get();
271     paintingData.dstPixelArray = dstPixelArray;
272     paintingData.width = ceilf(effectDrawingRect.width() * filter.filterScale());
273     paintingData.height = ceilf(effectDrawingRect.height() * filter.filterScale());
274     paintingData.radiusX = ceilf(radiusX * filter.filterScale());
275     paintingData.radiusY = ceilf(radiusY * filter.filterScale());
276
277     platformApply(paintingData);
278 }
279
280 static TextStream& operator<<(TextStream& ts, const MorphologyOperatorType& type)
281 {
282     switch (type) {
283     case FEMORPHOLOGY_OPERATOR_UNKNOWN:
284         ts << "UNKNOWN";
285         break;
286     case FEMORPHOLOGY_OPERATOR_ERODE:
287         ts << "ERODE";
288         break;
289     case FEMORPHOLOGY_OPERATOR_DILATE:
290         ts << "DILATE";
291         break;
292     }
293     return ts;
294 }
295
296 TextStream& FEMorphology::externalRepresentation(TextStream& ts, RepresentationType representation) const
297 {
298     ts << indent << "[feMorphology";
299     FilterEffect::externalRepresentation(ts, representation);
300     ts << " operator=\"" << morphologyOperator() << "\" "
301        << "radius=\"" << radiusX() << ", " << radiusY() << "\"]\n";
302
303     TextStream::IndentScope indentScope(ts);
304     inputEffect(0)->externalRepresentation(ts, representation);
305     return ts;
306 }
307
308 } // namespace WebCore