1 /*
2 * Copyright 2012 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "SkMatrixConvolutionImageFilter.h"
9 #include "SkBitmap.h"
10 #include "SkColorPriv.h"
11 #include "SkReadBuffer.h"
12 #include "SkWriteBuffer.h"
13 #include "SkRect.h"
14 #include "SkUnPreMultiply.h"
15
16 #if SK_SUPPORT_GPU
17 #include "effects/GrMatrixConvolutionEffect.h"
18 #endif
19
20 // We need to be able to read at most SK_MaxS32 bytes, so divide that
21 // by the size of a scalar to know how many scalars we can read.
22 static const int32_t gMaxKernelSize = SK_MaxS32 / sizeof(SkScalar);
23
SkMatrixConvolutionImageFilter(const SkISize & kernelSize,const SkScalar * kernel,SkScalar gain,SkScalar bias,const SkIPoint & kernelOffset,TileMode tileMode,bool convolveAlpha,SkImageFilter * input,const CropRect * cropRect,uint32_t uniqueID)24 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(
25 const SkISize& kernelSize,
26 const SkScalar* kernel,
27 SkScalar gain,
28 SkScalar bias,
29 const SkIPoint& kernelOffset,
30 TileMode tileMode,
31 bool convolveAlpha,
32 SkImageFilter* input,
33 const CropRect* cropRect,
34 uint32_t uniqueID)
35 : INHERITED(1, &input, cropRect, uniqueID),
36 fKernelSize(kernelSize),
37 fGain(gain),
38 fBias(bias),
39 fKernelOffset(kernelOffset),
40 fTileMode(tileMode),
41 fConvolveAlpha(convolveAlpha) {
42 size_t size = (size_t) sk_64_mul(fKernelSize.width(), fKernelSize.height());
43 fKernel = SkNEW_ARRAY(SkScalar, size);
44 memcpy(fKernel, kernel, size * sizeof(SkScalar));
45 SkASSERT(kernelSize.fWidth >= 1 && kernelSize.fHeight >= 1);
46 SkASSERT(kernelOffset.fX >= 0 && kernelOffset.fX < kernelSize.fWidth);
47 SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight);
48 }
49
Create(const SkISize & kernelSize,const SkScalar * kernel,SkScalar gain,SkScalar bias,const SkIPoint & kernelOffset,TileMode tileMode,bool convolveAlpha,SkImageFilter * input,const CropRect * cropRect,uint32_t uniqueID)50 SkMatrixConvolutionImageFilter* SkMatrixConvolutionImageFilter::Create(
51 const SkISize& kernelSize,
52 const SkScalar* kernel,
53 SkScalar gain,
54 SkScalar bias,
55 const SkIPoint& kernelOffset,
56 TileMode tileMode,
57 bool convolveAlpha,
58 SkImageFilter* input,
59 const CropRect* cropRect,
60 uint32_t uniqueID) {
61 if (kernelSize.width() < 1 || kernelSize.height() < 1) {
62 return NULL;
63 }
64 if (gMaxKernelSize / kernelSize.fWidth < kernelSize.fHeight) {
65 return NULL;
66 }
67 if (!kernel) {
68 return NULL;
69 }
70 return SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize, kernel, gain, bias,
71 kernelOffset, tileMode, convolveAlpha,
72 input, cropRect, uniqueID));
73 }
74
75 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING
tile_mode_is_valid(SkMatrixConvolutionImageFilter::TileMode tileMode)76 static bool tile_mode_is_valid(SkMatrixConvolutionImageFilter::TileMode tileMode) {
77 switch (tileMode) {
78 case SkMatrixConvolutionImageFilter::kClamp_TileMode:
79 case SkMatrixConvolutionImageFilter::kRepeat_TileMode:
80 case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode:
81 return true;
82 default:
83 break;
84 }
85 return false;
86 }
87
SkMatrixConvolutionImageFilter(SkReadBuffer & buffer)88 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buffer)
89 : INHERITED(1, buffer) {
90 fKernelSize.fWidth = buffer.readInt();
91 fKernelSize.fHeight = buffer.readInt();
92 if ((fKernelSize.fWidth >= 1) && (fKernelSize.fHeight >= 1) &&
93 // Make sure size won't be larger than a signed int,
94 // which would still be extremely large for a kernel,
95 // but we don't impose a hard limit for kernel size
96 (gMaxKernelSize / fKernelSize.fWidth >= fKernelSize.fHeight)) {
97 size_t size = fKernelSize.fWidth * fKernelSize.fHeight;
98 fKernel = SkNEW_ARRAY(SkScalar, size);
99 SkDEBUGCODE(bool success =) buffer.readScalarArray(fKernel, size);
100 SkASSERT(success);
101 } else {
102 fKernel = 0;
103 }
104 fGain = buffer.readScalar();
105 fBias = buffer.readScalar();
106 fKernelOffset.fX = buffer.readInt();
107 fKernelOffset.fY = buffer.readInt();
108 fTileMode = (TileMode) buffer.readInt();
109 fConvolveAlpha = buffer.readBool();
110 buffer.validate((fKernel != 0) &&
111 SkScalarIsFinite(fGain) &&
112 SkScalarIsFinite(fBias) &&
113 tile_mode_is_valid(fTileMode) &&
114 (fKernelOffset.fX >= 0) && (fKernelOffset.fX < fKernelSize.fWidth) &&
115 (fKernelOffset.fY >= 0) && (fKernelOffset.fY < fKernelSize.fHeight));
116 }
117 #endif
118
CreateProc(SkReadBuffer & buffer)119 SkFlattenable* SkMatrixConvolutionImageFilter::CreateProc(SkReadBuffer& buffer) {
120 SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
121 SkISize kernelSize;
122 kernelSize.fWidth = buffer.readInt();
123 kernelSize.fHeight = buffer.readInt();
124 const int count = buffer.getArrayCount();
125
126 const int64_t kernelArea = sk_64_mul(kernelSize.width(), kernelSize.height());
127 if (!buffer.validate(kernelArea == count)) {
128 return NULL;
129 }
130 SkAutoSTArray<16, SkScalar> kernel(count);
131 if (!buffer.readScalarArray(kernel.get(), count)) {
132 return NULL;
133 }
134 SkScalar gain = buffer.readScalar();
135 SkScalar bias = buffer.readScalar();
136 SkIPoint kernelOffset;
137 kernelOffset.fX = buffer.readInt();
138 kernelOffset.fY = buffer.readInt();
139 TileMode tileMode = (TileMode)buffer.readInt();
140 bool convolveAlpha = buffer.readBool();
141 return Create(kernelSize, kernel.get(), gain, bias, kernelOffset, tileMode, convolveAlpha,
142 common.getInput(0), &common.cropRect(), common.uniqueID());
143 }
144
flatten(SkWriteBuffer & buffer) const145 void SkMatrixConvolutionImageFilter::flatten(SkWriteBuffer& buffer) const {
146 this->INHERITED::flatten(buffer);
147 buffer.writeInt(fKernelSize.fWidth);
148 buffer.writeInt(fKernelSize.fHeight);
149 buffer.writeScalarArray(fKernel, fKernelSize.fWidth * fKernelSize.fHeight);
150 buffer.writeScalar(fGain);
151 buffer.writeScalar(fBias);
152 buffer.writeInt(fKernelOffset.fX);
153 buffer.writeInt(fKernelOffset.fY);
154 buffer.writeInt((int) fTileMode);
155 buffer.writeBool(fConvolveAlpha);
156 }
157
~SkMatrixConvolutionImageFilter()158 SkMatrixConvolutionImageFilter::~SkMatrixConvolutionImageFilter() {
159 delete[] fKernel;
160 }
161
162 class UncheckedPixelFetcher {
163 public:
fetch(const SkBitmap & src,int x,int y,const SkIRect & bounds)164 static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
165 return *src.getAddr32(x, y);
166 }
167 };
168
169 class ClampPixelFetcher {
170 public:
fetch(const SkBitmap & src,int x,int y,const SkIRect & bounds)171 static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
172 x = SkPin32(x, bounds.fLeft, bounds.fRight - 1);
173 y = SkPin32(y, bounds.fTop, bounds.fBottom - 1);
174 return *src.getAddr32(x, y);
175 }
176 };
177
178 class RepeatPixelFetcher {
179 public:
fetch(const SkBitmap & src,int x,int y,const SkIRect & bounds)180 static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
181 x = (x - bounds.left()) % bounds.width() + bounds.left();
182 y = (y - bounds.top()) % bounds.height() + bounds.top();
183 if (x < bounds.left()) {
184 x += bounds.width();
185 }
186 if (y < bounds.top()) {
187 y += bounds.height();
188 }
189 return *src.getAddr32(x, y);
190 }
191 };
192
193 class ClampToBlackPixelFetcher {
194 public:
fetch(const SkBitmap & src,int x,int y,const SkIRect & bounds)195 static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
196 if (x < bounds.fLeft || x >= bounds.fRight || y < bounds.fTop || y >= bounds.fBottom) {
197 return 0;
198 } else {
199 return *src.getAddr32(x, y);
200 }
201 }
202 };
203
204 template<class PixelFetcher, bool convolveAlpha>
filterPixels(const SkBitmap & src,SkBitmap * result,const SkIRect & r,const SkIRect & bounds) const205 void SkMatrixConvolutionImageFilter::filterPixels(const SkBitmap& src,
206 SkBitmap* result,
207 const SkIRect& r,
208 const SkIRect& bounds) const {
209 SkIRect rect(r);
210 if (!rect.intersect(bounds)) {
211 return;
212 }
213 for (int y = rect.fTop; y < rect.fBottom; ++y) {
214 SkPMColor* dptr = result->getAddr32(rect.fLeft - bounds.fLeft, y - bounds.fTop);
215 for (int x = rect.fLeft; x < rect.fRight; ++x) {
216 SkScalar sumA = 0, sumR = 0, sumG = 0, sumB = 0;
217 for (int cy = 0; cy < fKernelSize.fHeight; cy++) {
218 for (int cx = 0; cx < fKernelSize.fWidth; cx++) {
219 SkPMColor s = PixelFetcher::fetch(src,
220 x + cx - fKernelOffset.fX,
221 y + cy - fKernelOffset.fY,
222 bounds);
223 SkScalar k = fKernel[cy * fKernelSize.fWidth + cx];
224 if (convolveAlpha) {
225 sumA += SkScalarMul(SkIntToScalar(SkGetPackedA32(s)), k);
226 }
227 sumR += SkScalarMul(SkIntToScalar(SkGetPackedR32(s)), k);
228 sumG += SkScalarMul(SkIntToScalar(SkGetPackedG32(s)), k);
229 sumB += SkScalarMul(SkIntToScalar(SkGetPackedB32(s)), k);
230 }
231 }
232 int a = convolveAlpha
233 ? SkClampMax(SkScalarFloorToInt(SkScalarMul(sumA, fGain) + fBias), 255)
234 : 255;
235 int r = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumR, fGain) + fBias), a);
236 int g = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumG, fGain) + fBias), a);
237 int b = SkClampMax(SkScalarFloorToInt(SkScalarMul(sumB, fGain) + fBias), a);
238 if (!convolveAlpha) {
239 a = SkGetPackedA32(PixelFetcher::fetch(src, x, y, bounds));
240 *dptr++ = SkPreMultiplyARGB(a, r, g, b);
241 } else {
242 *dptr++ = SkPackARGB32(a, r, g, b);
243 }
244 }
245 }
246 }
247
248 template<class PixelFetcher>
filterPixels(const SkBitmap & src,SkBitmap * result,const SkIRect & rect,const SkIRect & bounds) const249 void SkMatrixConvolutionImageFilter::filterPixels(const SkBitmap& src,
250 SkBitmap* result,
251 const SkIRect& rect,
252 const SkIRect& bounds) const {
253 if (fConvolveAlpha) {
254 filterPixels<PixelFetcher, true>(src, result, rect, bounds);
255 } else {
256 filterPixels<PixelFetcher, false>(src, result, rect, bounds);
257 }
258 }
259
filterInteriorPixels(const SkBitmap & src,SkBitmap * result,const SkIRect & rect,const SkIRect & bounds) const260 void SkMatrixConvolutionImageFilter::filterInteriorPixels(const SkBitmap& src,
261 SkBitmap* result,
262 const SkIRect& rect,
263 const SkIRect& bounds) const {
264 filterPixels<UncheckedPixelFetcher>(src, result, rect, bounds);
265 }
266
filterBorderPixels(const SkBitmap & src,SkBitmap * result,const SkIRect & rect,const SkIRect & bounds) const267 void SkMatrixConvolutionImageFilter::filterBorderPixels(const SkBitmap& src,
268 SkBitmap* result,
269 const SkIRect& rect,
270 const SkIRect& bounds) const {
271 switch (fTileMode) {
272 case kClamp_TileMode:
273 filterPixels<ClampPixelFetcher>(src, result, rect, bounds);
274 break;
275 case kRepeat_TileMode:
276 filterPixels<RepeatPixelFetcher>(src, result, rect, bounds);
277 break;
278 case kClampToBlack_TileMode:
279 filterPixels<ClampToBlackPixelFetcher>(src, result, rect, bounds);
280 break;
281 }
282 }
283
284 // FIXME: This should be refactored to SkImageFilterUtils for
285 // use by other filters. For now, we assume the input is always
286 // premultiplied and unpremultiply it
unpremultiplyBitmap(const SkBitmap & src)287 static SkBitmap unpremultiplyBitmap(const SkBitmap& src)
288 {
289 SkAutoLockPixels alp(src);
290 if (!src.getPixels()) {
291 return SkBitmap();
292 }
293 SkBitmap result;
294 if (!result.tryAllocPixels(src.info())) {
295 return SkBitmap();
296 }
297 for (int y = 0; y < src.height(); ++y) {
298 const uint32_t* srcRow = src.getAddr32(0, y);
299 uint32_t* dstRow = result.getAddr32(0, y);
300 for (int x = 0; x < src.width(); ++x) {
301 dstRow[x] = SkUnPreMultiply::PMColorToColor(srcRow[x]);
302 }
303 }
304 return result;
305 }
306
onFilterImage(Proxy * proxy,const SkBitmap & source,const Context & ctx,SkBitmap * result,SkIPoint * offset) const307 bool SkMatrixConvolutionImageFilter::onFilterImage(Proxy* proxy,
308 const SkBitmap& source,
309 const Context& ctx,
310 SkBitmap* result,
311 SkIPoint* offset) const {
312 SkBitmap src = source;
313 SkIPoint srcOffset = SkIPoint::Make(0, 0);
314 if (getInput(0) && !getInput(0)->filterImage(proxy, source, ctx, &src, &srcOffset)) {
315 return false;
316 }
317
318 if (src.colorType() != kN32_SkColorType) {
319 return false;
320 }
321
322 SkIRect bounds;
323 if (!this->applyCropRect(ctx, proxy, src, &srcOffset, &bounds, &src)) {
324 return false;
325 }
326
327 if (!fConvolveAlpha && !src.isOpaque()) {
328 src = unpremultiplyBitmap(src);
329 }
330
331 SkAutoLockPixels alp(src);
332 if (!src.getPixels()) {
333 return false;
334 }
335
336 if (!result->tryAllocPixels(src.info().makeWH(bounds.width(), bounds.height()))) {
337 return false;
338 }
339
340 offset->fX = bounds.fLeft;
341 offset->fY = bounds.fTop;
342 bounds.offset(-srcOffset);
343 SkIRect interior = SkIRect::MakeXYWH(bounds.left() + fKernelOffset.fX,
344 bounds.top() + fKernelOffset.fY,
345 bounds.width() - fKernelSize.fWidth + 1,
346 bounds.height() - fKernelSize.fHeight + 1);
347 SkIRect top = SkIRect::MakeLTRB(bounds.left(), bounds.top(), bounds.right(), interior.top());
348 SkIRect bottom = SkIRect::MakeLTRB(bounds.left(), interior.bottom(),
349 bounds.right(), bounds.bottom());
350 SkIRect left = SkIRect::MakeLTRB(bounds.left(), interior.top(),
351 interior.left(), interior.bottom());
352 SkIRect right = SkIRect::MakeLTRB(interior.right(), interior.top(),
353 bounds.right(), interior.bottom());
354 filterBorderPixels(src, result, top, bounds);
355 filterBorderPixels(src, result, left, bounds);
356 filterInteriorPixels(src, result, interior, bounds);
357 filterBorderPixels(src, result, right, bounds);
358 filterBorderPixels(src, result, bottom, bounds);
359 return true;
360 }
361
onFilterBounds(const SkIRect & src,const SkMatrix & ctm,SkIRect * dst) const362 bool SkMatrixConvolutionImageFilter::onFilterBounds(const SkIRect& src, const SkMatrix& ctm,
363 SkIRect* dst) const {
364 SkIRect bounds = src;
365 bounds.fRight += fKernelSize.width() - 1;
366 bounds.fBottom += fKernelSize.height() - 1;
367 bounds.offset(-fKernelOffset);
368 if (getInput(0) && !getInput(0)->filterBounds(bounds, ctm, &bounds)) {
369 return false;
370 }
371 *dst = bounds;
372 return true;
373 }
374
375 #if SK_SUPPORT_GPU
376
convert_tilemodes(SkMatrixConvolutionImageFilter::TileMode tileMode)377 static GrTextureDomain::Mode convert_tilemodes(
378 SkMatrixConvolutionImageFilter::TileMode tileMode) {
379 switch (tileMode) {
380 case SkMatrixConvolutionImageFilter::kClamp_TileMode:
381 return GrTextureDomain::kClamp_Mode;
382 case SkMatrixConvolutionImageFilter::kRepeat_TileMode:
383 return GrTextureDomain::kRepeat_Mode;
384 case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode:
385 return GrTextureDomain::kDecal_Mode;
386 default:
387 SkASSERT(false);
388 }
389 return GrTextureDomain::kIgnore_Mode;
390 }
391
asFragmentProcessor(GrFragmentProcessor ** fp,GrTexture * texture,const SkMatrix &,const SkIRect & bounds) const392 bool SkMatrixConvolutionImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
393 GrTexture* texture,
394 const SkMatrix&,
395 const SkIRect& bounds) const {
396 if (!fp) {
397 return fKernelSize.width() * fKernelSize.height() <= MAX_KERNEL_SIZE;
398 }
399 SkASSERT(fKernelSize.width() * fKernelSize.height() <= MAX_KERNEL_SIZE);
400 *fp = GrMatrixConvolutionEffect::Create(texture,
401 bounds,
402 fKernelSize,
403 fKernel,
404 fGain,
405 fBias,
406 fKernelOffset,
407 convert_tilemodes(fTileMode),
408 fConvolveAlpha);
409 return true;
410 }
411 #endif
412