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.
22static const int32_t gMaxKernelSize = SK_MaxS32 / sizeof(SkScalar);
23
24SkMatrixConvolutionImageFilter::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
50SkMatrixConvolutionImageFilter* 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
76static 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
88SkMatrixConvolutionImageFilter::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
119SkFlattenable* 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
145void 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
158SkMatrixConvolutionImageFilter::~SkMatrixConvolutionImageFilter() {
159    delete[] fKernel;
160}
161
162class UncheckedPixelFetcher {
163public:
164    static inline SkPMColor fetch(const SkBitmap& src, int x, int y, const SkIRect& bounds) {
165        return *src.getAddr32(x, y);
166    }
167};
168
169class ClampPixelFetcher {
170public:
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
178class RepeatPixelFetcher {
179public:
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
193class ClampToBlackPixelFetcher {
194public:
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
204template<class PixelFetcher, bool convolveAlpha>
205void 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
248template<class PixelFetcher>
249void 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
260void 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
267void 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
287static 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
307bool 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
362bool 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
377static 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
392bool 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