ImageFilterTest.cpp revision d5424a425bc21280afe2161f6ac1e5d9eb97e6b2 
1/*
2 * Copyright 2013 Google Inc.
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 "SkBicubicImageFilter.h"
9#include "SkBitmap.h"
10#include "SkBitmapDevice.h"
11#include "SkBitmapSource.h"
12#include "SkBlurImageFilter.h"
13#include "SkCanvas.h"
14#include "SkColorFilterImageFilter.h"
15#include "SkColorMatrixFilter.h"
16#include "SkDeviceImageFilterProxy.h"
17#include "SkDisplacementMapEffect.h"
18#include "SkDropShadowImageFilter.h"
19#include "SkFlattenableBuffers.h"
20#include "SkLightingImageFilter.h"
21#include "SkMatrixConvolutionImageFilter.h"
22#include "SkMatrixImageFilter.h"
23#include "SkMergeImageFilter.h"
24#include "SkMorphologyImageFilter.h"
25#include "SkOffsetImageFilter.h"
26#include "SkPicture.h"
27#include "SkRect.h"
28#include "SkTileImageFilter.h"
29#include "SkXfermodeImageFilter.h"
30#include "Test.h"
31
32#if SK_SUPPORT_GPU
33#include "GrContextFactory.h"
34#include "SkGpuDevice.h"
35#endif
36
37static const int kBitmapSize = 4;
38
39namespace {
40
41class MatrixTestImageFilter : public SkImageFilter {
42public:
43    MatrixTestImageFilter(skiatest::Reporter* reporter, const SkMatrix& expectedMatrix)
44      : SkImageFilter(0), fReporter(reporter), fExpectedMatrix(expectedMatrix) {
45    }
46
47    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context& ctx,
48                               SkBitmap* result, SkIPoint* offset) const SK_OVERRIDE {
49        REPORTER_ASSERT(fReporter, ctx.ctm() == fExpectedMatrix);
50        return true;
51    }
52
53    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(MatrixTestImageFilter)
54
55protected:
56    explicit MatrixTestImageFilter(SkReadBuffer& buffer) : SkImageFilter(0) {
57        fReporter = static_cast<skiatest::Reporter*>(buffer.readFunctionPtr());
58        buffer.readMatrix(&fExpectedMatrix);
59    }
60
61    virtual void flatten(SkWriteBuffer& buffer) const SK_OVERRIDE {
62        buffer.writeFunctionPtr(fReporter);
63        buffer.writeMatrix(fExpectedMatrix);
64    }
65
66private:
67    skiatest::Reporter* fReporter;
68    SkMatrix fExpectedMatrix;
69};
70
71}
72
73static void make_small_bitmap(SkBitmap& bitmap) {
74    bitmap.allocN32Pixels(kBitmapSize, kBitmapSize);
75    SkCanvas canvas(bitmap);
76    canvas.clear(0x00000000);
77    SkPaint darkPaint;
78    darkPaint.setColor(0xFF804020);
79    SkPaint lightPaint;
80    lightPaint.setColor(0xFF244484);
81    const int i = kBitmapSize / 4;
82    for (int y = 0; y < kBitmapSize; y += i) {
83        for (int x = 0; x < kBitmapSize; x += i) {
84            canvas.save();
85            canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
86            canvas.drawRect(SkRect::MakeXYWH(0, 0,
87                                             SkIntToScalar(i),
88                                             SkIntToScalar(i)), darkPaint);
89            canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
90                                             0,
91                                             SkIntToScalar(i),
92                                             SkIntToScalar(i)), lightPaint);
93            canvas.drawRect(SkRect::MakeXYWH(0,
94                                             SkIntToScalar(i),
95                                             SkIntToScalar(i),
96                                             SkIntToScalar(i)), lightPaint);
97            canvas.drawRect(SkRect::MakeXYWH(SkIntToScalar(i),
98                                             SkIntToScalar(i),
99                                             SkIntToScalar(i),
100                                             SkIntToScalar(i)), darkPaint);
101            canvas.restore();
102        }
103    }
104}
105
106static SkImageFilter* make_scale(float amount, SkImageFilter* input = NULL) {
107    SkScalar s = amount;
108    SkScalar matrix[20] = { s, 0, 0, 0, 0,
109                            0, s, 0, 0, 0,
110                            0, 0, s, 0, 0,
111                            0, 0, 0, s, 0 };
112    SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
113    return SkColorFilterImageFilter::Create(filter, input);
114}
115
116static SkImageFilter* make_grayscale(SkImageFilter* input = NULL, const SkImageFilter::CropRect* cropRect = NULL) {
117    SkScalar matrix[20];
118    memset(matrix, 0, 20 * sizeof(SkScalar));
119    matrix[0] = matrix[5] = matrix[10] = 0.2126f;
120    matrix[1] = matrix[6] = matrix[11] = 0.7152f;
121    matrix[2] = matrix[7] = matrix[12] = 0.0722f;
122    matrix[18] = 1.0f;
123    SkAutoTUnref<SkColorFilter> filter(SkColorMatrixFilter::Create(matrix));
124    return SkColorFilterImageFilter::Create(filter, input, cropRect);
125}
126
127DEF_TEST(ImageFilter, reporter) {
128    {
129        // Check that two non-clipping color matrices concatenate into a single filter.
130        SkAutoTUnref<SkImageFilter> halfBrightness(make_scale(0.5f));
131        SkAutoTUnref<SkImageFilter> quarterBrightness(make_scale(0.5f, halfBrightness));
132        REPORTER_ASSERT(reporter, NULL == quarterBrightness->getInput(0));
133    }
134
135    {
136        // Check that a clipping color matrix followed by a grayscale does not concatenate into a single filter.
137        SkAutoTUnref<SkImageFilter> doubleBrightness(make_scale(2.0f));
138        SkAutoTUnref<SkImageFilter> halfBrightness(make_scale(0.5f, doubleBrightness));
139        REPORTER_ASSERT(reporter, NULL != halfBrightness->getInput(0));
140    }
141
142    {
143        // Check that a color filter image filter without a crop rect can be
144        // expressed as a color filter.
145        SkAutoTUnref<SkImageFilter> gray(make_grayscale());
146        REPORTER_ASSERT(reporter, true == gray->asColorFilter(NULL));
147    }
148
149    {
150        // Check that a color filter image filter with a crop rect cannot
151        // be expressed as a color filter.
152        SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(0, 0, 100, 100));
153        SkAutoTUnref<SkImageFilter> grayWithCrop(make_grayscale(NULL, &cropRect));
154        REPORTER_ASSERT(reporter, false == grayWithCrop->asColorFilter(NULL));
155    }
156
157    {
158        // Tests pass by not asserting
159        SkBitmap bitmap, result;
160        make_small_bitmap(bitmap);
161        result.allocN32Pixels(kBitmapSize, kBitmapSize);
162
163        {
164            // This tests for :
165            // 1 ) location at (0,0,1)
166            SkPoint3 location(0, 0, SK_Scalar1);
167            // 2 ) location and target at same value
168            SkPoint3 target(location.fX, location.fY, location.fZ);
169            // 3 ) large negative specular exponent value
170            SkScalar specularExponent = -1000;
171
172            SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
173            SkPaint paint;
174            paint.setImageFilter(SkLightingImageFilter::CreateSpotLitSpecular(
175                    location, target, specularExponent, 180,
176                    0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1,
177                    bmSrc))->unref();
178            SkCanvas canvas(result);
179            SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize),
180                                      SkIntToScalar(kBitmapSize));
181            canvas.drawRect(r, paint);
182        }
183
184        {
185            // This tests for scale bringing width to 0
186            SkSize scale = SkSize::Make(-0.001f, SK_Scalar1);
187            SkAutoTUnref<SkImageFilter> bmSrc(SkBitmapSource::Create(bitmap));
188            SkAutoTUnref<SkBicubicImageFilter> bicubic(
189                SkBicubicImageFilter::CreateMitchell(scale, bmSrc));
190            SkBitmapDevice device(bitmap);
191            SkDeviceImageFilterProxy proxy(&device);
192            SkIPoint loc = SkIPoint::Make(0, 0);
193            // An empty input should early return and return false
194            SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeEmpty());
195            REPORTER_ASSERT(reporter,
196                            !bicubic->filterImage(&proxy, bitmap, ctx, &result, &loc));
197        }
198    }
199}
200
201static void test_crop_rects(SkBaseDevice* device, skiatest::Reporter* reporter) {
202    // Check that all filters offset to their absolute crop rect,
203    // unaffected by the input crop rect.
204    // Tests pass by not asserting.
205    SkBitmap bitmap;
206    bitmap.allocN32Pixels(100, 100);
207    bitmap.eraseARGB(0, 0, 0, 0);
208    SkDeviceImageFilterProxy proxy(device);
209
210    SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80));
211    SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60));
212    SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect));
213
214    SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED, SkXfermode::kSrcIn_Mode));
215    SkPoint3 location(0, 0, SK_Scalar1);
216    SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1);
217    SkScalar kernel[9] = {
218        SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
219        SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
220        SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
221    };
222    SkISize kernelSize = SkISize::Make(3, 3);
223    SkScalar gain = SK_Scalar1, bias = 0;
224
225    SkImageFilter* filters[] = {
226        SkColorFilterImageFilter::Create(cf.get(), input.get(), &cropRect),
227        SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
228                                        SkDisplacementMapEffect::kB_ChannelSelectorType,
229                                        40.0f, input.get(), input.get(), &cropRect),
230        SkBlurImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
231        SkDropShadowImageFilter::Create(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_ColorGREEN, input.get(), &cropRect),
232        SkLightingImageFilter::CreatePointLitDiffuse(location, SK_ColorGREEN, 0, 0, input.get(), &cropRect),
233        SkLightingImageFilter::CreatePointLitSpecular(location, SK_ColorGREEN, 0, 0, 0, input.get(), &cropRect),
234        SkMatrixConvolutionImageFilter::Create(kernelSize, kernel, gain, bias, SkIPoint::Make(1, 1), SkMatrixConvolutionImageFilter::kRepeat_TileMode, false, input.get(), &cropRect),
235        SkMergeImageFilter::Create(input.get(), input.get(), SkXfermode::kSrcOver_Mode, &cropRect),
236        SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
237        SkOffsetImageFilter::Create(SK_Scalar1, SK_Scalar1, input.get(), &cropRect),
238        SkDilateImageFilter::Create(3, 2, input.get(), &cropRect),
239        SkErodeImageFilter::Create(2, 3, input.get(), &cropRect),
240        SkTileImageFilter::Create(inputCropRect.rect(), cropRect.rect(), input.get()),
241        SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mode), input.get(), input.get(), &cropRect),
242    };
243
244    for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
245        SkImageFilter* filter = filters[i];
246        SkBitmap result;
247        SkIPoint offset;
248        SkString str;
249        str.printf("filter %d", static_cast<int>(i));
250        SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest());
251        REPORTER_ASSERT_MESSAGE(reporter, filter->filterImage(&proxy, bitmap, ctx, &result, &offset), str.c_str());
252        REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, str.c_str());
253    }
254
255    for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
256        SkSafeUnref(filters[i]);
257    }
258}
259
260DEF_TEST(ImageFilterCropRect, reporter) {
261    SkBitmap temp;
262    temp.allocN32Pixels(100, 100);
263    SkBitmapDevice device(temp);
264    test_crop_rects(&device, reporter);
265}
266
267DEF_TEST(ImageFilterMatrixTest, reporter) {
268    SkBitmap temp;
269    temp.allocN32Pixels(100, 100);
270    SkBitmapDevice device(temp);
271    SkCanvas canvas(&device);
272    canvas.scale(SkIntToScalar(2), SkIntToScalar(2));
273
274    SkMatrix expectedMatrix = canvas.getTotalMatrix();
275
276    SkPicture picture;
277    SkCanvas* recordingCanvas = picture.beginRecording(100, 100,
278        SkPicture::kOptimizeForClippedPlayback_RecordingFlag);
279
280    SkPaint paint;
281    SkAutoTUnref<MatrixTestImageFilter> imageFilter(
282        new MatrixTestImageFilter(reporter, expectedMatrix));
283    paint.setImageFilter(imageFilter.get());
284    SkCanvas::SaveFlags saveFlags = static_cast<SkCanvas::SaveFlags>(
285        SkCanvas::kHasAlphaLayer_SaveFlag | SkCanvas::kFullColorLayer_SaveFlag);
286    recordingCanvas->saveLayer(NULL, &paint, saveFlags);
287    SkPaint solidPaint;
288    solidPaint.setColor(0xFFFFFFFF);
289    recordingCanvas->save();
290    recordingCanvas->scale(SkIntToScalar(10), SkIntToScalar(10));
291    recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(100, 100)), solidPaint);
292    recordingCanvas->restore(); // scale
293    recordingCanvas->restore(); // saveLayer
294    picture.endRecording();
295
296    canvas.drawPicture(picture);
297}
298
299static void test_huge_blur(SkBaseDevice* device, skiatest::Reporter* reporter) {
300    SkCanvas canvas(device);
301
302    SkBitmap bitmap;
303    bitmap.allocN32Pixels(100, 100);
304    bitmap.eraseARGB(0, 0, 0, 0);
305
306    // Check that a blur with an insane radius does not crash or assert.
307    SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<30), SkIntToScalar(1<<30)));
308
309    SkPaint paint;
310    paint.setImageFilter(blur);
311    canvas.drawSprite(bitmap, 0, 0, &paint);
312}
313
314DEF_TEST(HugeBlurImageFilter, reporter) {
315    SkBitmap temp;
316    temp.allocN32Pixels(100, 100);
317    SkBitmapDevice device(temp);
318    test_huge_blur(&device, reporter);
319}
320
321static void test_xfermode_cropped_input(SkBaseDevice* device, skiatest::Reporter* reporter) {
322    SkCanvas canvas(device);
323    canvas.clear(0);
324
325    SkBitmap bitmap;
326    bitmap.allocN32Pixels(1, 1);
327    bitmap.eraseARGB(255, 255, 255, 255);
328
329    SkAutoTUnref<SkColorFilter> green(
330        SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode));
331    SkAutoTUnref<SkColorFilterImageFilter> greenFilter(
332        SkColorFilterImageFilter::Create(green.get()));
333    SkImageFilter::CropRect cropRect(SkRect::MakeEmpty());
334    SkAutoTUnref<SkColorFilterImageFilter> croppedOut(
335        SkColorFilterImageFilter::Create(green.get(), NULL, &cropRect));
336
337    // Check that an xfermode image filter whose input has been cropped out still draws the other
338    // input. Also check that drawing with both inputs cropped out doesn't cause a GPU warning.
339    SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrcOver_Mode);
340    SkAutoTUnref<SkImageFilter> xfermodeNoFg(
341        SkXfermodeImageFilter::Create(mode, greenFilter, croppedOut));
342    SkAutoTUnref<SkImageFilter> xfermodeNoBg(
343        SkXfermodeImageFilter::Create(mode, croppedOut, greenFilter));
344    SkAutoTUnref<SkImageFilter> xfermodeNoFgNoBg(
345        SkXfermodeImageFilter::Create(mode, croppedOut, croppedOut));
346
347    SkPaint paint;
348    paint.setImageFilter(xfermodeNoFg);
349    canvas.drawSprite(bitmap, 0, 0, &paint);
350
351    uint32_t pixel;
352    SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
353    canvas.readPixels(info, &pixel, 4, 0, 0);
354    REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
355
356    paint.setImageFilter(xfermodeNoBg);
357    canvas.drawSprite(bitmap, 0, 0, &paint);
358    canvas.readPixels(info, &pixel, 4, 0, 0);
359    REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
360
361    paint.setImageFilter(xfermodeNoFgNoBg);
362    canvas.drawSprite(bitmap, 0, 0, &paint);
363    canvas.readPixels(info, &pixel, 4, 0, 0);
364    REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
365}
366
367DEF_TEST(ImageFilterNestedSaveLayer, reporter) {
368    SkBitmap temp;
369    temp.allocN32Pixels(50, 50);
370    SkBitmapDevice device(temp);
371    SkCanvas canvas(&device);
372    canvas.clear(0x0);
373
374    SkBitmap bitmap;
375    bitmap.allocN32Pixels(10, 10);
376    bitmap.eraseColor(SK_ColorGREEN);
377
378    SkMatrix matrix;
379    matrix.setScale(SkIntToScalar(2), SkIntToScalar(2));
380    matrix.postTranslate(SkIntToScalar(-20), SkIntToScalar(-20));
381    SkAutoTUnref<SkImageFilter> matrixFilter(
382        SkMatrixImageFilter::Create(matrix, SkPaint::kLow_FilterLevel));
383
384    // Test that saveLayer() with a filter nested inside another saveLayer() applies the
385    // correct offset to the filter matrix.
386    SkRect bounds1 = SkRect::MakeXYWH(10, 10, 30, 30);
387    canvas.saveLayer(&bounds1, NULL);
388    SkPaint filterPaint;
389    filterPaint.setImageFilter(matrixFilter);
390    SkRect bounds2 = SkRect::MakeXYWH(20, 20, 10, 10);
391    canvas.saveLayer(&bounds2, &filterPaint);
392    SkPaint greenPaint;
393    greenPaint.setColor(SK_ColorGREEN);
394    canvas.drawRect(bounds2, greenPaint);
395    canvas.restore();
396    canvas.restore();
397    SkPaint strokePaint;
398    strokePaint.setStyle(SkPaint::kStroke_Style);
399    strokePaint.setColor(SK_ColorRED);
400
401    SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
402    uint32_t pixel;
403    canvas.readPixels(info, &pixel, 4, 25, 25);
404    REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
405
406    // Test that drawSprite() with a filter nested inside a saveLayer() applies the
407    // correct offset to the filter matrix.
408    canvas.clear(0x0);
409    canvas.readPixels(info, &pixel, 4, 25, 25);
410    canvas.saveLayer(&bounds1, NULL);
411    canvas.drawSprite(bitmap, 20, 20, &filterPaint);
412    canvas.restore();
413
414    canvas.readPixels(info, &pixel, 4, 25, 25);
415    REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN);
416}
417
418DEF_TEST(XfermodeImageFilterCroppedInput, reporter) {
419    SkBitmap temp;
420    temp.allocN32Pixels(100, 100);
421    SkBitmapDevice device(temp);
422    test_xfermode_cropped_input(&device, reporter);
423}
424
425#if SK_SUPPORT_GPU
426DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) {
427    GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
428    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
429                                                         SkImageInfo::MakeN32Premul(100, 100),
430                                                         0));
431    test_crop_rects(device, reporter);
432}
433
434DEF_GPUTEST(HugeBlurImageFilterGPU, reporter, factory) {
435    GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
436    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
437                                                         SkImageInfo::MakeN32Premul(100, 100),
438                                                         0));
439    test_huge_blur(device, reporter);
440}
441
442DEF_GPUTEST(XfermodeImageFilterCroppedInputGPU, reporter, factory) {
443    GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(0));
444    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
445                                                         SkImageInfo::MakeN32Premul(1, 1),
446                                                         0));
447    test_xfermode_cropped_input(device, reporter);
448}
449#endif
450